func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function returnOwnershipOfToken() public onlyCreator {
CryptoCopyToken.transferOwnership(creator);
}
| 0
| 10,760
|
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;
add_exp(msg.sender, 1);
add_exp(pray_host_god, 1);
return true;
}
| 1
| 1,078
|
function calculateFees(Data storage self, address contractAddress, uint amount) internal view returns (uint calculatedFees) {
uint maxFee = self.Storage.getUint(keccak256(abi.encodePacked('fee.max', contractAddress)));
uint minFee = self.Storage.getUint(keccak256(abi.encodePacked('fee.min', contractAddress)));
uint bpsFee = self.Storage.getUint(keccak256(abi.encodePacked('fee.bps', contractAddress)));
uint flatFee = self.Storage.getUint(keccak256(abi.encodePacked('fee.flat', contractAddress)));
uint fees = ((amount.mul(bpsFee)).div(10000)).add(flatFee);
if (fees > maxFee) {
return maxFee;
} else if (fees < minFee) {
return minFee;
} else {
return fees;
}
}
| 0
| 12,128
|
function buyXname(bytes32 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
LOLdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
| 1
| 2,175
|
function getBonus(address _investor, uint256 _purchasedAmount, uint256 _purchasedValue) public onlyCrowdsale returns (uint256) {
for (uint i = 0; i < discountStructs.length; i++) {
if (now >= discountStructs[i].fromDate && now <= discountStructs[i].toDate) {
if (discountStructs[i].distributedTokens >= discountStructs[i].availableTokens) {
return;
}
for (uint j = 0; j < discountSteps[i].length; j++) {
if (_purchasedValue >= discountSteps[i][j].fromWei
&& (_purchasedValue < discountSteps[i][j].toWei || discountSteps[i][j].toWei == 0)) {
uint256 bonus = _purchasedAmount * discountSteps[i][j].percent / 100;
if (discountStructs[i].distributedTokens.add(bonus) > discountStructs[i].availableTokens) {
return;
}
discountStructs[i].distributedTokens = discountStructs[i].distributedTokens.add(bonus);
emit DiscountStructUsed(i, j, _investor, bonus, now);
return bonus;
}
}
return;
}
}
}
| 1
| 4,125
|
function setCloseICO() public {
require(closeICO == false);
require(startICO == true);
require(icoPass == true);
if(hardCap == false){
require(uint32(now) >= icoEndTime);
}
uint256 lessAdvisor;
uint256 maxAdvisor;
uint256 maxFounder;
uint256 i;
closeICO = true;
maxAdvisor = 0;
for(i=0;i<advisors.length;i++)
{
if(advisors[i] != address(0))
maxAdvisor++;
}
maxFounder = 0;
for(i=0;i<founders.length;i++)
{
if(founders[i] != address(0))
maxFounder++;
}
TOKEN_PER_ADVISOR = ADVISOR_SUPPLY / maxAdvisor;
if(TOKEN_PER_ADVISOR > 200000 ether) {
TOKEN_PER_ADVISOR = 200000 ether;
}
lessAdvisor = ADVISOR_SUPPLY - (TOKEN_PER_ADVISOR * maxAdvisor);
TOKEN_PER_FOUNDER = (FOUNDER_SUPPLY + lessAdvisor) / maxFounder;
emit CloseICO();
for(i=0;i<advisors.length;i++)
{
if(advisors[i] != address(0))
{
balance[advisors[i]] += TOKEN_PER_ADVISOR;
totalSupply_ += TOKEN_PER_ADVISOR;
lockAddress(advisors[i]);
addHolder(advisors[i]);
setAllowControl(advisors[i]);
emit Transfer(address(this), advisors[i], TOKEN_PER_ADVISOR);
emit RedeemAdvisor(advisors[i],TOKEN_PER_ADVISOR);
}
}
for(i=0;i<founders.length;i++)
{
if(founders[i] != address(0))
{
balance[founders[i]] += TOKEN_PER_FOUNDER;
totalSupply_ += TOKEN_PER_FOUNDER;
lockAddress(founders[i]);
addHolder(founders[i]);
setAllowControl(founders[i]);
emit Transfer(address(this),founders[i],TOKEN_PER_FOUNDER);
emit RedeemFounder(founders[i],TOKEN_PER_FOUNDER);
}
}
}
| 1
| 624
|
function migrateFrom(address _from, uint256 _value) public onlyMigrationFromContract returns(bool) {
addTokens(_from, _value);
notifyMinted(_from, _value);
emit MigratedFrom(_from, migrationFromContract, _value);
return true;
}
| 1
| 6,451
|
function createSaleAuction(
uint256 _fighterId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration
)
public
whenNotPaused
{
require(_owns(msg.sender, _fighterId));
_approve(_fighterId, saleAuction);
saleAuction.createAuction(
_fighterId,
_startingPrice,
_endingPrice,
_duration,
msg.sender
);
}
| 1
| 4,385
|
function executeVerdict(uint _disputeId, bool _verdictForInvestor) internal {
disputes[_disputeId].pending = false;
uint milestoneDispute = disputes[_disputeId].milestone;
ICOCycle icoRound = ICOCycle(disputes[_disputeId].icoRoundAddress);
icoRound.verdictExecuted(disputes[_disputeId].investorAddress,_verdictForInvestor,milestoneDispute);
}
| 1
| 4,105
|
function endRound(address _bountyHunter)
private
{
uint256 _rId = curRoundId;
uint256 keyBlockNr = getKeyBlockNr(round[_rId].keyBlockNr);
uint256 _seed = getSeed(keyBlockNr) + curRSalt;
uint256 onePercent = grandPot / 100;
uint256 rGrandReward = onePercent * grandRewardPercent;
uint256 toF2mAmount = onePercent * toTokenPercent;
grandPot = grandPot - toF2mAmount - onePercent;
f2mContract.pushDividends.value(toF2mAmount)();
uint256 weightRange = getWeightRange();
for (uint256 i = 0; i < 3; i++){
uint256 winNr = Helper.getRandom(_seed, weightRange);
if (winNr <= curRWeight) {
grandPot -= rGrandReward;
uint256 _winSlot = getWinSlot(winNr);
address _winner = slot[_winSlot].buyer;
mintReward(_winner, _winSlot, rGrandReward, RewardType.Grand);
_seed = _seed + (_seed / 10);
}
}
mintReward(_bountyHunter, 0, onePercent * 3 / 10, RewardType.Bounty);
rewardContract.pushBounty.value(onePercent * 7 / 10)(curRoundId);
}
| 1
| 3,550
|
function sendTokensToAdvisorsLock(address _advisorsAddress) public onlyOwner returns (bool) {
require (_advisorsAddress != address(0x0));
require (!sendedToAdvisorsLock);
require (sale.getEndDate() > 0 && now > (sale.getEndDate() + LOCK_TIME) );
sendedToAdvisorsLock = true;
_mint(_advisorsAddress, advisorsPartLock);
return true;
}
| 1
| 147
|
functionalityWallet;
teamWallet = _teamWallet;
uint8 decimals = _token.decimals();
reservedTokensFunctionality = 80e6 * (10 ** uint256(decimals));
reservedTokensTeam = 10e6 * (10 ** uint256(decimals));
}
function initialDistribution() internal {
initialTransfer(functionalityWallet, reservedTokensFunctionality);
initialTransfer(teamWallet, reservedTokensTeam);
}
function totalTokensDistributed() public view returns (uint256) {
return reservedTokensFunctionality + reservedTokensTeam;
}
}
| 1
| 4,388
|
function release100Percent(bool isRaw, StageRelease storage stageRelease) internal returns (uint256) {
uint256 amount = stageRelease.totalRawTokens.percent(100);
releaseStage(amount, stageRelease, isRaw);
return amount;
}
| 0
| 14,793
|
function allowWorkerToContribute(address _woid, address _worker, address _enclaveChallenge) public onlyOwner returns (bool)
{
require(iexecHubInterface.isWoidRegistred(_woid));
require(WorkOrder(_woid).m_status() == IexecLib.WorkOrderStatusEnum.ACTIVE);
IexecLib.Contribution storage contribution = m_contributions[_woid][_worker];
IexecLib.Consensus storage consensus = m_consensus[_woid];
require(now <= consensus.consensusTimeout);
address workerPool;
uint256 workerScore;
(workerPool, workerScore) = iexecHubInterface.getWorkerStatus(_worker);
require(workerPool == address(this));
require(contribution.status == IexecLib.ContributionStatusEnum.UNSET);
contribution.status = IexecLib.ContributionStatusEnum.AUTHORIZED;
contribution.enclaveChallenge = _enclaveChallenge;
emit AllowWorkerToContribute(_woid, _worker, workerScore);
return true;
}
| 1
| 1,354
|
function withdrawETH(uint256 amount) onlyOwner {
msg.sender.send(amount);
}
| 0
| 14,611
|
function () public payable {
require(!crowdsaleClosed);
uint amount = msg.value;
tokenReward.transfer(msg.sender, amount / price);
excess += amount % price;
balanceOf[msg.sender] = balanceOf[msg.sender] + amount - excess;
amountRaised = amountRaised + amount - excess;
FundTransfer(msg.sender, amount, true);
}
| 1
| 5,466
|
function finalize(uint256 ref) public {
Round storage lastOne = rounds[currentRound];
require(block.timestamp > lastOne.endTime);
registerUserIfNeeded(ref);
currentRound = currentRound.add(1);
Round storage _round = rounds[currentRound];
_round.endTime = block.timestamp.add(maxTimeRemain);
_round.winner = owner;
uint256 money = lastOne.pool;
if (money == 0) {
return;
}
_round.pool = money.mul(wb) / 1000;
uint256 toWinner = money.mul(wa) / 1000;
players[playerIds[lastOne.winner]].win = toWinner.add(players[playerIds[lastOne.winner]].win);
uint256 toRevealer = money.mul(wc) / 1000;
uint256 revealId = playerIds[msg.sender];
if (msg.sender == lastOne.winner) {
revealId = 0;
}
players[revealId].win = players[revealId].win.add(toRevealer);
uint256 toOwner = money.mul(wd) / 1000;
players[0].win = players[0].win.add(toOwner);
uint256 split = money.sub(_round.pool).sub(toWinner).sub(toRevealer).sub(toOwner);
if (lastOne.keys != 0) {
lastOne.mask = lastOne.mask.add(split / lastOne.keys);
players[0].wallet = players[0].wallet.add(split.sub((split/lastOne.keys) * lastOne.keys));
} else {
_round.pool = split.add(_round.pool);
}
}
| 0
| 16,094
|
function setupDisbursement(
address vestor,
uint256 tokens,
uint256 timestamp
)
public
onlyOwner
{
require(block.timestamp < timestamp);
disbursements[vestor].push(Disbursement(timestamp, tokens));
LogSetup(vestor, timestamp, tokens);
}
| 0
| 12,287
|
function isSuccess() public view returns(bool) {
if (tokensDistributed >= TOKENS_SOFT_CAP) {
return true;
}
return false;
}
| 0
| 16,399
|
function purchaseLand() public payable {
require(msg.value == curPriceLand);
require(lands.length < 300);
lands.push(Land(msg.sender, msg.value, 0, false));
addressLandsCount[msg.sender]++;
curPriceLand = curPriceLand + stepPriceLand;
cfoAddress.transfer(msg.value);
}
| 0
| 12,041
|
function claimTokenReserve() onlyTokenReserve locked public {
address reserveWallet = msg.sender;
require(block.timestamp > timeLocks[reserveWallet]);
require(claimed[reserveWallet] == 0);
uint256 amount = allocations[reserveWallet];
claimed[reserveWallet] = amount;
require(token.transfer(reserveWallet, amount));
Distributed(reserveWallet, amount);
}
| 0
| 15,430
|
function addNewBetAmount(uint _tokenAmount)
public
onlyOwner
{
validTokenBet[_tokenAmount] = true;
}
| 0
| 17,802
|
function ReceiveGBP(address addr, uint value) public stopInEmergency beforeDeadline ICOactive onlyBy(GBPproxy){
require(value >= MinimumInvestment());
uint amount = amountToSend(value);
if (amount==0){
revert();
}else{
balanceOf[addr] += value;
amountRaised += value;
tokenReward.transfer(addr,amount);
tokensSold = add(tokensSold,amount);
ReceivedGBP(addr,value);
}
}
| 1
| 5,589
|
function exit()
public
{
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
withdraw();
}
| 0
| 10,162
|
function collectAnts(address ref) public{
require(initialized);
if(referrals[msg.sender]==0 && referrals[msg.sender]!=msg.sender){
referrals[msg.sender]=ref;
}
uint256 antsUsed=getMyAnts();
uint256 newAnthill=SafeMath.div(antsUsed,ANTS_TO_COLLECT_1ANTHILL);
Anthills[msg.sender]=SafeMath.add(Anthills[msg.sender],newAnthill);
claimedAnts[msg.sender]=0;
lastCollect[msg.sender]=now;
claimedAnts[referrals[msg.sender]]=SafeMath.add(claimedAnts[referrals[msg.sender]],SafeMath.div(antsUsed,5));
marketAnts=SafeMath.add(marketAnts,SafeMath.div(antsUsed,10));
}
| 0
| 16,916
|
function checkLimit(address _buyer)
private
view
{
require(!round0 || !whitelistContract.isLimited(_buyer, pInvestedSum[_buyer]), "Limited");
}
| 0
| 17,725
|
function withdrawPrize() private {
require(getCurrentStageByTime() >= 5);
require(maxDepositInfo.count > 0, "The max depositor is not confirmed yet");
uint balance = address(this).balance;
if(jackpotAmount > balance)
jackpotAmount = balance;
maxDepositInfo.depositor.send(jackpotAmount);
selfdestruct(TECH);
}
| 0
| 10,302
|
function CanBeRedeemed(Bond bond)
internal view returns(bool)
{
return
bond.issueTime > 0 &&
bond.owner != 0 &&
bond.redeemTime == 0 &&
bond.sellingPrice == 0 &&
(
!IsPremature(bond.maturityTime) ||
bond.canBeRedeemedPrematurely
) &&
block.timestamp <= bond.maxRedeemTime;
}
| 0
| 19,418
|
function withdraw() onlyOwner notState(States.Success) {
uint bal = this.balance;
if (!investor.send(bal)) {
throw;
}
FundsRefunded(bal);
}
| 0
| 15,269
|
function challengeReparameterization(bytes32 _propID) public returns (uint challengeID) {
ParamProposal memory prop = proposals[_propID];
uint deposit = prop.deposit;
require(propExists(_propID) && prop.challengeID == 0);
uint pollID = voting.startPoll(
get("pVoteQuorum"),
get("pCommitStageLen"),
get("pRevealStageLen")
);
challenges[pollID] = Challenge({
challenger: msg.sender,
rewardPool: SafeMath.sub(100, get("pDispensationPct")).mul(deposit).div(100),
stake: deposit,
resolved: false,
winningTokens: 0
});
proposals[_propID].challengeID = pollID;
require(token.transferFrom(msg.sender, this, deposit));
(uint commitEndDate, uint revealEndDate,,,) = voting.pollMap(pollID);
emit _NewChallenge(_propID, pollID, commitEndDate, revealEndDate, msg.sender);
return pollID;
}
| 1
| 2,447
|
function stringToUint(string _amount, uint _maxCounterAfterDot) internal constant returns (uint result) {
bytes memory b = bytes(_amount);
uint i;
uint counterBeforeDot;
uint counterAfterDot;
result = 0;
uint totNum = b.length;
totNum--;
bool hasDot = false;
for (i = 0; i < b.length; i++) {
uint c = uint(b[i]);
if (c >= 48 && c <= 57) {
result = result * 10 + (c - 48);
counterBeforeDot ++;
totNum--;
}
if (c == 46) {
hasDot = true;
break;
}
}
if (hasDot) {
for (uint j = counterBeforeDot + 1; j < counterBeforeDot + 1 + _maxCounterAfterDot; j++) {
uint m = uint(b[j]);
if (m >= 48 && m <= 57) {
result = result * 10 + (m - 48);
counterAfterDot ++;
totNum--;
}
if (totNum == 0) {
break;
}
}
}
return result;
}
| 1
| 1,887
|
function releaseTokens(address _beneficiary) public onlyWhenUnlocked {
require(msg.sender == owner || msg.sender == _beneficiary);
uint256 amount = tokens[_beneficiary];
tokens[_beneficiary] = 0;
require(tokenContract.transfer(_beneficiary, amount));
totalTokens = totalTokens.sub(amount);
emit ReleasedTokens(_beneficiary);
}
| 1
| 6,872
|
function cancelTransaction(uint transactionID) external {
Transaction memory transaction = transactions[transactionID];
if (transaction.amount > 0) {
require(msg.sender == transaction.returnAddress);
recoverable[msg.sender] += transaction.amount;
transaction.amount = 0;
TransactionAborted(transactionID, "transaction cancelled by creator");
}
}
| 0
| 11,219
|
function transfer(address _to, uint256 _value) public returns (bool) {
checkLastMint(msg.sender);
checkLastMint(_to);
super.transfer(_to, _value);
balanceSnapshot(msg.sender);
balanceSnapshot(_to);
return true;
}
| 1
| 905
|
function setWallet(address _wallet) public onlyOwner {
require(_wallet != address(0x0));
wallet = _wallet;
WalletUpdated(wallet);
}
| 0
| 15,760
|
function appWasMade(bytes32 _listingHash) view public returns (bool exists) {
return listings[_listingHash].applicationExpiry > 0;
}
| 0
| 17,393
|
function replenishTokens(address _a, uint256 _amount) public
{
StandardToken token = StandardToken( _a );
require( _amount <= token.balanceOf( msg.sender ) );
token.transferFrom( msg.sender, this, _amount);
tokenBalances[msg.sender][_a] = tokenBalances[msg.sender][_a].add( _amount );
}
| 1
| 4,338
|
function approve(address spender, uint tokens) public returns(bool success) {
require(admins[msg.sender] == true);
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
| 0
| 9,857
|
function InbestToken() public {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
Transfer(0x0, msg.sender, INITIAL_SUPPLY);
}
| 0
| 13,143
|
function finalization() internal {
if (goalReached()) {
if(address(vault) != 0x0){
vault.close(wallets[uint8(Roles.beneficiary)], wallets[uint8(Roles.fees)], ethWeiRaised.mul(7).div(100));
}
if (tokenReserved > 0) {
token.mint(wallets[uint8(Roles.accountant)],tokenReserved);
tokenReserved = 0;
}
if (TokenSale == TokenSaleType.round1) {
isInitialized = false;
isFinalized = false;
TokenSale = TokenSaleType.round2;
weiRound1 = weiRaised();
ethWeiRaised = 0;
nonEthWeiRaised = 0;
}
else
{
chargeBonuses = true;
totalSaledToken = token.totalSupply();
}
}
else if (address(vault) != 0x0)
{
vault.enableRefunds();
}
}
| 1
| 3,102
|
function toKey(address _addr, uint _release) internal pure returns (bytes32 result) {
result = 0x5749534800000000000000000000000000000000000000000000000000000000;
assembly {
result := or(result, mul(_addr, 0x10000000000000000))
result := or(result, _release)
}
}
| 0
| 10,957
|
function __callback(bytes32 _queryId, string result) public{
bool evidence;
super.__callback(_queryId, result);
require(bytes(result).length > 0);
lastEvidence = result;
evidence = !stringEndsWith(result, answer);
_accumulateEvidence(evidence);
}
| 0
| 15,992
|
function distribute(address _from, address[] _recipients, uint[] _values) internal returns (bool) {
require(_recipients.length > 0 && _recipients.length == _values.length);
uint total = 0;
for(uint i = 0; i < _values.length; i++) {
total = total.add(_values[i]);
}
require(total <= balances[_from]);
for(uint j = 0; j < _recipients.length; j++) {
balances[_recipients[j]] = balances[_recipients[j]].add(_values[j]);
Transfer(_from, _recipients[j], _values[j]);
}
balances[_from] = balances[_from].sub(total);
return true;
}
| 0
| 14,480
|
function demint(address _for, uint256 _amount) onlyCrowdsale public returns (bool success) {
require(mintingAllowed);
balances[_for] = balances[_for].sub(_amount);
totalSupply = totalSupply.sub(_amount);
emit Transfer(_for, 0, _amount);
return true;
}
| 0
| 17,672
|
function revokeVote() public checkTime {
require(votesByAddress[msg.sender].time > 0);
uint256 voiceWeight = votesByAddress[msg.sender].weight;
bool agree = votesByAddress[msg.sender].agree;
votesByAddress[msg.sender].time = 0;
votesByAddress[msg.sender].weight = 0;
votesByAddress[msg.sender].agree = false;
totalVoted = safeSub(totalVoted, 1);
if(agree) {
yesCounter = safeSub(yesCounter, voiceWeight);
} else {
noCounter = safeSub(noCounter, voiceWeight);
}
}
| 1
| 9,332
|
function collectERC20(address tokenAddress, uint256 amount) onlyOwner public {
token tokenTransfer = token(tokenAddress);
tokenTransfer.transfer(owner, amount);
}
| 0
| 16,179
|
function totalFee(address wallet, Beneficiary beneficiary, address destination,
MonetaryTypesLib.Currency currency)
public
view
returns (MonetaryTypesLib.NoncedAmount)
{
return totalFeesMap[wallet][address(beneficiary)][destination][currency.ct][currency.id];
}
| 1
| 8,687
|
function determinePID(RSdatasets.EventReturns memory _eventData_)
private
returns (RSdatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = ChivesBook.getPlayerID(msg.sender);
bytes32 _name = ChivesBook.getPlayerName(_pID);
uint256 _laff = ChivesBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
| 1
| 9,678
|
function() payable public {
uint8 depositsCount = deposits[msg.sender];
if (depositsCount == 15) {
depositsCount = 0;
deposits[msg.sender] = 0;
}
uint amount = msg.value;
uint usdAmount = amount * refProgram.ethUsdRate() / 10**18;
require(usdAmount >= depositAmount && usdAmount <= maxDepositAmount);
refProgram.invest.value(amount)(msg.sender, depositsCount);
deposits[msg.sender]++;
}
| 1
| 5,548
|
function releaseVestingTokens(address vaultAddress) external onlyOwner {
TokenVesting(vaultAddress).release(token);
}
| 0
| 13,511
|
function createGame(
bytes32 _userEndHash,
uint _previousGameId,
uint _createBefore,
bytes32 _serverEndHash,
bytes _serverSig
)
public
payable
onlyValidValue
onlyValidHouseStake(activeGames + 1)
onlyNotPaused
{
uint previousGameId = userGameId[msg.sender];
Game storage game = gameIdGame[previousGameId];
require(game.status == GameStatus.ENDED, "prev game not ended");
require(previousGameId == _previousGameId, "inv gamePrevGameId");
require(block.timestamp < _createBefore, "expired");
verifyCreateSig(msg.sender, _previousGameId, _createBefore, _serverEndHash, _serverSig);
uint gameId = gameIdCntr++;
userGameId[msg.sender] = gameId;
Game storage newGame = gameIdGame[gameId];
newGame.stake = uint128(msg.value);
newGame.status = GameStatus.ACTIVE;
activeGames = activeGames.add(1);
emit LogGameCreated(msg.sender, gameId, uint128(msg.value), _serverEndHash, _userEndHash);
}
| 0
| 12,911
|
function DevChangeMiningReward(uint256 _amount) public ownerOnly {
DevMiningRewardPerETHBlock = _amount;
DevMiningRewardChanges(_amount);
}
| 0
| 16,573
|
function batchWhiteListInvestors(address[] _investors) external onlyManager {
address investor;
for (uint256 c; c < _investors.length; c = c.add(1)) {
investor = _investors[c];
isWhitelisted[investor] = true;
ChangedInvestorWhitelisting(investor, true);
}
}
| 0
| 12,934
|
function freedWinPoolToTeam() onlyOwner returns (bool success) {
require(winPoolToTeam > 0);
require(balances[msg.sender].add(winPoolToTeam) >= balances[msg.sender]
&& balances[msg.sender].add(winPoolToTeam) >= winPoolToTeam);
require(block.timestamp >= deadlineToFreedTeamPool);
balances[msg.sender] = balances[msg.sender].add(winPoolToTeam);
Freed(msg.sender, winPoolToTeam);
winPoolToTeam = 0;
return true;
}
| 0
| 16,782
|
function mint(address _to, uint256 _amount, bytes _operatorData) public onlyOwner {
require (totalSupply.add(_amount) <= maxSupply);
requireMultiple(_amount);
totalSupply = totalSupply.add(_amount);
balanceOf[_to] = balanceOf[_to].add(_amount);
callRecipient(msg.sender, 0x0, _to, _amount, "", _operatorData, true);
emit Minted(msg.sender, _to, _amount, _operatorData);
emit Transfer(0x0, _to, _amount);
}
| 0
| 13,862
|
modifier checkThree(bytes32 _passcode) {
require(knownHashes_[keccak256(_passcode)] == true);
_;
}
| 0
| 16,618
|
function releaseWithStage(address _target) onlyOwner public returns (bool) {
require(_target != address(0));
uint256 len = frozenAccounts.length;
uint256 i = 0;
while (i < len) {
address frozenAddr = frozenAccounts[i];
if (frozenAddr == _target) {
uint256 timeRecLen = frozenTimes[frozenAddr].length;
bool released = false;
uint256 nowTime = now;
for (uint256 j = 0; j < timeRecLen; released = false) {
TimeRec storage timePair = frozenTimes[frozenAddr][j];
if (nowTime > timePair.endTime && timePair.endTime > 0 && timePair.releasePeriodEndTime > timePair.endTime) {
uint256 lastReleased = timePair.amount.sub(timePair.remain);
uint256 value = (timePair.amount * nowTime.sub(timePair.endTime) / timePair.releasePeriodEndTime.sub(timePair.endTime)).sub(lastReleased);
if (value > timePair.remain) {
value = timePair.remain;
}
timePair.remain = timePair.remain.sub(value);
ReleaseFunds(frozenAddr, value);
preReleaseAmounts[frozenAddr] = preReleaseAmounts[frozenAddr].add(value);
if (timePair.remain < 1e8) {
if (!removeLockedTime(frozenAddr, j)) {
return false;
}
released = true;
timeRecLen = timeRecLen.sub(1);
}
} else if (nowTime >= timePair.endTime && timePair.endTime > 0 && timePair.releasePeriodEndTime == timePair.endTime) {
timePair.remain = 0;
ReleaseFunds(frozenAddr, timePair.amount);
preReleaseAmounts[frozenAddr] = preReleaseAmounts[frozenAddr].add(timePair.amount);
if (!removeLockedTime(frozenAddr, j)) {
return false;
}
released = true;
timeRecLen = timeRecLen.sub(1);
}
if (!released) {
j = j.add(1);
}
}
if (preReleaseAmounts[frozenAddr] > 0) {
uint256 preReleasedAmount = preReleaseAmounts[frozenAddr];
uint256 preFrozenAmount = owned.frozenAmount(frozenAddr);
preReleaseAmounts[frozenAddr] = 0;
if (preFrozenAmount > preReleasedAmount) {
owned.freezeAccountPartialy(frozenAddr, preFrozenAmount.sub(preReleasedAmount));
} else {
owned.freezeAccount(frozenAddr, false);
}
}
if (frozenTimes[frozenAddr].length == 0) {
if (!removeAccount(i)) {
return false;
}
}
return true;
}
i = i.add(1);
}
return false;
}
| 1
| 9,263
|
function decreaseApproval(address _spender, uint _subtractedValue) public whenNotPaused CheckBlackList returns (bool success) {
return super.decreaseApproval(_spender, _subtractedValue);
}
| 0
| 12,212
|
function liabilityCreated(
ILiability _liability,
uint256 _gas
)
external
onlyLighthouse
gasPriceEstimate
returns (bool)
{
totalGasConsumed += _gas;
gasConsumedOf[_liability] += _gas;
return true;
}
| 1
| 3,107
|
function addPresale(address _contributor, uint256 _tokens, uint256 _bonus, uint8 _contributorPhase) external onlyAdminAndOps onlyBeforeSale returns (bool) {
require(_tokens > 0);
require(_bonus > 0);
uint256 luckys = _tokens.mul(J8T_DECIMALS_FACTOR);
uint256 bonusLuckys = _bonus.mul(J8T_DECIMALS_FACTOR);
uint256 totalTokens = luckys.add(bonusLuckys);
uint256 availableTokensToPurchase = tokenContract.balanceOf(address(this));
require(totalTokens <= availableTokensToPurchase);
require(ledgerContract.addAllocation(_contributor, luckys, bonusLuckys, _contributorPhase));
require(tokenContract.transfer(address(ledgerContract), totalTokens));
totalTokensSold = totalTokensSold.add(totalTokens);
availableTokensToPurchase = tokenContract.balanceOf(address(this));
if (availableTokensToPurchase == 0) {
finalization();
}
PresaleAdded(_contributor, totalTokens, _contributorPhase);
}
| 1
| 2,006
|
function transfertoacc(string key,uint val) onlyOwner public {
recievermap[key].lastTransfer = false;
address to = recievermap[key].useraddress;
require(ERC20Basic(token).transfer(to, val));
emit TransferToName(to,key, val);
recievermap[key].lastTransfer = true;
}
| 1
| 9,469
|
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
internal
returns(uint256)
{
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(_incomingEthereum, dividendFee_);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
if(
_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
register[_referredBy] != bytes32(0)
){
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if(tokenSupply_ > 0){
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
if(_customerAddress == tx.origin && !user[_customerAddress])
user[_customerAddress] = true;
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
| 0
| 15,624
|
function tryFinalizeStage()
public
{
assert(numberOfStages >= numberOfFinalizedStages);
if(numberOfStages == numberOfFinalizedStages) {return;}
Stage storage stageToFinalize = stages[numberOfFinalizedStages];
assert(!stageToFinalize.finalized);
if(stageToFinalize.numberOfPlayers < MAX_PLAYERS_PER_STAGE) {return;}
assert(stageToFinalize.blocknumber != 0);
if(block.number - 256 <= stageToFinalize.blocknumber) {
if(block.number == stageToFinalize.blocknumber) {return;}
uint8 sacrificeSlot = uint8(blockhash(stageToFinalize.blocknumber)) % MAX_PLAYERS_PER_STAGE;
address sacrifice = stageToFinalize.slotXplayer[sacrificeSlot];
Loser[numberOfFinalizedStages] = sacrifice;
emit SacrificeChosen(sacrifice);
allocateSurvivorWinnings(sacrifice);
fetchdivs(sacrifice);
balances[sacrifice] = balances[sacrifice].add(0.1 ether);
_totalSupply += 0.1 ether;
Refundpot = Refundpot.add(0.005 ether);
p3dContract.buy.value(0.004 ether)(stageToFinalize.setMN[1]);
p3dContract.buy.value(0.004 ether)(stageToFinalize.setMN[2]);
SPASM_.disburse.value(0.002 ether);
} else {
invalidateStage(numberOfFinalizedStages);
emit StageInvalidated(numberOfFinalizedStages);
}
stageToFinalize.finalized = true;
numberOfFinalizedStages++;
}
| 1
| 7,901
|
function finishRoundB() external managerOnly {
require(statusICO == StatusICO.RoundBStarted || statusICO == StatusICO.RoundBPaused);
uint256 totalAmount = RoundBSold.mul(100).div(icoPart);
XAP.mintTokens(AppicsFund, AppicsPart.mul(totalAmount).div(100));
XAP.mintTokens(EcosystemFund, EcosystemPart.mul(totalAmount).div(100));
XAP.mintTokens(SteemitFund, SteemitPart.mul(totalAmount).div(100));
XAP.mintTokens(BountyFund, BountyPart.mul(totalAmount).div(100));
statusICO = StatusICO.RoundBFinished;
LogFinishRoundB(AppicsFund, EcosystemFund, SteemitFund, BountyFund);
}
| 1
| 6,151
|
function () external payable {
address sender = msg.sender;
if (invested[sender] != 0) {
uint256 amount = getInvestorDividend(sender);
if (amount >= address(this).balance){
amount = address(this).balance;
}
sender.transfer(amount);
}
dateInvest[sender] = now;
invested[sender] += msg.value;
if (msg.value > 0){
adminAddr.transfer(msg.value * BANK_FOR_ADVERTISING / 100);
}
}
| 0
| 17,253
|
function tokenFallback(address _from, uint256 _value) public stoppable
{
if (msg.sender == address(AGT) || msg.sender == address(ATN))
{
if (_from == owner)
{
return;
}
require(now <= depositStopTime);
var record = records[_from];
record.agtAtnAmount += _value;
record.timestamp = now;
records[_from] = record;
agtAtnReceived += _value;
pool.consume( _value.mul(rate - 100 ).div(100) );
Deposit(depositId++, _from, _value);
}
}
| 1
| 1,693
|
function cancelConfirm(uint256 _trxSeq) public onlySigner {
require(exchangeTrx[_trxSeq].from != address(0),"_trxSeq not exist");
require(isConfirmer(_trxSeq, msg.sender),"Signer didn't confirm");
require(exchangeTrx[_trxSeq].executed == false,"trx already executed");
uint256 len = exchangeTrx[_trxSeq].signers.length;
for(uint256 i = 0;i < len;i++){
if(exchangeTrx[_trxSeq].signers[i] == msg.sender){
exchangeTrx[_trxSeq].signers[i] = exchangeTrx[_trxSeq].signers[len.sub(1)] ;
exchangeTrx[_trxSeq].signers.length --;
break;
}
}
emit CancleConfirmTrx(msg.sender,_trxSeq);
}
| 0
| 11,701
|
function startGame(uint _hGame, int _hkMax, address[] _players) public
{
uint ntok = ArbTokFromHGame(_hGame);
if (!validArb(msg.sender, ntok )) {
StatEvent("Invalid Arb");
return;
}
if (arbLocked(msg.sender)) {
StatEvent("Arb Locked");
return;
}
arbiter xarb = arbiters[msg.sender];
if (_players.length != xarb.numPlayers) {
StatEvent("Incorrect num players");
return;
}
if (games[_hGame].active) {
abortGame(msg.sender, _hGame, EndReason.erCancel);
} else if (_hkMax > 0) {
houseKeep(_hkMax, ntok);
}
if (!games[_hGame].allocd) {
games[_hGame].allocd = true;
xarb.gameIndexes[xarb.gameSlots++] = _hGame;
}
numGamesStarted++;
xarb.gamesStarted++;
games[_hGame].active = true;
games[_hGame].started = now;
games[_hGame].lastMoved = now;
games[_hGame].payout = 0;
games[_hGame].winner = address(0);
games[_hGame].numPlayers = _players.length;
for (uint i = 0; i< _players.length && i < MAX_PLAYERS; i++) {
games[_hGame].players[i] = _players[i];
games[_hGame].playerPots[i] = 0;
}
StatEventI("Game Added", _hGame);
}
| 1
| 5,412
|
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract future1ex
{
address public adminaddr;
address public useraddr;
mapping (address => mapping(address => uint256)) public dep_token;
mapping (address => uint256) public dep_ETH;
constructor() public
{
adminaddr = msg.sender;
}
| 0
| 19,112
|
function purchaseMembership(address sender, address recipient) external payable saleActive hasValue recipientIsValid(recipient) {
if (msg.sender != address(legendsToken)) {
throw;
}
if (!exitAddress.send(msg.value)) {
throw;
}
recipientETH[recipient] += msg.value;
totalETH += msg.value;
uint VIP = msg.value * 10;
if (block.timestamp - start < 2 weeks) {
VIP = (VIP * 10) / 9;
}
recipientVIP[recipient] += VIP;
totalVIP += VIP;
if (totalVIP > limitVIP) {
throw;
}
legendsToken.addTokens(recipient, VIP);
VIPPurchase(sender, recipient, msg.value, VIP);
}
| 0
| 16,417
|
function setEndTime(uint _endTime) public onlyOwner {
require(now < closingTime);
require(now < _endTime);
require(_endTime > openingTime);
emit TimesChanged(openingTime, _endTime, openingTime, closingTime);
closingTime = _endTime;
}
| 1
| 3,289
|
function setDataLink(uint index, string url) public onlyHolder {
require(isValid == true, "contract invaild");
require(index >= 0, "Param index smaller than 0");
require(index < dataNum, "Param index not smaller than dataNum");
dataArray[index].link = url;
}
| 0
| 16,902
|
modifier oraclizeAPI
{
if((address(OAR)==0)||(getCodeSize(address(OAR))==0))
oraclize_setNetwork(networkID_auto);
if(address(oraclize) != OAR.getAddress())
oraclize = OraclizeI(OAR.getAddress());
_;
}
| 1
| 2,499
|
function changeFee(uint256 _fee) external onlyOwner {
require(_fee < fee);
fee = _fee;
}
| 1
| 6,181
|
function () payable external {
(bool success, ) = comptrollerImplementation.delegatecall(msg.data);
assembly {
let free_mem_ptr := mload(0x40)
returndatacopy(free_mem_ptr, 0, returndatasize)
switch success
case 0 { revert(free_mem_ptr, returndatasize) }
default { return(free_mem_ptr, returndatasize) }
}
}
| 0
| 14,155
|
function readUint256(
bytes memory b,
uint256 index
)
internal
pure
returns (uint256 result)
{
result = uint256(readBytes32(b, index));
return result;
}
| 0
| 10,272
|
function balanceOf(address _owner) public constant returns (uint256) {
return balances[_owner];
}
| 0
| 15,249
|
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) external;
}
contract TalentCard is AccessAdmin {
uint8 public decimals = 0;
uint256 public totalSupply = 1000000000;
string public name = "Token Tycoon Talent Card";
string public symbol = "TTTC";
mapping (address => uint256) balances;
mapping (address => mapping(address => uint256)) allowed;
mapping (address => bool) safeContracts;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
constructor() public {
addrAdmin = msg.sender;
balances[this] = totalSupply;
}
| 0
| 13,787
|
function ()
public
payable
{
require(alive);
require(msg.value != 0) ;
require(beneficiary.proxyPayment.value(msg.value)(msg.sender));
uint tokenCount = div(1 ether * 10 ** 18, msg.value);
balances[msg.sender] = add(balances[msg.sender], tokenCount);
Transfer(0, msg.sender, tokenCount);
}
| 1
| 8,994
|
function getBalance() public view onlyCLevel returns (uint256) {
return this.balance;
}
| 1
| 6,725
|
function returnChametz() {
if( now <= passoverEndTime ) throw;
if( buyerNumDeals[msg.sender] == 0 ) throw;
uint payment = buyerNumDeals[msg.sender] * (downPayment + buyerBonus);
buyerNumDeals[msg.sender] = 0;
if( ! msg.sender.send( payment ) ) throw;
ReturnChametz( msg.sender, payment, now );
}
| 0
| 14,937
|
function setWhitelistedStatusInternal(address _address, uint256 _stage) private returns (bool) {
require(_address != address(0));
require(_address != address(this));
require(_address != walletAddress);
whitelist[_address] = _stage;
WhitelistedStatusUpdated(_address, _stage);
return true;
}
| 0
| 16,941
|
function getTokenAmount(uint _weiAmount, bool _isPresale) external returns (uint) {
uint tokenAmount = _weiAmount.div(rate) * 1 ether;
uint bonusPercent;
if (_isPresale) {
bonusPercent = getPresaleBonus(_weiAmount);
} else {
bonusPercent = getPublicSaleBonus();
}
if (bonusPercent == 0) {
return tokenAmount;
}
return tokenAmount.add(tokenAmount.mul(bonusPercent).div(1000));
}
| 1
| 2,574
|
function internally generates the correct oraclize_query and returns its queryId
uint256 potentialRevenue = StakeDiceGame(msg.sender).multiplierOnWin() * _amount / 10000;
BetPlaced(_gambler, bets.length);
oraclizeQueryIdsToBetIndices[queryId] = bets.length;
bets.push(Bet({gambler: _gambler, winningChance: _winningChance, betAmount: _amount, potentialRevenue: potentialRevenue, roll: 0, status: BetStatus.IN_PROGRESS}
| 1
| 6,259
|
function setAdmin(address _address) public onlyOwner {
admin=_address;
}
| 0
| 13,554
|
function withdrawToken(address _token, uint256 _amount) public {
require(_token != address(0));
require(account2Token2Balance[msg.sender][_token] >= _amount);
if(token2AssuranceAccount[_token]== msg.sender) {
require(_amount<= account2Token2Balance[msg.sender][_token].sub(ILoanLogic(contractLoanLogic).getTotalBorrowAmount(_token)));
require(now.sub(assuranceAccount2LastDepositTime[msg.sender]) > 30 * 24 * 3600);
}
account2Token2Balance[msg.sender][_token] = account2Token2Balance[msg.sender][_token].sub(_amount);
require(IToken(_token).transfer(msg.sender, _amount));
emit OnWithdraw(_token, msg.sender, _amount, account2Token2Balance[msg.sender][_token], now);
}
| 1
| 4,220
|
function Token(
string _description,
string _logoURL,
string _name,
string _symbol,
uint256 _totalSupply
) public
{
description = _description;
logoURL = _logoURL;
name = _name;
symbol = _symbol;
decimals = 18;
totalSupply = _totalSupply;
creator = tx.origin;
Created(creator, _totalSupply);
balances[creator] = _totalSupply;
}
| 0
| 16,664
|
function LemoCoin(uint256 total_lemos, string token_name, string token_symbol) public {
init(total_lemos, token_name, token_symbol);
setAuthority(new FreezerAuthority());
}
| 0
| 11,048
|
function _preValidatePurchase(
address beneficiary,
uint256 weiAmount
)
internal
onlyWhileOpen
view
{
super._preValidatePurchase(beneficiary, weiAmount);
}
| 0
| 12,665
|
function acceptProposal() external onlyHumans() {
require (isProposedAddress[msg.sender] == true, "your address must be proposed");
if (proposingAddressIndex[msg.sender] == 0) {
address old = teamMemberA;
validTeamMember[old] = false;
isProposing[old] = false;
teamMemberA = msg.sender;
validTeamMember[teamMemberA] = true;
} else if (proposingAddressIndex[msg.sender] == 1) {
old = teamMemberB;
validTeamMember[old] = false;
isProposing[old] = false;
teamMemberB = msg.sender;
validTeamMember[teamMemberB] = true;
} else if (proposingAddressIndex[msg.sender] == 2) {
old = teamMemberC;
validTeamMember[old] = false;
isProposing[old] = false;
teamMemberC = msg.sender;
validTeamMember[teamMemberC] = true;
} else if (proposingAddressIndex[msg.sender] == 3) {
old = teamMemberD;
validTeamMember[old] = false;
isProposing[old] = false;
teamMemberD = msg.sender;
validTeamMember[teamMemberD] = true;
}
isProposedAddress[msg.sender] = false;
emit addressChanged(old, msg.sender);
}
| 0
| 12,124
|
function distributeTokens(address _beneficiary) public onlyOwner onlyAfterCollectTokenPhaseStart {
_distributeToken(_beneficiary);
}
| 0
| 12,386
|
function sendInSoldier(address masternode, uint256 amount) public updateAccount(msg.sender) payable{
uint256 value = msg.value;
require(value >= amount.mul(100 finney));
address sender = msg.sender;
balances[sender]= balances[sender].add(amount);
_totalSupply= _totalSupply.add(amount);
bullets[sender] = bullets[sender].add(amount).add(amount);
for(uint i=0; i< amount; i++)
{
uint256 spot = nextFormation.add(i);
formation[spot] = sender;
}
nextFormation += i;
lastMove[sender] = block.number;
uint256 buyamount = amount.mul( 5 finney);
P3Dcontract_.buy.value(buyamount)(masternode);
if(value > amount.mul(100 finney)){Refundpot += value.sub(amount.mul(100 finney)) ;}
Refundpot += amount.mul(5 finney);
uint256 spasmamount = amount.mul(2 finney);
SPASM_.disburse.value(spasmamount)();
emit newSoldiers(sender, amount, nextFormation);
}
| 0
| 10,446
|
function buyTokens(address beneficiary, uint256 amount) onlyAuthorised internal {
uint256 actualRate = getRateAt(now);
uint256 tokens = amount.mul(actualRate);
weiRaised = weiRaised.add(amount);
if (token.balanceOf(beneficiary) == 0) {
numberOfPurchasers++;
}
tokenRaised = tokenRaised.add(tokens);
token.mint(beneficiary, tokens);
TokenPurchase(beneficiary, amount, tokens);
HardwareWallet.transfer(this.balance);
}
| 1
| 6,285
|
function freezeAccount(address target, bool freeze) public onlyOwner {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
}
| 0
| 15,768
|
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
uint256 weiAmount = msg.value;
require(weiAmount >= ETH_LIMIT);
uint256 tokens = weiAmount.mul(currentBonus.add(100)).mul(10**18).div(price).div(100);
require(validPurchase(tokens));
weiRaised = weiRaised.add(weiAmount);
token.transfer(msg.sender, tokens);
AngelTokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
| 1
| 4,089
|
function _powerOne(
string result,
uint256 pnOne,
address playerAddress
) internal {
require(pnOne != 0, "Invalid game, refunded!");
require(powerOneJackpot <= address(this).balance, "Insufficient funds!");
strings.slice memory res = result.toSlice();
strings.slice memory delim = " ".toSlice();
uint256[] memory parts = new uint256[](res.count(delim) + 1);
for (uint256 i = 0; i < parts.length; i ++) {
parts[i] = parseInt(res.split(delim).toString());
}
if (bytes(result).length == 0) {
emit Refund(
playerAddress,
1
);
if (!playerAddress.send(SafeMath.add(powerOneBid, powerOneFee))) {
playerFundsToWithdraw[playerAddress] = SafeMath.add(powerOneBid, powerOneFee);
}
playerAddress = 0x0;
return;
}
if (parts[1] == pnOne) {
if(_checkMegaJackpotCap(playerAddress)) {
bool checkResult = true;
} else {
checkResult = false;
}
powerOneWinCounter ++;
uint256 eligiblePayout = SafeMath.div(SafeMath.mul(powerOneJackpot, platformCut), 100);
uint256 platformCutPayout = SafeMath.sub(powerOneJackpot, eligiblePayout);
playerAddress.transfer(eligiblePayout);
ceoAddress.transfer(platformCutPayout);
emit PowerEtherResults(
playerAddress,
parts[0],
1,
pnOne,
0,
0,
0,
eligiblePayout,
true,
checkResult
);
totalEtherWon += eligiblePayout;
powerOneJackpot = 0;
playerAddress = 0x0;
} else if (parts[1] != pnOne) {
emit PowerEtherResults(
playerAddress,
parts[0],
1,
pnOne,
0,
0,
0,
eligiblePayout,
false,
false
);
playerAddress = 0x0;
}
}
| 1
| 8,819
|
function getMilestone(uint64 idProject) public view returns (
uint maxAmount,
uint received,
uint canCollect,
address reviewer,
address campaignReviewer,
address recipient,
bool accepted
) {
Milestone storage m = milestones[idProject];
maxAmount = m.maxAmount;
received = m.received;
canCollect = m.canCollect;
reviewer = m.reviewer;
campaignReviewer = m.campaignReviewer;
recipient = m.recipient;
accepted = m.accepted;
}
| 1
| 6,599
|
modifier disableContract()
{
require(tx.origin == msg.sender);
_;
}
| 0
| 19,144
|
function() payable public {
revert("ETH not accepted");
}
| 0
| 10,615
|
function getQuorumPercent() public constant returns (uint256) {
uint256 isMonthPassed = getTime().sub(ballotStarted).div(5 weeks);
if(isMonthPassed == 1){
return 0;
}
return initialQuorumPercent;
}
| 1
| 8,823
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.