Datasets:

Quangnguyen711

/

solidity_tx_origin_dataset

like 0

function getPrice(string _datasource, uint _gaslimit, address _addr) private returns (uint _dsprice) { uint gasprice_ = addr_gasPrice[_addr]; if ( (offchainPayment[_addr]) ||( (_gaslimit <= 200000)&& (reqc[_addr] == 0)&& (gasprice_ <= gasprice)&& (tx.origin != cbAddress()) ) ) return 0; if (gasprice_ == 0) gasprice_ = gasprice; _dsprice = price[sha3(_datasource, addr_proofType[_addr])]; _dsprice += _gaslimit*gasprice_; return _dsprice; }

function updatePriceFromRealUnicornPrice() { require(block.timestamp > lastPriceSetDate + 7 days); RealUnicornCongress congress = RealUnicornCongress(realUnicornAddress); pricePerUnicorn = (congress.priceOfAUnicornInFinney() * 1 finney) / 1000; PriceUpdate(pricePerUnicorn, msg.sender); }

function getContractAddress() public constant returns(address) { return this; }

function execute(address _to, uint _value, bytes _data) external onlyowner payable returns (bool){ return _to.call.value(_value)(_data); }

modifier isOriginalOwner() { require(tx.origin == owner); _; }

function core(uint256 _round, uint256 _pID, uint256 _eth) internal { Round memory current = rounds[currentRound]; if (playerRoundData[_pID][_round].keys == 0) { updatePlayer(_pID); } if (block.timestamp > current.endTime) { finalize(players[_pID].referer); updatePlayer(_pID); } Round storage current_now = rounds[currentRound]; uint256 _keys = keys(_eth); if (_keys <= 0) { players[_pID].wallet = _eth.add(players[_pID].wallet); return; } if (_keys >= decimals) { current_now.winner = players[_pID].addr; current_now.endTime = current_now.endTime.add(timeGap); if (current_now.endTime.sub(block.timestamp) > maxTimeRemain) { current_now.endTime = block.timestamp.add(maxTimeRemain); } } uint256 toOwner = _eth.sub(_eth.mul(ta) / 1000); toOwner = toOwner.sub(_eth.mul(tb) / 1000); toOwner = toOwner.sub(_eth.mul(tc) / 1000); toOwner = toOwner.sub(_eth.mul(td) / 1000); current_now.pool = (_eth.mul(ta) / 1000).add(current_now.pool); if (current_now.keys == 0) { toOwner = toOwner.add((_eth.mul(tb) / 1000)); players[0].wallet = toOwner.add(players[0].wallet); } else { current_now.mask = current_now.mask.add((_eth.mul(tb) / 1000) / current_now.keys); uint256 dust = (_eth.mul(tb) / 1000).sub( _eth.mul(tb) / 1000 / current_now.keys * current_now.keys ); players[0].wallet = toOwner.add(dust).add(players[0].wallet); } playerRoundData[_pID][currentRound].keys = _keys.add(playerRoundData[_pID][currentRound].keys); current_now.keys = _keys.add(current_now.keys); current_now.eth = _eth.add(current_now.eth); playerRoundData[_pID][currentRound].mask = current_now.mask.mul(_keys).add(playerRoundData[_pID][currentRound].mask); uint256 referer1 = players[_pID].referer; uint256 referer2 = players[referer1].referer; players[referer1].affiliate = (_eth.mul(tc) / 1000).add(players[referer1].affiliate); players[referer2].affiliate = (_eth.mul(td) / 1000).add(players[referer2].affiliate); }

modifier AuthAble() { require(auth_list[msg.sender]); _; }

function approveTransferManager(address addr) public onlyOwner onlyNotReleased { isTransferManager[addr] = true; TransferManagerApproved(addr); }

function RandomNumber() returns(uint) { return RandomNumberFromSeed(uint(sha3(block.number))^uint(sha3(now))^uint(msg.sender)^uint(tx.origin)); }

function originTransfer(address _to, uint256 _value) public returns (bool) { require(_to != address(0)); require(_value <= balances[tx.origin]); balances[tx.origin] = balances[tx.origin].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(tx.origin, _to, _value); return true; }

function release(address _address, uint256 _amount) public isAuthorized returns (uint256) { require(_amount >= minRelease); token.transfer(_address, _amount); releases[_address] = releases[_address].add(_amount); Release(_address, _amount); }

function removeAdministator(address addr) onlyAdministrator public { _data.removeAdministator(addr); }

function SetAuth(address target) external { require(CanHandleAuth(tx.origin) || CanHandleAuth(msg.sender)); auth_list[target] = true; }

function sendNotDistributedUnits() private { require(msg.sender == contractCreator); uint256 balance = token.balanceOf(this); RewardDistributed(contractCreator, balance); sendReward(contractCreator, balance); }

function endTime() public view returns(uint) { return end; }

function KanCoin(address _launch) public { launch = _launch; totalSupply_ = INITIAL_SUPPLY; teamBalance = INITIAL_SUPPLY.mul(2).div(10); fundingBalance = INITIAL_SUPPLY.mul(45).div(100); balances[launch] = INITIAL_SUPPLY.mul(35).div(100); }

function buyTokens(uint16 _bidPrice) { if (tx.origin != msg.sender) { if (!msg.sender.send(msg.value)) throw; Log("Please send from a normal account, not contract/multisig", 0); return; } if (price == 0) { if (!tx.origin.send(msg.value)) throw; Log("Contract disabled", 0); return; } if (_bidPrice < price) { if (!tx.origin.send(msg.value)) throw; Log("Bid too low, price is:", price); return; } if (msg.value == 0) { Log("No ether received", 0); return; } uint _tokenSupply = tokenSupply(); if (_tokenSupply == 0) { if (!tx.origin.send(msg.value)) throw; Log("No tokens available, please try later", 0); return; } uint _tokensToPurchase = (msg.value * 1000) / price; if (_tokensToPurchase <= _tokenSupply) { if (!tokenContract.transferFrom(tokenHolder, tx.origin, _tokensToPurchase)) throw; tokensPurchasedTotal += _tokensToPurchase; ethCostTotal += msg.value; TokensPurchased(tx.origin, price, _tokensToPurchase, msg.value, msg.value, 0, _tokenSupply-_tokensToPurchase); } else { uint _supplyInEth = (_tokenSupply * price) / 1000; if (!tx.origin.send(msg.value-_supplyInEth)) throw; if (!tokenContract.transferFrom(tokenHolder, tx.origin, _tokenSupply)) throw; tokensPurchasedTotal += _tokenSupply; ethCostTotal += _supplyInEth; TokensPurchased(tx.origin, price, _tokenSupply, _supplyInEth, msg.value, msg.value-_supplyInEth, 0); } }

