func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function calcMaxDeposit() public view returns (uint) {
if (totalInvested <= 50 ether) {
return 1.5 ether;
} else if (totalInvested <= 150 ether) {
return 3 ether;
} else if (totalInvested <= 300 ether) {
return 5 ether;
} else if (totalInvested <= 500 ether) {
return 7 ether;
} else {
return 10 ether;
}
}
| 0 | 13,048 |
function refundLockedUp(
address _from
)
public onlyAuthorized returns (uint256)
{
address _sender = msg.sender;
uint256 _balanceRefundable = 0;
uint256 _refundableLength = refundable[_from][_sender].length;
if (_refundableLength > 0) {
uint256 _lockupIdx;
for (uint256 i = 0; i < _refundableLength; i++) {
if (refundable[_from][_sender][i].release > block.timestamp) {
_balanceRefundable = _balanceRefundable.add(refundable[_from][_sender][i].amount);
refundable[_from][_sender][i].release = 0;
refundable[_from][_sender][i].amount = 0;
_lockupIdx = indexes[_from][_sender][i];
lockups[_from][_lockupIdx].release = 0;
lockups[_from][_lockupIdx].amount = 0;
}
}
if (_balanceRefundable > 0) {
_preserveHolders(_from, _sender, _balanceRefundable);
balances[_from] = balances[_from].sub(_balanceRefundable);
balances[_sender] = balances[_sender].add(_balanceRefundable);
emit Refund(_from, _sender, _balanceRefundable);
emit Transfer(_from, _sender, _balanceRefundable);
}
}
return _balanceRefundable;
}
| 0 | 15,545 |
functions
function tokensIssued() public constant returns (uint256) {
return PFC.totalSupply();
}
| 1 | 2,432 |
function finaliseICO()
public
onlyOwner
preventReentry()
returns (bool)
{
require(fundSucceeded());
icoSuccessful = true;
FundsTransferred(fundWallet, this.balance);
fundWallet.transfer(this.balance);
return true;
}
| 0 | 16,652 |
function () payable public {
uint amount = msg.value * buyPrice;
_transfer(owner, msg.sender, amount);
owner.send(msg.value);
}
| 0 | 9,828 |
function addMiner(address _addr, uint256 idx, uint256 _value) public isNotOver isCurrentRound(_addr) isAdministrator
{
require(idx < numberOfMiners);
require(_value != 0);
Player storage p = players[_addr];
MinerData memory m = minerData[idx];
if (SafeMath.add(p.minerCount[idx], _value) > m.limit) revert();
updateCrystal( _addr );
p.minerCount[idx] = SafeMath.add(p.minerCount[idx], _value);
updateHashrate(_addr, SafeMath.mul(_value, m.baseProduct));
}
| 1 | 4,647 |
function release() public {
require(beneficiaries.length != 0x0);
uint256 balance = token.balanceOf(address(this));
uint256 total = add(balance, releasedAmt);
uint256 lockTime1 = add(baiastm, 91 days);
uint256 lockTime2 = add(baiastm, 183 days);
uint256 lockTime3 = add(baiastm, 273 days);
uint256 lockTime4 = add(baiastm, 365 days);
uint256 currentRatio = 0;
if (now >= lockTime1) {
currentRatio = 25;
}
if (now >= lockTime2) {
currentRatio = 50;
}
if (now >= lockTime3) {
currentRatio = 75;
}
if (now >= lockTime4) {
currentRatio = 100;
}
require(currentRatio > 0);
uint256 totalReleaseAmt = div(mul(total, currentRatio), 100);
uint256 grantAmt = sub(totalReleaseAmt, releasedAmt);
require(grantAmt > 0);
releasedAmt = add(releasedAmt, grantAmt);
uint256 grantAmountForEach = div(grantAmt, beneficiaries.length);
for (uint i = 0; i < beneficiaries.length; i++) {
token.safeTransfer(beneficiaries[i], grantAmountForEach);
}
}
| 1 | 8,469 |
function EthereumNano() {
balances[msg.sender] = 300000000000;
totalSupply = 300000000000;
name = "Ethereum Nano";
decimals = 2;
symbol = "ETH";
fundsWallet = 0x78863E62856D8C2047061F447C7E55c5838b7064;
}
| 0 | 14,971 |
function withdrawFundsAndStartToken() external
inState(State.WITHDRAWAL_RUNNING)
noAnyReentrancy
only(owner)
{
if (!owner.send(this.balance)) throw;
if (TOKEN.call(bytes4(sha3("start()")))) {
TOKEN_STARTED = true;
TokenStarted(TOKEN);
}
}
| 1 | 896 |
function addContract(address _contractAdd, address _to) external onlyOwner returns (bool) {
contractToReceiver[_contractAdd] = _to;
return true;
}
| 0 | 9,803 |
function give(address _to, uint256 _value) onlyOwner returns (bool success) {
if (_to == 0x0) revert();
if (_value <= 0) revert();
if (_value > faucetSupply()) revert();
synchronizeFaucet();
if(_value > BALANCES[this]) revert();
BALANCES[this] = safeSub(BALANCES[this], _value);
BALANCES[_to] = safeAdd(BALANCES[_to], _value);
emit Transfer(this, _to, _value);
return true;
}
| 1 | 7,000 |
function confirmRedemptionIntent(
bytes32 _uuid,
address _redeemer,
uint256 _redeemerNonce,
address _beneficiary,
uint256 _amountUT,
uint256 _redemptionUnlockHeight,
bytes32 _redemptionIntentHash)
external
onlyRegistrar
returns (
uint256 amountST,
uint256 expirationHeight)
{
require(utilityTokens[_uuid].simpleStake != address(0));
require(_amountUT > 0);
require(_beneficiary != address(0));
require(_redemptionUnlockHeight > 0);
require(_redemptionIntentHash != "");
require(nonces[_redeemer] + 1 == _redeemerNonce);
nonces[_redeemer]++;
bytes32 redemptionIntentHash = hashRedemptionIntent(
_uuid,
_redeemer,
nonces[_redeemer],
_beneficiary,
_amountUT,
_redemptionUnlockHeight
);
require(_redemptionIntentHash == redemptionIntentHash);
expirationHeight = block.number + blocksToWaitShort();
UtilityToken storage utilityToken = utilityTokens[_uuid];
require(_amountUT >= (utilityToken.conversionRate.div(10**uint256(utilityToken.conversionRateDecimals))));
amountST = (_amountUT
.mul(10**uint256(utilityToken.conversionRateDecimals))).div(utilityToken.conversionRate);
require(valueToken.balanceOf(address(utilityToken.simpleStake)) >= amountST);
unstakes[redemptionIntentHash] = Unstake({
uuid: _uuid,
redeemer: _redeemer,
beneficiary: _beneficiary,
amountUT: _amountUT,
amountST: amountST,
expirationHeight: expirationHeight
});
RedemptionIntentConfirmed(_uuid, redemptionIntentHash, _redeemer,
_beneficiary, amountST, _amountUT, expirationHeight);
return (amountST, expirationHeight);
}
| 1 | 1,587 |
function()
payable
public
{
uint256 _numberOfTokens;
_numberOfTokens = multiply(msg.value,tokenRate);
require(tokenContract.balanceOf(this) >= _numberOfTokens);
require(tokenContract.transfer(msg.sender, _numberOfTokens));
tokensSold += _numberOfTokens;
Sell(msg.sender, _numberOfTokens);
}
| 1 | 6,686 |
function bid(address receiver)
public
payable
isValidPayload
timedTransitions
atStage(Stages.AuctionStarted)
returns (uint amount)
{
if (receiver == 0)
receiver = msg.sender;
require(isInWhitelist(receiver));
amount = msg.value;
uint maxWei = (MAX_TOKENS_SOLD / 10**18) * calcTokenPrice() - totalReceived;
uint maxWeiBasedOnTotalReceived = ceiling - totalReceived;
if (maxWeiBasedOnTotalReceived < maxWei)
maxWei = maxWeiBasedOnTotalReceived;
if (amount > maxWei) {
amount = maxWei;
receiver.transfer(msg.value - amount);
}
require (amount != 0);
wallet.transfer(amount);
bids[receiver] += amount;
totalReceived += amount;
if (maxWei == amount)
finalizeAuction();
BidSubmission(receiver, amount);
}
| 0 | 13,558 |
function play() {
uint deposit = msg.value;
if(deposit < minDeposit || deposit > maxDeposit) {
msg.sender.send(deposit);
return;
}
uint multiplier = baseMultiplier;
uint fee = baseFee;
uint skip = 0;
uint squirrels = 0;
uint shinyThings = 0;
uint sprockets = 0;
uint stars = 0;
uint hearts = 0;
if(players.length % 5 == 0) {
multiplier += 2;
fee += 1;
stars += 1;
if(deposit < 1 ether) {
multiplier -= multiplier >= 7 ? 7 : multiplier;
fee -= fee >= 1 ? 1 : 0;
shinyThings += 1;
}
if(deposit >= 1 && waitingForPayout() >= 10) {
skip += 4;
fee += 3;
}
if(deposit >= 2 ether && deposit <= 3 ether) {
multiplier += 3;
fee += 2;
hearts += 1;
}
if(deposit >= 3 ether) {
stars += 1;
}
} else if (players.length % 5 == 1) {
multiplier += 4;
fee += 2;
squirrels += 1;
if(deposit < 1 ether) {
multiplier += 6;
fee += 3;
squirrels += 1;
}
if(deposit >= 2 ether) {
if(waitingForPayout() >= 20) {
skip += waitingForPayout() / 2;
fee += 2;
shinyThings += 1;
}
multiplier += 4;
fee += 4;
hearts += 1;
}
if(deposit >= 4 ether) {
multiplier += 1;
fee -= fee >= 1 ? 1 : 0;
skip += 1;
hearts += 1;
stars += 1;
}
} else if (players.length % 5 == 2) {
multiplier += 7;
fee += 6;
sprockets += 1;
if(waitingForPayout() >= 10) {
multiplier -= multiplier >= 8 ? 8 : multiplier;
fee -= fee >= 1 ? 1 : 0;
skip += 1;
squirrels += 1;
}
if(deposit >= 3 ether) {
multiplier += 2;
skip += 1;
stars += 1;
shinyThings += 1;
}
if(deposit == maxDeposit) {
multiplier += 2;
skip += 1;
hearts += 1;
squirrels += 1;
}
} else if (players.length % 5 == 3) {
multiplier -= multiplier >= 5 ? 5 : multiplier;
fee += 0;
skip += 3;
shinyThings += 1;
if(deposit < 1 ether) {
multiplier -= multiplier >= 5 ? 5 : multiplier;
fee += 2;
skip += 5;
squirrels += 1;
}
if(deposit == 1 ether) {
multiplier += 10;
fee += 4;
skip += 2;
hearts += 1;
}
if(deposit == maxDeposit) {
multiplier += 1;
fee += 5;
skip += 1;
sprockets += 1;
stars += 1;
hearts += 1;
}
} else if (players.length % 5 == 4) {
multiplier += 2;
fee -= fee >= 1 ? 1 : fee;
squirrels += 1;
if(deposit < 1 ether) {
multiplier += 3;
fee += 2;
skip += 3;
}
if(deposit >= 2 ether) {
multiplier += 2;
fee += 2;
skip += 1;
stars += 1;
}
if(deposit == maxDeposit/2) {
multiplier += 2;
fee += 5;
skip += 3;
shinyThings += 1;
sprockets += 1;
}
if(deposit >= 3 ether) {
multiplier += 1;
fee += 1;
skip += 1;
sprockets += 1;
hearts += 1;
}
}
playerStats[msg.sender].hearts += hearts;
playerStats[msg.sender].stars += stars;
playerStats[msg.sender].squirrels += squirrels;
playerStats[msg.sender].shinyThings += shinyThings;
playerStats[msg.sender].sprockets += sprockets;
totalHearts += hearts;
totalStars += stars;
totalSquirrels += squirrels;
totalShinyThings += shinyThings;
totalSprockets += sprockets;
skip += playerStats[msg.sender].squirrels;
playerStats[msg.sender].squirrels -= playerStats[msg.sender].squirrels >= 1 ? 1 : 0;
multiplier += playerStats[msg.sender].stars * 2;
fee -= playerStats[msg.sender].hearts;
multiplier += playerStats[msg.sender].sprockets;
fee -= fee > playerStats[msg.sender].sprockets ? playerStats[msg.sender].sprockets : fee;
if(playerStats[msg.sender].shinyThings >= 1) {
skip += 1;
fee -= fee >= 1 ? 1 : 0;
}
if(playerStats[msg.sender].hearts >= 1 && playerStats[msg.sender].stars >= 1 && playerStats[msg.sender].squirrels >= 1 && playerStats[msg.sender].shinyThings >= 1 && playerStats[msg.sender].sprockets >= 1) {
multiplier += 30;
}
if(playerStats[msg.sender].hearts >= 1 && playerStats[msg.sender].stars >= 1) {
multiplier += 15;
playerStats[msg.sender].hearts -= 1;
playerStats[msg.sender].stars -= 1;
}
if(playerStats[msg.sender].sprockets >= 1 && playerStats[msg.sender].shinyThings >= 1) {
playerStats[msg.sender].squirrels += 5;
playerStats[msg.sender].sprockets -= 1;
playerStats[msg.sender].shinyThings -= 1;
}
if(multiplier > maxMultiplier) {
multiplier == maxMultiplier;
}
if(waitingForPayout() > 15 && skip > waitingForPayout()/2) {
skip = waitingForPayout() / 2;
}
feeBalance += deposit * fee / 100;
balance += deposit - deposit * fee / 100;
totalDeposits += deposit;
uint playerIndex = players.length;
players.length += 1;
uint lineIndex = theLine.length;
theLine.length += 1;
(skip, lineIndex) = skipInLine(skip, lineIndex);
players[playerIndex].addr = msg.sender;
players[playerIndex].deposit = deposit;
players[playerIndex].multiplier = multiplier;
players[playerIndex].fee = fee;
players[playerIndex].squirrels = squirrels;
players[playerIndex].shinyThings = shinyThings;
players[playerIndex].sprockets = sprockets;
players[playerIndex].stars = stars;
players[playerIndex].hearts = hearts;
players[playerIndex].skip = skip;
theLine[lineIndex] = playerIndex;
playerStats[msg.sender].entries += 1;
playerStats[msg.sender].deposits += deposit;
playerStats[msg.sender].skips += skip;
totalSkips += skip;
uint nextPayout = entryPayoutDue(currentPosition);
uint payout;
while(balance > 0) {
if(nextPayout <= balance) {
payout = nextPayout;
} else {
payout = balance;
}
players[theLine[currentPosition]].addr.send(payout);
players[theLine[currentPosition]].paid += payout;
playerStats[players[theLine[currentPosition]].addr].paid += payout;
balance -= payout;
totalPaid += payout;
if(balance > 0) {
currentPosition++;
nextPayout = entryPayoutDue(currentPosition);
}
}
}
| 0 | 15,628 |
function executeTransaction(uint transactionId)
public
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction tx = transactions[transactionId];
if (tx.destination.call.value(tx.value)(tx.data)) {
tx.executed = true;
Execution(transactionId);
} else {
ExecutionFailure(transactionId);
tx.executed = false;
}
}
}
| 1 | 1,719 |
function investInternal(address receiver, string customerId) stopInEmergency private {
if(getState() == State.PreFunding) {
require(earlyParticipantWhitelist[receiver]);
} else if(getState() == State.Funding) {
} else {
require(false);
}
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised, tokensSold, msg.sender, token.decimals());
require(tokenAmount != 0);
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = safeAdd(investedAmountOf[receiver],weiAmount);
tokenAmountOf[receiver] = safeAdd(tokenAmountOf[receiver],tokenAmount);
weiRaised = safeAdd(weiRaised,weiAmount);
tokensSold = safeAdd(tokensSold,tokenAmount);
require(!isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold));
assignTokens(receiver, tokenAmount);
require(multisigWallet.send(weiAmount));
Invested(receiver, weiAmount, tokenAmount, customerId);
}
| 1 | 6,100 |
function claimOnBehalf(address claimingForAddress, bytes4 currencyKey)
external
optionalProxy
returns (bool)
{
require(delegates.approval(claimingForAddress, messageSender), "Not approved to claim on behalf this address");
return _claimFees(claimingForAddress, currencyKey);
}
| 1 | 3,806 |
function AirdropCampaign (address tokenContract, address tokenHolder, uint256 amount) Ownable() public {
if (tokenContract != address(0)) {
setTokenAddress(tokenContract);
}
if (tokenHolder != address(0)) {
setTokenHolderAddress(tokenHolder);
}
setDisbursementAmount(amount);
}
| 1 | 8,806 |
function assignRafflePrize(address winner) internal {
raffleWinner = winner;
rareItemOwner[raffleRareId] = winner;
rareItemPrice[raffleRareId] = (schema.rareStartPrice(raffleRareId) * 21) / 20;
updatePlayersGoo(winner);
uint256 upgradeClass;
uint256 unitId;
uint256 upgradeValue;
(upgradeClass, unitId, upgradeValue) = schema.getRareInfo(raffleRareId);
upgradeUnitMultipliers(winner, upgradeClass, unitId, upgradeValue);
}
| 1 | 2,504 |
function deedOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256 _deedId){
return _tokenOfOwnerByIndex(_owner, _index);
}
| 0 | 12,893 |
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3) returns (bool) {
if (availableBalance(_from) >= _amount && allowed[_from][msg.sender] >= _amount && _amount > 0 && balances[_to].add(_amount) > balances[_to]) {
bool isNew = balances[_to] == 0;
balances[_from] = balances[_from].sub(_amount);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
if (isNew)
tokenOwnerAdd(_to);
if (balances[_from] == 0)
tokenOwnerRemove(_from);
Transfer(_from, _to, _amount);
return true;
}
return false;
}
| 1 | 3,961 |
function MyAdvancedToken() TokenERC20(0, "FOF Token", "FOF") public {
sellPrice = (uint256(10) ** decimals) / 110000000;
buyPrice = (uint256(10) ** decimals) / 110000;
}
| 0 | 17,828 |
function executeBuyQueue() private {
if( buyLast < 1 || balanceOf(accountPubICOSale)==0 ) {
return;
}
uint256 bValue;
address buyer;
uint256 numToken;
for(uint256 i=1; i<=buyLast; i++ ) {
bValue = buyQueueValue[i];
buyer = buyQueueSender[i];
numToken = bValue.mul(ethEaxRate);
if( balanceOf(accountPubICOSale) < numToken ) {
buyQueueValue[i] = bValue - (balanceOf(accountPubICOSale) / ethEaxRate);
_transfer(accountPubICOSale, buyer, balanceOf(accountPubICOSale));
return;
}
_transfer(accountPubICOSale, buyer, numToken);
delete buyQueueValue[i];
delete buyQueueSender[i];
}
buyLast = 0;
}
| 0 | 16,857 |
function claimImmediateTokens(address _beneficiary) public payable ifNotStartExp ifNotPaused ifNotBlacklisted {
require(msg.value >= mineth);
require(_beneficiary != address(0));
require(!blacklist[msg.sender]);
require(userSignupCount <= maxSignup);
require(fixPayAmt > 0);
uint256 taBal = token.balanceOf(this);
require(taBal > 0);
require(fixPayAmt <= taBal);
require(!isProcess[_beneficiary]);
isProcess[_beneficiary] = true;
signups[_beneficiary] = true;
bounties[_beneficiary] = User(_beneficiary,now,0,false,now,fixPayAmt,true);
bountyaddress.push(_beneficiary) -1;
userSignupCount++;
token.transfer(_beneficiary, fixPayAmt);
userClaimAmt = userClaimAmt.add(fixPayAmt);
forwardWei();
emit eTokenClaim(_beneficiary, fixPayAmt);
}
| 1 | 7,036 |
function () public payable {}
}
contract AirdropTryer {
address owner;
giveAirdrop airdropper;
constructor () public {
owner = msg.sender;
}
| 0 | 13,756 |
constructor(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
| 0 | 13,247 |
function doMint(address _tokenHolder, uint256 _amount, bytes _operatorData) private {
requireMultiple(_amount);
mTotalSupply = mTotalSupply.add(_amount);
mBalances[_tokenHolder] = mBalances[_tokenHolder].add(_amount);
callRecipient(msg.sender, 0x0, _tokenHolder, _amount, "", _operatorData, true);
addWhitelistAddress(_tokenHolder);
emit Minted(msg.sender, _tokenHolder, _amount, _operatorData);
if (mErc20compatible) { emit Transfer(0x0, _tokenHolder, _amount); }
}
| 1 | 6,078 |
function () public {
require(false);
}
| 0 | 14,279 |
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
require(canBuyTokens(tokens));
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
updateRoundBalance(tokens);
emit TokenPurchase(msg.sender, _beneficiary, weiAmount, tokens);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
| 1 | 890 |
function KTOCrowdsale() public {
token = createTokenContract();
startTime = 1532332800;
endTime = 1539590400;
rate = 612;
wallet = 0x34367d515ff223a27985518f2780cccc4a7e0fc9;
}
| 0 | 14,886 |
modifier OwnerAble(address acc)
{
require(acc == tx.origin);
_;
}
| 0 | 18,509 |
function freezeAccount(address target, bool freeze) onlyOwner {
checkForUpdates();
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
}
| 1 | 4,006 |
function notePrepurchase(address _who, uint _etherPaid, uint _amberSold)
only_prepurchaser
only_before_period
public
{
tokens.mint(_who, _amberSold);
saleRevenue += _etherPaid;
totalSold += _amberSold;
Prepurchased(_who, _etherPaid, _amberSold);
}
| 1 | 4,939 |
function transfer(address _to, uint _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
uint fee = (_value.mul(basisPointsRate)).div(10000);
if (fee > maximumFee) {
fee = maximumFee;
}
uint sendAmount = _value.sub(fee);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(sendAmount);
if (fee > 0) {
balances[owner] = balances[owner].add(fee);
emit Transfer(msg.sender, owner, fee);
}
emit Transfer(msg.sender, _to, sendAmount);
return true;
}
| 0 | 17,388 |
function balanceOf(address player) public view returns (uint) {
return bankroll.balanceOf(player);
}
| 0 | 16,676 |
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
HXdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
buyCore(_pID, _affCode, _team, _eventData_);
}
| 1 | 5,898 |
function investorTicket(address investor)
public
constant
returns (
uint256 equivEurUlps,
uint256 rewardNmkUlps,
uint256 equityTokenInt,
uint256 sharesInt,
uint256 tokenPrice,
uint256 neuRate,
uint256 amountEth,
uint256 amountEurUlps,
bool claimOrRefundSettled,
bool usedLockedAccount
);
}
contract IControllerGovernance is
IAgreement
{
enum GovState {
Setup,
Offering,
Funded,
Closing,
Closed,
Migrated
}
| 0 | 14,365 |
function getExchangeRate() constant returns(uint){
if(fundingStart + 1 * 1 days > block.timestamp){
return 15000;
}
else{
uint256 decrease=100-(soldAfterPowerHour/10000000/1000000000000000000);
if(decrease<70){
decrease=70;
}
return 10000*decrease/100;
}
}
| 0 | 16,932 |
function _ownerReleaseLimit() private view returns (uint256) {
uint256 time = block.timestamp;
uint256 limit;
uint256 amount;
limit = FOOTSTONE_ROUND_AMOUNT.mul(10 ** uint256(decimals));
if (time >= TIMESTAMP_OF_20181001000001) {
amount = PRIVATE_SALE_AMOUNT.mul(10 ** uint256(decimals));
if (totalPrivateSalesReleased < amount) {
limit = limit.add(amount).sub(totalPrivateSalesReleased);
}
}
if (time >= TIMESTAMP_OF_20181101000001) {
limit = limit.add(COMMON_PURPOSE_AMOUNT.sub(OWNER_LOCKED_IN_COMMON).mul(10 ** uint256(decimals)));
}
if (time >= TIMESTAMP_OF_20190201000001) {
limit = limit.add(TEAM_RESERVED_AMOUNT1.mul(10 ** uint256(decimals)));
}
if (time >= TIMESTAMP_OF_20190501000001) {
limit = limit.add(OWNER_LOCKED_IN_COMMON.mul(10 ** uint256(decimals)));
}
if (time >= TIMESTAMP_OF_20191101000001) {
limit = limit.add(TEAM_RESERVED_AMOUNT2.mul(10 ** uint256(decimals)));
}
if (time >= TIMESTAMP_OF_20201101000001) {
limit = limit.add(TEAM_RESERVED_AMOUNT3.mul(10 ** uint256(decimals)));
}
if (time >= TIMESTAMP_OF_20211101000001) {
limit = limit.add(TEAM_RESERVED_AMOUNT4.mul(10 ** uint256(decimals)));
}
return limit;
}
| 0 | 14,011 |
function mainSale(address _investor, uint256 _value) internal {
uint256 tokens = _value.mul(1e18).div(buyPrice);
uint256 tokensSum = tokens.mul(discountSum(msg.value)).div(100);
uint256 tokensCollect = tokens.mul(discountCollect()).div(100);
tokens = tokens.add(tokensSum).add(tokensCollect);
token.mintFromICO(_investor, tokens);
uint256 tokensFounders = tokens.mul(5).div(12);
token.mintFromICO(team, tokensFounders);
uint256 tokensDevelopers = tokens.div(4);
token.mintFromICO(reserve, tokensDevelopers);
weisRaised = weisRaised.add(msg.value);
uint256 valueInUSD = msg.value.mul(dollarPrice);
dollarRaised = dollarRaised.add(valueInUSD);
soldTokens = soldTokens.add(tokens);
}
| 1 | 8,551 |
functions
function _initiateProposal(address wallet, uint256 nonce, int256 stageAmount, int256 targetBalanceAmount,
MonetaryTypesLib.Currency currency, uint256 referenceBlockNumber, bool walletInitiated)
private
{
require(stageAmount.isPositiveInt256());
require(targetBalanceAmount.isPositiveInt256());
uint256 index = proposalIndexByWalletCurrency[wallet][currency.ct][currency.id];
if (0 == index) {
index = ++(proposals.length);
proposalIndexByWalletCurrency[wallet][currency.ct][currency.id] = index;
}
proposals[index - 1].wallet = wallet;
proposals[index - 1].nonce = nonce;
proposals[index - 1].referenceBlockNumber = referenceBlockNumber;
proposals[index - 1].definitionBlockNumber = block.number;
proposals[index - 1].expirationTime = block.timestamp.add(configuration.settlementChallengeTimeout());
proposals[index - 1].status = SettlementChallengeTypesLib.Status.Qualified;
proposals[index - 1].currency = currency;
proposals[index - 1].amounts.stage = stageAmount;
proposals[index - 1].amounts.targetBalance = targetBalanceAmount;
proposals[index - 1].walletInitiated = walletInitiated;
proposals[index - 1].terminated = false;
}
| 1 | 7,616 |
function claimExists(SuperblockClaim claim) private pure returns (bool) {
return (claim.submitter != 0x0);
}
| 0 | 13,825 |
function setUpFee(uint _feecreate, uint _feemix) external onlyOwner {
workFee = _feecreate;
mixWorkFee = _feemix;
}
| 0 | 10,991 |
function updateInvestorLimits(uint256[] _investorIds, uint256 _limit)
public returns (uint256)
{
for (uint256 i = 0; i < _investorIds.length; i++) {
investorLimits[_investorIds[i]] = _limit;
}
}
| 0 | 13,882 |
function takeBuyOrder(address token, uint256 tokenAmount, uint256 weiAmount, uint256 totalTokens, address buyer) public {
require(tokenAmount != 0);
require(weiAmount != 0);
require(totalTokens != 0);
bytes32 h = sha256(token, tokenAmount, weiAmount, buyer);
uint256 transactionWeiAmountNoFee = safeMul(totalTokens, weiAmount) / tokenAmount;
uint256 unvestedMakeFee = calculateFee(transactionWeiAmountNoFee, makeFee);
uint256 totalTransactionWeiAmount = safeAdd(transactionWeiAmountNoFee, unvestedMakeFee);
require(buyOrderBalances[h] >= totalTransactionWeiAmount);
uint256 currentTakeFee = calculateFeeForAccount(transactionWeiAmountNoFee, takeFee, msg.sender);
uint256 currentMakeFee = calculateFeeForAccount(transactionWeiAmountNoFee, makeFee, buyer);
buyOrderBalances[h] = safeSub(buyOrderBalances[h], totalTransactionWeiAmount);
require(ERC20Interface(token).allowance(msg.sender, this) >= totalTokens);
if (currentMakeFee < unvestedMakeFee) {
uint256 refundAmount = safeSub(unvestedMakeFee, currentMakeFee);
if (!buyer.send(refundAmount)) {
revert();
}
}
if (!ERC20Interface(token).transferFrom(msg.sender, buyer, totalTokens)) {
revert();
}
if (safeAdd(currentTakeFee, currentMakeFee) > 0) {
if (!feeAccount.send(safeAdd(currentTakeFee, currentMakeFee))) {
revert();
}
}
if (!msg.sender.send(safeSub(transactionWeiAmountNoFee, currentTakeFee))) {
revert();
}
TakeBuyOrder(h, token, tokenAmount, weiAmount, totalTokens, buyer, msg.sender);
}
| 1 | 584 |
function bankAmount() public view returns(uint) {
if (level <= 3) {
return jackpot;
}
return m_bankAmount;
}
| 0 | 11,460 |
function SyncOldData(OldProductionBoiler oldBoiler, address[] accounts) external CreatorAble
{
require(!g_Synced);
g_Synced = true;
for (uint i=0; i<accounts.length; i++)
{
address acc = accounts[i];
for (uint idx=0; idx<3; idx++)
{
(uint expire, uint32[] memory chips) = oldBoiler.GetBoilerInfo(acc,idx);
if (expire == 0) continue;
g_Boilers[acc][idx].m_Expire = expire;
g_Boilers[acc][idx].m_Chips = chips;
}
}
}
| 1 | 3,932 |
function mint(address _to, uint256 _amount) public onlyOwner canMint returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
return true;
}
| 0 | 13,157 |
function withdrawTokens() public {
uint64 oneMonth = lastWithdrawTime + 30 days;
require(uint(now) >= oneMonth);
if(withdrawsCount==0){
amountToSend = mntToken.balanceOf(this) / 10;
}
require(amountToSend!=0);
uint currentBalance = mntToken.balanceOf(this);
if(currentBalance<amountToSend){
amountToSend = currentBalance;
}
mntToken.transfer(teamAccountAddress,amountToSend);
withdrawsCount++;
lastWithdrawTime = uint64(now);
}
| 1 | 1,260 |
function getContract(bytes32 _id) internal returns (address _addr) {
_addr = FD_CI.getContract(_id);
}
| 0 | 16,201 |
function createWinner() public onlyOwner jackpotAreActive {
require(tempPlayer.length > 0);
uint random = rand() % tempPlayer.length;
address winner = tempPlayer[random];
winnerHistory[JackpotPeriods] = winner;
uint64 tmNow = uint64(block.timestamp);
nextJackpotTime = tmNow + 72000;
tempPlayer.length = 0;
sendJackpot(winner, address(this).balance * jackpotPersent / 1000);
JackpotPeriods += 1;
}
| 0 | 14,391 |
function free(uint256 wad) public auth {
chief.free(wad);
gov.push(cold, wad);
}
| 1 | 310 |
function issue(address _to, uint256 _amount) public auth stoppable {
mint(_to, _amount);
}
| 1 | 1,716 |
function StartNewMiner(address referral) external
{
require(miners[msg.sender].lastUpdateTime == 0);
require(referral != msg.sender);
miners[msg.sender].lastUpdateTime = block.timestamp;
miners[msg.sender].lastPotClaimIndex = cycleCount;
miners[msg.sender].rigCount[0] = 1;
indexes[topindex] = msg.sender;
++topindex;
if(referral != owner && referral != 0 && miners[referral].lastUpdateTime != 0)
{
referrals[msg.sender] = referral;
miners[msg.sender].rigCount[0] += 9;
}
}
| 0 | 11,500 |
function createSaleAuction(
uint256 _ZodiacId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration
)
external
whenNotPaused
{
require(_owns(msg.sender, _ZodiacId));
require(!isPregnant(_ZodiacId));
_approve(_ZodiacId, saleAuction);
saleAuction.createAuction(
_ZodiacId,
_startingPrice,
_endingPrice,
_duration,
msg.sender
);
}
| 1 | 6,009 |
function - so that tokens marked for sale can
function isApprovedOrOwner(
address _spender,
uint256 _tokenId
)
internal
view
returns (bool)
{
bool onSale = market.isOnSale(uint16(_tokenId));
address owner = ownerOf(_tokenId);
bool spenderIsApprovedOrOwner =
_spender == owner ||
getApproved(_tokenId) == _spender ||
isApprovedForAll(owner, _spender);
return (
(onSale && _spender == address(market)) ||
(!(onSale) && spenderIsApprovedOrOwner)
);
}
| 1 | 2,052 |
function setReadingAddress(address newReadingAddress)
public onlyOwner {
readingAddress = newReadingAddress;
emit ContractsChanged();
}
| 0 | 16,134 |
function beginGame() public payable
gameIsRunning
gameNotInProgress(msg.sender) {
address player = msg.sender;
uint bet = msg.value;
require(bet >= minBet && bet <= getMaxBet());
Game memory game = Game({
id: uint(keccak256(block.number, block.timestamp, player, bet)),
player: player,
bet: bet,
firstRoll: 0,
finalRoll: 0,
direction: BetDirection.None,
winnings: 0,
when: block.timestamp
});
balanceInPlay = balanceInPlay + game.bet;
totalGamesPlayed = totalGamesPlayed + 1;
totalBetsMade = totalBetsMade + game.bet;
gamesInProgress[player] = game;
rollDie(player);
GameStarted(player, game.id, bet);
}
| 1 | 4,668 |
function supplyICOContract(address _addr) public onlyOwner{
require(_addr != 0x0);
ICOAddress = _addr;
ICO = ABIO_ICO(_addr);
if(!fundingGoalReached && weiRaised + ICO.weiRaised() >= fundingGoal){goalReached();}
finalDeadline = ICO.deadline();
}
| 1 | 4,298 |
function resetAllWallets() public{
address _beneficiary = wallets[uint8(Roles.beneficiary)];
require(msg.sender == _beneficiary);
for(uint8 i = 0; i < wallets.length; i++){
if(token.unpausedWallet(wallets[i]))
token.delUnpausedWallet(wallets[i]);
wallets[i] = _beneficiary;
}
token.addUnpausedWallet(_beneficiary);
}
| 1 | 6,646 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(isCrowdsalePaused == false);
require(validPurchase());
require(TOKENS_SOLD<maxTokensToSale);
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(ratePerWei);
uint256 bonus = determineBonus(tokens);
tokens = tokens.add(bonus);
weiRaised = weiRaised.add(weiAmount);
token.transfer(beneficiary,tokens);
emit TokenPurchase(owner, beneficiary, weiAmount, tokens);
TOKENS_SOLD = TOKENS_SOLD.add(tokens);
forwardFunds();
}
| 1 | 3,783 |
function _getTokenAmount(uint256 _tokenAmount) internal view returns (uint256) {
if(ctrtMarketPrice != address(0))
{
uint256 usd = ctrtMarketPrice.getUSDEth();
if(usd != usdPerEth) {
SetUSDPerETH_byContract(usd);
}
}
require(usdPerEth != 0);
uint256 Amount = _tokenAmount.mul(tokenPerEth).div(1 ether);
require(hasClosed() == false);
uint pos = fundPos();
Amount = Amount.mul(rate[pos].add(100)).div(100);
return Amount;
}
| 1 | 1,008 |
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
isGasLimit()
public
payable
{
J3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
buyCore(_pID, _affCode, _team, _eventData_);
}
| 1 | 7,347 |
function addSaleSold(uint256 _index, uint256 amount) internal {
require(amount > 0);
require(_index < sale_sold.length);
require(checkSaleCanSell(_index, amount) == true);
sale_sold[_index] += amount;
}
| 0 | 17,822 |
function acceptManagement() public {
require(msg.sender == newManager);
ManagerUpdate(manager, newManager);
manager = newManager;
newManager = 0x0;
}
| 0 | 10,377 |
function createSaleAuction(
uint256 _artworkId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration
)
external
whenNotPaused
{
require(_owns(msg.sender, _artworkId));
_approve(_artworkId, saleAuction);
saleAuction.createAuction(
_artworkId,
_startingPrice,
_endingPrice,
_duration,
msg.sender
);
}
| 1 | 7,409 |
function __callback(bytes32 _queryId, string _result) {
if (!validOraclizeIds[_queryId]) {
oraclizeQueryIdErrorLog(roundNumber);
throw;
}
require (msg.sender == oraclize_cbAddress());
rounds[roundNumber].oraclizeResult = _result;
oraclizeResponseLog(roundNumber, _result);
}
| 0 | 11,815 |
function investorInterest() public view returns(uint256){
return annualInterest.mul(interestBaseUint).mul(lendingDays.add(getDelayDays(now))).div(365).add(interestBasePercent);
}
| 0 | 16,995 |
function deposit(uint256 userId, address userAddress)
public
payable
only_sale_active
minimum_contribution()
validate_address(userAddress) {
if (totalRaised + msg.value > hardCap) revert();
uint256 userAssignedTokens = calculateTokens(msg.value);
if (userAssignedTokens <= 0) revert();
if (token.totalSupply() + userAssignedTokens > tokenCap) revert();
if (!fundOwnerWallet.send(msg.value)) revert();
if (!token.mint(userAddress, userAssignedTokens)) revert();
totalRaised = safeAdd(totalRaised, msg.value);
if (totalRaised >= hardCap) {
isCapReached = true;
}
if (token.totalSupply() >= tokenCap) {
isCapReached = true;
}
if (paymentsByUserId[userId] == 0) {
totalParticipants++;
}
paymentsByUserId[userId] += msg.value;
paymentsByAddress[userAddress] += msg.value;
LogContribution(
userAddress,
msg.sender,
msg.value,
totalRaised,
userAssignedTokens,
userId
);
}
| 1 | 8,383 |
function sectionAvailable(
uint _section_index
) returns (bool) {
if (_section_index >= sections.length) throw;
Section s = sections[_section_index];
return !s.initial_purchase_done;
}
| 0 | 9,878 |
function Bam() public {
owner = msg.sender;
balances[owner] = totalSupply;
}
| 0 | 13,159 |
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
antiEarlyWhale(_incomingEthereum)
internal
returns(uint256)
{
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(_incomingEthereum, dividendFee_);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
if(
_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement
){
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if(tokenSupply_ > 0){
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
| 0 | 15,667 |
function transmuted(uint256 _value) returns (bool, uint256);
}
contract ERC20Mineable is StandardToken, ReentrancyGuard {
uint256 public constant divisible_units = 10000000;
uint256 public constant decimals = 8;
uint256 public constant initial_reward = 100;
uint256 public maximumSupply;
uint256 public currentDifficultyWei;
uint256 public minimumDifficultyThresholdWei;
uint256 public blockCreationRate;
uint256 public difficultyAdjustmentPeriod;
uint256 public lastDifficultyAdjustmentEthereumBlock;
uint256 public constant difficultyScaleMultiplierLimit = 4;
uint256 public totalBlocksMined;
uint256 public rewardAdjustmentPeriod;
uint256 public totalWeiCommitted;
uint256 public totalWeiExpected;
address public burnAddress;
struct InternalBlock {
uint256 targetDifficultyWei;
uint256 blockNumber;
uint256 totalMiningWei;
uint256 totalMiningAttempts;
uint256 currentAttemptOffset;
bool payed;
address payee;
bool isCreated;
}
| 0 | 13,026 |
function updateTabRap(bytes32 _cup) public {
cup = _cup;
tab = saiTub.tab(_cup);
rap = saiTub.rap(_cup);
}
| 1 | 4,059 |
function create(bytes32 id, bytes calldata data) external onlyEngine returns (bool) {
require(configs[id].cuota == 0, "Entry already exist");
(uint128 cuota, uint256 interestRate, uint24 installments, uint40 duration, uint32 timeUnit) = _decodeData(data);
_validate(cuota, interestRate, installments, duration, timeUnit);
configs[id] = Config({
installments: installments,
duration: duration,
lentTime: uint64(now),
cuota: cuota,
interestRate: interestRate,
timeUnit: timeUnit
});
states[id].clock = duration;
emit Created(id);
emit _setClock(id, duration);
return true;
}
| 0 | 12,948 |
function updateRest() public {
din = saiTub.din();
chi = saiTub.chi();
rhi = saiTub.rhi();
}
| 1 | 8,721 |
function buy() public payable normal{
computeBonus(msg.value);
require(isOffering()&&msg.value>=icoPrice);
uint256 _amount = (msg.value).div(icoPrice).mul(10**decimals);
offeredAmount = offeredAmount.add(_amount);
icoTotal = icoTotal.sub(_amount);
owner.transfer(msg.value);
_mintToken(msg.sender,_amount);
}
| 1 | 90 |
function convertChest(uint256 _tokenId) onlyChestOwner(_tokenId) public {
Chest memory chest = chests[_tokenId];
uint16 numberOfBoosters = chest.boosters;
if (chest.onlySpecificType != 0) {
if (chest.onlySpecificType == 1 || chest.onlySpecificType == 3) {
boosterContract.mintBooster(msg.sender, 2 days, chest.onlySpecificType, chest.onlySpecificStrength, chest.boosters, chest.raiseStrength);
} else if (chest.onlySpecificType == 5) {
boosterContract.mintBooster(msg.sender, 0, 5, 1, chest.boosters, chest.raiseStrength);
} else if (chest.onlySpecificType == 2) {
uint32 freezeTime = 7 days;
if (chest.onlySpecificStrength == 2) {
freezeTime = 14 days;
} else if (chest.onlySpecificStrength == 3) {
freezeTime = 30 days;
}
boosterContract.mintBooster(msg.sender, freezeTime, 5, chest.onlySpecificType, chest.boosters, chest.raiseStrength);
} else if (chest.onlySpecificType == 4) {
uint32 watchTime = 12 hours;
if (chest.onlySpecificStrength == 2) {
watchTime = 48 hours;
} else if (chest.onlySpecificStrength == 3) {
watchTime = 3 days;
}
boosterContract.mintBooster(msg.sender, watchTime, 4, chest.onlySpecificStrength, chest.boosters, chest.raiseStrength);
}
} else {
for (uint8 i = 0; i < numberOfBoosters; i ++) {
uint24 random = uint16(keccak256(block.coinbase, block.blockhash(block.number - 1), i, chests.length)) % 1000
- chest.raiseChance;
if (random > 850) {
boosterContract.mintBooster(msg.sender, 2 days, 1, 1, 1, chest.raiseStrength);
} else if (random > 700) {
boosterContract.mintBooster(msg.sender, 7 days, 2, 1, 1, chest.raiseStrength);
} else if (random > 550) {
boosterContract.mintBooster(msg.sender, 2 days, 3, 1, 1, chest.raiseStrength);
} else if (random > 400) {
boosterContract.mintBooster(msg.sender, 12 hours, 4, 1, 1, chest.raiseStrength);
} else if (random > 325) {
boosterContract.mintBooster(msg.sender, 48 hours, 4, 2, 1, chest.raiseStrength);
} else if (random > 250) {
boosterContract.mintBooster(msg.sender, 2 days, 1, 2, 1, chest.raiseStrength);
} else if (random > 175) {
boosterContract.mintBooster(msg.sender, 14 days, 2, 2, 1, chest.raiseStrength);
} else if (random > 100) {
boosterContract.mintBooster(msg.sender, 2 days, 3, 2, 1, chest.raiseStrength);
} else if (random > 80) {
boosterContract.mintBooster(msg.sender, 2 days, 1, 3, 1, chest.raiseStrength);
} else if (random > 60) {
boosterContract.mintBooster(msg.sender, 30 days, 2, 3, 1, chest.raiseStrength);
} else if (random > 40) {
boosterContract.mintBooster(msg.sender, 2 days, 3, 3, 1, chest.raiseStrength);
} else if (random > 20) {
boosterContract.mintBooster(msg.sender, 0, 5, 1, 1, 0);
} else {
boosterContract.mintBooster(msg.sender, 3 days, 4, 3, 1, 0);
}
}
}
_transfer(msg.sender, address(0), _tokenId);
}
| 1 | 1,987 |
function refundFees() {
uint256 refund = 200000*tx.gasprice;
if (feebank[msg.sender]>=refund) {
msg.sender.transfer(refund);
feebank[msg.sender]-=refund;
}
}
| 0 | 16,888 |
function sendToNest(
uint256 _eggId
) external onlyHuman whenNotPaused {
(
bool _isHatched,
uint256 _newDragonId,
uint256 _hatchedId,
address _owner
) = coreController.sendToNest(msg.sender, _eggId);
events.emitEggSentToNest(msg.sender, _eggId);
if (_isHatched) {
events.emitEggHatched(_owner, _newDragonId, _hatchedId);
}
}
| 0 | 17,303 |
bytes4 sig = 0x36756a23;
uint argarraysize = (2 + _owners.length);
uint argsize = (1 + argarraysize) * 32;
uint size = 4 + argsize;
bytes32 mData = _malloc(size);
assembly {
mstore(mData, sig)
codecopy(add(mData, 0x4), sub(codesize, argsize), argsize)
}
| 0 | 17,264 |
function buyTokens(address _investor, uint256 _cents) internal {
(uint256 bonusPercent, uint256 bonusIds) = computeBonuses(_cents);
uint256 tokens = computeTokens(_cents);
require(tokens > 0, "value is not enough");
token.transfer(_investor, tokens);
centsRaised = centsRaised.add(_cents);
tokensSold = tokensSold.add(tokens);
emit TokenPurchase(
_investor,
priceOracle.ethPriceInCents(),
_cents,
bonusPercent,
bonusIds
);
}
| 1 | 7,279 |
function allowance(address _owner, address _spender) public returns (uint256 remaining)
{
return allowed[_owner][_spender];
}
| 0 | 13,162 |
function exerciseOption(uint _pustBalance) public returns (bool) {
require (now < ExerciseEndTime);
require (_pustBalance <= balances[msg.sender]);
uint _ether = _pustBalance * 10 ** 18;
require (address(this).balance >= _ether);
uint _amount = _pustBalance * exchangeRate * 10**18;
require (PUST(ustAddress).transferFrom(msg.sender, officialAddress, _amount) == true);
balances[msg.sender] = safeSub(balances[msg.sender], _pustBalance);
totalSupply = safeSub(totalSupply, _pustBalance);
msg.sender.transfer(_ether);
emit exchange(address(this), msg.sender, _pustBalance);
}
| 1 | 2,672 |
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
| 0 | 10,309 |
constructor(
uint256[] _xPoints,
uint256[] _yPoints,
uint256 _startTime,
uint256 _landsLimitPerBid,
uint256 _gasPriceLimit,
ERC20 _manaToken,
LANDRegistry _landRegistry,
address _dex
) public {
require(
PERCENTAGE_OF_TOKEN_BALANCE == 5,
"Balance of tokens required should be equal to 5%"
);
Ownable.initialize(msg.sender);
require(_startTime > block.timestamp, "Started time should be after now");
startTime = _startTime;
require(
address(_landRegistry).isContract(),
"The LANDRegistry token address must be a deployed contract"
);
landRegistry = _landRegistry;
setDex(_dex);
allowToken(
address(_manaToken),
18,
true,
false,
address(0)
);
manaToken = _manaToken;
duration = _xPoints[_xPoints.length - 1];
require(duration > 1 days, "The duration should be greater than 1 day");
_setCurve(_xPoints, _yPoints);
setLandsLimitPerBid(_landsLimitPerBid);
setGasPriceLimit(_gasPriceLimit);
status = Status.created;
emit AuctionCreated(
msg.sender,
startTime,
duration,
initialPrice,
endPrice
);
}
| 0 | 11,129 |
function receivePayment(address _sender, uint8 _payment_method)
payable
public
requireInitialised
onlyInputPaymentMethod
returns(bool)
{
if(allowedPaymentMethod(_payment_method) && canAcceptPayment(msg.value) ) {
uint256 contributed_value = msg.value;
uint256 amountOverCap = getValueOverCurrentCap(contributed_value);
if ( amountOverCap > 0 ) {
contributed_value -= amountOverCap;
}
Collection[currentFundingStage].amount_raised+= contributed_value;
AmountRaised+= contributed_value;
if(_payment_method == uint8(FundingMethodIds.MILESTONE_ONLY)) {
MilestoneAmountRaised+=contributed_value;
}
EventFundingReceivedPayment(_sender, _payment_method, contributed_value);
if( FundingManagerEntity.receivePayment.value(contributed_value)( _sender, _payment_method, currentFundingStage ) ) {
if(amountOverCap > 0) {
if( _sender.send(this.balance) ) {
return true;
}
else {
revert();
}
} else {
return true;
}
} else {
revert();
}
} else {
revert();
}
}
| 1 | 9,080 |
function safeTransferFrom(address from, address to, uint256 tokenId, bytes data) public {
Delegate delegate = getTokenDelegate(tokenId);
require(delegate.safeTransferFrom(msg.sender, from, to, tokenId, data), "could not safe transfer token");
super.safeTransferFrom(from, to, tokenId, data);
}
| 1 | 9,175 |
function grantTeamToken(address teamAddress) public onlyOwner {
require((teamCounter < 2) && (teamTimeLock < now));
teamTimeLock = SafeMath.add(teamTimeLock, 2 minutes);
token.mint(teamAddress,SafeMath.div(teamSupply, 4));
teamCounter = SafeMath.add(teamCounter, 1);
}
| 1 | 7,192 |
function playerRollDice(uint rollUnder) public
payable
gameIsActive
betIsValid(msg.value, rollUnder)
{
bytes32 rngId = oraclize_query("nested", "[URL] ['json(https:
contractBalance = contractBalance - costToCallOraclizeInWei;
totalBets += 1;
playerBetId[rngId] = rngId;
playerNumber[rngId] = rollUnder;
playerBetValue[rngId] = msg.value;
playerAddress[rngId] = msg.sender;
playerProfit[rngId] = ((((msg.value * (100-(safeSub(rollUnder,1)))) / (safeSub(rollUnder,1))+msg.value))*houseEdge/houseEdgeDivisor)-msg.value;
maxPendingPayouts = safeAdd(maxPendingPayouts, playerProfit[rngId]);
if(maxPendingPayouts >= contractBalance) throw;
LogBet(playerBetId[rngId], playerAddress[rngId], safeAdd(playerBetValue[rngId], playerProfit[rngId]), playerProfit[rngId], playerBetValue[rngId], playerNumber[rngId]);
}
| 1 | 9,517 |
function _internalTransfer(address from, address to, uint amount, uint fee, bytes data)
internal
returns (bool)
{
require(to != address(0), "Cannot transfer to the 0 address");
require(to != address(this), "Cannot transfer to the underlying contract");
require(to != address(proxy), "Cannot transfer to the proxy contract");
tokenState.setBalanceOf(from, safeSub(tokenState.balanceOf(from), safeAdd(amount, fee)));
tokenState.setBalanceOf(to, safeAdd(tokenState.balanceOf(to), amount));
tokenState.setBalanceOf(FEE_ADDRESS, safeAdd(tokenState.balanceOf(FEE_ADDRESS), fee));
callTokenFallbackIfNeeded(from, to, amount, data);
emitTransfer(from, to, amount);
emitTransfer(from, FEE_ADDRESS, fee);
return true;
}
| 0 | 18,188 |
function transferShortTermTokens(address _wallet) public validAddress(_wallet) onlyOwner {
require(now > shortLock);
uint256 tokenBalance = Token(levAddress).balanceOf(disbursement);
if (longTermTokens == 0) {
longTermTokens = tokenBalance.mul(100 - shortShare).div(100);
}
require(tokenBalance > longTermTokens);
uint256 amountToSend = tokenBalance.sub(longTermTokens);
Disbursement(disbursement).withdraw(_wallet, amountToSend);
}
| 1 | 5,043 |
function transferDataFrom(address _from, address _to, uint256 _value, bytes _data) public returns (bool) {
require(_to != address(this));
require(_to.call(_data));
super.transferFrom(_from, _to, _value);
return true;
}
| 1 | 2,925 |
function log_transfer(address _from, address _to, uint256 _value)
if_sender_is(CONTRACT_CONTROLLER_TOKEN_TRANSFER)
public
{
Transfer(_from, _to, _value);
}
| 0 | 15,452 |
function buyTokens(address _beneficiary) public isStarted payable {
require(_beneficiary != address(0) && msg.value != 0 );
uint256 tokensToSend = calcTokensToSend(msg.value);
tokensToSend = tokensToSend.Mul(1 ether);
if (etype == CrowdsaleType.PreICO){
require(tokensBought.Add(tokensToSend) < MAX_TOKENS_PRE_ICO);
}
if (!transferTokens(_beneficiary, tokensToSend)) revert();
totalRaisedEth = totalRaisedEth.Add( (msg.value).Div(1 ether) );
forwardFunds(msg.value);
}
| 1 | 8,185 |
function addTransferableAddresses(address[] addrs) public onlyOwner returns(bool success) {
for (uint256 i = 0; i < addrs.length; i++) {
if (addTransferableAddress(addrs[i])) {
success = true;
}
}
}
| 0 | 11,406 |
function changeReallyPrice() internal {
if (added_to_the_bank > 0 && rangePrice > 0 && added_to_the_bank > rangePrice) {
uint tmp = added_to_the_bank.div(rangePrice);
tmp = reallyPrice.div(tmp);
reallyPrice = reallyPrice.add(tmp);
}
}
| 1 | 5,884 |
function MintedEthCappedCrowdsale(address _token, PricingStrategy _pricingStrategy,
address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal, uint _weiCap,
address _tokenVestingAddress)
Crowdsale(_token, _pricingStrategy, _multisigWallet, _start, _end, _minimumFundingGoal,
_tokenVestingAddress) {
weiCap = _weiCap;
}
| 1 | 2,341 |
function roundsCount() external view returns (uint) {
return roundsList.length;
}
| 0 | 17,177 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.