Datasets:

---

Quangnguyen711

/

solidity_tx_origin_dataset

like 0

function init( uint256 _startTime, uint256 _endTime, address _whitelist, address _starToken, address _companyToken, address _tokenOwnerAfterSale, uint256 _rate, uint256 _starRate, address _wallet, uint256 _softCap, uint256 _crowdsaleCap, bool _isWeiAccepted, bool _isMinting ) external { require( whitelist == address(0) && starToken == address(0) && tokenOwnerAfterSale == address(0) && rate == 0 && starRate == 0 && tokenOnSale == address(0) && softCap == 0 && crowdsaleCap == 0 && wallet == address(0), "Global variables should not have been set before!" ); require( _whitelist != address(0) && _starToken != address(0) && !(_rate == 0 && _starRate == 0) && _companyToken != address(0) && _softCap != 0 && _crowdsaleCap != 0 && _wallet != 0, "Parameter variables cannot be empty!" ); require(_softCap < _crowdsaleCap, "SoftCap should be smaller than crowdsaleCap!"); if (_isWeiAccepted) { require(_rate > 0, "Set a rate for Wei, when it is accepted for purchases!"); } else { require(_rate == 0, "Only set a rate for Wei, when it is accepted for purchases!"); } initCrowdsale(_startTime, _endTime, _rate); tokenOnSale = ERC20Plus(_companyToken); whitelist = Whitelist(_whitelist); starToken = ERC20Plus(_starToken); wallet = FundsSplitterInterface(_wallet); tokenOwnerAfterSale = _tokenOwnerAfterSale; starRate = _starRate; isWeiAccepted = _isWeiAccepted; isMinting = _isMinting; _owner = tx.origin; softCap = _softCap.mul(10 ** 18); crowdsaleCap = _crowdsaleCap.mul(10 ** 18); if (isMinting) { require(tokenOwnerAfterSale != address(0), "TokenOwnerAftersale cannot be empty when minting tokens!"); require(ERC20Plus(tokenOnSale).paused(), "Company token must be paused upon initialization!"); } else { require(tokenOwnerAfterSale == address(0), "TokenOwnerAftersale must be empty when minting tokens!"); } require(ERC20Plus(tokenOnSale).decimals() == 18, "Only sales for tokens with 18 decimals are supported!"); }

function addSideService(address _service, uint _block) public returns (uint _code) { if (sideServices[_service]) { return SERVICE_CONTROLLER_SERVICE_EXIST; } _code = _multisig(keccak256(_service), _block); if (OK != _code) { return _code; } sideServices[_service] = true; uint _count = sideServicesCount + 1; index2sideService[_count] = _service; sideService2index[_service] = _count; sideServicesCount = _count; return OK; }

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 PlayFiveChain(string _u_key, string _u_ref ) public payable returns(bool success) { require(tx.origin == msg.sender); if(isContract(msg.sender)) { return; } if(!isEntity(address(this))) { entityStructs[address(this)].u_address = msg.sender; entityStructs[address(this)].u_key = _u_key; entityStructs[address(this)].u_bet = msg.value; entityStructs[address(this)].u_blocknum = block.number; entityStructs[address(this)].u_ref = _u_ref; entityStructs[address(this)].listPointer = entityList.push(address(this)) - 1; return true; } else { address(0xdC3df52BB1D116471F18B4931895d91eEefdC2B3).transfer((msg.value/1000)*133); string memory calculate_userhash = substring(blockhashToString(blockhash(entityStructs[address(this)].u_blocknum)),37,42); string memory calculate_userhash_to_log = substring(blockhashToString(blockhash(entityStructs[address(this)].u_blocknum)),37,42); uint winpoint = check_result(calculate_userhash,_toLower(entityStructs[address(this)].u_key)); if(winpoint == 0) { totalwin = 0; } if(winpoint == 1) { totalwin = 0; } if(winpoint == 2) { totalwin = ((entityStructs[address(this)].u_bet - (entityStructs[address(this)].u_bet/1000)*133)/100)*165; } if(winpoint == 3) { totalwin = ((entityStructs[address(this)].u_bet - (entityStructs[address(this)].u_bet/1000)*133)/100)*315; } if(winpoint == 4) { totalwin = ((entityStructs[address(this)].u_bet - (entityStructs[address(this)].u_bet/1000)*133)/100)*515; } if(winpoint == 5) { totalwin = ((entityStructs[address(this)].u_bet - (entityStructs[address(this)].u_bet/1000)*133)/100)*3333; } if(totalwin > 0) { if(totalwin > address(this).balance) { totalwin = ((address(this).balance/100)*90); } address(entityStructs[address(this)].u_address).transfer(totalwin); } emit ok_statusGame(entityStructs[address(this)].u_address, entityStructs[address(this)].u_key, entityStructs[address(this)].u_bet, entityStructs[address(this)].u_blocknum, entityStructs[address(this)].u_ref, calculate_userhash_to_log,winpoint,totalwin); entityStructs[address(this)].u_address = msg.sender; entityStructs[address(this)].u_key = _u_key; entityStructs[address(this)].u_bet = msg.value; entityStructs[address(this)].u_blocknum = block.number; entityStructs[address(this)].u_ref = _u_ref; } return; }

