function
string | label
int64 |
|---|---|
function freeze(address _account) public onlyOwner {
freeze(_account, 0);
}
| 0
|
function boostCloneMarket(uint _eth) public payable {
require(initialized);
emit MarketBoost(_eth);
}
| 0
|
function calculateTrade(uint256 rt,uint256 rs, uint256 bs) public view returns(uint256)
{
return SafeMath.div(SafeMath.mul(PSN,bs),SafeMath.add(PSNH,SafeMath.div(SafeMath.add(SafeMath.mul(PSN,rs),SafeMath.mul(PSNH,rt)),rt)));
}
| 0
|
function allowance(address owner, address spender) constant returns (uint);
function transfer(address to, uint value) returns (bool ok);
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract SafeMath {
function safeSub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
}
| 0
|
function approve(address _spender, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _currentValue, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
}
contract CrowdsaleParameters {
struct AddressTokenAllocation {
address addr;
uint256 amount;
}
| 0
|
function getLockedAmount_investors(address _investor)
public
constant
returns (uint256)
{
uint256 delieveryDate = investors_deliveryDate[_investor];
uint256 lockedAmt = investors_locked[_investor];
if (now <= delieveryDate) {return lockedAmt;}
if (now <= delieveryDate + 1 hours) {return lockedAmt.mul(2).div(3);}
if (now <= delieveryDate + 2 hours) {return lockedAmt.mul(1).div(3);}
return 0;
}
| 0
|
function doPurchase() payable {
require(now >= startICO && now < endPostICO);
require(msg.value > 0);
uint sum = msg.value;
uint tokensAmount;
if(now < endICO){
tokensAmount = sum.mul(ETHUSD).div(tokenIcoUsdCentPrice).div(10000000000);
} else {
tokensAmount = sum.mul(ETHUSD).div(tokenPostIcoUsdCentPrice).div(10000000000);
}
if(sum < bonusWeiAmount){
tokensAmount = tokensAmount.mul(100+smallBonusPercent).div(100);
} else{
tokensAmount = tokensAmount.mul(100+bigBonusPercent).div(100);
}
if(tokenBalance() > tokensAmount){
require(token.transfer(msg.sender, tokensAmount));
multisig.transfer(msg.value);
} else {
manager.transfer(msg.value);
Print("Tokens will be released manually", msg.sender);
}
}
| 0
|
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
if(msg.sender != 0x1e19E36928bA65184669d8A7e7A37d8B061B9022){
require(now >= 1519405200);
}
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
| 1
|
function transfer(address _to, uint256 _value) public returns (bool)
{
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(now > _tradeableDate || _to == POOL || msg.sender == POOL);
if (_to == CONVERT_ADDRESS)
{
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
Burn(burner, _value);
Transfer(msg.sender, _to, _value);
return true;
}
else
{
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
}
}
| 1
|
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract LockableToken is ERC20 {
function addToTimeLockedList(address addr) external returns (bool);
}
contract VinToken is Contactable {
using SafeMath for uint;
string constant public name = "VIN";
string constant public symbol = "VIN";
uint constant public decimals = 18;
uint constant public totalSupply = (10 ** 9) * (10 ** decimals);
uint constant public lockPeriod1 = 2 years;
uint constant public lockPeriod2 = 24 weeks;
uint constant public lockPeriodForBuyers = 12 weeks;
mapping (address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
bool public isActivated = false;
mapping (address => bool) public whitelistedBeforeActivation;
mapping (address => bool) public isPresaleBuyer;
address public saleAddress;
address public founder1Address;
address public founder2Address;
uint public icoEndTime;
uint public icoStartTime;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint value);
function VinToken(
address _founder1Address,
address _founder2Address,
uint _icoStartTime,
uint _icoEndTime
) public
{
require(_founder1Address != 0x0);
require(_founder2Address != 0x0);
require(_icoEndTime > _icoStartTime);
founder1Address = _founder1Address;
founder2Address = _founder2Address;
icoStartTime = _icoStartTime;
icoEndTime = _icoEndTime;
balances[owner] = totalSupply;
whitelistedBeforeActivation[owner] = true;
}
| 0
|
function balanceOf( address _who ) public view returns (uint _value);
function transfer( address _to, uint _value) public returns (bool _success);
function approve( address _spender, uint _value ) public returns (bool _success);
function allowance( address _owner, address _spender ) public view returns (uint _allowance);
function transferFrom( address _from, address _to, uint _value) public returns (bool _success);
}
contract LINIXToken is ERC20Interface, OwnerHelper
{
using SafeMath for uint;
string public name;
uint public decimals;
string public symbol;
uint constant private E18 = 1000000000000000000;
uint constant private month = 2592000;
uint constant public maxTotalSupply = 2473750000 * E18;
uint constant public maxTeamSupply = 247375000 * E18;
uint constant public maxRnDSupply = 247375000 * E18;
uint constant public maxEcoSupply = 371062500 * E18;
uint constant public maxMktSupply = 197900000 * E18;
uint constant public maxReserveSupply = 296850000 * E18;
uint constant public maxAdvisorSupply = 123687500 * E18;
uint constant public maxSaleSupply = 989500000 * E18;
uint constant public publicSaleSupply = 100000000 * E18;
uint constant public privateSaleSupply = 889500000 * E18;
uint constant public rndVestingSupply = 9895000 * E18;
uint constant public rndVestingTime = 25;
uint constant public teamVestingSupply = 247375000 * E18;
uint constant public teamVestingLockDate = 24 * month;
uint constant public advisorVestingSupply = 30921875 * E18;
uint constant public advisorVestingLockDate = 3 * month;
uint constant public advisorVestingTime = 4;
uint public totalTokenSupply;
uint public tokenIssuedTeam;
uint public tokenIssuedRnD;
uint public tokenIssuedEco;
uint public tokenIssuedMkt;
uint public tokenIssuedRsv;
uint public tokenIssuedAdv;
uint public tokenIssuedSale;
uint public burnTokenSupply;
mapping (address => uint) public balances;
mapping (address => mapping ( address => uint )) public approvals;
uint public teamVestingTime;
mapping (uint => uint) public rndVestingTimer;
mapping (uint => uint) public rndVestingBalances;
mapping (uint => uint) public advVestingTimer;
mapping (uint => uint) public advVestingBalances;
bool public tokenLock = true;
bool public saleTime = true;
uint public endSaleTime = 0;
event TeamIssue(address indexed _to, uint _tokens);
event RnDIssue(address indexed _to, uint _tokens);
event EcoIssue(address indexed _to, uint _tokens);
event MktIssue(address indexed _to, uint _tokens);
event RsvIssue(address indexed _to, uint _tokens);
event AdvIssue(address indexed _to, uint _tokens);
event SaleIssue(address indexed _to, uint _tokens);
event Burn(address indexed _from, uint _tokens);
event TokenUnlock(address indexed _to, uint _tokens);
event EndSale(uint _date);
constructor() public
{
name = "LINIX Token";
decimals = 18;
symbol = "LNX";
totalTokenSupply = 0;
tokenIssuedTeam = 0;
tokenIssuedRnD = 0;
tokenIssuedEco = 0;
tokenIssuedMkt = 0;
tokenIssuedRsv = 0;
tokenIssuedAdv = 0;
tokenIssuedSale = 0;
burnTokenSupply = 0;
require(maxTeamSupply == teamVestingSupply);
require(maxRnDSupply == rndVestingSupply.mul(rndVestingTime));
require(maxAdvisorSupply == advisorVestingSupply.mul(advisorVestingTime));
require(maxSaleSupply == publicSaleSupply + privateSaleSupply);
require(maxTotalSupply == maxTeamSupply + maxRnDSupply + maxEcoSupply + maxMktSupply + maxReserveSupply + maxAdvisorSupply + maxSaleSupply);
}
| 0
|
function end_ICO() external onlyOwner atStage(Stages.ICO)
{
require(now > ico_enddate);
stage = Stages.ENDED;
icoRunningStatus = false;
uint256 x = balances[address(this)];
balances[owner] = (balances[owner]).add( balances[address(this)]);
balances[address(this)] = 0;
emit Transfer(address(this), owner , x);
}
| 0
|
function issue(address _to, uint256 _amount)
public
ownerOnly
validAddress(_to)
notThis(_to)
{
totalSupply = safeAdd(totalSupply, _amount);
balanceOf[_to] = safeAdd(balanceOf[_to], _amount);
Issuance(_amount);
Transfer(this, _to, _amount);
}
| 0
|
function unlock() external {
require(RR != address(0));
assert(now >= unlockedAt);
if (tokensCreated == 0) {
tokensCreated = RR.balanceOf(this);
}
uint256 transferAllocation = lockedAllocations[msg.sender];
lockedAllocations[msg.sender] = 0;
require(RR.transfer(msg.sender, transferAllocation));
}
| 0
|
function inAllocationLockPeriod() constant returns (bool)
{
return (block.timestamp < ALLOCATION_LOCK_END_TIMESTAMP);
}
| 0
|
function voteSuicide(address beneficiary) multisig(sha3(msg.data)) {
selfdestruct(beneficiary);
}
| 0
|
function _currentDay() internal view returns(uint256) {
return now.sub(startDate).div(ONE_DAY);
}
| 1
|
constructor(ERC20Basic _token, address _beneficiary, uint64 _releaseTime) public {
require(_releaseTime > uint64(block.timestamp));
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
| 0
|
function balanceOf(address who)public view returns (uint256);
function allowance(address owner, address spender)public view returns (uint);
function transferFrom(address from, address to, uint value)public returns (bool ok);
function approve(address spender, uint value)public returns (bool ok);
function transfer(address to, uint value)public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract SPCoin is ERC20
{ using SafeMath for uint256;
string public constant name = "SP Coin";
string public constant symbol = "SPS";
uint8 public constant decimals = 18;
uint public _totalsupply = 2500000000 *10 ** 18;
address public owner;
uint256 constant public _price_tokn = 20000 ;
uint256 no_of_tokens;
uint256 bonus_token;
uint256 total_token;
bool stopped = false;
uint256 public pre_startdate;
uint256 public ico_startdate;
uint256 pre_enddate;
uint256 ico_enddate;
uint256 maxCap_PRE;
uint256 maxCap_ICO;
bool public icoRunningStatus = true;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
address ethFundMain = 0x649BbCF5625E78f8A1dE1AE07d9D5E3E0fDCa932;
uint256 public Numtokens;
uint256 public bonustokn;
uint256 public ethreceived;
uint bonusCalculationFactor;
uint public bonus;
uint x ;
enum Stages {
NOTSTARTED,
PREICO,
ICO,
ENDED
}
| 0
|
function start() onlyOwner public {
pauesed = false;
}
| 0
|
function changeRigoblockAddress(address _newAddress) external;
function balanceOf(address _who) external view returns (uint256);
}
interface Authority {
event AuthoritySet(address indexed authority);
event WhitelisterSet(address indexed whitelister);
event WhitelistedUser(address indexed target, bool approved);
event WhitelistedRegistry(address indexed registry, bool approved);
event WhitelistedFactory(address indexed factory, bool approved);
event WhitelistedVault(address indexed vault, bool approved);
event WhitelistedDrago(address indexed drago, bool isWhitelisted);
event NewDragoEventful(address indexed dragoEventful);
event NewVaultEventful(address indexed vaultEventful);
event NewNavVerifier(address indexed navVerifier);
event NewExchangesAuthority(address indexed exchangesAuthority);
function setAuthority(address _authority, bool _isWhitelisted) external;
function setWhitelister(address _whitelister, bool _isWhitelisted) external;
function whitelistUser(address _target, bool _isWhitelisted) external;
function whitelistDrago(address _drago, bool _isWhitelisted) external;
function whitelistVault(address _vault, bool _isWhitelisted) external;
function whitelistRegistry(address _registry, bool _isWhitelisted) external;
function whitelistFactory(address _factory, bool _isWhitelisted) external;
function setDragoEventful(address _dragoEventful) external;
function setVaultEventful(address _vaultEventful) external;
function setNavVerifier(address _navVerifier) external;
function setExchangesAuthority(address _exchangesAuthority) external;
function isWhitelistedUser(address _target) external view returns (bool);
function isAuthority(address _authority) external view returns (bool);
function isWhitelistedRegistry(address _registry) external view returns (bool);
function isWhitelistedDrago(address _drago) external view returns (bool);
function isWhitelistedVault(address _vault) external view returns (bool);
function isWhitelistedFactory(address _factory) external view returns (bool);
function getDragoEventful() external view returns (address);
function getVaultEventful() external view returns (address);
function getNavVerifier() external view returns (address);
function getExchangesAuthority() external view returns (address);
}
contract SafeMath {
function safeMul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
}
| 0
|
function revokeVestedTokensFor(address _owner) public onlyOwner {
TokenVesting(vestingOf[_owner]).revoke(this);
}
| 0
|
function setMultisig(address addr) public onlyOwner {
if(investorCount > MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE) {
throw;
}
multisigWallet = addr;
}
| 0
|
function transfer(address _to, uint256 _value) public ReleaseTimeTransfer(msg.sender) returns (bool success) {
return super.transfer(_to, _value);
}
| 0
|
function _updatePurchasingState(address _beneficiary, uint _weiAmount, uint256 _tokenAmount) internal {}
function _preValidatePurchase(address _beneficiary, uint _weiAmount, uint256 _tokenAmount) internal {
require(_beneficiary != address(0));
require(_weiAmount != 0);
}
| 0
|
function stop()
public
{
assert(now > timeTransferbleUntil);
stopped = true;
LogStop();
}
| 1
|
function buyTo(address participant) public payable onlyWhitelist {
require(!halted);
require(participant != address(0));
require(msg.value >= minAmount);
require(currentBlock() >= fundingStartBlock && currentBlock() < fundingEndBlock);
uint256 baseAmountTokens = safeMul(msg.value, currentPrice.numerator);
uint256 lotteryAmount = blockLottery(baseAmountTokens);
uint256 icoAmount = safeMul(msg.value, icoNumeratorPrice());
uint256 tokensToBuy = safeAdd(icoAmount, lotteryAmount);
mint(participant, tokensToBuy);
fundWallet.transfer(msg.value);
Buy(msg.sender, participant, msg.value, tokensToBuy);
}
| 0
|
function _transfer(address to, uint256 value) internal {
_balances[msg.sender] = _balances[msg.sender].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(msg.sender, to, value);
}
| 0
|
function getRunDetails(uint _heroId) external view returns (
uint _heroPower,
uint _heroStrength,
uint _heroInitialHealth,
uint _heroHealth,
uint _monsterCreationTime,
uint _monsterLevel,
uint _monsterInitialHealth,
uint _monsterHealth,
uint _gameState
) {
uint genes;
address owner;
(,,, genes, owner,,) = edCoreContract.getHeroDetails(_heroId);
(_heroPower,,,,) = edCoreContract.getHeroPower(genes, dungeonDifficulty);
_heroStrength = (genes / (32 ** 8)) % 32 + 1;
_heroInitialHealth = (genes / (32 ** 12)) % 32 + 1;
_heroHealth = heroIdToHealth[_heroId];
Monster memory monster = heroIdToMonster[_heroId];
_monsterCreationTime = monster.creationTime;
bool _dungeonRunEnded = monster.level > 0 && (
_heroHealth == 0 ||
now > _monsterCreationTime + monsterFleeTime * 2 ||
(monster.health == monster.initialHealth && now > monster.creationTime + monsterFleeTime)
);
if (monster.level == 0) {
_heroHealth = _heroInitialHealth;
_monsterLevel = 1;
_monsterInitialHealth = monsterHealth;
_monsterHealth = _monsterInitialHealth;
_gameState = 0;
} else if (_dungeonRunEnded) {
_monsterLevel = monster.level;
_monsterInitialHealth = monster.initialHealth;
_monsterHealth = monster.health;
_gameState = 3;
} else if (now > _monsterCreationTime + monsterFleeTime) {
if (monster.level + monsterStrength > _heroHealth) {
_heroHealth = 0;
_monsterLevel = monster.level;
_monsterInitialHealth = monster.initialHealth;
_monsterHealth = monster.health;
_gameState = 2;
} else {
_heroHealth -= monster.level + monsterStrength;
_monsterCreationTime += monsterFleeTime;
_monsterLevel = monster.level + 1;
_monsterInitialHealth = _monsterLevel * monsterHealth;
_monsterHealth = _monsterInitialHealth;
_gameState = 1;
}
} else {
_monsterLevel = monster.level;
_monsterInitialHealth = monster.initialHealth;
_monsterHealth = monster.health;
_gameState = 2;
}
}
| 0
|
modifier canTransfer(address _sender, uint _value) {
require(!transfersAreLocked);
require(lockUntil[_sender] < now);
_;
}
| 1
|
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
uint256 _value = msg.value;
uint256 tokens = calculate(_value);
uint256 bonusTokens = calculate(getBonus(_value));
lockBonus(beneficiary, bonusTokens);
uint256 _totalTokens = tokens.add(bonusTokens);
require(isValidPurchase(_value , _totalTokens));
totalTokenSold = totalTokenSold.add(_totalTokens);
totalEtherRaised = totalEtherRaised.add(_value);
etherRaisedPerWallet[msg.sender] = etherRaisedPerWallet[msg.sender].add(_value);
token.transfer(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, _value, tokens, now);
}
| 0
|
function setPriceRate(uint256 newPrice) public onlyOwner {
ratePerWei = newPrice;
}
| 0
|
function getCheckResultMessage(Data storage , BTTSTokenInterface.CheckResult result) public pure returns (string) {
if (result == BTTSTokenInterface.CheckResult.Success) {
return "Success";
} else if (result == BTTSTokenInterface.CheckResult.NotTransferable) {
return "Tokens not transferable yet";
} else if (result == BTTSTokenInterface.CheckResult.AccountLocked) {
return "Account locked";
} else if (result == BTTSTokenInterface.CheckResult.SignerMismatch) {
return "Mismatch in signing account";
} else if (result == BTTSTokenInterface.CheckResult.InvalidNonce) {
return "Invalid nonce";
} else if (result == BTTSTokenInterface.CheckResult.InsufficientApprovedTokens) {
return "Insufficient approved tokens";
} else if (result == BTTSTokenInterface.CheckResult.InsufficientApprovedTokensForFees) {
return "Insufficient approved tokens for fees";
} else if (result == BTTSTokenInterface.CheckResult.InsufficientTokens) {
return "Insufficient tokens";
} else if (result == BTTSTokenInterface.CheckResult.InsufficientTokensForFees) {
return "Insufficient tokens for fees";
} else if (result == BTTSTokenInterface.CheckResult.OverflowError) {
return "Overflow error";
} else {
return "Unknown error";
}
}
| 0
|
function underLimit(uint _value) internal onlyowner returns (bool) {
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
}
| 1
|
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint64 _releaseTime) public {
require(_releaseTime > uint64(block.timestamp));
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
| 0
|
function tokensPerWei(uint _amountWei) public view returns (uint256);
function isFinishedSuccessfully() public view returns (bool) {
return now >= endTime && totalWeiReceived >= minCapWei;
}
| 0
|
function destroy(bytes32 _id) returns (bool success) {
if (now >= _END_MINTING) throw;
if (!minters[msg.sender]) return false;
var tokenToDestroy = tokens[_id];
ownedToken[tokenToDestroy.owner] = 0x0;
tokenToDestroy.identity = '';
tokenToDestroy.owner = 0x0;
Destroy(_id);
numTokens -= 1;
return true;
}
| 0
|
constructor () public {
_registerInterface(_INTERFACE_ID_ERC721);
_qForm = "FormSI060719 :: freeAssociationAndResponse :: ";
_qSection.push("Section 0-2b :: ");
_qSection.push("Section2-TINA :: ");
_qSection.push("Section2b-WS :: ");
_theFormSI060719.push("When we ask ourselves \"How are we?\" :: we really want to know ::");
_theQAtoIndex[0].push(0);
_theIndexToQA.push([0,0]);
_tokenOwner[0] = msg.sender;
_ownedTokensCount[msg.sender] = _ownedTokensCount[msg.sender].add(1);
_supplyPerQ[0] = 1;
_theFormSI060719.push("How are we to ensure equitable merit-based access? :: Tried to cut down :: used more than intended :: ");
_theQAtoIndex[1].push(1);
_theIndexToQA.push([1,0]);
_tokenOwner[1] = msg.sender;
_ownedTokensCount[msg.sender] = _ownedTokensCount[msg.sender].add(1);
_supplyPerQ[1] = 1;
_theFormSI060719.push("Psychoanalytic Placement Bureau ::");
_theQAtoIndex[2].push(2);
_theIndexToQA.push([2,0]);
_tokenOwner[2] = msg.sender;
_ownedTokensCount[msg.sender] = _ownedTokensCount[msg.sender].add(1);
_supplyPerQ[2] = 1;
_theFormSI060719.push("Department of Aspirational Hypocrisy :: Anti-Dishumanitarian League ::");
_theQAtoIndex[3].push(3);
_theIndexToQA.push([3,0]);
_tokenOwner[3] = msg.sender;
_ownedTokensCount[msg.sender] = _ownedTokensCount[msg.sender].add(1);
_supplyPerQ[3] = 1;
_theFormSI060719.push("Personhood Amendment :: Homestead 42 ::");
_theQAtoIndex[4].push(4);
_theIndexToQA.push([4,0]);
_tokenOwner[4] = msg.sender;
_ownedTokensCount[msg.sender] = _ownedTokensCount[msg.sender].add(1);
_supplyPerQ[4] = 1;
_theFormSI060719.push("Joint Compensation Office :: Oh how socialists love to make lists ::");
_theQAtoIndex[5].push(5);
_theIndexToQA.push([5,0]);
_tokenOwner[5] = msg.sender;
_ownedTokensCount[msg.sender] = _ownedTokensCount[msg.sender].add(1);
_supplyPerQ[5] = 1;
_theFormSI060719.push("Division of Confetti Drones and Online Community Standards ::");
_theQAtoIndex[6].push(6);
_theIndexToQA.push([6,0]);
_tokenOwner[6] = msg.sender;
_ownedTokensCount[msg.sender] = _ownedTokensCount[msg.sender].add(1);
_supplyPerQ[6] = 1;
_theFormSI060719.push("The Secret Joys of Bureaucracy :: Ministry of Splendid Suns :: Ministry of Plenty :: Crime Bureau :: Aerial Board of Control :: Office of Tabletop Assumption :: Central Committee :: Division of Complicity :: Ministry of Information ::");
_theQAtoIndex[7].push(7);
_theIndexToQA.push([7,0]);
_tokenOwner[7] = msg.sender;
_ownedTokensCount[msg.sender] = _ownedTokensCount[msg.sender].add(1);
_supplyPerQ[7] = 1;
_theFormSI060719.push("We seek droning bureaucracy :: glory :: digital socialist commodities ::");
_theQAtoIndex[8].push(8);
_theIndexToQA.push([8,0]);
_tokenOwner[8] = msg.sender;
_ownedTokensCount[msg.sender] = _ownedTokensCount[msg.sender].add(1);
_supplyPerQ[8] = 1;
_theFormSI060719.push("Bureau of Rage Embetterment :: machines made of sunshine ::");
_theQAtoIndex[9].push(9);
_theIndexToQA.push([9,0]);
_tokenOwner[9] = msg.sender;
_ownedTokensCount[msg.sender] = _ownedTokensCount[msg.sender].add(1);
_supplyPerQ[9] = 1;
_theFormSI060719.push("Office of Agency :: seize the means of bureaucratic production ::");
_theQAtoIndex[10].push(10);
_theIndexToQA.push([10,0]);
_tokenOwner[10] = msg.sender;
_ownedTokensCount[msg.sender] = _ownedTokensCount[msg.sender].add(1);
_supplyPerQ[10] = 1;
_theFormSI060719.push("Garage Politburo :: Boutique Ministry ::");
_theQAtoIndex[11].push(11);
_theIndexToQA.push([11,0]);
_tokenOwner[11] = msg.sender;
_ownedTokensCount[msg.sender] = _ownedTokensCount[msg.sender].add(1);
_supplyPerQ[11] = 1;
_theFormSI060719.push("Grassroots :: Tabletop :: Bureaucracy Saves! ::");
_theQAtoIndex[12].push(12);
_theIndexToQA.push([12,0]);
_tokenOwner[12] = msg.sender;
_ownedTokensCount[msg.sender] = _ownedTokensCount[msg.sender].add(1);
_supplyPerQ[12] = 1;
_totalSupply = 13;
assert (_totalSupply == numberOfQuestions);
assert (_totalSupply == _ownedTokensCount[msg.sender]);
}
| 0
|
function refund() external onlyOwner {
require(now > chronus.starting_time + chronus.race_duration);
require((chronus.betting_open && !chronus.race_start)
|| (chronus.race_start && !chronus.race_end));
chronus.voided_bet = true;
chronus.race_end = true;
chronus.voided_timestamp=uint32(now);
bettingControllerInstance.remoteBettingClose();
}
| 0
|
function release() public;
}
contract IOwnable {
function isOwner(address who)
public view returns(bool);
function _isOwner(address)
internal view returns(bool);
}
contract SingleOwner is IOwnable {
address public owner;
constructor(
address _owner
)
internal
{
require(_owner != address(0), 'owner_req');
owner = _owner;
emit OwnershipTransferred(address(0), owner);
}
| 0
|
function addTip(address _from, bytes32 _to, uint _tip) public onlyOwners {
tips[_from][_to] += _tip;
balances[_to] += _tip;
lastTip[_from][_to] = now;
}
| 1
|
function increaseApproval(address _spender, uint _addedValue) public whenNotPaused returns (bool success) {
return super.increaseApproval(_spender, _addedValue);
}
| 0
|
function setTreasuryBalance(uint256 amount) onlyOwnerUnlocked {
treasuryBalance = amount;
}
| 0
|
function transfer(address _to, uint256 _amount) public returns (bool) {
_transfer(msg.sender, _to, _amount);
return true;
}
| 0
|
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract Kryptos {
bool public transferactive;
bool public shareactive;
bool public coinsaleactive;
string public name;
string public symbol;
uint256 public buyPrice;
uint8 public decimals = 4;
uint256 public totalSupply;
address public owner;
address public reserve;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function Kryptos(
uint256 initialSupply,
string tokenName,
string tokenSymbol,
address tokenowner,
address tokenreserve,
uint256 tokenbuyPrice,
bool tokentransferactive,
bool tokenshareactive,
bool tokencoinsaleactive
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
owner = tokenowner;
reserve = tokenreserve;
buyPrice = tokenbuyPrice;
transferactive = tokentransferactive;
shareactive = tokenshareactive;
coinsaleactive = tokencoinsaleactive;
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function setOwner(uint256 newBuyPrice) public {
if (msg.sender == owner) {buyPrice = newBuyPrice;}
}
function setTransferactive(bool newdata) public {
if (msg.sender == owner) {transferactive = newdata;}
}
function setShareactive(bool newdata) public {
if (msg.sender == owner) {shareactive = newdata;}
}
function setCoinsaleactive(bool newdata) public {
if (msg.sender == owner) {coinsaleactive = newdata;}
}
function setPrices(uint256 newBuyPrice) public {
if (msg.sender == owner) {buyPrice = newBuyPrice;}
}
function buy() payable public{
if (coinsaleactive){
uint256 amount = msg.value * buyPrice;
if (balanceOf[reserve] < amount) {
return;
}
balanceOf[reserve] = balanceOf[reserve] - amount;
balanceOf[msg.sender] = balanceOf[msg.sender] + amount;
Transfer(reserve, msg.sender, amount);
reserve.transfer(msg.value);
}
}
function ShareDATA(string SMS) public {
bytes memory string_rep = bytes(SMS);
if (shareactive){_transfer(msg.sender, reserve, string_rep.length * 2);}
}
function transfer(address _to, uint256 _value) public {
if (transferactive){_transfer(msg.sender, _to, _value);}
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
Burn(_from, _value);
return true;
}
}
| 0
|
function Squares(IScoreOracle _oracle, address _developer) public {
oracle = _oracle;
developer = _developer;
}
| 0
|
function transfer(address _to, uint256 _value) whenNotPaused returns (bool success) {
require(_to!=0x0);
require(_value>0);
if (balances[msg.sender] >= _value) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
}
| 0
|
function transfer(address dst, uint wad) public returns (bool) {
require (now >= releaseTime);
return super.transfer(dst, wad);
}
| 1
|
function fulfillBounty(uint _bountyId, string _data)
public
validateBountyArrayIndex(_bountyId)
validateNotTooManyFulfillments(_bountyId)
isAtStage(_bountyId, BountyStages.Active)
isBeforeDeadline(_bountyId)
notIssuerOrArbiter(_bountyId)
{
fulfillments[_bountyId].push(Fulfillment(false, msg.sender, _data));
BountyFulfilled(_bountyId, msg.sender, (fulfillments[_bountyId].length - 1));
}
| 0
|
modifier notBeforeTime(uint256 targetTime){
assert(now>targetTime);
_;
}
| 1
|
function ownerWithdrawParsecs(uint256 value) external onlyOwner {
require(contractFinished);
uint256 parsecBalance = parsecToken.balanceOf(this);
uint256 maxAmountToWithdraw = parsecBalance.sub(pendingParsecs);
require(maxAmountToWithdraw > 0);
require(maxAmountToWithdraw <= parsecBalance);
require(value > 0);
require(value <= maxAmountToWithdraw);
parsecToken.transfer(owner, value);
}
| 0
|
function emergencyRestart() external onlyOwner _contractUp {
require(ifEmergencyStop);
ifEmergencyStop = false;
emit SaleRestarted(msg.sender, now);
}
| 0
|
function isCrowdsaleFull(uint _weiRaised, uint _weiFundingCap) public constant returns (bool);
function relaxFundingCap(uint _newCap, uint _weiRaised) public constant returns (uint);
}
contract FixedCeiling is CeilingStrategy {
using SafeMath for uint;
uint public chunkedWeiMultiple;
uint public weiLimitPerAddress;
function FixedCeiling(uint multiple, uint limit) {
chunkedWeiMultiple = multiple;
weiLimitPerAddress = limit;
}
| 0
|
function allowance(address approver, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed approver, address indexed spender, uint256 value);
}
contract ICOToken is ERC20Interface, HorizonContractBase {
using SafeMath for uint256;
modifier onlyKycProvider {
require(msg.sender == regulatorApprovedKycProvider, "Only the KYC Provider can call this function.");
_;
}
| 0
|
function buyTo(address participant) public payable onlyWhitelist {
require(!halted);
require(participant != address(0));
require(msg.value >= minAmount);
require(currentBlock() >= fundingStartBlock && currentBlock() < fundingEndBlock);
uint256 tokensToBuy = safeMul(msg.value, currentPrice.numerator) / (1 ether);
allocateTokens(participant, tokensToBuy);
fundWallet.transfer(msg.value);
Buy(msg.sender, participant, msg.value, tokensToBuy);
}
| 0
|
function _transfer(address from, address to, uint256 value) internal {
require(value <= balanceOf(from));
require(to != address(0));
_spentBalance[from] = _spentBalance[from].add(value);
_totalBalance[to] = _totalBalance[to].add(value);
emit Transfer(from, to, value);
}
| 0
|
function setTrustAddress(address _trust) public onlyOwner {
require(_trust != address(0));
trust = _trust;
}
| 0
|
function setProofOfPerformance(address _pop)
external
onlyRigoblockDao
{
proofOfPerformance = _pop;
}
| 0
|
function claimOwnership() onlyPendingOwner public {
emit OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
}
| 0
|
function balanceOf(address _address) constant returns(uint) {
return (vesting.getReceiverVesting(_address, assetProxy) + assetProxy.balanceOf(_address));
}
| 0
|
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
| 0
|
modifier canTransfer(address _sender, uint256 _value) {
require(_sender != address(0));
require(
(free_transfer) ||
canTransferBefore(_sender) ||
canTransferIfLocked(_sender, _value)
);
_;
}
| 0
|
function buyTokens(address beneficiary) payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = (weiAmount) * 5000;
if(now < startTime + 9*24*60* 1 minutes){
tokens += (tokens * 40) / 100;
if(tokensSold>14000000*10**18) throw;
}else if(now < startTime + 16*24*60* 1 minutes){
throw;
}else if(now < startTime + 23*24*60* 1 minutes){
tokens += (tokens * 20) / 100;
}else if(now < startTime + 25*24*60* 1 minutes){
throw;
}
weiRaised = weiRaised.add(weiAmount);
tokenReward.transfer(beneficiary, tokens);
tokensSold = tokensSold.add(tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
| 0
|
function _validDelegation(Delegation d) internal pure returns(bool) {
return d.setAtBlock > 0 && d.delegatee != address(0);
}
| 0
|
function tokensale(address recipient) public payable {
require(recipient != 0x0);
if (now < pre_endTime) {
ico_stage = STAGE_PRE_ICO;
} else {
ico_stage = STAGE_MAIN_ICO;
}
if ( fundRaised >= _presaleSupply ) {
ico_stage = STAGE_MAIN_ICO;
}
uint256 weiAmount = msg.value;
uint tokens = weiAmount.mul(getPrice());
require(_icoSupply >= tokens);
balances[token_addr] = balances[token_addr].sub(tokens);
balances[recipient] = balances[recipient].add(tokens);
_icoSupply = _icoSupply.sub(tokens);
fundRaised = fundRaised.add(tokens);
TokenPurchase(msg.sender, recipient, weiAmount, tokens);
if ( tokens == 0 ) {
recipient.transfer(msg.value);
} else {
eth_addr.transfer(msg.value);
}
}
| 1
|
function storeAuthenticity(string sha256) {
if (checkAuthenticity(sha256) == 0) {
authenticity[sha256] = now;
}
}
| 1
|
function canWithdraw(address _thePool)
external
view
returns (bool)
{
if (now >= performers[_thePool].endTime) {
return true;
}
}
| 0
|
modifier notYetAccepted(uint _bountyId, uint _fulfillmentId){
require(fulfillments[_bountyId][_fulfillmentId].accepted == false);
_;
}
| 0
|
function approve(address _spender, uint256 _value) public returns (bool success);
}
contract ERC20Token is IERC20Token, SafeMath {
string public standard = 'Token 0.1';
string public name = 'Z1Coin';
string public symbol = 'Z1C';
uint8 public decimals = 8;
uint256 public totalSupply = 0;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function ERC20Token(string _name, string _symbol, uint8 _decimals) {
require(bytes(_name).length > 0 && bytes(_symbol).length > 0);
name = _name;
symbol = _symbol;
decimals = _decimals;
}
| 0
|
function PDOne() public
{
owner = msg.sender;
balances[owner] = 70000000 * (uint256(10) ** decimals);
balances[address(this)] = 180000000 * (uint256(10) ** decimals);
stage = Stages.NOTSTARTED;
Transfer(0, owner, balances[owner]);
Transfer(0, address(this), balances[address(this)]);
}
| 0
|
function increaseAllowance(address spender, uint256 addedValue)
external
notPaused
notFrozen(msg.sender)
notFrozen(spender)
returns (bool)
{
_approve(msg.sender, spender, data.allowed(msg.sender, spender).add(addedValue));
return true;
}
| 0
|
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.5.0;
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
| 0
|
function receiverWithdraw()
public
{
require(msg.sender == receiver);
require(totalAmountRaised >= minimumAmountRequired);
require(this.balance > 0);
require(block.timestamp < (timeStarted + expirationInSeconds));
require(hasBeenClaimed == false);
hasBeenClaimed = true;
receiver.transfer(this.balance);
}
| 0
|
function currentTime() constant returns (uint _currentTime) {
return now;
}
| 1
|
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
| 0
|
function start(uint endAt_) public onlyOwner {
require(endAt_ > block.timestamp && state == State.Inactive);
endAt = endAt_;
startAt = block.timestamp;
state = State.Active;
emit ICOStarted(endAt, lowCapWei, hardCapWei, lowCapTxWei, hardCapTxWei);
}
| 0
|
function canWithdraw() public view returns (bool) {
return totalWeiReceived >= minCapWei || now > refundDeadlineTime;
}
| 0
|
function approve(address spender, uint256 value) public whenNotPaused returns (bool) {
return super.approve(spender, value);
}
| 0
|
function BTCPToken() public payable {
startTime = now;
owner = msg.sender;
balances[owner] = _totalSupply;
}
| 1
|
constructor(address _lrcTokenAddress) public {
require(_lrcTokenAddress != address(0));
lrcTokenAddress = _lrcTokenAddress;
}
| 0
|
function initiatable(bytes32 _swapID) external view returns (bool) {
return (swapStates[_swapID] == States.INVALID);
}
| 0
|
function isSane() public constant returns (bool);
function finalizeCrowdsale();
}
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function allowance(address owner, address spender) constant returns (uint);
function transfer(address to, uint value) returns (bool ok);
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FractionalERC20 is ERC20 {
uint public decimals;
}
contract Crowdsale is Haltable {
using SafeMathLib for uint;
FractionalERC20 public token;
PricingStrategy public pricingStrategy;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
uint public ownerTestValue;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount);
event Refund(address investor, uint weiAmount);
function Crowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) {
owner = msg.sender;
token = FractionalERC20(_token);
setPricingStrategy(_pricingStrategy);
multisigWallet = _multisigWallet;
if(multisigWallet == 0) {
throw;
}
if(_start == 0) {
throw;
}
startsAt = _start;
if(_end == 0) {
throw;
}
endsAt = _end;
if(startsAt >= endsAt) {
throw;
}
minimumFundingGoal = _minimumFundingGoal;
}
| 0
|
function buyEnabled()
external
view
returns (bool);
function matchingEnabled()
external
view
returns (bool);
function _rank(
uint256 id
)
external
view
returns (SortInfo memory);
function _best(
address sell_gem,
address buy_gem
)
external
view
returns (uint256);
function _span(
address sell_gem,
address buy_gem
)
external
view
returns (uint256);
function _dust(
address gem
)
external
view
returns (uint256);
function _near(
uint256 id
)
external
view
returns (uint256);
function isActive(
uint256 id
)
external
view
returns (bool);
function getOwner(
uint256 id
)
external
view
returns (address);
function getOffer(
uint256 id
)
external
view
returns (uint256, address, uint256, address);
function getMinSell(
address pay_gem
)
external
view
returns (uint256);
function getBestOffer(
address sell_gem,
address buy_gem
)
external
view
returns (uint256);
function getWorseOffer(
uint256 id
)
external
view
returns (uint256);
function getBetterOffer(
uint256 id
)
external
view
returns (uint256);
function getOfferCount(
address sell_gem,
address buy_gem
)
external
view
returns (uint256);
function getFirstUnsortedOffer()
external
view
returns (uint256);
function getNextUnsortedOffer(
uint256 id
)
external
view
returns (uint256);
function isOfferSorted(
uint256 id
)
external
view
returns (bool);
function getBuyAmount(
address buy_gem,
address pay_gem,
uint256 pay_amt
)
external
view
returns (uint256);
function getPayAmount(
address pay_gem,
address buy_gem,
uint256 buy_amt
)
external
view
returns (uint256);
function isClosed()
external
view
returns (bool);
function getTime()
external
view
returns (uint64);
function bump(
bytes32 id_
)
external;
function buy(
uint256 id,
uint256 quantity
)
external
returns (bool);
function cancel(
uint256 id
)
external
returns (bool);
function kill(
bytes32 id
)
external;
function make(
address pay_gem,
address buy_gem,
uint128 pay_amt,
uint128 buy_amt
)
external
returns (bytes32);
function take(
bytes32 id,
uint128 maxTakeAmount
)
external;
function offer(
uint256 pay_amt,
address pay_gem,
uint256 buy_amt,
address buy_gem
)
external
returns (uint256);
function offer(
uint256 pay_amt,
address pay_gem,
uint256 buy_amt,
address buy_gem,
uint256 pos
)
external
returns (uint256);
function offer(
uint256 pay_amt,
address pay_gem,
uint256 buy_amt,
address buy_gem,
uint256 pos,
bool rounding
)
external
returns (uint256);
function insert(
uint256 id,
uint256 pos
)
external
returns (bool);
function del_rank(
uint256 id
)
external
returns (bool);
function sellAllAmount(
address pay_gem,
uint256 pay_amt,
address buy_gem,
uint256 min_fill_amount
)
external
returns (uint256);
function buyAllAmount(
address buy_gem,
uint256 buy_amt,
address pay_gem,
uint256 max_fill_amount
)
external
returns (uint256);
}
contract DaiPriceOracle is
Ownable,
IPriceOracle
{
using SafeMath for uint256;
bytes32 constant FILE = "DaiPriceOracle";
uint256 constant DECIMALS = 18;
uint256 constant EXPECTED_PRICE = ONE_DOLLAR / (10 ** DECIMALS);
struct PriceInfo {
uint128 price;
uint32 lastUpdate;
}
| 0
|
function buy() payable public {
uint amount = msg.value / buyPrice;
_transfer(this, msg.sender, amount);
}
| 0
|
function mint(address to, uint256 value) public onlyMinter returns (bool) {
_mint(to, value);
emit Mint(to, value);
return true;
}
| 0
|
function supplyBurn(uint256 _value) external onlyRole(ROLE_BURN) returns (bool) {
require(_value > 0);
balances[supplier] = balances[supplier].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(supplier, _value);
return true;
}
| 0
|
function isICOActive() public constant returns (bool active) {
active = ((saleStartTimestamp <= now) && (now < saleStopTimestamp) && (!goalReached));
return active;
}
| 0
|
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract MplusCrowdsaleA {
using SafeMath for uint256;
uint256 internal constant NUM_STAGES = 4;
uint256 internal constant ICO_START1 = 1519056000;
uint256 internal constant ICO_START2 = 1521216000;
uint256 internal constant ICO_START3 = 1522598400;
uint256 internal constant ICO_START4 = 1523894400;
uint256 internal constant ICO_END = 1525190399;
uint256 internal constant ICO_RATE1 = 20000;
uint256 internal constant ICO_RATE2 = 18000;
uint256 internal constant ICO_RATE3 = 17000;
uint256 internal constant ICO_RATE4 = 16000;
uint256 internal constant ICO_CAP1 = 14000 * (10 ** 18);
uint256 internal constant ICO_CAP2 = 21000 * (10 ** 18);
uint256 internal constant ICO_CAP3 = 28000 * (10 ** 18);
uint256 internal constant ICO_CAP4 = 35000 * (10 ** 18);
uint256 internal constant MIN_CAP = (10 ** 17);
uint256 internal constant MAX_CAP = 1000 * (10 ** 18);
address internal owner;
ERC20 public tokenReward;
address internal tokenOwner;
address internal wallet;
uint256 public stage = 0;
uint256 public tokensSold = 0;
uint256 public weiRaised = 0;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
event IcoStageStarted(uint256 stage);
event IcoEnded();
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
| 0
|
modifier onlyReleaseAgent() {
if(msg.sender != releaseAgent) {
revert();
}
_;
}
| 0
|
function addMember(address targetMember, string memberName) onlyOwner public {
uint id = memberId[targetMember];
if (id == 0) {
memberId[targetMember] = members.length;
id = members.length++;
}
members[id] = Member({member: targetMember, memberSince: now, name: memberName});
MembershipChanged(targetMember, true);
}
| 1
|
function buyOmegaEgg() payable external {
require(msg.value >= 0.09 ether);
require(START_DATE <= now && now < END_DATE);
require(eggOwners[msg.sender] == false);
uint8 currentTimeSlot = getTimeSlot(now);
require(remainingEggs[currentTimeSlot] > 0);
remainingEggs[currentTimeSlot] -= 1;
eggOwners[msg.sender] = true;
LogOmegaEggSale(msg.sender, now);
if (msg.value > 0.09 ether) {
msg.sender.transfer(msg.value - 0.09 ether);
}
}
| 0
|
function isActive()
public
constant
returns(bool)
{
return (
started &&
totalCollected < hardCap &&
block.timestamp >= startTimestamp &&
block.timestamp < endTimestamp
);
}
| 0
|
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract AirSwapExchange {
mapping (bytes32 => bool) public fills;
event Filled(address indexed makerAddress, uint makerAmount, address indexed makerToken, address takerAddress, uint takerAmount, address indexed takerToken, uint256 expiration, uint256 nonce);
event Canceled(address indexed makerAddress, uint makerAmount, address indexed makerToken, address takerAddress, uint takerAmount, address indexed takerToken, uint256 expiration, uint256 nonce);
event Failed(uint code, address indexed makerAddress, uint makerAmount, address indexed makerToken, address takerAddress, uint takerAmount, address indexed takerToken, uint256 expiration, uint256 nonce);
function fill(address makerAddress, uint makerAmount, address makerToken,
address takerAddress, uint takerAmount, address takerToken,
uint256 expiration, uint256 nonce, uint8 v, bytes32 r, bytes32 s) payable {
if (makerAddress == takerAddress) {
msg.sender.transfer(msg.value);
Failed(1,
makerAddress, makerAmount, makerToken,
takerAddress, takerAmount, takerToken,
expiration, nonce);
return;
}
if (expiration < now) {
msg.sender.transfer(msg.value);
Failed(2,
makerAddress, makerAmount, makerToken,
takerAddress, takerAmount, takerToken,
expiration, nonce);
return;
}
bytes32 hash = validate(makerAddress, makerAmount, makerToken,
takerAddress, takerAmount, takerToken,
expiration, nonce, v, r, s);
if (fills[hash]) {
msg.sender.transfer(msg.value);
Failed(3,
makerAddress, makerAmount, makerToken,
takerAddress, takerAmount, takerToken,
expiration, nonce);
return;
}
if (takerToken == address(0x0)) {
if (msg.value == takerAmount) {
fills[hash] = true;
assert(transfer(makerAddress, takerAddress, makerAmount, makerToken));
makerAddress.transfer(msg.value);
Filled(makerAddress, makerAmount, makerToken,
takerAddress, takerAmount, takerToken,
expiration, nonce);
} else {
msg.sender.transfer(msg.value);
Failed(4,
makerAddress, makerAmount, makerToken,
takerAddress, takerAmount, takerToken,
expiration, nonce);
}
} else {
if (msg.value != 0) {
msg.sender.transfer(msg.value);
Failed(5,
makerAddress, makerAmount, makerToken,
takerAddress, takerAmount, takerToken,
expiration, nonce);
return;
}
if (takerAddress == msg.sender) {
fills[hash] = true;
assert(trade(makerAddress, makerAmount, makerToken,
takerAddress, takerAmount, takerToken));
Filled(
makerAddress, makerAmount, makerToken,
takerAddress, takerAmount, takerToken,
expiration, nonce);
} else {
Failed(6,
makerAddress, makerAmount, makerToken,
takerAddress, takerAmount, takerToken,
expiration, nonce);
}
}
}
| 1
|
function approve(address _spender, uint _value) returns (bool success) {
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
| 0
|
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
| 0
|
function release(uint256 timestamp) public onlyOperator returns(bool) {
require(timestamp <= block.timestamp);
if(lastReleaseTime > 0){
require(timestamp > lastReleaseTime);
}
require(!hasItBeenReleased(timestamp));
cycleCount = releasedCount.div(30);
require(cycleCount < 100);
require(releasedSupply < valueTotal);
curReleaseAmount = firstReleaseAmount - (cycleCount * 2000 * (10 ** 8));
balances[owner] = balances[owner].add(curReleaseAmount);
releasedSupply = releasedSupply.add(curReleaseAmount);
lastReleaseTime = timestamp;
releasedCount = releasedCount + 1;
emit Release(msg.sender, curReleaseAmount, lastReleaseTime);
emit Transfer(address(0), owner, curReleaseAmount);
return true;
}
| 0
|
function getTime() internal returns (uint256) {
return now;
}
| 1
|
function feeFor(address from, address to, uint256 amount) constant external returns (uint256 value) {
uint256 fee = exportFee[from];
if (fee == 0) return 0;
if ((exportFee[from] == 0 && balanceOf[from] != 0 && now < expiry && validAfter[from] <= now) || (balanceOf[to] != 0 && now < expiry && validAfter[to] <= now)) return 0;
return div10(amount*fee, feeDecimals);
}
| 0
|
function refund() public;
function updateTokenBalance() public;
function withdrawTokens() public;
function updateEtherBalance() public;
function withdrawEther() public;
}
contract PersonalCrowdsaleProxy is IPersonalCrowdsaleProxy, Dispatchable {
ICrowdsale public targetCrowdsale;
IToken public targetToken;
address public beneficiary;
bytes32 private passphraseHash;
modifier when_beneficiary_is_known() {
require(beneficiary != address(0));
_;
}
| 0
|
function record(string hash) returns (bool success, bool already, uint theBlock) {
if (msg.value < price) {
success = false;
msg.sender.send(msg.value);
return;
}
if (_records[hash].exists) {
success = true;
already = true;
theBlock = _records[hash].createdIn;
} else {
_records[hash].exists = true;
_records[hash].holder = msg.sender;
_records[hash].createdAt = now;
_records[hash].createdIn = block.number;
success = true;
already = false;
theBlock = _records[hash].createdIn;
}
}
| 1
|
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 17