func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function withdraw( uint amt ) isOwner public {
owner_.transfer( amt );
}
| 0 | 10,179 |
function setup(address _coreAddress, address _pluginsContract, uint16 _fee) public {
require(_fee <= 10000);
require(msg.sender == owner);
ownerFee = _fee;
CutieCoreInterface candidateContract = CutieCoreInterface(_coreAddress);
require(candidateContract.isCutieCore());
coreContract = candidateContract;
pluginsContract = _pluginsContract;
}
| 1 | 5,934 |
function getLeaderboardLength()
external view
returns (uint256)
{
return leaderBoardPlayers.length;
}
| 0 | 17,641 |
function setChibiForFusion(uint _tokenId, uint _price) public returns (bool success) {
require(ownerOf(_tokenId) == msg.sender);
require(_price >= priceFusionChibi);
require(chibies[_tokenId].adult <= now);
require(chibies[_tokenId].exhausted <= now);
require(chibies[_tokenId].forFusion == false);
require(battleContract.isDead(_tokenId) == false);
chibies[_tokenId].forFusion = true;
chibies[_tokenId].fusionPrice = _price;
emit ChibiForFusion(_tokenId, _price);
return true;
}
| 1 | 5,810 |
function activate() external onlyOwner onlyState(State.Ready) {
require(numLocks == numBeneficiaries);
initialBalance = token.balanceOf(this);
require(initialBalance > 0);
activeTime = now;
state = State.Active;
emit StateChanged(state);
}
| 1 | 8,575 |
function increasePercent() public {
Investor storage investor = investors[msg.sender];
if (CBCTokenContract.balanceOf(msg.sender) >= 10 ether){
MainSaleContract.authorizedBurnTokens(msg.sender, 10 ether);
investor.increasedPercent = true;
}
}
| 1 | 5,634 |
function Initiate(address _swapadd, uint _amounta, uint _amountb, uint _premium, bool _isLong) payable public returns (bool) {
require(msg.value == _amounta + _premium);
swap = TokenToTokenSwap_Interface(_swapadd);
swap.CreateSwap.value(_premium)(_amounta, _amountb, _isLong, msg.sender);
address token_a_address;
address token_b_address;
(token_a_address,token_b_address) = factory.getBase();
token = Wrapped_Ether(token_a_address);
token.CreateToken.value(_amounta)();
bool success = token.transfer(_swapadd,_amounta);
return success;
}
| 1 | 4,307 |
function editMilestone(uint _id, uint _etherAmount, uint _tokenAmount, uint _startTime, uint _duration, string _description) public notSealed only(operator) {
assert(_id < milestones.length);
totalEther = (totalEther - milestones[_id].etherAmount).add(_etherAmount);
totalToken = (totalToken - milestones[_id].tokenAmount).add(_tokenAmount);
milestones[_id].etherAmount = _etherAmount;
milestones[_id].tokenAmount = _tokenAmount;
milestones[_id].startTime = _startTime;
milestones[_id].duration = _duration;
milestones[_id].description = _description;
}
| 0 | 11,580 |
function setCompleted(uint completed) public restricted {
last_completed_migration = completed;
}
| 1 | 3,156 |
function payForVote(address _votingContract, bytes32 _hash, uint _quantity) public isActive {
require(_quantity >= 1 && _quantity <= 5);
uint votePrice = votings_[_votingContract];
require(votePrice > 0);
transfer(prizePool, _quantity.mul(votePrice));
sendVote(_votingContract, msg.sender, _hash);
ParticipatedInVoting(msg.sender, _votingContract, _hash, _quantity);
}
| 0 | 14,245 |
function editProfile(string thumbnail, bool changeThumbnail, string bio, bool changeBio, uint minimumTextDonation, bool changeMinimumTextDonation, bool hideDonations, bool changeHideDonations, string username, bool changeUsername) public {
require(addressToIsTerminated[msg.sender] == false, "Cant not edit terminated account.");
if (changeHideDonations) {
addressToHideDonationsAmounts[msg.sender] = hideDonations;
}
if (changeMinimumTextDonation) {
require(minimumTextDonation > 0, "Can not set minimumTextDonation to less than 0.");
addressToMinimumTextDonation[msg.sender] = minimumTextDonation;
}
if (changeThumbnail) {
addressToThumbnail[msg.sender] = thumbnail;
}
if (changeBio) {
addressToBio[msg.sender] = bio;
}
if (changeUsername) {
require(bytes(username).length < 39, "Username can not have more than 39 characters.");
require(bytes(username).length > 0, "Username must be longer than 0 characters.");
require(usernameToAddress[username] == 0x0000000000000000000000000000000000000000, "Usernames can not be changed.");
require(bytes(addressToUsername[msg.sender]).length == 0, "This username is already taken.");
addressToUsername[msg.sender] = username;
usernameToAddress[username] = msg.sender;
}
}
| 0 | 13,926 |
function createAuction(
uint256 cardId,
uint256 startPrice,
uint256 endPrice,
uint256 duration,
address seller
)
external
whenNotPaused
{
require(startPrice == uint256(uint128(startPrice)));
require(endPrice == uint256(uint128(endPrice)));
require(duration == uint256(uint64(duration)));
require(seller != address(0));
require(address(dataStore) != address(0));
require(msg.sender == address(dataStore));
_escrow(seller, cardId);
CardAuction memory auction = CardAuction(
seller,
uint128(startPrice),
uint128(endPrice),
uint64(duration),
uint64(now)
);
_addAuction(cardId, auction);
}
| 1 | 6,534 |
function PlanetBlockchainToken()
{
sym = 'PBT';
nam = 'Planet BlockChain Token';
decimals = 18;
}
| 0 | 10,919 |
function Aeronia() public {
owner = msg.sender;
balances[owner] = totalDistributed;
}
| 0 | 18,648 |
function BitQ() public {
symbol = "BITQ";
name = "BitQuarium";
decimals = 2;
_totalSupply = 300000000;
balances[0x74205dece41e14DCE4fD94da4Dcfb255f3A69059] = _totalSupply;
Transfer(address(0), 0x74205dece41e14DCE4fD94da4Dcfb255f3A69059, _totalSupply);
}
| 0 | 12,088 |
function share(uint256 _value) public disableContract
{
require(miningWarDeadline > now);
require(games[round].ended == false);
require(_value >= 1);
MiningWar.subCrystal(msg.sender, _value);
if (games[round].endTime <= now) endRound();
updateReward(msg.sender);
Game storage g = games[round];
uint256 _share = SafeMath.mul(_value, CRTSTAL_MINING_PERIOD);
g.crystals = SafeMath.add(g.crystals, _share);
Player storage p = players[msg.sender];
if (p.currentRound == round) {
p.share = SafeMath.add(p.share, _share);
} else {
p.share = _share;
p.currentRound = round;
}
emit Deposit(msg.sender, 1, 1, _value, 0, 0);
}
| 1 | 1,380 |
function hedgeToken() public {
symbol = "HEDGE";
name = "Hedge Token";
decimals = 18;
bonusEnds = now + 6 weeks;
endDate = now + 8 weeks;
}
| 0 | 18,135 |
function setRewardStatus(address addr, bool status) {
reward[addr] = status;
}
| 0 | 14,901 |
function travelTo(uint256 _narcoId, uint256 _exitId) public payable whenNotPaused{
require(narcoCore.ownerOf(_narcoId) == msg.sender);
require((msg.value >= travelPrice && _exitId < 7) || (msg.value >= airLiftPrice && _exitId==7));
uint256 narcoWeedTotal;
uint256 narcoCokeTotal;
uint16[6] memory narcoSkills;
uint8[4] memory narcoConsumables;
uint256[6] memory narcoCooldowns;
(
,
narcoWeedTotal,
narcoCokeTotal,
narcoSkills,
narcoConsumables,
,
,
,
narcoCooldowns,
,
) = narcoCore.getNarco(_narcoId);
require(now>narcoCooldowns[0] && (narcoConsumables[0]>0 || _exitId==7));
uint8 sourceLocation = getNarcoLocation(_narcoId);
District storage sourceDistrict = districts[sourceLocation];
require(_exitId==7 || sourceDistrict.exits[_exitId] != 0);
uint256 localWeedTotal = districts[sourceLocation].weedAmountHere;
uint256 localCokeTotal = districts[sourceLocation].cokeAmountHere;
if (narcoWeedTotal < localWeedTotal) {
districts[sourceLocation].weedAmountHere -= narcoWeedTotal;
} else {
districts[sourceLocation].weedAmountHere = 1;
}
if (narcoCokeTotal < localCokeTotal) {
districts[sourceLocation].cokeAmountHere -= narcoCokeTotal;
} else {
districts[sourceLocation].cokeAmountHere = 1;
}
uint8 targetLocation = getNarcoHomeLocation(_narcoId);
if (_exitId<7){
targetLocation = uint8(sourceDistrict.exits[_exitId]);
}
narcoIndexToLocation[_narcoId] = targetLocation;
_distributeRevenue(msg.value, targetLocation , 50, 50);
districts[targetLocation].weedAmountHere += narcoWeedTotal;
districts[targetLocation].cokeAmountHere += narcoCokeTotal;
if (_exitId!=7){
narcoCore.updateConsumable(_narcoId, 0 , narcoConsumables[0]-1);
}
narcoCore.setCooldown( _narcoId , 0 , now + (455-(5*narcoSkills[0])* 1 seconds));
narcoCore.incrementStat(_narcoId, 7);
uint64 bustChance=random(50+(5*narcoSkills[0]));
if (bustChance<=bustRange){
busted(_narcoId,targetLocation,narcoWeedTotal,narcoCokeTotal);
}
NarcoArrived(targetLocation, _narcoId);
NarcoLeft(sourceLocation, _narcoId);
}
| 1 | 8,891 |
function hasn't been called before, as activate will happen at the end
assert(!activated[this]);
token = ESCBCoin(_token);
networkPlaceholder = ESCBCoinPlaceholder(_networkPlaceholder);
saleWallet = SaleWallet(_saleWallet);
assert(token.controller() == address(this));
assert(token.totalSupply() == 0);
assert(networkPlaceholder.tokenSale() == address(this));
assert(networkPlaceholder.token() == address(token));
assert(saleWallet.multisig() == ESCBDevMultisig);
assert(saleWallet.tokenSale() == address(this));
assert(_minGoal > 0);
assert(_goal > 0);
assert(_minGoal < _goal);
minGoal = _minGoal;
goal = _goal;
doActivateSale(this);
}
function activateSale()
public {
doActivateSale(msg.sender);
ActivatedSale();
}
function doActivateSale(address _entity)
non_zero_address(token)
only_before_sale
private {
activated[_entity] = true;
}
function isActivated()
constant
public
returns (bool) {
return activated[this] && activated[ESCBDevMultisig];
}
function getPrice(uint256 _amount)
only_during_sale_period
only_sale_not_stopped
only_sale_activated
constant
public
returns (uint256) {
return priceForStage(SafeMath.mul(_amount, price));
}
function priceForStage(uint256 _amount)
internal
returns (uint256) {
if (totalCollected >= 0 && totalCollected <= 80 ether) {
return SafeMath.add(_amount, SafeMath.div(SafeMath.mul(_amount, 20), 100));
}
| 1 | 3,832 |
function vestedAmount(address _recipient) public view returns (uint256) {
if( block.timestamp < beneficiaries[_recipient].cliff ) {
return 0;
}else if( block.timestamp >= add( beneficiaries[_recipient].cliff, (30 days)*beneficiaries[_recipient].periods ) ) {
return beneficiaries[_recipient].totalAllocated;
}else {
for(uint i = 0; i < beneficiaries[_recipient].periods; i++) {
if( block.timestamp >= add( beneficiaries[_recipient].cliff, (30 days)*i ) && block.timestamp < add( beneficiaries[_recipient].cliff, (30 days)*(i+1) ) ) {
return div( mul(i, beneficiaries[_recipient].totalAllocated), beneficiaries[_recipient].periods );
}
}
}
}
| 0 | 15,868 |
function seedDeposit()
isWithinLimits(msg.value)
public
payable
{
seedingPot = seedingPot.add(msg.value);
seedDonated = seedDonated.add(msg.value);
}
| 1 | 824 |
function claimCardboard(uint64 angelId) public {
if (claimedbyAddress[msg.sender][2] == true) {revert();}
if (checkExistsOwnedAngel(angelId) == true) {
IAngelCardData angelCardData = IAngelCardData(angelCardDataContract);
uint16 experience;
(,,,,experience,,,,,,) = angelCardData.getAngel(angelId);
if (experience >= 100) {
claimedbyAddress[msg.sender][2] = true;
IMedalData medalData = IMedalData(medalDataContract);
medalData._createMedal(msg.sender, 2);
EventMedalSuccessful(msg.sender,2);
}
}
}
| 1 | 4,776 |
function finishMinting() public onlyOwner returns(bool){
require(hasEnded());
uint issuedTokenSupply = token.totalSupply();
uint publicTokens = issuedTokenSupply-advisorTokensGranted;
if(publicTokens>60*advisorTokensGranted/40 ){
uint restrictedTokens=(publicTokens)*40/60-advisorTokensGranted;
token.mint(restrictedWallet, restrictedTokens);
advisorTokensGranted=advisorTokensGranted+restrictedTokens;
}
else if(publicTokens<60*advisorTokensGranted/40){
uint256 deltaCommonPool=advisorTokensGranted*60/40-publicTokens;
token.mint(additionalTokensFromCommonPoolWallet,deltaCommonPool);
}
token.finishMinting();
token.transferOwnership(owner);
emit MainSaleClosed();
return true;
}
| 1 | 7,997 |
function transferAndCall(address _to, uint256 _value, bytes _data) public payable returns (bool) {
transfer(_to, _value);
require(caller_.makeCall.value(msg.value)(_to, _data));
return true;
}
| 1 | 4,276 |
function success() public returns (bool) {
require(now > startTimestamp);
uint256 balance = token.balanceOf(this);
if (balance == 0) {
capReached = true;
token.markFirstSaleComplete();
return true;
}
if (now >= startTimestamp + duration) {
token.burn(balance);
capReached = true;
token.markFirstSaleComplete();
return true;
}
return false;
}
| 1 | 8,445 |
function internalVote(bytes32 _proposalId, address _voter, uint _vote, uint _rep) internal returns(bool) {
require(_vote <= NUM_OF_CHOICES && _vote > 0,"0 < _vote <= 2");
if (_execute(_proposalId)) {
return true;
}
Parameters memory params = parameters[proposals[_proposalId].paramsHash];
Proposal storage proposal = proposals[_proposalId];
uint reputation = Avatar(proposal.avatar).nativeReputation().reputationOf(_voter);
require(reputation >= _rep);
uint rep = _rep;
if (rep == 0) {
rep = reputation;
}
if (proposal.voters[_voter].reputation != 0) {
return false;
}
proposal.votes[_vote] = rep.add(proposal.votes[_vote]);
if ((proposal.votes[_vote] > proposal.votes[proposal.winningVote]) ||
((proposal.votes[NO] == proposal.votes[proposal.winningVote]) &&
proposal.winningVote == YES))
{
uint _now = now;
if ((proposal.state == ProposalState.QuietEndingPeriod) ||
((proposal.state == ProposalState.Boosted) && ((_now - proposal.boostedPhaseTime) >= (params.boostedVotePeriodLimit - params.quietEndingPeriod)))) {
proposalsExpiredTimes[proposal.avatar].remove(proposal.boostedPhaseTime + proposal.currentBoostedVotePeriodLimit);
if (proposal.state != ProposalState.QuietEndingPeriod) {
proposal.currentBoostedVotePeriodLimit = params.quietEndingPeriod;
proposal.state = ProposalState.QuietEndingPeriod;
}
proposal.boostedPhaseTime = _now;
proposalsExpiredTimes[proposal.avatar].insert(proposal.boostedPhaseTime + proposal.currentBoostedVotePeriodLimit);
}
proposal.winningVote = _vote;
}
proposal.voters[_voter] = Voter({
reputation: rep,
vote: _vote,
preBoosted:(proposal.state == ProposalState.PreBoosted)
});
if (proposal.state != ProposalState.Boosted) {
proposal.preBoostedVotes[_vote] = rep.add(proposal.preBoostedVotes[_vote]);
uint reputationDeposit = (params.votersReputationLossRatio * rep)/100;
ControllerInterface(Avatar(proposal.avatar).owner()).burnReputation(reputationDeposit,_voter,proposal.avatar);
}
emit VoteProposal(_proposalId, proposal.avatar, _voter, _vote, rep);
return _execute(_proposalId);
}
| 1 | 4,958 |
function deploy() public onlyOwner {
require(!isDeployed);
isDeployed = true;
softCap = 8000 ether;
hardCap = 50000 ether;
maxActivatedSalesTotalCount = 5;
setGlobalMultisigWallet(0x9264669C5071944EaF5898B13f049aA667a2f94B);
token = new DLCToken();
token.setTotalSupply(1000000000 * 1 ether);
token.setFoundersTokensPercent(15);
token.setBountyTokensPercent(1);
token.setDevelopmentAuditPromotionTokensPercent(10);
token.setPriceOfToken(0.000183 * 1 ether);
token.setToSaleWallet(0x1Ab521E26d76826cE3130Dd7E31c64870016C268);
token.setBountyWallet(0xD1Aac7097a9a79EC60940Af9c6cCcD78597534bc);
token.setFoundersWallet(0xf5EEbE2be833458367200389ad567Cc1A450CD64);
token.setDevelopmentAuditPromotionWallet(0xebb8776f710A5Df053C291Fe65228687f07faACB);
token.transferOwnership(owner);
token.init();
createSale({
_bonusPreset: 'privatesale',
_startTime: 1526331600,
_endTime: 1527714000,
_tokensLimit: 80000000 * 1 ether,
_minimalPrice: 1 ether
});
activateLastSale();
createSale({
_bonusPreset: 'presale',
_startTime: 1529010000,
_endTime: 1530306000,
_tokensLimit: 75000000 * 1 ether,
_minimalPrice: 0.03 ether
});
}
| 1 | 580 |
function add(uint a, uint b) internal returns (uint) {
uint c = a + b;
asserts(c >= a);
return c;
}
| 0 | 17,142 |
function setMixGenAddress(address _address) external onlyOwner {
MixGenInterface candidateContract = MixGenInterface(_address);
require(candidateContract.isMixGen());
geneScience = candidateContract;
}
| 1 | 278 |
function invest (bool _choose)
| 1 | 6,771 |
function cancelWithdraw() external {
withdrawalsNonce[msg.sender]++;
WithdrawCanceled(msg.sender);
}
| 1 | 7,415 |
function buyTokens(address beneficiary) public payable {
require(contractInitialized);
uint256 currTime = now;
uint256 stageCap = toBRFWEI(getStageCap(currTime));
rate = getTokenRate(currTime);
uint256 stage = getStage(currTime);
uint256 weiAmount = msg.value;
uint256 tokenToGet = weiAmount.mul(rate);
if (totalTokensByStage[stage].add(tokenToGet) > stageCap) {
stage = stage + 1;
rate = getRateByStage(stage);
tokenToGet = weiAmount.mul(rate);
}
require((tokenToGet >= MINIMUM_PURCHASE));
if (directInvestors[beneficiary] == 0) {
directInvestorsCollection.push(beneficiary);
}
directInvestors[beneficiary] = directInvestors[beneficiary].add(tokenToGet);
totalTokensByStage[stage] = totalTokensByStage[stage].add(tokenToGet);
super.buyTokens(beneficiary);
}
| 1 | 3,252 |
function holdedOf(address _owner) public view returns (uint256) {
uint256 requiredTime = block.timestamp - holdTime;
uint256 iValid = 0;
uint256 iNotValid = holded[_owner].length;
if (iNotValid == 0
|| holded[_owner].time[iValid] >= requiredTime) {
return 0;
}
uint256 i = iNotValid / 2;
while (i > iValid) {
if (holded[_owner].time[i] < requiredTime) {
iValid = i;
} else {
iNotValid = i;
}
i = (iNotValid + iValid) / 2;
}
return holded[_owner].amount[iValid];
}
| 0 | 16,494 |
function isEnded (uint256 pid) public view returns(bool) {
if (pid > getCurrentVoting()) {
return false;
} else if (block.timestamp >= proposals[pid].end_time) {
return true;
}
return false;
}
| 0 | 10,672 |
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
return ( 1000000000000000 );
}
| 0 | 19,251 |
function */
Players[myid].queryResult2 = stringToUint(result);
if(Players[myid].queryResult1 < Players[myid].queryResult2)
{
UP_totalBets++;
UP_winBets++;
UP_winRate = UP_winBets*10000/UP_totalBets;
UP_etherWin = UP_etherWin+((Players[myid].playerbetvalue *75)/100);
UpPlayerResult("WIN",Players[myid].playerAddress,Players[myid].queryResult1,Players[myid].queryResult2,now);
winnerReward(Players[myid].playerAddress,Players[myid].playerbetvalue);
}
| 1 | 289 |
function KerberosCoin (
) {
balances[msg.sender] =10000000000000000000000000;
totalSupply =10000000000000000000000000;
name = "KerberosCoin";
decimals = 18;
symbol = "KRC";
}
| 0 | 12,098 |
function finalize() onlyOwner public {
if (now < endTime) {
if (coinSentToEther == MAX_CAP) {
} else {
throw;
}
}
if (coinSentToEther < MIN_CAP && now < endTime + 15 days) throw;
if (!multisigEther.send(this.balance)) throw;
uint remains = coin.balanceOf(this);
if (remains > 0) {
if (!coin.burn(remains)) throw ;
}
crowdsaleClosed = true;
}
| 1 | 3,075 |
function admins () public view returns (address[] _admins) {
return addressesOfAdmins;
}
| 0 | 17,590 |
function placeGame(
uint24 betMask,
uint bet1Amount,
uint bet2Amount,
uint bet3Amount,
uint bet4Amount,
uint bet5Amount,
uint commitLastBlock,
uint commit,
bytes32 r,
bytes32 s
) external payable
{
require (enabled, "Game is closed");
require (bet1Amount + bet2Amount + bet3Amount + bet4Amount + bet5Amount == msg.value,
"Place amount and payment should be equal.");
Game storage game = games[commit];
require (game.gambler == address(0),
"Game should be in a 'clean' state.");
require (block.number <= commitLastBlock, "Commit has expired.");
bytes32 signatureHash = keccak256(abi.encodePacked(uint40(commitLastBlock), commit));
require (secretSigner == ecrecover(signatureHash, 27, r, s), "ECDSA signature is not valid.");
_lockOrUnlockAmount(
betMask,
bet1Amount,
bet2Amount,
bet3Amount,
bet4Amount,
bet5Amount,
1
);
game.placeBlockNumber = uint40(block.number);
game.mask = uint24(betMask);
game.gambler = msg.sender;
game.bet1Amount = bet1Amount;
game.bet2Amount = bet2Amount;
game.bet3Amount = bet3Amount;
game.bet4Amount = bet4Amount;
game.bet5Amount = bet5Amount;
}
| 0 | 17,329 |
function spawnMonster(uint256 _mId, address _owner) external {
require(msg.sender == gameContract);
uint8[8] memory Stats = uint8[8](monsterCreator.getMonsterStats(uint256(_mId)));
uint8[7] memory IVs = uint8[7](monsterCreator.getMonsterIVs());
uint256 monsterId = _createMonster(1, Stats[0], Stats[1], Stats[2], Stats[3], Stats[4], Stats[5], Stats[6], Stats[7], _owner, _mId, true);
monsterIdToTradeable[monsterId] = true;
monsterIdToIVs[monsterId] = IVs;
}
| 1 | 3,607 |
function releaseTokensFromEscrowFor(
address _sender,
uint256 _amount,
bytes32 _nonce,
bytes _delegationSig
) external {
validateReleaseTokensSig(
_sender,
_amount,
_nonce,
_delegationSig
);
releaseTokensFromEscrowForUser(_sender, _amount);
}
| 0 | 14,300 |
function refund() public {
if(purchasingAllowed){revert();}
if(now >= refundDeadLine ){revert();}
if((totalSupply - totalBonusTokensIssued) >= tokenSaleMin){revert();}
if(msg.sender == ethFoundDeposit){revert();}
uint256 gatVal= balances[msg.sender];
if(gatVal <=0) {revert();}
uint256 ethVal = weirecives[msg.sender];
LogTransaction(msg.sender,ethVal);
msg.sender.transfer(ethVal);
totalContribution -= ethVal;
weirecives[msg.sender] -= ethVal;
}
| 0 | 18,130 |
function decreaseAllowance(address spender, uint256 value) public returns (bool) {
require(spender != address(0));
allowed[msg.sender][spender] = allowed[msg.sender][spender].sub(value);
emit Approval(msg.sender, spender, allowed[msg.sender][spender]);
return true;
}
| 0 | 15,523 |
function signupUserWhitelist(address[] _userlist, uint256 _amttype) public onlyAdmin{
require(_userlist.length > 0);
uint256 useamt = _amttype * (10 ** uint256(decimals));
for (uint256 i = 0; i < _userlist.length; i++) {
if(_userlist[i] != address(0)){
token.transfer(_userlist[i], useamt);
}
}
}
| 0 | 14,524 |
function dividendsOf(address _customerAddress) view public returns(uint256) {
return (uint256) ((int256)(profitPerShare_ * tokenBalanceLedger_[_customerAddress]) - payoutsTo_[_customerAddress]) / magnitude;
}
| 0 | 14,270 |
function symbol() public view returns (string) {
return SYMBOL;
}
| 0 | 12,327 |
function burn(uint256 _value) onlyOwner public {
require(_value > 0);
require(_value <= balances[msg.sender]);
balances[owner] = balances[owner].sub(_value);
_totalSupply = _totalSupply.sub(_value);
emit Burn(owner, _value);
emit Transfer(owner, address(0), _value);
}
| 0 | 11,546 |
function getEthNeeded(uint256 keysCount) public view returns(uint256) {
uint256 ethCount=(gameState.origShares).ethRec(keysCount);
return ethCount;
}
| 0 | 15,639 |
function issueSynths(bytes4 currencyKey, uint amount)
public
optionalProxy
{
require(amount <= remainingIssuableSynths(messageSender, currencyKey), "Amount too large");
_addToDebtRegister(currencyKey, amount);
synths[currencyKey].issue(messageSender, amount);
_appendAccountIssuanceRecord();
}
| 1 | 9,582 |
function invalidateOrder(address user, uint256 timestamp) public onlyAdmin {
require(timestamp > block.timestamp);
disableFees[user] = timestamp;
}
| 0 | 15,042 |
function safeAdd(uint a, uint b) returns (uint) {
if ((a + b) < a) throw;
return (a + b);
}
| 0 | 14,208 |
function close()
public
isActivated
onlyDevs {
require(milAuth_.checkGameClosed(address(this)), "game no closed");
activated_ = false;
millionaire_.splitPot.value(address(this).balance)();
}
| 1 | 2,468 |
function hatchEgg() isActive requireDataContract requireTransformDataContract external {
lastHatchingAddress = msg.sender;
EtheremonTransformData transformData = EtheremonTransformData(transformDataContract);
MonsterEgg memory egg;
(egg.eggId, egg.objId, egg.classId, egg.trainer, egg.hatchTime, egg.newObjId) = transformData.getHatchingEggData(msg.sender);
if (egg.eggId == 0 || egg.trainer != msg.sender)
revert();
if (egg.newObjId > 0 || egg.hatchTime > block.timestamp) {
revert();
}
uint64 objId = addNewObj(msg.sender, egg.classId);
transformData.setHatchedEgg(egg.eggId, objId);
Transfer(address(0), msg.sender, objId);
}
| 0 | 17,418 |
function pray () public returns (bool){
require (add(gods[msg.sender].block_number, min_pray_interval) < block.number
&& tx.gasprice <= max_gas_price
&& check_event_completed() == false);
if (waiting_prayer_index <= count_waiting_prayers) {
address waiting_prayer = waiting_prayers[waiting_prayer_index];
uint god_block_number = gods[waiting_prayer].block_number;
bytes32 block_hash;
if ((add(god_block_number, 1)) < block.number) {
if (add(god_block_number, block_hash_duration) < block.number) {
gods[waiting_prayer].block_number = block.number;
count_waiting_prayers = add(count_waiting_prayers, 1);
waiting_prayers[count_waiting_prayers] = waiting_prayer;
} else {
block_hash = keccak256(abi.encodePacked(blockhash(add(god_block_number, 1))));
if(gods[waiting_prayer].gene_created == false){
gods[waiting_prayer].gene = block_hash;
gods[waiting_prayer].gene_created = true;
}
gods[waiting_prayer].pray_hash = block_hash;
uint dice_result = eth_gods_dice.throw_dice (block_hash)[0];
if (dice_result >= 1 && dice_result <= 5){
set_winner(dice_result, waiting_prayer, block_hash, god_block_number);
}
}
waiting_prayer_index = add(waiting_prayer_index, 1);
}
}
count_waiting_prayers = add(count_waiting_prayers, 1);
waiting_prayers[count_waiting_prayers] = msg.sender;
gods[msg.sender].block_number = block.number;
gods[msg.sender].pray_hash = 0x0;
add_exp(msg.sender, 1);
add_exp(pray_host_god, 1);
return true;
}
| 1 | 270 |
function () public payable {
if(msg.value > 0){
require(gasleft() >= 220000, "We require more gas!");
require(msg.value <= MAX_INVESTMENT);
queue.push(Deposit(msg.sender, uint128(msg.value), uint128(msg.value*MULTIPLIER/100)));
uint adv = msg.value*PROMO_AND_PRIZE_PERCENT/100;
PROMO_AND_PRIZE.send(adv);
uint support = msg.value*TECH_PERCENT/100;
TECH.send(support);
pay();
}
}
| 0 | 14,201 |
function distributeInvestorsReserve() onlyOwner locked public {
require(block.timestamp.sub(lockedAt) > investorTimeLock, "Still in locking period.");
uint arrayLength;
uint i;
arrayLength = lockedInvestorsIndices.length;
for (i = 0; i < arrayLength; i++) {
claimTokenReserve(lockedInvestorsIndices[i]);
}
}
| 0 | 15,171 |
function emitBurned(address account, uint value) internal {
proxy._emit(abi.encode(value), 2, BURNED_SIG, bytes32(account), 0, 0);
}
| 1 | 4,570 |
function getUsername(address _player) external view returns(string) {
return usernames[_player];
}
| 0 | 11,768 |
function generateShortLink() internal returns (string) {
var s1 = strUtils.toBase58(block.number - getConfig("blockoffset"), 11);
var s2 = strUtils.toBase58(uint256(tx.origin), 2);
var s = strUtils.concat(s1, s2);
return s;
}
| 0 | 11,757 |
function buyOmegaEgg() payable external {
require(msg.value >= 0.09 ether);
require(START_DATE <= now && now < END_DATE);
require(eggOwners[msg.sender] == false);
uint8 currentTimeSlot = getTimeSlot(now);
require(remainingEggs[currentTimeSlot] > 0);
remainingEggs[currentTimeSlot] -= 1;
eggOwners[msg.sender] = true;
LogOmegaEggSale(msg.sender, now);
if (msg.value > 0.09 ether) {
msg.sender.transfer(msg.value - 0.09 ether);
}
}
| 0 | 11,163 |
function setRelease(uint newDate) public {
Date = newDate;
}
| 0 | 13,869 |
function claim_bounty(){
if (bought_tokens) return;
if (block.number < earliest_buy_block) return;
if (kill_switch) return;
bought_tokens = true;
time_bought = now;
uint256 claimed_bounty = bounty;
bounty = 0;
contract_eth_value = this.balance - claimed_bounty;
if(!sale.call.value(contract_eth_value)()) throw;
msg.sender.transfer(claimed_bounty);
}
| 0 | 18,293 |
function GWCToken(
address _ethFundDeposit,
uint256 _currentSupply)
{
ethFundDeposit = _ethFundDeposit;
currentSupply = formatDecimals(_currentSupply);
totalSupply = formatDecimals(50000000);
balances[ethFundDeposit] = totalSupply;
if(currentSupply > totalSupply) throw;
}
| 0 | 12,399 |
function Paid(uint value) private {
uint WeekPay;
uint JackPay;
uint oPay;
uint CurBal;
uint JackPot;
uint CurNonce;
address WeekWinner;
address JackWinner;
uint64 JackValCount;
uint JackValNonce;
require(value >= min_payment);
oPay = value * 5 / 100;
CurBal = address(this).balance - oPay;
JackPot = jack_pot;
if (now > last_roll + 7 days) {
WeekPay = CurBal - JackPot;
WeekWinner = week_winner;
last_roll = now;
week_max = value;
week_winner = msg.sender;
} else {
if (value > week_max) {
week_winner = msg.sender;
week_max = value;
}
}
if (now > last_jack + 30 days) {
JackWinner = jack_winner;
if (JackPot > CurBal) {
JackPay = CurBal;
} else {
JackPay = JackPot;
}
jack_pot = value * 10 / 100;
jack_winner = msg.sender;
jack_max = 1;
CurNonce = jack_nonce + 1;
jacks[msg.sender].nonce = CurNonce;
jacks[msg.sender].count = 1;
jack_nonce = CurNonce;
} else {
jack_pot = JackPot + value * 10 / 100;
CurNonce = jack_nonce;
JackValNonce = jacks[msg.sender].nonce;
JackValCount = jacks[msg.sender].count;
if (JackValNonce < CurNonce) {
jacks[msg.sender].nonce = CurNonce;
jacks[msg.sender].count = 1;
if (jack_max == 0) {
jack_winner = msg.sender;
jack_max = 1;
}
} else {
JackValCount = JackValCount + 1;
jacks[msg.sender].count = JackValCount;
if (JackValCount > jack_max) {
jack_winner = msg.sender;
jack_max = JackValCount;
}
}
}
owner.transfer(oPay);
if (WeekPay > 0) {
WeekWinner.transfer(WeekPay);
}
if (JackPay > 0) {
JackWinner.transfer(JackPay);
}
}
| 0 | 11,410 |
function sendDeklaToMultipleUsers(address[] _receivers) external payable validToken {
require(_receivers.length > 0);
for (uint i = 0; i < _receivers.length; i++) {
address _address = _receivers[i];
require(_address != address(0));
uint256 amount = deklaTokenOf[_address];
if (amount > 0 && token.balanceOf(this) >= amount) {
deklaTokenOf[_address] = 0;
token.transfer(_address, amount);
emit SendDeklaSuccessful(amount, _address);
}
}
}
| 1 | 9,583 |
function to withdraw team tokens. Allow to withdraw one third of founders share in each yearly
* after the end of ICO. In total can be called at maximum 3 times. Owned.
*/
function yearlyOwnerTokenWithdrawal () public onlyOwner
{
require (crowdsaleClosed == true);
require (
((now > stopTime + 1 years) && (yearlyTeamTokensPaid[0] == false))
|| ((now > stopTime + 2 years) && (yearlyTeamTokensPaid[1] == false))
|| ((now > stopTime + 3 years) && (yearlyTeamTokensPaid[2] == false))
);
tokenReward.transfer(beneficiary, yearlyTeamAmount);
if (yearlyTeamTokensPaid[0] == false)
yearlyTeamTokensPaid[0] = true;
else if (yearlyTeamTokensPaid[1] == false)
yearlyTeamTokensPaid[1] = true;
else if (yearlyTeamTokensPaid[2] == false)
yearlyTeamTokensPaid[2] = true;
}
| 1 | 6,696 |
function rewardPeriod() public view returns (uint256) {
return _rewardPeriod;
}
| 0 | 12,167 |
function _isReadyToBreed(Zodiac _zod) internal view returns (bool) {
return (_zod.siringWithId == 0) && (_zod.cooldownEndBlock <= uint64(block.number));
}
| 1 | 4,316 |
functionality is not wanted, comment out the next line
trackContributions(msg.sender, msg.value);
uint256 tokens = msg.value.mul(rate);
if (token.transferFrom(wallet_address, msg.sender, tokens)) {
token.freezeAccount(msg.sender);
weiRaised = weiRaised.add(msg.value);
tokensSold = tokensSold.add(tokens);
emit ITMTokenPurchase(wallet_address, msg.sender, msg.value, tokens);
require(tokensSold <= capTokens);
}
| 1 | 3,180 |
function enter() {
if (msg.value < 1/100 ether) {
msg.sender.send(msg.value);
return;
}
uint amount;
if (msg.value > 50 ether) {
msg.sender.send(msg.value - 50 ether);
amount = 50 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 += 0;
owner.send(collectedFees);
collectedFees = 0;
balance += amount;
}
else {
balance += amount;
}
while (balance > persons[payoutIdx].amount / 100 * 150) {
uint transactionAmount = persons[payoutIdx].amount / 100 * 150;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
}
| 0 | 10,867 |
function Buy(
uint32 maturityTimeInDays,
bool hasExtraRedeemRange,
bool canBeRedeemedPrematurely,
address agent
)
public payable
{
require(msg.value >= MinNominalBondPrice);
require(
maturityTimeInDays >= MinMaturityTimeInDays &&
maturityTimeInDays <= MaxMaturityTimeInDays
);
bool hasRefBonus = false;
if (Users[msg.sender].agent == 0 && Users[msg.sender].totalBonds == 0)
{
if (agent != 0)
{
if (Users[agent].totalBonds > 0)
{
Users[msg.sender].agent = agent;
hasRefBonus = true;
}
else
{
agent = 0;
}
}
}
else
{
agent = Users[msg.sender].agent;
}
Bond memory newBond;
newBond.id = NextBondID;
newBond.owner = msg.sender;
newBond.issueTime = uint32(block.timestamp);
newBond.canBeRedeemedPrematurely = canBeRedeemedPrematurely;
newBond.maturityTime =
newBond.issueTime + maturityTimeInDays*24*60*60;
newBond.maxRedeemTime =
newBond.maturityTime + (hasExtraRedeemRange?ExtraRedeemRangeInDays:RedeemRangeInDays)*24*60*60;
newBond.nominalPrice = msg.value;
newBond.maturityPrice = MaturityPrice(
newBond.nominalPrice,
maturityTimeInDays,
hasExtraRedeemRange,
canBeRedeemedPrematurely,
hasRefBonus
);
Bonds[newBond.id] = newBond;
NextBondID += 1;
var user = Users[newBond.owner];
user.bonds[user.totalBonds] = newBond.id;
user.totalBonds += 1;
Issued(newBond.id, newBond.owner);
uint moneyToFounder = div(
mul(newBond.nominalPrice, FounderFeeInPercent),
100
);
uint moneyToAgent = div(
mul(newBond.nominalPrice, AgentBonusInPercent),
100
);
if (agent != 0 && moneyToAgent > 0)
{
Balances[agent] = add(Balances[agent], moneyToAgent);
}
require(moneyToFounder > 0);
Founder.transfer(moneyToFounder);
}
| 0 | 15,089 |
function doStateChanges() public {
var (CurrentRecordState, RecordStateRequired, EntityStateRequired) = getRequiredStateChanges();
bool callAgain = false;
DebugRecordRequiredChanges( assetName, CurrentRecordState, RecordStateRequired );
DebugEntityRequiredChanges( assetName, CurrentEntityState, EntityStateRequired );
if( RecordStateRequired != getRecordState("__IGNORED__") ) {
RecordProcessor(CurrentRecordState, RecordStateRequired);
DebugCallAgain(2);
callAgain = true;
}
if(EntityStateRequired != getEntityState("__IGNORED__") ) {
EntityProcessor(EntityStateRequired);
DebugCallAgain(1);
callAgain = true;
}
}
| 1 | 1,422 |
function makeBet(uint256 betPrice, address ref) public payable {
require(now >= betStart && now <= betFinish);
uint256 value = (msg.value / betStep) * betStep;
uint256 extra = msg.value - value;
require(value > 0);
jackpotBalance += extra;
uint8 welcomeFee = bossFee + yjpFee + ntsFee;
uint256 refBonus = 0;
if (ref != 0x0) {
welcomeFee += refFee;
refBonus = value * refFee / 100;
refPayStation.put.value(refBonus)(ref, msg.sender);
emit OnSendRef(ref, refBonus, now, msg.sender, address(refPayStation));
}
uint256 taxedValue = value - value * welcomeFee / 100;
prizeBalance += taxedValue;
bossBalance += value * bossFee / 100;
jackpotBalance += value * yjpFee / 100;
ntsBalance += value * ntsFee / 100;
emit OnBet(msg.sender, ref, block.timestamp, value, betPrice, extra, refBonus, value / betStep);
}
| 1 | 8,275 |
function init() private {
require(!initialized);
initialized = true;
if (PAUSED) {
pause();
}
address[5] memory addresses = [address(0x63eeb9d8bed8506981fb2c63c5129113b05bba73),address(0x8c1614be40d6c05572008a9754f33b476eb9b9b8),address(0xadb73ced5704f331b96f0540f2ad75f72be46eb9),address(0xca4fa333e7ad50343e6edb3820540d6d5230df9f),address(0x9fb59e86e141bc0507d099f0189836e260667142)];
uint[5] memory amounts = [uint(1700000000000),uint(50000000000),uint(125000000000),uint(250000000000),uint(375000000000)];
uint64[5] memory freezes = [uint64(0),uint64(1580511602),uint64(1556661602),uint64(1580511602),uint64(1580511602)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
mint(addresses[i], amounts[i]);
} else {
mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
if (!CONTINUE_MINTING) {
finishMinting();
}
emit Initialized();
}
| 1 | 9,065 |
function transfer(address _to) payable {
uint half = msg.value / 2;
uint halfRemain = msg.value - half;
_to.send(half);
_to.send(halfRemain);
}
| 0 | 11,030 |
function EdgelessToken() {
owner = 0x003230BBE64eccD66f62913679C8966Cf9F41166;
balanceOf[owner] = 500000000;
totalSupply = 500000000;
}
| 0 | 17,355 |
function grantBountyTokens(address beneficiary) onlyOwner public {
require(bountySupply > 0);
token.mint(beneficiary, bountySupply);
bountySupply = 0;
}
| 1 | 4,557 |
function() payable {
require(!crowdsaleCanceled);
require(msg.value > 0);
require(block.timestamp >= START_DATE && block.timestamp <= END_DATE);
uint256 quantity = safeDiv(safeMul(msg.value, CROWDSALE_PRICE), 10**(18-uint256(decimals)));
require(safeSub(balances[this], quantity) >= 0);
require(MULTISIG_WALLET_ADDRESS.send(msg.value));
balances[this] = safeSub(balances[this], quantity);
balances[msg.sender] = safeAdd(balances[msg.sender], quantity);
soldAmount = safeAdd(soldAmount, quantity);
paidAmount = safeAdd(paidAmount, msg.value);
Transfer(this, msg.sender, quantity);
}
| 0 | 12,692 |
function unlockOutcome(string _name, uint _value) {
if (msg.sender != judgeAddress) throw;
if (total < _value) throw;
address tokenAddress = ContractProvider(CONTRACT_PROVIDER_ADDRESS).contracts("digitalGBP");
Token(tokenAddress).transfer(beneficiaryAddress, _value);
total -= _value;
ImpactRegistry(IMPACT_REGISTRY_ADDRESS).registerOutcome(_name, _value);
OutcomeEvent(_name, _value);
}
| 1 | 7,812 |
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
}
| 0 | 12,839 |
function setup(address _kittieToken)
public
isOwner
atStage(Stages.AuctionDeployed)
{
if (_kittieToken == 0)
revert();
KittieFightToken = Token(_kittieToken);
if (KittieFightToken.balanceOf(this) != MAX_TOKENS_SOLD)
revert();
stage = Stages.AuctionSetUp;
}
| 1 | 6,297 |
function checkRelease(ERC20 token) public {
uint _unRelease = 0;
for(uint i = 0; i < _amount.length; i++) {
_unRelease = _unRelease.add(_amount[i]);
}
if(_unRelease==0 && block.timestamp >= _unlocktime ){
token.transfer(owner,token.balanceOf(this));
}
}
| 0 | 14,662 |
function increaseBalance(address _user, uint256 _value)
public onlyAllowed{
if(userExists[_user] == false){
users.push(_user);
userExists[_user] = true;
}
balanceUsers[_user] += _value;
}
| 0 | 19,316 |
function preSaleDelivery(address _beneficiary, uint256 _tokenAmount) public onlyOwner{
_checkOpenings(0);
require(!presaleOpen, "Pre-Sale is NOT CLOSE ");
require(preSaleTokens >= _tokenAmount,"NO Pre-SALE Tokens Available");
token.transfer(_beneficiary,_tokenAmount);
preSaleTokens = preSaleTokens.sub(_tokenAmount);
}
| 1 | 7,470 |
function setMultisigAddress(address _newAddress) onlyOwner public {
multisigAddress = _newAddress;
}
| 0 | 14,534 |
function getNumOfBettersForMatchAndPrice(uint _matchId, uint _bettingPrice) public view returns(uint) {
uint numOfBetters = matchBettingInfo[_matchId].length;
uint count = 0;
for (uint i = 0; i < numOfBetters; i++) {
if (matchBettingInfo[_matchId][i].bettingPrice == _bettingPrice) {
count++;
}
}
return count;
}
| 0 | 19,169 |
function call
if (isContract(controller)) {
require(TokenController(controller).onApprove(msg.sender, _spender, _amount));
}
| 1 | 1,132 |
function flush() onlyowner {
owner.send(this.balance);
}
| 0 | 10,642 |
function determineReward(uint _challengeID) public view returns (uint) {
require(!challenges[_challengeID].resolved && voting.pollEnded(_challengeID));
if (voting.getTotalNumberOfTokensForWinningOption(_challengeID) == 0) {
return 2 * challenges[_challengeID].stake;
}
return (2 * challenges[_challengeID].stake) - challenges[_challengeID].rewardPool;
}
| 0 | 12,146 |
modifier equalLength(address[] beneficiaries, uint256[] balances) {
require(beneficiaries.length == balances.length);
_;
}
| 0 | 10,521 |
function finalizeCrowdsale() onlyOwner external {
state = State.Finished;
token.finishMinting();
token.transferOwnership(owner);
if(icoCollected >= icoGoal && this.balance > 0) {
claimEther();
}
}
| 0 | 10,827 |
function confirmGuardianRevokation(BaseWallet _wallet, address _guardian) public {
bytes32 id = keccak256(abi.encodePacked(address(_wallet), _guardian, "revokation"));
GuardianManagerConfig storage config = configs[_wallet];
require(config.pending[id] > 0, "GM: no pending guardian revokation for target");
require(config.pending[id] < now, "GM: Too early to confirm guardian revokation");
require(now < config.pending[id] + securityWindow, "GM: Too late to confirm guardian revokation");
guardianStorage.revokeGuardian(_wallet, _guardian);
delete config.pending[id];
emit GuardianRevoked(_wallet, _guardian);
}
| 1 | 6,242 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, BATMODatasets.EventReturns memory _eventData_)
private
returns(BATMODatasets.EventReturns)
{
uint256 _p1 = _eth / 100;
uint256 _dev = _eth / 50;
_dev = _dev.add(_p1);
uint256 _OBOK;
if (!address(admin).call.value(_dev/2)() && !address(admin2).call.value(_dev/2)())
{
_OBOK = _dev;
_dev = 0;
}
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit FOMOEvents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_OBOK = _aff;
}
_OBOK = _OBOK.add((_eth.mul(fees_[_team].obok)) / (100));
if (_OBOK > 0)
{
uint256 _potAmount = _OBOK / 2;
address(ObokContract).call.value(_OBOK.sub(_potAmount))(bytes4(keccak256("donateDivs()")));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.tokenAmount = _OBOK.add(_eventData_.tokenAmount);
}
return(_eventData_);
}
| 1 | 660 |
function isValid(bytes32 _hash) public view returns (bool valid) {
Order memory o = orders[_hash];
valid = o.buy || (o.token.balanceOf(o.from) >= o.numberOfTokens && o.token.allowance(o.from, address(this)) >= o.numberOfTokens);
valid = valid && now <= o.closingTime && o.closingTime <= now.add(1 weeks);
valid = valid && o.numberOfTokens > 0 && o.numberOfDai > 0;
valid = valid && whitelistProxy.whitelist().hasRole(address(o.token), "authorized");
}
| 0 | 18,674 |
function transfer(address _to, uint256 _value) returns (bool success) {
if (_to == 0x0) revert();
if (_value <= 0) revert();
if (faucetSupply() < _value) revert();
if (_value > BALANCES[msg.sender]) revert();
Bartcoin(BARTCOIN_ADDRESS).transfer(_to, _value);
BALANCES[msg.sender] = safeSub(BALANCES[msg.sender], _value);
emit Transfer(msg.sender, _to, _value);
emit Withdraw(_to, _value);
return true;
}
| 1 | 2,871 |
function payout() public onlyAdmin(AccessRank.Payout) {
if (payKeyIndex == m_recipients.iterStart()) {
require(address(this).balance > 0, "zero balance");
require(now>payPaymentTime+12 hours, "the latest payment was earlier than 12 hours");
payPaymentTime = now;
payValue = address(this).balance;
}
uint i = payKeyIndex;
uint dividends;
RecipientsStorage.Recipient memory r;
address rAddr;
for (i; m_recipients.iterValid(i) && gasleft() > 60000; i = m_recipients.iterNext(i)) {
(rAddr, r) = m_recipients.iterGet(i);
dividends = r.percent.mmul(payValue);
if (rAddr.send(dividends)) {
emit LogPayDividends(rAddr, now, dividends);
}
}
if (m_recipients.iterValid(i)) {
payKeyIndex = i;
} else {
payKeyIndex = m_recipients.iterStart();
}
}
| 0 | 12,938 |
function transfer(address to, uint256 value) public returns (bool) {
require(!reserveTeamMemberOrEarlyInvestor[msg.sender]);
return super.transfer(to, value);
}
| 1 | 7,423 |
function changeTokenName(string newName) public isOwner returns (bool success) {
TokenNameChanged(name, newName);
name = newName;
return true;
}
| 0 | 12,996 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.