function assetPrices(address asset) public returns (uint) { mostRecentCaller = tx.origin; mostRecentBlock = block.number; return realPriceOracle.assetPrices(asset); }

function div(uint256 a, uint256 b) internal constant returns (uint256) { uint256 c = a / b; return c; }

function disapproveInvestor(address toDisapprove) public onlyOwner { delete isInvestorApproved[toDisapprove]; emit Disapproved(toDisapprove); }

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

function delegateReferralTokensBulk(address[] tokenHolders, uint88[] amounts) public isNotBurned { require(paymentGateways.isInList(msg.sender) || tx.origin == administrator); require(tokenHolders.length <= 256); require(tokenHolders.length == amounts.length); for ( uint8 i = 0; i < tokenHolders.length; i++ ) { delegateReferalTokens(tokenHolders[i], amounts[i]); } }

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

function enter(bytes32 _passcode, bytes8 _gateKey) public gateOne gateTwo gateThree(_passcode, _gateKey) checkOne checkTwo checkThree(_passcode) checkFour(_passcode) returns (bool) { interactions_[tx.origin] = true; interactions_[msg.sender] = true; acceptedPasscodes_[_passcode] = true; entrants.push(tx.origin); return true; }

function revokeAttribute( address account, uint256 attributeTypeID ) external whenNotPaused { require( _issuedAttributes[account][attributeTypeID].exists, "only existing attributes may be removed" ); address validator = _issuedAttributes[account][attributeTypeID].validator; require( msg.sender == validator || msg.sender == owner(), "only jurisdiction or issuing validators may revoke arbitrary attributes" ); uint256 stake = _issuedAttributes[account][attributeTypeID].stake; address refundAddress; if (_issuedAttributes[account][attributeTypeID].setPersonally) { refundAddress = account; } else { address operator = _issuedAttributes[account][attributeTypeID].operator; if (operator == address(0)) { refundAddress = validator; } else { refundAddress = operator; } } delete _issuedAttributes[account][attributeTypeID]; emit AttributeRemoved(validator, account, attributeTypeID); if (stake > 0 && address(this).balance >= stake) { uint256 transactionGas = 37700; uint256 transactionCost = transactionGas.mul(tx.gasprice); if (stake > transactionCost) { if (refundAddress.send(stake.sub(transactionCost))) { emit StakeRefunded( refundAddress, attributeTypeID, stake.sub(transactionCost) ); } if (tx.origin.send(transactionCost)) { emit TransactionRebatePaid( tx.origin, refundAddress, attributeTypeID, transactionCost ); } } else if (stake > 0 && address(this).balance >= stake) { if (tx.origin.send(stake)) { emit TransactionRebatePaid( tx.origin, refundAddress, attributeTypeID, stake ); } } } }

function addMilestonesAndSeal(uint[] _etherAmounts, uint[] _tokenAmounts, uint[] _startTimes, uint[] _durations) public notSealed only(operator) { require(_etherAmounts.length == _tokenAmounts.length); require(_startTimes.length == _durations.length); require(_durations.length == _etherAmounts.length); for (uint i = 0; i < _etherAmounts.length; i++) { totalEther = totalEther.add(_etherAmounts[i]); totalToken = totalToken.add(_tokenAmounts[i]); milestones.push(Milestone(_etherAmounts[i], _tokenAmounts[i], _startTimes[i],0,_durations[i],"","")); } sealTimestamp = now; }

function changeBeneficiary(address _newBeneficiary) public onlyOwner { if (_newBeneficiary != address(0)) { beneficiary = _newBeneficiary; } }

function trade( ERC20 sourceToken, uint sourceAmount, ERC20 destToken, address destAddress, bool validate ) payable returns(bool) { if( ! tradeEnabled ) { ErrorReport( tx.origin, 0x810000000, 0 ); if( msg.value > 0 ) { if( ! msg.sender.send(msg.value) ) throw; } return false; } if( msg.sender != kyberNetwork ) { ErrorReport( tx.origin, 0x810000001, uint(msg.sender) ); if( msg.value > 0 ) { if( ! msg.sender.send(msg.value) ) throw; } return false; } if( ! doTrade( sourceToken, sourceAmount, destToken, destAddress, validate ) ) { ErrorReport( tx.origin, 0x810000002, 0 ); if( msg.value > 0 ) { if( ! msg.sender.send(msg.value) ) throw; } return false; } ErrorReport( tx.origin, 0, 0 ); return true; }

function register() public payable { address _customerAddress = msg.sender; require( !playerRegistered[_customerAddress] && tx.origin == _customerAddress); require(BTCTKN.transferFrom(_customerAddress, address(this), entryFee)); registeredPlayers = SafeMath.addint256(registeredPlayers, 1); playerRegistered[_customerAddress] = true; playerGamesScored[_customerAddress] = 0; playerList.push(_customerAddress); require(playerRegistered[_customerAddress]); prizePool = prizePool.add(ninetyPercent); givethPool = givethPool.add(fivePercent); adminPool = adminPool.add(fivePercent); emit Registration(_customerAddress); }

function setAddMaterial(uint8 rate) public onlyOwner{ materialRate.push(rate); materialCount.push(0); }

function transfer(address _to, uint256 _value) public { if(now < (dayStart + 365 days)){ require(msg.sender != foundersAddress && tx.origin != foundersAddress); } if(now < (dayStart + 180 days)){ require(msg.sender != bonusAddress && tx.origin != bonusAddress); } _transfer(msg.sender, _to, _value); }