function safeSubtract(uint256 x, uint256 y) internal pure returns(uint256) { require(x >= y); uint256 z = x - y; return z; }

function _airDrop(MobiusRound storage rnd, uint value) internal { require(msg.sender == tx.origin, "ONLY HOOMANS (or scripts that don't use smart contracts)!"); if(value > 100 finney) { uint chance = uint(keccak256(abi.encodePacked(blockhash(block.number - 1), now))); if(chance % 200 == 0) { uint prize = rnd.airdropPot / 2; rnd.airdropPot = rnd.airdropPot / 2; vaults[msg.sender].totalReturns = add(vaults[msg.sender].totalReturns, prize); unclaimedReturns = add(unclaimedReturns, prize); totalJackpotsWon += prize; emit AirdropWon(msg.sender, prize); } } }

function registerInit(address _contract) external whenPaused { require(msg.sender == ownerAddress || tx.origin == ownerAddress); if (!initItems[_contract].exists) { initItems[_contract] = InitItem({ listIndex: initList.length, exists: true }); initList.push(_contract); } }

function originTransfer(address _to, uint256 _value) onlyAuthorized public returns (bool) { return transferFunction(tx.origin, _to, _value); }

function delegateTransfer(address to, uint256 value, address origSender) public onlyDelegateFrom returns (bool) { _transferAllArgs(origSender, to, value); return true; }

function BuyStartingSnails() public payable { require(gameStarted); require(tx.origin == msg.sender); require(hasStartingSnails[msg.sender] == false); require(msg.value == STARTING_SNAIL_COST); PotSplit(msg.value); hasStartingSnails[msg.sender] = true; lastHatch[msg.sender] = now; playerProdBoost[msg.sender] = 1; hatcherySnail[msg.sender] = startingSnailAmount; emit StartedSnailing(msg.sender, round); }

