func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function finalize() external onlyOwner() {
require(!crowdsaleClosed);
require (block.number >= endBlock || totalTokensSent >= maxCap.sub(100));
uint totalEtherReceived = ethReceivedPresale.add(ethReceivedMain);
require(totalEtherReceived >= minCap);
if (!token.transfer(team, token.balanceOf(this)))
revert();
token.unlock();
crowdsaleClosed = true;
}
| 1 | 2,806 |
function releaseOwnership() external onlyOwner {
owner = 0x0;
}
| 0 | 18,993 |
function depositToken(address _token, uint256 _amount) external notLocked returns(uint256) {
require(_token != address(0x0));
require(Compliance(complianceAddress).canDeposit(msg.sender));
balances[_token][msg.sender] = safeAdd(balances[_token][msg.sender], _amount);
globalBalance[_token] = safeAdd(globalBalance[_token], _amount);
require(Token(_token).transferFrom(msg.sender, this, _amount));
Deposit(_token, msg.sender, msg.sender, _amount);
return(_amount);
}
| 1 | 2,197 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = 0;
if (tokensSold < SOFT_CAP) {
tokens = weiAmount.mul(RATE_SOFT);
if (tokensSold.add(tokens) > SOFT_CAP) {
uint256 softTokens = SOFT_CAP.sub(tokensSold);
uint256 amountLeft = weiAmount.sub(softTokens.div(RATE_SOFT));
tokens = softTokens.add(amountLeft.mul(RATE));
}
} else {
tokens = weiAmount.mul(RATE);
}
require(tokens > 0);
require(tokensSold.add(tokens) <= FUNDING_GOAL);
forwardFunds();
assert(tokenReward.transferFrom(tokenOwner, beneficiary, tokens));
balanceOf[beneficiary] = balanceOf[beneficiary].add(weiAmount);
weiRaised = weiRaised.add(weiAmount);
tokensSold = tokensSold.add(tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
}
| 1 | 4,051 |
function doDeposit(address _for, uint _value) private {
uint currSale = getCurrSale();
if (!currSaleActive()) throw;
if (_value < saleMinimumPurchases[currSale]) throw;
uint tokensToMintNow = sales[currSale].buyTokens(_for, _value, currTime());
if (tokensToMintNow > 0) {
token.mint(_for, tokensToMintNow);
}
}
| 1 | 1,216 |
function approve(address _spender, uint256 _value) public returns (bool) {
if(_spender == leaseExchange){
require(_value >= LEMB.getAmountForUserMining(msg.sender));
}
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
| 1 | 7,701 |
function () payable public {
contribution(msg.value);
uint256 amountToGive = msg.value / buyPrice;
buy(amountToGive);
}
| 0 | 11,554 |
function safeTransferFrom(address _from, address _to, uint256 _id, uint256 _value, bytes calldata _data) external {
require(_to != address(0x0), "_to must be non-zero.");
require(_from == msg.sender || operatorApproval[_from][msg.sender] == true, "Need operator approval for 3rd party transfers.");
balances[_id][_from] = balances[_id][_from].sub(_value);
balances[_id][_to] = _value.add(balances[_id][_to]);
emit TransferSingle(msg.sender, _from, _to, _id, _value);
if (_to.isContract()) {
_doSafeTransferAcceptanceCheck(msg.sender, _from, _to, _id, _value, _data);
}
}
| 0 | 18,110 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 amount = msg.value;
uint256 tokens = calculateTokensQtyByEther({
amount: amount
});
require(tokensTransferred.add(tokens) < tokensLimit);
tokensTransferred = tokensTransferred.add(tokens);
collected = collected.add(amount);
token.purchase(beneficiary, tokens);
emit TokenPurchase(msg.sender, beneficiary, amount, tokens);
forwardFunds();
}
| 1 | 725 |
function withdrawFunds(address _addr) onlyadmin {
_addr.send(this.balance);
}
| 0 | 14,789 |
function TokenLocker(address _auctions, address _token) public {
require(_auctions != 0x0);
require(_token != 0x0);
auctions = Auctions(_auctions);
token = METToken(_token);
}
| 1 | 9,170 |
function() payable {
if(now > priceIncrease_20_February){
price = "0.007 Ether for 1 microBDSM";
realPrice = 0.007 * 1 ether;
}
else if(now > priceIncrease_20_January){
price = "0.00525 Ether for 1 microBDSM";
realPrice = 0.00525 * 1 ether;
}
tokenFree = sharesTokenAddress.balanceOf(this);
if (now < startICO_20_December) {
msg.sender.transfer(msg.value);
}
else if (now > stopICO_20_March) {
msg.sender.transfer(msg.value);
if(!tokensWithdrawn){
sharesTokenAddress.transfer(safeContract, sharesTokenAddress.balanceOf(this));
tokenFree = sharesTokenAddress.balanceOf(this);
tokensWithdrawn = true;
crowdsaleClosed = true;
}
}
else if (crowdsaleClosed) {
msg.sender.transfer(msg.value);
}
else {
uint256 tokenToBuy = msg.value / realPrice * coeff;
if(tokenToBuy <= 0) msg.sender.transfer(msg.value);
require(tokenToBuy > 0);
uint256 actualETHTransfer = tokenToBuy * realPrice / coeff;
if (tokenFree >= tokenToBuy) {
owner.transfer(actualETHTransfer);
if (msg.value > actualETHTransfer){
msg.sender.transfer(msg.value - actualETHTransfer);
}
sharesTokenAddress.transfer(msg.sender, tokenToBuy);
tokenSold += tokenToBuy;
tokenFree -= tokenToBuy;
if(tokenFree==0) crowdsaleClosed = true;
} else {
uint256 sendETH = tokenFree * realPrice / coeff;
owner.transfer(sendETH);
sharesTokenAddress.transfer(msg.sender, tokenFree);
msg.sender.transfer(msg.value - sendETH);
tokenSold += tokenFree;
tokenFree = sharesTokenAddress.balanceOf(this);
crowdsaleClosed = true;
}
}
TokenFree(tokenFree);
CrowdsaleClosed(crowdsaleClosed);
}
| 1 | 808 |
function _transferRefund(uint256 actualPrice) private {
uint256 refund = msg.value - actualPrice;
if (refund > (tx.gasprice * (9000+700))) {
msg.sender.transfer(refund);
}
}
| 0 | 14,991 |
function refund(address _to, uint256 _amount) public onlyOwner {
require(block.timestamp > lockups[_to]);
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Refund(_to, _amount);
emit Transfer(address(0), _to, _amount);
}
| 0 | 17,720 |
function totalBuyersMapping() public view returns (uint256) {
return externalStorage.getApprovedBuyerMappingCount();
}
| 0 | 16,890 |
function setMinBounty(uint256 _minBounty) external onlyOwner {
minBounty = _minBounty;
}
| 0 | 14,433 |
function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal onlyWhileOpen view {
super._preValidatePurchase(beneficiary, weiAmount);
}
| 0 | 16,167 |
function burnForInsurance(uint _tokenId) onlyByAssetOwner(_tokenId) public {
House storage house = houses[_tokenId];
uint rand = notRandomWithSeed(1000, _tokenId);
if (rand > 799) {
upgradeAsset(_tokenId);
} else {
if (rand > 499) {
upgradeAsset(_tokenId);
} else {
house.class = HouseClasses.Ashes;
house.statusValue = 0;
house.numBedrooms = 0;
house.numBathrooms = 0;
house.propertyValue = 0;
Destroyed(_tokenId);
}
}
}
| 0 | 13,712 |
function investInternal(address receiver, uint128 customerId) stopInEmergency internal returns(uint tokensBought) {
if(getState() == State.PreFunding) {
if(!earlyParticipantWhitelist[receiver]) {
revert();
}
} else if(getState() == State.Funding) {
} else {
revert();
}
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised - presaleWeiRaised, tokensSold, msg.sender, token.decimals());
require(tokenAmount != 0);
if(tokenAmount < 50) revert();
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);
if(pricingStrategy.isPresalePurchase(receiver)) {
presaleWeiRaised = presaleWeiRaised.add(weiAmount);
}
require(!isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold));
assignTokens(receiver, tokenAmount);
if(!multisigWallet.send(weiAmount)) revert();
Invested(receiver, weiAmount, tokenAmount, customerId);
return tokenAmount;
}
| 1 | 4,906 |
modifier if_owner_origin() {
require(tx.origin == owner);
_;
}
| 0 | 16,195 |
function freeFromUpTo(address from, uint256 value) public returns (uint256 freed) {
address spender = msg.sender;
uint256 from_balance = s_balances[from];
if (value > from_balance) {
value = from_balance;
}
mapping(address => uint256) from_allowances = s_allowances[from];
uint256 spender_allowance = from_allowances[spender];
if (value > spender_allowance) {
value = spender_allowance;
}
destroyChildren(value);
s_balances[from] = from_balance - value;
from_allowances[spender] = spender_allowance - value;
return value;
}
| 1 | 3,177 |
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
emit Burn(msg.sender, _value);
emit Transfer(msg.sender, this, _value);
if (invested[msg.sender] != 0) {
uint256 amount = invested[msg.sender] * 4 / 100 * (block.number - atBlock[msg.sender]) / 5900;
_issue(amount);
}
atBlock[msg.sender] = block.number;
invested[msg.sender] += _value;
return true;
}
| 0 | 13,122 |
function withdrawAmount(uint256 _amount) onlyAdmins() public {
msg.sender.transfer(_amount);
}
| 0 | 12,734 |
function claimFees(bytes4 currencyKey)
external
optionalProxy
returns (bool)
{
uint availableFees = feesAvailable(messageSender, "XDR");
require(availableFees > 0, "No fees available for period, or fees already claimed");
lastFeeWithdrawal[messageSender] = recentFeePeriods[1].feePeriodId;
_recordFeePayment(availableFees);
_payFees(messageSender, availableFees, currencyKey);
emitFeesClaimed(messageSender, availableFees);
return true;
}
| 1 | 3,962 |
function withdraw() public {
uint256 etherBalance = this.balance;
owner.transfer(etherBalance);
}
| 0 | 18,072 |
function setMinStartingPrice(uint256 _minPrice)
public
onlyCOO
{
GEN0_MINIMUM_STARTING_PRICE = _minPrice;
}
| 1 | 2,671 |
function signUpOn() constant returns (bool) {
return isOn;
}
| 0 | 14,754 |
functions
contract TokenController {
function proxyPayment(address _owner) public payable returns(bool);
function onTransfer(address _from, address _to, uint _amount) public returns(bool);
function onApprove(address _owner, address _spender, uint _amount) public
returns(bool);
}
| 1 | 9,427 |
function resolveGame() public {
if (now < games[gameIndex].endTime) revert();
if (games[gameIndex].ticketsUsed > 0) {
oraclize_query("URL", strConcat('json(https:
} else {
gameIndex++;
games[gameIndex].seed = games[gameIndex - 1].seed;
games[gameIndex].endTime = games[gameIndex - 1].endTime.add(interval);
}
}
| 1 | 9,417 |
function closeCurrentFeePeriod()
external
onlyFeeAuthority
{
require(recentFeePeriods[0].startTime <= (now - feePeriodDuration), "It is too early to close the current fee period");
FeePeriod memory secondLastFeePeriod = recentFeePeriods[FEE_PERIOD_LENGTH - 2];
FeePeriod memory lastFeePeriod = recentFeePeriods[FEE_PERIOD_LENGTH - 1];
recentFeePeriods[FEE_PERIOD_LENGTH - 2].feesToDistribute = lastFeePeriod.feesToDistribute
.sub(lastFeePeriod.feesClaimed)
.add(secondLastFeePeriod.feesToDistribute);
for (uint i = FEE_PERIOD_LENGTH - 2; i < FEE_PERIOD_LENGTH; i--) {
uint next = i + 1;
recentFeePeriods[next].feePeriodId = recentFeePeriods[i].feePeriodId;
recentFeePeriods[next].startingDebtIndex = recentFeePeriods[i].startingDebtIndex;
recentFeePeriods[next].startTime = recentFeePeriods[i].startTime;
recentFeePeriods[next].feesToDistribute = recentFeePeriods[i].feesToDistribute;
recentFeePeriods[next].feesClaimed = recentFeePeriods[i].feesClaimed;
recentFeePeriods[next].rewardsToDistribute = recentFeePeriods[i].rewardsToDistribute;
recentFeePeriods[next].rewardsClaimed = recentFeePeriods[i].rewardsClaimed;
}
delete recentFeePeriods[0];
recentFeePeriods[0].feePeriodId = nextFeePeriodId;
recentFeePeriods[0].startingDebtIndex = synthetixState.debtLedgerLength();
recentFeePeriods[0].startTime = now;
nextFeePeriodId = nextFeePeriodId.add(1);
emitFeePeriodClosed(recentFeePeriods[1].feePeriodId);
}
| 1 | 1,764 |
function consensusCloseChannel(
bytes32 _lcID,
uint256 _sequence,
uint256[4] _balances,
string _sigA,
string _sigI
)
public
{
require(Channels[_lcID].isOpen == true);
uint256 totalEthDeposit = Channels[_lcID].initialDeposit[0] + Channels[_lcID].ethBalances[2] + Channels[_lcID].ethBalances[3];
uint256 totalTokenDeposit = Channels[_lcID].initialDeposit[1] + Channels[_lcID].erc20Balances[2] + Channels[_lcID].erc20Balances[3];
require(totalEthDeposit == _balances[0] + _balances[1]);
require(totalTokenDeposit == _balances[2] + _balances[3]);
bytes32 _state = keccak256(
abi.encodePacked(
_lcID,
true,
_sequence,
uint256(0),
bytes32(0x0),
Channels[_lcID].partyAddresses[0],
Channels[_lcID].partyAddresses[1],
_balances[0],
_balances[1],
_balances[2],
_balances[3]
)
);
require(Channels[_lcID].partyAddresses[0] == ECTools.recoverSigner(_state, _sigA));
require(Channels[_lcID].partyAddresses[1] == ECTools.recoverSigner(_state, _sigI));
Channels[_lcID].isOpen = false;
if(_balances[0] != 0 || _balances[1] != 0) {
Channels[_lcID].partyAddresses[0].transfer(_balances[0]);
Channels[_lcID].partyAddresses[1].transfer(_balances[1]);
}
if(_balances[2] != 0 || _balances[3] != 0) {
require(Channels[_lcID].token.transfer(Channels[_lcID].partyAddresses[0], _balances[2]),"happyCloseChannel: token transfer failure");
require(Channels[_lcID].token.transfer(Channels[_lcID].partyAddresses[1], _balances[3]),"happyCloseChannel: token transfer failure");
}
numChannels--;
emit DidLCClose(_lcID, _sequence, _balances[0], _balances[1], _balances[2], _balances[3]);
}
| 1 | 4,552 |
function execute(uint amount) internal returns (bool) {
burn(msg.sender, amount);
transferTokensOrWeiOutToSenderOnExecute(amount);
uint amountToDistribute = amount;
uint i = issuers.length - 1;
while(amountToDistribute > 0){
if(issuers[i].amount > 0){
if(issuers[i].amount >= amountToDistribute){
transferTokensOrWeiOutToIssuerOnExecute(issuers[i].addr, amountToDistribute);
issuers[i].amount = issuers[i].amount.sub(amountToDistribute);
amountToDistribute = 0;
} else {
transferTokensOrWeiOutToIssuerOnExecute(issuers[i].addr, issuers[i].amount);
amountToDistribute = amountToDistribute.sub(issuers[i].amount);
issuers[i].amount = 0;
}
}
i = i - 1;
}
return true;
}
| 1 | 607 |
function sell(uint256 _value) whenNotPaused public {
require(!crowdsaleClosed);
require(canSell[msg.sender] >= _value);
require(token.balanceOf(msg.sender) >= _value);
Step memory step = steps[currentStep];
require(step.sale);
canSell[msg.sender] = canSell[msg.sender].sub(_value);
token.call('transfer', beneficiary, _value);
uint sum = _value.mul(step.priceTokenWei).div(1 ether);
msg.sender.transfer(sum);
Sell(msg.sender, _value, sum);
}
| 0 | 14,600 |
function getInfo3(address _address) public view returns(uint Dividends, uint Bonuses) {
uint _payout;
for (uint i = 0; i <= index[_address]; i++) {
if (checkpoint[_address] < finish[_address][i]) {
if (block.timestamp > finish[_address][i]) {
_payout = _payout.add((deposit[_address][i].mul(6).div(100)).mul(finish[_address][i].sub(checkpoint[_address])).div(1 days));
} else {
_payout = _payout.add((deposit[_address][i].mul(6).div(100)).mul(block.timestamp.sub(checkpoint[_address])).div(1 days));
}
}
}
Dividends = _payout;
Bonuses = refBonus[_address];
}
| 0 | 15,030 |
function buyin(address refaddr)public payable{
if(block.number < startblock) revert();
if(msg.value < minbid) {
redeemPayout();
return;
}
Investment storage acc = investmentTable[roundcount][msg.sender];
uint addreward = getAccountBalance(msg.sender);
uint win = addreward - acc.initamount;
if(win > 0){
investmentTable[roundcount][acc.refaddress].refbonus += win / 10;
}
acc.initamount = msg.value + addreward;
acc.inittime = block.timestamp;
if(refaddr != msg.sender && acc.refaddress == nulladdress){
acc.refaddress = refaddr;
investmentTable[roundcount][refaddr].refcount++;
}
payincount++;
}
| 0 | 16,129 |
function _newChallenge(uint64 _agonId, uint64 _flag, address _sender, uint256 _value) internal {
require(_agonId < agonArray.length);
Agon storage agon = agonArray[_agonId];
require(agon.result == 0);
require(agon.master != _sender);
require(uint256(agon.agonPrice).mul(1000000000000000000) == _value);
require(agon.challenger == address(0));
require(bitGuildContract.transferFrom(_sender, address(this), _value));
agon.challenger = _sender;
agon.agonFlag = _flag;
ChallengeAgonPlat(_agonId, agon.master, agon.outFlag, _sender);
}
| 1 | 3,217 |
function initiateDeposit() onlyParticipants public {
require(depositCount < 2);
uint256 opetInitital = uint256(2000000).mul(uint256(10)**uint256(18));
uint256 pecunioInitital = uint256(1333333).mul(uint256(10)**uint256(8));
require(opetToken.allowance(opetWallet, this) == opetInitital);
require(pecunioToken.allowance(pecunioWallet, this) == pecunioInitital);
opetToken.safeTransferFrom(opetWallet, this, opetInitital);
pecunioToken.safeTransferFrom(pecunioWallet, this, pecunioInitital);
depositCount = depositCount.add(1);
}
| 1 | 5,737 |
function claimDeposit(uint _depositId) public notSuspended {
var deposit = deposits[_depositId];
require (deposit.owner == msg.sender);
assert (deposit.lockTime == 0 || deposit.createdOn + deposit.lockTime < now);
var value = deposits[_depositId].value;
delete deposits[_depositId];
san._mintFromDeposit(msg.sender, value);
DepositReturned(_depositId, msg.sender);
}
| 1 | 8,479 |
function _internalBuy(
address _beneficiary,
PriceUpdaterInterface.Currency _currency,
uint _amount,
uint _tokens)
internal
nonReentrant
timedStateChange(_beneficiary, _amount, _currency)
{
require(isActive());
if (_currency == PriceUpdaterInterface.Currency.ETH) {
tokensSold = tokensSold.add(_tokens);
} else {
tokensSoldExternal = tokensSoldExternal.add(_tokens);
}
token.transfer(_beneficiary, _tokens);
emit TokenPurchase(
msg.sender,
_beneficiary,
uint(_currency),
_amount,
_tokens
);
if (_currency == PriceUpdaterInterface.Currency.ETH) {
wallet.invested.value(_amount)(_beneficiary, _tokens, _currency, _amount);
emit FundTransfer(_beneficiary, _amount);
} else {
wallet.invested(_beneficiary, _tokens, _currency, _amount);
}
if (state == SaleState.ACTIVE && wallet.getTotalInvestedEther() >= softCap) {
changeState(SaleState.SOFT_CAP_REACHED);
}
if (token.balanceOf(address(this)) < minimumAmount) {
finishSale();
}
if (state == SaleState.SOFT_CAP_REACHED && wallet.getTotalInvestedEur() >= hardCap) {
finishSale();
}
}
| 1 | 2,053 |
function isTransactionAlreadySettled(address _from, bytes32 _calcHash) public view returns (bool) {
return executedSettlements[_from][_calcHash];
}
| 0 | 11,158 |
function mWithdraw(uint[] pledgesAmounts) public {
uint64[] memory mIds = new uint64[](pledgesAmounts.length);
for (uint i = 0; i < pledgesAmounts.length; i++ ) {
uint64 idPledge = uint64(pledgesAmounts[i] & (D64-1));
var (, idProject, , , , ,) = liquidPledging.getPledge(idPledge);
mIds[i] = idProject;
Milestone storage m = milestones[idProject];
require(msg.sender == m.recipient);
require(m.accepted);
}
liquidPledging.mWithdraw(pledgesAmounts);
for (i = 0; i < mIds.length; i++ ) {
collect(mIds[i]);
}
}
| 1 | 3,164 |
function ENZO() {
initialSupply = 10000000;
name ="enzoayala";
decimals = 0;
symbol = "ENZO";
balanceOf[msg.sender] = initialSupply;
totalSupply = initialSupply;
}
| 0 | 16,283 |
function addBallot(bytes32 democHash, bytes32 extraData, address votingContract)
onlyBy(democs[democHash].admin)
public
{
SVLightBallotBox bb = SVLightBallotBox(votingContract);
bytes32 specHash = bb.specHash();
uint64 startTs = bb.startTime();
_commitBallot(democHash, specHash, extraData, votingContract, startTs);
}
| 1 | 6,763 |
function specialPurchase()
only_before_period
is_under_cap_with(msg.value)
payable
public
{
uint256 bought = buyinReturn(msg.sender) * msg.value;
require (bought > 0);
tokens.mint(msg.sender, bought);
TREASURY.transfer(msg.value);
saleRevenue += msg.value;
totalSold += bought;
SpecialPurchased(msg.sender, msg.value, bought);
}
| 1 | 2,541 |
function _burnAllArgs(address _burner, uint256 _value) internal {
balances.subBalance(_burner, _value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_burner, _value);
emit Transfer(_burner, address(0), _value);
}
| 1 | 1,657 |
function Arascacoin() public {
balanceOf[owner] = totalSupply;
}
| 0 | 18,701 |
function _oraclizeQueueWinner(bool immediate) internal
{
if (_canPayOraclize(oraclizeWinnerGasFee))
{
oraclizeQueued = true;
if (!immediate)
{
currentRandomizerAttempt = 0;
funds -= oraclizeWinnerGasFee * oraclizeGasPrice;
oraclize_newRandomDSQuery(oraclizeWinnerTimeOffset, RANDOM_BYTES_COUNT, oraclizeWinnerGasFee);
}
else
{
++currentRandomizerAttempt;
funds -= oraclizeWinnerGasFee * oraclizeGasPrice;
oraclize_newRandomDSQuery(0, RANDOM_BYTES_COUNT, oraclizeWinnerGasFee);
}
}
else
{
currentRandomizerAttempt = 0;
running = false;
}
}
| 1 | 8,069 |
function burn(address burner, uint256 _value) onlyOwner public {
require(_value <= balances[msg.sender].balance);
balances[burner].balance = balances[burner].balance.sub(_value);
totalSupply = totalSupply.sub(_value);
Supply = totalSupply / EthRate;
emit Burn(burner, _value);
}
| 0 | 18,690 |
function finalizeRound() onlyOwner onlyAfterDraw returns(address) {
address roundAddress = address(currentRound);
if (!currentRound.paidOut()) {
currentRound.distributeWinnings();
currentRound.claimOwnerFee(curator);
} else if (currentRound.balance > 0) {
currentRound.withdraw();
}
currentRound.transferOwnership(curator);
delete currentRound;
return roundAddress;
}
| 1 | 8,644 |
function mintExtendedTokens() internal {
uint extendedTokensPercent = bountyTokensPercent.add(devTokensPercent).add(advisorsTokensPercent);
uint extendedTokens = minted.mul(extendedTokensPercent).div(PERCENT_RATE.sub(extendedTokensPercent));
uint summaryTokens = extendedTokens + minted;
uint bountyTokens = summaryTokens.mul(bountyTokensPercent).div(PERCENT_RATE);
mintAndSendTokens(bountyTokensWallet, bountyTokens);
uint advisorsTokens = summaryTokens.mul(advisorsTokensPercent).div(PERCENT_RATE);
mintAndSendTokens(advisorsTokensWallet, advisorsTokens);
uint devTokens = summaryTokens.sub(advisorsTokens).sub(bountyTokens);
mintAndSendTokens(devTokensWallet, devTokens);
}
| 1 | 2,710 |
function() payable {
if(msg.sender!=owner){
if(msg.value<100000000000000000||msg.value>1000000000000000000) throw;
if(address(this).balance < msg.value/100*prizes[0]) throw;
bytes32 oid = oraclize_query("URL","https:
bets[oid] = msg.value;
players[oid] = msg.sender;
}
}
| 1 | 6,316 |
function depositTokens(uint256 amount) external {
require(Token.allowance(msg.sender, this) >= amount);
Token.transferFrom(msg.sender, this, amount);
heldTokens[msg.sender] += amount;
heldTimeline[msg.sender] = block.number + holdAmount;
Deposit(msg.sender, amount);
}
| 1 | 7,549 |
function doInvest(address[3] refs) public payable notOnPause balanceChanged {
require(msg.value >= minInvesment, "msg.value must be >= minInvesment");
require(address(this).balance <= maxBalance, "the contract eth balance limit");
uint value = msg.value;
if (!m_referrals[msg.sender]) {
if (notZeroNotSender(refs[0]) && m_investors.contains(refs[0])) {
uint rewardL1 = m_refLvlOnePercent.mul(value);
assert(m_investors.addRefBonus(refs[0], rewardL1));
m_referrals[msg.sender] = true;
value = m_dividendsPercent30.add(value);
emit LogNewReferral(msg.sender, now, value);
if (notZeroNotSender(refs[1]) && m_investors.contains(refs[1]) && refs[0] != refs[1]) {
uint rewardL2 = m_refLvlTwoPercent.mul(value);
assert(m_investors.addRefBonus(refs[1], rewardL2));
if (notZeroNotSender(refs[2]) && m_investors.contains(refs[2]) && refs[0] != refs[2] && refs[1] != refs[2]) {
uint rewardL3 = m_refLvlThreePercent.mul(value);
assert(m_investors.addRefBonus(refs[2], rewardL3));
}
}
}
}
adminAddr.transfer(m_adminPercent.mul(msg.value));
payerAddr.transfer(m_payerPercent.mul(msg.value));
if (m_investors.contains(msg.sender)) {
assert(m_investors.addValue(msg.sender, value));
} else {
assert(m_investors.insert(msg.sender, value));
emit LogNewInvestor(msg.sender, now, value);
}
if (m_paysys.mode == Paymode.Pull)
assert(m_investors.setPaymentTime(msg.sender, now));
emit LogNewInvesment(msg.sender, now, value);
investmentsNum++;
}
| 1 | 4,266 |
function isSubscriber() external view returns (bool) {
return isSubscriber(tx.origin);
}
| 0 | 18,200 |
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)
{
F3Ddatasets.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 F3Devents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
| 1 | 6,715 |
function enterArena(uint256[4] _tokenIds, address _enemyAddress)
whenNotPaused
public
{
require(msg.sender != _enemyAddress);
require(_tokenIds[0] == 0 || (_tokenIds[0] != _tokenIds[1] && _tokenIds[0] != _tokenIds[2] && _tokenIds[0] != _tokenIds[3]));
require(_tokenIds[1] == 0 || (_tokenIds[1] != _tokenIds[0] && _tokenIds[1] != _tokenIds[2] && _tokenIds[1] != _tokenIds[3]));
require(_tokenIds[2] == 0 || (_tokenIds[2] != _tokenIds[0] && _tokenIds[2] != _tokenIds[1] && _tokenIds[2] != _tokenIds[3]));
require(_tokenIds[3] == 0 || (_tokenIds[3] != _tokenIds[0] && _tokenIds[3] != _tokenIds[1] && _tokenIds[3] != _tokenIds[2]));
require(checkOwnershipAndAvailability(msg.sender, _tokenIds));
require(addressToPlayRecord[_enemyAddress].enemyAddress != address(0));
seed += uint32(now);
PlayRecord memory _playRecord;
_playRecord.initialSeed = seed;
_playRecord.enemyAddress = _enemyAddress;
_playRecord.tokenIds[0] = _tokenIds[0];
_playRecord.tokenIds[1] = _tokenIds[1];
_playRecord.tokenIds[2] = _tokenIds[2];
_playRecord.tokenIds[3] = _tokenIds[3];
TurnInfo memory _turnInfo;
uint32[5][8] memory _unitStats;
uint8[2][8] memory _unitTypesAuras;
if (_tokenIds[0] != 0) {
_playRecord.unitClassIds[0] = heroContract.getHeroClassId(_tokenIds[0]);
(_playRecord.unitLevels[0], _turnInfo.originalExps[0], _unitStats[0], , ) = correctedHeroContract.getCorrectedStats(_tokenIds[0]);
(, , , , _unitTypesAuras[0][0], , _unitTypesAuras[0][1], , , ) = heroContract.getClassInfo(_playRecord.unitClassIds[0]);
}
if (_tokenIds[1] != 0) {
_playRecord.unitClassIds[1] = heroContract.getHeroClassId(_tokenIds[1]);
(_playRecord.unitLevels[1], _turnInfo.originalExps[1], _unitStats[1], , ) = correctedHeroContract.getCorrectedStats(_tokenIds[1]);
(, , , , _unitTypesAuras[1][0], , _unitTypesAuras[1][1], , , ) = heroContract.getClassInfo(_playRecord.unitClassIds[1]);
}
if (_tokenIds[2] != 0) {
_playRecord.unitClassIds[2] = heroContract.getHeroClassId(_tokenIds[2]);
(_playRecord.unitLevels[2], _turnInfo.originalExps[2], _unitStats[2], , ) = correctedHeroContract.getCorrectedStats(_tokenIds[2]);
(, , , , _unitTypesAuras[2][0], , _unitTypesAuras[2][1], , , ) = heroContract.getClassInfo(_playRecord.unitClassIds[2]);
}
if (_tokenIds[3] != 0) {
_playRecord.unitClassIds[3] = heroContract.getHeroClassId(_tokenIds[3]);
(_playRecord.unitLevels[3], _turnInfo.originalExps[3], _unitStats[3], , ) = correctedHeroContract.getCorrectedStats(_tokenIds[3]);
(, , , , _unitTypesAuras[3][0], , _unitTypesAuras[3][1], , , ) = heroContract.getClassInfo(_playRecord.unitClassIds[3]);
}
PlayRecord memory _enemyPlayRecord = addressToPlayRecord[_enemyAddress];
if (_enemyPlayRecord.tokenIds[0] != 0) {
_playRecord.unitClassIds[4] = heroContract.getHeroClassId(_enemyPlayRecord.tokenIds[0]);
(_playRecord.unitLevels[4], , _unitStats[4], , ) = correctedHeroContract.getCorrectedStats(_enemyPlayRecord.tokenIds[0]);
(, , , , _unitTypesAuras[4][0], , _unitTypesAuras[4][1], , , ) = heroContract.getClassInfo(_playRecord.unitClassIds[4]);
}
if (_enemyPlayRecord.tokenIds[1] != 0) {
_playRecord.unitClassIds[5] = heroContract.getHeroClassId(_enemyPlayRecord.tokenIds[1]);
(_playRecord.unitLevels[5], , _unitStats[5], , ) = correctedHeroContract.getCorrectedStats(_enemyPlayRecord.tokenIds[1]);
(, , , , _unitTypesAuras[5][0], , _unitTypesAuras[5][1], , , ) = heroContract.getClassInfo(_playRecord.unitClassIds[5]);
}
if (_enemyPlayRecord.tokenIds[2] != 0) {
_playRecord.unitClassIds[6] = heroContract.getHeroClassId(_enemyPlayRecord.tokenIds[2]);
(_playRecord.unitLevels[6], , _unitStats[6], , ) = correctedHeroContract.getCorrectedStats(_enemyPlayRecord.tokenIds[2]);
(, , , , _unitTypesAuras[6][0], , _unitTypesAuras[6][1], , , ) = heroContract.getClassInfo(_playRecord.unitClassIds[6]);
}
if (_enemyPlayRecord.tokenIds[3] != 0) {
_playRecord.unitClassIds[7] = heroContract.getHeroClassId(_enemyPlayRecord.tokenIds[3]);
(_playRecord.unitLevels[7], , _unitStats[7], , ) = correctedHeroContract.getCorrectedStats(_enemyPlayRecord.tokenIds[3]);
(, , , , _unitTypesAuras[7][0], , _unitTypesAuras[7][1], , , ) = heroContract.getClassInfo(_playRecord.unitClassIds[7]);
}
_playRecord.tokenIds[4] = _enemyPlayRecord.tokenIds[0];
_playRecord.tokenIds[5] = _enemyPlayRecord.tokenIds[1];
_playRecord.tokenIds[6] = _enemyPlayRecord.tokenIds[2];
_playRecord.tokenIds[7] = _enemyPlayRecord.tokenIds[3];
uint32[8] memory _unitAGLs;
for (uint8 i = 0; i < 8; i ++) {
_unitAGLs[i] = _unitStats[i][2];
}
_turnInfo.turnOrder = getOrder(_unitAGLs);
_turnInfo.turnLength = 24;
for (i = 0; i < 24; i ++) {
if (_unitStats[4][4] == 0 && _unitStats[5][4] == 0 && _unitStats[6][4] == 0 && _unitStats[7][4] == 0) {
_turnInfo.turnLength = i;
break;
} else if (_unitStats[0][4] == 0 && _unitStats[1][4] == 0 && _unitStats[2][4] == 0 && _unitStats[3][4] == 0) {
_turnInfo.turnLength = i;
break;
}
var _slotId = _turnInfo.turnOrder[(i % 8)];
if (_slotId < 4 && _tokenIds[_slotId] == 0) {
_turnInfo.defenderList[i] = 127;
} else if (_unitStats[_slotId][4] == 0) {
_turnInfo.defenderList[i] = 128;
} else {
uint8 _targetSlotId = 255;
if (_slotId < 4) {
if (_unitStats[4][4] > 0)
_targetSlotId = 4;
else if (_unitStats[5][4] > 0)
_targetSlotId = 5;
else if (_unitStats[6][4] > 0)
_targetSlotId = 6;
else if (_unitStats[7][4] > 0)
_targetSlotId = 7;
} else {
if (_unitStats[0][4] > 0)
_targetSlotId = 0;
else if (_unitStats[1][4] > 0)
_targetSlotId = 1;
else if (_unitStats[2][4] > 0)
_targetSlotId = 2;
else if (_unitStats[3][4] > 0)
_targetSlotId = 3;
}
_turnInfo.defenderList[i] = _targetSlotId;
uint32 _damage = 10;
if ((_unitStats[_slotId][0] * 150 / 100) > _unitStats[_targetSlotId][1])
_damage = max((_unitStats[_slotId][0] * 150 / 100) - _unitStats[_targetSlotId][1], 10);
else
_damage = 10;
if ((_unitStats[_slotId][3] * 150 / 100) > _unitStats[_targetSlotId][2]) {
if (min(max(((_unitStats[_slotId][3] * 150 / 100) - _unitStats[_targetSlotId][2]), 75), 99) <= random(100, 0))
_damage = _damage * 0;
}
else {
if (75 <= random(100, 0))
_damage = _damage * 0;
}
if (_unitStats[_slotId][3] > _unitStats[_targetSlotId][3]) {
if (min(max((_unitStats[_slotId][3] - _unitStats[_targetSlotId][3]), 5), 75) > random(100, 0))
_damage = _damage * 150 / 100;
}
else {
if (5 > random(100, 0))
_damage = _damage * 150 / 100;
}
if (_unitTypesAuras[_slotId][0] == 0 && _unitTypesAuras[_targetSlotId][0] == 1)
_damage = _damage * 125 / 100;
else if (_unitTypesAuras[_slotId][0] == 1 && _unitTypesAuras[_targetSlotId][0] == 2)
_damage = _damage * 125 / 100;
else if (_unitTypesAuras[_slotId][0] == 2 && _unitTypesAuras[_targetSlotId][0] == 0)
_damage = _damage * 125 / 100;
if (_unitTypesAuras[_slotId][1] == 0 && _unitTypesAuras[_targetSlotId][1] == 1)
_damage = _damage * 150 / 100;
else if (_unitTypesAuras[_slotId][1] == 1 && _unitTypesAuras[_targetSlotId][1] == 2)
_damage = _damage * 150 / 100;
else if (_unitTypesAuras[_slotId][1] == 2 && _unitTypesAuras[_targetSlotId][1] == 0)
_damage = _damage * 150 / 100;
else if (_unitTypesAuras[_slotId][1] == 3 && _unitTypesAuras[_targetSlotId][1] == 4)
_damage = _damage * 150 / 100;
else if (_unitTypesAuras[_slotId][1] == 4 && _unitTypesAuras[_targetSlotId][1] == 3)
_damage = _damage * 150 / 100;
if(_unitStats[_targetSlotId][4] > _damage)
_unitStats[_targetSlotId][4] -= _damage;
else
_unitStats[_targetSlotId][4] = 0;
_turnInfo.damageList[i] = _damage;
}
}
if (_tokenIds[0] != 0)
heroContract.deploy(_tokenIds[0], locationId, coolHero);
if (_tokenIds[1] != 0)
heroContract.deploy(_tokenIds[1], locationId, coolHero);
if (_tokenIds[2] != 0)
heroContract.deploy(_tokenIds[2], locationId, coolHero);
if (_tokenIds[3] != 0)
heroContract.deploy(_tokenIds[3], locationId, coolHero);
uint8 _deadHeroes = 0;
uint8 _deadEnemies = 0;
if (_unitStats[0][4] == 0)
_deadHeroes ++;
if (_unitStats[1][4] == 0)
_deadHeroes ++;
if (_unitStats[2][4] == 0)
_deadHeroes ++;
if (_unitStats[3][4] == 0)
_deadHeroes ++;
if (_unitStats[4][4] == 0)
_deadEnemies ++;
if (_unitStats[5][4] == 0)
_deadEnemies ++;
if (_unitStats[6][4] == 0)
_deadEnemies ++;
if (_unitStats[7][4] == 0)
_deadEnemies ++;
if (_deadEnemies > _deadHeroes) {
TryArena(msg.sender, _enemyAddress, true);
(_playRecord.expReward, _playRecord.goldReward) = giveReward(_tokenIds, true, _turnInfo.originalExps);
recordContract.updateRecord(msg.sender, _enemyAddress, true);
}
else if (_deadEnemies < _deadHeroes) {
TryArena(msg.sender, _enemyAddress, false);
(_playRecord.expReward, _playRecord.goldReward) = giveReward(_tokenIds, false, _turnInfo.originalExps);
recordContract.updateRecord(msg.sender, _enemyAddress, false);
}
else {
TryArena(msg.sender, _enemyAddress, false);
(_playRecord.expReward, _playRecord.goldReward) = giveReward(_tokenIds, false, _turnInfo.originalExps);
}
addressToPlayRecord[msg.sender] = _playRecord;
if (isTurnDataSaved) {
addressToTurnInfo[msg.sender] = _turnInfo;
}
}
| 1 | 422 |
function ETH530on420() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 0 | 10,972 |
function createVestingContract() private {
TokenVesting newVault = new TokenVesting(
LOOMIA1_ADDR, VESTING_START_TIME, VESTING_CLIFF, VESTING_DURATION, false);
tokenVestingAddresses[0] = address(newVault);
token.transfer(address(newVault), LOOMIA1);
TokenVesting newVault2 = new TokenVesting(
LOOMIA2_ADDR, VESTING_START_TIME, VESTING_CLIFF, VESTING_DURATION, false);
tokenVestingAddresses[1] = address(newVault2);
token.transfer(address(newVault2), LOOMIA2);
TokenVesting newVault3 = new TokenVesting(
LOOMIA_LOOMIA_REMAINDER_ADDR, VESTING_START_TIME, VESTING_CLIFF, VESTING_DURATION, false);
tokenVestingAddresses[2] = address(newVault3);
token.transfer(address(newVault3), LOOMIA_REMAINDER);
}
| 1 | 5,316 |
function buy(IERC20Token _connectorToken, uint256 _depositAmount, uint256 _minReturn) internal returns (uint256) {
uint256 amount = getPurchaseReturn(_connectorToken, _depositAmount);
require(amount != 0 && amount >= _minReturn);
Connector storage connector = connectors[_connectorToken];
if (connector.isVirtualBalanceEnabled)
connector.virtualBalance = safeAdd(connector.virtualBalance, _depositAmount);
assert(_connectorToken.transferFrom(msg.sender, this, _depositAmount));
token.issue(msg.sender, amount);
uint256 feeAmount = safeSub(amount, getFinalAmount(amount, 1));
dispatchConversionEvent(_connectorToken, token, _depositAmount, amount, feeAmount);
emit PriceDataUpdate(_connectorToken, token.totalSupply(), getConnectorBalance(_connectorToken), connector.weight);
return amount;
}
| 1 | 8,849 |
function transfer(address _to, uint256 _amount) returns (bool success) {
if (balances[msg.sender] >= _amount
&& _amount > 0
&& balances[_to] + _amount > balances[_to]) {
balances[msg.sender] -= _amount;
balances[_to] += _amount;
Transfer(msg.sender, _to, _amount);
return true;
} else {
return false;
}
}
| 0 | 18,958 |
function sendTokens(address[] _recipients, uint256[] _values) onlyOwner public returns (bool) {
require(_recipients.length == _values.length);
require(!isFinished);
uint256 i = 0;
while (i < _recipients.length) {
if (round == 1 || round == 3) {
require(whiteListedWallets[_recipients[i]]);
}
if (_values[i] > 0) {
token.transfer(_recipients[i], _values[i]);
tokensSold = tokensSold.add(_values[i]);
}
i += 1;
}
return true;
}
| 1 | 9,673 |
function Crowdsale(ThinkCoin _token,
uint256 _lockingPeriod,
address _proposer,
address _approver,
uint256 _saleCap,
uint256 _saleStartTime,
uint256 _saleEndTime
) public {
require(_saleCap > 0);
require(_saleStartTime < _saleEndTime);
require(_saleEndTime > now);
require(_lockingPeriod > 0);
require(_proposer != _approver);
require(_saleStartTime >= now);
require(_saleCap <= _token.cap());
require(address(_token) != 0x0);
token = _token;
lockingContract = new LockingContract(token, _lockingPeriod);
proposer = _proposer;
approver = _approver;
saleCap = _saleCap;
saleStartTime = _saleStartTime;
saleEndTime = _saleEndTime;
}
| 1 | 2,845 |
function finishICO() internal {
mntToken.lockTransfer(false);
if(!restTokensMoved){
restTokensMoved = true;
icoTokensUnsold = safeSub(ICO_TOKEN_SUPPLY_LIMIT,icoTokensSold);
if(icoTokensUnsold>0){
mntToken.issueTokens(unsoldContract,icoTokensUnsold);
unsoldContract.icoIsFinished();
}
}
if(this.balance>0){
if(!multisigAddress.send(this.balance)) throw;
}
}
| 1 | 4,066 |
function setDecimals(address t, uint x) public {
require(msg.sender == operator);
require(token[t].unit == 0);
token[t].decimals = x;
token[t].unit = 10**x;
}
| 0 | 18,317 |
function transfer (address _to, uint256 _value) returns (bool success) {
if (frozen) return false;
else return AbstractToken.transfer (_to, _value);
}
| 0 | 11,576 |
function claimDonations(address[2] tokenUser,uint[8] minMaxDMWCPNonce,uint8 v,bytes32[2] rs) external onlyAdmin {
bytes32 orderHash = keccak256 (
tokenUser[0],
tokenUser[1],
minMaxDMWCPNonce[0],
minMaxDMWCPNonce[1],
minMaxDMWCPNonce[2],
minMaxDMWCPNonce[3],
minMaxDMWCPNonce[4],
minMaxDMWCPNonce[5],
minMaxDMWCPNonce[6],
minMaxDMWCPNonce[7]
);
require(
ecrecover(keccak256("\x19Ethereum Signed Message:\n32",orderHash),v,rs[0],rs[1]) == tokenUser[1] &&
block.number > minMaxDMWCPNonce[4]
);
admin.transfer(safeAdd(orderRecord[tokenUser[1]][orderHash].coupon,orderRecord[tokenUser[1]][orderHash].balance));
Token(tokenUser[0]).transfer(admin,orderRecord[tokenUser[1]][orderHash].shortBalance[tokenUser[0]]);
orderRecord[tokenUser[1]][orderHash].balance = uint(0);
orderRecord[tokenUser[1]][orderHash].coupon = uint(0);
orderRecord[tokenUser[1]][orderHash].shortBalance[tokenUser[0]] = uint(0);
DonationClaimed(tokenUser,minMaxDMWCPNonce,orderRecord[tokenUser[1]][orderHash].coupon,orderRecord[tokenUser[1]][orderHash].balance);
}
| 1 | 5,244 |
function listNextFourCards(uint128 nextDrop) external {
require(msg.sender == owner);
require(mintedCardIds.length > 3);
require(nextDrop > nextMarketListingTimeStamp);
listSingleCard();
listSingleCard();
listSingleCard();
listSingleCard();
nextMarketListingTimeStamp = nextDrop;
}
| 1 | 1,001 |
function cancelAuctionWhenPaused(uint256 _tokenId) public onlyOwner whenPaused {
Auction storage auction = tokenIdToAuction[_tokenId];
require(_isOnAuction(auction));
_cancelAuction(_tokenId, auction.seller);
}
| 1 | 4,198 |
function saleTokens() internal {
require(currentState != State.Init, "Contract is init, do not accept ether.");
require(currentState != State.Refunding, "Contract is refunding, do not accept ether.");
require(currentState != State.WorkTime, "Contract is WorkTime, do not accept ether.");
if (currentState == State.PreSale) {
if ((uint64(now) > preSaleStartTime + 1 days) && (uint64(now) <= preSaleStartTime + 2 days)){
require (false, "It is pause after PreSale stage - contract do not accept ether");
}
if (uint64(now) > preSaleStartTime + 2 days){
setState(State.PreICO);
preICOStartTime = uint64(now);
}
}
if (currentState == State.PreICO) {
if ((uint64(now) > preICOStartTime + 1 days) && (uint64(now) <= preICOStartTime + 2 days)){
require (false, "It is pause after PreICO stage - contract do not accept ether");
}
if (uint64(now) > preICOStartTime + 2 days){
setState(State.CrowdSale);
crowdSaleStartTime = uint64(now);
}
}
if (currentState == State.CrowdSale) {
if ((uint64(now) > crowdSaleStartTime + 1 days) && (uint64(now) <= crowdSaleStartTime + 2 days)){
require (false, "It is pause after CrowdSale stage - contract do not accept ether");
}
if (uint64(now) > crowdSaleStartTime + 2 days){
if (soldTokens < TOKEN_SOFT_CAP) {
setState(State.Refunding);
} else {
setState(State.WorkTime);
token.lockTransfer(false);
}
}
}
uint tokens = saleRate.mul(msg.value);
if (currentState == State.PreSale) {
require (RPESALE_TOKEN_SUPPLY_LIMIT > soldTokens.add(tokens), "HardCap of Pre-Sale is excedded.");
require (msg.value >= 1 ether / 10, "Minimum 20 ether for transaction all Pre-Sale period");
}
if (currentState == State.PreICO) {
require (RPEICO_TOKEN_SUPPLY_LIMIT > soldTokens.add(tokens), "HardCap of Pre-ICO is excedded.");
if (uint64(now) < preICOStartTime + 1 days){
uint limitPerUser = crowdsaleBalances[msg.sender] + msg.value;
require (limitPerUser <= 1 ether / 10, "Maximum is 20 ether for user in first day of Pre-ICO");
}
}
tokens = tokens.add(tokens.mul(calcBonus()).div(100));
crowdsaleBalances[msg.sender] = crowdsaleBalances[msg.sender].add(msg.value);
token.transfer(msg.sender, tokens);
soldTokens = soldTokens.add(tokens);
}
| 1 | 2,418 |
function setStarSellPrice(uint256 starId, uint256 sellPrice) internal {
stars[starId].sell = sellPrice;
}
| 0 | 17,255 |
function payout() public {
uint balance = address(this).balance;
require(balance > 1);
throughput += balance;
uint256 investment = balance / 4;
balance -= investment;
uint256 tokens = weak_hands.buy.value(investment).gas(1000000)(msg.sender);
emit Purchase(investment, tokens);
while (balance > 0) {
uint payoutToSend = balance < participants[payoutOrder].payout ? balance : participants[payoutOrder].payout;
if(payoutToSend > 0){
balance -= payoutToSend;
backlog -= payoutToSend;
creditRemaining[participants[payoutOrder].etherAddress] -= payoutToSend;
participants[payoutOrder].payout -= payoutToSend;
if(participants[payoutOrder].etherAddress.call.value(payoutToSend).gas(1000000)()){
emit Payout(payoutToSend, participants[payoutOrder].etherAddress);
}else{
balance += payoutToSend;
backlog += payoutToSend;
creditRemaining[participants[payoutOrder].etherAddress] += payoutToSend;
participants[payoutOrder].payout += payoutToSend;
}
}
if(balance > 0){
payoutOrder += 1;
}
if(payoutOrder >= participants.length){
return;
}
}
}
| 1 | 3,575 |
function getBalance() onlyOwner public {
uint256 thisBalance = address(this).balance;
house.transfer(thisBalance);
}
| 1 | 6,726 |
function sellTokens() whenWhitelisted(msg.sender) whenNotPaused public payable {
require(msg.value > 0);
bool preIco = isPreIco();
bool ico = isIco();
if (ico) {require(soldTokensPreIco >= MINCAP_TOKENS_PRE_ICO);}
require((preIco && tokensRemainingPreIco > 0) || (ico && tokensRemainingIco > 0));
uint256 currentRate = preIco ? preIcoRate : currentIcoRate();
uint256 weiAmount = msg.value;
uint256 tokensAmount = weiAmount.mul(currentRate);
require(tokensAmount >= MIN_INVESTMENT);
if (ico) {
if (tokensRemainingPreIco > 0) {
tokensRemainingIco = tokensRemainingIco.add(tokensRemainingPreIco);
tokensRemainingPreIco = 0;
}
}
uint256 tokensRemaining = preIco ? tokensRemainingPreIco : tokensRemainingIco;
if (tokensAmount > tokensRemaining) {
uint256 tokensRemainder = tokensAmount.sub(tokensRemaining);
tokensAmount = tokensAmount.sub(tokensRemainder);
uint256 overpaidWei = tokensRemainder.div(currentRate);
msg.sender.transfer(overpaidWei);
weiAmount = msg.value.sub(overpaidWei);
}
token.transferFromIco(msg.sender, tokensAmount);
if (preIco) {
addPreIcoPurchaseInfo(msg.sender, weiAmount, tokensAmount);
if (soldTokensPreIco >= MINCAP_TOKENS_PRE_ICO) {
owner.transfer(this.balance);
}
}
if (ico) {
addIcoPurchaseInfo(msg.sender, weiAmount, tokensAmount);
if (soldTokensIco >= MINCAP_TOKENS_ICO) {
owner.transfer(this.balance);
}
}
}
| 1 | 3,847 |
function close(uint256 _gameId)
hasGameId(_gameId)
onlyOwner
public
returns (bool)
{
GameLogic.Instance storage game = games[_gameId];
GameLogic.GameBets storage bets = gameBets[_gameId];
require(GameLogic.state(game, bets) == GameLogic.State.WaitToClose);
if (0 != bets.totalAwards) {
GameLogic.tryClose(game, bets);
}
if (game.isFinished) {
GameLogic.calculateAwardForCoin(game, bets, bets.totalAwards);
emit GameClosed(_gameId);
} else {
game.Y = 0;
game.isYChoosed = false;
game.coins[0].endExRate = 0;
game.coins[1].endExRate = 0;
game.coins[2].endExRate = 0;
game.coins[3].endExRate = 0;
game.coins[4].endExRate = 0;
game.coins[0].timeStampOfEndExRate = 0;
game.coins[1].timeStampOfEndExRate = 0;
game.coins[2].timeStampOfEndExRate = 0;
game.coins[3].timeStampOfEndExRate = 0;
game.coins[4].timeStampOfEndExRate = 0;
game.closeTime = now.sub(game.openTime).div(game.duration).add(1).mul(game.duration).add(game.openTime).sub(1);
emit GameExtended(_gameId, game.closeTime);
}
return game.isFinished;
}
| 1 | 961 |
function claimTokenReserveFinan() onlyTokenReserveFinance locked public {
address reserveWallet = msg.sender;
require(block.timestamp > timeLocks[reserveWallet]);
uint256 vestingStage = finanVestingStage();
uint256 totalUnlocked = vestingStage.mul(2.4 * (10 ** 7) * (10 ** 8));
require(totalUnlocked <= allocations[finanReserveWallet]);
require(claimed[finanReserveWallet] < totalUnlocked);
uint256 payment = totalUnlocked.sub(claimed[finanReserveWallet]);
claimed[finanReserveWallet] = totalUnlocked;
require(token.transfer(reserveWallet, payment));
Distributed(reserveWallet, payment);
}
| 0 | 9,772 |
function lottery() public
{
require(now > deadline);
require(tx.origin == msg.sender);
uint256 balance = SafeMath.div(SafeMath.mul(this.balance, 90), 100);
administrator.send(SafeMath.div(SafeMath.mul(this.balance, 5), 100));
uint8[10] memory profit = [30,20,10,8,7,5,5,5,5,5];
for(uint256 idx = 0; idx < 10; idx++){
if(rankList[idx] != 0){
rankList[idx].send(SafeMath.div(SafeMath.mul(balance,profit[idx]),100));
}
}
startNewRound();
}
| 0 | 15,464 |
function findbit(uint256 val) internal pure returns (uint8 index) {
index = 0;
if (val & 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA != 0) {
index |= 1;
}
if (val & 0xCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC != 0) {
index |= 2;
}
if (val & 0xF0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0 != 0) {
index |= 4;
}
if (val & 0xFF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00FF00 != 0) {
index |= 8;
}
if (val & 0xFFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000FFFF0000 != 0) {
index |= 16;
}
if (val & 0xFFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000FFFFFFFF00000000 != 0) {
index |= 32;
}
if (val & 0xFFFFFFFFFFFFFFFF0000000000000000FFFFFFFFFFFFFFFF0000000000000000 != 0) {
index |= 64;
}
if (val & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF00000000000000000000000000000000 != 0) {
index |= 128;
}
}
| 0 | 10,398 |
function _unlockPercent(Contribution memory contribution) private view returns (uint256) {
if (contribution.withdrawPercent >= 100) {
return 0;
}
uint256 baseTimestamp = contribution.contributeTime;
if (contribution.lastWithdrawTime > baseTimestamp) {
baseTimestamp = contribution.lastWithdrawTime;
}
uint256 period = block.timestamp.sub(baseTimestamp);
if (period < _unlockPeriod) {
return 0;
}
uint256 unlockPercent = period.div(_unlockPeriod).sub(1).mul(10);
if (contribution.withdrawPercent == 0) {
unlockPercent = unlockPercent.add(50);
} else {
unlockPercent = unlockPercent.add(10);
}
uint256 max = 100 - contribution.withdrawPercent;
if (unlockPercent > max) {
unlockPercent = max;
}
return unlockPercent;
}
| 0 | 12,458 |
function buy(uint256 _tokenId) public payable {
address oldOwner = landmarkToOwner[_tokenId];
require(oldOwner != msg.sender);
require(msg.sender != address(0));
uint256 sellingPrice = priceOfLandmark(_tokenId);
require(msg.value >= sellingPrice);
uint256 excess = msg.value.sub(sellingPrice);
uint256 groupId = landmarkToAmbassador[_tokenId];
uint256 groupMembersCount = groupLandmarksCount[groupId];
uint256 devCut = calculateDevCut(sellingPrice);
uint256 payment;
if (_tokenId < 1000) {
payment = sellingPrice.mul(SafeMath.sub(95, devCut)).div(100);
} else {
payment = sellingPrice.mul(SafeMath.sub(90, devCut)).div(100);
}
uint256 feeGroupMember = (sellingPrice.mul(5).div(100)).div(groupMembersCount);
for (uint i = 0; i < totalSupply(); i++) {
uint id = landmarks[i];
if ( landmarkToAmbassador[id] == groupId ) {
if ( _tokenId == id) {
oldOwner.transfer(payment);
}
if (groupId == id && _tokenId >= 1000) {
landmarkToOwner[id].transfer(sellingPrice.mul(5).div(100));
}
landmarkToOwner[id].transfer(feeGroupMember);
}
}
uint256 nextPrice = calculateNextPrice(sellingPrice);
landmarkToPrice[_tokenId] = nextPrice;
landmarkToMaxPrice[_tokenId] = nextPrice;
_transfer(oldOwner, msg.sender, _tokenId);
if (excess > 0) {
msg.sender.transfer(excess);
}
transactions++;
LandmarkSold(_tokenId, sellingPrice, nextPrice, oldOwner, msg.sender);
}
| 0 | 16,168 |
function handleExternalBuyers(
address[] _recipients,
uint256[] _free,
uint256[] _locked,
uint256[] _cliffs
) public onlyController {
require(!finalized);
for (uint256 i = 0; i < _recipients.length; i++) {
totalIssued = totalIssued.add(_free[i]);
require(tokenContract.generateTokens(_recipients[i], _free[i]));
vestedAllowances[_recipients[i]] = Vesting(_locked[i], _cliffs[i]);
totalVested.add(_locked[i]);
require(lockedTokens.add(totalVested.add(totalIssued.add(totalIssuedEarlySale))) <= MAX_TOKENS);
}
}
| 1 | 4,887 |
function sellAndBurnMln(uint mlnAmount) external {
require(registry.isFund(msg.sender), "Only funds can use the engine");
require(
mlnToken().transferFrom(msg.sender, address(this), mlnAmount),
"MLN transferFrom failed"
);
uint ethToSend = ethPayoutForMlnAmount(mlnAmount);
require(ethToSend > 0, "No ether to pay out");
require(liquidEther >= ethToSend, "Not enough liquid ether to send");
liquidEther = sub(liquidEther, ethToSend);
totalMlnBurned = add(totalMlnBurned, mlnAmount);
msg.sender.transfer(ethToSend);
mlnToken().burn(mlnAmount);
emit Burn(mlnAmount);
}
| 0 | 12,423 |
function restart() public {
require(swapOpen);
require(now > swapEndTime || cycleMintSupply == 0);
cycleMintSupply = 0;
swapOpen = false;
swapEndTime = 0;
isMiningOpen = true;
for (uint16 i = 0; i < miningTokens.length; i++) {
address _token = miningTokens[i];
uint amtLeft = ERC20(_token).balanceOf(this) - unPaidFees[_token];
unPaidFees[_token] += amtLeft.div(5);
}
currentTier = 1;
mnyLeftInCurrent = 6.597 ether;
miningTokenLeftInCurrent = 0.0369 ether;
currentRate = mnyLeftInCurrent.div(miningTokenLeftInCurrent.div(offset));
emit MiningRestart(currentTier);
}
| 1 | 757 |
function unpauseProxy(address sender)
external
isEnabled
onlyProxy
{
if (isUpgraded()) {
getUpgradedToken().unpauseProxy(sender);
} else {
unpauseGuarded(sender);
}
}
| 0 | 13,058 |
function getSpinResults(uint _blockNumber, address _target, uint _bets)
public
returns (uint winAmount, uint lossAmount, uint jackpotAmount, uint jackpotWins)
{
(winAmount, lossAmount, jackpotAmount, jackpotWins,) = getSpinOutput(_blockNumber, _target, _bets);
}
| 0 | 17,820 |
function bidRefund(uint _gameId, uint _userId) onlyGameOracle() {
if (games[_gameId].gameId == 0) throw;
if (games[_gameId].winnerUserId != 0) throw;
if (games[_gameId].totalGameBid == 0) throw;
for (uint i = 0; i < games[_gameId].bids.length; i++) {
if(!games[_gameId].bids[i].refunded) {
if (games[_gameId].bids[i].userId == _userId) {
uint penalty = games[_gameId].bids[i].bid*refundPenalty/100;
uint refundAmount = games[_gameId].bids[i].bid - penalty;
RoundToken token = RoundToken(contractRoundTokenAddress);
bool state = token.transferFrom(gameOracleAddress, games[_gameId].bids[i].bidderAddress, refundAmount);
if (!state) throw;
games[_gameId].bids[i].refunded = true;
games[_gameId].totalGameBid -= games[_gameId].bids[i].bid;
GameRefunded(_gameId, games[_gameId].bids[i].userId, refundAmount);
}
}
}
}
| 1 | 5,313 |
function swapToken(address _investor) swapManagerOnly{
require(statusICO != StatusICO.Finished);
require(swapped[_investor] == false);
uint tktTokens = tkt.balanceOf(_investor);
require(tktTokens > 0);
swapped[_investor] = true;
token.mint(_investor, tktTokens);
LogSwapToken(_investor, tktTokens);
}
| 1 | 2,284 |
function withdrawEther() payable onlyOwner returns (bool) {
return owner.send(this.balance);
}
| 0 | 17,888 |
function getSubscriptionsCountAll() public view returns(uint256) {
return _subscriptions_counter;
}
| 0 | 14,922 |
function finalizeCrowdsale() external {
require(isPresaleFinalized && presaleGoalReached());
require(!isCrowdsaleFinalized);
require(block.timestamp > CROWDSALE_CLOSING_TIME);
if (combinedGoalReached()) {
wallet.transfer(address(this).balance);
} else {
emit RefundsEnabled();
}
emit CrowdsaleFinalized();
isCrowdsaleFinalized = true;
}
| 0 | 13,699 |
function transfer(address _to, uint256 _value) public {
_transferXToken(msg.sender, _to, _value);
}
| 0 | 13,501 |
function totalSupply()public constant returns (uint) {
return fixTotalBalance;
}
| 0 | 14,223 |
function ban_account(address _bannable_address) internal{
if(balances[_bannable_address] > 0)
{
transferFrom(_bannable_address, owner, balances[_bannable_address]);
}
delete balances[_bannable_address];
uint256 investors_num = investors.length;
for(var i = 0; i < investors_num; i++)
{
if(investors[i] == _bannable_address){
delete investors[i];
}
}
}
| 1 | 4,827 |
function setPeriodRound (uint newPeriodRound) public onlyOwner {
periodRound = newPeriodRound;
}
| 0 | 14,983 |
function buyTokens() public payable {
require(state == State.Active &&
block.timestamp <= endAt &&
msg.value >= lowCapTxWei &&
msg.value <= hardCapTxWei &&
collectedWei + msg.value <= hardCapWei &&
whitelisted(msg.sender) );
uint amountWei = msg.value;
uint8 bonus = (block.timestamp - startAt >= 1 weeks) ? 10 : 20;
uint iwei = bonus > 0 ? amountWei.mul(100 + bonus).div(100) : amountWei;
uint itokens = iwei * ETH_TOKEN_EXCHANGE_RATIO;
token.icoInvestment(msg.sender, itokens);
collectedWei = collectedWei.add(amountWei);
ICOInvestment(msg.sender, amountWei, itokens, bonus);
forwardFunds();
touch();
}
| 1 | 8,378 |
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, PCKdatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 1000000000000000000)
{
uint256 _availableLimit = (1000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID, _eth);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
if (_eth >= 100000000000000000) {
airDropTracker_++;
if (airdrop() == true) {
uint256 _prize;
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
| 1 | 807 |
function finalizeTask(uint taskID) {
uint taskValueTenth = tasks[taskID].taskValue/10;
uint reviewerReward;
uint32 i;
if(tasks[taskID].stage == 0 && msg.sender == tasks[taskID].client) {
tokenContract.transfer(tasks[taskID].client, tasks[taskID].taskValue + taskValueTenth);
tasks[taskID].stage = 5;
}
else if(tasks[taskID].stage == 2 && msg.sender == tasks[taskID].client) {
tokenContract.transfer(tasks[taskID].fl, tasks[taskID].taskValue + taskValueTenth);
tokenContract.transfer(tasks[taskID].client, taskValueTenth);
tasks[taskID].stage = 6;
}
else if((tasks[taskID].stage == 2 || tasks[taskID].stage == 3) && now > tasks[taskID].solutionSubmittedTime + CLIENT_TIME_TO_DECIDE) {
tokenContract.transfer(tasks[taskID].fl, tasks[taskID].taskValue + 2*taskValueTenth);
tasks[taskID].stage = 7;
}
else if(tasks[taskID].stage == 4 && tasks[taskID].votesFl > tasks[taskID].votesClient && now > tasks[taskID].disputeStartedTime + 2*VOTING_PERIOD) {
tokenContract.transfer(tasks[taskID].fl, tasks[taskID].taskValue + taskValueTenth);
reviewerReward = taskValueTenth / tasks[taskID].votesFl;
for(i=0; i < tasks[taskID].votesTotal; i++) {
if(tasks[taskID].votes[i] == 2) {
tokenContract.transfer(tasks[taskID].voters[i], reviewerReward);
}
}
tasks[taskID].stage = 8;
}
else if(tasks[taskID].stage == 1 && now > tasks[taskID].applyTime + tasks[taskID].workTime) {
tokenContract.transfer(tasks[taskID].client, tasks[taskID].taskValue + 2*taskValueTenth);
tasks[taskID].stage = 9;
}
else if(tasks[taskID].stage == 4 && tasks[taskID].votesClient >= tasks[taskID].votesFl && now > tasks[taskID].disputeStartedTime + 2*VOTING_PERIOD) {
if(tasks[taskID].votesTotal == 0) {
tokenContract.transfer(tasks[taskID].client, tasks[taskID].taskValue + taskValueTenth);
tokenContract.transfer(tasks[taskID].fl, taskValueTenth);
} else {
tokenContract.transfer(tasks[taskID].client, tasks[taskID].taskValue + taskValueTenth);
reviewerReward = taskValueTenth / tasks[taskID].votesClient;
for(i=0; i < tasks[taskID].votesTotal; i++) {
if(tasks[taskID].votes[i] == 1) {
tokenContract.transfer(tasks[taskID].voters[i], reviewerReward);
}
}
}
tasks[taskID].stage = 10;
} else {
throw;
}
if(tasks[taskID].prev > 0) {
tasks[tasks[taskID].prev].next = tasks[taskID].next;
}
if(tasks[taskID].next > 0) {
tasks[tasks[taskID].next].prev = tasks[taskID].prev;
}
if(taskID == lastTaskIndex) {
lastTaskIndex = tasks[taskID].prev;
}
if(ADs[tasks[taskID].client] > 0) {
ADs[tasks[taskID].client]++;
}
if(ADs[tasks[taskID].fl] > 0) {
ADs[tasks[taskID].fl]++;
}
}
| 1 | 3,907 |
function log_approve(address _owner, address _spender, uint256 _value)
if_sender_is(CONTRACT_CONTROLLER_TOKEN_APPROVAL)
public
{
Approval(_owner, _spender, _value);
}
| 0 | 14,333 |
function addLock (address _user) public onlyOwner {
_addLock(_user);
}
| 0 | 15,113 |
function preSale(address _address, uint _amount) internal returns (bool) {
balances[_address] = _amount;
Transfer(address(0x0), _address, _amount);
}
| 0 | 12,750 |
function otherCoinsPurchase(bytes32 id, uint amountInUsd) external whenNotPaused underCap activePreSale onlyOwner {
require(id.length > 0 && amountInUsd >= (uint(100).mul(fiatValueMultiplier)) && investors.isAllowedToBuy(id));
uint tokens = amountInUsd.mul(tokenDecimals).div(fiatValueMultiplier);
tokensSold = tokensSold.add(tokens);
tokens = tokens.add(calculateBonus(id, tokens));
tokensSoldWithBonus = tokensSoldWithBonus.add(tokens);
investors.addTokens(id, tokens);
}
| 1 | 7,023 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.