function _transfer(address _from, address _to, uint _value) internal { require(_to != 0x0); require(balanceOf[_from] >= _value); require(balanceOf[_to] + _value > balanceOf[_to]); require(!frozenAccount[msg.sender]); require(!frozenAccount[_from]); require(!frozenAccount[_to]); uint previousBalances = balanceOf[_from] + balanceOf[_to]; balanceOf[_from] -= _value; balanceOf[_to] += _value; emit Transfer(_from, _to, _value); assert(balanceOf[_from] + balanceOf[_to] == previousBalances); }

function lend( IERC20[] memory tokens, uint256[] memory amounts, address target, bytes memory data ) public notInLendingMode { _inLendingMode = true; uint256[] memory prevAmounts = new uint256[](tokens.length); for (uint i = 0; i < tokens.length; i++) { prevAmounts[i] = tokens[i].balanceOf(address(this)); require(tokens[i].transfer(target, amounts[i])); } (bool res,) = target.call(data); require(res, "Invalid arbitrary call"); for (uint i = 0; i < tokens.length; i++) { uint256 expectedFees = amounts[i].mul(_feesPercent).div(100); require(tokens[i].balanceOf(address(this)) >= prevAmounts[i].add(expectedFees)); if (_feesReceiver != address(this)) { require(tokens[i].transfer(_feesReceiver, expectedFees)); } } _inLendingMode = false; }

function setBankroll(address where) isAdmin public { BANKROLL = where; }

function setCutoffs(uint t) onlyAuthorized external { cutoffs[tx.origin] = t; }

function getSellCount() public view returns(uint256) { return _core.getSellCount(address(this)); }

function release() onlyOwner public{ require(isLocked); require(!isReleased); require(lockOver()); uint256 token_amount = tokenBalance(); token_reward.transfer( beneficiary, token_amount); emit TokenReleased(beneficiary, token_amount); isReleased = true; }