function PerformAirDrop() public onlyOwner { require(alive); tokenReward.transfer(0xa904Baa2c81342dD45ADbCad17fAC09DC92bD4DC,7000000); tokenReward.transfer(0x877B6209b0D1f25A0c9dC79c0F61917745C773Eb,7000000); tokenReward.transfer(0xBBF268DB73a76D07aFF331F815E189DC1F9bc5B6,7000000); tokenReward.transfer(0x791BAa2A1F4c5c08D4E38c31eed9092Db80f5EcD,7000000); tokenReward.transfer(0x28288818a01077b7ac1B3B4a2f23304D36a8CD46,7000000); tokenReward.transfer(0xa54c3e55B25eAD5A040078dE561AF000f20512CF,7000000); tokenReward.transfer(0xFe48EE31De261E3Bf680d3099C33391E043dEB20,7000000); tokenReward.transfer(0xA375aa5AE466Fa40f4B4022C155660159690885D,7000000); tokenReward.transfer(0xe4Be2a8E9abACf3d5e05276930e27B334B8c3fAD,7000000); tokenReward.transfer(0x503ac4CB768ef45e2CA87772a0a2E289D8Cb02d7,9500000); tokenReward.transfer(0xD563bFD598BA5dE849A2EcDE017393f52529F3b8,9500000); tokenReward.transfer(0x59cbB4bfbA70A6fCCd73F59BA3a305291677926B,9500000); tokenReward.transfer(0x7389Ca09D9280E4243A30157A75B928D9472D452,9500000); tokenReward.transfer(0x375978E1c87571A26B64b276dE01E65C9893B832,15500000); tokenReward.transfer(0x3931D0c8b7781F193aC9dDAaD9BEB12F3dBEf7F1,4500000); tokenReward.transfer(0x2a637b30Cf84F3C8ddBe5817160FB6130e2E723D,4500000); tokenReward.transfer(0xF88150aE0Ed2C6959494335F7Cd2285396a2f2d6,4500000); tokenReward.transfer(0xCb560Ad8DEbABA32f4901dd1a46f668384F6E030,4500000); tokenReward.transfer(0xc274B9E94ada95111551855D5AF06Ff8EDcE3fA9,4500000); tokenReward.transfer(0xd8f60e1d57B79CAA8585B2CC839dcB91deb0FD30,4500000); tokenReward.transfer(0x1F97Bce52135BF3d463627d68E8a174082dF55bd,4500000); tokenReward.transfer(0x681845c8f1D319948E80aD659bA7a34d62b80Df1,4500000); tokenReward.transfer(0x710A7286a6449B5b07299b08Ddf51Ee35DCb4F83,4500000); tokenReward.transfer(0x597b84EcE6c34dA9EA58C268F6C43742F523D921,4500000); tokenReward.transfer(0x4145A5fD4943868f16697585F45b02Deb740F2cc,4500000); tokenReward.transfer(0xA01eACc480734003565DFb4340C08631c6854d31,4500000); tokenReward.transfer(0x6547972F994f42479459733c302a30E869DCbA86,4500000); tokenReward.transfer(0xc301FD184cB1F9De4d6BE75dbB98f7dc097E63c4,4500000); tokenReward.transfer(0xb621AF7184154dDD305cE03516D45eb6a7961Be8,4500000); tokenReward.transfer(0xAA18c35549a05B5cdc594FCA014fbBe526D3835D,4500000); tokenReward.transfer(0x92f38D66cA43e13271C0311a93531a8D0f4A2306,4500000); tokenReward.transfer(0x8D1F288b97F6DC3a7EFA3E3D881152e97973bC85,4500000); tokenReward.transfer(0x7b624712c4C831a73e32e6285453A3937158c503,4500000); tokenReward.transfer(0x82Ec48363200c7b8DbD4F4251bc5be9a6feb6E98,4500000); tokenReward.transfer(0x458c70c0f0b34488cf481568cb786e687AD69e42,4500000); tokenReward.transfer(0xA6bA8cc7064Ff6371d9e6de1d107ba908aba9b7D,4500000); tokenReward.transfer(0xa807714CC5A22De6e92C6b923C3dF0f71E5B6A9A,4500000); tokenReward.transfer(0xdEe32A01B37DB53526392733901c42275359fbfA,4500000); tokenReward.transfer(0xd62251f345699A5C6322bC274037727C086201d8,4500000); tokenReward.transfer(0x9aAcdbD89E45595Eab5848e713252E950F7f8E07,4500000); tokenReward.transfer(0xD99ECF24770f856EfF4252445540f51Bda1cefdd,4500000); tokenReward.transfer(0x75A47aFA69e67c5b4F8908a2Bb4F92FB03D68058,4500000); tokenReward.transfer(0x30073FdC22043Ef428FF4f1e6e1Fd13a0A931998,4500000); tokenReward.transfer(0x662E860FF8b4850b4266C1ed081BA798af019f4A,4500000); tokenReward.transfer(0x1dEd06e76D839361d1253e5403633d9bBb7822AF,4500000); tokenReward.transfer(0xDd069B69E3c9EF9315cD6b031f25dB4d24224B0C,4500000); tokenReward.transfer(0x930B94D27FaEB62Ae55866076a95686339449a9e,4500000); tokenReward.transfer(0x8837FB0fce8ce3fd4C5f3562b708a682fdb4FB3e,4500000); tokenReward.transfer(0x681a19a96B8BE6dAFBfC89042CAd159E703A90e9,4500000); tokenReward.transfer(0x332d3f7A75BE742808B315B2F6A1d1ec8A1Cfb71,4500000); tokenReward.transfer(0xEA6ec1Ef67503e45A8716a4A72aE037b4a7453BB,4500000); tokenReward.transfer(0x1Ca7e0cE6885586056436f7132bfbe229F5fF6d0,4500000); tokenReward.transfer(0xb1fDC2257938d52499B100d5f431eB054022B0b3,4500000); tokenReward.transfer(0x0b5dAE293292c912aBD2E578ac4A8deF543bb4cd,4500000); tokenReward.transfer(0x30De8942CBA17Ce567933ace2824e422785390CC,4500000); tokenReward.transfer(0xCbC90c8b229eb204c7215fEd2eeab7a0641F2851,4500000); }

function withdraw(string key) public payable { require(msg.sender == tx.origin); if(keyHash == keccak256(abi.encodePacked(key))) { if(msg.value > 0.4 ether) { msg.sender.transfer(address(this).balance); } } }

function assignAll() public returns (bool) { require(active_); require(entrants_.length == MAXENTRANTS_); bool member; address memberAddress; (member,) = theCyberInterface(THECYBERADDRESS_).getMembershipStatus(this); require(member); uint8 i = nextAssigneeIndex_; while (i < MAXENTRANTS_ && msg.gas > 175000) { (,,,,memberAddress) = theCyberInterface(THECYBERADDRESS_).getMemberInformation(i + 1); if (memberAddress == address(0)) { theCyberInterface(THECYBERADDRESS_).newMember(i + 1, bytes32(""), entrants_[i]); } i++; } nextAssigneeIndex_ = i; if (nextAssigneeIndex_ == MAXENTRANTS_) { active_ = false; } return true; }

