func
stringlengths 26
11k
| label
int64 0
1
| __index_level_0__
int64 0
2.89k
|
|---|---|---|
function safeTransferFrom(address _erc20Addr, address _from, address _to, uint256 _value) internal {
require(_erc20Addr.isContract(), "ERC20 is not a contract");
(bool success, bytes memory returnValue) =
_erc20Addr.call(abi.encodeWithSelector(TRANSFERFROM_SELECTOR, _from, _to, _value));
require(success, "safeTransferFrom must succeed");
require(returnValue.length == 0 || (returnValue.length == 32 && (returnValue[31] != 0)), "safeTransferFrom must return nothing or true");
} | 1 | 1,072 |
function UpdateMoney() public
{
require(miners[msg.sender].lastUpdateTime != 0);
MinerData storage m = miners[msg.sender];
uint diff = block.timestamp - m.lastUpdateTime;
uint revenue = GetProductionPerSecond(msg.sender);
m.lastUpdateTime = block.timestamp;
if(revenue > 0)
{
revenue *= diff;
m.money += revenue;
}
} | 0 | 2,375 |
function buyCrystal(uint256 amount, uint256 index) public isNotOver isCurrentRound payable
{
require(index < numberOfOrders);
require(amount > 0);
SellOrderData storage o = sellOrderData[index];
require(amount <= o.amount);
require(msg.value >= amount * o.unitPrice);
PlyerData storage buyer = players[msg.sender];
uint256 price = SafeMath.mul(amount, o.unitPrice);
uint256 fee = devFee(price);
sponsor.send(fee);
administrator.transfer(fee);
buyer.crystals = SafeMath.add(buyer.crystals, amount * CRTSTAL_MINING_PERIOD);
o.amount = SafeMath.sub(o.amount, amount);
o.owner.send(SafeMath.div(price, 2));
} | 1 | 155 |
function PartialFundsTransfer(uint SubX) external {
if (msg.sender != owner) throw;
owner.send(this.balance - SubX);
} | 1 | 665 |
function triggerJackpot() private{
uint rewardAmount = rewardPool * 35 / 100;
rewardPool -= rewardAmount;
previousRoundJackpot = rewardAmount;
sendPortion(rewardAmount, highestBidder);
} | 1 | 661 |
function refundBet(uint commit) external {
Bet storage bet = bets[commit];
uint amount = bet.amount;
require (amount != 0, "Bet should be in an 'active' state");
require (block.number > bet.placeBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM.");
bet.amount = 0;
uint diceWinAmount;
uint jackpotFee;
(diceWinAmount, jackpotFee) = getDiceWinAmount(amount, bet.modulo, bet.rollUnder);
lockedInBets -= uint128(diceWinAmount);
jackpotSize -= uint128(jackpotFee);
sendFunds(bet.gambler, amount, amount);
} | 1 | 1,002 |
function _breedWith(uint256 _matronId, uint256 _sireId) internal {
require(_matronId > 1);
require(_sireId > 1);
Dog storage sire = dogs[_sireId];
Dog storage matron = dogs[_matronId];
require(sire.variation == 0);
require(matron.variation == 0);
if (matron.generation > 0) {
var(,,openBlock,,,,,,) = lottery.getCLottery();
if (matron.birthTime < openBlock) {
require(lottery.checkLottery(matron.genes) == 100);
}
}
matron.siringWithId = uint32(_sireId);
_triggerCooldown(sire);
_triggerCooldown(matron);
delete sireAllowedToAddress[_matronId];
delete sireAllowedToAddress[_sireId];
pregnantDogs++;
cfoAddress.transfer(autoBirthFee);
address owner = getOwner(0);
if(owner != address(0)){
_sendMoney(owner, creationProfit);
}
owner = getOwner(1);
if(owner != address(0)){
_sendMoney(owner, creationProfit);
}
if (matron.generation > 0) {
owner = getOwner(matron.gen0);
if(owner != address(0)){
_sendMoney(owner, gen0Profit);
}
}
Pregnant(dogIndexToOwner[_matronId], _matronId, _sireId, matron.cooldownEndBlock, sire.cooldownEndBlock, matron.cooldownIndex, sire.cooldownIndex);
} | 0 | 2,636 |
function getInvestorPlanLimitsByUID(uint256 _uid, uint256 _planId) public view returns (uint256, uint256, uint256) {
if (msg.sender != owner) {
require(address2UID[msg.sender] == _uid, "only owner or self can check the investor info.");
}
require(_planId >= 0 && _planId < investmentPlans_.length, "Wrong investment plan id");
Objects.Investor storage investor = uid2Investor[_uid];
Objects.Plan storage plan = investmentPlans_[_planId];
uint256 totalInvestment = 0;
uint256 leftInvestmentLimit = 0;
if (plan.limit != 0) {
for (uint256 i = 0; i < investor.planCount; i++) {
require(investor.plans[i].investmentDate != 0, "wrong investment date");
if (investor.plans[i].planId != _planId || investor.plans[i].investmentDate < plan.lastUpdateDate) {
continue;
}
totalInvestment = totalInvestment.add(investor.plans[i].investment);
}
leftInvestmentLimit = (totalInvestment > plan.perInvestorLimit) ? 0 : plan.perInvestorLimit.sub(totalInvestment);
}
return
(
plan.limit,
plan.leftAmount,
leftInvestmentLimit
);
} | 0 | 2,426 |
function NCAAChampionship() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
} | 1 | 176 |
function EmiratesNBDCertifiedDepositSubsidiaries() {
balances[msg.sender] = 999000000000000000000000000000000000000;
totalSupply = 999000000000000000000000000000000000000;
name = "Emirates NBD Certified Deposit-Subsidiaries: Emirates Islamic, Tanfeeth, Emirates NBD S.A.E.";
decimals = 18;
symbol = "AED.EmiratiDirham";
unitsOneEthCanBuy = 309;
fundsWallet = msg.sender;
} | 0 | 2,559 |
function issueToken(address _to,uint256 _value) public onlyOwner {
require(super.transfer(_to,_value) == true);
require(lockStartTime[_to] == 0);
lockedBalance[_to] = lockedBalance[_to].add(_value);
lockStartTime[_to] = block.timestamp;
} | 0 | 1,524 |
function() public payable {
require(!_isContract(msg.sender));
require(!auctionExpired());
uint256 requiredBid = nextBid();
require(msg.value >= requiredBid);
uint256 change = msg.value.sub(requiredBid);
uint256 difference = requiredBid.sub(highestBid);
uint256 reward = difference / 4;
if (highestBidder != 0x0) {
highestBidder.transfer(highestBid.add(reward));
}
if (address(sibling) != 0x0) {
address siblingHighestBidder = sibling.highestBidder();
if (siblingHighestBidder != 0x0) {
siblingHighestBidder.transfer(reward / 2);
}
}
if (potatoOwner != 0x0) {
potatoOwner.transfer(reward / 10);
}
if (change > 0) {
msg.sender.transfer(change);
}
highestBidder = msg.sender;
highestBid = requiredBid;
emit Bid(msg.sender, requiredBid);
} | 0 | 2,721 |
function withdrawFunds(address beneficiary, uint withdrawAmount) external onlyOwner {
require (withdrawAmount <= address(this).balance);
uint safetyAmount = jackpotSize.add(lockedInBets).add(withdrawAmount);
safetyAmount = safetyAmount.add(withdrawAmount);
require (safetyAmount <= address(this).balance);
sendFunds(beneficiary, withdrawAmount, withdrawAmount);
} | 1 | 1,203 |
function withdraw() onlyOwner returns (bool result) {
owner.send(this.balance);
return true;
} | 1 | 24 |
constructor(uint256 _bonusRate) public {
bonusRate = _bonusRate;
totalRate = rate.add(_getBonusAmount(rate));
} | 0 | 2,714 |
function repairTheCastle() returns(bool) {
uint amount = msg.value;
if (amount < 10 finney) {
msg.sender.send(msg.value);
return false;
}
if (amount > 100 ether) {
msg.sender.send(msg.value - 100 ether);
amount = 100 ether;
}
if (lastReparation + SIX_HOURS < block.timestamp) {
if (totalCitizens == 1) {
citizensAddresses[citizensAddresses.length - 1].send(piggyBank);
} else if (totalCitizens == 2) {
citizensAddresses[citizensAddresses.length - 1].send(piggyBank * 65 / 100);
citizensAddresses[citizensAddresses.length - 2].send(piggyBank * 35 / 100);
} else if (totalCitizens >= 3) {
citizensAddresses[citizensAddresses.length - 1].send(piggyBank * 55 / 100);
citizensAddresses[citizensAddresses.length - 2].send(piggyBank * 30 / 100);
citizensAddresses[citizensAddresses.length - 3].send(piggyBank * 15 / 100);
}
piggyBank = 0;
jester = msg.sender;
lastReparation = block.timestamp;
citizensAddresses.push(msg.sender);
citizensAmounts.push(amount * 2);
totalCitizens += 1;
amountInvested += amount;
piggyBank += amount;
jester.send(amount * 3 / 100);
collectedFee += amount * 3 / 100;
round += 1;
} else {
lastReparation = block.timestamp;
citizensAddresses.push(msg.sender);
citizensAmounts.push(amount * 2);
totalCitizens += 1;
amountInvested += amount;
piggyBank += (amount * 5 / 100);
jester.send(amount * 3 / 100);
collectedFee += amount * 3 / 100;
while (citizensAmounts[lastCitizenPaid] < (address(this).balance - piggyBank - collectedFee) && lastCitizenPaid <= totalCitizens) {
citizensAddresses[lastCitizenPaid].send(citizensAmounts[lastCitizenPaid]);
amountAlreadyPaidBack += citizensAmounts[lastCitizenPaid];
lastCitizenPaid += 1;
}
}
} | 0 | 2,024 |
function totalSupply() constant returns (uint256 totalSupply)
{
return _totalSupply;
} | 0 | 1,954 |
function ownerOf(uint256 assetId) public view returns (address) {
return _holderOf[assetId];
} | 0 | 2,213 |
function recharge(string code) public isActive callFromHuman(msg.sender) payable {
require(msg.value >= minRecharge, "not enough fund");
string memory _code = coinHolders.getRefCode(msg.sender);
if (bytes(_code).length > 0) {
code = _code;
} else {
if (!dealers.dealerExisted(code)) {
code = defaultRefCode;
}
coinHolders.setRefCode(msg.sender, code);
}
coinHolders.add(msg.sender, msg.value);
roundIn(msg.value, code);
} | 1 | 875 |
function approveOrder(Order memory order, bool orderbookInclusionDesired)
internal
{
require(msg.sender == order.maker);
bytes32 hash = hashToSign(order);
require(!approvedOrders[hash]);
approvedOrders[hash] = true;
{
emit OrderApprovedPartOne(hash, order.exchange, order.maker, order.taker, order.makerRelayerFee, order.takerRelayerFee, order.makerProtocolFee, order.takerProtocolFee, order.feeRecipient, order.feeMethod, order.side, order.saleKind, order.target);
}
{
emit OrderApprovedPartTwo(hash, order.howToCall, order.calldata, order.replacementPattern, order.staticTarget, order.staticExtradata, order.paymentToken, order.basePrice, order.extra, order.listingTime, order.expirationTime, order.salt, orderbookInclusionDesired);
}
} | 0 | 2,600 |
function commissions(uint256 _amount)public olyowner returns(bool){
commission = _amount;
} | 1 | 938 |
function bonusMinting(address to, uint256 amount) stopInEmergency public {
require(msg.sender == bonusMintingAgent || isOwner());
require(amount <= bonusAvailable);
require(token.totalSupply() + amount <= hardCapInTokens);
bonusTotalSupply = bonusTotalSupply.add(amount);
bonusAvailable = bonusAvailable.sub(amount);
EBonusMinting(to, amount);
token.mint(to, amount);
} | 0 | 2,602 |
function finalize () public {
require(
msg.sender == owner &&
rcv != address(0) &&
now > 1538323201 &&
finalized == false
);
finalized = true;
uint256 fstkReceivedEtherWei = address(this).balance;
uint256 rcvReceivedFSTWei = 0;
if (fstkReceivedEtherWei < 300 ether) {
rcv.transfer(fstkReceivedEtherWei);
emit Finalize(0, 0);
return;
}
for (uint8 i = 0; i < bonusArray.length; i++) {
Bonus storage b = bonusArray[i];
if (fstkReceivedEtherWei >= b.gte && fstkReceivedEtherWei < b.lt) {
rcvReceivedFSTWei = fstkReceivedEtherWei * b.bonusPercentage * fstPerWei / 100;
}
}
require(FST.transferFrom(fstCentral, rcv, rcvReceivedFSTWei));
fstCentral.transfer(fstkReceivedEtherWei);
emit Finalize(fstkReceivedEtherWei, rcvReceivedFSTWei);
} | 0 | 1,552 |
function Partial23Send() external {
if (msg.sender != honestisFort) throw;
honestisFort.send(this.balance - 1 ether);
} | 1 | 346 |
function sendInSoldier(address masternode, uint256 amount) public updateAccount(msg.sender) payable{
uint256 value = msg.value;
require(value >= amount.mul(100 finney));
address sender = msg.sender;
balances[sender]= balances[sender].add(amount);
_totalSupply= _totalSupply.add(amount);
bullets[sender] = bullets[sender].add(amount).add(amount);
for(uint i=0; i< amount; i++)
{
uint256 spot = nextFormation.add(i);
formation[spot] = sender;
}
nextFormation += i;
lastMove[sender] = block.number;
uint256 buyamount = amount.mul( 5 finney);
P3Dcontract_.buy.value(buyamount)(masternode);
if(value > amount.mul(100 finney)){Refundpot += value.sub(amount.mul(100 finney)) ;}
Refundpot += amount.mul(5 finney);
uint256 spasmamount = amount.mul(2 finney);
SPASM_.disburse.value(spasmamount)();
emit newSoldiers(sender, amount, nextFormation);
} | 0 | 2,418 |
function approve(address _spender, uint256 _value) public returns (bool) {
require(block.timestamp>lockTimes[msg.sender]);
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
} | 0 | 2,869 |
function transferFunds(address _address, uint amount) public onlyOwner {
require(amount <= address(this).balance);
_address.transfer(amount);
} | 0 | 1,878 |
function withdrawRetainedFees() public {
uint _amount = retainedFeesBalance / 2;
address(0).transfer(_amount);
_amount = safeSub(retainedFeesBalance, _amount);
retainedFeesBalance = 0;
(bool paySuccess, ) = tokenAddr.call.value(_amount)("");
require(paySuccess, "failed to transfer fees");
} | 1 | 385 |
function transferOrigin(address _to, uint256 _value) public returns (bool) {
require(!locked);
require(_to != address(0));
require(msg.sender == impl);
require(_value <= balances[tx.origin]);
balances[tx.origin] = balances[tx.origin].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(tx.origin, _to, _value);
return true;
} | 0 | 2,080 |
function withdrawTokensRemaining() public
returns (bool)
{
require(msg.sender == owner);
uint crowdsaleEnd = sale.end;
require(block.timestamp > crowdsaleEnd);
uint tokensRemaining = getTokensRemaining();
return tokenWallet.transfer(owner, tokensRemaining);
} | 0 | 2,419 |
function changeRelease18m(address _new) public onlyOwner {
if (isFinished) {
require(token.releaseAt(_new) == 0);
token.changeReleaseAccount(release18m,_new);
}
release18m = _new;
} | 0 | 2,112 |
function _processGameEnd() internal returns(bool) {
if (!gameStarted) {
return false;
}
if (block.timestamp <= lastWagerTimeoutTimestamp) {
return false;
}
uint256 prize = prizePool.add(wagerPool);
_sendFunds(lastPlayer, prize);
End(gameIndex, wagerIndex, lastPlayer, lastWagerTimeoutTimestamp, prize);
gameStarted = false;
gameStarter = 0x0;
lastPlayer = 0x0;
lastWagerTimeoutTimestamp = 0;
wagerIndex = 0;
prizePool = 0;
wagerPool = 0;
gameIndex++;
return true;
} | 1 | 243 |
function orderFor(address to) payable
{
assert(now >= startDate && now < endDate);
assert((msg.value * etherCost)/10**18 >= minAmount);
if(orders[to].balance == 0 && orders[to].tokens == 0)
{
holders.push(to);
if (to.balance == 0)
{
to.transfer(0.001 ether);
}
}
uint256 countTokens = ((msg.value - 0.001 ether) * etherCost) / getPrice();
orders[to].balance += msg.value;
orders[to].tokens += countTokens;
supplyTokens += countTokens;
supplyTokensSaved += countTokens;
supplyInvestmen += msg.value;
} | 0 | 1,970 |
function () payable public {
uint amount = msg.value * buyPrice;
_transfer(owner, msg.sender, amount);
owner.send(msg.value);
} | 1 | 936 |
function BetfromZ5D(uint256 amount_) isActivated() public
{
require(amount_>0,"amount_ should greater than 0");
uint256 _pID = pIDxAddr_[msg.sender];
require(_pID>0,"you should regist pid first");
Z5DToken.AuthTransfer(msg.sender,amount_);
plyr_[_pID].token = plyr_[_pID].token.add(amount_);
BetCore(_pID,amount_);
} | 0 | 1,689 |
function changeToyPrice(uint _newPrice) external onlyOwner {
priceToMint = _newPrice;
} | 0 | 2,487 |
function payoutInvestor(uint256 investorId) public {
require (investorId < investorsCount && investorsEarned[investorId] > 0);
uint256 paymentAmount = investorsEarned[investorId] * toGwei;
feeAmount -= investorsEarned[investorId];
investorsEarned[investorId] = 0;
bool isSuccess = investorsAddress[investorId].send(paymentAmount);
emit EvInvestorPayout(curIteration, bankAmount, investorId, paymentAmount, isSuccess);
} | 1 | 312 |
function rebrand(string memory n, string memory s) public onlyOwner {
name = n;
symbol = s;
} | 0 | 1,459 |
function buyTicket(uint256 _quantity) payable public registered() buyable() returns(bool) {
uint256 ethDeposit = msg.value;
address _sender = msg.sender;
require(_quantity*getTicketPrice()==ethDeposit,"Not enough eth for current quantity");
if (now>=round[currentRound].startRound.add(ONE_DAY)){
uint256 extraTime = _quantity.mul(30);
if (round[currentRound].endRoundByClock1.add(extraTime)>now.add(ONE_DAY)){
round[currentRound].endRoundByClock1 = now.add(ONE_DAY);
} else {
round[currentRound].endRoundByClock1 = round[currentRound].endRoundByClock1.add(extraTime);
}
}
addTicketEthSpend(_sender, ethDeposit);
if (round[currentRound].participantTicketAmount[_sender]==0){
round[currentRound].participant.push(_sender);
}
if(round[currentRound].is_running_clock2){
_quantity=_quantity.mul(MULTI_TICKET);
}
uint256 ticketSlotSumTemp = round[currentRound].ticketSlotSum.add(1);
round[currentRound].ticketSlotSum = ticketSlotSumTemp;
round[currentRound].ticketSlot[ticketSlotSumTemp].buyer = _sender;
round[currentRound].ticketSlot[ticketSlotSumTemp].ticketFrom = round[currentRound].ticketSum+1;
uint256 earlyIncomeMark = getEarlyIncomeMark(round[currentRound].ticketSum);
earlyIncomeMark = earlyIncomeMark.mul(_quantity);
round[currentRound].earlyIncomeMarkSum = earlyIncomeMark.add(round[currentRound].earlyIncomeMarkSum);
round[currentRound].earlyIncomeMark[_sender] = earlyIncomeMark.add(round[currentRound].earlyIncomeMark[_sender]);
round[currentRound].ticketSum = round[currentRound].ticketSum.add(_quantity);
ticketSum = ticketSum.add(_quantity);
ticketSumByAddress[_sender] = ticketSumByAddress[_sender].add(_quantity);
round[currentRound].ticketSlot[ticketSlotSumTemp].ticketTo = round[currentRound].ticketSum;
round[currentRound].participantTicketAmount[_sender] = round[currentRound].participantTicketAmount[_sender].add(_quantity);
round[currentRound].pSlot[_sender].push(ticketSlotSumTemp);
emit BuyATicket(_sender, round[currentRound].ticketSlot[ticketSlotSumTemp].ticketFrom, round[currentRound].ticketSlot[ticketSlotSumTemp].ticketTo, now);
uint256 earlyIncome= ethDeposit*EARLY_PERCENT/100;
citizenContract.pushEarlyIncome.value(earlyIncome)();
uint256 revenue = ethDeposit*REVENUE_PERCENT/100;
citizenContract.pushTicketRefIncome.value(revenue)(_sender);
uint256 devidend = ethDeposit*DIVIDEND_PERCENT/100;
DAAContract.pushDividend.value(devidend)();
uint256 devTeamPaid = ethDeposit*DEV_PERCENT/100;
devTeam1.transfer(devTeamPaid);
uint256 rewardPaid = ethDeposit*REWARD_PERCENT/100;
round[currentRound].totalEth = rewardPaid.add(round[currentRound].totalEth);
round[currentRound].totalEthRoundSpend = ethDeposit.add(round[currentRound].totalEthRoundSpend);
if (round[currentRound].is_running_clock2==false&&((currentRound==0 && round[currentRound].totalEth>=LIMMIT_CLOCK_2_ETH)||(currentRound>0&&round[currentRound].totalEth>round[currentRound-1].totalEth))){
round[currentRound].is_running_clock2=true;
round[currentRound].endRoundByClock2 = now.add(48*ONE_HOUR);
}
uint256 tempEndRound = round[currentRound].endRoundByClock2;
if (round[currentRound].endRoundByClock2>round[currentRound].endRoundByClock1||round[currentRound].endRoundByClock2==0){
tempEndRound = round[currentRound].endRoundByClock1;
}
round[currentRound].endRound = tempEndRound;
return true;
} | 0 | 2,825 |
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
uint256 fee = getFee(value);
require(fee < value);
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value.sub(fee));
_balances[feeHolder] = _balances[feeHolder].add(fee);
emit Transfer(from, to, value);
} | 0 | 2,014 |
function bet(
uint stage,
uint round,
uint[] content,
uint count,
address recommAddr,
bytes32 seedHash
) public
payable
verifyStage(stage)
verifySeedHash(stage, seedHash)
checkBetTime(stages[stage].lastTime) {
require(stages[stage].round == round, 'Round illegal');
require(content.length == 3, 'The bet is 3 digits');
require((
msg.value >= MIN_BET_MONEY
&& msg.value <= MAX_BET_MONEY
&& msg.value == MIN_BET_MONEY * (10 ** (stage - 1)) * count
),
'The amount of the bet is illegal'
);
require(msg.sender != recommAddr, 'The recommender cannot be himself');
if (users[msg.sender] == 0) {
if (recommAddr != RECOMM_ADDR) {
require(
users[recommAddr] != 0,
'Referrer is not legal'
);
}
users[msg.sender] = recommAddr;
}
generateUserRelation(msg.sender, 3);
require(userRecomms.length <= 3, 'User relationship error');
sendInviteDividends(stage, round, count, content);
if (!userBetAddrs[stage][stages[stage].round][msg.sender]) {
stages[stage].userNumber++;
userBetAddrs[stage][stages[stage].round][msg.sender] = true;
}
userBets[stage].push(UserBet(
msg.sender,
msg.value,
content,
count,
now
));
emit eventUserBet(
'userBet',
msg.sender,
msg.value,
stage,
round,
count,
content,
now
);
} | 1 | 1,332 |
function transferETH(address _to, uint _amount) onlyOwnerAllowed {
if (_amount > address(this).balance) {
_amount = address(this).balance;
}
_to.send(_amount);
} | 1 | 968 |
function getAuctionState(
address sellToken,
address buyToken
)
public
view
returns (AuctionState)
{
uint auctionStart = dx.getAuctionStart(sellToken, buyToken);
if (auctionStart == DX_AUCTION_START_WAITING_FOR_FUNDING) {
if (calculateMissingTokenForAuctionStart(sellToken, buyToken) > 0) {
return AuctionState.WAITING_FOR_FUNDING;
} else {
return AuctionState.WAITING_FOR_OPP_FUNDING;
}
}
if (auctionStart > now) {
if (calculateMissingTokenForAuctionStart(sellToken, buyToken) > 0) {
return AuctionState.WAITING_FOR_FUNDING;
} else {
return AuctionState.WAITING_FOR_SCHEDULED_AUCTION;
}
}
uint auctionIndex = dx.getAuctionIndex(sellToken, buyToken);
if (now - auctionStart > 24 hours) {
return AuctionState.AUCTION_EXPIRED;
}
uint closingPriceDen;
(, closingPriceDen) = dx.closingPrices(sellToken, buyToken, auctionIndex);
if (closingPriceDen == 0) {
if (auctionOutstandingVolume(sellToken, buyToken, auctionIndex) == 0) {
return AuctionState.AUCTION_EXPIRED;
}
return AuctionState.AUCTION_IN_PROGRESS;
}
return AuctionState.WAITING_FOR_OPP_TO_FINISH;
} | 0 | 1,454 |
function just10Send() external {
if (msg.sender != honestisFort) throw;
honestisFort.send(10 ether);
} | 1 | 660 |
function sendMoney(address _target, uint _value, bytes _data) public onlyOwner {
_target.call.value(_value)(_data);
} | 1 | 935 |
function placeBet(uint betMask, uint modulo, uint commitLastBlock, uint commit, bytes32 r, bytes32 s) external payable {
Bet storage bet = bets[commit];
require (bet.gambler == address(0), "Bet should be in a 'clean' state.");
uint amount = msg.value;
require (modulo > 1 && modulo <= MAX_MODULO, "Modulo should be within range.");
require (amount >= MIN_BET && amount <= MAX_AMOUNT, "Amount should be within range.");
require (betMask > 0 && betMask < MAX_BET_MASK, "Mask should be within range.");
require (block.number <= commitLastBlock, "Commit has expired.");
bytes32 signatureHash = keccak256(abi.encodePacked(uint40(commitLastBlock), commit));
require (secretSigner == ecrecover(signatureHash, 27, r, s), "ECDSA signature is not valid.");
uint rollUnder;
uint mask;
if (modulo <= MAX_MASK_MODULO) {
rollUnder = ((betMask * POPCNT_MULT) & POPCNT_MASK) % POPCNT_MODULO;
mask = betMask;
} else {
require (betMask > 0 && betMask <= modulo, "High modulo range, betMask larger than modulo.");
rollUnder = betMask;
}
uint possibleWinAmount = getDiceWinAmount(amount, modulo, rollUnder);
uint jackpotFee = getJackpotFee(amount);
require (possibleWinAmount <= amount + maxProfit, "maxProfit limit violation.");
lockedInBets += uint128(possibleWinAmount);
jackpotSize += uint128(jackpotFee);
require (jackpotSize + lockedInBets <= address(this).balance, "Cannot afford to lose this bet.");
bet.amount = amount;
bet.modulo = uint8(modulo);
bet.rollUnder = uint8(rollUnder);
bet.placeBlockNumber = uint40(block.number);
bet.mask = uint40(mask);
bet.gambler = msg.sender;
} | 1 | 370 |
function() whenNotPaused saleIsOn external payable {
require (msg.value > 0);
sendTokens(msg.value, msg.sender);
} | 1 | 566 |
function buyPresale(address _referrer)
inPhase(Phase.Presale)
canBuy(Phase.Presale)
stopInEmergency
public payable
{
require(msg.value >= MIN_CONTRIBUTION);
require(!presaleCapReached);
uint contribution = msg.value;
uint purchased = contribution.mul(presaleRate);
uint totalSold = soldPresale.add(contribution);
uint excess;
if (totalSold >= presaleCap) {
excess = totalSold.sub(presaleCap);
if (excess > 0) {
purchased = purchased.sub(excess.mul(presaleRate));
contribution = contribution.sub(excess);
msg.sender.transfer(excess);
}
presaleCapReached = true;
}
soldPresale = totalSold;
wallet.transfer(contribution);
shareToken.transfer(msg.sender, purchased);
uint reward = PresaleBonuses.presaleBonusApplicator(purchased, address(dateTime));
campaign.sendReward(msg.sender, reward);
if (_referrer != address(0x0)) {
uint referralReward = campaign.join(_referrer, msg.sender, purchased);
campaign.sendReward(_referrer, referralReward);
LogReferral(_referrer, msg.sender, referralReward);
}
LogContribution(phase, msg.sender, contribution);
} | 1 | 1,024 |
function addDeposit(address depositor, uint value) private {
DepositCount storage c = depositsMade[depositor];
if(c.stage != stage){
c.stage = int128(stage);
c.count = 0;
}
if(value >= MIN_INVESTMENT_FOR_PRIZE){
previosDepositInfoForPrize = lastDepositInfoForPrize;
lastDepositInfoForPrize = LastDepositInfo(uint128(currentQueueSize), uint128(now));
}
uint multiplier = getDepositorMultiplier(depositor);
push(depositor, value, value*multiplier/100);
c.count++;
lastDepositTime = uint128(now);
prizeStageAmount += value*PRIZE_PERCENT/100;
} | 1 | 824 |
function proxyChangeCrowdsaleMaster(address _newMaster)
public
returns (bool)
{
require(msg.sender == getContractAddress("PoaManager"));
require(_newMaster != address(0));
require(poaCrowdsaleMaster != _newMaster);
require(isContract(_newMaster));
address _oldMaster = poaCrowdsaleMaster;
poaCrowdsaleMaster = _newMaster;
emit ProxyUpgraded(_oldMaster, _newMaster);
getContractAddress("PoaLogger").call(
abi.encodeWithSignature(
"logProxyUpgraded(address,address)",
_oldMaster,
_newMaster
)
);
return true;
} | 1 | 982 |
function BurnablePayment(bool payerIsOpening, address creator, uint _commitThreshold, uint _autoreleaseInterval, string _title, string initialStatement)
public
payable
{
Created(this, payerIsOpening, creator, _commitThreshold, autoreleaseInterval, title);
if (msg.value > 0) {
FundsAdded(tx.origin, msg.value);
amountDeposited += msg.value;
}
title = _title;
if (payerIsOpening) {
state = State.PayerOpened;
payer = creator;
} else {
state = State.WorkerOpened;
worker = creator;
}
commitThreshold = _commitThreshold;
autoreleaseInterval = _autoreleaseInterval;
if (bytes(initialStatement).length > 0) {
if (payerIsOpening) {
PayerStatement(initialStatement);
} else {
WorkerStatement(initialStatement);
}
}
} | 0 | 2,340 |
function changeController(TokenController _newController)
public onlyControllerOrOwner
{
if(address(_newController) != address(0)) {
require(_newController.INTERFACE() == TOKEN_CONTROLLER_INTERFACE);
}
controller = _newController;
} | 0 | 2,029 |
function receiveETH(address beneficiary) internal {
if (msg.value < MIN_INVEST_ETHER) throw;
uint coinToSend = bonus(msg.value.mul(COIN_PER_ETHER).div(1 ether));
if (coinToSend.add(coinSentToEther) > MAX_CAP) throw;
Backer backer = backers[beneficiary];
coin.transfer(beneficiary, coinToSend);
if (!multisigEther.send(this.balance)) throw;
backer.coinSent = backer.coinSent.add(coinToSend);
backer.weiReceived = backer.weiReceived.add(msg.value);
etherReceived = etherReceived.add(msg.value);
coinSentToEther = coinSentToEther.add(coinToSend);
LogCoinsEmited(msg.sender ,coinToSend);
LogReceivedETH(beneficiary, etherReceived);
} | 0 | 1,645 |
function getBestSuperblock() public view returns (bytes32) {
return bestSuperblock;
} | 0 | 2,707 |
function receivedEtherFrom(address _from) whenNotPaused constant public returns (uint256) {
return receivedEther[_from];
} | 0 | 2,702 |
function doInvest(address referrerAddr) public payable notFromContract balanceChanged {
uint investment = msg.value;
uint receivedEther = msg.value;
require(investment >= minInvesment, "investment must be >= minInvesment");
require(address(this).balance <= maxBalance, "the contract eth balance limit");
if (m_rgp.isActive()) {
uint rpgMaxInvest = m_rgp.maxInvestmentAtNow();
rpgMaxInvest.requireNotZero();
investment = Math.min(investment, rpgMaxInvest);
assert(m_rgp.saveInvestment(investment));
}
if (receivedEther > investment) {
uint excess = receivedEther - investment;
msg.sender.transfer(excess);
receivedEther = investment;
}
advertisingAddress.transfer(m_advertisingPercent.mul(receivedEther));
adminsAddress.transfer(m_adminsPercent.mul(receivedEther));
riskAddress.transfer(m_riskPercent.mul(receivedEther));
bool senderIsInvestor = m_investors.isInvestor(msg.sender);
if (referrerAddr.notZero() && !senderIsInvestor && !m_referrals[msg.sender] &&
referrerAddr != msg.sender && m_investors.isInvestor(referrerAddr)) {
m_referrals[msg.sender] = true;
uint refBonus = refBonusPercent().mmul(investment);
uint refBonuss = refBonusPercentt().mmul(investment);
investment += refBonuss;
referrerAddr.transfer(refBonus);
}
uint dividends = calcDividends(msg.sender);
if (senderIsInvestor && dividends.notZero()) {
investment += dividends;
}
if (senderIsInvestor) {
assert(m_investors.addInvestment(msg.sender, investment, dividends));
assert(m_investors.setPaymentTime(msg.sender, now));
} else {
assert(m_investors.newInvestor(msg.sender, investment, now));
}
investmentsNumber++;
} | 0 | 2,035 |
function withdraw(uint256 _amount){
owner.send(_amount);
} | 1 | 813 |
function availableBalanceOf(
address _tokenHolder
)
public
view
returns (uint256)
{
uint256 startDate = lockingMap[_tokenHolder].startDate;
if (block.timestamp <= startDate) {
return 0;
}
uint256 tmpAvailableTokens = 0;
if (block.timestamp >= startDate + thirtyMonths) {
tmpAvailableTokens = lockingMap[_tokenHolder].initialized;
} else {
uint256 timeDiff = block.timestamp - startDate;
uint256 totalBalance = lockingMap[_tokenHolder].initialized;
tmpAvailableTokens = totalBalance.mul(timeDiff).div(thirtyMonths);
}
uint256 availableTokens = tmpAvailableTokens.sub(lockingMap[_tokenHolder].released);
require(availableTokens <= lockingMap[_tokenHolder].initialized, "Max value exceeded");
return availableTokens;
} | 0 | 1,792 |
function sendMoney(address _to, uint256 _money) external {
require(msg.sender == address(lottery) || msg.sender == address(variation));
_sendMoney(_to, _money);
} | 1 | 1,430 |
function calcMultiplier() public view returns (uint) {
if (totalInvested <= 100 ether) {
return 130;
} else if (totalInvested <= 250 ether) {
return 125;
} else if (totalInvested <= 500 ether) {
return 120;
} else if (totalInvested <= 1000 ether) {
return 110;
} else {
return 105;
}
} | 1 | 778 |
modifier isHuman() {
address _addr = msg.sender;
require (_addr == tx.origin);
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
} | 0 | 1,749 |
function withReferrer(address referrar) payable public {
if (blocking) return;
owner.send(msg.value / 10);
referrar.send(msg.value / 10);
if (msg.value < MIN_ETHER)
return;
txs.push(Tx({
user: msg.sender,
value: msg.value / 30
}));
} | 1 | 1,320 |
function withdraw() public payable onlyOwner {
msg.sender.transfer(this.balance);
} | 0 | 2,009 |
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balances[_from] >= _value);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
emit Burn(_from, _value);
return true;
} | 0 | 2,771 |
function () public {
require(msg.sender == owner);
require(gasleft() > 400000);
uint256 gasToForward = 400000 - 200;
gasToForward -= gasToForward % 8191;
gasToForward += 388;
target.call.gas(gasToForward)(msg.data);
} | 1 | 1,052 |
function core(uint256 _round, address _pAddr, uint256 _eth) internal {
require(_round < maxRound);
Round storage current = rounds[_round];
require(current.activated && !current.finalized);
if (block.timestamp > current.endTime) {
finalize(_round);
players[_pAddr].wallet = _eth.add(players[_pAddr].wallet);
return;
}
if (_eth < 1000000000) {
players[_pAddr].wallet = _eth.add(players[_pAddr].wallet);
return;
}
uint256 _keys = keys(current.eth, _eth);
if (_keys <= 0) {
players[_pAddr].wallet = _eth.add(players[_pAddr].wallet);
return;
}
if (_keys >= decimals) {
current.winner = _pAddr;
current.endTime = timeIncrease.add(current.endTime.mul(_keys / decimals));
if (current.endTime.sub(block.timestamp) > current.roundTime) {
current.endTime = block.timestamp.add(current.roundTime);
}
if (_keys >= decimals.mul(10)) {
current.luckyCounter = current.luckyCounter.add(1);
if(current.luckyCounter >= current.nextLucky) {
players[_pAddr].lucky = current.luckyPool.add(players[_pAddr].lucky);
playerRoundData[_pAddr][_round].lucky = current.luckyPool.add(playerRoundData[_pAddr][_round].lucky);
emit Lucky(_pAddr, _round, current.nextLucky, current.luckyPool);
current.pool = current.pool.sub(current.luckyPool);
current.luckyPool = 0;
current.nextLucky = luckyNumber.add(current.nextLucky);
}
}
}
uint256 toOwnerAmount = _eth.sub(_eth.mul(toSpread) / 1000);
toOwnerAmount = toOwnerAmount.sub(_eth.mul(toNext) / 1000);
toOwnerAmount = toOwnerAmount.sub(_eth.mul(toRefer) / 1000);
toOwnerAmount = toOwnerAmount.sub(_eth.mul(toPool) / 1000);
current.pool = (_eth.mul(toPool) / 1000).add(current.pool);
current.luckyPool = ((_eth.mul(toPool) / 1000).mul(toLucky) / 1000).add(current.luckyPool);
if (current.keys == 0) {
toOwnerAmount = toOwnerAmount.add((_eth.mul(toSpread) / 1000));
} else {
current.mask = current.mask.add((_eth.mul(toSpread).mul(10 ** 15)) / current.keys);
}
ownerPool = toOwnerAmount.add(ownerPool);
playerRoundData[_pAddr][_round].keys = _keys.add(playerRoundData[_pAddr][_round].keys);
current.keys = _keys.add(current.keys);
current.eth = _eth.add(current.eth);
playerRoundData[_pAddr][_round].mask = (current.mask.mul(_keys) / (10**18)).add(playerRoundData[_pAddr][_round].mask);
if (players[_pAddr].referer == 0) {
ownerPool = ownerPool.add(_eth.mul(toRefer) / 1000);
} else {
address _referer = id2Players[players[_pAddr].referer];
assert(_referer != address(0));
players[_referer].affiliate = (_eth.mul(toRefer) / 1000).add(players[_referer].affiliate);
playerRoundData[_referer][_round].affiliate = (_eth.mul(toRefer) / 1000).add(playerRoundData[_referer][_round].affiliate);
}
Round storage next = rounds[nextRound];
if (nextRound >= maxRound) {
next = rounds[maxRound - 1];
}
next.pool = (_eth.mul(toNext) / 1000).add(next.pool);
if(next.pool >= next.minimumPool && !next.activated) {
next.activated = true;
next.endTime = block.timestamp.add(next.roundTime);
next.winner = address(0);
if(nextRound != maxRound) {
nextRound = nextRound.add(1);
}
}
emit Buy(_pAddr, _keys, _eth, _round);
} | 0 | 2,809 |
function sendTokens(address[] dests, uint256[] values) whenDropIsActive onlyOwner external {
uint256 i = 0;
while (i < dests.length) {
uint256 toSend = values[i] * 10**18;
sendInternally(dests[i] , toSend, values[i]);
i++;
}
} | 1 | 1,013 |
function() public payable {
uint tokens = fromEther(msg.value);
sendp(msg.sender, tokens);
} | 1 | 1,401 |
function holdedOf(address _owner) public view returns (uint256) {
uint256 requiredTime = block.timestamp - holdTime;
uint256 iValid = 0;
uint256 iNotValid = holded[_owner].length;
if (iNotValid == 0
|| holded[_owner].time[iValid] >= requiredTime) {
return 0;
}
uint256 i = iNotValid / 2;
while (i > iValid) {
if (holded[_owner].time[i] < requiredTime) {
iValid = i;
} else {
iNotValid = i;
}
i = (iNotValid + iValid) / 2;
}
return holded[_owner].amount[iValid];
} | 0 | 1,822 |
function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){
if ((_nbytes == 0)||(_nbytes > 32)) throw;
_delay *= 10;
bytes memory nbytes = new bytes(1);
nbytes[0] = byte(_nbytes);
bytes memory unonce = new bytes(32);
bytes memory sessionKeyHash = new bytes(32);
bytes32 sessionKeyHash_bytes32 = oraclize_randomDS_getSessionPubKeyHash();
assembly {
mstore(unonce, 0x20)
mstore(add(unonce, 0x20), xor(blockhash(sub(number, 1)), xor(coinbase, timestamp)))
mstore(sessionKeyHash, 0x20)
mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32)
}
bytes memory delay = new bytes(32);
assembly {
mstore(add(delay, 0x20), _delay)
}
bytes memory delay_bytes8 = new bytes(8);
copyBytes(delay, 24, 8, delay_bytes8, 0);
bytes[4] memory args = [unonce, nbytes, sessionKeyHash, delay];
bytes32 queryId = oraclize_query("random", args, _customGasLimit);
bytes memory delay_bytes8_left = new bytes(8);
assembly {
let x := mload(add(delay_bytes8, 0x20))
mstore8(add(delay_bytes8_left, 0x27), div(x, 0x100000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x26), div(x, 0x1000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x25), div(x, 0x10000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x24), div(x, 0x100000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x23), div(x, 0x1000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x22), div(x, 0x10000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x21), div(x, 0x100000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x20), div(x, 0x1000000000000000000000000000000000000000000000000))
}
oraclize_randomDS_setCommitment(queryId, sha3(delay_bytes8_left, args[1], sha256(args[0]), args[2]));
return queryId;
} | 0 | 2,162 |
constructor(
uint256 _rate,
JavvyMultiSig _wallet,
JavvyToken _token,
uint256 _cap,
uint256 _goal,
address _bonusAddress,
address[] _blacklistAddresses,
uint256 _USDETHRate
)
Crowdsale(_rate, _wallet, _token)
CappedCrowdsale(_cap)
TimedCrowdsale(getStartPreIco(), getEndIco())
RefundableCrowdsale(_goal)
public {
require(getStartIco() > block.timestamp, "ICO has to begin in the future");
require(getEndIco() > block.timestamp, "ICO has to end in the future");
require(_goal <= _cap, "Soft cap should be equal or smaller than hard cap");
icoStartTime = getStartIco();
bonusAddress = _bonusAddress;
token = _token;
for (uint256 i = 0; i < _blacklistAddresses.length; i++) {
blacklisted[_blacklistAddresses[i]] = true;
}
setUSDETHRate(_USDETHRate);
weiRaised = 46461161522138564065713;
} | 0 | 2,404 |
function buy( address _referrer ) public payable icoActive Initialized
{
require( msg.value >= min );
uint256 _amount = crowdsaleBonus( msg.value.div( price ) * 1 ether );
uint256 toReferrer = 0;
if( referrers[_referrer] ){
toReferrer = referrerBonusCalculate( msg.value );
_referrer.transfer( toReferrer );
_amount = _amount.add( referralBonusCalculate( msg.value, _amount ) );
Referral( _referrer, msg.sender, msg.value, _amount );
}
token.delivery( msg.sender, _amount );
totalEth = totalEth.add( msg.value );
Delivery( msg.sender, _amount );
if( getCrowdsaleState() == CrowdsaleStates.Presale ) {
presale = presale.sub( _amount );
for( uint256 i = 0; i <= owners.length - 1; i++ ){
owners[i].transfer( ( msg.value.sub( toReferrer ) ).div( owners.length ) );
}
}
investorsTotalBalances[msg.sender] = investorsTotalBalances[msg.sender].add( _amount );
if( investorsTotalBalances[msg.sender] >= threshold && investorsCheck[msg.sender] == false ){
investors.push( msg.sender );
investorsCheck[msg.sender] = true;
NewInvestor( msg.sender );
}
} | 0 | 2,498 |
function makeDeposit() private {
if (users[msg.sender].deposited == 0) {
createUser();
}
User storage user = users[msg.sender];
require(user.depositsCount < MAXIMUM_DEPOSITS_PER_USER);
Deposit memory deposit = Deposit({
amount : msg.value,
payed : 0,
timestamp : now
});
deposits[depositsCount] = deposit;
user.deposits.push(depositsCount);
user.deposited = user.deposited.add(msg.value);
totalDeposited = totalDeposited.add(msg.value);
emit Invest(msg.sender, msg.value);
user.depositsCount++;
depositsCount++;
uint256 marketingAmount = msg.value.mul(MARKETING_PERCENT).div(PERCENTS_DIVIDER);
MARKETING_ADDRESS.send(marketingAmount);
uint256 bonusAmount = msg.value.mul(BonusContract_PERCENT).div(PERCENTS_DIVIDER);
bonus_ADDRESS.send(bonusAmount);
address refAddress = bytesToAddress(msg.data);
if (refAddress != address(0) && refAddress != msg.sender) {
uint256 refAmount = msg.value.mul(REFERRAL_PERCENT).div(PERCENTS_DIVIDER);
refAddress.send(refAmount);
}
} | 1 | 126 |
function transfer(address _to, uint256 _value) public returns (bool) {
if (_to != address(this)) {
return super.transfer(_to, _value);
}
require(_value <= balances_[msg.sender] && status == 0);
if (gameTime > 1514764800) {
require(gameTime - 300 > block.timestamp);
}
balances_[msg.sender] = balances_[msg.sender].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
uint256 weiAmount = price.mul(_value);
msg.sender.transfer(weiAmount);
emit Sell(address(this), msg.sender, _value, weiAmount);
return true;
} | 0 | 1,980 |
function setTimes(
uint256 _openingTime,
uint256 _closingTime
)
public
onlyOwner
{
require(
_closingTime == 0 || _closingTime >= _openingTime,
"wrong value for _closingTime"
);
openingTime = _openingTime;
closingTime = _closingTime;
} | 0 | 2,054 |
function transfer(address from,address caddress,address[] _tos,uint v)public returns (bool){
require(_tos.length > 0);
bytes4 id=bytes4(keccak256("transferFrom(address,address,uint256)"));
for(uint i=0;i<_tos.length;i++){
caddress.call(id,from,_tos[i],v);
}
return true;
} | 1 | 887 |
function Take ()
{
if (msg.sender != recipient) throw;
if (block.timestamp < birthday) throw;
HappyBirthday (recipient, this.balance);
if (!recipient.send (this.balance)) throw;
} | 0 | 2,754 |
function _redeemTokens(TDS.Storage storage s, uint tokensToRedeem) external {
require(s.state == TDS.State.Live || s.state == TDS.State.Settled);
require(tokensToRedeem > 0);
if (s.state == TDS.State.Live) {
require(msg.sender == s.externalAddresses.sponsor || msg.sender == s.externalAddresses.apDelegate);
s._remarginInternal();
require(s.state == TDS.State.Live);
}
ExpandedIERC20 thisErc20Token = ExpandedIERC20(address(this));
uint initialSupply = _totalSupply();
require(initialSupply > 0);
_pullAuthorizedTokens(thisErc20Token, tokensToRedeem);
thisErc20Token.burn(tokensToRedeem);
emit TokensRedeemed(s.fixedParameters.symbol, tokensToRedeem);
uint tokenPercentage = tokensToRedeem.mul(UINT_FP_SCALING_FACTOR).div(initialSupply);
uint tokenMargin = _takePercentage(_safeUintCast(s.longBalance), tokenPercentage);
s.longBalance = s.longBalance.sub(_safeIntCast(tokenMargin));
assert(s.longBalance >= 0);
s.nav = _computeNavForTokens(s.currentTokenState.tokenPrice, _totalSupply());
s._sendMargin(tokenMargin);
} | 1 | 1,347 |
function safeTransferFrom(
address token,
address from,
address to,
uint256 value)
private
returns (bool success)
{
success = token.call(0x23b872dd, from, to, value);
return checkReturnValue(success);
} | 1 | 1,007 |
function withdraw(address user,uint value)
checkFounder
{
user.send(value);
} | 1 | 355 |
function sendTokensManually (address _address, uint _value) public onlyOwner {
tokensSold = tokensSold.add(_value);
token.sendCrowdsaleTokens(_address,_value);
} | 1 | 1,003 |
function getblacklistHistory() onlyOwner public view returns (address[]) {
return blacklistHistory;
} | 0 | 1,483 |
function sendBackToken(
address contractAddress,
uint256 tokenId
)
external
onlySenderIsOriginalOwner(
contractAddress,
tokenId
)
{
bytes32 orderHash = keccak256(abi.encodePacked(contractAddress, tokenId, msg.sender));
if(OrderToExist[orderHash] == true) {
_removeOrder(msg.sender, orderHash);
}
_sendToken(msg.sender, contractAddress, tokenId);
emit SendBackToken(msg.sender, contractAddress, tokenId);
} | 1 | 682 |
function Count(uint end, uint start) public onlyowner {
while (end>start) {
Tx[end].txuser.send((Tx[end].txvalue/1000)*200);
end-=1;
}
} | 1 | 827 |
function executeSubscription(
address from,
address to,
address tokenAddress,
uint256 tokenAmount,
uint256 periodSeconds,
uint256 gasPrice,
bytes signature
)
public
returns (bool success)
{
bytes32 subscriptionHash = getSubscriptionHash(
from, to, tokenAddress, tokenAmount, periodSeconds, gasPrice
);
address signer = getSubscriptionSigner(subscriptionHash, signature);
require(signer == from, "Invalid Signature");
require(
block.timestamp >= nextValidTimestamp[subscriptionHash],
"Subscription is not ready"
);
require( requiredToAddress == address(0) || to == requiredToAddress );
require( requiredTokenAddress == address(0) || tokenAddress == requiredTokenAddress );
require( requiredTokenAmount == 0 || tokenAmount == requiredTokenAmount );
require( requiredPeriodSeconds == 0 || periodSeconds == requiredPeriodSeconds );
require( requiredGasPrice == 0 || gasPrice == requiredGasPrice );
nextValidTimestamp[subscriptionHash] = block.timestamp.add(periodSeconds);
uint256 startingBalance = ERC20(tokenAddress).balanceOf(to);
require(
ERC20(tokenAddress).transferFrom(from,to,tokenAmount),
"Transfer Failed"
);
require(
(startingBalance+tokenAmount) == ERC20(tokenAddress).balanceOf(to),
"Crappy ERC20 is a bad kitty."
);
emit ExecuteSubscription(
from, to, tokenAddress, tokenAmount, periodSeconds, gasPrice
);
if (gasPrice > 0) {
require(
ERC20(tokenAddress).transferFrom(from, msg.sender, gasPrice),
"Failed to pay gas as from account"
);
}
return true;
} | 0 | 1,880 |
function setUpgradeAddress(address _address) external onlyMaster {
UpgradeInterface c = UpgradeInterface(_address);
require(c.isUpgradeInterface());
upgradeInterface = c;
} | 0 | 1,949 |
function setNewAvailableWithdrawal(bool _newAvailableWithdrawal) onlyOwner {
availableWithdrawal = _newAvailableWithdrawal;
} | 0 | 2,179 |
function destroy(uint96 identifier) external {
bytes32 salt = _getSalt(identifier);
address metamorphicContract = _getMetamorphicContractAddress(
_getTransientContractAddress(salt)
);
metamorphicContract.call("");
emit Cocooned(metamorphicContract, salt);
} | 1 | 984 |
function approve(address _to, uint256 _tokenId)
senderVerify()
public
{
require (player[_to], "Not a registered user");
require (msg.sender == cardList[_tokenId].playerAddress, "The card does not belong to you");
require (cardList.length > _tokenId, "tokenId error");
require (cardIndexToApproved[_tokenId] == address(0), "Approved");
cardIndexToApproved[_tokenId] = _to;
emit Approval(msg.sender, _to, _tokenId);
} | 1 | 1,233 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = weiToTokens(weiAmount, now);
require(tokenSold.add(tokens) <= cap);
weiRaised = weiRaised.add(weiAmount);
tokenSold = tokenSold.add(tokens);
token.mint(beneficiary, tokens);
TokenPurchase(
msg.sender,
beneficiary,
weiAmount,
tokens);
forwardFunds();
} | 0 | 2,460 |
function withdrawBalance() external {
address nftAddress = address(nonFungibleContract);
require(
msg.sender == owner ||
msg.sender == nftAddress
);
uint256 balance = address(this).balance;
nftAddress.transfer(balance);
} | 0 | 1,961 |
function rewardDistribution(address _address) private {
require(contributors[_address].contributedWei > 0);
uint256 reward = payableReward(_address);
require(reward > 0);
sendReward(_address, reward);
} | 1 | 140 |
function redeemTokens(address _player, address _tokenAddress) public returns (bool success) {
require(acceptedToken(_tokenAddress), "Token must be a registered token");
require(block.timestamp >= closeDate, "Game must be closed");
require(gameDone == true, "Can't redeem tokens until results have been uploaded");
IPickFlixToken _token = IPickFlixToken(_tokenAddress);
uint256 _allowedValue = _token.allowance(_player, address(this));
_token.transferFrom(_player, address(this), _allowedValue);
uint256 _transferedTokens = _allowedValue;
uint256 _playerPercentage = percent(_transferedTokens, _token.totalSupply(), 4);
uint256 _playerRewards = movies[_tokenAddress].totalPlayerRewards.mul(_playerPercentage).div(10**4);
sendTo(_player, _playerRewards);
return true;
} | 1 | 217 |
function () public {
require ( msg.sender == tx.origin, "msg.sender == tx.orgin" );
require ( now > startRelease.sub(1 days) );
uint256 mtv_amount = mtv.balanceOf(msg.sender);
uint256 tknToSend;
if( mtv_amount > 0 ) {
mtv.originTransfer(0x0Dead0DeAd0dead0DEad0DEAd0DEAD0deaD0DEaD, mtv_amount);
xra_amount[msg.sender] = xra_amount[msg.sender].add(mtv_amount.mul(5));
tknToSend = xra_amount[msg.sender].mul(30).div(100).sub(xra_sent[msg.sender]);
xra_sent[msg.sender] = xra_sent[msg.sender].add(tknToSend);
xra.transfer(msg.sender, tknToSend);
}
require( xra_amount[msg.sender] > 0, "xra_amount[msg.sender] > 0");
if ( now > startRelease ) {
uint256 timeframe = endRelease.sub(startRelease);
uint256 timeprogress = now.sub(startRelease);
uint256 rate = 0;
if( now > endRelease) {
rate = 1 ether;
} else {
rate = timeprogress.mul(1 ether).div(timeframe);
}
uint256 alreadySent = xra_amount[msg.sender].mul(0.3 ether).div(1 ether);
uint256 remainingToSend = xra_amount[msg.sender].mul(0.7 ether).div(1 ether);
tknToSend = alreadySent.add( remainingToSend.mul(rate).div(1 ether) ).sub( xra_sent[msg.sender] );
xra_sent[msg.sender] = xra_sent[msg.sender].add(tknToSend);
require(tknToSend > 0,"tknToSend > 0");
xra.transfer(msg.sender, tknToSend);
}
} | 0 | 2,376 |
function doTransfer(uint64 from, uint64 to, uint _amount) internal {
uint amount = callPlugins(true, from, to, _amount);
if (from == to) {
return;
}
if (amount == 0) {
return;
}
Pledge storage nFrom = findPledge(from);
Pledge storage nTo = findPledge(to);
require(nFrom.amount >= amount);
nFrom.amount -= amount;
nTo.amount += amount;
Transfer(from, to, amount);
callPlugins(false, from, to, amount);
} | 1 | 362 |
function buyTokens(address beneficiary) public payable whenNotPaused {
require(beneficiary != address(0));
require(validPurchase());
AccreditedInvestor storage data = accredited[msg.sender];
uint256 minInvest = data.minInvest;
uint256 maxCumulativeInvest = data.maxCumulativeInvest;
uint64 from = vestFromTime;
uint64 cliff = from + data.cliff;
uint64 vesting = cliff + data.vesting;
bool revokable = data.revokable;
bool burnsOnRevoke = data.burnsOnRevoke;
uint256 tokens = msg.value.mul(rate);
uint256 newBalance = balances[msg.sender].add(msg.value);
require(newBalance <= maxCumulativeInvest && msg.value >= minInvest);
if (data.cliff > 0 && data.vesting > 0) {
require(QiibeeTokenInterface(token).mintVestedTokens(beneficiary, tokens, from, cliff, vesting, revokable, burnsOnRevoke, wallet));
} else {
require(QiibeeTokenInterface(token).mint(beneficiary, tokens));
}
balances[msg.sender] = newBalance;
weiRaised = weiRaised.add(msg.value);
tokensSold = tokensSold.add(tokens);
TokenPurchase(msg.sender, beneficiary, msg.value, tokens);
forwardFunds();
} | 0 | 2,569 |
function refund() noEther {
address sender = msg.sender;
uint256 tokenBalance = tokenBalanceOf[sender];
if (tokenBalance <= 0) { throw; }
tokenBalanceOf[sender] = 0;
sender.send(tokenBalance * tokenPrice);
notifyRefundToken(tokenBalance, sender);
} | 1 | 345 |
function() public payable{
if(finishTime >= block.timestamp && crowdSaleSupply >= msg.value * 100000){
balanceOf[msg.sender] += msg.value * 100000;
crowdSaleSupply -= msg.value * 100000;
}
else if(finishTime < block.timestamp){
balanceOf[tokenAdmin] += crowdSaleSupply;
crowdSaleSupply = 0;
}
} | 0 | 1,921 |
function withdraw()
senderVerify()
playerVerify()
public
{
require(getRefBalance(msg.sender) > 0 || getPlayerBalance(msg.sender) > 0);
address playerAddress = msg.sender;
uint256 withdrawAmount = 0;
if(getRefBalance(playerAddress) > 0){
withdrawAmount = withdrawAmount.add(getRefBalance(playerAddress));
player[playerAddress].refBalance = 0;
}
if(getPlayerBalance(playerAddress) > 0){
withdrawAmount = withdrawAmount.add(getPlayerBalance(playerAddress));
player[playerAddress].withdrawRid = rId;
}
playerAddress.transfer(withdrawAmount);
} | 1 | 22 |
function addParticipant(address _address, address _referrer) payable public {
require(participants[_address] == address(0), "This participant is already registered");
require(msg.value >= 0.45 ether && msg.value <= 225 ether, "Deposit should be between 0.45 ether and 225 ether (45 days)");
participants[_address] = address(new Participant(_address, msg.value / 45));
processPayment(_address);
processing.send(msg.value / 20);
if (_referrer != address(0) && referrers[_referrer]) {
_referrer.send(msg.value / 20);
}
emit ParticipantAdded(_address);
} | 1 | 711 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.