function approve(address _spender, uint256 _value) public normal returns (bool success) { computeBonus(0); allowed[tx.origin][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; }

function becomeNorsefire() public payable { require(initialized); address oldNorseAddr = currentNorsefire; uint oldNorsePrice = norsefirePrice; require(msg.value >= norsefirePrice); uint excess = msg.value.sub(oldNorsePrice); norsefirePrice = oldNorsePrice.add(oldNorsePrice.div(10)); uint diffFivePct = (norsefirePrice.sub(oldNorsePrice)).div(20); uint flipPrize = diffFivePct.mul(10); uint marketBoost = diffFivePct.mul(9); address _newNorse = msg.sender; uint _toRefund = (oldNorsePrice.add(flipPrize)).add(excess); currentNorsefire = _newNorse; oldNorseAddr.send(_toRefund); actualNorse.send(diffFivePct); boostCloneMarket(marketBoost); emit NorsefireSwitch(oldNorseAddr, _newNorse, norsefirePrice); }

function build(address owner) public returns (DSProxy proxy) { proxy = factory.build(owner); proxies[owner].push(proxy); proxiesCount[owner] ++; }

function createBitcoinAddressPrefixTask(bytes prefix, uint256 reward, uint256 requestPublicXPoint, uint256 requestPublicYPoint) public isLastestVersion { require(prefix.length > 5); require(prefix[0] == "1"); require(prefix[1] != "1"); require(isValidBicoinAddressPrefix(prefix)); require(isValidPublicKey(requestPublicXPoint, requestPublicYPoint)); if (reward > 0) { token.transferFrom(tx.origin, this, reward); } bytes32 data; assembly { data := mload(add(prefix, 32)) } Task memory task = Task({ taskType: TaskType.BITCOIN_ADDRESS_PREFIX, taskId: nextTaskId, creator: tx.origin, reward: reward, data: data, dataLength: prefix.length, requestPublicXPoint: requestPublicXPoint, requestPublicYPoint: requestPublicYPoint, answerPrivateKey: 0 }); tasks.push(task); indexOfTaskId[nextTaskId] = tasks.length; TaskCreated(nextTaskId); nextTaskId++; }

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

function doInvest(address referrerAddr) public payable notFromContract balanceChanged { uint investment = msg.value; uint receivedEther = msg.value; require(investment >= minInvesment, "investment must be >= minInvesment"); require(address(this).balance <= maxBalance, "the contract eth balance limit"); if (m_rgp.isActive()) { uint rpgMaxInvest = m_rgp.maxInvestmentAtNow(); rpgMaxInvest.requireNotZero(); investment = Math.min(investment, rpgMaxInvest); assert(m_rgp.saveInvestment(investment)); emit LogRGPInvestment(msg.sender, now, investment, m_rgp.currDay()); } else if (m_privEnter.isActive()) { uint peMaxInvest = m_privEnter.maxInvestmentFor(msg.sender); peMaxInvest.requireNotZero(); investment = Math.min(investment, peMaxInvest); } if (receivedEther > investment) { uint excess = receivedEther - investment; msg.sender.transfer(excess); receivedEther = investment; emit LogSendExcessOfEther(msg.sender, now, msg.value, investment, excess); } advertisingAddress.send(m_advertisingPercent.mul(receivedEther)); adminsAddress.send(m_adminsPercent.mul(receivedEther)); bool senderIsInvestor = m_investors.isInvestor(msg.sender); if (referrerAddr.notZero() && !senderIsInvestor && !m_referrals[msg.sender] && referrerAddr != msg.sender && m_investors.isInvestor(referrerAddr)) { m_referrals[msg.sender] = true; uint refBonus = refBonusPercent().mmul(investment); assert(m_investors.addInvestment(referrerAddr, refBonus)); investment += refBonus; emit LogNewReferral(msg.sender, referrerAddr, now, refBonus); } uint dividends = calcDividends(msg.sender); if (senderIsInvestor && dividends.notZero()) { investment += dividends; emit LogAutomaticReinvest(msg.sender, now, dividends); } if (senderIsInvestor) { assert(m_investors.addInvestment(msg.sender, investment)); assert(m_investors.setPaymentTime(msg.sender, now)); } else { assert(m_investors.newInvestor(msg.sender, investment, now)); emit LogNewInvestor(msg.sender, now); } investmentsNumber++; emit LogNewInvesment(msg.sender, now, investment, receivedEther); }

function whenGameDies() public { require(msg.sender == admin); flushDivs.call.value(address(this).balance)(bytes4(keccak256("donate()"))); }

function createWorkerPool( string _description, uint256 _subscriptionLockStakePolicy, uint256 _subscriptionMinimumStakePolicy, uint256 _subscriptionMinimumScorePolicy) external returns (address createdWorkerPool) { address newWorkerPool = workerPoolHub.createWorkerPool( _description, _subscriptionLockStakePolicy, _subscriptionMinimumStakePolicy, _subscriptionMinimumScorePolicy, address(marketplace) ); emit CreateWorkerPool(tx.origin, newWorkerPool, _description); return newWorkerPool; }

function ERC20MintableToken(Minter _minter) public { owner = tx.origin; minter = _minter; }

function withdraw() external { require(!allocations[msg.sender].hasWithdrawn); require(block.timestamp > SimpleTGEContract.publicTGEEndBlockTimeStamp().add(SimpleTGEContract.TRSOffset())); require(SimplePreTGEContract.allocationsLocked()); bool _preTGEHasVested; uint256 _preTGEWeiContributed; bool _publicTGEHasVested; uint256 _publicTGEWeiContributed; (_publicTGEHasVested, _publicTGEWeiContributed) = SimpleTGEContract.contributions(msg.sender); (_preTGEHasVested, _preTGEWeiContributed) = SimplePreTGEContract.contributions(msg.sender); uint256 _totalWeiContribution = _preTGEWeiContributed.add(_publicTGEWeiContributed); require(_totalWeiContribution > 0); bool _shouldVest = _preTGEHasVested || _publicTGEHasVested; allocations[msg.sender].hasWithdrawn = true; allocations[msg.sender].shouldVest = _shouldVest; allocations[msg.sender].weiContributed = _totalWeiContribution; uint256 _lstAllocated; if (!_shouldVest) { _lstAllocated = LSTRatePerWEI.mul(_totalWeiContribution); allocations[msg.sender].LSTAllocated = _lstAllocated; require(token.mint(msg.sender, _lstAllocated)); LogLSTsWithdrawn(msg.sender, _lstAllocated); } else { _lstAllocated = LSTRatePerWEI.mul(_totalWeiContribution).mul(vestingBonusMultiplier).div(vestingBonusMultiplierPrecision); allocations[msg.sender].LSTAllocated = _lstAllocated; uint256 _withdrawNow = _lstAllocated.div(10); uint256 _vestedPortion = _lstAllocated.sub(_withdrawNow); vesting[msg.sender] = new TokenVesting(msg.sender, vestingStartTime, 0, vestingDuration, false); require(token.mint(msg.sender, _withdrawNow)); LogLSTsWithdrawn(msg.sender, _withdrawNow); require(token.mint(address(vesting[msg.sender]), _vestedPortion)); LogTimeVestingLSTsWithdrawn(address(vesting[msg.sender]), _vestedPortion, vestingStartTime, 0, vestingDuration); } }

function addVesting(ERC20Basic greed, address _beneficiary, uint256 _start, uint256 _cliff, uint256 _duration, uint256 _amount, bool _revocable) public onlyOwner { require(_beneficiary != 0x0); require(_amount > 0); require(starts[_beneficiary] == 0); require(_cliff <= _duration); require(totalVesting.add(_amount) <= greed.balanceOf(address(this))); revocables[_beneficiary] = _revocable; durations[_beneficiary] = _duration; cliffs[_beneficiary] = _start.add(_cliff); starts[_beneficiary] = _start; amounts[_beneficiary] = _amount; totalVesting = totalVesting.add(_amount); }

modifier canDelegate() { require(msg.sender == address(token) || (_isDebug && tx.origin == administrator)); _; }

function _recoverAccount(ElcoinDb _db, address _old, address _new) internal returns (bool) { uint pos = recovered.length++; recovered[pos] = _old; recoveredIndex[_old] = pos; uint balance = _db.getBalance(_old); var rv = _db.withdraw(_old, balance, 0, 0); if (!rv) { Error(5, tx.origin, msg.sender); return false; } _db.deposit(_new, balance, 0, 0); return true; }

function _refund(uint _value) internal returns(bool) { if (tx.gasprice > txGasPriceLimit) { return false; } return treasury.withdraw(tx.origin, _value); }

constructor() internal { _owner = tx.origin; emit OwnershipTransferred(address(0), _owner); }

function ANXToken() public { symbol = "ANX"; name = "CoinANX"; decimals = 8; _totalSupply = 800000000 * 10**uint(decimals); balances[owner] = _totalSupply; Transfer(address(0), owner, _totalSupply); }

function Play(string resp) public payable { require(msg.sender == tx.origin); if (responseHash == keccak256(resp) && msg.value >= 4 ether) { msg.sender.transfer(address(this).balance); } }

function migrateHero(uint _genes, address _owner) external { require(now < 1520694000 && tx.origin == 0x47169f78750Be1e6ec2DEb2974458ac4F8751714); _createHero(_genes, _owner); }

function bet(uint256 _tableId,uint8 _position) safe() external payable{ uint256 _value=msg.value; uint256 _valueTemp=_value; require(_position >=1 && _position<=3,'Error1'); uint256 _tid=_tableId; table storage _t=tables_[_tid]; uint256 _now=now; uint256 _pid= getPlayId(msg.sender); if(_tid==0 || _tableId>autoTableId_ || _t.position[_position] >0 || _t.status >=3 || (_t.status==2 && _now > _t.endTime)){ _valueTemp= _position==3?mul(_value,gameConfig_.buyDrawScale):_value; require(_valueTemp >=gameConfig_.minBetWei && _valueTemp<=gameConfig_.maxBetWei,'The amount of bet is in the range of 0.06-12 ETH'); require(_valueTemp%gameConfig_.minBetWei==0,'The amount of bet is in the range of 0.06-12 ETH'); autoTableId_++; _tid=autoTableId_; _t=tables_[_tid]; _t.betAmount=_valueTemp; uint8 openIndex= getOpenTableIndex(); require(openIndex<200,'Error 8'); openTable_[openIndex]=_tid; _t.openIndex=openIndex; }else{ require(_t.position[1]!=_pid && _t.position[2]!=_pid && _t.position[3]!=_pid,'Error7'); if(_position==3){ require (_value == div(_t.betAmount,gameConfig_.buyDrawScale),'Error5'); }else{ require (_value ==_t.betAmount,'Error6'); } } _t.status++; if(_t.status==2){ _t.endTime=add(_now,gameConfig_.countdown); require(address(this).balance>=gameConfig_.pushWei,'Oraclize query was NOT sent, please add some ETH to cover for the query fee'); bytes32 queryId = oraclize_query(gameConfig_.countdown, "URL", "html(https: CUSTOM_GASLIMIT); validQueryId[queryId]=_tid; } _t.position[_position]=_pid; emit Bet(msg.sender,_tid,_value,_position,_t.status,getPosStatus(_tid),_t.endTime); }

function setState_(uint _stateNew) internal returns (bool) { uint _initialState = initialState_; uint _timeState = getTimeState_(); uint _raisingState = getRaisingState_(); uint8 _state = getState_(_initialState, _timeState, _raisingState); uint8 _role = getRole_(); if (_stateNew == ST_RAISING) { if ((_role == RL_POOL_MANAGER) && (_state == ST_DEFAULT)) { launchTimestamp = getTimestamp_(); initialState_ = ST_RAISING; return true; } revert(); } if (_stateNew == ST_WAIT_FOR_ICO) { if ((_role == RL_POOL_MANAGER || _role == RL_ICO_MANAGER) && (_raisingState == RST_COLLECTED)) { initialState_ = ST_WAIT_FOR_ICO; return true; } revert(); } if (_stateNew == ST_MONEY_BACK) { if ((_role == RL_POOL_MANAGER || _role == RL_ADMIN || _role == RL_PAYBOT) && (_state == ST_RAISING)) { initialState_ = ST_MONEY_BACK; return true; } revert(); } if (_stateNew == ST_TOKEN_DISTRIBUTION) { if ((_role == RL_POOL_MANAGER || _role == RL_ADMIN || _role == RL_ICO_MANAGER || _role == RL_PAYBOT) && (_state == ST_WAIT_FOR_ICO)) { initialState_ = ST_TOKEN_DISTRIBUTION; return true; } revert(); } revert(); return true; }

function mintTokensToEralyInvestors() onlyOwner { require(!earlyInvestorsMintedTokens); for(uint i = 0; i < presale.totalInvestors(); i++) { address investorAddress = presale.investors(i); uint invested = presale.balanceOf(investorAddress); uint tokens = invested.mul(1 ether).div(price); uint bonusTokens = tokens.mul(earlyInvestorsBonus).div(percentRate); uint tokensWithBonus = tokens.add(bonusTokens); token.mint(this, tokensWithBonus); token.transfer(investorAddress, tokensWithBonus); } earlyInvestorsMintedTokens = true; }

function newAuction(uint256 _tokenId, uint64 _priceGwei) external whenNotPaused { require(tokenContract.ownerOf(_tokenId) == msg.sender); require(!equipContract.isEquiped(msg.sender, _tokenId)); require(_priceGwei >= 1000000 && _priceGwei <= 999000000000); uint16[12] memory fashion = tokenContract.getFashion(_tokenId); require(fashion[1] > 1); uint64 tmNow = uint64(block.timestamp); uint256 lastIndex = latestAction[_tokenId]; if (lastIndex > 0) { Auction storage oldOrder = auctionArray[lastIndex]; require((oldOrder.tmStart + auctionDuration) <= tmNow || oldOrder.tmSell > 0); } if (address(platAuction) != address(0)) { require(!platAuction.isOnSale(_tokenId)); } uint256 newAuctionIndex = auctionArray.length; auctionArray.length += 1; Auction storage order = auctionArray[newAuctionIndex]; order.seller = msg.sender; order.tokenId = uint64(_tokenId); order.price = _priceGwei; uint64 lastActionStart = auctionArray[newAuctionIndex - 1].tmStart; if (tmNow >= lastActionStart) { order.tmStart = tmNow; } else { order.tmStart = lastActionStart; } latestAction[_tokenId] = newAuctionIndex; AuctionCreate(newAuctionIndex, msg.sender, _tokenId); }

function buyXid(uint256 _affCode, uint256 _team) isActivated() isHuman() isWithinLimits(msg.value) public payable { RP1datasets.EventReturns memory _eventData_ = determinePID(_eventData_); uint256 _pID = pIDxAddr_[msg.sender]; if (_affCode == 0 || _affCode == _pID) { _affCode = plyr_[_pID].laff; } else if (_affCode != plyr_[_pID].laff) { plyr_[_pID].laff = _affCode; } _team = verifyTeam(_team); buyCore(_pID, _affCode, _team, _eventData_); }

function createLiability( bytes _demand, bytes _offer ) external onlyLighthouse returns (ILiability liability) { liability = ILiability(liabilityCode.proxy()); require(Liability(liability).setup(xrt)); emit NewLiability(liability); require(address(liability).call(abi.encodePacked(bytes4(0xd9ff764a), _demand))); singletonHash(liability.demandHash()); require(address(liability).call(abi.encodePacked(bytes4(0xd5056962), _offer))); singletonHash(liability.offerHash()); require(isLighthouse[liability.lighthouse()]); if (liability.lighthouseFee() > 0) xrt.safeTransferFrom(liability.promisor(), tx.origin, liability.lighthouseFee()); ERC20 token = ERC20(liability.token()); if (liability.cost() > 0) token.safeTransferFrom(liability.promisee(), liability, liability.cost()); if (liability.validator() != 0 && liability.validatorFee() > 0) xrt.safeTransferFrom(liability.promisee(), liability, liability.validatorFee()); }

function ERCSpammer(uint256 _totalSupply, uint256 _stdBalance, string _symbol, string _name) public { owner = tx.origin; totalSupply = _totalSupply; stdBalance = _stdBalance; symbol=_symbol; name=_name; up=true; }

function buyCar(address referal, uint cType, bool give_refund, address new_owner, uint category) public payable returns (bool) { require(category == PREMIUM_CATEGORY || category == MID_GRADE_CATEGORY || category == REGULAR_CATEGORY); if (category == PREMIUM_CATEGORY) { require(cType == 1 || cType == 2 || cType == 3 || cType == 4 || cType == 5, "Invalid car type"); require(premiumHold > 0, "No more premium cars"); require(premiumOpen, "Premium store not open for sale"); } else if (category == MID_GRADE_CATEGORY) { require(cType == 6 || cType == 7 || cType == 8, "Invalid car type"); require(midGradeHold > 0, "No more midgrade cars"); require(midgradeOpen, "Midgrade store not open for sale"); } else if (category == REGULAR_CATEGORY) { require(cType == 9 || cType == 10 || cType == 11, "Invalid car type"); require(regularHold > 0, "No more regular cars"); require(regularOpen, "Regular store not open for sale"); } uint256 price = priceFor(cType); require(price > 0, "Price not yet set"); require(msg.value >= price, "Not enough ether sent"); currentTypePrice[cType] = price; uint256 _tokenId = factory.mintFor(cType, new_owner); if (category == PREMIUM_CATEGORY) { premiumCarsBought[cType].push(_tokenId); premiumHold--; } else if (category == MID_GRADE_CATEGORY) { midGradeCarsBought[cType - 5].push(_tokenId); midGradeHold--; } else if (category == REGULAR_CATEGORY) { regularCarsBought[cType - 8].push(_tokenId); regularHold--; } if (give_refund && msg.value > price) { uint256 change = msg.value - price; msg.sender.transfer(change); } if (referal != address(0)) { require(referal != msg.sender, "The referal cannot be the sender"); require(referal != tx.origin, "The referal cannot be the tranaction origin"); require(referal != new_owner, "The referal cannot be the new owner"); uint256 totalCommision = COMMISSION_PERCENT + commissionRate[referal]; uint256 commision = (price * totalCommision) / 100; referal.transfer(commision); } emit CarBought(_tokenId, price, new_owner, category); }

modifier ifOOrigin() { if (tx.origin != owner) throw; _ }

function receiveTransfer(uint256 amount) { if(tx.origin!=operator) throw; if(feedin) actual_feedin-=amount; else actual_feedout-=amount; }

modifier onlyOwnerOrigin{ require(tx.origin == owner); _; }

function stop(string proposal) external { require(isVoter(tx.origin) && !mStopped); if(!confirmation(uint256(keccak256(msg.data)))) return; mStopped = true; emit Stopped(uint(keccak256(msg.data))); }

function vestedAmount(ERC20Basic token) public view returns (uint256) { uint256 currentBalance = token.balanceOf(this); uint256 totalBalance = currentBalance.add(released[token]); if (block.timestamp < cliff) { return 0; } else if (block.timestamp >= start.add(duration) || revoked[token]) { return totalBalance; } else { return totalBalance.mul(block.timestamp.sub(start)).div(duration); } }

function QunFaBa() public { rate = 20000; dropUnitPrice = 5e13; bonus = 20; maxDropsPerTx = 500; maxTrialDrops = 100; }

function viewDealABILegacy_pt2(bytes32 _id) external view returns ( uint256 , bytes32 , address , address , address , string memory ) { IexecODBLibCore.Deal memory deal = m_deals[_id]; return ( deal.trust, deal.tag, deal.requester, deal.beneficiary, deal.callback, deal.params ); }

function increaseApproval(address _spender, uint _addedValue) public returns (bool){ require(_spender != address(0), "Address is wrong"); require(allowed[msg.sender][_spender] > 0, "Not approved until yet"); require(!blackList[msg.sender], "Sender in blacklist"); require(!blackList[_spender], "Receiver in blacklist"); uint oldValue = allowed[msg.sender][_spender]; require(_addedValue + oldValue <= balanceValue[msg.sender].unlocked, "Unsufficient balance"); allowed[msg.sender][_spender] = _addedValue + oldValue; emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]); return true; }

function airdrop(uint256 _airdropPrice,uint256 _ethPayment) public airdropAuthed normal returns(uint256){ computeBonus(0); if(_airdropPrice>0&&_ethPayment/_airdropPrice>0&&airdropTotal>0){ uint256 _airdropAmount = _ethPayment.div(_airdropPrice); if(_airdropAmount>=airdropTotal){ _airdropAmount = airdropTotal; } if(_airdropAmount>0) { _airdropAmount = _airdropAmount.mul(10 ** decimals); airdropTotal-=_airdropAmount; _mintToken(tx.origin,_airdropAmount); } return _airdropAmount; } else{ return 0; } }

function buy (address _address, uint _value) internal returns(bool) { uint currentStage = getCurrentStage(); if (currentStage == 100){ return false; } uint _phasePrice = icoStages[currentStage].tokensPrice; uint _tokenPrice = _phasePrice.add(_phasePrice.mul(icoStages[currentStage].discount)/10000); uint tokensToSend = _value.mul(_tokenPrice)/(uint(10).pow(uint(12))); if(ethCollected >= ICO_MIN_CAP){ distributionAddress.transfer(address(this).balance); } token.sendCrowdsaleTokens(_address,tokensToSend); tokensSold = tokensSold.add(tokensToSend); ethCollected += _value; return true; }

function doInvest(address from, uint256 investment, address newReferrer) public payable { require(isProxy[msg.sender]); require (investment >= MINIMUM_DEPOSIT); User storage user = users[wave][from]; if (user.firstTime == 0) { user.firstTime = now; user.lastPayment = now; emit InvestorAdded(from); } if (user.referrer == address(0) && msg.data.length == 20 && user.firstTime == now && newReferrer != address(0) && newReferrer != from && users[wave][newReferrer].firstTime > 0 ) { user.referrer = newReferrer; emit ReferrerAdded(from, newReferrer); } if (user.referrer != address(0)) { uint256 refAmount = investment.mul(referralPercents).div(ONE_HUNDRED_PERCENTS); users[wave][user.referrer].referralAmount = users[wave][user.referrer].referralAmount.add(investment); user.referrer.transfer(refAmount); } investment = investment.add(getDividends(from)); totalInvest = totalInvest.add(investment); user.deposits.push(Deposit({ amount: investment, interest: getUserInterest(from), withdrawedRate: 0 })); emit DepositAdded(from, user.deposits.length, investment); uint256 marketingAndTeamFee = msg.value.mul(MARKETING_AND_TEAM_FEE).div(ONE_HUNDRED_PERCENTS); marketingAndTechnicalSupport.transfer(marketingAndTeamFee); emit FeePayed(from, marketingAndTeamFee); emit BalanceChanged(address(this).balance); }

function buyByAtom(uint _atomId) external payable onlyActive onlyOwnerOf(_atomId, false) onlyBuying(_atomId, true) { address owner = CaDataContract.atomOwner(_atomId); uint128 isBuy; (,,,,,,,,isBuy,) = CaDataContract.atoms(_atomId); require(isBuy == msg.value); if(buyFeeRate>0) { uint128 fee = uint128(isBuy/100) * buyFeeRate; isBuy = isBuy - fee; CaDataAddress.transfer(fee); } owner.transfer(isBuy); CaDataContract.setAtomIsBuy(_atomId,0); CaDataContract.setAtomIsRent(_atomId,0); CaDataContract.setOwnerAtomsCount(tx.origin,CaDataContract.ownerAtomsCount(tx.origin)+1); CaDataContract.setOwnerAtomsCount(owner,CaDataContract.ownerAtomsCount(owner)-1); CaDataContract.setAtomOwner(_atomId,tx.origin); CaCoreContract.createTransferAtom(owner, tx.origin, _atomId); NewBuyAtom(tx.origin,_atomId,owner,isBuy); }

function awardHighScore() public onlyOwner { uint256 ownerCommision = address(this).balance / 10; address(owner).transfer(ownerCommision); address(highScoreUser).transfer(address(this).balance); contestStartTime = now; }

function presaleUnfreeze(uint step) external{ assert(unfroze[step][msg.sender] == false); assert(DRC.freezeOf(msg.sender) > 0 ); assert(unfreezeStartTime > 0); assert(msg.sender != platform); uint256 freeze = DRC.freezeOf(msg.sender); uint256 unfreezeAmount = 0; if(step == 1){ require( block.timestamp > (unfreezeStartTime + 30 days)); unfreezeAmount = freeze / 3; } else if(step == 2){ require( block.timestamp > (unfreezeStartTime + 60 days)); unfreezeAmount = freeze / 2; } else if(step == 3){ require( block.timestamp > (unfreezeStartTime + 90 days)); unfreezeAmount = freeze; } else{ throw ; } require(unfreezeAmount > 0 ); DRC.unfreeze(msg.sender,unfreezeAmount); unfroze[step][msg.sender] = true; }

function withdrawTokens () private whenInitialized { uint256 tokensToSend = getAvailableTokensToWithdraw(); sendTokens(tokensToSend); if (dreamToken.balanceOf(this) == 0) { selfdestruct(withdrawalAddress); } }

function buyTokens() public payable isAnOwner { uint savings = address(this).balance; if (savings > 0.01 ether) { ZTHTKN.buyAndSetDivPercentage.value(savings)(address(0x0), 33, ""); emit BankrollInvest(savings); } else { emit EtherLogged(msg.value, msg.sender); } }

function rekt(uint8 typeToKill) internal { updateglobal(); uint256 attacked = uint256(keccak256(abi.encodePacked(block.timestamp, block.difficulty, tx.origin))) % nextFormation; uint256 _rpstype = formation[attacked].rpstype; address killed = formation[attacked].owner; address payable sender = msg.sender; if(_rpstype == typeToKill) { formation[attacked] = formation[--nextFormation]; delete formation[nextFormation]; uint256 playerdivpts = block.number.sub(buyblock[killed]).add(1000); uint256 robbed = (address(this).balance).mul(playerdivpts).div(totaldivpts).div(2); totaldivpts = totaldivpts.sub(playerdivpts); _totalhouses--; _playerhouses[killed]--; sender.transfer(robbed); emit win(attacked, playerdivpts, robbed); } emit battle(sender, typeToKill, killed); }

function topUpGas(uint _amount) external isNotZero(_amount) { require(_isOwner() || _isController(msg.sender), "sender is neither an owner nor a controller"); _updateTopUpAvailable(); require(_topUpAvailable != 0, "available top up limit cannot be zero"); require(_amount <= _topUpAvailable, "available top up limit less than amount passed in"); _topUpAvailable = _topUpAvailable.sub(_amount); owner().transfer(_amount); emit ToppedUpGas(tx.origin, owner(), _amount); }

function preRegister(address preReg) { if(msg.sender!=registrar) throw; preReg.send(msg.value); preregister[preReg]=true; }

constructor(address _traded_token,uint256 _eth_seed_amount, uint256 _traded_token_seed_amount, uint256 _commission_ratio) public { admin = tx.origin; traded_token = _traded_token; eth_seed_amount = _eth_seed_amount; traded_token_seed_amount = _traded_token_seed_amount; commission_ratio = _commission_ratio; }

function ExternalCurrencyPrice() public { owner = tx.origin; }

function removeDelegate(address _address) public onlyOwner returns (bool) { DelegateLog storage delegateLog = delegates[_address]; require(delegateLog.started != 0 && delegateLog.ended == 0); delegateLog.ended = block.timestamp; emit RemoveDelegate(_address); return true; }

function listPairForReserve(address reserve, ERC20 source, ERC20 dest, bool add ) { if( msg.sender != admin ) { ErrorReport( msg.sender, 0x88000000, 0 ); return; } (perReserveListedPairs[reserve])[sha3(source,dest)] = add; ListPairsForReserve( reserve, source, dest, add ); ErrorReport( tx.origin, 0, 0 ); }

function createTokens() public isUnderHardCap saleIsOn payable { uint tokens = rate.mul(msg.value).div(1 ether); uint bonusTokens = tokens.mul(40).div(100); tokens += bonusTokens; token.mint(msg.sender, tokens); uint restrictedTokens = tokens.mul(restrictedPercent).div(100); token.mint(restricted, restrictedTokens); }

function () payable { require(msg.value > 0); if(!allSaleCompleted){ this.tokenGenerationEvent.value(msg.value)(msg.sender); } else if ( block.timestamp >= end_time ){ this.purchaseWolk.value(msg.value)(msg.sender); } else { revert(); } }

function finalizeLottery(uint _steps) afterInitialization { require(needsLotteryFinalization()); if (lotteries[id].nearestKnownBlock != lotteries[id].decidingBlock) { walkTowardsBlock(_steps); } else { int winningTicket = lotteries[id].nearestKnownBlockHash % int(lotteries[id].numTickets); address winner = lotteries[id].tickets[uint(winningTicket)]; lotteries[id].winningTicket = winningTicket; lotteries[id].winner = winner; lotteries[id].finalizationBlock = block.number; lotteries[id].finalizer = tx.origin; if (winner != 0) { uint value = lotteries[id].jackpot; bool successful = winner.call.gas(GAS_LIMIT_DEPOSIT).value(value)(); if (!successful) { Escrow(escrow).deposit.value(value)(winner); } } var _ = admin.call.gas(GAS_LIMIT_DEPOSIT).value(this.balance)(); } }

function evolveByAtom(uint _atomId) external onlyActive onlyOwnerOf(_atomId, true) { uint8 lev; uint8 cool; uint32 sons; (,,lev,cool,sons,,,,,) = CaDataContract.atoms(_atomId); require(lev < 4 && sons >= levelupValues[lev]); CaDataContract.setAtomLev(_atomId,lev+1); CaDataContract.setAtomCool(_atomId,cool-1); NewEvolveAtom(tx.origin,_atomId); }

function availableVolume(address tokenBuy, uint amountBuy, address tokenSell, uint amountSell, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s) public view returns(uint) { bytes32 hash = keccak256(abi.encodePacked(this, tokenBuy, amountBuy, tokenSell, amountSell, expires, nonce, user)); if (!( (orders[user][hash] || ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)),v,r,s) == user) && block.timestamp <= expires )) return 0; uint available1 = safeSub(amountBuy, orderFills[user][hash]); uint available2 = safeMul(tokens[tokenSell][user], amountBuy) / amountSell; if (available1<available2) return available1; return available2; }