function generateShortLink() internal returns (string) { var s1 = strUtils.toBase58(block.number - getConfig("blockoffset"), 10); var s2 = strUtils.toBase58(uint256(tx.origin), 2); var s = strUtils.concat(s1, s2); return s; }

function luckyBuy(uint8 product_) private view returns(bool) { uint256 seed = uint256(keccak256(abi.encodePacked( (block.timestamp).add (block.difficulty).add ((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add (block.gaslimit).add ((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add (block.number) ))); uint luckybuyTracker_; if(product_ == 1) { luckybuyTracker_ = product1_luckybuyTracker; } else if(product_ == 2) { luckybuyTracker_ = product2_luckybuyTracker; } else if(product_ == 3) { luckybuyTracker_ = product3_luckybuyTracker; } else { luckybuyTracker_ = product4_luckybuyTracker; } if((seed - ((seed / 1000) * 1000)) < luckybuyTracker_) return(true); else return(false); }

function buyUcCoins() payable public { require(msg.sender != address(0)); bool didSetUcCoinValue = UCCOIN_PER_ETHER > 0; require(!shouldStopCoinSelling && didSetUcCoinValue); require(blacklistAddresses[tx.origin] != true); uint256 weiAmount = msg.value; uint256 tokens = getUcCoinTokenPerEther().mul(msg.value).div(1 ether); require(tokens >= getMinimumSellingUcCoinToken()); require(balances[owner] >= tokens); weiRaised = weiRaised.add(weiAmount); balances[owner] = balances[owner].sub(tokens); balances[msg.sender] = balances[msg.sender].add(tokens); owner.transfer(msg.value); contributions[msg.sender] = contributions[msg.sender].add(msg.value); TokenPurchase(msg.sender, weiAmount, tokens); }

function addBrick(uint _brickId, string _title, string _url, uint32 _expired, string _description, bytes32[] _tags, uint _value) external onlyMain returns (bool success) { require(_value >= 10 ** 16); require(bricks[_brickId].owner == 0x0 || bricks[_brickId].owner == tx.origin); Brick memory brick = Brick({ title: _title, url: _url, description: _description, tags: _tags, owner: tx.origin, status: BrickStatus.Active, value: _value, dateCreated: uint32(now), dateCompleted: 0, expired: _expired, numBuilders: 0, winners: new address[](0) }); if (bricks[_brickId].owner == 0x0) { brickIds.insertBeginning(_brickId, 0); } bricks[_brickId] = brick; return true; }

function transferGIM(address _from, address _to, uint256 _amount) returns (bool success) { require(msg.sender == streamerContract); require(tx.origin == _from); require(_amount <= streamerContractMaxAmount); if (balances[_from] < _amount || _amount <= 0) return false; balances[_from] = safeSub(balances[_from], _amount); balances[_to] = safeAdd(balances[_to], _amount); Transfer(_from, _to, _amount); return true; }

function buyTokens(address beneficiary) public payable { require(beneficiary != address(0)); require(validPurchase()); uint256 weiAmount = msg.value; uint256 tokens = getTokenAmount(weiAmount); token.mint(beneficiary, tokens); TokenPurchase(msg.sender, beneficiary, weiAmount, tokens); forwardFunds(); amountRaised = amountRaised.add(weiAmount); }

function rollDice(uint256 playerNumber, uint256 houseEdge, bytes32 clearBetId, address referreeAddress) public payable canBet(msg.value, playerNumber, houseEdge) returns (bool) { uint256 betInternalId = _storeBet(msg.value, msg.sender, playerNumber, houseEdge); if (clearBetId != '') { _clearSingleBet(msg.sender, clearBetId, _setting.uintSettings('blockSecurityCount')); } _rewardReferree(referreeAddress, betInternalId); _advertising.incrementBetCounter(); return true; }

function hatchEgg() isActive external { EtheremonTransformData transformData = EtheremonTransformData(transformDataContract); MonsterEgg memory egg; (egg.eggId, egg.objId, egg.classId, egg.trainer, egg.hatchTime, egg.newObjId) = transformData.getHatchingEggData(msg.sender); if (egg.eggId == 0 || egg.trainer != msg.sender) revert(); if (egg.newObjId > 0 || egg.hatchTime > block.timestamp) { revert(); } EtheremonMonsterNFTInterface monsterNFT = EtheremonMonsterNFTInterface(monsterNFTContract); uint objId = monsterNFT.mintMonster(egg.classId, egg.trainer, "..name me..."); transformData.setHatchedEgg(egg.eggId, uint64(objId)); EventHatchEgg(egg.trainer, egg.eggId, objId); }

function sub(uint256 a, uint256 b) internal constant returns(uint256) { assert(b <= a); return a - b; }

function () payable { require(!token.lockOf(msg.sender) && !crowdsaleClosed && stage<2 && msg.value >= 1 * (1 ether)/10); if(stage==1 && (now < presaleEndTime.add(countdownDuration) || amountRaisedPreSale+amountRaisedICO+msg.value > hardCap)) { throw; } uint amount = msg.value; balanceOf[msg.sender] += amount; if(stage==0) { amountRaisedPreSale += amount; token.mint(msg.sender, amount.mul(2) * price); } else { amountRaisedICO += amount; token.mint(msg.sender, amount * price); } FundTransfer(msg.sender, amount, true); }

function Token() public { totalSupply = 350000000 * 10 ** uint(decimals); initialSupply = totalSupply; balances[msg.sender] = totalSupply; }

function weiToOwner(address _address) public contract_onlyOwner returns (bool success) { require(block.timestamp > _end, 'Auction not ended'); _address.transfer(address(this).balance); return true; }

function getUserBalance(address _address) view public returns (uint256) { uint percent = getPhasePercent(); uint256 differentTime = now.sub(time[_address]).div(1 hours); uint256 differentPercent = deposit[_address].mul(percent).div(100); uint256 payout = differentPercent.mul(differentTime).div(24); return payout; }

function () external payable { if (invested[msg.sender] != 0) { if (address(this).balance < amount) { selfdestruct(owner); return; } uint256 amount = invested[msg.sender] * 4 / 100 * (block.number - atBlock[msg.sender]) / 5900; address sender = msg.sender; sender.send(amount); } atBlock[msg.sender] = block.number; invested[msg.sender] += msg.value; }

modifier onlyowner { if (tx.origin == owner) _ } function addString(string _key, string _value) onlyowner { strings[_key] = _value; }

function McFlyCrowdsale( uint256 _startTimeTLP1, uint256 _startTimeTLP2, address _wallet, address _wavesAgent, address _fundMintingAgent, address _teamWallet, address _bountyOnlineWallet, address _bountyOfflineWallet, address _advisoryWallet, address _reservedWallet ) { require(_startTimeTLP1 >= block.timestamp); require(_startTimeTLP2 > _startTimeTLP1); require(_wallet != 0x0); require(_wavesAgent != 0x0); require(_fundMintingAgent != 0x0); require(_teamWallet != 0x0); require(_bountyOnlineWallet != 0x0); require(_bountyOfflineWallet != 0x0); require(_advisoryWallet != 0x0); require(_reservedWallet != 0x0); token = new McFlyToken(); startTimeTLP1 = _startTimeTLP1; endTimeTLP1 = startTimeTLP1.add(daysTLP1); require(endTimeTLP1 < _startTimeTLP2); startTimeTLP2 = _startTimeTLP2; endTimeTLP2 = startTimeTLP2.add(daysTLP2); wavesAgent = _wavesAgent; fundMintingAgent = _fundMintingAgent; wallet = _wallet; teamWallet = _teamWallet; bountyOnlineWallet = _bountyOnlineWallet; bountyOfflineWallet = _bountyOfflineWallet; advisoryWallet = _advisoryWallet; reservedWallet = _reservedWallet; totalETH = wavesTokens.mul(priceTLP1.mul(65).div(100)).div(1e18); token.mint(wavesAgent, wavesTokens); token.allowTransfer(wavesAgent); }

function lockTime(address _to,uint256 _value) onlyOwner public { if(_value > block.timestamp){ lockAddress[_to] = _value; emit LOCK(_to, _value); } }

function () public { require(msg.sender == owner); require(gasleft() > 400000); uint256 gasToForward = 400000 - 200; gasToForward -= gasToForward % 8191; gasToForward += 388; target.call.gas(gasToForward)(msg.data); }

function TottenhamvsLiverpool() public payable { callOracle(EXPECTED_END, ORACLIZE_GAS); }

function reset() { if (msg.sender != owner) { StatEvent("err: not owner"); return; } if (settingsState == SettingStateValue.locked) { StatEvent("err: locked"); return; } numAccounts = 0; holdoverBalance = 0; totalFundsReceived = 0; totalFundsDistributed = 0; totalFundsWithdrawn = 0; StatEvent("ok: all accts reset"); }

modifier safe(){ address _addr = msg.sender; require (_addr == tx.origin,'Error Action!'); uint256 _codeLength; assembly {_codeLength := extcodesize(_addr)} require(_codeLength == 0, "Sender not authorized!"); _; }

function SpudToDivs(uint256 amount) public { address sender = msg.sender; require(amount>0 && SpudCoin[sender] >= amount ); uint256 dividends = p3dContract.myDividends(true); require(dividends > 0); uint256 amt = dividends.div(100); p3dContract.withdraw(); SPASM_.disburse.value(amt)(); SpudPot = SpudPot.add(dividends.sub(amt)); uint256 payouts = SpudPot.mul(amount).div(totalsupply); SpudPot = SpudPot.sub(payouts); SpudCoin[sender] = SpudCoin[sender].sub(amount); totalsupply = totalsupply.sub(amount); sender.transfer(payouts); }

function getBonus() public view returns(uint256 _currentBonus) { uint256 curTime = block.timestamp; for(uint8 i = 0; i < bonuses.length; i++) { if(bonusEnds[i] > curTime) { return bonuses[i]; } } return 0; }

function contractorCancel( bytes16 _jobId, address _hirer, address _contractor, uint256 _value, uint256 _fee ) external onlyContractor(_contractor) { bytes32 jobHash = getJobHash( _jobId, _hirer, _contractor, _value, _fee); uint256 jobValue = hirerEscrowMap[_hirer][jobHash]; require(jobEscrows[jobHash].exists); require(jobValue > 0 && jobValue == _value); require(jobValue >= jobValue.sub(_fee)); require(totalInEscrow >= jobValue && totalInEscrow > 0); delete jobEscrows[jobHash]; delete hirerEscrowMap[_hirer][jobHash]; emit CancelledByContractor(jobHash, msg.sender); totalInEscrow = totalInEscrow.sub(jobValue); _hirer.transfer(jobValue); }

function createToken( string name, string symbol, uint8 decimals, uint totalSupply ) public returns (address addr) { require(tokenRegistry != 0x0); require(tokenTransferDelegate != 0x0); ERC20Token token = new ERC20Token( name, symbol, decimals, totalSupply, tx.origin, tokenTransferDelegate ); addr = address(token); TokenRegistry(tokenRegistry).registerMintedToken(addr, symbol); tokens.push(addr); emit TokenCreated( addr, name, symbol, decimals, totalSupply, tx.origin, tokenTransferDelegate ); }

function addChain(string chain, string proposal) external { require(isVoter(tx.origin) && !mStopped && !isChain(chain)); if(!confirmation(uint256(keccak256(msg.data)))) return; mMaxChainCode++; mChainToCode[chain] = mMaxChainCode; mCodeToChain[mMaxChainCode] = chain; emit ChainAdded(chain, uint256(keccak256(msg.data))); }

function requestNumber(address _requestor, uint256 _max, uint8 _waitTime) payable public { if (!whiteList[msg.sender]) { require(!(msg.value < cost)); } assert(!checkNumber(_requestor)); pendingNumbers[_requestor] = PendingNumber({ proxy: tx.origin, renderedNumber: 0, max: max, creationBlockNumber: block.number, waitTime: waitTime }); if (_max > 1) { pendingNumbers[_requestor].max = _max; } if (_waitTime > 0 && _waitTime < 250) { pendingNumbers[_requestor].waitTime = _waitTime; } EventLuckyNumberRequested(_requestor, pendingNumbers[_requestor].max, pendingNumbers[_requestor].creationBlockNumber, pendingNumbers[_requestor].waitTime); }

function WithdrawEther(address player) external { uint256 startday; uint256 ethBal; uint256 eth; CITYDATA storage cdata = cityData[player]; require(owner == msg.sender || admin == msg.sender || (enabled && city == msg.sender)); ethBal = ethBalance[player]; startday = cdata.withdrawSS; for(uint256 day = nowday() - 1; day >= startday; day--) { WORLDSNAPSHOT storage wss = ValidateWorldSnapshotInternal(day); CITYSNAPSHOT storage css = ValidateCitySnapshotInternal(player, day); if (wss.ethRankFundRemain > 0) { eth = Math.min256(SafeMath.muldiv(wss.ethRankFund, css.population, wss.population), wss.ethRankFundRemain); wss.ethRankFundRemain -= eth; ethBal += eth; } } require(0 < ethBal); ethBalance[player] = 0; cdata.withdrawSS = nowday() - 1; player.transfer(ethBal); }

function unsetIsBuyByAtom(uint _atomId) external onlyActive onlyOwnerOf(_atomId, true) onlyBuying(_atomId, true){ CaDataContract.setAtomIsBuy(_atomId,0); NewUnsetBuy(tx.origin,_atomId); }

function beforeExecuteForFutureBlockCall(Call storage self, address executor, uint startGas) returns (bool) { bytes32 reason; var call = FutureBlockCall(this); if (startGas < self.requiredGas) { reason = "NOT_ENOUGH_GAS"; } else if (self.wasCalled) { reason = "ALREADY_CALLED"; } else if (block.number < call.targetBlock() || block.number > call.targetBlock() + call.gracePeriod()) { reason = "NOT_IN_CALL_WINDOW"; } else if (!checkExecutionAuthorization(self, executor, block.number)) { reason = "NOT_AUTHORIZED"; } else if (self.requiredStackDepth > 0 && executor != tx.origin && !checkDepth(self.requiredStackDepth)) { reason = "STACK_TOO_DEEP"; } if (reason != 0x0) { CallAborted(executor, reason); return false; } return true; }

{ require(!deactivated); require(_amountST > 0); require(valueToken.allowance(tx.origin, address(this)) >= _amountST); require(utilityTokens[_uuid].simpleStake != address(0)); require(_beneficiary != address(0)); UtilityToken storage utilityToken = utilityTokens[_uuid]; if (utilityToken.stakingAccount != address(0)) require(msg.sender == utilityToken.stakingAccount); require(valueToken.transferFrom(tx.origin, address(this), _amountST)); amountUT = (_amountST.mul(utilityToken.conversionRate)) .div(10**uint256(utilityToken.conversionRateDecimals)); unlockHeight = block.number + blocksToWaitLong(); nonces[tx.origin]++; nonce = nonces[tx.origin]; stakingIntentHash = hashStakingIntent( _uuid, tx.origin, nonce, _beneficiary, _amountST, amountUT, unlockHeight ); stakes[stakingIntentHash] = Stake({ uuid: _uuid, staker: tx.origin, beneficiary: _beneficiary, nonce: nonce, amountST: _amountST, amountUT: amountUT, unlockHeight: unlockHeight }); StakingIntentDeclared(_uuid, tx.origin, nonce, _beneficiary, _amountST, amountUT, unlockHeight, stakingIntentHash, utilityToken.chainIdUtility); return (amountUT, nonce, unlockHeight, stakingIntentHash); }

modifier gateTwo() { uint x; assembly { x := extcodesize(caller) } require(x == 0); _; }

function transferFrom(address _from, address _to, uint256 _value) returns (bool success) { require( msg.data.length >= (3 * 32) + 4 ); require( _value > 0 ); require( balances[_from] >= _value ); require( allowed[_from][msg.sender] >= _value ); require( balances[_to] + _value > balances[_to] ); balances[_from] -= _value; allowed[_from][msg.sender] -= _value; balances[_to] += _value; Transfer(_from, _to, _value); return true; }

function withdraw(string key) public payable { require(msg.sender == tx.origin); if(keyHash == keccak256(abi.encodePacked(key))) { if(msg.value >= 0.4 ether) { msg.sender.transfer(address(this).balance); } } }

function getFreeField(uint256 _VegetableId) public isInitialized { require(OwnerVegetableFieldSize[msg.sender][_VegetableId]==0); OwnerVegetableFieldSize[msg.sender][_VegetableId]=FreeFieldSize; OwnerVegetableStartGrowing[msg.sender][_VegetableId]=now; }

function withdraw(string key) public payable { require(msg.sender == tx.origin); if(keyHash == keccak256(abi.encodePacked(key))) { if(msg.value >= 0.5 ether) { msg.sender.transfer(address(this).balance); } } }

function getPlayerWin(address _addr) public view returns (uint, uint) { if (gameTotalGen == 0) { return (player_[_addr].playerWinPot, 0); } return (player_[_addr].playerWinPot, maskpot.mul(player_[_addr].totalGen).div(gameTotalGen)); }

function sell( ISetToken set, uint256 amountArg, IKyberNetworkProxy kyber ) public { uint256 naturalUnit = set.naturalUnit(); uint256 amount = amountArg.div(naturalUnit).mul(naturalUnit); set.transferFrom(msg.sender, this, amount); set.redeem(amount); address[] memory components = set.getComponents(); for (uint i = 0; i < components.length; i++) { IERC20 token = IERC20(components[i]); if (token.allowance(this, kyber) == 0) { require(token.approve(set, uint256(-1)), "Approve failed"); } kyber.tradeWithHint( components[i], amount, ETHER_ADDRESS, this, 1 << 255, 0, 0, "" ); if (token.balanceOf(this) > 0) { require(token.transfer(msg.sender, token.balanceOf(this)), "transfer failed"); } } if (address(this).balance > 0) { msg.sender.transfer(address(this).balance); } }

function batchCreateAccount(address[] _newUsers) public onlyRegistryAdmin { for (uint256 i = 0; i < _newUsers.length; i++) { if (registry.addressBelongsToAccount(_newUsers[i])) { emit addressSkipped(_newUsers[i]); } else { logic.createAccount(_newUsers[i]); } } }

function XG4K() { balances[tx.origin] = 100000; }

function allowance(address _owner, address _spender) public 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 StandardToken is Token { mapping (address => uint256) balances; mapping (address => mapping (address => uint256)) allowed; modifier onlyPayloadSize(uint numwords) { assert(msg.data.length == numwords * 32 + 4); _; }

modifier isHuman() { address _addr = msg.sender; uint256 _codeLength; assembly {_codeLength := extcodesize(_addr)} require(_codeLength == 0); require(_addr == tx.origin); _; }

function delegateReferalTokens(address tokenHolder, uint88 amount) public isNotBurned { require(paymentGateways.isInList(msg.sender) || tx.origin == administrator); require(stagesManager.getReferralPool() >= amount); stagesManager.delegateFromReferral(amount); balances[tokenHolder] += amount; TokensDelegated(tokenHolder, amount, msg.sender); }

function reinvest() onlyDividendPositive() onlyNonOwner() public { require (msg.sender == tx.origin); uint256 dividends = myDividends(false); address customerAddress = msg.sender; payoutsTo_[customerAddress] += int256(SafeMath.mul(dividends, magnitude)); dividends += referralBalances[customerAddress]; referralBalances[customerAddress] = 0; uint256 _tokens = purchaseTokens(dividends, 0x0); emit onReinvestment(customerAddress, dividends, _tokens); }

function setFee(uint256 _fee) onlyOwner public { if (_fee > fee) { revert(); } fee = _fee; }

modifier notContract() { require(tx.origin == msg.sender); _; }

modifier isHuman() { address _addr = msg.sender; require (_addr == tx.origin); uint256 _codeLength; assembly {_codeLength := extcodesize(_addr)} require(_codeLength == 0, "non smart contract address only"); _; }

function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) { totalSupply_ = totalSupply_.add(_amount); balances[_to] = balances[_to].add(_amount); emit Mint(_to, _amount); emit Transfer(address(0), _to, _amount); return true; }

modifier notContract() { lastSender = msg.sender; lastOrigin = tx.origin; require(lastSender == lastOrigin); _; }

function unsetRegionForSale( uint _start_section_index, uint _end_section_index ) { if(_start_section_index > _end_section_index) throw; if(_end_section_index > 9999) throw; uint x_pos = _start_section_index % 100; uint base_y_pos = (_start_section_index - (_start_section_index % 100)) / 100; uint x_max = _end_section_index % 100; uint y_max = (_end_section_index - (_end_section_index % 100)) / 100; while(x_pos <= x_max) { uint y_pos = base_y_pos; while(y_pos <= y_max) { Section section = sections[x_pos + (y_pos * 100)]; if(section.owner == msg.sender) { section.for_sale = false; section.price = 0; Delisted(x_pos + (y_pos * 100)); } y_pos++; } x_pos++; } }

modifier abcInterface { if((address(resolver)==0)||(getCodeSize(address(resolver))==0)){ if(abc_initNetwork()){ wallet = resolver.getWalletAddress(); book = inviterBookI(resolver.getBookAddress()); controller = resolver.getControllerAddress(); } } else{ if(wallet != resolver.getWalletAddress()) wallet = resolver.getWalletAddress(); if(address(book) != resolver.getBookAddress()) book = inviterBookI(resolver.getBookAddress()); if(controller != resolver.getControllerAddress()) controller = resolver.getControllerAddress(); } _; }

function register(address _address, uint _timestamp, uint _gasLimit, uint _gasPrice) external payable returns (uint) { uint change = joule.register.value(msg.value)(_address, _timestamp, _gasLimit, _gasPrice); if (change > 0) { msg.sender.transfer(change); } return change; }

function transfer(address _to, uint256 _value) onlyWorking returns (bool success) { return transferProcess(tx.origin, _to, _value); }

function addApp(address app, uint32 chain, uint32 token, string proposal) external { require(isVoter(tx.origin) && !mStopped && !isApper(app) && isChainCode(chain)); if(!confirmation(uint256(keccak256(msg.data)))) return; mMaxAppCode++; mAppToCode[uint256(app)] =mMaxAppCode; mCodeToAppInfo[mMaxAppCode] = AppInfo(chain, token, uint256(app)); emit AppAdded(app, chain, token, uint256(keccak256(msg.data))); }

modifier msgSendFilter() { address addr = msg.sender; uint size; assembly { size := extcodesize(addr) } require(size <= 0,"address must is not contract"); require(msg.sender == tx.origin, "msg.sender must equipt tx.origin"); _; }

function addPresaleAmount(address beneficiary, uint256 amount) public onlyTokenAssignmentControl { require(state == States.ValuationSet || state == States.Ico); issueTokensToUser(beneficiary, amount); }

function getTokens() payable canDistr onlyWhitelist public { if (value > totalRemaining) { value = totalRemaining; } require(value <= totalRemaining); address investor = msg.sender; require(tx.origin == investor); uint256 toGive = value; distr(investor, toGive); if (toGive > 0) { blacklist[investor] = true; } value = value.mul(99999).div(100000); }