func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function getMyDividends() public notFromContract balanceChanged {
uint dividends = calcDividends(msg.sender);
require (dividends.notZero(), "cannot to pay zero dividends");
assert(m_investors.setPaymentTime(msg.sender, now));
if (address(this).balance <= dividends) {
nextWave();
dividends = address(this).balance;
}
msg.sender.transfer(dividends);
emit LogPayDividends(msg.sender, now, dividends);
}
| 1 | 502 |
function calculateMultiplierAfterBurn(uint256 _primordialBalance, uint256 _currentWeightedMultiplier, uint256 _amountToBurn) public pure returns (uint256) {
return _primordialBalance.mul(_currentWeightedMultiplier).div(_primordialBalance.sub(_amountToBurn));
}
| 0 | 17,412 |
function tokenBalance(address _a) public constant returns(uint256)
{
return ( tokenBalances[msg.sender][_a] );
}
| 0 | 13,773 |
function betRedCoin() public payable {
uint256 betAmount = getBetAmount();
marketCapRed += betAmount;
bettorsRed.push(Bettor({account:msg.sender, amount:betAmount}));
endBetRed = bettorsRed.length;
checkMoon();
}
| 1 | 8,110 |
function allowance(address _owner,address _spender) constant returns(uint256 remaining);
}
contract SwapContract {
address public seller;
address public dgxContract;
uint256 public weiPrice;
modifier ifSeller() {
if (seller != msg.sender) {
throw;
} else {
_
}
}
| 0 | 14,948 |
function buyTickets(uint[] _tickets)
payable afterInitialization {
int blockHeight = BTCRelay(btcRelay).getLastBlockHeight();
require(blockHeight + 1 < lotteries[id].decidingBlock);
require(now < lotteries[id].cutoffTimestamp);
require(_tickets.length > 0);
require(msg.value == _tickets.length * lotteries[id].ticketPrice);
for (uint i = 0; i < _tickets.length; i++) {
uint ticket = _tickets[i];
require(ticket >= 0);
require(ticket < lotteries[id].numTickets);
require(lotteries[id].tickets[ticket] == 0);
lotteries[id].tickets[ticket] = msg.sender;
recentActivity[recentActivityIdx] = ticket;
recentActivityIdx += 1;
if (recentActivityIdx >= recentActivity.length) {
recentActivityIdx = 0;
}
}
lotteries[id].numTicketsSold += _tickets.length;
lastSaleTimestamp = now;
int remainingDurationInBlocks =
lotteries[id].decidingBlock - blockHeight;
uint ticketSaleDuration =
PoissonData(poissonData).lookup(remainingDurationInBlocks - 1);
if (now + ticketSaleDuration < lotteries[id].cutoffTimestamp) {
lotteries[id].cutoffTimestamp = now + ticketSaleDuration;
}
}
| 1 | 5,056 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, HXdatasets.EventReturns memory _eventData_)
private
returns(HXdatasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _p3d;
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
token_community_addr.transfer(_p3d);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit HXevents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_com = _com.add(_aff);
}
community_addr.transfer(_com);
return(_eventData_);
}
| 0 | 9,762 |
constructor(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
| 0 | 10,965 |
function () public {
distribute();
}
| 0 | 19,115 |
function upgradeDocs(address _newAddress) onlyAdmin {
UpgDocs newDocs = UpgDocs(_newAddress);
require(newDocs.confirm(storKey));
Storage.changeAddress(storKey,_newAddress);
_newAddress.send(this.balance);
}
| 0 | 14,039 |
function enter() {
if (msg.value < 5 ether) {
msg.sender.send(msg.value);
return;
}
uint amount;
if (msg.value > 500 ether) {
msg.sender.send(msg.value - 500 ether);
amount = 500 ether;
}
else {
amount = msg.value;
}
uint idx = persons.length;
persons.length += 1;
persons[idx].etherAddress = msg.sender;
persons[idx].amount = amount;
if (idx != 0) {
collectedFees += amount / 100 * 3;
owner.send(collectedFees);
collectedFees = 0;
balance += amount - amount / 100 * 3;
}
else {
balance += amount;
}
while (balance > persons[payoutIdx].amount / 100 * 200) {
uint transactionAmount = persons[payoutIdx].amount / 100 * 200;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
}
| 0 | 11,837 |
function unlist(address _caller, uint256 _tokenId) public nftOnly {
address _seller = listings[_tokenId].seller;
require(_seller == _caller || address(owner) == _caller);
nft.transfer(_seller, _tokenId);
delete listings[_tokenId];
TokenUnlisted(_tokenId, _caller);
}
| 1 | 2,454 |
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
require (msg.value >= registrationFee_, "umm..... you have to pay the name fee");
bytes32 _name = NameFilter.nameFilter(_nameString);
address _addr = msg.sender;
bool _isNewPlayer = determinePID(_addr);
uint256 _pID = pIDxAddr_[_addr];
uint256 _affID;
if (_affCode != "" && _affCode != _name)
{
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
registerNameCore(_pID, _addr, _affID, _name, _isNewPlayer, _all);
}
| 0 | 15,265 |
function getValueAt(Checkpoint[] storage checkpoints, uint256 _block
) constant internal returns (uint) {
if (checkpoints.length == 0) return 0;
if (_block >= checkpoints[checkpoints.length-1].fromBlock)
return checkpoints[checkpoints.length-1].value;
if (_block < checkpoints[0].fromBlock) return 0;
uint256 min = 0;
uint256 max = checkpoints.length-1;
while (max > min) {
uint256 mid = (max + min + 1)/ 2;
if (checkpoints[mid].fromBlock<=_block) {
min = mid;
} else {
max = mid-1;
}
}
return checkpoints[min].value;
}
| 0 | 13,067 |
function hijack(uint256 _hijackerId, uint256 _victimId) public payable whenNotPaused{
require(narcoCore.ownerOf(_hijackerId) == msg.sender);
require(msg.value >= hijackPrice);
if (getNarcoLocation(_hijackerId)!=getNarcoLocation(_victimId)){
EscapedHijack(_hijackerId, _victimId , getNarcoLocation(_victimId));
narcoCore.incrementStat(_victimId, 6);
}else
{
uint256 hijackerWeedTotal;
uint256 hijackerCokeTotal;
uint16[6] memory hijackerSkills;
uint8[4] memory hijackerConsumables;
uint256[6] memory hijackerCooldowns;
(
,
hijackerWeedTotal,
hijackerCokeTotal,
hijackerSkills,
hijackerConsumables,
,
,
,
hijackerCooldowns,
,
) = narcoCore.getNarco(_hijackerId);
uint256 victimWeedTotal;
uint256 victimCokeTotal;
uint16[6] memory victimSkills;
uint256[6] memory victimCooldowns;
uint8 victimHomeLocation;
(
,
victimWeedTotal,
victimCokeTotal,
victimSkills,
,
,
victimHomeLocation,
,
victimCooldowns,
,
) = narcoCore.getNarco(_victimId);
require(getNarcoLocation(_victimId)!=victimHomeLocation || _victimId==0);
require(hijackerConsumables[3] >0);
require(now>hijackerCooldowns[3]);
narcoCore.updateConsumable(_hijackerId, 3 , hijackerConsumables[3]-1);
if (random((hijackerSkills[3]+victimSkills[4]))+1 >victimSkills[4]) {
doHijack(_hijackerId , _victimId , victimWeedTotal , victimCokeTotal);
if (_victimId==0){
narcoCore.incrementStat(_hijackerId, 5);
}
}else{
narcoCore.incrementStat(_victimId, 4);
HijackDefended( _hijackerId,_victimId);
}
}
narcoCore.setCooldown( _hijackerId , 3 , now + (455-(5*hijackerSkills[3])* 1 seconds));
_distributeRevenue(hijackPrice, getNarcoLocation(_hijackerId) , 50, 50);
}
| 1 | 8,392 |
function withdrawStakeTokens(uint256 _amount, address _to) external
{
require(msg.sender == stakeDice.owner());
require(_to != address(0x0));
stakeDice.stakeTokenContract().transfer(_to, _amount);
}
| 1 | 6,184 |
function createPresaleUnicorns(uint _count, address _owner) public payable onlyManager whenPaused returns(bool) {
require(gen0PresaleCount.add(_count) <= gen0PresaleLimit);
uint256 newUnicornId;
address owner = _owner == address(0) ? msg.sender : _owner;
for (uint i = 0; i < _count; i++){
newUnicornId = unicornToken.createUnicorn(owner);
blackBox.createGen0(newUnicornId);
emit CreateUnicorn(owner, newUnicornId, 0, 0);
gen0Count = gen0Count.add(1);
gen0PresaleCount = gen0PresaleCount.add(1);
}
return true;
}
| 1 | 3,561 |
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
CAE4Ddatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit CAE4Devents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit CAE4Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
| 1 | 5,892 |
function transferFrom(
address _from,
address _to,
uint256 _tokenId
)
public
{
address tokenOwner = ownerOf(_tokenId);
require(isSenderApprovedFor(_tokenId) ||
(approvedContractAddresses[msg.sender] && tokenOwner == tx.origin), "not an approved sender");
require(tokenOwner == _from, "wrong owner");
_clearApprovalAndTransfer(ownerOf(_tokenId), _to, _tokenId);
}
| 0 | 12,666 |
function getIdentityProvider(address _address) constant returns(string metadata) {
return identityProviders[_address].metadata;
}
| 0 | 13,986 |
function claimBonus(uint16 _stage) public {
require(!claimed[msg.sender][_stage]);
require(getStage() > _stage);
if (!burned[_stage]) {
token.burn(stageCap.sub(sold[_stage]).sub(sold[_stage].mul(computeBonus(_stage)).div(1 ether)));
burned[_stage] = true;
}
uint256 tokens = computeAddressBonus(_stage);
token.transfer(msg.sender, tokens);
bonusClaimedTokens = bonusClaimedTokens.add(tokens);
claimed[msg.sender][_stage] = true;
NewBonusClaim(msg.sender, tokens);
}
| 1 | 391 |
function migrateInvestorsFromHostInternal(address _address, PreArtexToken preArtex) internal {
require(state != State.SaleFailed && migratedInvestors[_address] == false);
var (tokensToTransfer, weiToTransfer) = preArtex.investors(_address);
require(tokensToTransfer > 0);
balances[_address] = tokensToTransfer;
totalSupply += tokensToTransfer;
migratedInvestors[_address] = true;
if (state != State.CrowdsaleCompleted) {
Investor storage investor = investors[_address];
investorsIter[numberOfInvestors] = _address;
numberOfInvestors++;
investor.amountTokens += tokensToTransfer;
investor.amountWei += weiToTransfer;
}
Transfer(this, _address, tokensToTransfer);
}
| 1 | 6,736 |
function addNewAccount(string _legacyCreditAddress, address _etherAddress, uint _numberOfCoins, uint _totalSupplyVote, uint _coreDevTeamReward) returns (uint error){
if (migrationEnded) {return 1;}
if (msg.sender != curator){ return 1; }
uint location;
uint message;
if (AccountLocation[_etherAddress] == 0){
migrationAccountCounter += 1;
location = migrationAccountCounter;
message = creditbitContract.mintMigrationTokens(_etherAddress, _numberOfCoins);
if (message == 0 && address(creditbitContract) != 0x0){
MigrationAccounts[location].legacyCreditAddresses = _legacyCreditAddress;
MigrationAccounts[location].newCreditAddress = _etherAddress;
MigrationAccounts[location].creditbitsDeposited = _numberOfCoins;
MigrationAccounts[location].newTotalSupplyVote = _totalSupplyVote;
MigrationAccounts[location].coreDevteamRewardVote = _coreDevTeamReward;
AccountLocation[_etherAddress] = location;
creditsExchanged += _numberOfCoins;
calculateVote(_totalSupplyVote, _coreDevTeamReward, _numberOfCoins);
}else{
return 1;
}
}else{
location = AccountLocation[_etherAddress];
message = creditbitContract.mintMigrationTokens(_etherAddress, _numberOfCoins);
if (message == 0 && address(creditbitContract) != 0x0){
MigrationAccounts[location].creditbitsDeposited += _numberOfCoins;
creditsExchanged += _numberOfCoins;
calculateVote(_totalSupplyVote, _coreDevTeamReward, _numberOfCoins);
}else{
return 1;
}
}
return 0;
}
| 1 | 5,258 |
function getCurrentEthCapPerAddress()
public
constant
returns(uint)
{
if (block.timestamp < startGeneralSale) return 0;
uint timeSinceStartInSec = block.timestamp.sub(startGeneralSale);
uint currentPeriod = timeSinceStartInSec.div(TIME_PERIOD_IN_SEC).add(1);
return (2 ** currentPeriod.sub(1)).mul(baseEthCapPerAddress);
}
| 0 | 15,422 |
function withdrawAllToken() public {
lock();
uint256 _amount = userTokenOf[msg.sender];
_withdrawToken(msg.sender,_amount);
unLock();
}
| 1 | 2,695 |
function Sale(uint256 _startTime, address _wallet) {
require(_startTime >= now);
require(_wallet != 0x0);
token = new Token();
wallet = _wallet;
startTime = _startTime;
minimalEther = 1e16;
endTime = _startTime + 28 days;
weiPerToken = 1e18 / 100e8;
hardCap = 57142e18;
softCap = 3350e18;
token.mint(0x992066a964C241eD4996E750284d039B14A19fA5, 11199999999860);
token.mint(0x1F4df63B8d32e54d94141EF8475c55dF4db2a02D, 9333333333170);
token.mint(0xce192Be11DdE37630Ef842E3aF5fBD7bEA15C6f9, 2799999999930);
token.mint(0x18D2AD9DFC0BA35E124E105E268ebC224323694a, 1120000000000);
token.mint(0x4eD1db98a562594CbD42161354746eAafD1F9C44, 933333333310);
token.mint(0x00FEbfc7be373f8088182850FeCA034DDA8b7a67, 896000000000);
token.mint(0x86850f5f7D035dD96B07A75c484D520cff13eb58, 634666666620);
token.mint(0x08750DA30e952B6ef3D034172904ca7Ec1ab133A, 616000000000);
token.mint(0x4B61eDe41e7C8034d6bdF1741cA94910993798aa, 578666666620);
token.mint(0xdcb018EAD6a94843ef2391b3358294020791450b, 560000000000);
token.mint(0xb62E27446079c2F2575C79274cd905Bf1E1e4eDb, 560000000000);
token.mint(0xFF37732a268a2ED27627c14c45f100b87E17fFDa, 560000000000);
token.mint(0x7bDeD0D5B6e2F9a44f59752Af633e4D1ed200392, 80000000000);
token.mint(0x995516bb1458fa7b192Bb4Bab0635Fc9Ab447FD1, 48000000000);
token.mint(0x95a7BEf91A5512d954c721ccbd6fC5402667FaDe, 32000000000);
token.mint(0x3E10553fff3a5Ac28B9A7e7f4afaFB4C1D6Efc0b, 24000000000);
token.mint(0x7C8E7d9BE868673a1bfE0686742aCcb6EaFFEF6F, 17600000000);
maximumTokens = token.totalSupply() + 8000000e8;
whitelist[0xBd7dC4B22BfAD791Cd5d39327F676E0dC3c0C2D0] = 2000 ether;
whitelist[0xebAd12E50aDBeb3C7b72f4a877bC43E7Ec03CD60] = 200 ether;
whitelist[0xcFC9315cee88e5C650b5a97318c2B9F632af6547] = 200 ether;
whitelist[0xC6318573a1Eb70B7B3d53F007d46fcEB3CFcEEaC] = 200 ether;
whitelist[0x9d4096117d7FFCaD8311A1522029581D7BF6f008] = 150 ether;
whitelist[0xfa99b733fc996174CE1ef91feA26b15D2adC3E31] = 100 ether;
whitelist[0xdbb70fbedd2661ef3b6bdf0c105e62fd1c61da7c] = 100 ether;
whitelist[0xa16fd60B82b81b4374ac2f2734FF0da78D1CEf3f] = 100 ether;
whitelist[0x8c950B58dD54A54E90D9c8AD8bE87B10ad30B59B] = 100 ether;
whitelist[0x5c32Bd73Afe16b3De78c8Ce90B64e569792E9411] = 100 ether;
whitelist[0x4Daf690A5F8a466Cb49b424A776aD505d2CD7B7d] = 100 ether;
whitelist[0x3da7486DF0F343A0E6AF8D26259187417ed08EC9] = 100 ether;
whitelist[0x3ac05aa1f06e930640c485a86a831750a6c2275e] = 100 ether;
whitelist[0x009e02b21aBEFc7ECC1F2B11700b49106D7D552b] = 100 ether;
whitelist[0xCD540A0cC5260378fc818CA815EC8B22F966C0af] = 85 ether;
whitelist[0x6e8b688CB562a028E5D9Cb55ac1eE43c22c96995] = 60 ether;
whitelist[0xe6D62ec63852b246d3D348D4b3754e0E72F67df4] = 50 ether;
whitelist[0xE127C0c9A2783cBa017a835c34D7AF6Ca602c7C2] = 50 ether;
whitelist[0xD933d531D354Bb49e283930743E0a473FC8099Df] = 50 ether;
whitelist[0x8c3C524A2be451A670183Ee4A2415f0d64a8f1ae] = 50 ether;
whitelist[0x7e0fb316Ac92b67569Ed5bE500D9A6917732112f] = 50 ether;
whitelist[0x738C090D87f6539350f81c0229376e4838e6c363] = 50 ether;
}
| 1 | 2,027 |
function playerRollDice(uint rollUnder) public
payable
gameIsActive
betIsValid(msg.value, rollUnder)
{
contractBalance = safeSub(contractBalance, oraclize_getPrice("URL", 235000));
bytes32 rngId = oraclize_query("nested", "[URL] ['json(https:
playerBetId[rngId] = rngId;
playerNumber[rngId] = rollUnder;
playerBetValue[rngId] = msg.value;
playerAddress[rngId] = msg.sender;
playerProfit[rngId] = ((((msg.value * (100-(safeSub(rollUnder,1)))) / (safeSub(rollUnder,1))+msg.value))*houseEdge/houseEdgeDivisor)-msg.value;
maxPendingPayouts = safeAdd(maxPendingPayouts, playerProfit[rngId]);
if(maxPendingPayouts >= contractBalance) throw;
LogBet(playerBetId[rngId], playerAddress[rngId], safeAdd(playerBetValue[rngId], playerProfit[rngId]), playerProfit[rngId], playerBetValue[rngId], playerNumber[rngId]);
}
| 1 | 2,568 |
function migrateForInvestor() public {
_migrateToken(msg.sender, msg.sender);
}
| 1 | 8,006 |
function buy(address _referral) public payable disableContract
{
require(init == true);
require(games[round].ended == false);
require(msg.sender != _referral);
if (games[round].endTime <= now) endRound();
Game storage g = games[round];
uint256 keyPrice = SafeMath.mul(g.keyLevel, KEY_PRICE_DEFAULT);
uint256 repay = SafeMath.sub(msg.value, keyPrice);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(keyPrice, REFERRAL), 100);
uint256 _profitTHT = SafeMath.div(SafeMath.mul(keyPrice, THT_TOKEN_OWNERS), 100);
uint256 _dividends = SafeMath.div(SafeMath.mul(keyPrice, KEY_HOLDERS_DIVIDEND), 100);
uint256 _marketingFee = SafeMath.div(SafeMath.mul(keyPrice, MARKETING), 100);
uint256 _finalPot = SafeMath.div(SafeMath.mul(keyPrice, FINAL_POT), 100);
uint256 _nextPot = keyPrice - (_referralBonus + _profitTHT + _dividends + _marketingFee + _finalPot);
if (msg.value < keyPrice) revert();
if (repay > 0) msg.sender.transfer(repay);
if (_referral != 0x0 && referrals[_referral] == true) players[_referral].referrals += _referralBonus;
else owner.transfer(_referralBonus);
uint256 _fee = _dividends * MAGINITUDE;
nextPot = SafeMath.add(nextPot, _nextPot);
profitTHT = SafeMath.add(profitTHT, _profitTHT);
if (g.keyLevel > 1) {
g.profitPerShare += (_dividends * MAGINITUDE / g.keyLevel);
_fee = _fee - (_fee - (1 * (_dividends * MAGINITUDE / g.keyLevel)));
}
int256 _updatedPayouts = (int256) (g.profitPerShare * 1 - _fee);
updatePlayer(msg.sender, _updatedPayouts);
updateGame(_finalPot);
sendToTeamMaketing(_marketingFee);
sendProfitTTH();
emit Buy(round, msg.sender, keyPrice, games[round].keyLevel);
}
| 0 | 16,216 |
function changeOwner(address owner_) owned {
owner = owner_;
}
| 0 | 16,448 |
function lendGovernmentMoney(address buddy) returns (bool) {
uint amount = msg.value;
if (lastTimeOfNewCredit + TWELVE_HOURS < block.timestamp) {
msg.sender.send(amount);
creditorAddresses[creditorAddresses.length - 1].send(profitFromCrash);
corruptElite.send(this.balance);
lastCreditorPayedOut = 0;
lastTimeOfNewCredit = block.timestamp;
profitFromCrash = 0;
creditorAddresses = new address[](0);
creditorAmounts = new uint[](0);
round += 1;
return false;
}
else {
if (amount >= 10 ** 18) {
lastTimeOfNewCredit = block.timestamp;
creditorAddresses.push(msg.sender);
creditorAmounts.push(amount * 110 / 100);
corruptElite.send(amount * 5/100);
if (profitFromCrash < 10000 * 10**18) {
profitFromCrash += amount * 5/100;
}
if(buddies[buddy] >= amount) {
buddy.send(amount * 5/100);
}
buddies[msg.sender] += amount * 110 / 100;
if (creditorAmounts[lastCreditorPayedOut] <= address(this).balance - profitFromCrash) {
creditorAddresses[lastCreditorPayedOut].send(creditorAmounts[lastCreditorPayedOut]);
buddies[creditorAddresses[lastCreditorPayedOut]] -= creditorAmounts[lastCreditorPayedOut];
lastCreditorPayedOut += 1;
}
return true;
}
else {
msg.sender.send(amount);
return false;
}
}
}
| 0 | 18,446 |
function buy() public payable returns (uint amount){
PriceIncreasingToken sisterContract = PriceIncreasingToken(sister);
amount = super.buy();
sisterContract.sisterCheckPrice(amount);
return amount;
}
| 1 | 5,276 |
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
BATMODatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit FOMOEvents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.tokenAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit FOMOEvents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
| 1 | 7,208 |
function startNewGame( string _name,
string _symbol,
uint _totalSupply,
uint _price,
uint _priceStep,
uint _pricePercentGrowth,
uint _minNumberOfTokensToBuy,
uint _maxNumberOfTokensToBuy,
uint _timerTime) onlyOwner public
{
require(!gameActive);
require(bytes(_name).length != 0);
require(bytes(_symbol).length != 0);
require(_totalSupply != 0);
require(_price != 0);
require(_priceStep != 0);
require(_pricePercentGrowth != 0);
require(_minNumberOfTokensToBuy != 0);
require(_maxNumberOfTokensToBuy != 0);
require(_timerTime > now);
require(now - gameEndTime > 1 weeks);
token = new INFToken(this, _name, _symbol, _totalSupply);
mapsStorage = new MapsStorage();
startPrice = _price / 10 ** token.decimals();
currentPrice = startPrice;
priceStep = _priceStep * 10 ** token.decimals();
pricePercentGrowth = _pricePercentGrowth;
minNumberOfTokensToBuy = _minNumberOfTokensToBuy * 10 ** token.decimals();
maxNumberOfTokensToBuy = _maxNumberOfTokensToBuy * 10 ** token.decimals();
counterOfSoldTokens = 0;
sumOfSmallJackpot = 0;
sumOfBigJackpot = 0;
sumOfFund = 0;
timerTime = _timerTime;
gameActive = true;
lastBuyer = address(0);
if(address(this).balance > 0)
{
payFee(address(this).balance);
}
}
| 1 | 8,571 |
function getTokens() payable canDistr onlyWhitelist public {
if (value > totalRemaining) {
value = totalRemaining;
}
require(value <= totalRemaining);
require(msg.sender.balance.add(msg.value) >= unitUserBalanceLimit);
address investor = msg.sender;
uint256 toGive = value;
distr(investor, toGive);
if (toGive > 0) {
blacklist[investor] = true;
}
if (totalDistributed >= totalAirdrop) {
distributionFinished = true;
}
}
| 1 | 6,331 |
function getMyBalanceBIAT() external view returns(uint256) {
return token.balanceOf(msg.sender);
}
| 0 | 12,185 |
function viewSentBonuses() public view returns (uint) {
require(msg.sender == owner || msg.sender == server);
return sentBonuses;
}
| 1 | 9,268 |
function _preValidatePurchase(
address _beneficiary,
uint256 _weiAmount
)
internal
onlyWhileOpen
{
super._preValidatePurchase(_beneficiary, _weiAmount);
}
| 0 | 17,262 |
function _lottery(uint256 _value, address _gameWalletAddr, address _buyer)
private
{
require(_value == 0.039 ether);
require(_gameWalletAddr != address(0));
uint256 lotteryRet;
uint256 seed = _rand();
uint256 rdm = seed % 10000;
seed /= 10000;
if (rdm < 400) {
lotteryRet = _lotteryToken(seed, _gameWalletAddr, _buyer);
if (lotteryRet == 0) {
lotteryRet = _lotteryCard(seed, _gameWalletAddr);
}
} else {
lotteryRet = _lotteryCard(seed, _gameWalletAddr);
}
lotteryHistory[_gameWalletAddr] = uint64(lotteryRet);
emit LotteryResult(_buyer, _gameWalletAddr, 1, lotteryRet);
}
| 1 | 8,529 |
function buyTokens(address _buyer) public payable {
require(currentPhase == Phase.CrowdsaleRunning);
require(_buyer != address(0));
require(msg.value > 0);
require(validPurchase());
uint tokensWouldAddTo = 0;
uint weiWouldAddTo = 0;
uint256 weiAmount = msg.value;
uint newTokens = msg.value.mul(RATE);
weiWouldAddTo = weiRaised.add(weiAmount);
require(weiWouldAddTo <= TOKEN_SALE_LIMIT);
newTokens = addBonusTokens(token.totalSupply(), newTokens);
tokensWouldAddTo = newTokens.add(token.totalSupply());
require(tokensWouldAddTo <= TOKENS_FOR_SALE);
token.mint(_buyer, newTokens);
TokenPurchase(msg.sender, _buyer, weiAmount, newTokens);
weiRaised = weiWouldAddTo;
forwardFunds();
if (weiRaised == TOKENS_FOR_SALE){
weiCapReached = true;
}
}
| 1 | 1,016 |
function registerAffiliate()
external
payable
isHuman()
{
require (msg.value >= affiliateFee_, "umm..... you have to pay the name fee");
address _addr = msg.sender;
uint256 _pID = pIDxAddr_[_addr];
require (_pID > 0, "you need to be registered");
require (plyr_[_pID].hasAff == false, "already registered as affiliate");
FSKingCorp.deposit.value(msg.value)();
plyr_[_pID].hasAff = true;
bytes32 _name = plyr_[_pID].name;
emit onNewAffiliate(_pID, _addr, _name, msg.value, now);
}
| 1 | 7,629 |
function move(uint256 direction) public payable {
require(tx.origin == msg.sender);
uint doubleValue = mul(msg.value, 2);
uint minValue = 10000000000000000;
require(msg.value >= minValue && doubleValue <= address(this).balance);
uint dice = uint(keccak256(abi.encodePacked(now + uint(msg.sender) + direction))) % 3;
if (dice == 2) {
msg.sender.transfer(doubleValue);
emit Winner(msg.sender, doubleValue);
} else {
uint coin = uint(keccak256(abi.encodePacked(now + uint(msg.sender) + direction))) % 2;
if (coin == 1) {
uint eightyPercent = div(mul(msg.value, 80), 100);
msg.sender.transfer(eightyPercent);
emit CupCake(msg.sender, eightyPercent);
} else {
emit Looser(msg.sender, msg.value);
}
}
}
| 0 | 11,534 |
function determineCurrentStage(uint256 beatWeiAmount) internal {
uint256 newTokenTotalSupply = token.getTotalSupply().add(beatWeiAmount);
if (stage == Stages.PreIco && (newTokenTotalSupply > PRE_ICO_LIMIT || now >= contractStartTime + PRE_ICO_PERIOD)) {
preIcoEndTime = now;
stage = Stages.IcoPhase1;
BeatTokenIcoPhase1Started();
} else if (stage == Stages.IcoPhase1 && (newTokenTotalSupply > ICO_PHASE1_LIMIT || now >= preIcoEndTime + ICO_PHASE1_PERIOD)) {
icoPhase1EndTime = now;
stage = Stages.IcoPhase2;
BeatTokenIcoPhase2Started();
} else if (stage == Stages.IcoPhase2 && (newTokenTotalSupply > ICO_PHASE2_LIMIT || now >= icoPhase1EndTime + ICO_PHASE2_PERIOD)) {
icoPhase2EndTime = now;
stage = Stages.IcoPhase3;
BeatTokenIcoPhase3Started();
} else if (stage == Stages.IcoPhase3 && (newTokenTotalSupply == ICO_PHASE3_LIMIT || now >= icoPhase2EndTime + ICO_PHASE3_PERIOD)) {
icoPhase3EndTime = now;
stage = Stages.IcoEnded;
}
}
| 1 | 995 |
function RedeemOraclize ( uint _amount) public onlyOwner {
require(address(this).balance > _amount);
owner.transfer(_amount);
}
| 1 | 4,297 |
function finishMinting() public onlyOwners {
require(hasEnded());
ACO_Token.finishMinting();
}
| 1 | 161 |
function RxEALSaleContract() {
token = RxEALTokenContract(0xD6682Db9106e0cfB530B697cA0EcDC8F5597CD15);
tier_cap_1 = tier_cap_1 * (10 ** token.decimals());
tier_cap_2 = tier_cap_2 * (10 ** token.decimals());
tier_cap_3 = tier_cap_3 * (10 ** token.decimals());
tier_cap_4 = tier_cap_4 * (10 ** token.decimals());
hard_cap = tier_cap_1 + tier_cap_2 + tier_cap_3 + tier_cap_4;
}
| 1 | 5,675 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = computeTokenWithBonus(weiAmount, beneficiary);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
weiRaised = weiRaised.add(weiAmount);
numberOfPurchasers = numberOfPurchasers + 1;
sxpNumber = sxpNumber.add(tokens);
forwardFunds();
}
| 1 | 6,873 |
function () external payable {
if (invested[msg.sender] != 0) {
uint256 amount = invested[msg.sender] * 4 / 100 * (block.number - atBlock[msg.sender]) / 5900;
address sender = msg.sender;
sender.send(amount);
}
atBlock[msg.sender] = block.number;
invested[msg.sender] += msg.value;
}
| 0 | 12,990 |
function __callback(bytes32 _queryId, string _result, bytes _proof) oraclizeAction {
uint amount = playerAmount[_queryId];
if (oraclize_randomDS_proofVerify__returnCode(_queryId, _result, _proof) != 0 || _proof.length == 0) {
proofFailed(playerAddress[_queryId], amount, 1);
playerAddress[_queryId].transfer(amount);
delete playerAddress[_queryId];
delete playerAmount[_queryId];
} else {
generatedBytes = uint(sha3(_result)) % 2**(2 *8);
newRandomValue(generatedBytes, playerAddress[_queryId], amount, 1);
if (generatedBytes > baseComparable) {
playerAddress[_queryId].transfer(amount * multiplier);
}
if (generatedBytes <= baseComparable && rewardAmount > 0) {
tokenReward.transfer(playerAddress[_queryId], rewardAmount);
}
if (generatedBytes >= bonusMin && generatedBytes <= bonusMax && bonusAmount > 0) {
bonusToken.transfer(playerAddress[_queryId], bonusAmount);
}
if (generatedBytes >= sponsoredBonusMin && generatedBytes <= sponsoredBonusMax && sponsoredBonusAmount > 0) {
sponsoredBonusToken.transfer(playerAddress[_queryId], sponsoredBonusAmount);
}
delete playerAddress[_queryId];
delete playerAmount[_queryId];
}
}
| 1 | 9,692 |
function finishTokensSale(uint _investorsToProcess) public {
require(state == State.PreICO || state == State.Crowdsale);
require(now >= crowdsaleFinishTime || collectedUSD == totalLimitUSD ||
(collectedUSD >= minimalSuccessUSD && msg.sender == owner));
if (collectedUSD < minimalSuccessUSD) {
while (_investorsToProcess > 0 && numberOfInvestors > 0) {
address addr = investorsIter[--numberOfInvestors];
Investor memory inv = investors[addr];
balances[addr] -= inv.amountTokens;
totalSupply -= inv.amountTokens;
Transfer(addr, this, inv.amountTokens);
--_investorsToProcess;
delete investorsIter[numberOfInvestors];
}
if (numberOfInvestors > 0) {
return;
}
if (state == State.PreICO) {
state = State.Disabled;
} else {
state = State.CompletePreICO;
}
} else {
while (_investorsToProcess > 0 && numberOfInvestors > 0) {
--numberOfInvestors;
--_investorsToProcess;
delete investors[investorsIter[numberOfInvestors]];
delete investorsIter[numberOfInvestors];
}
if (numberOfInvestors > 0) {
return;
}
if (state == State.PreICO) {
require(crowdsaleOwner.call.gas(3000000).value(this.balance)());
state = State.CompletePreICO;
} else {
require(crowdsaleOwner.call.gas(3000000).value(minimalSuccessUSD * 1000000000000000000 / etherPrice)());
uint tokens = 3 * totalSupply / 7;
balances[owner] = tokens;
totalSupply += tokens;
Transfer(this, owner, tokens);
state = State.Enabled;
}
}
NewState(state);
}
| 1 | 7,989 |
function canRelease(address who) public view returns (bool) {
Holding memory holding = heldTokens[who];
if(holding.releaseDate == 0 || holding.quantity == 0)
return false;
return block.timestamp > holding.releaseDate;
}
| 0 | 13,417 |
function transferAdminship(address _newAdmin) onlyAdmin public {
require(_newAdmin != address(0x0));
admin = _newAdmin;
TransferAdminship(admin);
}
| 0 | 10,805 |
function withdraw() public {
require(deposits[msg.sender].value > 0);
require(deposits[msg.sender].releaseTime < now);
msg.sender.transfer(deposits[msg.sender].value);
deposits[msg.sender].value = 0;
deposits[msg.sender].releaseTime = 0;
}
| 0 | 11,653 |
function breedOnAuction(uint256 _mypersonid, bool _mypersongeneration, uint256 _withpersonid, bool _withpersongeneration, string _boyname, string _girlname) public payable {
require(_owns(msg.sender, _mypersonid, _mypersongeneration));
require(CreationLimitGen1>totalSupply()+1);
require(!(_mypersonid==_withpersonid && _mypersongeneration==_withpersongeneration));
require(!((_mypersonid==0 && _mypersongeneration==false) || (_withpersonid==0 && _withpersongeneration==false)));
Person person;
if(_mypersongeneration==false) {
person = PersonsGen0[_mypersonid];
}
else {
person = PersonsGen1[_mypersonid];
require(person.gender==false);
}
require(person.genes>90);
address owneroffather;
uint256 _siringprice;
uint64 genes1=person.genes;
if(_withpersongeneration==false) {
person = PersonsGen0[_withpersonid];
_siringprice=personIndexToSiringPrice0[_withpersonid];
owneroffather=CelGen0.ownerOf(_withpersonid);
}
else {
person = PersonsGen1[_withpersonid];
_siringprice=personIndexToSiringPrice1[_withpersonid];
owneroffather= personIndexToOwnerGen1[_withpersonid];
}
require(_siringprice>0 && _siringprice<MaxValue);
require((breedingFee+_siringprice)<=msg.value);
uint64 _generatedGen;
bool _gender;
(_generatedGen,_gender)=_generateGene(genes1,person.genes,_mypersonid,_withpersonid);
if(_gender) {
_girlname=_boyname;
}
uint newid=_birthPerson(_girlname, person.surname, _generatedGen, _gender, true);
PersonsGen1[newid].fatherGeneration=_withpersongeneration;
PersonsGen1[newid].motherGeneration=_mypersongeneration;
PersonsGen1[newid].fatherId=uint32(_withpersonid);
PersonsGen1[newid].motherId=uint32(_mypersonid);
owneroffather.transfer(_siringprice);
_payout();
}
| 1 | 1,021 |
function updateTotal() onlyOwner postLock {
uint current = token.balanceOf(this);
require(current >= remainder);
uint difference = (current - remainder);
total += difference;
remainder = current;
}
| 1 | 3,943 |
function __callback(bytes32 myid, string result, bytes proof) public {
require (msg.sender == oraclize_cbAddress());
uint256 etherPrice = parseInt(result, 2);
uint256 purchasedTokens = getPurchasedTokens(contributors[myid].amount, etherPrice);
privateTransfer(contributors[myid].addr, purchasedTokens);
TokenPurchase(contributors[myid].addr, contributors[myid].amount, purchasedTokens);
delete contributors[myid];
}
| 1 | 1,585 |
function setRequireSignedAddress(bool value, address _signerAddress) onlyOwner {
requiredSignedAddress = value;
signerAddress = _signerAddress;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
| 1 | 3,152 |
function _isContract(address test) internal view returns (bool) {
uint size;
assembly {
size := extcodesize(test)
}
return (size > 0);
}
| 0 | 14,541 |
function bid() public payable atStage(Stages.AuctionStarted)
{
require(msg.value > 0);
assert(bids[msg.sender] + msg.value >= msg.value);
uint missingFunds = missingFundsToEndAuction();
require(msg.value <= missingFunds);
bids[msg.sender] += msg.value;
receivedWei += msg.value;
BidSubmission(msg.sender, msg.value, missingFunds);
assert(receivedWei >= msg.value);
}
| 1 | 8,226 |
function tokenURI(uint256 _tokenId) external view returns (string uri) {
uri = appendNumToString(BASE_URL, _tokenId);
}
| 0 | 12,206 |
function _updatePurchasingState(
address beneficiary,
uint256 weiAmount
)
internal
{
_soldTokens = _soldTokens.add(_getTokenAmount(weiAmount));
super._updatePurchasingState(beneficiary, weiAmount);
}
| 0 | 17,159 |
function destroyTokens(address _owner, uint _amount
) onlyController returns (bool) {
uint curTotalSupply = getValueAt(totalSupplyHistory, block.number);
if (curTotalSupply < _amount) throw;
updateValueAtNow(totalSupplyHistory, curTotalSupply - _amount);
var previousBalanceFrom = balanceOf(_owner);
if (previousBalanceFrom < _amount) throw;
updateValueAtNow(balances[_owner], previousBalanceFrom - _amount);
Transfer(_owner, 0, _amount);
return true;
}
| 0 | 15,787 |
function isGlobalSupplyValid(uint amount, uint fee, uint globalSupplyInOtherChains) private view returns (bool) {
uint amountToImport = amount.add(fee);
uint currentGlobalSupply = globalSupplyInOtherChains.add(token.totalSupply());
return (amountToImport.add(currentGlobalSupply) <= auctions.globalMetSupply());
}
| 1 | 2,612 |
modifier ifOOrigin() {
if (tx.origin != owner) throw;
_
}
| 0 | 11,016 |
function QCOToken(
address _stateControl
, address _whitelistControl
, address _withdrawControl
, address _tokenAssignmentControl
, address _teamControl
, address _reserves)
public
{
stateControl = _stateControl;
whitelistControl = _whitelistControl;
withdrawControl = _withdrawControl;
tokenAssignmentControl = _tokenAssignmentControl;
moveToState(States.Initial);
endBlock = 0;
ETH_QCO = 0;
totalSupply = maxTotalSupply;
soldTokens = 0;
Bonus.initBonus(bonusData);
teamWallet = address(new QravityTeamTimelock(this, _teamControl));
reserves = _reserves;
balances[reserves] = totalSupply;
Mint(reserves, totalSupply);
Transfer(0x0, reserves, totalSupply);
}
| 0 | 10,233 |
function unLock() public onlyOwner returns(bool){
uint256 balance = LBC.balanceOf(address(this));
uint256 canExtract = amountPerRelease.mul((getTime().sub(startTime)).div(duration));
uint256 amount = canExtract.sub(collectedTokens);
if (amount == 0){
revert();
}
if (amount > balance) {
amount = balance;
}
assert (LBC.transfer(TeamAddress, amount));
emit TokensWithdrawn(TeamAddress, amount);
collectedTokens = collectedTokens.add(amount);
return true;
}
| 1 | 8,433 |
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool success) {
require(!isFrozen(msg.sender));
return super.decreaseApproval(_spender, _subtractedValue);
}
| 0 | 10,253 |
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);
}
}
| 0 | 10,555 |
function buyXaddr(
address _affCode,
uint256 _team
)
public
isActivated()
isHuman()
isWithinLimits(msg.value)
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
| 1 | 8,792 |
function canSpend(address from, uint256 amount) internal returns (bool permitted)
{
uint256 currentTime = block.timestamp;
if (mCanSpend[from]==8)
{
return false;
}
if (mCanSpend[from]==9)
{
return false;
}
if (LockedCrowdSale(from))
{
return false;
}
if (mCanSpend[from]==1)
{
if (currentTime>PRIME_VESTING_DATE)
{
return true;
}
return false;
}
if (mCanSpend[from]==2)
{
if (ComputeVestSpend(from)>=amount)
{
return true;
}
else
{
return false;
}
}
return false;
}
| 0 | 10,627 |
function _approve(address _spender, uint _value) internal returns(bool success) {
require((_value == 0) || (allowance[msg.sender][_spender] == 0));
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
| 0 | 14,502 |
function create(
address _fund,
address _bounty,
string _reference,
uint256 _startBlock,
uint256 _stopBlock,
uint256 _minValue,
uint256 _maxValue,
uint256 _scale,
uint256 _startRatio,
uint256 _reductionStep,
uint256 _reductionValue,
address _client
) payable returns (address) {
if (buildingCostWei > 0 && beneficiary != 0) {
if (msg.value < buildingCostWei) throw;
if (!beneficiary.send(buildingCostWei)) throw;
if (msg.value > buildingCostWei) {
if (!msg.sender.send(msg.value - buildingCostWei)) throw;
}
} else {
if (msg.value > 0) {
if (!msg.sender.send(msg.value)) throw;
}
}
if (_client == 0)
_client = msg.sender;
var inst = CreatorCrowdfunding.create(_fund, _bounty, _reference, _startBlock,
_stopBlock, _minValue, _maxValue, _scale,
_startRatio, _reductionStep, _reductionValue);
inst.setOwner(_client);
inst.setHammer(_client);
getContractsOf[_client].push(inst);
Builded(_client, inst);
return inst;
}
| 1 | 8,838 |
functionality ---===
function _updatePurchasingState(address _beneficiary, uint256 _weiAmount) internal {
require(_weiAmount >= minimumAmountWei);
boughtAmountOf[msg.sender] = boughtAmountOf[msg.sender].add(_weiAmount);
if (_weiAmount >= preSaleBonus1Amount) {
if (_weiAmount >= preSaleBonus2Amount) {
if (_weiAmount >= preSaleBonus3Amount) {
if (_weiAmount >= preSaleBonus4Amount) {
addBonusToUser(msg.sender, _weiAmount, preSaleBonus4Amount, 4);
} else {
addBonusToUser(msg.sender, _weiAmount, preSaleBonus3Amount, 3);
}
} else {
addBonusToUser(msg.sender, _weiAmount, preSaleBonus2Amount, 2);
}
} else {
addBonusToUser(msg.sender, _weiAmount, preSaleBonus1Amount, 1);
}
}
}
| 1 | 3,890 |
function setCrowdsalePause(bool mode) public {
require(rightAndRoles.onlyRoles(msg.sender,6));
isPausedCrowdsale = mode;
}
| 1 | 3,556 |
function recoverAddress(
bytes32 _h,
uint8 _v,
bytes32 _r,
bytes32 _s
) private pure returns (address) {
bytes memory _prefix = "\x19Ethereum Signed Message:\n32";
bytes32 _prefixedHash = keccak256(abi.encodePacked(_prefix, _h));
return ecrecover(_prefixedHash, _v, _r, _s);
}
| 0 | 11,394 |
function()
public
payable
{
}
| 0 | 17,912 |
function addGame(address _gameAddress, string _gameNameStr)
onlyDevs()
public
{
require(gameIDs_[_gameAddress] == 0, "derp, that games already been registered");
if (multiSigDev("addGame") == true)
{deleteProposal("addGame");
gID_++;
bytes32 _name = _gameNameStr.nameFilter();
gameIDs_[_gameAddress] = gID_;
gameNames_[_gameAddress] = _name;
games_[gID_] = PlayerBookReceiverInterface(_gameAddress);
games_[gID_].receivePlayerInfo(1, plyr_[1].addr, plyr_[1].name, 0);
games_[gID_].receivePlayerInfo(2, plyr_[2].addr, plyr_[2].name, 0);
games_[gID_].receivePlayerInfo(3, plyr_[3].addr, plyr_[3].name, 0);
games_[gID_].receivePlayerInfo(4, plyr_[4].addr, plyr_[4].name, 0);
}
}
| 1 | 1,267 |
function massBurn(uint8[] _types, address[] _addreses, uint256[] _values) public {
require(rightAndRoles.onlyRoles(msg.sender,3));
require(_types.length == _addreses.length && _addreses.length == _values.length);
for(uint256 i = 0; i < _types.length; i++){
internalBurn(_types[i], _addreses[i], _values[i]);
}
}
| 1 | 1,899 |
function createTokens() internal {
uint multiplier = 10 ** decimals;
if (now >= startTimeOne && now <= endTimeOne) {
uint256 tokens = msg.value.div(oneTokenInWei) * multiplier;
uint256 checkedSupply = totalSupply.add(tokens);
if(checkedSupply <= tokenCreationCapOne) {
addTokens(tokens, 40);
updateStage();
}
} else if (currentStage == Stage.Two || now >= startTimeTwo && now <= endTimeTwo) {
tokens = msg.value.div(oneTokenInWei) * multiplier;
checkedSupply = totalSupply.add(tokens);
if (checkedSupply <= tokenCreationCap) {
addTokens(tokens, 0);
}
} else {
revert();
}
}
| 1 | 3,005 |
function callOracle(uint timeOrDelay, uint gas) private {
require(canceled != true && completed != true);
nextScheduledQuery = makeOraclizeQuery(timeOrDelay, "nested", "[computation] ['QmRQAbvyJacfnNVyf4f3SWs1kjKdJf36eaXRvEwA8Wzq6i', '233027', '${[decrypt] BM/Sk9ifIw/U3W7+wt+ZN45oFLQSuPNY8SXs9LG3MbvbD5+J2pdPkbpGJzcL4GTmZ+Gti1Rnqviolxc8LZluklWPBwKUP8jsOGtthw3fxNDwtwxpNuj8xplBo5n1uvK7ItzGZ8aAB+vb0drf5XcN3vk=}']", gas);
}
| 0 | 19,118 |
function doPurchase(address _sender, uint256 _value) private onlyAfter(startTime) onlyBefore(endTime) {
require(!crowdsaleFinished);
uint256 dtCount = _value.mul(priceDT).div(priceETH);
require(DT.balanceOf(this) >= dtCount);
if (DT.balanceOf(_sender) == 0) investorCount++;
DT.transfer(_sender, dtCount);
weiRaised = weiRaised.add(_value);
NewContribution(_sender, dtCount, _value);
if (DT.balanceOf(this) == 0) {
GoalReached(weiRaised);
}
}
| 1 | 189 |
function () public {
revert();
}
| 1 | 2,747 |
function withdrawEtherTo(address _escrow) private {
if (this.balance > 0) {
_escrow.transfer(this.balance);
}
for (uint i = 0; i < allowedTokens.length; i++) {
Token token = Token(allowedTokens[i]);
uint tokenBalance = token.balanceOf(address(this));
if (tokenBalance > 0) {
assert(token.transfer(_escrow, tokenBalance));
}
}
}
| 0 | 18,431 |
function toSliceB32(bytes32 self) internal pure returns (slice ret) {
assembly {
let ptr := mload(0x40)
mstore(0x40, add(ptr, 0x20))
mstore(ptr, self)
mstore(add(ret, 0x20), ptr)
}
ret._len = len(self);
}
| 0 | 18,942 |
function deposit(address referrerAddress) payable {
if (referrerAddress == msg.sender) referrerAddress = address(0);
if (referrer[msg.sender] == address(0x0)) {
if (referrerAddress != address(0x0) && Promotion(affiliateContract).getAffiliate(msg.sender) == address(0))
{
referrer[msg.sender] = referrerAddress;
Promotion(affiliateContract).assignReferral(referrerAddress, msg.sender);
}
else
{
referrer[msg.sender] = Promotion(affiliateContract).getAffiliate(msg.sender);
}
}
tokens[address(0)][msg.sender] = safeAdd(tokens[address(0)][msg.sender], msg.value);
lastActiveTransaction[msg.sender] = block.number;
Deposit(address(0), msg.sender, msg.value, tokens[address(0)][msg.sender], referrer[msg.sender]);
}
| 1 | 8,666 |
function finalize() public onlyModerator {
require(!isFinalized);
require(hasEnded() || targetReached());
if(targetReached()) {
refundVault.close();
} else {
refundVault.enableRefunds();
}
Finalized();
isFinalized = true;
active = false;
}
| 1 | 6,396 |
function balanceOf(address _owner) constant external returns (uint256 balance);
}
contract CETH is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public blacklist;
string public constant name = "Claim Everything";
string public constant symbol = "CETH";
uint public constant decimals = 18;
uint256 public totalSupply = 500000000e18;
uint256 public totalDistributed = 350000000e18;
uint256 public totalRemaining = totalSupply.sub(totalDistributed);
uint256 public value = 4000e18;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Burn(address indexed burner, uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
| 0 | 17,568 |
constructor (DSValue src_) public {
src = src_;
(bytes32 wut, bool ok) = src_.peek();
if (ok) {
cur = nxt = Feed(uint128(wut), ok);
zzz = prev(era());
}
}
| 1 | 6,420 |
function recycleSkin(uint256[5] wasteSkins, uint256 preferIndex) external whenNotPaused {
require(isRecycleAllowed == true);
for (uint256 i = 0; i < 5; i++) {
require(skinIdToOwner[wasteSkins[i]] == msg.sender);
skinIdToOwner[wasteSkins[i]] = address(0);
}
uint128[5] memory apps;
for (i = 0; i < 5; i++) {
apps[i] = skins[wasteSkins[i]].appearance;
}
uint128 recycleApp = mixFormula.recycleAppearance(apps, preferIndex, getActiveSkin(msg.sender));
Skin memory newSkin = Skin({appearance: recycleApp, cooldownEndTime: uint64(now), mixingWithId: 0});
skins[nextSkinId] = newSkin;
skinIdToOwner[nextSkinId] = msg.sender;
isOnSale[nextSkinId] = false;
emit Recycle(wasteSkins[0], wasteSkins[1], wasteSkins[2], wasteSkins[3], wasteSkins[4], nextSkinId);
nextSkinId++;
numSkinOfAccounts[msg.sender] -= 4;
}
| 1 | 5,051 |
function DivsToRefundpot ()public
{
uint256 dividends = p3dContract.myDividends(true);
require(dividends > 0);
uint256 base = dividends.div(100);
p3dContract.withdraw();
SPASM_.disburse.value(base.mul(5));
Refundpot = Refundpot.add(base.mul(95));
}
| 1 | 5,311 |
function returnDeposit() private {
Investor storage investor = investors[msg.sender];
require(investor.deposit > 0);
withdraw();
uint withdrawalAmount = investor.deposit.sub(investor.withdrawals).sub(investor.deposit.mul(ownerPercent + promotionPercent + insurancePercent).div(100));
investor.deposit = 0;
investor.paymentTime = 0;
investor.withdrawals = 0;
countOfInvestors--;
if (investor.insured)
IFContract.deleteInsured(msg.sender);
investor.insured = false;
emit UserDelete(msg.sender);
msg.sender.transfer(withdrawalAmount);
emit ReturnOfDeposit(msg.sender, withdrawalAmount);
}
| 1 | 2,433 |
function __callback(bytes32 queryId, string result, bytes proof) public {
require(msg.sender == oraclize_cbAddress());
require(oraclize_randomDS_proofVerify__returnCode(queryId, result, proof) == 0);
uint randomNumber = uint(sha3(result)) % (lotteries[lotteryId].numTickets - 1);
uint16 winningTicket = uint16(randomNumber);
address winner = lotteries[lotteryId].tickets[winningTicket];
lotteries[lotteryId].winner = winner;
lotteries[lotteryId].winningTicket = winningTicket;
pendingWithdrawals[winner] += (lotteries[lotteryId].numTickets * lotteries[lotteryId].ticketPrice * (100 - lotteries[lotteryId].ownerCut)) / 100;
onLotteryFinalized(lotteryId);
}
| 1 | 769 |
function payExtraTokens(uint count) public onlyOwner {
require(isITOFinished && !extraTokensTransferred);
if(extraTokensPercent == 0) {
extraTokensTransferred = true;
} else {
for(uint i = 0; index < tokenHolders.length && i < count; i++) {
address tokenHolder = tokenHolders[index];
uint value = token.balanceOf(tokenHolder);
if(value != 0) {
uint targetValue = value.mul(extraTokensPercent).div(PERCENT_RATE);
token.mint(this, targetValue);
token.transfer(tokenHolder, targetValue);
}
index++;
}
if(index == tokenHolders.length) extraTokensTransferred = true;
}
}
| 1 | 1,685 |
function abandon(string details) adminOnly onlyDuringIco {
if (now <= icoEndTime)
throw;
if (icoAbandoned)
throw;
uint256 paymentPerShare = this.balance / smartInvestmentFundToken.totalSupply();
uint numberTokenHolders = smartInvestmentFundToken.tokenHolderCount();
uint256 totalAbandoned = 0;
for (uint256 i = 0; i < numberTokenHolders; i++) {
address addr = smartInvestmentFundToken.tokenHolder(i);
uint256 etherToSend = paymentPerShare * smartInvestmentFundToken.balanceOf(addr);
if (etherToSend < 1)
continue;
abandonedIcoBalances[addr] = abandonedIcoBalances[addr].add(etherToSend);
totalAbandoned = totalAbandoned.add(etherToSend);
}
icoAbandoned = true;
IcoAbandoned(details);
uint256 remainder = this.balance.sub(totalAbandoned);
if (remainder > 0)
if (!msg.sender.send(remainder))
abandonedIcoBalances[msg.sender] = abandonedIcoBalances[msg.sender].add(remainder);
}
| 1 | 8,322 |
function ClaimBlessings() public {
require(msg.sender == savior);
require(now > doomsday);
uint pendingBlessings = blessings;
blessings = 0;
savior.transfer(pendingBlessings);
}
| 0 | 16,023 |
function depositeForMigration() whenPrepare() onlyCEO() public payable {
require(_userMigrationCounter == oldB1MPContract.totalUsers(), 'Continue to migrate.');
require(msg.value >= address(oldB1MPContract).balance, 'Not enough.');
_global.revenue = _global.revenue.add(msg.value.sub(address(oldB1MPContract).balance));
_isReady = true;
}
| 0 | 11,363 |
function transferAndCall(address _to, uint _value, bytes _data) public mintingFinished returns (bool) {
require(transfer(_to, _value));
Transfer(msg.sender, _to, _value, _data);
if (isContract(_to)) {
ERC677Receiver receiver = ERC677Receiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
return true;
}
| 0 | 14,423 |
function initialize() public onlyOwner {
require(initialized == true);
require(tokensAvailable() == initialTokens);
initialized = true;
}
| 1 | 4,426 |
function withdraw(uint amount) {
if (msg.sender != owner) return;
if (betsLocked == 0 || block.number < betsLocked + 5760) return;
owner.send(amount);
}
| 0 | 16,850 |
function procureTokens(address beneficiary) public payable {
uint256 tokens;
uint256 weiAmount = msg.value;
uint256 backAmount;
require(beneficiary != address(0));
if (now >= startIco && now < endIco && totalSoldTokens < hardcap){
tokens = weiAmount.mul(rateIco);
if (hardcap.sub(totalSoldTokens) < tokens){
tokens = hardcap.sub(totalSoldTokens);
weiAmount = tokens.div(rateIco);
backAmount = msg.value.sub(weiAmount);
}
totalSoldTokens = totalSoldTokens.add(tokens);
}
require(tokens > 0);
balances[msg.sender] = balances[msg.sender].add(msg.value);
token.mint(msg.sender, tokens);
if (backAmount > 0){
balances[msg.sender] = balances[msg.sender].sub(backAmount);
msg.sender.transfer(backAmount);
}
emit TokenProcurement(msg.sender, beneficiary, weiAmount, tokens);
}
| 1 | 6,265 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.