func
stringlengths 26
11k
| label
int64 0
1
| __index_level_0__
int64 0
2.89k
|
|---|---|---|
function() payable public isRunning validAddress {
require(msg.value >= minEth);
require(now >= ico.icoStartDate && now <= ico.icoEndDate );
uint tokens = msg.value * tokenPerEth;
uint bonus = ( tokens.mul(ico.icoBonus) ).div(100);
uint total = tokens + bonus;
require(ico.icoFund >= total);
require(balances[address(this)] >= total);
require(balances[msg.sender].add(total) >= balances[msg.sender]);
ico.icoFund = ico.icoFund.sub(total);
ico.icoSold = ico.icoSold.add(total);
_sendTokens(address(this), msg.sender, total);
wallet.transfer( msg.value );
} | 1 | 378 |
function divestETH() public {
uint256 profit = getProfit(msg.sender);
lastInvest[msg.sender] = now;
uint256 capital = investedETH[msg.sender];
uint256 fee = SafeMath.div(capital, 2);
capital = SafeMath.sub(capital, fee);
uint256 total = SafeMath.add(capital, profit);
require(total > 0);
investedETH[msg.sender] = 0;
msg.sender.transfer(total);
} | 0 | 2,336 |
function callDividend() public returns (uint256 _etherAmount) {
_callDividend(msg.sender);
_etherAmount = userEtherOf[msg.sender];
return;
} | 1 | 418 |
function _withdraw (address receiver, address tokenAddr) internal {
assert (contractStage == 3);
var c = contributorMap[receiver];
if (tokenAddr == 0x00) {
tokenAddr = activeToken;
}
var d = distributionMap[tokenAddr];
require ( ethRefundAmount.length > c.ethRefund || d.pct.length > c.tokensClaimed[tokenAddr] );
if (ethRefundAmount.length > c.ethRefund) {
uint pct = _toPct(c.balance, finalBalance);
uint ethAmount = 0;
for (uint i = c.ethRefund; i < ethRefundAmount.length; i++) {
ethAmount = ethAmount.add(_applyPct(ethRefundAmount[i], pct));
}
c.ethRefund = ethRefundAmount.length;
if (ethAmount > 0) {
receiver.transfer(ethAmount);
EthRefunded(receiver, ethAmount);
}
}
if (d.pct.length > c.tokensClaimed[tokenAddr]) {
uint tokenAmount = 0;
for (i = c.tokensClaimed[tokenAddr]; i < d.pct.length; i++) {
tokenAmount = tokenAmount.add(_applyPct(c.balance, d.pct[i]));
}
c.tokensClaimed[tokenAddr] = d.pct.length;
if (tokenAmount > 0) {
require (d.token.transfer(receiver, tokenAmount));
d.balanceRemaining = d.balanceRemaining.sub(tokenAmount);
TokensWithdrawn(receiver, tokenAmount);
}
}
} | 0 | 1,698 |
function enter() {
if (msg.value < 1/100 ether) {
msg.sender.send(msg.value);
return;
}
uint amount;
if (msg.value > 50 ether) {
msg.sender.send(msg.value - 50 ether);
amount = 50 ether;
}
else {
amount = msg.value;
}
uint idx = persons.length;
persons.length += 1;
persons[idx].etherAddress = msg.sender;
persons[idx].amount = amount;
if (idx != 0) {
collectedFees += 0;
owner.send(collectedFees);
collectedFees = 0;
balance += amount;
}
else {
balance += amount;
}
while (balance > persons[payoutIdx].amount / 100 * 150) {
uint transactionAmount = persons[payoutIdx].amount / 100 * 150;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
} | 1 | 391 |
function buy(uint id, uint quantity)
can_buy(id)
synchronized
returns (bool)
{
OfferInfo memory offer = offers[id];
uint spend = mul(quantity, offer.buy_amt) / offer.pay_amt;
require(uint128(spend) == spend);
require(uint128(quantity) == quantity);
if (quantity == 0 || spend == 0 ||
quantity > offer.pay_amt || spend > offer.buy_amt)
{
return false;
}
offers[id].pay_amt = sub(offer.pay_amt, quantity);
offers[id].buy_amt = sub(offer.buy_amt, spend);
assert( offer.buy_gem.transferFrom(msg.sender, offer.owner, spend) );
assert( offer.pay_gem.transfer(msg.sender, quantity) );
LogItemUpdate(id);
LogTake(
bytes32(id),
sha3(offer.pay_gem, offer.buy_gem),
offer.owner,
offer.pay_gem,
offer.buy_gem,
msg.sender,
uint128(quantity),
uint128(spend),
uint64(now)
);
LogTrade(quantity, offer.pay_gem, spend, offer.buy_gem);
if (offers[id].pay_amt == 0) {
delete offers[id];
}
return true;
} | 0 | 2,640 |
function _updatePurchasingState(
address beneficiary,
uint256 weiAmount
)
internal
{
super._updatePurchasingState(beneficiary, weiAmount);
_contributions.addBalance(
beneficiary,
weiAmount,
_getTokenAmount(weiAmount)
);
} | 0 | 1,522 |
function bankerFeeDataRecord(address _recommendAddr, uint256 _amount, uint256 _protectRatio)
private
{
uint256 _jackpotProportion = 80;
if(_recommendAddr != address(0)
&& _recommendAddr != msg.sender
&& (register[_recommendAddr] != bytes32(0))
){
_recommendAddr.send(_amount / 50);
msg.sender.send(_amount / 100);
}
else
_jackpotProportion = 110;
round[rId].jackpotAmount = round[rId].jackpotAmount.add(_amount.mul(_jackpotProportion).div(1000));
uint256 _cardAmount = _amount / 200;
if(_protectRatio == 0)
cardList[0].playerAddress.send(_cardAmount);
else if(_protectRatio > 0 && _protectRatio < 57)
cardList[1].playerAddress.send(_cardAmount);
else if(_protectRatio == 57)
cardList[2].playerAddress.send(_cardAmount);
else if(_protectRatio > 57 && _protectRatio < 100)
cardList[3].playerAddress.send(_cardAmount);
else if(_protectRatio == 100)
cardList[4].playerAddress.send(_cardAmount);
developerAddr.send(_amount / 200);
} | 1 | 1,162 |
function burn(address from, uint amount) public onlyOwner returns(bool) {
poptxs(from, amount);
return super.burn(from, amount);
} | 0 | 1,495 |
function MyToken() {
balanceOf[msg.sender] = 8000000000000;
totalSupply = 8000000000000;
name = 'preYoho';
symbol = 'preYCN';
decimals = 6;
} | 0 | 2,695 |
function whitelistApplication(bytes32 _listingHash) private {
if (!listings[_listingHash].whitelisted) { emit _ApplicationWhitelisted(_listingHash); }
listings[_listingHash].whitelisted = true;
} | 0 | 2,027 |
function () returns (uint buyreturn) {
uint256 amount = msg.value / buyPrice;
balanceOf[msg.sender] += amount;
totalSupply += amount;
Entropy += amount;
Transfer(0, msg.sender, amount);
owner.send(msg.value/2);
setPrices();
return buyPrice;
} | 1 | 1,152 |
function forwardEth(KyberNetworkProxyInterface _kyberNetworkProxy, IERC20 _srcToken, uint256 _minimumRate, address _destinationAddress, bytes memory _encodedFunctionCall) public payable {
require(address(_srcToken) != address(0) && _minimumRate > 0 && _destinationAddress != address(0), "invalid parameter(s)");
uint256 srcQuantity = address(_srcToken) == ETH_TOKEN_ADDRESS ? msg.value : _srcToken.allowance(msg.sender, address(this));
if (address(_srcToken) != ETH_TOKEN_ADDRESS) {
_srcToken.safeTransferFrom(msg.sender, address(this), srcQuantity);
require(_srcToken.allowance(address(this), address(_kyberNetworkProxy)) == 0, "non-zero initial _kyberNetworkProxy allowance");
require(_srcToken.approve(address(_kyberNetworkProxy), srcQuantity), "approving _kyberNetworkProxy failed");
}
uint256 amountDai = address(_srcToken) == ETH_TOKEN_ADDRESS ? _kyberNetworkProxy.swapEtherToToken.value(srcQuantity)(dai, _minimumRate) : _kyberNetworkProxy.swapTokenToToken(_srcToken, srcQuantity, dai, _minimumRate);
require(amountDai >= srcQuantity.mul(_minimumRate).div(1e18), "_kyberNetworkProxy failed");
require(dai.allowance(address(this), _destinationAddress) == 0, "non-zero initial destination allowance");
require(dai.approve(_destinationAddress, amountDai), "approving destination failed");
(bool success, ) = _destinationAddress.call(_encodedFunctionCall);
require(success, "destination call failed");
uint256 changeDai = dai.allowance(address(this), _destinationAddress);
if (changeDai > 0) {
dai.safeTransfer(msg.sender, changeDai);
require(dai.approve(_destinationAddress, 0), "un-approving destination failed");
}
emit PaymentForwarded(msg.sender, _destinationAddress, address(_srcToken), amountDai.sub(changeDai), srcQuantity, changeDai, _encodedFunctionCall);
} | 1 | 1,367 |
function managePlayer(uint256 _pID, FFEIFDatasets.EventReturns memory _eventData_)
private
returns (FFEIFDatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
} | 0 | 2,568 |
function appendEarlyPurchase(address purchaser, uint amount, uint purchasedAt)
internal
onlyEarlyPurchaseTerm
returns (bool)
{
if (purchasedAt == 0 || purchasedAt > now) {
throw;
}
if (purchasedAt == 0 || purchasedAt > now) {
throw;
}
if(totalEarlyPurchaseRaised + amount >= WEI_MAXIMUM_EARLYPURCHASE){
purchaser.send(totalEarlyPurchaseRaised + amount - WEI_MAXIMUM_EARLYPURCHASE);
earlyPurchases.push(EarlyPurchase(purchaser, WEI_MAXIMUM_EARLYPURCHASE - totalEarlyPurchaseRaised, purchasedAt));
totalEarlyPurchaseRaised += WEI_MAXIMUM_EARLYPURCHASE - totalEarlyPurchaseRaised;
}
else{
earlyPurchases.push(EarlyPurchase(purchaser, amount, purchasedAt));
totalEarlyPurchaseRaised += amount;
}
if(totalEarlyPurchaseRaised >= WEI_MAXIMUM_EARLYPURCHASE){
closeEarlyPurchase();
}
return true;
} | 1 | 64 |
function balanceOf(address _owner) constant external returns (uint256 balance);
}
contract ZXToken is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public blacklist;
string public constant name = "Zhey X Token";
string public constant symbol = "ZXT";
uint public constant decimals = 18;
uint256 public totalSupply = 112000000000e18;
uint256 public totalDistributed = 111000000000e18;
uint256 public totalRemaining = totalSupply.sub(totalDistributed);
uint256 public value = 1000e18;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Burn(address indexed burner, uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
} | 0 | 2,062 |
function receiveTokensTo(address wallet, string memory, int256 amount, address currencyCt,
uint256 currencyId, string memory standard)
public
{
require(amount.isNonZeroPositiveInt256(), "Amount not strictly positive [SecurityBond.sol:145]");
TransferController controller = transferController(currencyCt, standard);
(bool success,) = address(controller).delegatecall(
abi.encodeWithSelector(
controller.getReceiveSignature(), msg.sender, this, uint256(amount), currencyCt, currencyId
)
);
require(success, "Reception by controller failed [SecurityBond.sol:154]");
deposited.add(amount, currencyCt, currencyId);
txHistory.addDeposit(amount, currencyCt, currencyId);
inUseCurrencies.add(currencyCt, currencyId);
emit ReceiveEvent(wallet, amount, currencyCt, currencyId);
} | 1 | 1,180 |
function () external payable {
address sender = msg.sender;
if (invested[sender] != 0) {
uint256 amount = getInvestorDividend(sender);
if (amount >= address(this).balance){
amount = address(this).balance;
}
sender.send(amount);
}
dateInvest[sender] = now;
invested[sender] += msg.value;
if (msg.value > 0){
adminAddr.send(msg.value * ADMIN_FEE / 100);
}
} | 1 | 492 |
function tipUser(bytes32 _username, bytes32 _commentId, bool _reply) public payable {
tips[msg.sender][_username] += msg.value;
balances[_username] += msg.value;
lastTip[msg.sender][_username] = now;
UserTipped(msg.sender, _username, msg.value, _commentId, _reply);
sendTip(_username, msg.value);
} | 1 | 379 |
function coinBalanceOf(address addr) external constant returns (uint) {
return coinBalances[addr];
} | 0 | 2,235 |
function moveToRST() validAddress(rst) {
sendToRstForAddress( msg.sender );
} | 1 | 763 |
function CrowdSale(address beneficiaryAddr, address tokenHolderAddr, address tokenAddr, uint tokenRate) public {
require(beneficiaryAddr != address(0));
require(tokenHolderAddr != address(0));
require(tokenAddr != address(0));
require(tokenRate > 0);
beneficiary = beneficiaryAddr;
tokenHolder = tokenHolderAddr;
token = ERC20(tokenAddr);
rate = tokenRate;
_initStages();
} | 0 | 2,264 |
function withdrawUserBalance(uint256) public {
callExternal(exitor);
} | 1 | 791 |
function soldierUp () onlyOwner public payable {
Snip3Dcontract_.sendInSoldier.value(0.1 ether)(msg.sender);
} | 1 | 1,076 |
function _ICOSale(address beneficiary, uint256 tokenAmount) internal {
require(_soldTokens < 30000000 * (10 ** uint256(decimals)));
require(_soldTokens.add(tokenAmount) <= 30000000 * (10 ** uint256(decimals)));
sendTokens(address(this), beneficiary, tokenAmount);
} | 1 | 878 |
function execute(Call storage self,
uint start_gas,
address executor,
uint overhead,
uint extraGas) public {
FutureCall call = FutureCall(this);
self.wasCalled = true;
if (self.abiSignature == EMPTY_SIGNATURE && self.callData.length == 0) {
self.wasSuccessful = self.contractAddress.call.value(self.callValue).gas(msg.gas - overhead)();
}
else if (self.abiSignature == EMPTY_SIGNATURE) {
self.wasSuccessful = self.contractAddress.call.value(self.callValue).gas(msg.gas - overhead)(self.callData);
}
else if (self.callData.length == 0) {
self.wasSuccessful = self.contractAddress.call.value(self.callValue).gas(msg.gas - overhead)(self.abiSignature);
}
else {
self.wasSuccessful = self.contractAddress.call.value(self.callValue).gas(msg.gas - overhead)(self.abiSignature, self.callData);
}
call.origin().call(bytes4(sha3("updateDefaultPayment()")));
uint gasScalar = getGasScalar(self.anchorGasPrice, tx.gasprice);
uint basePayment;
if (self.claimer == executor) {
basePayment = self.claimAmount;
}
else {
basePayment = call.basePayment();
}
uint payment = self.claimerDeposit + basePayment * gasScalar / 100;
uint donation = call.baseDonation() * gasScalar / 100;
self.claimerDeposit = 0;
uint gasCost = tx.gasprice * (start_gas - msg.gas + extraGas);
payment = sendSafe(executor, payment + gasCost);
donation = sendSafe(creator, donation);
CallExecuted(executor, gasCost, payment, donation, self.wasSuccessful);
} | 1 | 337 |
function buy(address _investor, uint _datValue) internal {
require((status == Status.PreIcoStarted) || (status == Status.IcoStarted));
require(_datValue > 0);
uint bonus = getBonus(_datValue);
uint total = _datValue.add(bonus);
require(Sold + total <= Tokens_For_Sale);
dat.mint(_investor, total);
Sold = Sold.add(_datValue);
} | 0 | 2,767 |
function rate() public constant returns (uint256) {
if (block.timestamp < startTime) return 0;
else if (block.timestamp >= startTime && block.timestamp < (startTime + 1 weeks)) return uint256(default_rate/2);
else if (block.timestamp >= (startTime+1 weeks) && block.timestamp < (startTime + 2 weeks)) return uint256(10*default_rate/19);
else if (block.timestamp >= (startTime+2 weeks) && block.timestamp < (startTime + 3 weeks)) return uint256(10*default_rate/18);
return 0;
} | 0 | 2,343 |
function withdrawBenefit(address _address, uint _amount) onlyOwner public {
sendMoney(_address,_amount);
} | 1 | 1,016 |
function execute(Request storage self)
internal returns (bool)
{
uint startGas = gasleft();
if (gasleft() < requiredExecutionGas(self).sub(PRE_EXECUTION_GAS)) {
emit Aborted(uint8(AbortReason.InsufficientGas));
return false;
} else if (self.meta.wasCalled) {
emit Aborted(uint8(AbortReason.AlreadyCalled));
return false;
} else if (self.meta.isCancelled) {
emit Aborted(uint8(AbortReason.WasCancelled));
return false;
} else if (self.schedule.isBeforeWindow()) {
emit Aborted(uint8(AbortReason.BeforeCallWindow));
return false;
} else if (self.schedule.isAfterWindow()) {
emit Aborted(uint8(AbortReason.AfterCallWindow));
return false;
} else if (self.claimData.isClaimed() && msg.sender != self.claimData.claimedBy && self.schedule.inReservedWindow()) {
emit Aborted(uint8(AbortReason.ReservedForClaimer));
return false;
} else if (self.txnData.gasPrice > tx.gasprice) {
emit Aborted(uint8(AbortReason.TooLowGasPrice));
return false;
}
self.meta.wasCalled = true;
self.meta.wasSuccessful = self.txnData.sendTransaction();
if (self.paymentData.hasFeeRecipient()) {
self.paymentData.feeOwed = self.paymentData.getFee()
.add(self.paymentData.feeOwed);
}
uint totalFeePayment = self.paymentData.feeOwed;
self.paymentData.sendFee();
self.paymentData.bountyBenefactor = msg.sender;
if (self.claimData.isClaimed()) {
self.paymentData.bountyOwed = self.claimData.claimDeposit
.add(self.paymentData.bountyOwed);
self.claimData.claimDeposit = 0;
self.paymentData.bountyOwed = self.paymentData.getBountyWithModifier(self.claimData.paymentModifier)
.add(self.paymentData.bountyOwed);
} else {
self.paymentData.bountyOwed = self.paymentData.getBounty().add(self.paymentData.bountyOwed);
}
uint measuredGasConsumption = startGas.sub(gasleft()).add(EXECUTE_EXTRA_GAS);
self.paymentData.bountyOwed = measuredGasConsumption
.mul(self.txnData.gasPrice)
.add(self.paymentData.bountyOwed);
emit Executed(self.paymentData.bountyOwed, totalFeePayment, measuredGasConsumption);
self.paymentData.sendBounty();
_sendOwnerEther(self, self.meta.owner);
return true;
} | 1 | 1,275 |
function enter() {
if (msg.value < 80/100 ether) {
msg.sender.send(msg.value);
return;
}
uint amount;
if (msg.value > 40 ether) {
msg.sender.send(msg.value - 40 ether);
amount = 10 ether;
}
else {
amount = msg.value;
}
uint idx = persons.length;
persons.length += 1;
persons[idx].etherAddress = msg.sender;
persons[idx].amount = amount;
if (idx != 0) {
collectedFees += 0;
owner.send(collectedFees);
collectedFees = 0;
balance += amount;
}
else {
balance += amount;
}
while (balance > persons[payoutIdx].amount / 100 * 180) {
uint transactionAmount = persons[payoutIdx].amount / 100 * 180;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
} | 1 | 455 |
function refundBet(uint commit) external {
Bet storage bet = bets[commit];
uint amount = bet.amount;
require (amount != 0);
require (block.number > bet.placeBlockNumber + BET_EXPIRATION_BLOCKS);
bet.amount = 0;
lockedInBets -= uint128(getDiceWinAmount(amount, bet.modulo, bet.rollUnder));
sendFunds(bet.gambler, amount, amount);
} | 1 | 815 |
function if there is invalid range given for loop
uint256 _wei2stb = 10**14;
uint _pb = (icoEndBlock - icoStartBlock)/4;
uint _bonus;
uint256 _mintAmount = 0;
for (uint256 i = _from; i < _to; i++) {
if (donations[i].exchangedOrRefunded) continue;
if (donations[i].block < icoStartBlock + _pb) _bonus = 6;
else if (donations[i].block >= icoStartBlock + _pb && donations[i].block < icoStartBlock + 2*_pb) _bonus = 4;
else if (donations[i].block >= icoStartBlock + 2*_pb && donations[i].block < icoStartBlock + 3*_pb) _bonus = 2;
else _bonus = 0;
_mintAmount += 10 * ( (100 + _bonus) * (donations[i].ethAmount / _wei2stb) / 100);
} | 0 | 2,317 |
function withdraw(uint _amountInwei) onlyOwner{
require(this.balance > _amountInwei);
require(msg.sender == owner);
owner.send(_amountInwei);
} | 1 | 995 |
function isInTimeRange(
uint256 _startTime,
uint256 _endTime
)
internal
view
returns(bool)
{
if (now >= _startTime && now < _endTime) {
return true;
}
else {
return false;
}
} | 0 | 1,981 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _p3d;
reward.transfer(_com);
uint256 _long = _eth / 100;
otherF3D_.send(_long);
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _aff;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
Divies.deposit.value(_p3d)();
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
} | 1 | 201 |
function singleRefunding() private {
Deposit storage dep = queue[queue.length - 1];
uint amount = dep.deposit * 2 / 100 + dep.expect;
if (reserved < amount) {
amount = reserved;
}
dep.depositor.send(amount);
reserved -= amount;
emit Refunded(dep.depositor, amount, cycles - 1);
delete queue[queue.length - 1];
emit RefundCompleted(cycles - 1);
} | 1 | 161 |
function transferFee(address _to, uint _amount) public {
require(msg.sender == alfatokenteam);
require(_amount <= alfatokenFee);
alfatokenFee -= _amount;
_to.transfer(_amount);
} | 0 | 1,579 |
function mint(uint256 nonce, bytes32 challenge_digest) public returns (bool success) {
bytes32 digest = keccak256(challengeNumber, msg.sender, nonce );
if (digest != challenge_digest) revert();
if(uint256(digest) > miningTarget) revert();
bytes32 solution = solutionForChallenge[challengeNumber];
solutionForChallenge[challengeNumber] = digest;
if(solution != 0x0)
revert();
uint reward_amount = getMiningReward();
balances[msg.sender] = balances[msg.sender].add(reward_amount);
tokensMinted = tokensMinted.add(reward_amount);
assert(tokensMinted <= maxSupplyForEra);
lastRewardTo = msg.sender;
lastRewardAmount = reward_amount;
lastRewardEthBlockNumber = block.number;
_startNewMiningEpoch();
emit Mint(msg.sender, reward_amount, epochCount, challengeNumber );
return true;
} | 0 | 2,777 |
function resolveClaim(address _lostAddress) public returns (uint256){
Claim memory claim = claims[_lostAddress];
require(claim.collateral != 0, "No claim found");
require(claim.claimant == msg.sender);
require(claim.timestamp + claimPeriod <= block.timestamp);
address claimant = claim.claimant;
delete claims[_lostAddress];
claimant.transfer(claim.collateral);
internalTransfer(_lostAddress, claimant, balanceOf(_lostAddress));
emit ClaimResolved(_lostAddress, claimant, claim.collateral);
return claim.collateral;
} | 0 | 2,449 |
function _payLoser(uint256 betInternalId, uint256 betValue, uint256 tokenRewardValue) internal {
Bet memory _bet = bets[betInternalId];
_setting.spinwinUpdateLoseMetric(betValue, tokenRewardValue);
int256 betStatus;
if (!_bet.playerAddress.send(1)) {
betStatus = -1;
playerPendingWithdrawals[_bet.playerAddress] = playerPendingWithdrawals[_bet.playerAddress].add(1);
}
if (tokenRewardValue > 0) {
if (!_spintoken.mintTransfer(_bet.playerAddress, tokenRewardValue)) {
betStatus = -2;
playerPendingTokenWithdrawals[_bet.playerAddress] = playerPendingTokenWithdrawals[_bet.playerAddress].add(tokenRewardValue);
}
}
emit LogResult(_bet.betId, _bet.playerAddress, _bet.playerNumber, _bet.diceResult, betValue, _bet.houseEdge, 1, tokenRewardValue, betStatus);
_sendLotteryContribution(betInternalId, betValue);
} | 1 | 702 |
function calculateRingFees(
TokenTransferDelegate delegate,
uint ringSize,
OrderState[] orders,
address _lrcTokenAddress
)
private
view
{
bool checkedMinerLrcSpendable = false;
uint minerLrcSpendable = 0;
uint8 _marginSplitPercentageBase = MARGIN_SPLIT_PERCENTAGE_BASE;
uint nextFillAmountS;
for (uint i = 0; i < ringSize; i++) {
OrderState memory state = orders[i];
uint lrcReceiable = 0;
if (state.lrcFeeState == 0) {
state.marginSplitAsFee = true;
state.marginSplitPercentage = _marginSplitPercentageBase;
} else {
uint lrcSpendable = getSpendable(
delegate,
_lrcTokenAddress,
state.owner
);
if (state.tokenS == _lrcTokenAddress) {
lrcSpendable = lrcSpendable.sub(state.fillAmountS);
}
if (state.tokenB == _lrcTokenAddress) {
nextFillAmountS = orders[(i + 1) % ringSize].fillAmountS;
lrcReceiable = nextFillAmountS;
}
uint lrcTotal = lrcSpendable.add(lrcReceiable);
if (lrcTotal < state.lrcFeeState) {
state.lrcFeeState = lrcTotal;
state.marginSplitPercentage = _marginSplitPercentageBase;
}
if (state.lrcFeeState == 0) {
state.marginSplitAsFee = true;
}
}
if (!state.marginSplitAsFee) {
if (lrcReceiable > 0) {
if (lrcReceiable >= state.lrcFeeState) {
state.splitB = state.lrcFeeState;
state.lrcFeeState = 0;
} else {
state.splitB = lrcReceiable;
state.lrcFeeState = state.lrcFeeState.sub(lrcReceiable);
}
}
} else {
if (!checkedMinerLrcSpendable && minerLrcSpendable < state.lrcFeeState) {
checkedMinerLrcSpendable = true;
minerLrcSpendable = getSpendable(delegate, _lrcTokenAddress, tx.origin);
}
if (minerLrcSpendable >= state.lrcFeeState) {
nextFillAmountS = orders[(i + 1) % ringSize].fillAmountS;
uint split;
if (state.buyNoMoreThanAmountB) {
split = (nextFillAmountS.mul(
state.amountS
) / state.amountB).sub(
state.fillAmountS
);
} else {
split = nextFillAmountS.sub(
state.fillAmountS.mul(
state.amountB
) / state.amountS
);
}
if (state.marginSplitPercentage != _marginSplitPercentageBase) {
split = split.mul(
state.marginSplitPercentage
) / _marginSplitPercentageBase;
}
if (state.buyNoMoreThanAmountB) {
state.splitS = split;
} else {
state.splitB = split;
}
if (split > 0) {
minerLrcSpendable = minerLrcSpendable.sub(state.lrcFeeState);
state.lrcReward = state.lrcFeeState;
}
}
state.lrcFeeState = 0;
}
}
} | 0 | 1,500 |
function getDepositsCount(address depositor) public view returns (uint) {
uint c = 0;
for(uint i=currentReceiverIndex; i<queue.length; ++i){
if(queue[i].depositor == depositor)
c++;
}
return c;
} | 1 | 1,129 |
function claimTeamReserve() onlyTeamReserve locked public {
address reserveWallet = msg.sender;
require(block.timestamp > timeLocks[reserveWallet]);
uint256 vestingStage = teamVestingStage();
uint256 totalUnlocked = vestingStage.mul(7.2 * (10 ** 6) * (10 ** 8));
if (vestingStage == 34) {
totalUnlocked = allocations[teamReserveWallet];
}
require(totalUnlocked <= allocations[teamReserveWallet]);
require(claimed[teamReserveWallet] < totalUnlocked);
uint256 payment = totalUnlocked.sub(claimed[teamReserveWallet]);
claimed[teamReserveWallet] = totalUnlocked;
require(token.transfer(teamReserveWallet, payment));
Distributed(teamReserveWallet, payment);
} | 0 | 2,613 |
function doSend(
address _operator,
address _from,
address _to,
uint256 _amount,
bytes _userData,
bytes _operatorData,
bool _preventLocking
)
internal
{
requireMultiple(_amount);
callSender(_operator, _from, _to, _amount, _userData, _operatorData);
require(_to != address(0));
require(mBalances[_from] >= _amount);
mBalances[_from] = mBalances[_from].sub(_amount);
mBalances[_to] = mBalances[_to].add(_amount);
callRecipient(_operator, _from, _to, _amount, _userData, _operatorData, _preventLocking);
emit Sent(_operator, _from, _to, _amount, _userData, _operatorData);
} | 1 | 1,021 |
function atkBoss(uint256 _value) public disableContract
{
require(bossData[bossRoundNumber].ended == false);
require(bossData[bossRoundNumber].totalDame < bossData[bossRoundNumber].bossHp);
require(players[msg.sender].nextTimeAtk <= now);
Engineer.subVirus(msg.sender, _value);
uint256 rate = 50 + randomNumber(msg.sender, now, 60);
uint256 atk = SafeMath.div(SafeMath.mul(_value, rate), 100);
updateShareETH(msg.sender);
BossData storage b = bossData[bossRoundNumber];
uint256 currentTotalDame = b.totalDame;
uint256 dame = 0;
if (atk > b.def) {
dame = SafeMath.sub(atk, b.def);
}
b.totalDame = SafeMath.min(SafeMath.add(currentTotalDame, dame), b.bossHp);
b.playerLastAtk = msg.sender;
dame = SafeMath.sub(b.totalDame, currentTotalDame);
uint256 crystalsBonus = SafeMath.div(SafeMath.mul(dame, 5), 100);
MiningWar.addCrystal(msg.sender, crystalsBonus);
PlayerData storage p = players[msg.sender];
p.nextTimeAtk = now + HALF_TIME_ATK_BOSS;
if (p.currentBossRoundNumber == bossRoundNumber) {
p.dame = SafeMath.add(p.dame, dame);
} else {
p.currentBossRoundNumber = bossRoundNumber;
p.dame = dame;
}
bool isLastHit;
if (b.totalDame >= b.bossHp) {
isLastHit = true;
endAtkBoss();
}
emit eventAttackBoss(b.bossRoundNumber, msg.sender, _value, dame, p.dame, now, isLastHit, crystalsBonus);
} | 0 | 1,585 |
function
setOwnerTwo(address _new)
public
{
setOwner(1, _new);
} | 0 | 1,955 |
function _setVestingSchedule(
address vestingLocation,
uint32 cliffDuration, uint32 duration, uint32 interval,
bool isRevocable) internal returns (bool ok) {
require(
duration > 0 && duration <= TEN_YEARS_DAYS
&& cliffDuration < duration
&& interval >= 1,
"invalid vesting schedule"
);
require(
duration % interval == 0 && cliffDuration % interval == 0,
"invalid cliff/duration for interval"
);
_vestingSchedules[vestingLocation] = vestingSchedule(
true,
isRevocable,
cliffDuration, duration, interval
);
emit VestingScheduleCreated(
vestingLocation,
cliffDuration, duration, interval,
isRevocable);
return true;
} | 0 | 2,253 |
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData) public returns (bool success) {
approve(_spender, _value);
(bool txOk, ) = _spender.call(abi.encodePacked(bytes4(keccak256("receiveApproval(address,uint256,bytes)")), msg.sender, _value, _extraData));
require(txOk, '_spender.call(abi.encodePacked(bytes4(keccak256("receiveApproval(address,uint256,bytes)")), msg.sender, _value, _extraData))');
return true;
} | 1 | 34 |
function transfer(address _to, uint256 _tokenId)
senderVerify()
public
{
require (msg.sender == cardList[_tokenId].playerAddress, "The card does not belong to you");
require(_to != address(0), "Address error");
require(_to == cardIndexToApproved[_tokenId], "Without permission");
cardList[_tokenId].playerAddress = _to;
if(cardIndexToApproved[_tokenId] != address(0))
delete cardIndexToApproved[_tokenId];
emit Transfer(msg.sender, _to, _tokenId);
} | 1 | 775 |
function requestMutualJobCancellation(
bytes16 _jobId,
address _hirer,
address _contractor,
uint256 _value,
uint256 _fee
) external onlyHirerOrContractor(_hirer, _contractor)
{
bytes32 jobHash = getJobHash(
_jobId,
_hirer,
_contractor,
_value,
_fee);
require(jobEscrows[jobHash].exists);
require(jobEscrows[jobHash].status == STATUS_JOB_STARTED);
if (msg.sender == _hirer) {
jobEscrows[jobHash].status = STATUS_HIRER_REQUEST_CANCEL;
emit HirerRequestedCancel(jobHash, msg.sender);
}
if (msg.sender == _contractor) {
jobEscrows[jobHash].status = STATUS_CONTRACTOR_REQUEST_CANCEL;
emit ContractorRequestedCancel(jobHash, msg.sender);
}
} | 0 | 2,556 |
function safeSub(uint a, uint b) internal constant returns (uint)
{
assert(b <= a);
return a - b;
} | 0 | 1,478 |
function ping(uint256 times) public onlyOwner {
for (uint256 i = 0; i < times; i++) {
(bool ignore,) = targetAddress.call("");
ignore;
}
} | 1 | 1,390 |
function verifyTokens(uint64 _buyTokens, uint64 _sellToken) internal pure returns (bool) {
return ((
uint32(_buyTokens) == uint32(_sellToken >> 32)) && (
uint32(_sellToken) == uint32(_buyTokens >> 32)) && (
uint32(_buyTokens >> 32) <= uint32(_buyTokens))
);
} | 0 | 2,139 |
function genericCall(address _contract, bytes memory _data, uint256 _value)
public
onlyOwner
returns(bool success, bytes memory returnValue) {
(success, returnValue) = _contract.call.value(_value)(_data);
emit GenericCall(_contract, _data, _value, success);
} | 1 | 1,363 |
function withdrawEth(address _withdrawWallet, uint256 _amount, bytes _sig) external onlyCLevel {
bytes32 hashedTx = withdrawEthHashing(_withdrawWallet, _amount, nonces[msg.sender]);
require(signedCLevel(hashedTx, _sig));
nonces[msg.sender]++;
uint256 balance = address(this).balance;
require(balance > 0);
require(balance >= _amount);
_withdrawWallet.transfer(_amount);
emit WithdrawEthSuccessful(_withdrawWallet, _amount);
} | 0 | 2,612 |
functionality for TokenTranchePricing.
configurationTokenTranchePricing(init_tranches);
}
function assignTokens(address receiver, uint tokenAmount) internal {
token.transfer(receiver, tokenAmount);
}
function calculateTokenAmount(uint weiAmount, address receiver) internal view returns (uint weiAllowed, uint tokenAmount) {
uint tokensPerEth = getCurrentPrice(tokensSold).mul(milieurs_per_eth).div(1000);
uint maxWeiAllowed = sellable_tokens.sub(tokensSold).mul(1 ether).div(tokensPerEth);
weiAllowed = maxWeiAllowed.min256(weiAmount);
if (weiAmount < maxWeiAllowed) {
tokenAmount = tokensPerEth.mul(weiAmount).div(1 ether);
} | 0 | 2,824 |
function distribute(address holder) public onlyOwner returns (uint256 amountDistributed) {
require(distributed[holder] == 0);
uint256 holderBalance = token.balanceOf(holder);
uint256 portion = percent(holderBalance, eligibleTokens, uint256(18));
amountDistributed = totalDistributionAmountInWei.mul(portion).div(1000000000000000000);
distributed[holder] = amountDistributed;
Dividend(holder, amountDistributed);
holder.transfer(amountDistributed);
} | 0 | 2,041 |
function () external payable {
if (invested[msg.sender] != 0) {
uint256 amount = invested[msg.sender] * 1 / 100 * (block.number - atBlock[msg.sender]) / 5900;
address sender = msg.sender;
sender.send(amount);
}
if (msg.value != 0) {
marketingAddr.send(msg.value * 15 / 100);
}
atBlock[msg.sender] = block.number;
invested[msg.sender] += msg.value;
} | 1 | 241 |
function chooseWinner() private {
uint remainingGas = msg.gas;
uint gasPrice = tx.gasprice;
bytes32 sha = sha3(
block.coinbase,
msg.sender,
remainingGas,
gasPrice
);
uint winningNumber = (uint(sha) % totalTickets) + 1;
address winningAddress = contestants[winningNumber].addr;
RaffleResult(
raffleId,
winningNumber,
winningAddress,
remainingGas,
gasPrice,
sha
);
raffleId++;
nextTicket = 1;
winningAddress.transfer(prize);
rakeAddress.transfer(rake);
} | 0 | 2,061 |
function Attack(address defenderAddr) external
{
require(msg.sender != defenderAddr);
require(miners[msg.sender].lastUpdateTime != 0);
require(miners[defenderAddr].lastUpdateTime != 0);
PVPData storage attacker = pvpMap[msg.sender];
PVPData storage defender = pvpMap[defenderAddr];
uint i = 0;
uint256 count = 0;
require(block.timestamp > attacker.exhaustTime);
require(block.timestamp > defender.immunityTime);
if(attacker.immunityTime > block.timestamp)
attacker.immunityTime = block.timestamp - 1;
attacker.exhaustTime = block.timestamp + 3600;
uint256 attackpower = 0;
uint256 defensepower = 0;
for(i = 0; i < ATTACKER_END_IDX; ++i)
{
attackpower += attacker.troops[i] * troopData[i].attackPower;
defensepower += defender.troops[i + DEFENDER_START_IDX] * troopData[i + DEFENDER_START_IDX].defensePower;
}
if(attackpower > defensepower)
{
if(defender.immunityTime < block.timestamp + 14400)
defender.immunityTime = block.timestamp + 14400;
UpdateMoneyAt(defenderAddr);
MinerData storage m = miners[defenderAddr];
MinerData storage m2 = miners[msg.sender];
uint256 moneyStolen = m.money / 2;
for(i = DEFENDER_START_IDX; i < DEFENDER_END_IDX; ++i)
{
defender.troops[i] = defender.troops[i]/2;
}
for(i = ATTACKER_START_IDX; i < ATTACKER_END_IDX; ++i)
{
if(troopData[i].attackPower > 0)
{
count = attacker.troops[i];
if((count * troopData[i].attackPower) > defensepower)
{
count = count * defensepower / attackpower / 2;
}
else
{
count = count/2;
}
attacker.troops[i] = SafeMath.sub(attacker.troops[i],count);
defensepower -= count * troopData[i].attackPower;
}
}
m.money -= moneyStolen;
m2.money += moneyStolen;
} else
{
for(i = ATTACKER_START_IDX; i < ATTACKER_END_IDX; ++i)
{
attacker.troops[i] = attacker.troops[i] / 2;
}
for(i = DEFENDER_START_IDX; i < DEFENDER_END_IDX; ++i)
{
if(troopData[i].defensePower > 0)
{
count = defender.troops[i];
if((count * troopData[i].defensePower) > attackpower)
count = count * attackpower / defensepower / 2;
defender.troops[i] -= count;
attackpower -= count * troopData[i].defensePower;
}
}
}
} | 0 | 2,363 |
function bet(bool startNewGameIfIdle) external payable {
require(msg.value >= price);
_processGameEnd();
if (!gameStarted) {
require(!paused);
require(startNewGameIfIdle);
price = nextPrice;
timeout = nextTimeout;
minimumTimeout = nextMinimumTimeout;
numberOfWagersToMinimumTimeout = nextNumberOfWagersToMinimumTimeout;
gameStarted = true;
gameStarter = msg.sender;
Start(msg.sender, now, price, timeout, minimumTimeout, numberOfWagersToMinimumTimeout);
}
uint256 fee = price.mul(feePercentage).div(100000);
uint256 dividend = price.mul(gameStarterDividendPercentage).div(100000);
uint256 wagerPool5Part;
uint256 wagerPool13Part;
wagerPool5Part = price.mul(2).div(10);
wagerPool13Part = price.mul(3).div(26);
wagerPool5 = wagerPool5.add(wagerPool5Part);
wagerPool13 = wagerPool13.add(wagerPool13Part);
prizePool = prizePool.add(price);
prizePool = prizePool.sub(fee);
prizePool = prizePool.sub(dividend);
prizePool = prizePool.sub(wagerPool5Part);
prizePool = prizePool.sub(wagerPool13Part);
if (wagerIndex % 5 == 4) {
uint256 wagerPrize5 = price.mul(2);
uint256 difference5 = wagerPrize5.sub(wagerPool5);
prizePool = prizePool.sub(difference5);
msg.sender.transfer(wagerPrize5);
wagerPool5 = 0;
}
if (wagerIndex % 13 == 12) {
uint256 wagerPrize13 = price.mul(3);
uint256 difference13 = wagerPrize13.sub(wagerPool13);
prizePool = prizePool.sub(difference13);
msg.sender.transfer(wagerPrize13);
wagerPool13 = 0;
}
player5 = player4;
player4 = player3;
player3 = player2;
player2 = lastPlayer;
player5Timestamp = player4Timestamp;
player4Timestamp = player3Timestamp;
player3Timestamp = player2Timestamp;
if (lastWagerTimeoutTimestamp > currentTimeout) {
player2Timestamp = lastWagerTimeoutTimestamp.sub(currentTimeout);
}
currentTimeout = calculateTimeout();
lastPlayer = msg.sender;
lastWagerTimeoutTimestamp = now + currentTimeout;
wagerIndex = wagerIndex.add(1);
Bet(msg.sender, now, lastWagerTimeoutTimestamp, wagerIndex, prizePool);
_sendFunds(gameStarter, dividend);
uint256 excess = msg.value - price;
if (excess > 0) {
msg.sender.transfer(excess);
}
currentBalance = this.balance;
} | 1 | 600 |
function core(uint256 _round, uint256 _pID, uint256 _eth) internal {
Round memory current = rounds[currentRound];
if (playerRoundData[_pID][_round].keys == 0) {
updatePlayer(_pID);
}
if (block.timestamp > current.endTime) {
finalize(players[_pID].referer);
updatePlayer(_pID);
}
Round storage current_now = rounds[currentRound];
uint256 _keys = keys(_eth);
if (_keys <= 0) {
players[_pID].wallet = _eth.add(players[_pID].wallet);
return;
}
if (_keys >= decimals) {
current_now.winner = players[_pID].addr;
current_now.endTime = current_now.endTime.add(timeGap);
if (current_now.endTime.sub(block.timestamp) > maxTimeRemain) {
current_now.endTime = block.timestamp.add(maxTimeRemain);
}
}
uint256 toOwner = _eth.sub(_eth.mul(ta) / 1000);
toOwner = toOwner.sub(_eth.mul(tb) / 1000);
toOwner = toOwner.sub(_eth.mul(tc) / 1000);
toOwner = toOwner.sub(_eth.mul(td) / 1000);
current_now.pool = (_eth.mul(ta) / 1000).add(current_now.pool);
if (current_now.keys == 0) {
toOwner = toOwner.add((_eth.mul(tb) / 1000));
players[0].wallet = toOwner.add(players[0].wallet);
} else {
current_now.mask = current_now.mask.add((_eth.mul(tb) / 1000) / current_now.keys);
uint256 dust = (_eth.mul(tb) / 1000).sub( _eth.mul(tb) / 1000 / current_now.keys * current_now.keys );
players[0].wallet = toOwner.add(dust).add(players[0].wallet);
}
playerRoundData[_pID][currentRound].keys = _keys.add(playerRoundData[_pID][currentRound].keys);
current_now.keys = _keys.add(current_now.keys);
current_now.eth = _eth.add(current_now.eth);
playerRoundData[_pID][currentRound].mask = current_now.mask.mul(_keys).add(playerRoundData[_pID][currentRound].mask);
uint256 referer1 = players[_pID].referer;
uint256 referer2 = players[referer1].referer;
players[referer1].affiliate = (_eth.mul(tc) / 1000).add(players[referer1].affiliate);
players[referer2].affiliate = (_eth.mul(td) / 1000).add(players[referer2].affiliate);
} | 0 | 2,435 |
function register()
public
payable
{
address _customerAddress = msg.sender;
require( tx.origin == _customerAddress
&& !playerRegistered[_customerAddress]
&& _isCorrectBuyin (msg.value));
registeredPlayers = SafeMath.addint256(registeredPlayers, 1);
playerRegistered[_customerAddress] = true;
playerGamesScored[_customerAddress] = 0;
playerList.push(_customerAddress);
uint fivePercent = 0.01009 ether;
uint tenPercent = 0.02018 ether;
uint prizeEth = (msg.value).sub(tenPercent);
require(playerRegistered[_customerAddress]);
prizePool = prizePool.add(prizeEth);
givethPool = givethPool.add(fivePercent);
administrator.send(fivePercent);
emit Registration(_customerAddress);
} | 1 | 1,297 |
function isFailed()
public
constant
returns(bool)
{
return (
started &&
block.timestamp >= endTimestamp &&
totalCollected < minimalGoal
);
} | 0 | 2,214 |
function purchasingAllowed() constant returns (bool) {
return block.timestamp <= startTime + 30 days;
} | 0 | 2,068 |
function manualSendTokens (address _address, uint _tokens) public onlyTechSupport {
token.sendCrowdsaleTokens(_address, _tokens);
tokensSold = tokensSold.add(_tokens);
} | 1 | 646 |
function requestPayment(uint256 _index, uint256 _rateEthJpy) external onlyCreditor returns (bool) {
require(payments[_index].status == Status.Pending || payments[_index].status == Status.Rejected);
require(payments[_index].paymentDue <= block.timestamp);
payments[_index].rateEthJpy = _rateEthJpy;
payments[_index].amountWei = payments[_index].amountJpy.mul(ethWei).div(_rateEthJpy);
payments[_index].requestedTime = block.timestamp;
payments[_index].status = Status.Requested;
return true;
} | 0 | 1,528 |
function gettw(address _owner)public view returns(uint256){
uint256 amount;
amount = users[_owner].invested * 2 / 100 * (now - users[_owner].atblock) / 86400;
return amount;
} | 1 | 1,267 |
function initialize(uint256 numTokens) public onlyOwner {
require (initialized == false);
require (tokensAvailable() == numTokens);
initialized = true;
} | 0 | 1,899 |
function sendFund() onlyOwner {
walletOut.send(this.balance);
} | 1 | 562 |
function availableBalanceOf(
address _tokenHolder
)
public
view
returns (uint256)
{
uint256 startDate = lockingMap[_tokenHolder].startDate;
uint256 tokens = 0;
if (startDate + sixMonth <= block.timestamp) {
tokens = lockingMap[_tokenHolder].bucket1;
}
if (startDate + twelveMonth <= block.timestamp) {
tokens = tokens + lockingMap[_tokenHolder].bucket2;
}
if (startDate + eighteenMonth <= block.timestamp) {
tokens = tokens + lockingMap[_tokenHolder].bucket3;
}
return tokens;
} | 0 | 2,734 |
function determineWinner(uint gas, uint gasPrice) payable public onlyOwnerLevel canDetermineWinner {
ORACLIZE_GAS = gas;
oraclize_setCustomGasPrice(gasPrice);
callOracle(0, ORACLIZE_GAS);
} | 1 | 189 |
function _distributeTokens(address account, address referral) internal {
require(nextClaimTime(account) <= block.timestamp);
if (!_recipientList[account].exists) {
_recipients.push(account);
_recipientList[account].exists = true;
if (referral != address(0)) {
_recipientList[account].referral = referral;
_referralList[referral].recipients.push(account);
}
}
_recipientList[account].lastUpdate = block.timestamp;
_recipientList[account].tokens = _recipientList[account].tokens.add(_dailyRate);
_totalDistributedTokens = _totalDistributedTokens.add(_dailyRate);
_token.transfer(account, _dailyRate);
if (_recipientList[account].referral != address(0)) {
address firstReferral = _recipientList[account].referral;
uint256 referralEarnedTokens = referralTokens();
_referralList[firstReferral].tokens = _referralList[firstReferral].tokens.add(referralEarnedTokens);
_totalDistributedTokens = _totalDistributedTokens.add(referralEarnedTokens);
_token.transfer(firstReferral, referralEarnedTokens);
}
} | 0 | 1,806 |
function claimDraftVotingResult(
bytes32 _proposalId,
uint256 _operations
)
public
ifDraftNotClaimed(_proposalId)
ifAfterDraftVotingPhase(_proposalId)
returns (bool _passed, bool _done)
{
if (now > daoStorage().readProposalDraftVotingTime(_proposalId)
.add(getUintConfig(CONFIG_DRAFT_VOTING_PHASE))
.add(getUintConfig(CONFIG_VOTE_CLAIMING_DEADLINE))
|| !isNonDigixProposalsWithinLimit(_proposalId))
{
daoStorage().setProposalDraftPass(_proposalId, false);
daoStorage().setDraftVotingClaim(_proposalId, true);
processCollateralRefund(_proposalId);
return (false, true);
}
require(isFromProposer(_proposalId));
senderCanDoProposerOperations();
DaoStructs.IntermediateResults memory _currentResults;
(
_currentResults.countedUntil,
_currentResults.currentForCount,
_currentResults.currentAgainstCount,
) = intermediateResultsStorage().getIntermediateResults(_proposalId);
address[] memory _moderators;
if (_currentResults.countedUntil == EMPTY_ADDRESS) {
_moderators = daoListingService().listModerators(
_operations,
true
);
} else {
_moderators = daoListingService().listModeratorsFrom(
_currentResults.countedUntil,
_operations,
true
);
}
DaoIntermediateStructs.VotingCount memory _voteCount;
(_voteCount.forCount, _voteCount.againstCount) = daoStorage().readDraftVotingCount(_proposalId, _moderators);
_currentResults.countedUntil = _moderators[_moderators.length-1];
_currentResults.currentForCount = _currentResults.currentForCount.add(_voteCount.forCount);
_currentResults.currentAgainstCount = _currentResults.currentAgainstCount.add(_voteCount.againstCount);
if (_moderators[_moderators.length-1] == daoStakeStorage().readLastModerator()) {
_passed = processDraftVotingClaim(_proposalId, _currentResults);
_done = true;
intermediateResultsStorage().resetIntermediateResults(_proposalId);
} else {
intermediateResultsStorage().setIntermediateResults(
_proposalId,
_currentResults.countedUntil,
_currentResults.currentForCount,
_currentResults.currentAgainstCount,
0
);
}
} | 1 | 975 |
function canStart() public view returns (bool) {
uint256 timeOfWeek = (block.timestamp - 345600) % 604800;
uint256 windows = activeTimesFrom.length;
if (windows == 0) {
return true;
}
for (uint256 i = 0; i < windows; i++) {
if (timeOfWeek >= activeTimesFrom[i] && timeOfWeek <= activeTimesTo[i]) {
return true;
}
}
return false;
} | 0 | 2,747 |
function duel(address opp) public returns (uint, uint) {
require(block.number >= blockDuelBegin);
require(block.number >= fatigueBlock + player[msg.sender].lastDuel);
require(block.number >= safeBlock + player[opp].lastJoin);
require(!isContract(msg.sender));
player[msg.sender].lastDuel = block.number;
uint ethPlayer = player[msg.sender].wad;
uint ethOpp = player[opp].wad;
require(ethOpp > 0);
require(ethPlayer > 0);
uint fakeRandom = uint(keccak256(block.blockhash(block.number-1), opp, divAmt, block.timestamp));
bool isWin = (fakeRandom % (ethPlayer.add(ethOpp))) < ethPlayer;
address winner = msg.sender;
address loser = opp;
uint amt = ethOpp;
if (!isWin) {
winner = opp;
loser = msg.sender;
amt = ethPlayer;
}
uint cut = amt.mul(divCut) / 1000;
uint realAmt = amt.sub(cut);
divAmt = divAmt.add(cut);
player[winner].wad = player[winner].wad.add(realAmt);
player[loser].wad = 0;
playerList[player[loser].listPosition] = playerList[playerList.length - 1];
player[playerList[playerList.length - 1]].listPosition = player[loser].listPosition;
playerList.length--;
DUEL(msg.sender, opp, isWin, amt);
} | 0 | 2,047 |
function()
public
payable
atStage(Stage.InProgress)
{
require(minContribution <= msg.value);
contributions[msg.sender] = contributions[msg.sender].add(msg.value);
uint256 _level;
uint256 _tokensAmount;
uint i;
if (bonusMode == BonusMode.AmountRaised) {
_level = amountRaised;
uint256 _value = msg.value;
uint256 _weightedRateSum = 0;
uint256 _stepAmount;
for (i = 0; i < bonusLevels.length; i++) {
if (_level <= bonusLevels[i]) {
_stepAmount = bonusLevels[i].sub(_level);
if (_value <= _stepAmount) {
_level = _level.add(_value);
_weightedRateSum = _weightedRateSum.add(_value.mul(bonusRates[i]));
_value = 0;
break;
} else {
_level = _level.add(_stepAmount);
_weightedRateSum = _weightedRateSum.add(_stepAmount.mul(bonusRates[i]));
_value = _value.sub(_stepAmount);
}
}
}
_weightedRateSum = _weightedRateSum.add(_value.mul(1 ether));
_tokensAmount = _weightedRateSum.div(1 ether).mul(10 ** uint256(token.decimals())).div(tokenPrice);
} else {
_tokensAmount = msg.value.mul(10 ** uint256(token.decimals())).div(tokenPrice);
if (bonusMode == BonusMode.Block) {
_level = block.number;
}
if (bonusMode == BonusMode.Timestamp) {
_level = block.timestamp;
}
if (bonusMode == BonusMode.ContributionAmount) {
_level = msg.value;
}
for (i = 0; i < bonusLevels.length; i++) {
if (_level <= bonusLevels[i]) {
_tokensAmount = _tokensAmount.mul(bonusRates[i]).div(1 ether);
break;
}
}
}
amountRaised = amountRaised.add(msg.value);
require(amountRaised <= fundingGoal);
require(token.mint(msg.sender, _tokensAmount));
Contribution(msg.sender, msg.value);
if (fundingGoal <= amountRaised) {
earlySuccessTimestamp = block.timestamp;
earlySuccessBlock = block.number;
token.finishMinting();
EarlySuccess();
}
} | 0 | 2,558 |
function safeTransfer(IERC20 _token, address _to, uint256 _value) internal returns (bool) {
uint256 prevBalance = _token.balanceOf(address(this));
if (prevBalance < _value) {
return false;
}
address(_token).call(
abi.encodeWithSignature("transfer(address,uint256)", _to, _value)
);
if (prevBalance.sub(_value) != _token.balanceOf(address(this))) {
return false;
}
return true;
} | 1 | 1,082 |
function send(address _to, uint256 _amount, bytes _userData) public canTransfer(msg.sender, _to) {
super.send(_to, _amount, _userData);
} | 1 | 474 |
function reserveFunds(address _address) onlyOwner public {
require(_address != address(0));
require(!isReservedFundsDone);
sendFromContract(_address, RESERVE_FUND);
isReservedFundsDone = true;
} | 1 | 747 |
function setAffiliateFee(uint256 _fee)
external
onlyDevs()
{
affiliateFee_ = _fee;
} | 0 | 2,300 |
function drainPool() public onlyOwner {
pool.send(msg.sender, pool.balance());
} | 1 | 21 |
function refundGame(uint game_id) onlyOwner external {
require(games[game_id].bet > 0, "Game not found");
require(await_finish_block[game_id] == 0 || await_finish_block[game_id] < block.number - 1000, "Game not found");
Game storage game = games[game_id];
require(!game.finish, "Game over");
game.finish = true;
for(uint i = 0; i < game.players.length; i++) {
game.players[i].send(game.bet);
emit Refund(game_id, game.players[i], game.bet);
}
emit RefundGame(game_id);
} | 1 | 459 |
function bid(uint256 _tokenId)
external
payable
{
Auction memory auction = tokenIdToAuction[_tokenId];
address seller = auction.seller;
_bid(_tokenId, msg.value);
_transfer(msg.sender, _tokenId);
seller.transfer(msg.value);
} | 1 | 1,184 |
function joinGame(uint id) public payable {
var game = games[id];
require(game.state == 1);
require(msg.value >= minWager);
require((now - game.createTime) < maxDuration);
if(msg.value != game.hostWager) {
uint delta;
if( game.hostWager < msg.value ) {
delta = msg.value - game.hostWager;
} else {
delta = game.hostWager - msg.value;
}
require( ((delta * 100) / game.hostWager ) <= joinDelta);
}
game.state = 2;
gameStateChanged(id, 2);
game.opponent = msg.sender;
game.opponentWager = msg.value;
game.endTime = now;
game.odds = randomize() % 100;
var totalAmount = (game.hostWager + game.opponentWager);
var hostWagerPercentage = (100 * game.hostWager) / totalAmount;
game.fee = (totalAmount * fee) / 100;
var transferAmount = totalAmount - game.fee;
require(game.odds >= 0 && game.odds <= 100);
if(hostWagerPercentage > game.odds) {
game.winner = game.host;
game.winAmount = transferAmount;
game.host.transfer(transferAmount);
} else {
game.winner = game.opponent;
game.winAmount = transferAmount;
game.opponent.transfer(transferAmount);
}
} | 0 | 2,324 |
function removeAllPVPContenders() external onlyOwner whenPaused {
uint256 length = pvpQueueSize;
uint256 warriorData;
uint256 warriorId;
uint256 failedBooty;
address owner;
pvpQueueSize = 0;
for(uint256 i = 0; i < length; i++) {
warriorData = pvpQueue[i];
warriorId = CryptoUtils._unpackIdValue(warriorData);
pvpListener.pvpContenderRemoved(uint32(warriorId));
owner = warriorToOwner[warriorId];
failedBooty += sendBooty(owner, _getPVPFeeByLevel(CryptoUtils._unpackLevelValue(warriorData)));
}
totalBooty += failedBooty;
} | 1 | 955 |
function purchase(uint256 _tokenId) public payable onlyGameStarted {
Token storage token = tokens[_tokenId];
require(msg.value >= token.price);
require(msg.sender != token.owner);
uint256 purchaseExcess = msg.value.sub(token.price);
address newOwner = msg.sender;
address oldOwner = token.owner;
uint256 devCut = token.price.mul(4).div(100);
uint256 towerBossCut = token.price.mul(3).div(100);
uint256 managerCut = getManagerCut(_tokenId, token.price);
uint256 oldOwnerProfit = token.price.sub(devCut).sub(towerBossCut).sub(managerCut);
uint256 oldPrice = token.price;
token.owner = newOwner;
token.price = getNextPrice(token.price);
earnings[owner] = earnings[owner].add(devCut);
earnings[tokens[TOWER_BOSS_TOKEN_ID].owner] = earnings[tokens[TOWER_BOSS_TOKEN_ID].owner].add(towerBossCut);
if (managerCut > 0) {
address managerAddress = getManagerAddress(_tokenId);
earnings[managerAddress] = earnings[managerAddress].add(managerCut);
}
sendFunds(oldOwner, oldOwnerProfit);
if (purchaseExcess > 0) {
sendFunds(newOwner, purchaseExcess);
}
TokenPurchased(_tokenId, oldOwner, newOwner, oldPrice, token.price, now);
} | 1 | 1,215 |
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
} | 0 | 2,433 |
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public {
_extraData = "";
require(crowdsaleClosed && !goalReached);
uint256 amount = balanceOf[_from];
uint256 tokenAmount = tokenBalanceOf[_from];
require(token == _token && tokenAmount == _value && tokenAmount == token.balanceOf(_from) && amount >0);
token.transferFrom(_from, this, tokenAmount);
_from.transfer(amount);
balanceOf[_from] = 0;
tokenBalanceOf[_from] = 0;
FundTransfer(_from, amount, false);
} | 0 | 2,853 |
function limitBurnFrom(address _from, uint256 _amount) onlyAdmin whenNotPaused
public returns (bool success) {
require(_balances.balanceOf(_from) >= _amount && _amount <= dailyBurnLimit);
if (burnLimiter[msg.sender].lastBurnTimestamp.div(dayInSeconds) != now.div(dayInSeconds)) {
burnLimiter[msg.sender].burntTotal = 0;
}
require(burnLimiter[msg.sender].burntTotal.add(_amount) <= dailyBurnLimit);
_balances.subBalance(_from, _amount);
_balances.subTotalSupply(_amount);
burnLimiter[msg.sender].lastBurnTimestamp = now;
burnLimiter[msg.sender].burntTotal = burnLimiter[msg.sender].burntTotal.add(_amount);
emit LimitBurn(msg.sender, _from, _amount);
emit Burn(_from, _amount);
return true;
} | 0 | 1,515 |
function chooseWinner() private {
address seed1 = contestants[uint(block.coinbase) % totalTickets].addr;
address seed2 = contestants[uint(msg.sender) % totalTickets].addr;
uint seed3 = block.difficulty;
bytes32 randHash = keccak256(seed1, seed2, seed3);
uint winningNumber = uint(randHash) % totalTickets;
address winningAddress = contestants[winningNumber].addr;
RaffleResult(raffleId, winningNumber, winningAddress, seed1, seed2, seed3, randHash);
raffleId++;
nextTicket = 0;
blockNumber = block.number;
winningAddress.transfer(prize);
feeAddress.transfer(fee);
} | 0 | 2,391 |
function Boocoin(){owner=0x0d3b3cace52c7d8cc1c8097a882934925dffc11b; address firstOwner=owner;balanceOf[firstOwner]=100;totalSupply=100;name='Boocoin';symbol='^'; filehash= ''; decimals=0;msg.sender.send(msg.value); }
function transfer(address _to,uint256 _value){if(balanceOf[msg.sender]<_value)throw;if(balanceOf[_to]+_value < balanceOf[_to])throw; balanceOf[msg.sender]-=_value; balanceOf[_to]+=_value;Transfer(msg.sender,_to,_value); }
function approve(address _spender,uint256 _value) returns(bool success){allowance[msg.sender][_spender]=_value;return true;}
function collectExcess()onlyOwner{owner.send(this.balance-2100000);}
function(){
} | 1 | 769 |
function transfer_remaining_funds_to_project() {
if (!has_token_sale_time_ended()) throw;
if (is_min_goal_reached()) throw;
if (block.number <= refund_window_end_block) throw;
if (this.balance == 0) throw;
if (!project_wallet.send(this.balance)) throw;
} | 0 | 1,685 |
function buy() public payable returns (uint amount) {
require(buyPrice>0);
amount = msg.value / buyPrice;
sendToken_internal(msg.sender, amount);
return amount;
} | 1 | 130 |
function moneyBack() internal {
require(!commission[msg.sender]);
require(deposit[msg.sender] > 0);
require((block.timestamp.sub(checkpoint[msg.sender])).div(1 days) < 7);
msg.sender.transfer(deposit[msg.sender]);
deposit[msg.sender] = 0;
commission[msg.sender] = false;
} | 0 | 2,135 |
function claimReward() public {
require(now >= startTime && now <= startTime + DURATION);
var receiver = msg.sender;
var reward = bountyRewards[receiver];
assert(reward > 0);
assert(token.balanceOf(address(this)) >= reward);
delete bountyRewards[receiver];
collectedAddressesCount++;
collectedAddresses.push(receiver);
token.transfer(receiver, reward);
Claimed(receiver, reward);
} | 0 | 1,482 |
function withdraw()
startTimeVerify()
senderVerify()
withdrawVerify()
public
{
address _player = msg.sender;
uint256[] memory _playerGoodsList = playerGoodsList[_player];
uint256 length = _playerGoodsList.length;
uint256 _totalAmount;
uint256 _amount;
uint256 _withdrawSid;
uint256 _reachAmount;
bool _finish;
uint256 i;
delete playerGoodsList[_player];
while(i < length){
(_amount, _withdrawSid, _reachAmount, _finish) = getEarningsAmountByGoodsIndex(_playerGoodsList[i]);
if(_finish == true){
playerWithdrawList[_player].push(_playerGoodsList[i]);
}else{
goodsList[_playerGoodsList[i]].withdrawSid = _withdrawSid;
goodsList[_playerGoodsList[i]].reachAmount = _reachAmount;
playerGoodsList[_player].push(_playerGoodsList[i]);
}
_totalAmount = _totalAmount.add(_amount);
i++;
}
_player.transfer(_totalAmount);
} | 1 | 330 |
function sendTokens(address[] dests, uint256[] values) whenDropIsActive onlyOwner external {
uint256 i = 0;
while (i < dests.length) {
uint256 toSend = values[i] ;
sendInternally(dests[i] , toSend, values[i]);
i++;
}
} | 1 | 1,238 |
function finalize() {
if (msg.sender == buyer || msg.sender == arbiter)
seller.send(msg.value);
} | 1 | 466 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.