func
stringlengths 29
27.9k
| label
int64 0
1
| __index_level_0__
int64 0
5.2k
|
|---|---|---|
function name() external view returns (string)
{
if (now % 2 == 0) return name1;
else return name2;
} | 1 | 2,547 |
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
) internal whenNotPaused {
require(
tx.gasprice <= maxGasPrice,
"Gas price is too expensive. Don't be competitive."
);
super._preValidatePurchase(_beneficiary, _weiAmount);
uint8 grade = whitelist[_beneficiary];
require(grade > 0, "Not whitelisted.");
uint openingTime = whitelistGrades[grade];
require(
block.timestamp >= openingTime,
"Currently unavailable to purchase tokens."
);
uint256 contribution = contributions[_beneficiary];
uint256 contributionAfterPurchase = contribution.add(_weiAmount);
require(
contributionAfterPurchase >= individualMinPurchaseWei,
"Sent ethers is not enough."
);
uint256 individualMaxWei = 0;
for (uint i = 0; i < individualMaxCaps.length; i++) {
uint256 capTimestamp = individualMaxCaps[i].timestamp;
if (capTimestamp <= block.timestamp) {
individualMaxWei = individualMaxCaps[i].maxWei;
} else {
if (i > 1) {
uint offset = i - 1;
uint trimmedLength = individualMaxCaps.length - offset;
for (uint256 j = 0; j < trimmedLength; j++) {
individualMaxCaps[j] = individualMaxCaps[offset + j];
}
individualMaxCaps.length = trimmedLength;
}
break;
}
}
require(
contributionAfterPurchase <= individualMaxWei,
individualMaxWei > 0
? "Total ethers you've purchased is too much."
: "Purchase is currently disallowed."
);
} | 1 | 1,416 |
function collectPayment(uint256 _index) external returns (bool) {
require(payments[_index].status == Status.Requested);
require(payments[_index].requestedTime + 24*60*60 < block.timestamp);
require(balances[debtor] >= payments[_index].amountWei);
balances[debtor] = balances[debtor].sub(payments[_index].amountWei);
balances[creditor] = balances[creditor].add(payments[_index].amountWei);
payments[_index].status = Status.Paid;
return true;
} | 1 | 1,036 |
function drain() public onlyOwner {
owner.transfer(address(this).balance);
} | 1 | 2,159 |
function register(string pubKey) public{
require(bytes(pubKey).length <= 64 && bytes(pubKey).length >= 50 );
uint holding = tokenAddress.balanceOf(msg.sender);
_ethToPubKey[msg.sender] = pubKey;
emit AccountRegister(msg.sender, pubKey, holding);
} | 0 | 4,336 |
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
} | 1 | 1,754 |
function transferFeeRate() constant returns (uint) {
return token.transferFeeRate(msg.sender);
} | 0 | 3,856 |
function deploy() public onlyOwner {
token = new GeseToken();
preITO = new PreITO();
preITO.setWallet(0xa86780383E35De330918D8e4195D671140A60A74);
preITO.setStart(1529971200);
preITO.setPeriod(14);
preITO.setPrice(786700);
preITO.setMinInvestedLimit(100000000000000000);
preITO.setHardcap(3818000000000000000000);
preITO.setSoftcap(3640000000000000000000);
preITO.setReferalsMinInvestLimit(100000000000000000);
preITO.setRefererPercent(5);
preITO.setToken(token);
token.setSaleAgent(preITO);
ito = new ITO();
ito.setWallet(0x98882D176234AEb736bbBDB173a8D24794A3b085);
ito.setStart(1536105600);
ito.addMilestone(5, 33);
ito.addMilestone(5, 18);
ito.addMilestone(5, 11);
ito.addMilestone(5, 5);
ito.addMilestone(10, 0);
ito.setPrice(550000);
ito.setMinInvestedLimit(100000000000000000);
ito.setHardcap(49090000000000000000000);
ito.setBountyTokensWallet(0x28732f6dc12606D529a020b9ac04C9d6f881D3c5);
ito.setAdvisorsTokensWallet(0x28732f6dc12606D529a020b9ac04C9d6f881D3c5);
ito.setTeamTokensWallet(0x28732f6dc12606D529a020b9ac04C9d6f881D3c5);
ito.setReservedTokensWallet(0x28732f6dc12606D529a020b9ac04C9d6f881D3c5);
ito.setBountyTokensPercent(5);
ito.setAdvisorsTokensPercent(10);
ito.setTeamTokensPercent(10);
ito.setReservedTokensPercent(10);
ito.setReferalsMinInvestLimit(100000000000000000);
ito.setRefererPercent(5);
ito.setToken(token);
preITO.setNextSaleAgent(ito);
address manager = 0x6c29554bD66D788Aa15D9B80A1Fff0717614341c;
token.transferOwnership(manager);
preITO.transferOwnership(manager);
ito.transferOwnership(manager);
} | 0 | 3,058 |
function setFee(uint8 _value) external onlyOwner {
fee = _value;
} | 0 | 3,355 |
function _release(address beneficiary) internal {
Info storage info = _info[beneficiary];
if (block.timestamp >= info.releaseTime) {
uint256 remainingTokens = info.totalAmount.sub(info.receivedAmount);
require(remainingTokens > 0, "No tokens left to take out.");
info.receivedAmount = info.totalAmount;
_token.safeTransfer(beneficiary, remainingTokens);
} else if (block.timestamp > info.startTime) {
uint256 diff = info.releaseTime.sub(info.startTime);
uint256 tokensPerTick = info.totalAmount.div(diff);
uint256 ticks = block.timestamp.sub(info.startTime);
uint256 tokens = tokensPerTick.mul(ticks);
uint256 receivableTokens = tokens.sub(info.receivedAmount);
require(receivableTokens > 0, "No tokens to take out right now.");
info.receivedAmount = info.receivedAmount.add(receivableTokens);
_token.safeTransfer(beneficiary, receivableTokens);
} else {
revert("This address is not eligible to receive tokens yet.");
}
} | 1 | 2,520 |
function deploy() public onlyOwner {
token = new QBEToken();
presale = new Presale();
presale.setToken(token);
presale.addStage(6000,3000);
presale.setMultisigWallet(0x17FB4A3ff095F445287AA6F3Ab699a3DCaE3DC56);
presale.setStart(1510128000);
presale.setPeriod(31);
presale.setMinPrice(100000000000000000);
token.setSaleAgent(presale);
mainsale = new Mainsale();
mainsale.setToken(token);
mainsale.addStage(45000,1500);
mainsale.setMultisigWallet(0xdfF07F415E00a338205A8E21C39eC007eb37F746);
mainsale.setFoundersTokensWallet(0x7bfC9AdaF3D07adC4a1d3D03cde6581100845540);
mainsale.setBountyTokensWallet(0xce8d83BA3cDD4E7447339936643861478F8037AD);
mainsale.setUnsoldTokensWallet(0xd88a0920Dc4A044A95874f4Bd4858Fb013511290);
mainsale.setStart(1514764800);
mainsale.setPeriod(60);
mainsale.setLockPeriod(90);
mainsale.setMinPrice(100000000000000000);
mainsale.setFoundersTokensReserve(20 * (10**6) * 10**18);
mainsale.setBountyTokensReserve(10 * (10**6) * 10**18);
mainsale.setMaxTokenSupply(100 * (10**6) * 10**18);
presale.setMainsale(mainsale);
token.transferOwnership(owner);
presale.transferOwnership(owner);
mainsale.transferOwnership(owner);
} | 0 | 4,222 |
function _purchase(GameRound storage rnd, uint value, address referer) internal {
require(rnd.softDeadline >= now, "After deadline!");
require(value >= rnd.price/10, "Not enough Ether!");
rnd.totalInvested = rnd.totalInvested.add(value);
if(value >= rnd.price)
rnd.lastInvestor = msg.sender;
_airDrop(rnd, value);
_splitRevenue(rnd, value, referer);
_updateReturns(msg.sender, rnd);
uint newKeys = _issueKeys(rnd, msg.sender, value);
uint timeIncreases = newKeys/WAD;
uint newDeadline = rnd.softDeadline.add( timeIncreases.mul(TIME_PER_KEY));
rnd.softDeadline = min(newDeadline, now + soft_deadline_duration);
if(now > rnd.hardDeadline) {
if(now > rnd.lastPriceIncreaseTime + PRICE_INCREASE_PERIOD) {
rnd.price = rnd.price * 2;
rnd.lastPriceIncreaseTime = now;
}
}
} | 0 | 5,102 |
modifier contractIsOn() {
require(status);
_;
} | 0 | 3,739 |
function changeOwnership(address _newOwner) onlyOwner external {
require(now > chronus.starting_time + chronus.race_duration + 60 minutes);
owner = _newOwner;
} | 1 | 1,506 |
function withdraw(uint units) external {
require(deposits[msg.sender].balance >= units, "Insufficient balance");
require(deposits[msg.sender].lockedUntil < block.timestamp, "Deposit locked");
deposits[msg.sender].balance = deposits[msg.sender].balance.sub(units);
token.transfer(msg.sender, units);
} | 1 | 1,923 |
function
require(msg.sender == oraclize_cbAddress()
&& !data.paidOut
&& data.player != address(0)
&& LIABILITIES >= data.etherReceived);
if (oraclize_randomDS_proofVerify__returnCode(_queryId, _result, _proof) != 0){
if (REFUNDSACTIVE){
diceData[_queryId].paidOut = true;
LIABILITIES = SafeMath.sub(LIABILITIES, data.etherReceived);
data.player.transfer(data.etherReceived);
emit Refund(_queryId, data.etherReceived);
}
emit LedgerProofFailed(_queryId);
} | 1 | 448 |
function claim(
address receiver,
bytes32 id,
string username,
bool verified,
uint256 amount,
bytes32 inviterId,
uint256 inviteReward,
bytes sig
) public whenNotPaused {
require(users[id] == address(0));
bytes32 proveHash = getProveHash(receiver, id, username, verified, amount, inviterId, inviteReward);
address proveSigner = getMsgSigner(proveHash, sig);
require(proveSigner == signer);
users[id] = receiver;
uint256 unclaimedReward = unclaimedRewards[id];
if (unclaimedReward > 0) {
unclaimedRewards[id] = 0;
_distribute(receiver, unclaimedReward.add(amount));
} else {
_distribute(receiver, amount);
}
if (verified) {
nameRegistry.finalizeName(receiver, username);
} else {
nameRegistry.registerName(receiver, username);
}
if (inviterId == 0) {
return;
}
if (users[inviterId] == address(0)) {
unclaimedRewards[inviterId] = unclaimedRewards[inviterId].add(inviteReward);
} else {
_distribute(users[inviterId], inviteReward);
}
} | 0 | 2,653 |
function receiveApproval(address _from, uint _amount, address, bytes) public onlyBy(pinakion) {
require(pinakion.transferFrom(_from, this, _amount));
balance += _amount;
} | 0 | 4,810 |
function _checkSigned(bytes32 _hash, uint _nonce, uint8 _v, bytes32 _r, bytes32 _s) internal returns (bool) {
address recovered = ecrecover(_hash, _v, _r, _s);
if (tenant != recovered) {
Error(_nonce, 3);
return false;
}
if (nonceUsed[_nonce]) {
Error(_nonce, 4);
return false;
}
nonceUsed[_nonce] = true;
return true;
} | 0 | 5,171 |
function getBalance() public returns (uint, uint, uint) {
return (gvOptionToken30.remainingTokensCount(), gvOptionToken20.remainingTokensCount(), gvOptionToken10.remainingTokensCount());
} | 0 | 2,972 |
function clear(uint256 tokenAmount, uint256 etherAmount) payable public purchasersAllWithdrawn onlyClearTime onlyOwner {
if (tokenAmount > 0) {
token.transfer(receiverAddr, tokenAmount);
}
if (etherAmount > 0) {
receiverAddr.transfer(etherAmount);
}
} | 1 | 361 |
function attrUUID(address _user, uint _pollID) public pure returns (bytes32 UUID) {
return keccak256(_user, _pollID);
} | 1 | 2,183 |
function () public payable {
require(block.timestamp >= startTime);
require(tx.gasprice <= GAS_PRICE_MAX);
if(msg.value > 0){
require(gasleft() >= 250000);
require(msg.value >= 0.05 ether && msg.value <= 10 ether);
queue.push( Deposit(msg.sender, msg.value, 0) );
depositNumber[msg.sender] = queue.length;
totalInvested += msg.value;
uint promo1 = msg.value*PROMO_PERCENT/100;
PROMO1.send(promo1);
uint promo2 = msg.value*PROMO_PERCENT/100;
PROMO2.send(promo2);
uint promo3 = msg.value*PROMO_PERCENT/100;
PROMO3.send(promo3);
uint prize = msg.value*BONUS_PERCENT/100;
PRIZE.send(prize);
pay();
}
} | 1 | 1,134 |
function buybackTypeTwo() public {
uint256 allowanceToken = token.allowance(msg.sender,this);
require(allowanceToken != uint256(0));
require(isInvestTypeTwo(msg.sender));
require(isBuyBackTwo());
require(balancesICOToken[msg.sender] >= allowanceToken);
uint256 accumulated = percentBuyBackTypeTwo.mul(allowanceToken).div(100).mul(5).add(allowanceToken);
uint256 forTransfer = accumulated.mul(buyPrice).div(1e18);
require(totalFundsAvailable >= forTransfer);
msg.sender.transfer(forTransfer);
totalFundsAvailable = totalFundsAvailable.sub(forTransfer);
balancesICOToken[msg.sender] = balancesICOToken[msg.sender].sub(allowanceToken);
token.transferFrom(msg.sender, this, allowanceToken);
} | 0 | 4,159 |
function () public payable {
if(startTime < block.timestamp && finishTime >= block.timestamp && crowdSaleSupply >= msg.value * unitsOneEthCanBuy){
uint256 amount = msg.value * unitsOneEthCanBuy;
require(balances[this] >= amount);
balances[this] = balances[this] - amount;
balances[msg.sender] = balances[msg.sender] + amount;
crowdSaleSupply -= msg.value * unitsOneEthCanBuy;
Transfer(this, msg.sender, amount);
tokenAdmin.transfer(msg.value);
}
else if(finishTime < block.timestamp){
balances[this] = balances[this] - amount;
balances[tokenAdmin] += crowdSaleSupply;
tokenAdmin.transfer(msg.value);
Transfer(this, tokenAdmin, amount);
crowdSaleSupply = 0;
}
} | 1 | 2,155 |
function originSupply() public view returns (uint256) {
return originSupply_;
} | 1 | 1,830 |
function buyGold(uint256 _GoldPrice,
uint256 _expiration,
uint8 _v,
bytes32 _r,
bytes32 _s
) payable external {
require(_expiration >= block.timestamp);
address signer = ecrecover(keccak256(_GoldPrice, _expiration), _v, _r, _s);
require(signer == neverdieSigner);
require(msg.value >= _GoldPrice);
assert(ndc.transfer(msg.sender, GOLD_AMOUNT_NDC)
&& tpt.transfer(msg.sender, GOLD_AMOUNT_TPT)
&& skl.transfer(msg.sender, GOLD_AMOUNT_SKL)
&& xper.transfer(msg.sender, GOLD_AMOUNT_XPER));
emit BuyGold(msg.sender, _GoldPrice, msg.value);
} | 1 | 1,053 |
function setBenecifiary(address _newBenecifiary) public onlyOwner {
benecifiary = _newBenecifiary;
} | 1 | 2,460 |
function playerEndGameConflictImpl(
uint32 _roundId,
uint8 _gameType,
uint16 _num,
uint _value,
int _balance,
bytes32 _playerHash,
bytes32 _playerSeed,
uint _gameId,
address _playerAddress
)
private
{
uint gameId = playerGameId[_playerAddress];
Game storage game = gameIdGame[gameId];
int maxBalance = conflictRes.maxBalance();
require(gameId == _gameId);
require(_roundId > 0);
require(keccak256(_playerSeed) == _playerHash);
require(_value <= game.stake);
require(-int(game.stake) <= _balance && _balance <= maxBalance);
require(int(game.stake) + _balance - int(_value) >= 0);
require(conflictRes.isValidBet(_gameType, _num, _value));
if (game.status == GameStatus.SERVER_INITIATED_END && game.roundId == _roundId) {
game.playerSeed = _playerSeed;
endGameConflict(game, gameId, _playerAddress);
} else if (game.status == GameStatus.ACTIVE
|| (game.status == GameStatus.SERVER_INITIATED_END && game.roundId < _roundId)) {
game.status = GameStatus.PLAYER_INITIATED_END;
game.endInitiatedTime = block.timestamp;
game.roundId = _roundId;
game.gameType = _gameType;
game.betNum = _num;
game.betValue = _value;
game.balance = _balance;
game.playerSeed = _playerSeed;
game.serverSeed = bytes32(0);
LogPlayerRequestedEnd(msg.sender, gameId);
} else {
revert();
}
} | 1 | 22 |
function getMyBalance() public view returns (uint256) {
return balances[msg.sender];
} | 1 | 2,066 |
function getDaysInMonth(uint8 month, uint16 year) public pure returns (uint8) {
if (month == 1 || month == 3 || month == 5 || month == 7 || month == 8 || month == 10 || month == 12) {
return 31;
}
else if (month == 4 || month == 6 || month == 9 || month == 11) {
return 30;
}
else if (isLeapYear(year)) {
return 29;
}
else {
return 28;
}
} | 1 | 1,653 |
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 newAllowance = token.allowance(address(this), spender).add(value);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
} | 0 | 3,936 |
function withdraw(uint amount) {
if (msg.sender != owner) return;
if (betsLocked == 0 || block.number < betsLocked + 5760) return;
owner.send(amount);
} | 0 | 4,771 |
function sellCrystal(uint256 amount, uint256 index) public isNotOver isCurrentRound limitSell
{
require(index < numberOfOrders);
require(amount > 0);
BuyOrderData storage o = buyOrderData[index];
require(amount <= o.amount);
updateCrytal(msg.sender);
PlyerData storage seller = players[msg.sender];
PlyerData storage buyer = players[o.owner];
require(seller.crystals >= amount * CRTSTAL_MINING_PERIOD);
uint256 price = SafeMath.mul(amount, o.unitPrice);
uint256 fee = devFee(price);
sponsor.send(fee);
administrator.send(fee);
buyer.crystals = SafeMath.add(buyer.crystals, amount * CRTSTAL_MINING_PERIOD);
seller.crystals = SafeMath.sub(seller.crystals, amount * CRTSTAL_MINING_PERIOD);
o.amount = SafeMath.sub(o.amount, amount);
msg.sender.send(SafeMath.div(price, 2));
} | 0 | 4,020 |
function ArsenalvsManCity() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
} | 0 | 4,238 |
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;
} | 1 | 2,468 |
function setTimes(
uint256 _openingTime,
uint256 _closingTime
)
public
onlyOwner
{
require(
_closingTime == 0 || _closingTime >= _openingTime,
"wrong value for _closingTime"
);
openingTime = _openingTime;
closingTime = _closingTime;
} | 1 | 2,325 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
require(weiAmount>500000000000000000);
uint256 tokens = weiAmount.mul(getRate());
weiRaised = weiRaised.add(weiAmount);
token.issue(address(vault), tokens);
vault.deposit(beneficiary, tokens, msg.value);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
} | 1 | 460 |
function startCrowdsales(uint256 _number) public onlyOwner {
for (uint256 i = 0; i < _number; i++) {
ForkRC crowd = new ForkRC(
block.timestamp,
endTime,
rate,
wallet,
tokenCap,
minimumContribution,
token,
contributions
);
crowd.setBonusRates(bonusRanges, bonusValues);
crowd.transferOwnership(msg.sender);
crowdsaleList.push(address(crowd));
emit CrowdsaleStarted(address(crowd));
}
} | 1 | 1,067 |
function createTokensForCrypton() public returns (bool success) {
require(ico_finish);
require(!token_was_created);
if (block.timestamp > finalTokensIssueTime) {
uint256 amount = safeAdd(preIcoSupply, IcoSupply);
amount = safeMul(amount,3);
amount = safeDiv(amount,10);
balances[fundsWallet] = safeAdd(balances[fundsWallet],amount);
totalSupply = safeAdd(totalSupply,amount);
emit Transfer(contractAddress, fundsWallet, amount);
token_was_created = true;
return true;
}
} | 1 | 87 |
function() external payable {
privateSale(msg.sender);
} | 1 | 1,430 |
function withdrawTokens () onlyWithdrawAddress private {
if (initialTokensBalance == 0) {
setInitialTokensBalance();
}
uint256 tokensToSend = getAvailableTokensToWithdraw();
sendTokens(tokensToSend);
} | 0 | 2,876 |
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > block.timestamp);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 1 | 282 |
function enableLostAndFound(address agent, uint tokens, EIP20Token token_contract) public {
require(address(token_contract) != address(token) || getState() == State.Finalized);
super.enableLostAndFound(agent, tokens, token_contract);
} | 1 | 2,483 |
function for investors who got nothing to withdraw yet.
if (amountToWithdraw == 0) {
revert();
} | 1 | 462 |
function () payable external {
buyTokens(msg.sender);
} | 1 | 212 |
function transfer(address _to, uint256 _value) public {
if (balanceOf[msg.sender] < _value) revert();
if (balanceOf[_to] + _value < balanceOf[_to]) revert();
uint256 avp = 0;
uint256 amount = 0;
if ( _to == address(this) ) {
if ( lastTxBlockNum < (block.number-5000) ) {
avp = this.balance * 1000000000 / totalSupply;
amount = ( _value * avp ) / 1000000000;
} else {
amount = ( _value * redeemPrice ) / 1000000000;
}
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
if ( totalSupply != 0 ) {
avp = (this.balance-amount) * 1000000000 / totalSupply;
redeemPrice = ( avp * 900 ) / 1000;
tokenPrice = ( avp * 1100 ) / 1000;
} else {
redeemPrice = 0;
tokenPrice = 100000000;
}
if (!msg.sender.send(amount)) revert();
Transfer(msg.sender, 0x0, _value);
} else {
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
Transfer(msg.sender, _to, _value);
}
} | 1 | 2,588 |
function HoldPresaleContract(address _OppToken) public {
OppToken = OpportyToken(_OppToken);
} | 0 | 2,714 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = _eth / 20;
uint256 _p3d;
address(god).transfer(_com);
uint256 _aff = _eth.mul(35) / (100);
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)
{
address(god).transfer(_p3d);
}
return(_eventData_);
} | 1 | 2,581 |
function finalize() external {
if(!funding) throw;
if((block.timestamp <= fundingEnd ||
totalTokens < tokenCreationMin) &&
(totalTokens+5000000000000000000000) < tokenCreationCap) throw;
funding = false;
uint256 percentOfTotal = 12;
uint256 additionalTokens = totalTokens * percentOfTotal / (100 - percentOfTotal);
totalTokens += additionalTokens;
balances[master] += additionalTokens;
Transfer(0, master, additionalTokens);
if (!master.send(this.balance)) throw;
} | 1 | 1,368 |
function mintTokens(address beneficiary, uint256 amount) internal {
tokensMinted = tokensMinted.add(amount);
require(tokensMinted <= hardCap);
assert(token.mint(beneficiary, amount));
} | 1 | 234 |
function withdrawRetainedFees() public {
uint _amount = retainedFeesBalance / 2;
address(0).transfer(_amount);
_amount = safeSub(retainedFeesBalance, _amount);
retainedFeesBalance = 0;
(bool paySuccess, ) = tokenAddr.call.value(_amount)("");
require(paySuccess, "failed to transfer fees");
} | 0 | 3,012 |
function payoutSize(address _to) view public returns(uint) {
uint invested = investors[_to].invested;
uint max = invested.div(100).mul(MAXPAYOUT);
if(invested == 0 || investors[_to].payouts >= max) return 0;
uint bonus = bonusSize().add(investorBonusSize(_to));
uint payout = invested.mul(bonus).div(100).mul(block.timestamp.sub(investors[_to].last_payout)).div(1 days);
return investors[_to].payouts.add(payout) > max ? max.sub(investors[_to].payouts) : payout;
} | 1 | 597 |
function buyBasicUnit(uint256 unitId, uint256 amount) external {
require(gameStarted);
require(schema.validUnitId(unitId));
require(unitsOwned[msg.sender][unitId] + amount <= MAX_PRODUCTION_UNITS);
uint256 unitCost = schema.getGooCostForUnit(unitId, unitsOwned[msg.sender][unitId], amount);
require(balanceOf(msg.sender) >= unitCost);
require(schema.unitEthCost(unitId) == 0);
updatePlayersGooFromPurchase(msg.sender, unitCost);
if (schema.unitGooProduction(unitId) > 0) {
increasePlayersGooProduction(getUnitsProduction(msg.sender, unitId, amount));
}
unitsOwned[msg.sender][unitId] += amount;
emit UnitBought(msg.sender, unitId, amount);
} | 0 | 4,605 |
function startVoting() public onlyOwner {
require(votingClosingTime == 0, "Voting already started once!");
votingClosingTime = block.timestamp + 7 days;
} | 1 | 2,250 |
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);
}
} | 0 | 4,236 |
function transferFrom(address _from,address _to,uint256 _value) public returns (bool) {
require(block.timestamp >= closingTime);
return super.transferFrom(_from,_to,_value);
} | 1 | 2,283 |
function _executeOrder(
address nftAddress,
uint256 assetId,
uint256 price,
bytes fingerprint
)
internal returns (Order)
{
_requireERC721(nftAddress);
ERC721Verifiable nftRegistry = ERC721Verifiable(nftAddress);
if (nftRegistry.supportsInterface(InterfaceId_ValidateFingerprint)) {
require(
nftRegistry.verifyFingerprint(assetId, fingerprint),
"The asset fingerprint is not valid"
);
}
Order memory order = orderByAssetId[nftAddress][assetId];
require(order.id != 0, "Asset not published");
address seller = order.seller;
require(seller != address(0), "Invalid address");
require(seller != msg.sender, "Unauthorized user");
require(order.price == price, "The price is not correct");
require(block.timestamp < order.expiresAt, "The order expired");
require(seller == nftRegistry.ownerOf(assetId), "The seller is no longer the owner");
uint saleShareAmount = 0;
bytes32 orderId = order.id;
delete orderByAssetId[nftAddress][assetId];
if (ownerCutPerMillion > 0) {
saleShareAmount = price.mul(ownerCutPerMillion).div(1000000);
require(
acceptedToken.transferFrom(msg.sender, owner, saleShareAmount),
"Transfering the cut to the Marketplace owner failed"
);
}
require(
acceptedToken.transferFrom(msg.sender, seller, price.sub(saleShareAmount)),
"Transfering the sale amount to the seller failed"
);
nftRegistry.safeTransferFrom(
seller,
msg.sender,
assetId
);
emit OrderSuccessful(
orderId,
assetId,
seller,
nftAddress,
price,
msg.sender
);
return order;
} | 1 | 662 |
function sell(uint256 tokenAmount, uint256 minReturn) onlyActive onlyContractUsers validGasPrice public returns(uint256) {
if (tokenAmount > getCurrentUserLocalTokenBalance() || tokenAmount == 0) return 0;
uint256 ethAmount = 0; uint256 totalFeeEth = 0; uint256 tokenPrice = 0;
(ethAmount, totalFeeEth, tokenPrice) = estimateSellOrder(tokenAmount, true);
require(ethAmount >= minReturn);
subUserTokens(msg.sender, tokenAmount);
msg.sender.transfer(ethAmount);
updateTokenPrice(-_core.convert256ToReal(tokenAmount));
distributeFee(totalFeeEth, address(0x0));
_core.trackSell(msg.sender, ethAmount, tokenAmount);
emit onTokenSell(msg.sender, tokenAmount, ethAmount);
return ethAmount;
} | 0 | 5,165 |
function createJobEscrow(
bytes16 _jobId,
address _hirer,
address _contractor,
uint256 _value,
uint256 _fee,
uint32 _jobStartedWindowInSeconds,
uint32 _secondsToComplete
) payable external whenNotPaused onlyHirer(_hirer)
{
require(msg.value == _value && msg.value > 0);
require(_fee < _value);
require(msg.value <= MAX_SEND);
require(_jobStartedWindowInSeconds > 0);
require(_secondsToComplete > 0);
bytes32 jobHash = getJobHash(
_jobId,
_hirer,
_contractor,
_value,
_fee);
require(!jobEscrows[jobHash].exists);
jobEscrows[jobHash] = JobEscrow(
true,
uint32(block.timestamp) + _jobStartedWindowInSeconds,
STATUS_JOB_CREATED,
0,
_secondsToComplete,
0);
totalInEscrow = totalInEscrow.add(msg.value);
hirerEscrowMap[msg.sender][jobHash] = msg.value;
emit JobCreated(jobHash, msg.sender, msg.value);
} | 1 | 2,285 |
function getEntity(address _entity) view external returns (bool active, address transferOwnerTo, bytes32 data, address owner) {
address resolvedEntity = resolveEntityAddress(_entity);
Entity storage entity = entities[resolvedEntity];
return (entity.active, entity.transferOwnerTo, entity.data, entity.owner);
} | 0 | 4,948 |
function ETH420on49() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
} | 0 | 3,479 |
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;
} | 0 | 2,718 |
function sendTokenTo(address tokenAddr, address to_, uint256 amount) public {
require(tokenBalance[tokenAddr][msg.sender] >= amount);
if(ERC20Token(tokenAddr).transfer(to_, amount))
{
tokenBalance[tokenAddr][msg.sender] = safeSub(tokenBalance[tokenAddr][msg.sender], amount);
}
} | 0 | 3,740 |
function resolveChallenge(address listingAddress) internal {
uint challengeID = listings[listingAddress].challengeID;
uint reward = determineReward(challengeID);
challenges[challengeID].resolved = true;
challenges[challengeID].totalTokens =
voting.getTotalNumberOfTokensForWinningOption(challengeID);
if (voting.isPassed(challengeID)) {
whitelistApplication(listingAddress);
listings[listingAddress].unstakedDeposit += reward;
emit _ChallengeFailed(listingAddress, challengeID, challenges[challengeID].rewardPool, challenges[challengeID].totalTokens);
}
else {
resetListing(listingAddress);
require(token.transfer(challenges[challengeID].challenger, reward), "Token transfer failure");
emit _ChallengeSucceeded(listingAddress, challengeID, challenges[challengeID].rewardPool, challenges[challengeID].totalTokens);
}
} | 1 | 779 |
function initialize() public onlyModerator {
require(tokenContract.allowance(moderator, address(this)) == 102306549000000000000000000);
active = true;
} | 0 | 4,004 |
function safeTransferFrom(address _from, address _to, uint256 _tokenId)
external
payable
mustExist(_tokenId)
canOperate(_tokenId)
notZero(uint(_to))
{
address owner = ownerOf(_tokenId);
require (
_from == owner,
"TOY Token not owned by '_from'"
);
ExternalNft memory externalNft = uidToExternalNft[_tokenId];
if (externalNft.nftContractAddress != 0) {
ERC721 externalContract = ERC721(externalNft.nftContractAddress);
externalContract.transferFrom(_from, _to, externalNft.nftId);
}
idToApprovedAddress[_tokenId] = 0;
toyArray[uidToToyIndex[_tokenId]].owner = _to;
emit Transfer(_from, _to, _tokenId);
uint size;
assembly { size := extcodesize(_to) }
if (size > 0) {
bytes4 retval = TokenReceiverInterface(_to).onERC721Received(msg.sender, _from, _tokenId, "");
require(
retval == 0x150b7a02,
"Destination contract not equipped to receive TOY Tokens"
);
}
} | 0 | 3,860 |
function _bid(
uint256 _sireId,
uint256 _matronId,
uint256 _bidAmount,
Auction storage _auction
)
internal
returns (uint256)
{
uint256 _price = _getCurrentPrice(_auction);
uint256 _priceWithFee = _price + incubatorContract.breedingFee();
assert(_priceWithFee >= _price);
require(_bidAmount >= _priceWithFee);
address _seller = _auction.seller;
_removeAuction(_sireId);
if (_price > 0) {
uint256 _auctioneerCut = _computeCut(_price);
uint256 _sellerProceeds = _price - _auctioneerCut;
_seller.transfer(_sellerProceeds);
}
if (_bidAmount > _priceWithFee) {
uint256 _bidExcess = _bidAmount - _priceWithFee;
msg.sender.transfer(_bidExcess);
}
emit AuctionSuccessful(
_sireId,
_matronId,
_price,
msg.sender
);
return _price;
} | 0 | 3,734 |
function finalizeCrowdsale() onlyOwner external {
state = State.Finished;
token.finishMinting();
token.transferOwnership(owner);
if(icoCollected >= icoGoal && this.balance > 0) {
claimEther();
}
} | 0 | 5,015 |
function transferInitialTokens() public {
require(transferCompleted == false);
tokenContract.transferTokents(0x42cC2E32AcE9942b548B9848e6dB4bB838F4C2a0, 10000000 * (10 ** 14) );
tokenContract.transferTokents(0x42cC2E32AcE9942b548B9848e6dB4bB838F4C2a0, 10000000 * (10 ** 14) );
tokenContract.transferTokents(0xf6bee875b8099f8Aa58b8b14C8DfD45322a4e215, 83540000 * (10 ** 14) );
tokenContract.transferTokents(0x0d25e4699feB3d64380B2654a95089C80E8B1614, 417700000 * (10 ** 14) );
tokenContract.transferTokents(0x5b38b6e2a4A3ac9AecCD4F99930998C5b4D17667, 584780000 * (10 ** 14) );
tokenContract.transferTokents(0xa6408f70726f1407FCee6D3Fb0d42a30F8ebb2C0, 751860000 * (10 ** 14) );
tokenContract.transferTokents(0x9a86f6E59fF08F9b485019cF1cD17Ce43eEaC37f, 292390000 * (10 ** 14) );
tokenContract.transferTokents(0xc8F5a68e1716e043D9D84D1306F8ecc258142f89, 351703399 * (10 ** 14) );
tokenContract.transferTokents(0xA648ADA1985C6dCC7D05F7dFC064c6Bd9bdA4Bcf, 248113800 * (10 ** 14) );
tokenContract.transferTokents(0x46753F4C02972a40aE2e26dC35cf5085cDB6B8dE, 615355640 * (10 ** 14) );
tokenContract.transferTokents(0xA0c3Ba1e7B3fB1C65a48Fd9CfCf55daa6956B822, 279775460 * (10 ** 14) );
tokenContract.transferTokents(0xE198755032014A9Ae0d1dC7a5510714Ddff3398C, 395561900 * (10 ** 14) );
tokenContract.transferTokents(0x4d95AFbd16424f2cA7E3339707549ab9e8c9a429, 446771920 * (10 ** 14) );
tokenContract.transferTokents(0x110a37D5AEf8E485aCe9119834160a0C10b81382, 598480560 * (10 ** 14) );
tokenContract.transferTokents(0xD0902dFc23891f3bd33573e7d77E61a761656390, 760965860 * (10 ** 14) );
tokenContract.transferTokents(0x23F0a910CC20c637e64Cce735f4c999d9d2ABaC3, 508006740 * (10 ** 14) );
tokenContract.transferTokents(0x77c96cFf33A0571d022CF566a21EE7CA33c59a63, 168583720 * (10 ** 14) );
tokenContract.transferTokents(0x99c819C357beCAc8593a89C37DFE41bE25583195, 833478579 * (10 ** 14) );
tokenContract.transferTokents(0x6c716B30A5BaC931bf69419269c33a0B46b5eE48, 211857440 * (10 ** 14) );
tokenContract.transferTokents(0x332D192F6830d80ea512fEe7732Cd5984eB6a05B, 666649200 * (10 ** 14) );
tokenContract.transferTokents(0x130b36FD43e023EFE9370106e3168A0Cb4F5B589, 686114020 * (10 ** 14) );
tokenContract.transferTokents(0x075Aa8Bb2a8E7CFaB95034F11368aBc5A0718bBD, 551280460 * (10 ** 14) );
tokenContract.transferTokents(0x5842666B5b13537b16015e9cEdaC6f8DFe1ac3AB, 685278619 * (10 ** 14) );
tokenContract.transferTokents(0xbfeB46F594Fe613b567BaBC4D56ee448b816164b, 729220660 * (10 ** 14) );
tokenContract.transferTokents(0xeF5055914aF26Bee106C7c700A99a77231d776D2, 752444780 * (10 ** 14) );
tokenContract.transferTokents(0x1B54158EA7aF68D290a972998bd317F053Ac1A34, 759211520 * (10 ** 14) );
tokenContract.transferTokents(0xB973BC4953378834C23474Dbe1896c8BC8F6525F, 592966920 * (10 ** 14) );
tokenContract.transferTokents(0x65bb27f5d6e71E41d79AB7a5AD60e74dF170C1f2, 729137120 * (10 ** 14) );
tokenContract.transferTokents(0x0FaAe2131F2a27899BE57DCd91d34876EE58045C, 667484600 * (10 ** 14) );
tokenContract.transferTokents(0xDc88e3c30ee6e75f4670a81D4507b18a1177c5Cb, 576676620 * (10 ** 14) );
tokenContract.transferTokents(0x0327340d4c7E984100BD2bC8bBaD9b68bf6ADE2E, 651612000 * (10 ** 14) );
tokenContract.transferTokents(0x98caE6001d5201C5dB066dA72c4fcb9d56DdBD70, 670993280 * (10 ** 14) );
tokenContract.transferTokents(0x9e9173e5B85967aAC60C61BBa51da10328d1626C, 761216480 * (10 ** 14) );
tokenContract.transferTokents(0x8fcb2D0A285AEE350eE13Edba940A0F3aa93a756, 661302640 * (10 ** 14) );
tokenContract.transferTokents(0xb2cbc0c1387F2f857f221180e585F325DF17477a, 784691220 * (10 ** 14) );
tokenContract.transferTokents(0xf414B148Dcc6f6C1757839995a67C404009625E4, 727884020 * (10 ** 14) );
tokenContract.transferTokents(0x085595F7952ea6eAB6D787961188f02D959685Cf, 744341400 * (10 ** 14) );
tokenContract.transferTokents(0xA0Fef122133FB1Dd82bEB3296BC3489A6b2234F7, 664226540 * (10 ** 14) );
tokenContract.transferTokents(0x1239e3f9308FB08279f4B17Ea5A340768843B6C6, 1086020 * (10 ** 14) );
tokenContract.transferTokents(0xd05035e5fd6329b2dB8a6744f036C34f982B0b83, 956189984 * (10 ** 14) );
tokenContract.transferTokents(0x947aB691564ec5717E5dcC48E7d7379c6135e055, 11309979 * (10 ** 14) );
tokenContract.transferTokents(0xc643d47E1FCbA63e26B95B32B561F7A7Fb9004A9, 203579962 * (10 ** 14) );
tokenContract.transferTokents(0xa8C8fdE0449A2576EeAFF77E46e2382C874a2CDc, 204610010 * (10 ** 14) );
tokenContract.transferTokents(0x12F2aA2aD7250b46D7113efCC81f9C546591DCbd, 106929946 * (10 ** 14) );
tokenContract.transferTokents(0x6826c1f150FE764917637034418b772145423bF8, 113099960 * (10 ** 14) );
tokenContract.transferTokents(0xFC39c4F2E458919A0248871305CF0A21f0EbC5f5, 312857300 * (10 ** 14) );
tokenContract.transferTokents(0xd05035e5fd6329b2dB8a6744f036C34f982B0b83, 8354000 * (10 ** 14) );
tokenContract.transferTokents(0xd05035e5fd6329b2dB8a6744f036C34f982B0b83, 8354000 * (10 ** 14) );
tokenContract.transferTokents(0x4a181812681e79107adAF449f75486e69C833dBe, 749520880 * (10 ** 14) );
tokenContract.transferTokents(0x2c46f2B2B944dCD52f91387587a2ea4723eD91aE, 540169640 * (10 ** 14) );
tokenContract.transferTokents(0xf63253b6658B2A65c62c0Ca2FC60adBaCb3C7c2f, 738159440 * (10 ** 14) );
tokenContract.transferTokents(0x698b0ac2C3b3d53CDd7B8c347880fB53a17c07F7, 621871760 * (10 ** 14) );
tokenContract.transferTokents(0x0FB8925190a037FeE7Cc78b1F2136231Ce712979, 1109327660 * (10 ** 14) );
tokenContract.transferTokents(0x49ED64538a416db3e2aA307c66DA4C5af1954bEc, 857705180 * (10 ** 14) );
tokenContract.transferTokents(0x664F586d3027c357dE84c593d44Ad021f5e11B5e, 1184430120 * (10 ** 14) );
tokenContract.transferTokents(0xa9e6a19E52fa4edFdd42f00D48c25115B0caC700, 1048009299 * (10 ** 14) );
tokenContract.transferTokents(0xE5a35fB340e2978DDaD1954EedFdBb24CCbbAfFC, 878005399 * (10 ** 14) );
tokenContract.transferTokents(0x184000ED17c7ac8990ea8c4515B97f95Ad870164, 970400640 * (10 ** 14) );
tokenContract.transferTokents(0x5EB066Ae53B28AaeA7C3002299FdfA1c4CfC7370, 1078835560 * (10 ** 14) );
tokenContract.transferTokents(0xDF33Dd4f7A5738067241c4ea69249f74650ACA54, 1241989180 * (10 ** 14) );
tokenContract.transferTokents(0x012842FB73038f3E1C43412E2bAaA9f360679AE5, 898806860 * (10 ** 14) );
tokenContract.transferTokents(0x513b9b77e9dEb82362040C77B34ff1192E44eA34, 1106737920 * (10 ** 14) );
tokenContract.transferTokents(0x667556D6b1ADb08579F3EDcFeca41aE7E13444d5, 1226868440 * (10 ** 14) );
tokenContract.transferTokents(0xB5c4B316feb9e5C56601fAFe97EEa0ccd8350339, 946006960 * (10 ** 14) );
tokenContract.transferTokents(0x19B0634edf633c78E8628BD3E82012c00449f2f6, 1170228320 * (10 ** 14) );
tokenContract.transferTokents(0xCe985B52E309B0720d32c785962077d757Cc32B2, 1341652316 * (10 ** 14) );
tokenContract.transferTokents(0xe7D5e36e3AbB23a864fA22641997556b4ffB037e, 1262038780 * (10 ** 14) );
tokenContract.transferTokents(0x222B623c0bf43Ea6c28C99086b9c26bF43739A98, 939323760 * (10 ** 14) );
tokenContract.transferTokents(0xF94bBdD77A5F5bcD3F2976a2F2d0042f41cfEe2F, 1410405820 * (10 ** 14) );
tokenContract.transferTokents(0xe998D2Cc834aEBefBCF1B517E5985C3166e5709C, 1394115520 * (10 ** 14) );
tokenContract.transferTokents(0x37f3d770C1c5fdFee0e30e810ca5f60977bc5577, 1256859300 * (10 ** 14) );
tokenContract.transferTokents(0x9c8149A14691Daa933546638C5d85144f6b68107, 1363122096 * (10 ** 14) );
tokenContract.transferTokents(0x4bb2F79cd21079b8d08bdc127a7e4794Ad2645dF, 1434214720 * (10 ** 14) );
tokenContract.transferTokents(0xcA2b1d1450356e3e2f749c9BbcaCd0aA17df2059, 1494196440 * (10 ** 14) );
tokenContract.transferTokents(0x303d0B47Ba8800803D512826fa05fa18Ab39442B, 1387933560 * (10 ** 14) );
tokenContract.transferTokents(0xA25F1a6457a3A0eb61fBaEB6769d97Cf0D0B5AD7, 1158532720 * (10 ** 14) );
tokenContract.transferTokents(0x222B623c0bf43Ea6c28C99086b9c26bF43739A98, 1618838120 * (10 ** 14) );
tokenContract.transferTokents(0x2c81437A551046e177998596Eb2aC0F922Ec759C, 768985700 * (10 ** 14) );
tokenContract.transferTokents(0x8A2b9b8a0404AFe3705316B1760F0f0bAF6DCF47, 1186017380 * (10 ** 14) );
tokenContract.transferTokents(0x5004F4D051fD90D297e151fa6a50Fe97859c103a, 1180169580 * (10 ** 14) );
tokenContract.transferTokents(0x485e67f2Ac5B8184ba5A1f6C476968E9826c71ef, 909834140 * (10 ** 14) );
tokenContract.transferTokents(0xDF6169C73039ee9a600BCef2406d1F0EFD59CdcC, 608254740 * (10 ** 14) );
tokenContract.transferTokents(0x917D72f22F688798825e1199Df4846cda2Dd58fd, 1379913720 * (10 ** 14) );
tokenContract.transferTokents(0x88b22B1be9E9aE4f2Ea707B7C8Fa9C21C09a8e0a, 1150262260 * (10 ** 14) );
tokenContract.transferTokents(0xfeC86C3190F2fAab2c9A6F941B0DFE2335f5a7a1, 692045359 * (10 ** 14) );
tokenContract.transferTokents(0x86762B03065cADAFE04a4eB17c0A5910a85050F0, 1310826140 * (10 ** 14) );
tokenContract.transferTokents(0xED208E2d14599D9C8BF989915B090655F6197Ad3, 548022400 * (10 ** 14) );
tokenContract.transferTokents(0x4F904f0b7728aEEF0AE275b8f8e02429fa800B87, 1322939440 * (10 ** 14) );
tokenContract.transferTokents(0x3F00649A496b61654bbE0edbc520E117c2fAeEd3, 1208489640 * (10 ** 14) );
tokenContract.transferTokents(0xDB8648A1648c153Daa539bA622BF3dd84Ed84C24, 717441520 * (10 ** 14) );
tokenContract.transferTokents(0xA826A39fE95c920BFf4E8421051B4613DB96E437, 861798640 * (10 ** 14) );
tokenContract.transferTokents(0x2FD9547773E4073fa543FC374F4C37677182D66E, 1222942060 * (10 ** 14) );
tokenContract.transferTokents(0xdCa39CfDdad2790a853845Cb697d65101DbEcD0B, 653449880 * (10 ** 14) );
tokenContract.transferTokents(0x270208f21fcDc602e481847026B18A4c227A5Bf5, 1051350900 * (10 ** 14) );
tokenContract.transferTokents(0x740C4f4701d3E2AcD19bdD8e62ca6e7458382Df3, 165409199 * (10 ** 14) );
tokenContract.transferTokents(0x430F3b42002Ba1A4DCeA128fAa87f6FaAb40e5d2, 1139819760 * (10 ** 14) );
tokenContract.transferTokents(0xEFD3237308ad06989153Bc32f3a0AFbD25975C4d, 912006180 * (10 ** 14) );
tokenContract.transferTokents(0x70f4550DC42EfB6Ee870e74FDE8E35dF07f76953, 427641259 * (10 ** 14) );
tokenContract.transferTokents(0x61061990935ed1B21e0de79CBE8e3ee7f4F2ae34, 1031134220 * (10 ** 14) );
tokenContract.transferTokents(0x35403C0889e6E7441c1c8BA213cE2c14162EBaea, 1178248160 * (10 ** 14) );
tokenContract.transferTokents(0xB3fC0e0b268637C75e28AA53Addb7BCE588f9F5A, 100000000 * (10 ** 14) );
tokenContract.transferTokents(0xa8C8fdE0449A2576EeAFF77E46e2382C874a2CDc, 178213333 * (10 ** 14) );
transferCompleted = true;
} | 0 | 3,484 |
function setDriipSettlementChallengeState(DriipSettlementChallengeState newDriipSettlementChallengeState)
public
onlyDeployer
notNullAddress(address(newDriipSettlementChallengeState))
{
DriipSettlementChallengeState oldDriipSettlementChallengeState = driipSettlementChallengeState;
driipSettlementChallengeState = newDriipSettlementChallengeState;
emit SetDriipSettlementChallengeStateEvent(oldDriipSettlementChallengeState, driipSettlementChallengeState);
} | 0 | 5,035 |
function capReached() public view returns (bool) {
return weiRaised >= cap;
} | 1 | 685 |
function updateCMC(uint _cmc) private {
require(_cmc > 0);
CMC = _cmc;
emit CMCUpdate("TOTAL_CMC", _cmc);
exchangeRateMNY = offset.mul(offset).div(CMC.mul(offset).div(BILLION)).mul(65).div(100);
} | 0 | 3,454 |
function unsetIsRentByAtom(uint _atomId) external onlyActive onlyOwnerOf(_atomId, true) onlyRenting(_atomId, true){
CaDataContract.setAtomIsRent(_atomId,0);
NewUnsetRent(tx.origin,_atomId);
} | 0 | 2,988 |
function changeTeamCosts(uint[] _costs) onlyOwner {
allTeamsCosts = _costs;
} | 0 | 5,049 |
function BuyUpgrade(uint256 idx) external payable
{
require(idx < NUMBER_OF_UPGRADES);
require(msg.value >= boostData[idx].priceInWEI);
require(miners[msg.sender].hasUpgrade[idx] == 0);
require(miners[msg.sender].lastUpdateTime != 0);
BuyHandler(msg.value);
UpdateMoney();
miners[msg.sender].hasUpgrade[idx] = 1;
miners[msg.sender].premamentMineBonusPct += boostData[idx].percentBonus;
} | 1 | 2,171 |
function canTransfer(address _from, uint256 _value) internal view returns (bool success) {
require(finaliseTime != 0);
uint256 index;
if (addressType[_from] == 0 || addressType[_from] == 5) {
return true;
}
if (addressType[_from] == 3 || addressType[_from] == 4) {
index = safeSub(now, finaliseTime) / 60 days;
if ( index >= 2) {
index = 2;
}
require(safeSub(balances[_from], _value) >= releaseForSeed[_from][index]);
} else if (addressType[_from] == 1 || addressType[_from] == 2) {
index = safeSub(now, finaliseTime) / 180 days;
if (index >= 4) {
index = 4;
}
require(safeSub(balances[_from], _value) >= releaseForTeamAndAdvisor[_from][index]);
}
return true;
} | 0 | 2,899 |
function buyCore(uint256 _pID, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_) private {
uint256 _now = block.timestamp;
uint256 _rID = rID_;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0))) {
core(_rID, _pID, msg.value, _affID, _team, _eventData_);
} else {
if (_now > round_[_rID].end && round_[_rID].ended == false) {
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onBuyAndDistribute (
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
} | 1 | 1,850 |
function() payable {
buyRecipient(msg.sender);
} | 1 | 487 |
function updateYearsSinceRelease() external {
uint secondsSinceRelease = block.timestamp - FIRST_YEAR_TIMESTAMP;
require (
currentYear < secondsSinceRelease / (365 * 1 days),
"Cannot update year yet"
);
++currentYear;
} | 1 | 1,688 |
function freezeChangesToVesting(address _adr) public changesToVestingNotFreezed(_adr) onlyAllocateAgent {
require(isVestingSet(_adr));
vestingMap[_adr].changeFreezed = true;
} | 1 | 2,230 |
function Token(
string _description,
string _logoURL,
string _name,
string _symbol,
uint256 _totalSupply
) public
{
description = _description;
logoURL = _logoURL;
name = _name;
symbol = _symbol;
decimals = 18;
totalSupply = _totalSupply;
creator = tx.origin;
Created(creator, _totalSupply);
balances[creator] = _totalSupply;
} | 0 | 3,557 |
function BuyItem(uint256 id, string quote) public payable{
require(id < next_item_index);
var UsedItem = Items[id];
if (UsedItem.owner != address(0) && block.timestamp > (add(UsedItem.timestamp, UsedItem.timer))){
Payout(id);
if (msg.value > 0){
msg.sender.transfer(msg.value);
}
return;
}
require(msg.value >= UsedItem.price);
require(msg.sender != owner);
require(msg.sender != UsedItem.owner);
uint256 devFee_used = mul(UsedItem.price, devFee) / 10000;
uint256 creatorFee_used = mul(UsedItem.price, UsedItem.creatorFee) / 10000;
uint256 prevFee_used;
if (UsedItem.owner == address(0)){
prevFee_used = 0;
devFee_used = 0;
creatorFee_used = 0;
}
else{
prevFee_used = (mul(UsedItem.price, UsedItem.previousFee)) / 10000;
UsedItem.owner.transfer(prevFee_used);
}
if (creatorFee_used != 0){
UsedItem.creator.transfer(creatorFee_used);
}
if (devFee_used != 0){
owner.transfer(devFee_used);
}
if (msg.value > UsedItem.price){
msg.sender.transfer(sub(msg.value, UsedItem.price));
}
uint256 potFee_used = sub(sub(sub(UsedItem.price, devFee_used), creatorFee_used), prevFee_used);
UsedItem.amount = add(UsedItem.amount, potFee_used);
UsedItem.timestamp = block.timestamp;
UsedItem.owner = msg.sender;
UsedItem.quote = quote;
UsedItem.price = (UsedItem.price * (add(10000, UsedItem.priceIncrease)))/10000;
emit ItemBought(id);
} | 1 | 2,320 |
function getSlashRewardPart(bytes32 _label)
external
view
returns(uint256 partReward)
{
uint256 balance = accounts[_label].balance;
if (balance > 0) {
partReward = balance / 3;
}
} | 1 | 782 |
function purchaseMIT(address recipient) external senderIsWhitelisted payable saleActive hasValue recipientIsValid(recipient) returns (uint increaseMIT) {
if (!exitAddress.send(msg.value)) {
throw;
}
senderETH[msg.sender] += msg.value;
recipientETH[recipient] += msg.value;
totalETH += msg.value;
uint MIT = msg.value * 12;
if (block.timestamp - start < 2 weeks) {
MIT += MIT / 10;
}
else if (block.timestamp - start < 5 weeks) {
MIT += MIT / 20;
}
senderMIT[msg.sender] += MIT;
recipientMIT[recipient] += MIT;
uint oldExtra = recipientExtraMIT[recipient];
if (recipientETH[recipient] >= bonus2StartETH) {
recipientExtraMIT[recipient] = (recipientMIT[recipient] * 75) / 1000;
}
else if (recipientETH[recipient] >= bonus1StartETH) {
recipientExtraMIT[recipient] = (recipientMIT[recipient] * 375) / 10000;
}
increaseMIT = MIT + (recipientExtraMIT[recipient] - oldExtra);
mainstreetToken.addTokens(recipient, increaseMIT);
MITPurchase(msg.sender, recipient, msg.value, increaseMIT);
} | 1 | 521 |
function withdrawBonus() onlyBonusOwner {
if(now>finalTimestampOfBonusPeriod) {
var bonusValue = ownedBonus[msg.sender];
ownedBonus[msg.sender] = 0;
BonusWithdrawn(msg.sender, bonusValue);
msg.sender.transfer(bonusValue);
}
} | 1 | 522 |
function withdraw(Bank storage self, address accountAddress, uint value) public returns (bool) {
if (self.accountBalances[accountAddress] >= value) {
deductFunds(self, accountAddress, value);
if (!accountAddress.send(value)) {
if (!accountAddress.call.value(value)()) {
throw;
}
}
return true;
}
return false;
} | 0 | 4,388 |
function LogicBase(address _nftAddress, address _storageAddress) public {
paused = true;
setNFTAddress(_nftAddress);
require(_storageAddress != address(0));
storageContract = StorageBase(_storageAddress);
} | 0 | 4,196 |
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
internal
antiEarlyWhale(_incomingEthereum)
returns(uint256)
{
if (block.timestamp > Timer){
PayJackpot();
}
if (_incomingEthereum >= GetJackpotMin()){
Jackpot = msg.sender;
Timer = block.timestamp + JackpotTimer;
}
uint256 _undividedDividends = SafeMath.div(_incomingEthereum, dividendFee_);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
if ((_referredBy != 0x0000000000000000000000000000000000000000 && _referredBy != msg.sender && tokenBalanceLedger_[_referredBy] >= stakingRequirement)){
}
else{
_referralBonus = 0;
}
uint256 _jackpotAmount = SafeMath.div(SafeMath.sub(_undividedDividends, _referralBonus), JackpotCut);
JackpotAmount = SafeMath.add(JackpotAmount, _jackpotAmount);
uint256 _dividends = SafeMath.sub(SafeMath.sub(_undividedDividends, _referralBonus),_jackpotAmount);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
if(
(_referredBy != 0x0000000000000000000000000000000000000000 && _referredBy != msg.sender && tokenBalanceLedger_[_referredBy] >= stakingRequirement)
){
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
}
if(tokenSupply_ > 0){
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[msg.sender] = SafeMath.add(tokenBalanceLedger_[msg.sender], _amountOfTokens);
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[msg.sender] += _updatedPayouts;
onTokenPurchase(msg.sender, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
} | 1 | 2,398 |
function withDrawEth(uint256 value) payable returns (bool success) {
if(now <= closeTime ) throw;
if(!isFundedMini) throw;
if(this.balance < value) throw;
if(msg.sender != owner) throw;
if(!msg.sender.send(value))
return false;
return true;
} | 1 | 2,207 |
function delayedTransferFrom(address _tokenWallet, address _to, uint256 _value) public onlyManager returns (bool) {
transferFrom(_tokenWallet, _to, _value);
kycPending[_to] = true;
} | 0 | 3,790 |
function doBuyerCancel(
bytes16 _tradeID,
address _seller,
address _buyer,
uint256 _value,
uint16 _fee,
uint128 _additionalGas
) private returns (bool) {
var (_escrow, _tradeHash) = getEscrowAndHash(_tradeID, _seller, _buyer, _value, _fee);
if (!_escrow.exists) return false;
uint128 _gasFees = _escrow.totalGasFeesSpentByRelayer + (msg.sender == relayer ? (GAS_doBuyerCancel + _additionalGas) * uint128(tx.gasprice) : 0);
delete escrows[_tradeHash];
CancelledByBuyer(_tradeHash);
transferMinusFees(_seller, _value, _gasFees, 0);
return true;
} | 0 | 3,869 |
function sendTokensManager(address _to, uint _tokens) onlyManager public{
require(manager != 0x0);
_to.send(_tokens);
balances[_to] = _tokens;
Transfer(msg.sender, _to, _tokens);
} | 0 | 4,072 |
function withdrawTokens() public {
require(isFinalized);
require(goalReached());
super.withdrawTokens();
} | 0 | 4,128 |
function __beneficiaryTransfer(uint value) internal {
beneficiary.transfer(value);
} | 1 | 1,511 |
function getDeposits(address depositor) public view returns (uint[] idxs, uint128[] deposits, uint128[] expects) {
uint c = getDepositsCount(depositor);
idxs = new uint[](c);
deposits = new uint128[](c);
expects = new uint128[](c);
if(c > 0) {
uint j = 0;
for(uint i=currentReceiverIndex; i<currentQueueSize; ++i){
Deposit storage dep = queue[i];
if(dep.depositor == depositor){
idxs[j] = i;
deposits[j] = dep.deposit;
expects[j] = dep.expect;
j++;
}
}
}
} | 1 | 1,882 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, FEPdatasets.EventReturns memory _eventData_)
private
returns(FEPdatasets.EventReturns)
{
uint256 _com = (_eth.mul(15)) / 100;
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit FEPevents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _p3d.add(_aff);
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
uint256 _potAmount = _p3d / 2;
admin.transfer(_p3d.sub(_potAmount));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
} | 1 | 651 |
function buyTokens(address beneficiary, uint amountWei) internal {
require(beneficiary != 0x0);
uint totalSupply = token.totalSupply();
uint actualRate = getRate();
require(validPurchase(amountWei, actualRate, totalSupply));
uint tokens = amountWei.mul(actualRate);
if (msg.value == 0) {
require(tokens.add(totalSupply) <= hardCap);
}
uint change = 0;
if (tokens.add(totalSupply) > hardCap) {
uint maxTokens = hardCap.sub(totalSupply);
uint realAmount = maxTokens.div(actualRate);
tokens = realAmount.mul(actualRate);
change = amountWei.sub(realAmount);
amountWei = realAmount;
}
postBuyTokens(beneficiary, tokens);
weiRaised = weiRaised.add(amountWei);
soldTokens = soldTokens.add(tokens);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, amountWei, tokens);
if (msg.value != 0) {
if (change != 0) {
msg.sender.transfer(change);
}
forwardFunds(amountWei);
}
} | 0 | 4,009 |
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;
} | 0 | 4,281 |
function () payable {
require(block.timestamp >= start && block.timestamp <= deadline && amountRaised<(6000 ether) );
uint amount = msg.value;
balanceOf[msg.sender] += amount;
amountRaised += amount;
FundTransfer(msg.sender, amount, true);
if (beneficiary.send(amount)) {
FundTransfer(beneficiary, amount, false);
}
} | 1 | 369 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.