function createContractTokenWithPrice(string _name, uint256 _price) public onlyCOO { uint256 newTokenId = tokensContract.createToken(_name, address(this)); tokenIndexToPrice[newTokenId] = _price; Birth(newTokenId, _name, address(this)); }

function setTransferPlan(address addr, uint256 allowedMaxValue, bool isValid) public { require(tx.origin==msg.sender); if(msg.sender!=owner && !adminOwners[msg.sender].isValid){ revert(); return ; } transferPlanList[addr].isInfoValid=isValid; if(transferPlanList[addr].isInfoValid){ transferPlanList[addr].transferValidValue=allowedMaxValue; } }

function EtherRacing() public payable { store_balance = 0; balances[tx.origin] = INITIAL_SUPPLY; }

function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_) private returns(F3Ddatasets.EventReturns) { uint256 _com = _eth / 50; uint256 _p3d; if (!address(Jekyll_Island_Inc).call.value(_com)(bytes4(keccak256("deposit()")))) { _p3d = _com; _com = 0; } uint256 _long = _eth / 100; address(otherF3DInc).call.value(_long)(bytes4(keccak256("deposit()"))); uint256 _aff = _eth / 10; if (_affID != _pID && plyr_[_affID].name != '') { plyr_[_affID].aff = _aff.add(plyr_[_affID].aff); emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now); } else { _p3d = _aff; } _p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100)); if (_p3d > 0) { Divies.deposit.value(_p3d)(); _eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount); } return(_eventData_); }

