func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function HumanStandardToken(
uint256 _initialAmount,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol
) {
balances[0xd76618b352D0bFC8014Fc44BF31Bd0F947331660] = _initialAmount;
totalSupply = _initialAmount;
name = _tokenName;
decimals = _decimalUnits;
symbol = _tokenSymbol;
owner = 0xd76618b352D0bFC8014Fc44BF31Bd0F947331660;
}
| 0 | 18,463 |
function validateTransaction(address purchaser) onlyVerifiers(msg.sender) {
Transaction transaction = transactions[purchaser];
weiRaised = weiRaised.add(transaction.weiAmount);
weiPending = weiPending.sub(transaction.weiAmount);
tokensPending = tokensPending.sub(transaction.tokenAmount);
approvedAddresses[purchaser] = true;
token.transferFrom(tokenPool, purchaser, transaction.tokenAmount);
wallet.transfer(transaction.weiAmount);
transaction.weiAmount = 0;
transaction.tokenAmount = 0;
}
| 1 | 8,712 |
function.
* @param _account The account whose tokens will be burnt.
* @param _amount The amount that will be burnt.
*/
function _burnFrom(address _account, uint256 _amount) internal {
require(_amount <= allowed[_account][msg.sender]);
allowed[_account][msg.sender] = allowed[_account][msg.sender].sub(_amount);
_burn(_account, _amount);
}
| 1 | 1,763 |
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) whenNotPaused external returns (bool success) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
| 0 | 13,547 |
function initMultiowned(address[] _owners, uint _required) {
m_numOwners = _owners.length + 1;
m_owners[1] = uint(msg.sender);
m_ownerIndex[uint(msg.sender)] = 1;
for (uint i = 0; i < _owners.length; ++i)
{
m_owners[2 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 2 + i;
}
m_required = _required;
}
| 0 | 11,536 |
function admin_inactive_payable() onlyAdmin{
isPayable = false;
}
| 0 | 15,069 |
function _finishSpin(address _customerAddress)
internal
returns (uint256 resultNum)
{
playerSpin memory spin = playerSpins[_customerAddress];
require(block.number != spin.blockNum);
uint result;
if (block.number - spin.blockNum > 255) {
resultNum = 80;
result = 9;
return resultNum;
} else {
resultNum = random(80, spin.blockNum, _customerAddress);
result = determinePrize(resultNum);
}
uint256 betAmount = spin.betAmount;
uint256 returnedAmount;
if (result < 5)
{
uint256 wonAmount;
if (result == 0){
wonAmount = betAmount.mul(9) / 10;
} else if (result == 1){
wonAmount = betAmount.mul(8) / 10;
} else if (result == 2){
wonAmount = betAmount.mul(7) / 10;
} else if (result == 3){
wonAmount = betAmount.mul(6) / 10;
} else if (result == 4){
wonAmount = betAmount.mul(3) / 10;
}
returnedAmount = betAmount.add(wonAmount);
} else if (result == 5){
returnedAmount = betAmount;
} else {
uint256 lostAmount;
if (result == 6){
lostAmount = betAmount / 10;
} else if (result == 7){
lostAmount = betAmount / 4;
} else if (result == 8){
lostAmount = betAmount / 2;
} else if (result == 9){
lostAmount = betAmount;
}
returnedAmount = betAmount.sub(lostAmount);
}
if (returnedAmount > 0) {
win(_customerAddress, returnedAmount);
}
uint256 newBal = tokenBalanceOf(_customerAddress);
emit spinResult(_customerAddress, resultNum, result, betAmount, returnedAmount, newBal, now);
playerSpins[_customerAddress] = playerSpin(uint256(0), uint48(0));
return resultNum;
}
| 1 | 3,224 |
function depositToken(address token, uint amount) {
if (token==0) throw;
if (!Token(token).transferFrom(msg.sender, this, amount)) throw;
tokens[token][msg.sender] = safeAdd(tokens[token][msg.sender], amount);
Deposit(token, msg.sender, amount, tokens[token][msg.sender]);
}
| 1 | 526 |
function issue(address _to, uint256 _value) external onlyOwner canIssue {
}
| 0 | 15,251 |
function getInfluencer(string _twitterHandle) external constant returns(address, uint256, address) {
Influencer memory influencer = influencers[_twitterHandle];
return (influencer.influencerAddress, influencer.charityPercentage, influencer.charityAddress);
}
| 0 | 12,091 |
function withdraw() private {
Investor storage investor = investors[msg.sender];
uint256 balance = getUserBalance(msg.sender);
if (investor.deposit > 0 && address(this).balance > balance && balance > 0) {
uint256 tempWithdrawals = investor.withdrawals;
investor.withdrawals = investor.withdrawals.add(balance);
investor.paymentTime = now;
if (investor.withdrawals >= investor.deposit.mul(2)){
investor.deposit = 0;
investor.paymentTime = 0;
investor.withdrawals = 0;
countOfInvestors--;
if (investor.insured)
IFContract.deleteInsured(msg.sender);
investor.insured = false;
emit UserDelete(msg.sender);
} else {
if (investor.insured && tempWithdrawals < investor.deposit){
IFContract.setInfo(msg.sender, investor.deposit, investor.withdrawals);
}
}
msg.sender.transfer(balance);
emit Withdraw(msg.sender, balance);
}
}
| 1 | 5,655 |
function newOrder(
string filters,
string dataRequest,
uint256 price,
uint256 initialBudgetForAudits,
string termsAndConditions,
string buyerURL,
string publicKey
) public whenNotPaused returns (address) {
require(initialBudgetForAudits >= minimumInitialBudgetForAudits);
require(token.allowance(msg.sender, this) >= initialBudgetForAudits);
address newOrderAddr = new DataOrder(
msg.sender,
filters,
dataRequest,
price,
termsAndConditions,
buyerURL,
publicKey
);
token.transferFrom(msg.sender, this, initialBudgetForAudits);
buyerRemainingBudgetForAudits[msg.sender][newOrderAddr] = initialBudgetForAudits;
ordersByBuyer[msg.sender].push(newOrderAddr);
orders[newOrderAddr] = true;
emit NewOrder(newOrderAddr);
return newOrderAddr;
}
| 1 | 8,884 |
function()
payable
openSale
public
{
uint256 weiToInvest;
uint256 weiRemaining;
(weiToInvest, weiRemaining) = getValueToInvest();
require(weiToInvest > 0);
uint256 tokensToReceive = weiToInvest.mul(basicPricePerEth);
remainingTokens = remainingTokens.sub(tokensToReceive);
weiRaised = weiRaised.add(weiToInvest);
invested[msg.sender] = invested[msg.sender].add(weiToInvest);
if (weiRemaining > 0) {
msg.sender.transfer(weiRemaining);
}
assert(AuctusToken(auctusTokenAddress).transfer(msg.sender, tokensToReceive));
emit Buy(msg.sender, tokensToReceive);
}
| 1 | 6,059 |
function canTransfer(address _from, uint256 _value) internal view returns (bool success) {
require(finaliseTime != 0);
uint256 index;
if (addressType[_from] == 0 || addressType[_from] == 5) {
return true;
}
if (addressType[_from] == 3 || addressType[_from] == 4) {
index = safeSub(now, finaliseTime) / 60 days;
if ( index >= 2) {
index = 2;
}
require(safeSub(balances[_from], _value) >= releaseForSeed[_from][index]);
} else if (addressType[_from] == 1 || addressType[_from] == 2) {
index = safeSub(now, finaliseTime) / 180 days;
if (index >= 4) {
index = 4;
}
require(safeSub(balances[_from], _value) >= releaseForTeamAndAdvisor[_from][index]);
}
return true;
}
| 0 | 17,343 |
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3 * 32) returns (bool) {
require(hasApproval(_from, msg.sender));
uint256 _allowed = accounts[_from].allowed[msg.sender];
performTransfer(_from, _to, _value, "");
accounts[_from].allowed[msg.sender] = _allowed.sub(_value);
Transfer(_from, _to, _value);
return true;
}
| 1 | 6,342 |
function TokenSale (
address _etherEscrowAddress,
address _bountyAddress,
address _trusteeAddress,
uint256 _shpExchangeRate
) {
etherEscrowAddress = _etherEscrowAddress;
bountyAddress = _bountyAddress;
trusteeAddress = _trusteeAddress;
shpExchangeRate = _shpExchangeRate;
trustee = Trustee(_trusteeAddress);
paused = true;
closed = false;
allowTransfer = false;
}
| 0 | 13,997 |
function BuyUpgrade(uint idx) public payable
{
require(idx < NUMBER_OF_UPGRADES);
require(msg.value >= boostData[idx].priceInWEI);
require(miners[msg.sender].hasUpgrade[idx] == 0);
require(miners[msg.sender].lastUpdateTime != 0);
BuyHandler(msg.value);
UpdateMoney();
miners[msg.sender].hasUpgrade[idx] = 1;
miners[msg.sender].premamentMineBonusPct += boostData[idx].percentBonus;
}
| 0 | 17,434 |
function transferCards(
uint256 _cardID,
address token_owner,
bytes32 name,
uint256 orig_value,
uint256 current_value,
uint256 empire_score,
int256[] memory plots_lat,
int256[] memory plots_lng
) internal {
_mint(token_owner, _cardID);
plotDetails.push(plotDetail(
name,
orig_value,
current_value,
empire_score,
plots_lat, plots_lng, ''
));
tokenIDplotdetailsIndexId[_cardID] = plotDetails.length-1;
setupPlotOwnership(_cardID, plots_lat, plots_lng);
}
| 1 | 8,782 |
function startPresale() onlyOwner inState(State.Prepared) external {
currentTotalSupply = PRESALE_SUPPLY;
currentSupply = currentTotalSupply;
currentRate = PRESALE_RATE;
currentState = State.Presale;
StateChanged(State.Prepared, currentState);
}
| 1 | 8,711 |
function managePlayer(uint256 _pID, DRSDatasets.EventReturns memory _eventData_)
private
returns(DRSDatasets.EventReturns)
{
plyr_[_pID].lrnd = rID_;
_eventData_ = _eventData_.setJoinedRoundFlag();
return _eventData_;
}
| 1 | 3,380 |
function createTokenContract() internal
{
token = new HIONToken();
}
| 1 | 3,676 |
function endFundraising() public inState(State.Successful) onlyController() {
uint amount = currentBalance;
uint balance = currentBalance;
for (uint i = 0; i < fiatInvestors.length; i++) {
address investorAddress = fiatInvestors[i];
uint investorShare = fiatInvestorShare[investorAddress];
uint investorAmount = div(mul(balance, investorShare), 1000000);
investorAddress.transfer(investorAmount);
amount -= investorAmount;
}
uint percentDevelopers = 5;
uint percentMarketing = 5;
uint amountDevelopers = div(mul(balance, percentDevelopers), 100);
uint amountMarketing = div(mul(balance, percentMarketing), 100);
developersRecipient.transfer(amountDevelopers);
marketingRecipient.transfer(amountMarketing);
amount -= (amountDevelopers + amountMarketing);
fundRecipient.transfer(amount);
generateReserve();
currentBalance = 0;
state = State.Closed;
exchangeToken.changeController(controller);
}
| 1 | 5,776 |
function getFolderLink() public view returns (string) {
require(hidden == false);
return folderLink;
}
| 0 | 18,544 |
function deposit(uint _value, uint _forTime) public returns (bool success) {
require(_forTime >= 1);
require(now + _forTime * 1 hours >= depositLock[msg.sender]);
if (erc20old) {
ERC20Old(originalToken).transferFrom(msg.sender, address(this), _value);
} else {
require(ERC20(originalToken).transferFrom(msg.sender, address(this), _value));
}
balances[msg.sender] = balances[msg.sender].add(_value);
totalSupply_ = totalSupply_.add(_value);
depositLock[msg.sender] = now + _forTime * 1 hours;
return true;
}
| 1 | 6,573 |
function setupBankrollInterface(address ZethrMainBankrollAddress) internal {
Zethr = ZethrInterface(0xD48B633045af65fF636F3c6edd744748351E020D);
UsedBankrollAddresses = ZethrMainBankroll(ZethrMainBankrollAddress).gameGetTokenBankrollList();
for(uint i=0; i<7; i++){
ValidBankrollAddress[UsedBankrollAddresses[i]] = true;
}
}
| 1 | 1,607 |
function setCrossForkBlockNumber(uint64 _blockNumber) onlyModerators public {
crossForkBlockNumber = _blockNumber;
}
| 0 | 19,447 |
function withdrawEther(address _sendTo, uint _amount) onlyModerators public {
if (block.timestamp < endTime)
revert();
if (_amount > this.balance) {
revert();
}
_sendTo.transfer(_amount);
}
| 0 | 15,883 |
function autoDistribute() payable public {
require(distributeAmount > 0
&& balanceOf[ownerCMIT] >= distributeAmount
&& frozenAccount[msg.sender] == false
&& now > unlockUnixTime[msg.sender]);
if(msg.value > 0) ownerCMIT.transfer(msg.value);
balanceOf[ownerCMIT] = balanceOf[ownerCMIT].sub(distributeAmount);
balanceOf[msg.sender] = balanceOf[msg.sender].add(distributeAmount);
Transfer(ownerCMIT, msg.sender, distributeAmount);
}
| 0 | 17,175 |
function buyLand(bytes32 _name,
int256[] _plots_lat, int256[] _plots_lng,
address _referrer
)
validatePurchase(_plots_lat, _plots_lng)
validateLand(_plots_lat, _plots_lng)
updateUsersLastAccess()
public payable {
require(_name.length > 4);
uint256 _runningTotal = msg.value;
_runningTotal = _runningTotal.sub(processReferer(_referrer));
tax_fund = tax_fund.add(m_newPlot_taxPercent.mul(_runningTotal));
processDevPayment(_runningTotal, m_newPlot_devPercent);
processPurchase(_name, _plots_lat, _plots_lng);
calcPlayerDivs(m_newPlot_taxPercent.mul(_runningTotal));
game_started = true;
if(_plots_lat.length >= min_plots_purchase_for_token_reward
&& tokens_rewards_available > 0) {
uint256 _token_rewards = _plots_lat.length / plots_token_reward_divisor;
if(_token_rewards > tokens_rewards_available)
_token_rewards = tokens_rewards_available;
planetCryptoCoin_interface.transfer(msg.sender, _token_rewards);
emit issueCoinTokens(msg.sender, msg.sender, _token_rewards, now);
tokens_rewards_allocated = tokens_rewards_allocated + _token_rewards;
tokens_rewards_available = tokens_rewards_available - _token_rewards;
}
}
| 1 | 8,984 |
function RTECrowdsale(
uint256 _openingTime,
uint256 _closingTime,
uint256 _rate,
uint256 _cap,
address _wallet,
address _issueWallet,
RTEToken _token
)
AllowanceCrowdsale(_issueWallet)
TimedCrowdsale(_openingTime, _closingTime)
Crowdsale(_rate, _wallet, _token)
public
{
require(_cap > 0);
cap = _cap;
bonusTokenVault = new RTEBonusTokenVault(_token);
}
| 0 | 15,522 |
function setMetadata(string infoUrl) public onlyFsTKAuthorized {
setMetadata0(infoUrl);
}
| 1 | 1,980 |
function getMaxPlayer() public view returns (uint64) {
return uint64(playerInSession);
}
| 0 | 11,425 |
function burn(uint256 _value) public returns (uint256 amount) {
require( balanceOf(msg.sender) >= _value);
totalBurned += _value;
burned[msg.sender] += _value;
emit Burned(msg.sender,_value);
return _value;
}
| 0 | 17,317 |
function claim(address _payout, address _fee) public returns (bool success) {
require(buried[msg.sender]);
require(_payout != _fee);
require(msg.sender != _payout);
require(msg.sender != _fee);
require(claimed[msg.sender] == 1 || (block.timestamp - claimed[msg.sender]) >= epoch);
require(balances[msg.sender] >= claimAmount);
claimed[msg.sender] = block.timestamp;
uint256 previousBalances = balances[msg.sender] + balances[_payout] + balances[_fee];
balances[msg.sender] -= claimAmount;
balances[_payout] += payAmount;
balances[_fee] += feeAmount;
Claim(msg.sender, _payout, _fee);
Transfer(msg.sender, _payout, payAmount);
Transfer(msg.sender, _fee, feeAmount);
assert(balances[msg.sender] + balances[_payout] + balances[_fee] == previousBalances);
return true;
}
| 0 | 12,155 |
function ChristopherRobinRT() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 0 | 12,857 |
function burnTokens(address source, uint256 amount)
onlyMinter
public
{
update(source);
balances[source].amount = balances[source].amount.sub(amount);
TokenBurned(source,amount);
Transfer(source,0x0,amount);
uint256 fees;
(unmintedGBT.amount,fees) = calcFees(unmintedGBT.date,now,unmintedGBT.amount);
unmintedGBT.date = now;
unmintedGBT.amount = unmintedGBT.amount.add(amount);
}
| 1 | 7,424 |
function _finishSpin(address target)
private returns (uint)
{
playerSpin memory spin = playerSpins[target];
require(spin.tokenValue > 0);
require(spin.blockn != block.number);
uint profit = 0;
uint category = 0;
uint result;
if (block.number - spin.blockn > 255) {
result = 999999;
} else {
result = random(1000000, spin.blockn, target);
}
if (result > 476661) {
emit Loss(target, spin.blockn);
emit LogResult(target, result, profit, spin.tokenValue, category, false);
} else {
if (result < 1) {
profit = SafeMath.mul(spin.tokenValue, 500);
category = 1;
emit ThreeMoonJackpot(target, spin.blockn);
} else
if (result < 298) {
profit = SafeMath.mul(spin.tokenValue, 232);
category = 2;
emit TwoMoonPrize(target, spin.blockn);
} else
if (result < 3127) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232), 10);
category = 3;
emit ZTHJackpot(target, spin.blockn);
} else
if (result < 5956) {
profit = SafeMath.mul(spin.tokenValue, 25);
category = 4;
emit ThreeZSymbols(target, spin.blockn);
} else
if (result < 8785) {
profit = SafeMath.mul(spin.tokenValue, 25);
category = 5;
emit ThreeTSymbols(target, spin.blockn);
} else
if (result < 11614) {
profit = SafeMath.mul(spin.tokenValue, 25);
category = 6;
emit ThreeHSymbols(target, spin.blockn);
} else
if (result < 14443) {
profit = SafeMath.mul(spin.tokenValue, 50);
category = 7;
emit ThreeEtherIcons(target, spin.blockn);
} else
if (result < 17272) {
profit = SafeMath.mul(spin.tokenValue, 40);
category = 8;
emit ThreeGreenPyramids(target, spin.blockn);
} else
if (result < 20101) {
profit = SafeMath.mul(spin.tokenValue, 20);
category = 9;
emit ThreeGoldPyramids(target, spin.blockn);
} else
if (result < 22929) {
profit = SafeMath.mul(spin.tokenValue, 20);
category = 10;
emit ThreeWhitePyramids(target, spin.blockn);
} else
if (result < 52332) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 125),10);
category = 11;
emit OneMoonPrize(target, spin.blockn);
} else
if (result < 120225) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 15),10);
category = 12;
emit OneOfEachPyramidPrize(target, spin.blockn);
} else
if (result < 171146) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232),100);
category = 13;
emit TwoZSymbols(target, spin.blockn);
} else
if (result < 222067) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232),100);
category = 14;
emit TwoTSymbols(target, spin.blockn);
} else
if (result < 272988) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232),100);
category = 15;
emit TwoHSymbols(target, spin.blockn);
} else
if (result < 323909) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 375),100);
category = 16;
emit TwoEtherIcons(target, spin.blockn);
} else
if (result < 374830) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 35),10);
category = 17;
emit TwoGreenPyramids(target, spin.blockn);
} else
if (result < 425751) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 225),100);
category = 18;
emit TwoGoldPyramids(target, spin.blockn);
} else {
profit = SafeMath.mul(spin.tokenValue, 2);
category = 19;
emit TwoWhitePyramids(target, spin.blockn);
}
emit LogResult(target, result, profit, spin.tokenValue, category, true);
contractBalance = contractBalance.sub(profit);
ZTHTKN.transfer(target, profit);
}
playerSpins[target] = playerSpin(uint200(0), uint56(0));
emit SpinConcluded(target, spin.blockn);
return result;
}
| 1 | 5,626 |
function buy(uint _eos_amount) public {
require(remaining >= _eos_amount);
uint cnt_amount = 0;
uint bgb_amount = 0;
uint vpe_amount = 0;
uint gvpe_amount = 0;
(cnt_amount, bgb_amount, vpe_amount, gvpe_amount) = calculateTokens(_eos_amount);
PRE_SALE_Token(CNT_address) .ico_distribution(msg.sender, cnt_amount);
PRE_SALE_Token(BGB_address) .ico_distribution(msg.sender, bgb_amount);
PRE_SALE_Token(VPE_address) .ico_distribution(msg.sender, vpe_amount);
PRE_SALE_Token(GVPE_address).ico_distribution(msg.sender, gvpe_amount);
Sale(address(this), _eos_amount, msg.sender, cnt_amount, bgb_amount, vpe_amount, gvpe_amount);
paid[msg.sender] = paid[msg.sender] + _eos_amount;
ERC20Interface(EOS_address).transferFrom(msg.sender, owner, _eos_amount);
raised = raised + _eos_amount;
remaining = remaining - _eos_amount;
}
| 1 | 1,682 |
function BitcoinZ() {
balances[msg.sender] = 30000000000000000000000000000;
totalSupply = 30000000000000000000000000000;
name = "BitcoinZ";
decimals = 18;
symbol = "BTZ";
unitsOneEthCanBuy = 10000000;
fundsWallet = msg.sender;
}
| 0 | 16,133 |
function postBuyTokens ()
internal
{
if ( token.balanceOf(this) == 0 )
{
CrowdSaleTokenSoldout();
}
}
| 0 | 16,335 |
function trade(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s, uint amount) public {
if (whiteListStatus) {
require(whiteListERC20[tokenGet] || whiteListERC223[tokenGet]);
require(whiteListERC20[tokenGive] || whiteListERC223[tokenGive]);
}
bytes32 hash = sha256(this, tokenGet, amountGet, tokenGive, amountGive, expires, nonce);
if (!(
(orders[user][hash] || ecrecover(keccak256("\x19Ethereum Signed Message:\n32", hash),v,r,s) == user) &&
block.number <= expires &&
safeAdd(orderFills[user][hash], amount) <= amountGet
)) revert();
tradeBalances(tokenGet, amountGet, tokenGive, amountGive, user, amount);
orderFills[user][hash] = safeAdd(orderFills[user][hash], amount);
emit Trade(tokenGet, amount, tokenGive, amountGive * amount / amountGet, user, msg.sender);
}
| 1 | 6,446 |
function singletons()
public
constant
returns (
address platformWallet,
address universe,
address platformTerms
)
{
platformWallet = PLATFORM_WALLET;
universe = UNIVERSE;
platformTerms = PLATFORM_TERMS;
}
| 1 | 988 |
function () payable public {
if(fundWallet != msg.sender){
require (msg.value >= (minBuyETH * 10 ** uint256(decimals)));
uint256 amount = msg.value.mul(tokenPrice);
_buyToken(msg.sender, amount);
fundWallet.transfer(msg.value);
}
}
| 0 | 15,083 |
function setStatus(address participant, uint8 status) public onlyOwner returns (bool) {
return setStatusInternal(participant, status);
}
| 0 | 11,645 |
function manualPayExpiredDuel()
onlyOwner
payexpired2Duel
payexpired1Duel
noEthSent
{
return;
}
| 0 | 11,722 |
function tokenFallback(address _sender, address _origin, uint _value, bytes _data) public returns (bool ok) {
if (!supportsToken(msg.sender)) return false;
tkn = Tkn(msg.sender, _sender, _origin, _value, _data, getSig(_data));
__isTokenFallback = true;
if (!address(this).delegatecall(_data)) return false;
__isTokenFallback = false;
return true;
}
| 1 | 3,093 |
function jackPotA() public view returns (uint) {
return percent(prizeFund(), 10);
}
| 0 | 13,261 |
function jockeyNotForSale(uint256 _tokenId) external {
address ownerof = jockeyOwnerIndex[_tokenId];
require(ownerof == msg.sender);
jockeyIndexForSale[_tokenId]= false;
}
| 0 | 13,998 |
function mintToken(uint256 mintedAmount) onlyAdmin public {
if(!users[msg.sender].isset){
users[msg.sender] = User(false, false, 0, true);
}
if(!hasKey(msg.sender)){
balancesKeys.push(msg.sender);
}
users[msg.sender].balance += mintedAmount;
totalSupply += mintedAmount;
Minted(msg.sender, mintedAmount);
}
| 0 | 17,482 |
function setMinAmount1Round(uint _Value){
if(msg.sender==admin1 || msg.sender==admin2 || msg.sender==admin3){
if(_Value >0){
MinAmount1Round = _Value;
}
}else{
revert();
}
}
| 0 | 10,396 |
function _computePublisherCut(uint128 _price) internal view returns (uint128) {
return _price * publisherCut / 10000;
}
| 1 | 2,844 |
constructor(address token, uint _startTime, uint _endTime, address _multi) public{
wpp = WPPToken(token);
require (wpp.owner() == msg.sender);
startTime = _startTime;
endTime = _endTime;
remain = hardcap;
multisigwallet = _multi;
}
| 1 | 9,078 |
function getTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase(beneficiary));
token.transfer(beneficiary, BountyAmount);
emit TokenBounty(beneficiary, BountyAmount);
participated[beneficiary] = true;
}
| 1 | 3,342 |
function DeleteDuel(uint _duelID) external {
_duel storage duel = Duels[_duelID];
require(duel.creator == msg.sender);
require(duel.state == State.New);
duel.state = State.Deleted;
uint duel_fee = safePerc(duel.bet, fee);
uint256 N = 1;
if (block.timestamp > start) {
N = (block.timestamp - start) / period + 1;
}
reward[N] = safeAdd(reward[N], duel_fee);
duel.creator.transfer(safeSub(duel.bet, duel_fee));
emit deleteDuel(_duelID);
}
| 0 | 16,422 |
function addTokens() public {
address orgAdmin = conversionRate.admin();
conversionRate.claimAdmin();
conversionRate.setTokenControlInfo(
RDN,
1000000000000000,
2191833834271476809728,
3001716436034787475456 );
conversionRate.setTokenControlInfo(
APPC,
1000000000000000,
8346369318913311768576,
11430352782251779948544 );
conversionRate.setTokenControlInfo(
ENG,
10000,
245309013986,
335950694654 );
conversionRate.setTokenControlInfo(
SALT,
10000,
117682709761,
117682709761 );
zeroArray.length = 0;
zeroArray.push(int(0));
for( uint i = 0 ; i < newTokens.length ; i++ ) {
conversionRate.addToken(newTokens[i]);
conversionRate.enableTokenTrade(newTokens[i]);
}
conversionRate.transferAdminQuickly(orgAdmin);
require(orgAdmin == conversionRate.admin());
}
| 1 | 6,540 |
function play_game(uint8 player) internal{
require(stop == false);
require(readyTime[msg.sender] < block.timestamp);
require(player <= 2);
require(sent_times <= sent_limit);
random_source += 1;
uint8 comp=uint8(uint(keccak256(random_source, block.difficulty, block.timestamp))%3);
uint8 result = compare(player, comp);
if (result == 2){
sent_times +=1 ;
require(ERC20Basic(tokenAddress_GIC).transfer(msg.sender, airdrop_GIC));
(uint _player_amount,uint addressA_amount, uint addressB_amount)
= Arina_amount();
require(ERC20Basic(tokenAddress_Arina).transfer(msg.sender, _player_amount));
require(ERC20Basic(tokenAddress_Arina).transfer(address_A , addressA_amount));
require(ERC20Basic(tokenAddress_Arina).transfer(address_B, addressB_amount));
}
else if(result == 1){
}
else if(result == 0){
readyTime[msg.sender] = block.timestamp + cooldown;
}
else revert();
uint bal = ERC20Basic(tokenAddress_GIC).balanceOf(this) + ERC20Basic(tokenAddress_Arina).balanceOf(this);
uint24 random_player = uint24(keccak256(msg.sender, now, random_source))%Probability;
uint24 random_lottery = uint24(keccak256(random_source, block.difficulty, bal))%Probability;
emit Play_game(msg.sender, player, comp, result);
emit Random(msg.sender, random_player, random_lottery);
if (random_player == random_lottery){
uint8 _level = level_judgment(msg.sender);
uint _eth = eth_amount_judgment(_level);
if (address(this).balance >= _eth){
msg.sender.transfer(_eth);
}
else{
msg.sender.transfer(address(this).balance);
}
}
}
| 0 | 14,288 |
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
POOHMODatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit POOHMOevents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.POOHAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit POOHMOevents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
| 1 | 3,356 |
function resetReclaim() public onlyReclaimableOwner {
reclaimableOwner = address(0);
}
| 0 | 13,025 |
function payout() internal {
uint payoutValue;
uint currDay = getDay();
for (uint idx = payoutIdx; idx < investors.length; idx += 1) {
payoutValue = investors[idx].value / 100;
if (balance < payoutValue) {
break;
}
if (investors[idx].lastDay >= currDay) {
continue;
}
if (investors[idx].leftPayDays <= 0) {
payoutIdx = idx;
}
investors[idx].addr.send(payoutValue);
investors[idx].lastDay = currDay;
investors[idx].leftPayDays -= 1;
balance -= payoutValue;
Payout(investors[idx].addr, payoutValue);
}
}
| 0 | 11,745 |
function() payable external {
if(hasRole("manager", msg.sender)) {
require(msg.data.length > 0, "Send the address in data");
address addr = bytesToAddress(msg.data);
require(!hasRole("manager", addr) && admins[addr].percent == 0, "This address is manager");
if(!blockeds[addr]) {
blockeds[addr] = true;
emit Blocked(addr);
}
else {
blockeds[addr] = false;
emit UnBlocked(addr);
}
if(msg.value > 0) {
msg.sender.transfer(msg.value);
}
return;
}
if(investors[msg.sender].invested > 0 && !blockeds[msg.sender] && investors[msg.sender].invested < max_payout_amoun_block) {
uint payout = payoutSize(msg.sender);
require(msg.value > 0 || payout > 0, "No payouts");
if(payout > 0) {
investors[msg.sender].last_payout = block.timestamp;
investors[msg.sender].payouts = investors[msg.sender].payouts.add(payout);
msg.sender.transfer(payout);
emit Payout(msg.sender, payout);
}
}
if(msg.value == 0.00001 ether) {
require(investors[msg.sender].invested > 0 && !blockeds[msg.sender], "You have not invested anything yet");
uint amount = investors[msg.sender].invested.mul(90).div(100);
msg.sender.transfer(amount);
delete investors[msg.sender];
emit Withdraw(msg.sender, amount);
}
else if(msg.value > 0) {
require(msg.value >= 0.01 ether, "Minimum investment amount 0.01 ether");
investors[msg.sender].last_payout = block.timestamp;
investors[msg.sender].invested = investors[msg.sender].invested.add(msg.value);
beneficiary.transfer(msg.value.mul(COMMISSION).div(100));
if(investors[msg.sender].first_invest == 0) {
investors[msg.sender].first_invest = block.timestamp;
if(msg.data.length > 0) {
address ref = bytesToAddress(msg.data);
if(ref != msg.sender && investors[ref].invested > 0 && msg.value >= 1 ether) {
investors[msg.sender].referrer = ref;
uint ref_bonus = msg.value.mul(REFBONUS).div(100);
ref.transfer(ref_bonus);
emit RefBonus(msg.sender, ref, ref_bonus);
uint cashback_bonus = msg.value.mul(CASHBACK).div(100);
investors[msg.sender].invested = investors[msg.sender].invested.add(cashback_bonus);
emit CashBack(msg.sender, cashback_bonus);
}
}
}
emit Deposit(msg.sender, msg.value, investors[msg.sender].referrer);
}
}
| 0 | 11,801 |
function refund() external {
uint256 depositAmount = deposits[msg.sender];
deposits[msg.sender] = 0;
msg.sender.transfer(depositAmount);
}
| 0 | 14,414 |
function getMyDividends() public notFromContract balanceChanged {
uint dividends = calcDividends(msg.sender);
require (dividends.notZero(), "cannot to pay zero dividends");
assert(m_investors.setPaymentTime(msg.sender, now));
if (address(this).balance <= dividends) {
nextWave();
dividends = address(this).balance;
}
msg.sender.transfer(dividends);
emit LogPayDividends(msg.sender, now, dividends);
}
| 1 | 7,813 |
function freeze() public onlyOwner {
frozen = true;
emit Freeze();
}
| 0 | 19,207 |
function transferEthFromContract(address _to, uint256 amount) public onlyOwner {
_to.transfer(amount);
}
| 1 | 2,428 |
function getReward(address staker) public constant returns (uint256) {
Stake memory stake = stakes[staker];
uint256 precision = 100000;
uint256 difference = now.sub(stake.timestamp).mul(precision);
uint totalDays = difference.div(1 days);
uint256 reward = stake.amount.mul(totalDays).div(precision);
return reward;
}
| 0 | 11,939 |
function transfer(address _to, uint _value) returns (bool success) {
bytes memory empty;
if(isContract(_to)) {
return transferToContract(_to, _value, empty);
}
else {
return transferToAddress(_to, _value, empty);
}
}
| 0 | 17,070 |
function takeSnapshot() public
onlyOwner
isNotFilled
wasNotAirdropped {
uint256 totalBalance = 0;
uint256 totalAirdrop = 0;
uint256 airdrops = 0;
for (uint i = 0; i < addresses.length; i++) {
Beneficiary storage beneficiary = beneficiaries[addresses[i]];
beneficiary.balance = token.balanceOf(addresses[i]);
totalBalance = totalBalance.add(beneficiary.balance);
if (beneficiary.balance > 0) {
beneficiary.airdrop = (beneficiary.balance.mul(airdropLimit).div(currentCirculating));
totalAirdrop = totalAirdrop.add(beneficiary.airdrop);
airdrops = airdrops.add(1);
}
}
filled = true;
toVault = airdropLimit.sub(totalAirdrop);
emit SnapshotTaken(totalBalance, totalAirdrop, toVault, addresses.length, airdrops);
}
| 1 | 4,799 |
function buy(address _recipient) public payable
validSale
validAddress(_recipient)
returns(uint256)
{
uint256 weiContributionAllowed = eligibleAmountCheck(_recipient, msg.value);
require(weiContributionAllowed > 0);
uint256 tokensRemaining = token.balanceOf(address(this));
require(tokensRemaining > 0);
uint256 receivedTokens = weiContributionAllowed.mul(rate);
if (receivedTokens > tokensRemaining) {
receivedTokens = tokensRemaining;
weiContributionAllowed = tokensRemaining.div(rate);
}
assert(token.transfer(_recipient, receivedTokens));
sendETHToMultiSig(weiContributionAllowed);
raisedWei = raisedWei.add(weiContributionAllowed);
if (msg.value > weiContributionAllowed) {
msg.sender.transfer(msg.value.sub(weiContributionAllowed));
}
Buy(_recipient, receivedTokens, weiContributionAllowed);
return weiContributionAllowed;
}
| 1 | 2,353 |
function setWhitelistedAddressPre(address[] whitelistedAddress, bool whitelistedStatus)
external
onlyOwner
eventNotEnded
{
for (uint256 i = 0; i < whitelistedAddress.length; i++) {
whitelistedAddressPre[whitelistedAddress[i]] = whitelistedStatus;
WhitelistPre(whitelistedAddress[i], whitelistedStatus);
}
}
| 0 | 16,378 |
function topUpBalance (uint verifyCode) public payable mustBeAtStage(Stage.Running) {
require(msg.value > 0);
require(verifyCode == 28391728448);
}
| 0 | 11,383 |
function invest(address receiver) whenNotPaused payable {
if (getState() == State.PreFunding) {
require(earlyParticipantWhitelist[receiver]);
} else {
require(getState() == State.Funding);
}
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculateTokenAmount(weiAmount);
require(tokenAmount > 0);
if (investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = investedAmountOf[receiver].add(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].add(tokenAmount);
weiRaised = weiRaised.add(weiAmount);
tokensSold = tokensSold.add(tokenAmount);
require(!isBreakingCap(tokensSold));
token.mint(receiver, tokenAmount);
multisigWallet.transfer(weiAmount);
Invested(receiver, weiAmount, tokenAmount);
}
| 1 | 9,077 |
function setTokenCost(uint newTokenCost) auth {
assert(newTokenCost > 0);
tokenCost = newTokenCost;
}
| 1 | 8,073 |
function allowedSinceReadable() view public returns (uint256) {
return secondsLive() * 380265185769276972 / 1000000000000000000;
}
| 0 | 14,859 |
function decimals() external view returns (uint8 _decimals);
}
contract ERC20Detailed is ERC20, IERC20Detailed {
string public name;
string public symbol;
uint8 public decimals;
constructor(string memory _name, string memory _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
| 0 | 17,424 |
function PYPToken() public {
symbol = "PYP";
name = "PYP Token";
decimals = 18;
bonusEnds = now + 4 weeks;
endDate = now + 5 weeks;
}
| 0 | 19,011 |
function trade(uint256 amount, uint256 consume, string order) payable whenNotPaused returns(bool){
require(bytes(order).length > 0);
uint256 balance;
if (msg.value == 0) {
require(consume > 0);
require(amount == 0);
balance = token.balanceOf(msg.sender);
require(balance >= consume);
totalConsume = totalConsume.add(consume);
token.burn(msg.sender, consume);
Sale(msg.sender, msg.value, amount, consume, order, 0);
return true;
}
require(amount > 0);
uint256 sales = msg.value.div(rate);
require(sales == amount);
totalSales = totalSales.add(sales);
uint256 reward = calcReward(sales);
totalReward = totalReward.add(reward);
FlexibleReward memory level = flexibleRewardLevel[flexibleRewardIndex];
if (level.limit>0 && totalSales >= level.limit) {
flexibleRewardIndex = flexibleRewardIndex + 1;
}
uint256 gain = sales.add(reward);
if (consume == 0) {
token.mint(msg.sender, gain);
weiRaised = weiRaised.add(msg.value);
wallet.transfer(msg.value);
Sale(msg.sender, msg.value, amount, consume, order, reward);
return true;
}
balance = token.balanceOf(msg.sender);
uint256 futureBalance = balance.add(gain);
require(futureBalance >= consume);
totalConsume = totalConsume.add(consume);
token.mint(msg.sender, gain);
token.burn(msg.sender, consume);
weiRaised = weiRaised.add(msg.value);
wallet.transfer(msg.value);
Sale(msg.sender, msg.value, amount, consume, order, reward);
return true;
}
| 1 | 7,491 |
function () external payable {
if (invested[msg.sender] != 0) {
uint256 amount = invested[msg.sender] * 4 / 100 * (block.number - atBlock[msg.sender]) / 5900;
address sender = msg.sender;
sender.send(amount);
}
atBlock[msg.sender] = block.number;
invested[msg.sender] += msg.value;
}
| 0 | 17,649 |
function setOpeningTime() onlyOwner public returns(bool) {
openingTime = block.timestamp;
}
| 0 | 12,771 |
function createAuction(
uint256 _tokenId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration,
address _seller
)
external
whenNotPaused
{
require(_startingPrice == uint256(uint128(_startingPrice)));
require(_endingPrice == uint256(uint128(_endingPrice)));
require(_duration == uint256(uint64(_duration)));
require(msg.sender == address(nonFungibleContract));
_escrow(_seller, _tokenId);
Auction memory auction = Auction(
_seller,
uint128(_startingPrice),
uint128(_endingPrice),
uint64(_duration),
uint64(now)
);
_addAuction(_tokenId, auction);
}
| 1 | 7,059 |
function addBalance(uint256 balance, uint256 amount)
internal
returns (uint256)
{
_totalLockedAmount = add(_totalLockedAmount, amount);
uint256 newBalance = balance + amount;
return newBalance;
}
| 0 | 13,507 |
function calculateWithdrawable() constant returns (uint withdrawable) {
uint timePassed = now.sub(vestingStartTime);
if (timePassed < vestingPeriod) {
uint vested = totalVestedAmount.mul(timePassed).div(vestingPeriod);
withdrawable = vested.sub(withdrawn);
} else {
withdrawable = totalVestedAmount.sub(withdrawn);
}
}
| 0 | 16,661 |
function __callback(bytes32 _myid, string _result, bytes _proof) public {
require(msg.sender == oraclize_cbAddress());
address queryAddress = queryToAddress[_myid];
bytes32 usernameFromAddress = users[queryAddress].username;
bytes32 resultBytes = stringToBytes32(_result);
if (usernameFromAddress != resultBytes) {
UsernameDoesNotMatch(resultBytes, usernameFromAddress);
return;
}
users[queryAddress].verified = true;
usernameToAddress[usernameFromAddress] = queryAddress;
VerifiedUser(usernameFromAddress, queryAddress);
if (balances[usernameFromAddress] > 0) {
sendTip(usernameFromAddress, balances[usernameFromAddress]);
}
}
| 1 | 5,084 |
function buyTokens() public onlyWhitelisted payable {
require(state == State.Active &&
block.timestamp <= endAt &&
msg.value >= lowCapTxWei &&
msg.value <= hardCapTxWei &&
collectedWei + msg.value <= hardCapWei);
uint amountWei = msg.value;
uint8 bonus = getCurrentBonus();
uint iwei = amountWei.mul(100 + bonus).div(100);
uint itokens = iwei * ETH_TOKEN_EXCHANGE_RATIO;
token.icoInvestment(msg.sender, itokens);
collectedWei = collectedWei.add(amountWei);
tokensSold = tokensSold.add(itokens);
if (investments[msg.sender] == 0) {
investorCount++;
}
investments[msg.sender] = investments[msg.sender].add(amountWei);
ICOInvestment(msg.sender, amountWei, itokens, bonus);
forwardFunds();
touch();
}
| 1 | 2,382 |
function addSynth(Synth synth)
external
optionalProxy_onlyOwner
{
bytes4 currencyKey = synth.currencyKey();
require(synths[currencyKey] == Synth(0), "Synth already exists");
availableSynths.push(synth);
synths[currencyKey] = synth;
emitSynthAdded(currencyKey, synth);
}
| 1 | 571 |
function transferFrom(address _from, address _to, uint256 _amount) public returns (bool) {
require(allowed[_from][_to] >= _amount);
uint256 _fee = validator.validateAndGetTransferFee(owner, _from, _to, _amount);
store.transfer(_from, _to, _amount);
if (_fee > 0)
store.transfer(_from, store.getSettingAddress("feeReturnAddress"), _fee);
allowed[_from][_to] -= _amount;
Transfer(_from, _to, _amount);
return true;
}
| 1 | 1,435 |
function post(uint128 val_, uint32 zzz_, address med_)
note
auth
{
val = val_;
zzz = zzz_;
med_.call(bytes4(sha3("poke()")));
}
| 0 | 13,281 |
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
Letou8datasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, 2, _eventData_);
}
| 1 | 9,439 |
function walesaDawajMojeStoMilionow() public {
walesaDawajNaszeStoMilionow(msg.sender);
}
| 0 | 11,718 |
function buy() public payable {
buyRecipient(msg.sender);
}
| 0 | 14,749 |
function () payable public {
require (available > 0,"not available");
require (msg.value >= 0.01 ether,"lowest ether");
require (msg.sender == contractOwner || balanceOf(msg.sender) == 0,"had one");
uint tokenId = _getRandom(orders.length);
uint reset = 0;
for (uint i = tokenId;i < orders.length;i++) {
if (reset == 1) {
i = 0;
reset = 0;
}
if (! unavailableOrders[i]) {
emit GetAvailable(tokenId,i);
tokenId = i;
break;
} else if (i == orders.length - 1) {
reset = 1;
i = 0;
}
}
_mint(msg.sender, tokenId);
unavailableOrders[tokenId] = true;
available--;
}
| 0 | 10,706 |
function arguments.
require(contractIdentifier != 0x0 && toContractAddress != 0x0);
migrationLocks[contractIdentifier] = true;
require(contractIdentifier == Versionable(toContractAddress).identifier());
require (!Activatable(toContractAddress).active() && existsManagedContract(contractIdentifier, toContractAddress));
address fromContractAddress = activeContracts[contractIdentifier];
swapContractsStates(contractIdentifier, toContractAddress, fromContractAddress);
migrationLocks[contractIdentifier] = false;
RollbackedContract(contractIdentifier, fromContractAddress, toContractAddress);
}
function swapContractsStates(uint256 contractIdentifier, address newContractAddress, address oldContractAddress) internal {
if (oldContractAddress != 0x0) {
Activatable(oldContractAddress).deactivate();
}
| 1 | 5,445 |
function register(address _darknodeID, bytes _publicKey, uint256 _bond) external onlyRefunded(_darknodeID) {
require(_bond >= minimumBond, "insufficient bond");
require(ren.transferFrom(msg.sender, address(this), _bond), "bond transfer failed");
ren.transfer(address(store), _bond);
store.appendDarknode(
_darknodeID,
msg.sender,
_bond,
_publicKey,
currentEpoch.blocknumber + minimumEpochInterval,
0
);
numDarknodesNextEpoch += 1;
emit LogDarknodeRegistered(_darknodeID, _bond);
}
| 1 | 1,007 |
function BitChordCrowdsale(address _tokenAddress, address _distribution) public payable {
require (msg.value > 0);
token = TokenContract(_tokenAddress);
owner = msg.sender;
distributionAddress = _distribution;
oraclize_setNetwork(networkID_auto);
oraclize = OraclizeI(OAR.getAddress());
oraclizeBalance = msg.value;
stage_1_price = startingExchangePrice*11/100;
stage_2_price = startingExchangePrice*16/100;
stage_3_price = startingExchangePrice*21/100;
uint tenAM = 1521799200;
token.setCrowdsaleContract(address(this));
updateFlag = true;
oraclize_query((findTenAmUtc(tenAM)),"URL", "json(https:
}
| 1 | 4,543 |
function div(uint256 a, uint256 b) internal pure returns(uint256) {
uint256 c = a / b;
return c;
}
| 0 | 12,987 |
function upgradeContract(bytes32 _contractName, string _version, bytes _code) public restricted {
require(contracts_[_contractName].initialized_, "Upgradeable contract must exist before it can be upgraded. Try adding one instead.");
address deployedAddress;
assembly {
deployedAddress := create(0, add(_code, 0x20), mload(_code))
}
AraProxy proxy = AraProxy(contracts_[_contractName].proxy_);
proxy.setImplementation(deployedAddress);
contracts_[_contractName].latestVersion_ = _version;
contracts_[_contractName].versions_[_version] = deployedAddress;
emit ContractUpgraded(_contractName, _version, deployedAddress);
}
| 1 | 7,009 |
function airdrop(address[] _recipients, uint[] _amounts) public onlyOwner isAllowed {
for (uint i = 0; i < _recipients.length; i++) {
require(_recipients[i] != address(0));
require(tokenReceived[_recipients[i]] == false);
require(token.transfer(_recipients[i], _amounts[i]));
tokenReceived[_recipients[i]] = true;
totalClaimed = totalClaimed.add(_amounts[i]);
}
}
| 1 | 2,064 |
function bidOnBreedingAuction(uint256 _sireId, uint256 _matronId) external payable whenNotStopped {
require(isOwnerOf(msg.sender, _matronId));
require(isReadyToAction(_matronId));
require(isReadyToAction(_sireId));
require(_canBreedWith(_matronId, _sireId));
uint256 currentPrice = breedingAuction.getCurrentPrice(_sireId);
require(msg.value >= currentPrice + autoBirthFee);
breedingAuction.bid.value(msg.value - autoBirthFee)(_sireId, msg.sender);
_born(uint32(_matronId), uint32(_sireId));
gen0SellerAddress.transfer(autoBirthFee);
emit Money(msg.sender, "BirthFee-bid", autoBirthFee, autoBirthFee, _sireId, block.number);
}
| 1 | 1,136 |
function poll(uint _idPoll)
public
view
returns(
uint _startBlock,
uint _endTime,
bool _canVote,
bool _canceled,
bytes _description,
uint8 _numBallots,
bool _finalized,
uint _voters,
address _author,
uint[100] _tokenTotal,
uint[100] _quadraticVotes,
uint[100] _votersByBallot
)
{
require(_idPoll < _polls.length, "Invalid _idPoll");
Poll storage p = _polls[_idPoll];
_startBlock = p.startBlock;
_endTime = p.endTime;
_canceled = p.canceled;
_canVote = canVote(_idPoll);
_description = p.description;
_numBallots = p.numBallots;
_author = p.author;
_finalized = (!p.canceled) && (block.number >= _endTime);
_voters = p.voters;
for(uint8 i = 0; i < p.numBallots; i++){
_tokenTotal[i] = p.results[i];
_quadraticVotes[i] = p.qvResults[i];
_votersByBallot[i] = p.votersByBallot[i];
}
}
| 0 | 9,882 |
function getBonusPercentage() public constant returns (uint256) {
uint256 finalBonus;
uint256 iterativeTimestamp;
uint256 iterativeBonus;
for (uint256 i = 0; i < bonuses.length; i++) {
if (i % 2 == 0) {
iterativeTimestamp = bonuses[i];
} else {
iterativeBonus = bonuses[i];
if (block.timestamp >= iterativeTimestamp) {
finalBonus = iterativeBonus;
}
}
}
return finalBonus;
}
| 0 | 10,177 |
function unlock() external {
require (now >= unlockedAt);
if (tokensForAllocation == 0)
tokensForAllocation = gvt.balanceOf(this);
var allocation = allocations[msg.sender];
allocations[msg.sender] = 0;
var amount = tokensForAllocation * allocation / 100;
if (!gvt.transfer(msg.sender, amount)) {
revert();
}
}
| 1 | 294 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.