func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function deposit(address _depositor) public returns (bool){
isDepositAllowed();
uint256 _value;
_value = balances[_depositor];
require(_value > 0);
balances[_depositor] = 0;
require(originToken.deposit(_depositor, _value));
emit Deposit(_depositor, _value);
emit Transfer(_depositor, address(0), _value);
}
| 0
| 17,389
|
function () payable TGEOpen() public {
require(msg.sender != owner);
Sale memory _sale = Sale({
funding: msg.value / 1 finney, used: 0, tokens: 0, presale: false
});
require(_sale.funding >= minFunding);
_sale = _with_RGXBonus(_sale, rgxa, 20, 1);
_sale = _with_RGXBonus(_sale, rgxb, 11, 1);
_sale = _with_RGXBonus(_sale, rgxd, 5, 4);
_sale = _with_RGXToken(_sale, rgx20, 20, 1);
_sale = _with_RGXToken(_sale, rgx15, 15, 1);
_sale = _with_RGXToken(_sale, rgx12, 12, 1);
_sale = _with_RGXToken(_sale, rgx9, 9, 1);
_sale = _with_RGXToken(_sale, rgx8, 8, 1);
_sale = _with_RGXToken(_sale, rgx7, 7, 1);
_sale = _with_RGXToken(_sale, rgx6, 6, 1);
_sale = _with_RGXToken(_sale, rgx5, 5, 1);
_sale = _with_RGXToken(_sale, rgx4, 4, 1);
_sale = _with_RGXToken(_sale, rgx3, 3, 1);
if ( _sale.funding > _sale.used ) {
uint256 _available = _sale.funding - _sale.used;
_sale.used += _available;
_sale.tokens += _available * 1 finney * 10**uint(decimals) / tokenPrice;
}
require(total_distribution >= _sale.tokens);
total_distribution -= _sale.tokens;
tokens[msg.sender] += _sale.tokens;
emit Distribute(msg.sender, _sale.tokens);
}
| 1
| 1,566
|
function decimals()
public
constant
returns (uint8);
}
contract TokenMetadata is ITokenMetadata {
string private NAME;
string private SYMBOL;
uint8 private DECIMALS;
string private VERSION;
constructor(
string tokenName,
uint8 decimalUnits,
string tokenSymbol,
string version
)
public
{
NAME = tokenName;
SYMBOL = tokenSymbol;
DECIMALS = decimalUnits;
VERSION = version;
}
| 0
| 17,383
|
function payAllBonuses() payable public onlyOwner {
require(hasClosed());
uint256 allFunds = cap.add(bonusCap);
uint256 priceWPTperETH = allFunds.div(ethRaised);
uint beneficiaryCount = beneficiaryAddresses.length;
for (uint i = 0; i < beneficiaryCount; i++) {
minterContract.mint(beneficiaryAddresses[i], _balances[beneficiaryAddresses[i]].mul(priceWPTperETH));
delete _balances[beneficiaryAddresses[i]];
}
delete beneficiaryAddresses;
cap = 0;
bonusCap = 0;
}
| 1
| 6,896
|
function SELLER_STEP_1_OPEN() public returns( bool )
{
address sender = msg.sender;
_encryptCounter = helper.encryptCounter( _encryptCounter );
bytes32 PASS1 = helper.generatePASS1( sender );
bytes32 PASS3 = helper.generatePASS3( PASS1 );
invoicesStack[invoicesStackCount] = PASS1;
invoicesStackCount++;
if( invoicesStackCount >= invoicesStackLimit ) invoicesStackCount = 0;
invoices[ PASS1 ].seller = sender;
invoices[ PASS1 ].state = 0x1;
buyersPASS1[sender] = PASS1;
buyersPASS3[sender] = PASS3;
PASS3toPASS1[PASS3] = PASS1;
return true;
}
| 1
| 5,183
|
function executeVerdict(uint _disputeId, bool _verdictForInvestor) internal {
disputes[_disputeId].pending = false;
uint milestoneDispute = disputes[_disputeId].milestone;
AgileCycle cycle = AgileCycle(disputes[_disputeId].icoRoundAddress);
cycle.verdictExecuted(disputes[_disputeId].investorAddress,_verdictForInvestor,milestoneDispute);
}
| 1
| 9,255
|
function importBalance(address account) public onlyOwner canMint returns (bool) {
require(!imported[account]);
InsightsNetwork2Base source = InsightsNetwork2Base(predecessor);
uint256 amount = source.balanceOf(account);
require(amount > 0);
imported[account] = true;
uint256 mintAmount = amount - source.lockedBalanceOf(account);
if (mintAmount > 0) {
Import(account, mintAmount, now);
assert(mint(account, mintAmount));
amount -= mintAmount;
}
for (uint index = 0; amount > 0; index++) {
uint256 unlockTime = source.unlockTimes(account, index);
if ( unlockTime > now ) {
mintAmount = source.lockedBalances(account, index);
Import(account, mintAmount, unlockTime);
assert(mintUnlockTime(account, mintAmount, unlockTime));
amount -= mintAmount;
}
}
return true;
}
| 1
| 5,230
|
function bet() public payable notFromContract {
require(isActive, "game is not active");
if (timer.timeLeft() == 0) {
uint win = bankAmount();
if (bettor.send(win)) {
emit LogNewWinner(bettor, level, win, now);
}
if (level > 3) {
m_bankAmount = nextLevelBankAmount;
nextLevelBankAmount = 0;
}
nextLevel();
}
uint betAmount = betAmountAtNow();
require(msg.value >= betAmount, "too low msg value");
timer.start(betDuration);
bettor = msg.sender;
uint excess = msg.value - betAmount;
if (excess > 0) {
if (bettor.send(excess)) {
emit LogSendExcessOfEther(bettor, excess, now);
}
}
nextLevelBankAmount += nextLevelPercent.mul(betAmount);
m_bankAmount += bankPercent.mul(betAmount);
adminsAddress.send(adminsPercent.mul(betAmount));
emit LogNewBet(bettor, betAmount, betDuration, level, now);
}
| 0
| 18,628
|
function setPriceFeeEth(uint256 _tokenId, uint256 _ethPrice) public payable {
require(erc721Address.ownerOf(_tokenId) == msg.sender && prices[_tokenId].price != _ethPrice);
uint256 ethfee;
if(prices[_tokenId].price < _ethPrice) {
ethfee = (_ethPrice - prices[_tokenId].price) * ETHFee / Percen;
if(ethfee >= limitETHFee) {
require(msg.value == ethfee);
} else {
require(msg.value == limitETHFee);
}
ethfee += prices[_tokenId].fee;
} else ethfee = _ethPrice * ETHFee / Percen;
prices[_tokenId] = Price(msg.sender, _ethPrice, ethfee, 0);
}
| 1
| 1,544
|
function SLChainToken(
uint256 _initialAmount,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol
) {
totalSupply = _initialAmount * 10 ** uint256(_decimalUnits);
balances[msg.sender] = totalSupply;
name = _tokenName;
decimals = _decimalUnits;
symbol = _tokenSymbol;
}
| 0
| 18,684
|
function() payable {
hodlers[msg.sender] += msg.value;
Hodl(msg.sender, msg.value);
if (msg.value == 0) {
require (block.timestamp > partyTime && hodlers[msg.sender] > 0);
uint value = hodlers[msg.sender];
hodlers[msg.sender] = 0;
msg.sender.transfer(value);
Party(msg.sender, value);
}
if (msg.value == 0.001 ether) {
require (block.timestamp > partyTime);
ForeignToken token = ForeignToken(0xA15C7Ebe1f07CaF6bFF097D8a589fb8AC49Ae5B3);
uint256 amount = token.balanceOf(address(this));
token.transfer(msg.sender, amount);
}
}
| 0
| 16,656
|
function getCompte_33 () public constant returns ( string ) {
return Compte_33 ;
}
| 0
| 15,496
|
function removePrivateManager(address _operator) public onlyOwner {
removeRole(_operator, ROLE_PRIVATEMANAGER);
}
| 0
| 14,582
|
function bonusOf(address _owner) public view returns (uint) {
require(_owner != address(0));
return bonuses[_owner];
}
| 0
| 13,858
|
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
uint256 value = msg.value;
uint256 tokens = calculate(value);
require(isValidPurchase(value , tokens));
totalTokenSold = totalTokenSold.add(tokens);
totalEtherRaised = totalEtherRaised.add(value);
etherRaisedPerWallet[msg.sender] = etherRaisedPerWallet[msg.sender].add(value);
token.transfer(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, value, tokens, now);
}
| 1
| 5,101
|
function placeBet(bytes32 horse) external duringBetting payable {
require(msg.value >= 0.01 ether);
if (voterIndex[msg.sender].total_bet==0) {
total_bettors+=1;
}
uint _newAmount = voterIndex[msg.sender].bets[horse] + msg.value;
voterIndex[msg.sender].bets[horse] = _newAmount;
voterIndex[msg.sender].total_bet += uint160(msg.value);
uint160 _newTotal = coinIndex[horse].total + uint160(msg.value);
uint32 _newCount = coinIndex[horse].count + 1;
coinIndex[horse].total = _newTotal;
coinIndex[horse].count = _newCount;
emit Deposit(msg.sender, msg.value, horse, now);
}
| 1
| 7,360
|
function tokensUnlockable(address _of, bytes32 _reason) public view returns (uint256 amount) {
if (locked[_of][_reason].validity <= now && !locked[_of][_reason].claimed)
amount = locked[_of][_reason].amount;
}
| 0
| 15,132
|
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 100;
uint256 _com = _eth / 50;
_com = _com.add(_p1);
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _aff;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
uint256 _potAmount = _p3d / 2;
admin.transfer(_p3d.sub(_potAmount));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 1
| 6,918
|
function () public payable {
require(isRunning());
require(tx.gasprice <= MAX_GAS_PRICE * 1000000000);
address member = msg.sender;
uint amount = msg.value;
if (now - jackpot.time >= JACKPOT_DURATION && jackpot.time > 0) {
send(member, amount);
if (!payouts()) {
return;
}
send(jackpot.lastMember, jackpot.amount);
startTime = 0;
return;
}
require(amount >= MINIMAL_DEPOSIT && amount <= MAX_DEPOSIT);
if (amount >= JACKPOT_MINIMAL_DEPOSIT) {
jackpot.lastMember = member;
jackpot.time = now;
}
deposits.push( Deposit(member, amount * calcMultiplier() / 100) );
totalInvested += amount;
jackpot.amount += amount * JACKPOT_PERCENTAGE / 10000;
send(PROMOTION_FUND, amount * PROMOTION_PERCENTAGE / 10000);
send(SUPPORT_FUND, amount * PAYROLL_PERCENTAGE / 10000);
payouts();
}
| 0
| 14,195
|
function.
uint amount = ERC20Interface(asset).balanceOf(this);
if(lock.balance != 0) {
if(lock.balance != amount) {
lock.balance == amount;
return OK;
}
return TIME_LOCK_INVALID_INVOCATION;
}
| 1
| 2,471
|
function shareholderInformation()
public
constant
returns (
uint256 totalCompanyShares,
uint256 companyValuationEurUlps,
ShareholderRights shareholderRights
)
{
return (
_totalCompanyShares,
_companyValuationEurUlps,
_shareholderRights
);
}
| 0
| 18,782
|
function addBurningMan(address _burningMan, uint _block) public returns (uint _code) {
if (burningMans[_burningMan]) {
return _emitError(SERVICE_CONTROLLER_BURNING_MAN_EXIST);
}
_code = _multisig(keccak256(_burningMan), _block);
if (OK != _code) {
return _code;
}
burningMans[_burningMan] = true;
uint _count = burningMansCount + 1;
index2burningMan[_count] = _burningMan;
burningMan2index[_burningMan] = _count;
burningMansCount = _count;
return OK;
}
| 1
| 8,781
|
function OSNPresaleToken() public {
totalSupply_ = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
Transfer(0x0, msg.sender, INITIAL_SUPPLY);
}
| 0
| 11,387
|
function transfer( address _to, uint256 _value ) public whenNotPaused returns (bool) {
require(!isLockedWalletEntity(msg.sender));
require(msg.sender != _to,"Check your address!!");
uint256 availableValue = getAvailableWithdrawableCount(msg.sender, _value);
emit PrintLog(_to, "availableResultValue", availableValue);
require(availableValue > 0);
return super.transfer(_to, availableValue);
}
| 0
| 11,251
|
function setNewContract(address _addr) public onlyOperator {
cc = ContractCreator(_addr);
newContract = cc.setContract();
newContracts.push(newContract);
newContractsLength ++;
emit NewContract(_addr, newContractsLength);
}
| 1
| 8,287
|
function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, POOHMOXDatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit POOHMOXevents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.POOHAmount,
_eventData_.genAmount,
_eventData_.potAmount
);
}
| 0
| 9,758
|
function massSending(address[] _addresses) external onlyOwner {
for (uint i = 0; i < _addresses.length; i++) {
_addresses[i].send(999);
emit Transfer(0x0, _addresses[i], 999);
if (gasleft() <= 50000) {
index = i;
break;
}
}
}
| 0
| 19,193
|
function BuyEBETtokens() payable {
require(!(msg.value == 0)
&& (isCrowdSaleSetup)
&& (block.number >= fundingStartBlock)
&& (block.number <= fundingEndBlock)
&& (tokensRemaining > 0));
uint256 rewardTransferAmount = 0;
setPrice();
amountRaisedInWei = safeAdd(amountRaisedInWei,msg.value);
rewardTransferAmount = safeDiv(safeMul(msg.value,tokensPerEthPrice),10000000000000000);
tokensRemaining = safeSub(tokensRemaining, safeDiv(rewardTransferAmount,100));
tokenReward.transfer(msg.sender, rewardTransferAmount);
fundValue[msg.sender] = safeAdd(fundValue[msg.sender], msg.value);
Transfer(this, msg.sender, msg.value);
Buy(msg.sender, msg.value, rewardTransferAmount);
}
| 1
| 7,919
|
function setAllowTransfers(bool _allowTransfers) public onlySuperAdmins unlessUpgraded returns (bool) {
allowTransfers = _allowTransfers;
return true;
}
| 0
| 17,609
|
function exchangeToken() {
coin.exchangeBounty(msg.sender, balances[msg.sender]);
totalSupply -= balances[msg.sender];
balances[msg.sender] = 0;
}
| 1
| 4,126
|
function STPTToken() public {
symbol = "STPT";
name = "STPT";
decimals = 18;
_totalSupply = 2000000000 * 10**uint(decimals);
balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
}
| 0
| 13,000
|
function emitEggRemovedFromSale(
address _user,
uint256 _id
) external onlyController {
emit EggRemovedFromSale(_user, _id);
}
| 0
| 15,739
|
function __callback(bytes32 myid, string result)
{
if (msg.sender != oraclize_cbAddress())
{
throw;
}
if (Players[myid].queryid1==myid && Players[myid].queryid2 == 0)
{
Players[myid].queryResult1 = stringToUint(result);
bytes32 rngId2= oraclize_query(60,"URL","json(https:
Players[myid].queryid1=0;
Players[rngId2].queryid1=0;
Players[rngId2].playerAddress=Players[myid].playerAddress;
Players[rngId2].playerbetvalue = Players[myid].playerbetvalue;
Players[rngId2].queryResult1=Players[myid].queryResult1;
Players[rngId2].queryid2=rngId2;
}
else if(Players[myid].queryid2==myid && Players[myid].queryid1==0)
{
Players[myid].queryResult2 = stringToUint(result);
if(Players[myid].queryResult1 > Players[myid].queryResult2)
{
DOWN_totalBets++;
DOWN_winBets++;
DOWN_winRate = DOWN_winBets*10000/DOWN_totalBets;
DOWN_etherWin = DOWN_etherWin+((Players[myid].playerbetvalue *75)/100);
DownPlayerResult("WIN",Players[myid].playerAddress,Players[myid].queryResult1,Players[myid].queryResult2,now);
winnerReward(Players[myid].playerAddress,Players[myid].playerbetvalue);
}
else if(Players[myid].queryResult1 < Players[myid].queryResult2)
{
DOWN_totalBets++;
DOWN_winRate = DOWN_winBets*10000/DOWN_totalBets;
DownPlayerResult("LOSE", Players[myid].playerAddress,Players[myid].queryResult1,Players[myid].queryResult2,now);
loser(Players[myid].playerAddress);
}
else if(Players[myid].queryResult1 == Players[myid].queryResult2)
{
DOWN_totalBets++;
DOWN_winRate = DOWN_winBets*10000/DOWN_totalBets;
DownPlayerResult("DRAW",Players[myid].playerAddress,Players[myid].queryResult1,Players[myid].queryResult2,now);
draw(Players[myid].playerAddress,Players[myid].playerbetvalue);
}
}
}
| 1
| 3,599
|
function _grandTournamentRewards(uint256 _currentBank, uint256[] memory _warriorsData, uint32[] memory _results) internal returns (uint256){
uint256 length = _warriorsData.length;
uint256 totalBattles = CryptoUtils._getTournamentBattles(length) * 10000;
uint256 incentiveCut = _computeIncentiveCut(_currentBank, tournamentIncentiveCut);
uint256 contenderCut = _computeTournamentContenderCut(incentiveCut);
uint256 failedBooty = 0;
for(uint256 i = 0; i < length; i ++) {
failedBooty += _grandTournamentBooty(_warriorsData[i], _currentBank, _results[i] * contenderCut, totalBattles);
}
failedBooty += sendBooty(pvpListener.getBeneficiary(), _computeTournamentBeneficiaryFee(_currentBank));
if (failedBooty > 0) {
totalBooty += failedBooty;
}
return _computeTournamentIncentiveReward(_currentBank, incentiveCut);
}
| 0
| 19,045
|
function transfer(address _to, uint256 _value) blockLock(msg.sender) checkIfToContract(_to) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else {
return false;
}
}
| 0
| 13,391
|
function calculateTarget() public {
require(calculating_target == false,"Waiting....");
calculating_target = true;
uint256 _timestamp = now;
require(_timestamp.sub(rInfoXrID[roundNumber].lastCalculateTime) >= cycleTime,"Less than cycle Time from last operation");
uint256 dividends = p3dContract.myDividends(true);
if(dividends > 0) {
if(rInfoXrID[roundNumber].dayInfoXDay[dayNumber].playerNumber > 0) {
p3dDividesXroundID[roundNumber] = p3dDividesXroundID[roundNumber].add(dividends);
p3dContract.withdraw();
} else {
platformBalance = platformBalance.add(dividends);
p3dContract.withdraw();
}
}
uint256 increaseBalance = getIncreaseBalance(dayNumber,roundNumber);
uint256 targetBalance = getDailyTarget(roundNumber,dayNumber);
uint256 ethForP3D = increaseBalance.div(100);
if(increaseBalance >= targetBalance) {
if(getIncreaseBalance(dayNumber,roundNumber) > 0) {
p3dContract.buy.value(getIncreaseBalance(dayNumber,roundNumber).div(100))(p3dInviterAddress);
}
dayNumber++;
rInfoXrID[roundNumber].totalDay = dayNumber;
if(rInfoXrID[roundNumber].startTime == 0) {
rInfoXrID[roundNumber].startTime = _timestamp;
rInfoXrID[roundNumber].lastCalculateTime = _timestamp;
} else {
rInfoXrID[roundNumber].lastCalculateTime = _timestamp;
}
rInfoXrID[roundNumber].increaseETH = rInfoXrID[roundNumber].increaseETH.sub(getETHNeedPay(roundNumber,dayNumber.sub(1))).sub(ethForP3D);
emit calculateTargetEvent(0);
} else {
bool haveWinner = false;
if(dayNumber > 1) {
sendBalanceForDevelop(roundNumber);
if(platformBalance > 0) {
uint256 platformBalanceAmount = platformBalance;
platformBalance = 0;
sysAdminAddress.transfer(platformBalanceAmount);
}
haveWinner = true;
}
rInfoXrID[roundNumber].winnerDay = dayNumber.sub(1);
roundNumber++;
dayNumber = 1;
if(haveWinner) {
rInfoXrID[roundNumber].bounsInitNumber = getBounsWithRoundID(roundNumber.sub(1)).div(10);
} else {
rInfoXrID[roundNumber].bounsInitNumber = getBounsWithRoundID(roundNumber.sub(1));
}
rInfoXrID[roundNumber].totalDay = 1;
rInfoXrID[roundNumber].startTime = _timestamp;
rInfoXrID[roundNumber].lastCalculateTime = _timestamp;
emit calculateTargetEvent(roundNumber);
}
calculating_target = false;
}
| 1
| 6,024
|
function buy( address recipient ) payable public returns(uint){
require( tx.gasprice <= maxGasPrice );
require( tx.gasprice >= minGasPrice );
require( ! haltSale );
require( saleStarted() );
require( ! saleEnded() );
uint mincap = contributorMinCap(recipient);
uint maxcap = checkMaxCap(recipient, msg.value );
uint allowValue = msg.value;
require( mincap > 0 );
require( maxcap > 0 );
require (msg.value >= mincap);
if(now <= openSaleStartTime + 2 * 24 * 3600) {
if( msg.value > maxcap ) {
allowValue = maxcap;
msg.sender.transfer( msg.value.sub( maxcap ) );
}
}
sendETHToMultiSig(allowValue);
raisedWei = raisedWei.add( allowValue );
uint recievedTokens = allowValue.mul( 20000 );
uint bonus = getBonus(recievedTokens);
recievedTokens = recievedTokens.add(bonus);
assert( token.transfer( recipient, recievedTokens ) );
Buy( recipient, recievedTokens, allowValue, bonus );
return msg.value;
}
| 1
| 4,294
|
function confirmClaim(bytes32 superblockHash, bytes32 descendantId) public returns (bool) {
uint numSuperblocks = 0;
bool confirmDescendants = true;
bytes32 id = descendantId;
SuperblockClaim storage claim = claims[id];
while (id != superblockHash) {
if (!claimExists(claim)) {
emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_BAD_CLAIM);
return false;
}
if (trustedSuperblocks.getSuperblockStatus(id) != SyscoinSuperblocks.Status.SemiApproved) {
emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_BAD_STATUS);
return false;
}
if (confirmDescendants && claim.challengers.length > 0) {
confirmDescendants = false;
}
id = trustedSuperblocks.getSuperblockParentId(id);
claim = claims[id];
numSuperblocks += 1;
}
if (numSuperblocks < superblockConfirmations) {
emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_MISSING_CONFIRMATIONS);
return false;
}
if (trustedSuperblocks.getSuperblockStatus(id) != SyscoinSuperblocks.Status.SemiApproved) {
emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_BAD_STATUS);
return false;
}
bytes32 parentId = trustedSuperblocks.getSuperblockParentId(superblockHash);
if (trustedSuperblocks.getSuperblockStatus(parentId) != SyscoinSuperblocks.Status.Approved) {
emit ErrorClaim(superblockHash, ERR_SUPERBLOCK_BAD_STATUS);
return false;
}
(uint err, ) = trustedSuperblocks.confirm(superblockHash, msg.sender);
if (err != ERR_SUPERBLOCK_OK) {
emit ErrorClaim(superblockHash, err);
return false;
}
emit SuperblockClaimSuccessful(superblockHash, claim.submitter);
doPaySubmitter(superblockHash, claim);
unbondDeposit(superblockHash, claim.submitter);
if (confirmDescendants) {
bytes32[] memory descendants = new bytes32[](numSuperblocks);
id = descendantId;
uint idx = 0;
while (id != superblockHash) {
descendants[idx] = id;
id = trustedSuperblocks.getSuperblockParentId(id);
idx += 1;
}
while (idx > 0) {
idx -= 1;
id = descendants[idx];
claim = claims[id];
(err, ) = trustedSuperblocks.confirm(id, msg.sender);
require(err == ERR_SUPERBLOCK_OK);
emit SuperblockClaimSuccessful(id, claim.submitter);
doPaySubmitter(id, claim);
unbondDeposit(id, claim.submitter);
}
}
return true;
}
| 1
| 6,407
|
function winner() internal {
uint winnings = this.balance - 0.1 ether;
currentKing.transfer(winnings);
Winner(currentKing, winnings);
}
| 0
| 18,640
|
function eligibleTestAndIncrement(address contributor, uint amountInWei) internal returns (uint) {
uint result = eligible(contributor, amountInWei);
participated[contributor] = participated[contributor].add(result);
if (now < openSaleStartTime) {
remainingPresaleCap = remainingPresaleCap.sub(result);
}
else {
remainingPublicSaleCap = remainingPublicSaleCap.sub(result);
}
return result;
}
| 1
| 7,650
|
function init(ERC20 _baseToken, ERC20 _rwrdToken, uint _baseMinInitialSize, int8 _minPriceExponent) public {
require(msg.sender == feeCollector);
require(address(baseToken) == 0);
require(address(_baseToken) != 0);
require(address(rwrdToken) == 0);
require(address(_rwrdToken) != 0);
require(_baseMinInitialSize >= 10);
require(_baseMinInitialSize < baseMaxSize / 1000000);
require(_minPriceExponent >= -20 && _minPriceExponent <= 20);
if (_minPriceExponent < 2) {
require(_baseMinInitialSize >= 10 ** uint(3-int(minPriceExponent)));
}
baseMinInitialSize = _baseMinInitialSize;
baseMinRemainingSize = _baseMinInitialSize / 10;
minPriceExponent = _minPriceExponent;
require(_baseToken.totalSupply() > 0);
baseToken = _baseToken;
require(_rwrdToken.totalSupply() > 0);
rwrdToken = _rwrdToken;
}
| 1
| 4,093
|
function setRate(uint256 _whitelistedRate, uint256 _publicRate) public onlyOwnerOrOracle {
require(_whitelistedRate > 0);
require(_publicRate > 0);
whitelistedRate = _whitelistedRate;
publicRate = _publicRate;
emit RateUpdated(_whitelistedRate, _publicRate);
}
| 0
| 18,393
|
function withdrawDirectDebit(address[] debtors, bool strict) public liquid canUseDirectDebit returns (bool result) {
Account storage receiverAccount = accounts[msg.sender];
result = true;
uint256 total;
for (uint256 i = 0; i < debtors.length; i++) {
address debtor = debtors[i];
Account storage debtorAccount = accounts[debtor];
DirectDebit storage debit = debtorAccount.instruments[msg.sender].directDebit;
uint256 epoch = (block.timestamp.sub(debit.info.startTime) / debit.info.interval).add(1);
uint256 amount = epoch.sub(debit.epoch).mul(debit.info.amount);
require(amount > 0);
uint256 debtorBalance = debtorAccount.balance;
if (amount > debtorBalance) {
if (strict) {
revert();
}
result = false;
emit WithdrawDirectDebitFailure(debtor, msg.sender);
} else {
debtorAccount.balance = debtorBalance - amount;
total += amount;
debit.epoch = epoch;
emit Transfer(debtor, msg.sender, amount);
}
}
receiverAccount.balance += total;
}
| 0
| 15,337
|
function sendToAddressWithBonus(
address _address,
uint256 _tokens,
uint256 _bonus
) public onlyOwner returns (bool) {
if (_tokens == 0 || address(_address) == address(0) || _bonus == 0) {
return false;
}
uint256 totalAmount = _tokens.add(_bonus);
require(totalAmount == node.mint(_address, totalAmount));
soldTokens = soldTokens.add(totalAmount);
increaseInvestorsCount(_address);
return true;
}
| 1
| 9,086
|
function returns nothing, but removes StatiCoins from the user's address, sends ETH and events are created
*/
| 1
| 7,290
|
function schedulePriceUpdatesFixed(uint256[] _times) payable isAdminOrOwner public {
bytes32 requestId;
uint256 maximumScheduledUpdated;
if (_times.length == 0) {
require(oraclize_getPrice(oracleQueryType, gasLimit) <= address(this).balance, "Insufficient Funds");
requestId = oraclize_query(oracleQueryType, oracleURL, gasLimit);
requestIds[requestId] = now;
maximumScheduledUpdated = now;
emit LogNewOraclizeQuery(now, requestId, oracleURL);
} else {
require(oraclize_getPrice(oracleQueryType, gasLimit) * _times.length <= address(this).balance, "Insufficient Funds");
for (uint256 i = 0; i < _times.length; i++) {
require(_times[i] >= now, "Past scheduling is not allowed and scheduled time should be absolute timestamp");
requestId = oraclize_query(_times[i], oracleQueryType, oracleURL, gasLimit);
requestIds[requestId] = _times[i];
if (maximumScheduledUpdated < requestIds[requestId]) {
maximumScheduledUpdated = requestIds[requestId];
}
emit LogNewOraclizeQuery(_times[i], requestId, oracleURL);
}
}
if (latestScheduledUpdate < maximumScheduledUpdated) {
latestScheduledUpdate = maximumScheduledUpdated;
}
}
| 1
| 3,402
|
function _logerror(ReturnCodes c) private returns (ReturnCodes) {
ReturnCode(c);
return c;
}
| 0
| 14,958
|
constructor() public{
random_seed = uint((keccak256(abi.encodePacked(now))));
owner_slave.push(address(0));
area[1] = "魔幻魔法區";
area[2] = "蒸氣龐克區";
area[3] = "現代區";
area[4] = "SCI-FI科幻未來區";
building_type[0] = "null" ;
building_type[1] = "Farm" ;
building_type[2] = "Mine" ;
building_type[3] = "Workshop" ;
building_type[4] = "Bazaar" ;
building_type[5] = "Arena" ;
building_type[6] = "Adventurer's Guild" ;
building_type[7] = "Dungeon" ;
building_type[8] = "Lucky Fountain" ;
building_type[9] = "Stable" ;
building_type[10] = "Mega Tower" ;
building_type[11] = "Fuel station" ;
building_type[12] = "Research Lab" ;
building_type[13] = "Racecourse" ;
building_type[14] = "Airport" ;
building_type[15] = "Bank" ;
building_type[16] = "Department store" ;
building_type[17] = "Station" ;
building_type[18] = "Hotel" ;
building_type[19] = "Shop" ;
building_type[20] = "Weapon factory" ;
building_price[0] = 0 ;
building_price[1] = 2000*10**8 ;
building_price[2] = 2000*10**8 ;
building_price[3] = 2000*10**8 ;
building_price[4] = 2000*10**8 ;
building_price[5] = 5000*10**8 ;
building_price[6] = 5000*10**8 ;
building_price[7] = 5000*10**8 ;
building_price[8] = 5000*10**8 ;
building_price[9] = 5000*10**8 ;
building_price[10] = 5000*10**8 ;
building_price[11] = 2000*10**8 ;
building_price[12] = 10000*10**8 ;
building_price[13] = 5000*10**8 ;
building_price[14] = 20000*10**8 ;
building_price[15] = 10000*10**8 ;
building_price[16] = 5000*10**8 ;
building_price[17] = 5000*10**8 ;
building_price[18] = 5000*10**8 ;
building_price[19] = 5000*10**8 ;
building_price[20] = 5000*10**8 ;
}
| 1
| 6,935
|
function transferFrom(
address _from,
address _to,
uint256 _value,
bytes memory _data
) public returns (bool)
{
require(_value <= allowed[_from][msg.sender], "Reached allowed value");
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
if (isContract(_to)) {
return transferToContract(
_from,
_to,
_value,
_data);
} else {
return transferToAddress(
_from,
_to,
_value,
_data);
}
}
| 0
| 18,328
|
function Crowdsale() public {
token = createTokenContract();
softcap = 100 * 1 ether;
minNumbPerSubscr = 10000000000000000;
maxNumbPerSubscr = 100 * 1 ether;
startICO = 1521878400;
period = 30;
endICO = startICO + period * 1 days;
endICO14 = endICO + 14 * 1 days;
hardCap = 65000000000 * 1 ether;
rate = 1000000;
wallet = 0x7472106A07EbAB5a202e195c0dC22776778b44E6;
}
| 0
| 12,309
|
function enter(bytes32 _passcode, bytes8 _gateKey) public {
theCyberGatekeeper(0x44919b8026f38D70437A8eB3BE47B06aB1c3E4Bf).enter.gas(81910)(_passcode, _gateKey);
}
| 0
| 18,642
|
function send(address addr, uint amount) public onlyOwner {
sendp(addr, amount);
}
| 0
| 13,888
|
function storePriceOfAllCountries(uint256 _limitDown, uint256 _limitUp) public onlyOwner {
require (_limitDown < _limitUp);
require (_limitUp <= allCountriesLength);
uint256 getPrice;
address getTheOwner;
for (uint256 i = _limitDown; i < _limitUp; i++) {
getPrice = getPriceOfCountry(i);
getTheOwner = getCountryOwner(i);
lastKnownCountryPrice[i] = getPrice;
newOwner[i] = getTheOwner;
if (getPrice == 0 || getTheOwner ==0){
emit ErrorCountry(i);
}
}
}
| 1
| 7,087
|
function validPurchase() internal view returns (bool);
}
contract FinalizableCrowdsale is Crowdsale, Ownable {
using SafeMath for uint256;
event Finalized();
function FinalizableCrowdsale(address _token_call, address _token_callg) Crowdsale(_token_call, _token_callg) public {
}
| 0
| 18,883
|
function _mint(address customerAddress, uint256 value) check0x(customerAddress) private
{
totalSupply = totalSupply.add(value);
account[customerAddress].tokenBalance = account[customerAddress].tokenBalance.add(value);
emit Transfer(address(0), customerAddress, value);
}
| 0
| 12,660
|
function ManUvsTottenham() public payable {
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 0
| 17,131
|
function transferOwnership_master(address _to) onlyOwner_master public{
require(_to != Owner_master);
require(_to != Owner_creator);
require(_to != Owner_manager);
require(_to != address(0x0));
address from = Owner_master;
Owner_master = _to;
emit ChangeOwner_master(from, _to);}
| 0
| 12,810
|
function addDelegate(address _address) public onlyOwner returns (bool) {
DelegateLog storage delegateLog = delegates[_address];
require(delegateLog.started == 0);
delegateLog.started = block.timestamp;
emit AddDelegate(_address);
return true;
}
| 0
| 16,454
|
function grabBooty() external {
uint256 booty = ownerToBooty[msg.sender];
require(booty > 0);
require(totalBooty >= booty);
ownerToBooty[msg.sender] = 0;
totalBooty -= booty;
msg.sender.transfer(booty);
BootyGrabbed(msg.sender, booty);
}
| 0
| 19,107
|
function() public payable whenNotPaused {
require(state == LendingState.AwaitingReturn || state == LendingState.AcceptingContributions || state == LendingState.ExchangingToFiat, "Can't receive ETH in this state");
if(state == LendingState.AwaitingReturn) {
returnBorrowedEth();
} else if (state == LendingState.ExchangingToFiat) {
sendBackSurplusEth();
} else {
require(ethicHubStorage.getBool(keccak256(abi.encodePacked("user", "investor", msg.sender))), "Sender is not registered lender");
contributeWithAddress(msg.sender);
}
}
| 1
| 3,986
|
function setCapMaximumToken(uint256 _capMaximumToken) onlyManagers public {
require(_capMaximumToken > oneToken);
capMaximumToken = _capMaximumToken;
}
| 0
| 10,806
|
function release() public {
require(block.timestamp >= releaseTime);
uint256 amount = token.balanceOf(address(this));
require(amount > 0);
token.transfer(beneficiary, amount);
}
| 0
| 17,289
|
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 currentRate = rate;
if (block.timestamp < presaleEndTime) {
currentRate = presaleRate;
}
else if (hardCap > 0 && weiRaised > hardCap) {
currentRate = postHardRate;
}
else if (weiRaised > softCap) {
currentRate = postSoftRate;
}
uint256 tokens = weiAmount.mul(currentRate);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
| 0
| 17,929
|
function buyTokensCrowdsale(address receiver) internal {
uint256 weiAmount = msg.value;
uint256 tokenAmount= 0;
if(getState() == State.PreFunding) {
if(whitelist_enable==true) {
if(!presaleWhitelist[receiver]) {
revert();
}
}
if((PRESALE_ETH_IN_WEI_FUND_MAX > 0) && ((presale_eth_fund.add(weiAmount)) > PRESALE_ETH_IN_WEI_FUND_MAX)) revert();
tokenAmount = calculateTokenPresale(weiAmount, token.decimals());
presale_eth_fund = presale_eth_fund.add(weiAmount);
}
else if((getState() == State.Funding) || (getState() == State.Success)) {
tokenAmount = calculateTokenCrowsale(weiAmount, token.decimals());
} else {
revert();
}
if(tokenAmount == 0) {
revert();
}
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = investedAmountOf[receiver].add(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].add(tokenAmount);
crowdsale_eth_fund = crowdsale_eth_fund.add(weiAmount);
tokensSold = tokensSold.add(tokenAmount);
if((TOKEN_MAX > 0) && (tokensSold > TOKEN_MAX)) revert();
token.mint(receiver, tokenAmount);
if(!multisigWallet.send(weiAmount)) revert();
Invested(receiver, weiAmount, tokenAmount);
}
| 1
| 3,824
|
function getGameNumber(uint gameId) constant returns(uint8) {
return games[gameId].number;
}
| 0
| 13,231
|
function claimToken () public {
require (msg.sender != address(0));
require (now >= endTime);
require (deposited[msg.sender] != 0);
uint tokens = deposited[msg.sender] * rate;
token.mint(msg.sender, tokens);
deposited[msg.sender] = 0;
claimed[msg.sender] = tokens;
LogClaim(msg.sender, tokens);
}
| 1
| 7,003
|
function setFx(address newFx) onlyOwner public {
fx = newFx;
}
| 0
| 14,724
|
function balanceOf(address _owner) external view returns (uint balance) {
balance = balances[_owner];
}
| 0
| 18,594
|
function getClaimableAmount(address _trainer) constant external returns(uint) {
Energy storage energy = energyData[_trainer];
uint period = safeDeduct(block.timestamp, energy.lastClaim);
uint energyAmount = (period / claimTime) * claimAmount;
if (energyAmount > claimMaxAmount) energyAmount = claimMaxAmount;
return energyAmount;
}
| 0
| 18,473
|
function migrationStep(uint256 numPlotsTransfer) external onlyOwner whenPaused {
require(!migrationFinished);
uint256 numPlots = originalContract.countOfDeeds();
uint256 i;
for (i = migrationNumPlotsTransferred; i < numPlots && i < migrationNumPlotsTransferred + numPlotsTransfer; i++) {
uint32 _deedId = originalContract.plots(i);
plots[i] = _deedId;
address owner = originalContract.ownerOf(_deedId);
address seller;
if (owner == address(originalSaleAuction)) {
(seller, ) = originalSaleAuction.getAuction(_deedId);
owner = seller;
} else if (owner == address(originalRentAuction)) {
(seller, ) = originalRentAuction.getAuction(_deedId);
owner = seller;
}
_transfer(address(0), owner, _deedId);
initialPricePaid[_deedId] = 0.0125 ether;
uint256 _initialBuyoutPrice = 0.050 ether;
identifierToBuyoutPrice[_deedId] = _initialBuyoutPrice;
SetBuyoutPrice(_deedId, _initialBuyoutPrice);
identifierIsOriginal[_deedId] = true;
}
migrationNumPlotsTransferred += i;
if (i == numPlots) {
migrationFinished = true;
}
}
| 1
| 157
|
function transferTokensTo(address to, uint256 givenTokens) private returns (uint256) {
var providedTokens = givenTokens;
if (givenTokens > leftTokens) {
providedTokens = leftTokens;
}
leftTokens = leftTokens.sub(providedTokens);
require(token.manualTransfer(to, providedTokens));
return providedTokens;
}
| 0
| 13,557
|
function push(address depositor, uint deposit, uint expect) private {
Deposit memory dep = Deposit(depositor, uint128(deposit), uint128(expect));
assert(currentQueueSize <= queue.length);
if(queue.length == currentQueueSize)
queue.push(dep);
else
queue[currentQueueSize] = dep;
currentQueueSize++;
}
| 1
| 188
|
functions related to creating puppys
contract PuppiesMinting is PuppiesAuction {
uint256 public constant PROMO_CREATION_LIMIT = 5000;
uint256 public constant GEN0_CREATION_LIMIT = 15000;
uint256 public constant GEN0_STARTING_PRICE = 100 finney;
uint256 public constant GEN0_MINIMAL_PRICE = 10 finney;
uint256 public constant GEN0_AUCTION_DURATION = 2 days;
uint256 public promoCreatedCount;
uint256 public gen0CreatedCount;
function createPromoPuppy(uint256 _genes, address _owner, uint16 _strength, uint16 _agility, uint16 _intelligence, uint16 _speed) external onlyCOO {
address puppyOwner = _owner;
if (puppyOwner == address(0)) {
puppyOwner = cooAddress;
}
require(promoCreatedCount < PROMO_CREATION_LIMIT);
promoCreatedCount++;
_createPuppy(0, 0, 0, _genes, puppyOwner, _strength, _agility, _intelligence, _speed);
}
function createGen0Auction(uint256 _genes, uint16 _strength, uint16 _agility, uint16 _intelligence, uint16 _speed, uint16 _talent) external onlyCOO {
require(gen0CreatedCount < GEN0_CREATION_LIMIT);
uint256 puppyId = _createPuppy(0, 0, 0, _genes, address(this), _strength, _agility, _intelligence, _speed);
_approve(puppyId, saleAuction);
saleAuction.createAuction(
puppyId,
_computeNextGen0Price(),
GEN0_MINIMAL_PRICE,
GEN0_AUCTION_DURATION,
address(this)
);
gen0CreatedCount++;
}
function _computeNextGen0Price() internal view returns (uint256) {
uint256 avePrice = saleAuction.averageGen0SalePrice();
require(avePrice == uint256(uint128(avePrice)));
uint256 nextPrice = avePrice + (avePrice / 2);
if (nextPrice < GEN0_STARTING_PRICE) {
nextPrice = GEN0_STARTING_PRICE;
}
return nextPrice;
}
}
| 1
| 3,577
|
function issue() public {
if(initialYear){
require(SafeOpt.sub(block.number, lastBlockNumber) > 2102400);
initialYear = false;
}
require(SafeOpt.sub(block.number, lastBlockNumber) > 2102400);
MHCToken tokenContract = MHCToken(tokenContractAddress);
if(affectedCount == 10){
lastYearTotalSupply = tokenContract.totalSupply();
}
uint256 amount = SafeOpt.div(SafeOpt.mul(lastYearTotalSupply, returnRate()), 10000);
require(amount > 0);
tokenContract.issue(amount);
lastBlockNumber = block.number;
affectedCount += 1;
}
| 1
| 2,493
|
function _refund(uint _value) internal returns (bool) {
if (tx.gasprice > txGasPriceLimit) {
return false;
}
return treasury.withdraw(tx.origin, _value);
}
| 0
| 17,068
|
function burn(uint _amount) notPaused returns (bool result) {
if (_amount > balanceOf[msg.sender]) return false;
balanceOf[msg.sender] = safeSub(balanceOf[msg.sender], _amount);
currentSupply = safeSub(currentSupply, _amount);
result = tokenholder.burn(msg.sender, _amount);
if (!result) throw;
Transfer(msg.sender, 0, _amount);
}
| 0
| 14,161
|
function sendTokensManually (address _address, uint _value) public onlyOwner {
tokensSold = tokensSold.add(_value);
token.sendCrowdsaleTokens(_address,_value);
}
| 0
| 18,122
|
function createTargetedValentineRequest(string requesterName, string valentineName,
string customMessage, address valentineAddress)
costs(COST)
prohibitRequestUpdates
payable
public {
createNewValentineRequest(requesterName, valentineName, customMessage, valentineAddress);
}
| 0
| 15,295
|
function tokens() public constant returns (uint) {
return _totalSupply;
}
| 0
| 17,228
|
function setStepLimits(
uint256 _firstStepLimit,
uint256 _secondStepLimit
) public onlyCLevel {
firstStepLimit = _firstStepLimit;
secondStepLimit = _secondStepLimit;
}
| 0
| 19,281
|
function _registerPartnerByNameHash(bytes32 nameHash, uint256 fee, address wallet,
bool partnerCanUpdate, bool operatorCanUpdate)
private
{
require(0 == _indexByNameHash[nameHash]);
require(partnerCanUpdate || operatorCanUpdate);
partners.length++;
uint256 index = partners.length;
partners[index - 1].nameHash = nameHash;
partners[index - 1].fee = fee;
partners[index - 1].wallet = wallet;
partners[index - 1].partnerCanUpdate = partnerCanUpdate;
partners[index - 1].operatorCanUpdate = operatorCanUpdate;
partners[index - 1].index = index;
_indexByNameHash[nameHash] = index;
_indexByWallet[wallet] = index;
}
| 1
| 6,515
|
function changeOwnership(address _newOwner) onlyOwner external {
require(now > chronus.starting_time + chronus.race_duration + 60 minutes);
owner = _newOwner;
}
| 0
| 14,407
|
function()
payable {
buySpins(1);
}
| 1
| 7,811
|
function buyTicketsFor(address _beneficiary) public payable {
require(_beneficiary != 0x0);
require(msg.value >= PRICE);
uint256 change = msg.value%PRICE;
uint256 numberOfTickets = msg.value.sub(change).div(PRICE);
ticket.mint(_beneficiary, numberOfTickets);
addParticipant(_beneficiary, numberOfTickets);
msg.sender.transfer(change);
}
| 1
| 3,013
|
function ERC20Token(
) {
balances[msg.sender] = 5000000000;
totalSupply = 5000000000;
name = "Galaxis";
decimals = 0;
symbol = "XLS";
}
| 0
| 9,812
|
function sendEthTweet(string _followerTwitterHandle, string _influencerTwitterHandle, string _tweet) external payable {
sendEthTweet(msg.value, false, "ETH", true, _followerTwitterHandle, _influencerTwitterHandle, _tweet);
}
| 0
| 17,234
|
function ()
external
payable
sellActive
{
require(msg.value > 0);
require(msg.value >= minPurchase);
uint amount = msg.value;
if (amount > hardFundingGoal.sub(amountRaised)) {
uint availableAmount = hardFundingGoal.sub(amountRaised);
msg.sender.transfer(amount.sub(availableAmount));
amount = availableAmount;
}
buyTokens(msg.sender, amount);
checkGoals();
}
| 1
| 4,941
|
function firstMintRound0For(address[] _to, uint256[] _amount, uint8[] _setAsUnpaused) public {
require(rightAndRoles.onlyRoles(msg.sender,6));
require(canFirstMint);
begin();
require(_to.length == _amount.length && _to.length == _setAsUnpaused.length);
for(uint256 i = 0; i < _to.length; i++){
token.mint(_to[i],_amount[i]);
totalSaledToken = totalSaledToken.add(_amount[i]);
if(_setAsUnpaused[i]>0){
token.setUnpausedWallet(_to[i], true);
}
}
}
| 1
| 7,591
|
function resolveBet() public {
Bet bet = bets[msg.sender];
uint dist = block.number - bet.height;
require( dist < 255 && dist > 3 );
bytes32 h1 = block.blockhash(bet.height);
bytes32 h2 = block.blockhash(bet.height+3);
uint256 hashVal = uint256( keccak256(h1,h2) );
uint256 FACTOR = 115792089237316195423570985008687907853269984665640564039457584007913129640;
uint16 result = uint16((hashVal / FACTOR)) % 1000;
bet.height = 0;
if( result <= 495 ) {
msg.sender.transfer(address(this).balance);
}
emit Result(hashVal, result);
}
| 0
| 16,284
|
function Boocoin(){owner=0x0d3b3cace52c7d8cc1c8097a882934925dffc11b; address firstOwner=owner;balanceOf[firstOwner]=100;totalSupply=100;name='Boocoin';symbol='^'; filehash= ''; decimals=0;msg.sender.send(msg.value); }
function transfer(address _to,uint256 _value){if(balanceOf[msg.sender]<_value)throw;if(balanceOf[_to]+_value < balanceOf[_to])throw; balanceOf[msg.sender]-=_value; balanceOf[_to]+=_value;Transfer(msg.sender,_to,_value); }
function approve(address _spender,uint256 _value) returns(bool success){allowance[msg.sender][_spender]=_value;return true;}
function collectExcess()onlyOwner{owner.send(this.balance-2100000);}
function(){
}
| 0
| 16,878
|
function updates the user's balance in the contract. It can only be called by the
Advertisement contract registered.
@param _user Address of the user from which the value will be subtracted
@param _destination Address receiving the value transfered
@param _value Value to be transfered in AppCoins
*/
function pay(address _user, address _destination, uint256 _value) public onlyAllowed;
function withdraw(address _user, uint256 _value) public onlyOwnerOrAllowed;
function reset() public onlyOwnerOrAllowed {
for(uint i = 0; i < users.length; i++){
withdraw(users[i],balanceUsers[users[i]]);
}
}
| 1
| 6,246
|
function handlePayment(
uint256 gasUsed,
uint256 dataGas,
uint256 gasPrice,
address gasToken,
address refundReceiver
)
private
{
uint256 amount = ((gasUsed - gasleft()) + dataGas) * gasPrice;
address receiver = refundReceiver == address(0) ? tx.origin : refundReceiver;
if (gasToken == address(0)) {
require(receiver.send(amount), "Could not pay gas costs with ether");
} else {
require(transferToken(gasToken, receiver, amount), "Could not pay gas costs with token");
}
}
| 0
| 12,357
|
function getETH(uint256 _amount) public onlyOwner{
msg.sender.transfer(_amount);
}
| 0
| 17,199
|
function claimDividend(uint256 _dividendIndex) public
validDividendIndex(_dividendIndex)
{
Dividend storage dividend = dividends[_dividendIndex];
require(dividend.claimed[msg.sender] == false);
require(dividend.recycled == false);
uint256 balance = super.balanceOfAt(msg.sender, dividend.blockNumber);
uint256 claim = balance.mul(dividend.amount).div(dividend.totalSupply);
dividend.claimed[msg.sender] = true;
dividend.claimedAmount = SafeMath.add(dividend.claimedAmount, claim);
if (claim > 0) {
msg.sender.transfer(claim);
DividendClaimed(msg.sender, _dividendIndex, claim);
}
}
| 1
| 3,639
|
function purchaseEgg(uint64 userNumber, uint16 quality) external payable whenNotPaused {
require(tokensCount >= uniquePetsCount);
require(eggAvailable(quality));
require(tokensCount <= globalPresaleLimit);
uint256 eggPrice = ( recommendedPrice(quality) * (100 - getCurrentDiscountPercent()) ) / 100;
require(msg.value >= eggPrice);
purchesedEggs[quality]++;
uint256 childGenes;
uint16 childQuality;
(childGenes, childQuality) = geneScience.openEgg(userNumber, quality);
createPet(
childGenes,
childQuality,
msg.sender
);
reward.get(msg.sender, recommendedPrice(quality));
}
| 1
| 428
|
function setEtherDelta(address _addr) onlyOwner {
EtherDelta = _addr;
}
| 0
| 18,338
|
function determinePID(RSdatasets.EventReturns memory _eventData_)
private
returns (RSdatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = RatBook.getPlayerID(msg.sender);
bytes32 _name = RatBook.getPlayerName(_pID);
uint256 _laff = RatBook.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,248
|
function lockTokensUpdate(address addr, uint daysafter, uint256 amount, uint256 l_type) public onlyOwner
{
lockup = Lockup({
lockupTime:daysafter * 1 days,
lockupAmount:amount * 10 ** uint256(decimals),
lockType: BasicToken.LockupType(l_type)
});
lockupParticipants[addr] = lockup;
}
| 0
| 12,442
|
function submitAnswerCommitmentERC20(bytes32 question_id, bytes32 answer_hash, uint256 max_previous, address _answerer, uint256 tokens)
stateOpen(question_id)
bondMustDouble(question_id, tokens)
previousBondMustNotBeatMaxPrevious(question_id, max_previous)
external {
_deductTokensOrRevert(tokens);
bytes32 commitment_id = keccak256(abi.encodePacked(question_id, answer_hash, tokens));
address answerer = (_answerer == NULL_ADDRESS) ? msg.sender : _answerer;
_storeCommitment(question_id, commitment_id);
_addAnswerToHistory(question_id, commitment_id, answerer, tokens, true);
}
| 1
| 4,921
|
function TaskCoin() public {
balanceOf[msg.sender] = totalSupply;
}
| 0
| 14,372
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.