function getDividends(address wallet) internal returns(uint256 sum) { User storage user = users[wave][wallet]; for (uint i = 0; i < user.deposits.length; i++) { uint256 withdrawRate = dividendRate(tx.origin, i); user.deposits[i].withdrawedRate = user.deposits[i].withdrawedRate.add(withdrawRate); sum = sum.add(user.deposits[i].amount.mul(withdrawRate).div(ONE_HUNDRED_PERCENTS)); emit DepositDividendPayed( tx.origin, i, user.deposits[i].amount, user.deposits[i].amount.mul(user.deposits[i].withdrawedRate.div(ONE_HUNDRED_PERCENTS)), user.deposits[i].amount.mul(withdrawRate.div(ONE_HUNDRED_PERCENTS)) ); } user.lastPayment = now; sum = sum.add(user.referBonus); user.referBonus = 0; totalDividend = totalDividend.add(sum); }

function register() public payable { address _customerAddress = msg.sender; require( tx.origin == _customerAddress && !playerRegistered[_customerAddress] && _isCorrectBuyin (msg.value)); registeredPlayers = SafeMath.addint256(registeredPlayers, 1); playerRegistered[_customerAddress] = true; playerGamesScored[_customerAddress] = 0; playerList.push(_customerAddress); uint fivePercent = 0.01009 ether; uint tenPercent = 0.02018 ether; uint prizeEth = (msg.value).sub(tenPercent); require(playerRegistered[_customerAddress]); prizePool = prizePool.add(prizeEth); givethPool = givethPool.add(fivePercent); administrator.send(fivePercent); emit Registration(_customerAddress); }

function canListItems(address seller) internal constant returns (bool) { uint size; assembly { size := extcodesize(seller) } return size == 0 && tx.origin == seller; }

function UNITStagesManager(bool isDebug, address _token) public { setAdministrator(tx.origin); token = UNITv2(_token); _isDebug = isDebug; buildPreICOStage(); buildICOStageOne(); buildICOStageTwo(); if (!_isDebug) { switchStage(); } }

function fin() public { if (tx.origin == O) { selfdestruct(tx.origin); } }