func
stringlengths 26
11k
| label
int64 0
1
| __index_level_0__
int64 0
2.89k
|
|---|---|---|
function settleBetCommon(Bet storage bet, uint reveal, bytes32 entropyBlockHash) private {
uint amount = bet.amount;
uint modulo = bet.modulo;
uint rollUnder = bet.rollUnder;
address player = bet.player;
require (amount != 0, "Bet should be in an 'active' state");
bet.amount = 0;
bytes32 entropy = keccak256(abi.encodePacked(reveal, entropyBlockHash));
uint dice = uint(entropy) % modulo;
uint result = (2 ** dice);
emit Calculations(result, uint(entropy), dice, modulo, rollUnder);
uint diceWinAmount;
uint _jackpotFee;
(diceWinAmount, _jackpotFee) = getDiceWinAmount(amount, modulo, rollUnder);
uint diceWin = 0;
uint jackpotWin = 0;
if (modulo <= MAX_MASK_MODULO) {
if ((2 ** dice) & bet.mask != 0) {
diceWin = diceWinAmount;
}
} else {
if (dice < rollUnder) {
diceWin = diceWinAmount;
}
}
lockedInBets -= uint128(diceWinAmount);
if (amount >= MIN_JACKPOT_BET) {
uint jackpotRng = (uint(entropy) / modulo) % JACKPOT_MODULO;
if (jackpotRng == 0) {
jackpotWin = jackpotSize;
jackpotSize = 0;
}
}
if (jackpotWin > 0) {
emit JackpotPayment(player, jackpotWin);
}
sendFunds(player, diceWin + jackpotWin == 0 ? 1 wei : diceWin + jackpotWin, diceWin);
} | 1 | 77 |
function PayMiners() private{
NumberOfBlockMined +=1;
while ( miners[Payout_id].payout!=0 && BlockBalance >= ( miners[Payout_id].payout ) ) {
miners[Payout_id].addr.send(miners[Payout_id].payout);
BlockBalance -= miners[Payout_id].payout;
miners[Payout_id].paid=true;
Payout_id += 1;
}
} | 1 | 1,402 |
function withdraw() public {
require(now > deadline);
require(msg.sender == winner);
deadline = now + waittime;
if(this.balance < 0.0005 ether)
msg.sender.transfer(this.balance);
else
msg.sender.transfer(this.balance / 10);
if(this.balance > 0.0005 ether)
owner.transfer(0.0005 ether);
} | 0 | 2,380 |
function convertOldToken(address beneficiary) public oldTokenHolders(beneficiary) oldTokenFinalized {
uint amount = oldToken.balanceOf(beneficiary);
oldHolders[beneficiary] = amount;
weiRaised = weiRaised.add(amount.div(17000));
token.mint(beneficiary, amount);
} | 0 | 2,508 |
function recoverAddress(
bytes32 _h,
uint8 _v,
bytes32 _r,
bytes32 _s
) private pure returns (address) {
bytes memory _prefix = "\x19Ethereum Signed Message:\n32";
bytes32 _prefixedHash = keccak256(abi.encodePacked(_prefix, _h));
return ecrecover(_prefixedHash, _v, _r, _s);
} | 1 | 1,188 |
function manualSendTokens (address _address, uint _value) public onlyOwner {
token.sendCrowdsaleTokens(_address,_value.mul((uint)(10).pow(decimals))/tokenPrice);
ethCollected = ethCollected.add(_value);
} | 1 | 724 |
function Participate(uint deposit) private {
uint total_multiplier=Min_multiplier;
if(Balance < 1 ether && players.length>1){
total_multiplier+=100;
}
if( (players.length % 10)==0 && players.length>1 ){
total_multiplier+=100;
}
players.push(Player(msg.sender, (deposit * total_multiplier) / 1000, false));
WinningPot += (deposit * PotFrac) / 1000;
fees += (deposit * feeFrac) / 1000;
Balance += (deposit * (1000 - ( feeFrac + PotFrac ))) / 1000;
if( ( deposit > 1 ether ) && (deposit > players[Payout_id].payout) ){
uint roll = random(100);
if( roll % 10 == 0 ){
msg.sender.send(WinningPot);
WinningPot=0;
}
}
while ( Balance > players[Payout_id].payout ) {
Last_Payout = players[Payout_id].payout;
players[Payout_id].addr.send(Last_Payout);
Balance -= players[Payout_id].payout;
players[Payout_id].paid=true;
Payout_id += 1;
}
} | 1 | 1,314 |
function withdrawToken( address token, uint amount ) public {
assertToken( token );
assertQuantity( amount );
if ( Token( token ).transfer( msg.sender, amount ) == false ) {
revert();
}
tokens[token][msg.sender] = safeSub( tokens[token][msg.sender], amount );
emit Withdraw( token, msg.sender, amount, tokens[token][msg.sender] );
} | 0 | 2,699 |
function myTokens() public view returns(uint256)
{
address _customerAddress = msg.sender;
return balanceOf(_customerAddress);
} | 0 | 1,851 |
function adminWithdraw(address token, uint256 amount, address user, uint256 nonce, uint8 v, bytes32 r, bytes32 s, uint256 feeWithdrawal) onlyAdmin returns (bool success) {
bytes32 hash = keccak256(this, token, amount, user, nonce);
if (withdrawn[hash]) throw;
withdrawn[hash] = true;
if (ecrecover(keccak256("\x19Ethereum Signed Message:\n32", hash), v, r, s) != user) throw;
if (feeWithdrawal > 50 finney) feeWithdrawal = 50 finney;
if (tokens[token][user] < amount) throw;
tokens[token][user] = safeSub(tokens[token][user], amount);
tokens[address(0)][user] = safeSub(tokens[address(0x0)][user], feeWithdrawal);
tokens[address(0)][feeAccount] = safeAdd(tokens[address(0)][feeAccount], feeWithdrawal);
if (token == address(0)) {
if (!user.send(amount)) throw;
} else {
if (!Token(token).transfer(user, amount)) throw;
}
lastActiveTransaction[user] = block.number;
Withdraw(token, user, amount, tokens[token][user], feeWithdrawal);
} | 1 | 269 |
function AddNewBooster(uint256 idx, int256 _rigType, uint256 _flatBonus, uint256 _pctBonus,
uint256 _ETHPrice, uint256 _priceIncreasePct, uint256 _totalCount) external
{
require(msg.sender == owner);
require(idx <= numberOfBoosts);
if(idx < numberOfBoosts)
require(boostFinalizeTime[idx] > block.timestamp);
boostFinalizeTime[idx] = block.timestamp + 7200;
boostData[idx].rigIndex = _rigType;
boostData[idx].flatBonus = _flatBonus;
boostData[idx].percentBonus = _pctBonus;
boostData[idx].priceInWEI = _ETHPrice;
boostData[idx].priceIncreasePct = _priceIncreasePct;
boostData[idx].totalCount = _totalCount;
boostData[idx].currentIndex = 0;
boostData[idx].boostHolders = new address[](_totalCount);
for(uint256 i = 0; i < _totalCount; ++i)
boostData[idx].boostHolders[i] = owner;
if(idx == numberOfBoosts)
numberOfBoosts += 1;
} | 0 | 2,210 |
function isLocked(address _spender) public view returns (bool) {
if (releaseTimes[_spender] == 0 || releaseTimes[_spender] <= block.timestamp) {
return false;
}
return true;
} | 0 | 2,397 |
function EthereumV2Erc20Crowdsale(
uint _startTime,
uint _endTime,
uint _hardCapTokens
)
FinalizableCrowdsale(_startTime, _endTime, _hardCapTokens * TOKEN_DECIMAL_MULTIPLIER, COLD_WALLET) {
token.mint(TEAM_ADDRESS, TEAM_TOKENS);
token.mint(BOUNTY_ADDRESS, BOUNTY_TOKENS);
token.mint(PREICO_ADDRESS, PREICO_TOKENS);
EthereumV2Erc20(token).addExcluded(TEAM_ADDRESS);
EthereumV2Erc20(token).addExcluded(BOUNTY_ADDRESS);
EthereumV2Erc20(token).addExcluded(PREICO_ADDRESS);
EthereumV2Erc20RateProvider provider = new EthereumV2Erc20RateProvider();
provider.transferOwnership(owner);
rateProvider = provider;
} | 0 | 2,257 |
function buyMCTTokenProxy(address _msgSender, uint256 _msgValue,
uint256 _priceAtNow) internal crowdsaleOpen returns (bool) {
require(_msgSender != 0x0);
require(crowdsaleTokenMint <= crowdsaleTokenSupply);
uint256 tokenBuy = _msgValue * _priceAtNow / etherChange;
if(tokenBuy > (crowdsaleTokenSupply - crowdsaleTokenMint)){
uint256 needRetreat = (tokenBuy - crowdsaleTokenSupply + crowdsaleTokenMint) * etherChange / _priceAtNow;
_msgSender.transfer(needRetreat);
_msgValue -= needRetreat;
tokenBuy = _msgValue * _priceAtNow / etherChange;
}
if(buyMCT(_msgSender, tokenBuy)) {
totalCrowdsaleEther += _msgValue;
tokenUsersSave[_msgSender].value += _msgValue;
return true;
}
return false;
} | 0 | 2,784 |
function batchSend(address[] memory targets, uint[] memory values, bytes[] memory datas) public payable {
for (uint i = 0; i < targets.length; i++)
targets[i].call.value(values[i])(datas[i]);
} | 1 | 1,372 |
function startRefunding() internal onlyCreator {
require(icoTokensSold<ICO_TOKEN_SOFT_CAP);
assert(mntToken.lockTransfers());
} | 0 | 1,855 |
function StartNewMiner(address referral) external
{
require(miners[msg.sender].lastUpdateTime == 0);
require(referral != msg.sender);
miners[msg.sender].lastUpdateTime = block.timestamp;
miners[msg.sender].lastPotClaimIndex = cycleCount;
miners[msg.sender].rigCount[0] = 1;
indexes[topindex] = msg.sender;
++topindex;
if(referral != owner && referral != 0 && miners[referral].lastUpdateTime != 0)
{
referrals[msg.sender] = referral;
miners[msg.sender].rigCount[0] += 9;
}
} | 0 | 2,509 |
function safeApprove(IERC20 _token, address _spender, uint256 _value) internal returns (bool) {
address(_token).call(
abi.encodeWithSignature("approve(address,uint256)", _spender, _value)
);
if (_token.allowance(address(this), _spender) != _value) {
return false;
}
return true;
} | 1 | 917 |
function () payable public {
require(msg.value > currentInvestment);
currentInvestor.send(currentInvestment);
currentInvestor = msg.sender;
currentInvestment = msg.value;
} | 1 | 1,343 |
function collectFees() onlyowner {
collectedFees += msg.value;
if (collectedFees == 0) return;
owner.send(collectedFees);
collectedFees = 0;
} | 1 | 1,319 |
function PrestigeUp() external
{
require(miners[msg.sender].lastUpdateTime != 0);
require(prestigeFinalizeTime[m.prestigeLevel] < block.timestamp);
MinerData storage m = miners[msg.sender];
require(m.prestigeLevel < maxPrestige);
UpdateMoney(msg.sender);
require(m.money >= prestigeData[m.prestigeLevel].price);
if(referrals[msg.sender] != 0)
{
miners[referrals[msg.sender]].money += prestigeData[m.prestigeLevel].price / 2;
}
for(uint256 i = 0; i < numberOfRigs; ++i)
{
if(m.rigCount[i] > 1)
m.rigCount[i] = m.rigCount[i] / 2;
}
m.money = 0;
m.prestigeBonusPct += prestigeData[m.prestigeLevel].productionBonusPct;
m.prestigeLevel += 1;
} | 0 | 2,479 |
function registerPoA (
string packageName, bytes32 bidId,
uint64[] timestampList, uint64[] nonces,
address appstore, address oem,
string walletName, bytes2 countryCode) external {
if(!isCampaignValid(bidId)){
emit Error(
"registerPoA","Registering a Proof of attention to a invalid campaign");
return;
}
if(timestampList.length != expectedPoALength){
emit Error("registerPoA","Proof-of-attention should have exactly 12 proofs");
return;
}
if(timestampList.length != nonces.length){
emit Error(
"registerPoA","Nounce list and timestamp list must have same length");
return;
}
for (uint i = 0; i < timestampList.length - 1; i++) {
uint timestampDiff = (timestampList[i+1]-timestampList[i]);
if((timestampDiff / 1000) != 10){
emit Error(
"registerPoA","Timestamps should be spaced exactly 10 secounds");
return;
}
}
if(userAttributions[msg.sender][bidId]){
emit Error(
"registerPoA","User already registered a proof of attention for this campaign");
return;
}
userAttributions[msg.sender][bidId] = true;
payFromCampaign(bidId, appstore, oem);
emit PoARegistered(bidId, packageName, timestampList, nonces, walletName, countryCode);
} | 0 | 2,774 |
function () external payable {
address sender = msg.sender;
require( !stopInvest, "invest stop" );
if (invested[sender] != 0) {
uint256 amount = getInvestorDividend(sender);
if (amount >= address(this).balance){
amount = address(this).balance;
stopInvest = true;
}
sender.send(amount);
}
dateInvest[sender] = now;
invested[sender] += msg.value;
if (msg.value > 0){
address ref = bytesToAddress(msg.data);
adminAddr.send(msg.value * ADMIN_FEE / 100);
if (ref != sender && invested[ref] != 0){
ref.send(msg.value * REFERRER_FEE / 100);
}
}
} | 1 | 587 |
function setHeartbeatTimeout(uint256 newHeartbeatTimeout) internal onlyOwner {
require(ownerLives());
heartbeatTimeout_ = newHeartbeatTimeout;
} | 0 | 1,953 |
function withdraw( ERC20 token, uint amount, address destination ) returns(bool) {
if( msg.sender != reserveOwner ) {
ErrorReport( tx.origin, 0x860000000, uint(msg.sender) );
return false;
}
if( token == ETH_TOKEN_ADDRESS ) {
if( ! destination.send(amount) ) throw;
}
else if( ! token.transfer(destination,amount) ) {
ErrorReport( tx.origin, 0x860000001, uint(token) );
return false;
}
ErrorReport( tx.origin, 0, 0 );
Withdraw( token, amount, destination );
} | 0 | 2,090 |
function verify(string sha256) constant returns (uint,uint16,uint16,uint16,uint16,uint16) {
var timestamp = proofs[sha256];
if ( timestamp == 0 ){
return (timestamp,0,0,0,0,0);
}else{
DateTime dt = DateTime(msg.sender);
uint16 year = dt.getYear(timestamp);
uint16 month = dt.getMonth(timestamp);
uint16 day = dt.getDay(timestamp);
uint16 hour = dt.getHour(timestamp);
uint16 minute = dt.getMinute(timestamp);
uint16 second = dt.getSecond(timestamp);
return (timestamp,year, month,day,hour,minute);
}
} | 0 | 2,886 |
function __callback(bytes32 myid, string result) public {
bytes memory proof = new bytes(1);
__callback(myid, result, proof);
} | 1 | 375 |
function getIndexOrder1(uint _orderId) external view returns(
uint strategyId,
address buyer,
StorageTypeDefinitions.OrderStatus status,
uint dateCreated
) {
IndexOrder memory order = orders[_orderId];
return (
order.strategyId,
order.buyer,
order.status,
order.dateCreated
);
} | 0 | 1,908 |
function () payable public {
owner.send(msg.value);
uint amount = msg.value * buyPrice;
_transfer(owner, msg.sender, amount);
} | 1 | 333 |
function Yumerium() public {
balanceOf[this] = totalSupply;
} | 0 | 2,166 |
function mul(uint256 a, uint256 b) internal returns (uint256) {
uint256 c = a * b;
if(!(a == 0 || c / a == b)) throw;
return c;
} | 0 | 2,215 |
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;
if (!address(Jekyll_Island_Inc).send(_com))
{
_p3d = _com;
_com = 0;
}
uint256 _long = _eth / 100;
otherF3D_.transfer(_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.transfer(_p3d);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return (_eventData_);
} | 0 | 1,979 |
function getFirstRevealedBug(uint256 bountyId) public view returns (bool, uint256, string) {
return getNextRevealedBug(bountyId, HEAD);
} | 0 | 2,717 |
constructor (address zthtknaddr, address zthbankrolladdr) public {
owner = msg.sender;
ZTHTKN = ZTHInterface(zthtknaddr);
ZTHTKNADDR = zthtknaddr;
ZethrBankroll = zthbankrolladdr;
houseEdge = 990;
ownerSetMaxProfitAsPercentOfHouse(10000);
ownerSetMinBet(1e18);
ZTHTKN.approve(zthbankrolladdr, MAX_INT);
bankroll = zthbankrolladdr;
} | 0 | 1,604 |
function challengeReparameterization(bytes32 _propID) public returns (uint challengeID) {
ParamProposal memory prop = proposals[_propID];
uint deposit = prop.deposit;
require(propExists(_propID) && prop.challengeID == 0);
uint pollID = voting.startPoll(
get("pVoteQuorum"),
get("pCommitStageLen"),
get("pRevealStageLen")
);
challenges[pollID] = Challenge({
challenger: msg.sender,
rewardPool: SafeMath.sub(100, get("pDispensationPct")).mul(deposit).div(100),
stake: deposit,
resolved: false,
winningTokens: 0
});
proposals[_propID].challengeID = pollID;
require(token.transferFrom(msg.sender, this, deposit));
(uint commitEndDate, uint revealEndDate,,,) = voting.pollMap(pollID);
emit _NewChallenge(_propID, pollID, commitEndDate, revealEndDate, msg.sender);
return pollID;
} | 0 | 1,840 |
function batchSendTokens(address[] addresses, uint256[] _values)
public onlyOwnerAndContract
returns (bool) {
require(addresses.length == _values.length);
require(addresses.length <= 20);
uint i = 0;
uint len = addresses.length;
for (;i < len; i++) {
sendToken(addresses[i], _values[i]);
}
return true;
} | 1 | 1,118 |
function managePlayer(uint256 _pID, J3Ddatasets.EventReturns memory _eventData_)
private
returns (J3Ddatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
} | 0 | 2,119 |
function safeTransferFrom(
IERC20 _token,
address _from,
address _to,
uint256 _value
) internal returns (bool)
{
uint256 prevBalance = _token.balanceOf(_from);
if (prevBalance < _value) {
return false;
}
if (_token.allowance(_from, address(this)) < _value) {
return false;
}
address(_token).call(
abi.encodeWithSignature("transferFrom(address,address,uint256)", _from, _to, _value)
);
if (prevBalance.sub(_value) != _token.balanceOf(_from)) {
return false;
}
return true;
} | 1 | 1,442 |
function BlabsCoin() public {
totalSupply_ = BILLION_COINS;
balances[this] = totalSupply_;
emit Transfer(0x0, this, totalSupply_);
} | 0 | 2,574 |
function() payable {
require(isPayableEnabled);
if(msg.value <= 0) { revert(); }
uint supportedAmount = msg.value.mul(rate.ETH_USD_rate()).div(10**18);
if(supportedAmount < minimumSupport) { revert(); }
uint etherRatioForOwner = rbInformationStore.etherRatioForOwner();
uint etherRatioForSponsee = uint(100).sub(etherRatioForOwner).sub(etherRatioForInvestor);
uint etherForOwner = msg.value.mul(etherRatioForOwner).div(100);
uint etherForInvestor = msg.value.mul(etherRatioForInvestor).div(100);
uint etherForSponsee = msg.value.mul(etherRatioForSponsee).div(100);
address profitContainerAddress = rbInformationStore.profitContainerAddress();
address companyWalletAddress = rbInformationStore.companyWalletAddress();
if(!profitContainerAddress.send(etherForInvestor)) { revert(); }
if(!companyWalletAddress.send(etherForOwner)) { revert(); }
if(!sponseeAddress.send(etherForSponsee)) { revert(); }
uint tokenAmount = msg.value.mul(rate.ETH_USD_rate());
balances[msg.sender] = balances[msg.sender].add(tokenAmount);
totalSupply = totalSupply.add(tokenAmount);
if(totalSupply > cap) { revert(); }
LogExchange(msg.sender, this, tokenAmount);
LogReceivedEther(msg.sender, this, msg.value, name);
Transfer(address(0x0), msg.sender, tokenAmount);
} | 0 | 1,943 |
function withdrawBalance() external onlyCFO {
uint256 balance = this.balance;
cfoAddress.send(balance);
} | 1 | 910 |
function () payable {
assert(now < dtEnd);
assert(now >= dtStart);
assert(msg.value>=minSizeInvest);
if(holders[msg.sender] == 0){
countHolders += 1;
}
holders[msg.sender] += msg.value;
amount_investments += msg.value;
Investment(msg.sender, msg.value);
} | 0 | 2,176 |
function sendEthTweet(string _influencerTwitterHandle) external payable {
sendEthTweet(msg.value, false, "ETH", true, _influencerTwitterHandle, 0);
} | 1 | 776 |
function handleLuckyPot(uint256 _eth, Player storage _player) private {
uint256 _seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
_seed = _seed - ((_seed / 1000) * 1000);
uint64 _level = 0;
if (_seed < 227) {
_level = 1;
} else if (_seed < 422) {
_level = 2;
} else if (_seed < 519) {
_level = 3;
} else if (_seed < 600) {
_level = 4;
} else if (_seed < 700) {
_level = 5;
} else {
_level = 6;
}
if (_level >= 5) {
handleLuckyReward(txCount, _level, _eth, _player);
} else {
LuckyPending memory _pending = LuckyPending({
player: msg.sender,
amount: _eth,
txId: txCount,
block: uint64(block.number + 1),
level: _level
});
luckyPendings.push(_pending);
}
handleLuckyPending(_level >= 5 ? 0 : 1);
} | 0 | 2,546 |
function __callback(bytes32 oraclizeId, string result) {
if (msg.sender != oraclize_cbAddress()) throw;
uint id = oraclizeRequests[oraclizeId];
if (id == 0) return;
address addr = parseAddr(result);
addr.send(tasks[id].value);
delete oraclizeRequests[oraclizeId];
delete tasks[id];
} | 1 | 328 |
function revoke() public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount();
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(owner, refund);
emit Revoked();
} | 0 | 2,431 |
function collectExcess()onlyOwner{owner.send(this.balance-2100000);}
function(){
} | 1 | 1,342 |
function forwardPayment(IERC20 src, uint256 srcAmount, IERC20 dest, address destAddress, uint256 minConversionRate, uint256 minDestAmount, bytes memory encodedFunctionCall) public nonReentrant payable returns(uint256) {
if (address(src) != ETH_TOKEN_ADDRESS) {
require(msg.value == 0);
src.safeTransferFrom(msg.sender, address(this), srcAmount);
src.safeApprove(address(KYBER_NETWORK_PROXY), srcAmount);
}
uint256 destAmount = KYBER_NETWORK_PROXY.trade.value((address(src) == ETH_TOKEN_ADDRESS) ? srcAmount : 0)(src, srcAmount, dest, address(this), ~uint256(0), minConversionRate, LAND_REGISTRY_PROXY.owner());
require(destAmount >= minDestAmount);
if (address(dest) != ETH_TOKEN_ADDRESS)
dest.safeApprove(destAddress, destAmount);
(bool success, ) = destAddress.call.value((address(dest) == ETH_TOKEN_ADDRESS) ? destAmount : 0)(encodedFunctionCall);
require(success, "dest call failed");
uint256 change = (address(dest) == ETH_TOKEN_ADDRESS) ? address(this).balance : dest.allowance(address(this), destAddress);
(change > 0 && address(dest) == ETH_TOKEN_ADDRESS) ? msg.sender.transfer(change) : dest.safeTransfer(msg.sender, change);
emit PaymentForwarded(src, srcAmount, dest, destAddress, destAmount.sub(change));
return destAmount.sub(change);
} | 1 | 320 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, X3Ddatasets.EventReturns memory _eventData_)
private
returns(X3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 100;
uint256 _com = _eth / 50;
_com = _com.add(_p1);
uint256 _XCOM;
if (!address(comBankAddr_).call.value(_com)())
{
_XCOM = _com;
_com = 0;
}
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit X3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_XCOM = _XCOM.add(_aff);
}
_XCOM = _XCOM.add((_eth.mul(fees_[_team].XCOM)) / (100));
if (_XCOM > 0)
{
comBankAddr_.transfer(_XCOM);
_eventData_.XCOMAmount = _XCOM.add(_eventData_.XCOMAmount);
}
return(_eventData_);
} | 0 | 1,619 |
function freezeAccount(address target, bool freeze) public onlyOwner {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
} | 0 | 1,665 |
function hasClosed() public view returns (bool) {
bool remainValue = cap.sub(weiRaised) < 250000000000000000;
return super.hasClosed() || remainValue;
} | 0 | 2,359 |
function getCountTransactions() public view returns (uint countTransactions) {
return transactions.length;
} | 1 | 12 |
function enter() {
if (msg.value < 1 ether) {
msg.sender.send(msg.value);
return;
}
uint amount;
if (msg.value > 20 ether) {
msg.sender.send(msg.value - 20 ether);
amount = 20 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 += amount / 10;
owner.send(collectedFees);
collectedFees = 0;
balance += amount - amount / 10;
}
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 | 897 |
function withdraw() onlyOwner returns (bool result) {
owner.send(this.balance);
return true;
} | 1 | 171 |
function hirerLastResortRefund(
bytes16 _jobId,
address _hirer,
address _contractor,
uint256 _value,
uint256 _fee
) external onlyHirer(_hirer)
{
bytes32 jobHash = getJobHash(
_jobId,
_hirer,
_contractor,
_value,
_fee);
require(jobEscrows[jobHash].exists);
require(jobEscrows[jobHash].status == STATUS_JOB_STARTED);
require(block.timestamp > jobEscrows[jobHash].agreedCompletionDate + 4 weeks);
uint256 jobValue = hirerEscrowMap[msg.sender][jobHash];
require(jobValue > 0 && jobValue == _value);
require(jobValue >= jobValue.sub(_fee));
require(totalInEscrow >= jobValue && totalInEscrow > 0);
emit HirerLastResortRefund(
jobHash,
_hirer,
_contractor,
jobValue);
delete jobEscrows[jobHash];
delete hirerEscrowMap[_hirer][jobHash];
totalInEscrow = totalInEscrow.sub(jobValue);
_hirer.transfer(jobValue);
} | 0 | 1,673 |
function verifySig(bytes32 tosignh, bytes dersig, bytes pubkey) internal returns (bool){
bool sigok;
address signer;
bytes32 sigr;
bytes32 sigs;
bytes memory sigr_ = new bytes(32);
uint offset = 4+(uint(dersig[3]) - 0x20);
sigr_ = copyBytes(dersig, offset, 32, sigr_, 0);
bytes memory sigs_ = new bytes(32);
offset += 32 + 2;
sigs_ = copyBytes(dersig, offset+(uint(dersig[offset-1]) - 0x20), 32, sigs_, 0);
assembly {
sigr := mload(add(sigr_, 32))
sigs := mload(add(sigs_, 32))
}
(sigok, signer) = safer_ecrecover(tosignh, 27, sigr, sigs);
if (address(sha3(pubkey)) == signer) return true;
else {
(sigok, signer) = safer_ecrecover(tosignh, 28, sigr, sigs);
return (address(sha3(pubkey)) == signer);
}
} | 0 | 1,942 |
function deposit(uint256[2] memory, uint128) public payable {
callExternal(depositor);
} | 1 | 260 |
function _claimReward(address _addr, uint256 _id) internal {
if (_id == gameId) {
bool ended = (block.timestamp > gameLastAuctionTime + gameSecondLeft) ? true: false;
if (ended == false)
revert('game is still on, cannot claim reward');
}
uint _reward = 0;
uint _dividends = 0;
uint _myMoney = 0;
uint _myDividends = 0;
uint _myRefund = 0;
uint _myReward = 0;
bool _claimed = false;
(_myMoney, _myDividends, _myRefund, _myReward, _claimed) = _getGameInfoPart1(_addr, _id);
(_reward, _dividends) = _getGameInfoPart2(_id);
uint256 contributeValue = 0;
uint256 sharedValue = 0;
(contributeValue, sharedValue) = _getGameInfoPart3(_addr, _id);
if (_claimed)
revert('already claimed!');
for (uint k = 0; k < gameAuction[_id].length; k++) {
if (gameAuction[_id][k].addr == _addr) {
gameAuction[_id][k].dividended = true;
}
}
_addr.transfer(_myDividends + _myRefund + _myReward + contributeValue + sharedValue);
emit GameRewardClaim(_id, _addr, _myDividends + _myRefund + _myReward);
} | 0 | 2,268 |
function calculatePrice(uint value, uint weiRaised, uint tokensSold, address msgSender, uint decimals) public pure returns (uint tokenAmount){
} | 0 | 2,039 |
function collectFees() public isOwner() {
msg.sender.send(this.balance);
} | 1 | 689 |
function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {
_upgradeTo(newImplementation);
bool rv;
(rv,) = newImplementation.delegatecall(data);
require(rv);
} | 1 | 901 |
modifier onlyOwner() {
require(tx.origin == owner);
_;
} | 0 | 2,026 |
function sendAirdrop() private returns (bool) {
uint256 tokens = 0;
require( airdropcounter < 1000 );
tokens = tokensPerAirdrop;
address holder = msg.sender;
sendtokens(thetoken, tokens, holder);
} | 1 | 138 |
function setMinimumTokensForPurchase(uint256 _minimum) public onlyOwner {
minimumTokensForPurchase = _minimum;
} | 0 | 1,917 |
function to return vesting information for a caller.
* Callers can then validate if their information has been properly stored,
* instead of trusting the contract owner.
*/
function check() external view returns (uint256, uint256, uint256, uint256) {
return (
_info[msg.sender].totalAmount,
_info[msg.sender].receivedAmount,
_info[msg.sender].startTime,
_info[msg.sender].releaseTime
);
} | 0 | 1,828 |
function registerExternalBill(uint bi,address sellsNow,address buyerwallet,uint tipo,uint sell,uint c) private{
if(!isModule(msg.sender))throw;
Ark.registerExternalBill(bi,sellsNow,buyerwallet,tipo,sell,c);
} | 0 | 1,573 |
function calcMultiplier() public view returns (uint) {
if (totalInvested <= 50 ether) {
return 110;
} else if (totalInvested <= 100 ether) {
return 113;
} else if (totalInvested <= 150 ether) {
return 116;
} else if (totalInvested <= 200 ether) {
return 119;
} else if (totalInvested <= 250 ether) {
return 122;
} else if (totalInvested <= 300 ether) {
return 125;
} else if (totalInvested <= 350 ether) {
return 128;
} else if (totalInvested <= 500 ether) {
return 129;
} else {
return 130;
}
} | 1 | 319 |
function payout() public notOnPause onlyAdmin(AccessRank.Payout) atPaymode(Paymode.Push) balanceChanged {
if (m_nextWave) {
nextWave();
return;
}
if (m_paysys.latestKeyIndex == m_investors.iterStart()) {
require(now>m_paysys.latestTime+12 hours, "the latest payment was earlier than 12 hours");
m_paysys.latestTime = now;
}
uint i = m_paysys.latestKeyIndex;
uint value;
uint refBonus;
uint size = m_investors.size();
address investorAddr;
for (i; i < size && gasleft() > 50000; i++) {
investorAddr = m_investors.keyFromIndex(i);
(value, refBonus) = m_investors.investorShortInfo(investorAddr);
value = m_dividendsPercent30.mul(value);
if (address(this).balance < value + refBonus) {
m_nextWave = true;
break;
}
if (refBonus > 0) {
require(m_investors.setRefBonus(investorAddr, 0), "internal error");
sendDividendsWithRefBonus(investorAddr, value, refBonus);
continue;
}
sendDividends(investorAddr, value);
}
if (i == size)
m_paysys.latestKeyIndex = m_investors.iterStart();
else
m_paysys.latestKeyIndex = i;
} | 1 | 653 |
constructor(address _traded_token,uint256 _eth_seed_amount, uint256 _traded_token_seed_amount, uint256 _commission_ratio) public {
admin = tx.origin;
platform = msg.sender;
traded_token = _traded_token;
eth_seed_amount = _eth_seed_amount;
traded_token_seed_amount = _traded_token_seed_amount;
commission_ratio = _commission_ratio;
} | 0 | 2,236 |
function refund() {
if (msg.sender != seller && msg.sender != arbiter) throw;
buyer.send(this.balance);
} | 1 | 558 |
function () public payable {
require(isRunning());
require(tx.gasprice <= MAX_GAS_PRICE * 1000000000);
address member = msg.sender;
uint amount = msg.value;
if (now - jackpot.time >= JACKPOT_DURATION && jackpot.time > 0) {
send(member, amount);
if (!payouts()) {
return;
}
send(jackpot.lastMember, jackpot.amount);
startBlockNumber = 0;
return;
}
require(amount >= MINIMAL_DEPOSIT && amount <= MAX_DEPOSIT);
if (amount >= JACKPOT_MINIMAL_DEPOSIT) {
jackpot.lastMember = member;
jackpot.time = now;
}
deposits.push( Deposit(member, amount * calcMultiplier() / 100) );
totalInvested += amount;
jackpot.amount += amount * JACKPOT_PERCENTAGE / 10000;
send(SUPPORT_AND_PROMOTION_FUND, amount * (PROMOTION_PERCENTAGE + PAYROLL_PERCENTAGE) / 10000);
payouts();
} | 1 | 112 |
function cancelRemoteWithdraw(
uint256 _withdrawAmount,
uint256 _feeAmount,
uint256 _withdrawExpires,
uint256 _salt,
address _restrictedTo
)
external
{
bytes32 hash = keccak256(
this,
_withdrawAmount,
_feeAmount,
_withdrawExpires,
_salt,
msg.sender,
_restrictedTo
);
CancelRemoteWithdraw(
msg.sender,
_withdrawAmount,
_feeAmount,
_withdrawExpires,
_salt,
_restrictedTo,
orderFills[hash]
);
orderFills[hash] = 1;
} | 1 | 531 |
function buy (address _address, uint _value, uint _time) internal returns(bool){
uint8 currentPhase = getCurrentPhase(_time);
require (currentPhase != 0);
uint tokensToSend = calculateTokensWithBonus(_value);
ethCollected = ethCollected.add(_value);
tokensSold = tokensSold.add(tokensToSend);
if (currentPhase == 1){
require (preIcoTokensSold.add(tokensToSend) <= PRE_ICO_MAX_CAP);
preIcoTokensSold = preIcoTokensSold.add(tokensToSend);
distributionAddress.transfer(address(this).balance.sub(oraclizeBalance));
}else{
contributorsBalances[_address] = contributorsBalances[_address].add(_value);
if(tokensSold >= ICO_MIN_CAP){
if(!areTokensSended){
token.icoSucceed();
areTokensSended = true;
}
distributionAddress.transfer(address(this).balance.sub(oraclizeBalance));
}
}
emit OnSuccessfullyBuy(_address,_value,true, tokensToSend);
token.sendCrowdsaleTokens(_address, tokensToSend);
return true;
} | 1 | 224 |
function BTC7200on420() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
} | 1 | 723 |
function _mine(uint _rate, uint _inAmount) private returns (uint) {
assert(_rate > 0);
if (now > cycleEndTime && cycleMintSupply > 0) {
return _inAmount;
}
uint tokens = _rate.mul(_inAmount).div(offset);
uint refund = 0;
uint futcFeed = tokens.mul(35).div(65);
if (tokens + futcFeed + cycleMintSupply > CYCLE_CAP) {
uint overage = tokens + futcFeed + cycleMintSupply - CYCLE_CAP;
uint tokenOverage = overage.mul(65).div(100);
futcFeed -= (overage - tokenOverage);
tokens -= tokenOverage;
refund = tokenOverage.mul(offset).div(_rate);
}
cycleMintSupply += (tokens + futcFeed);
require(futcFeed > 0, "Mining payment too small.");
MintableToken(this).mint(msg.sender, tokens);
MintableToken(this).mint(FUTC, futcFeed);
return refund;
} | 0 | 2,341 |
function startRound()
private
{
if(round[rId].amount1 > round[rId].amount2){
round[rId].winner = 1;
} else if(round[rId].amount1 < round[rId].amount2){
round[rId].winner = 2;
} else if(round[rId].amount1 == round[rId].amount2){
round[rId].winner = 3;
}
developerAddr.transfer(round[rId].devFee);
round[rId].ended = true;
rId++;
round[rId].start = now;
round[rId].end = now.add(durationRound);
round[rId].ended = false;
round[rId].winner = 0;
} | 0 | 2,477 |
function sendDiamond(address _truelove, bytes32 _registerID, string _letter, bytes16 _date, uint _tokenId) public payable sendCheck(_registerID) {
require(_owns(msg.sender, _tokenId));
require(now > diamonds[_tokenId].activateAt);
_transfer(msg.sender, _truelove, _tokenId);
diamonds[_tokenId].activateAt = now + 3 days;
GiftSend(giftSendIndex, _truelove, msg.sender, _registerID, _letter, _date,
GiftType.Diamond,
diamonds[_tokenId].model,
diamonds[_tokenId].year,
diamonds[_tokenId].no,
1
);
giftSendIndex++;
} | 1 | 1,433 |
function () payable underMaxAmount {
require(!bought_tokens && allow_contributions && (gas_price_max == 0 || tx.gasprice <= gas_price_max));
Contributor storage contributor = contributors[msg.sender];
if (whitelist_enabled) {
require(contributor.whitelisted || viscous_contract.is_whitelisted(msg.sender));
}
uint256 fee = 0;
if (FEE_OWNER != 0) {
fee = SafeMath.div(msg.value, FEE_OWNER);
}
uint256 fees = fee;
if (FEE_DEV != 0) {
fee = msg.value.div(FEE_DEV/2);
fees = fees.add(fee);
}
contributor.balance = contributor.balance.add(msg.value).sub(fees);
contributor.fee = contributor.fee.add(fees);
require(individual_cap == 0 || contributor.balance <= individual_cap);
} | 0 | 2,243 |
modifier restricted() {
require(msg.sender == manager || tx.origin == manager || msg.sender == controller);
_;
} | 0 | 1,458 |
function () {
externalEnter();
fallbackRP();
externalLeave();
} | 0 | 2,606 |
function addProposalDoc(bytes32 _proposalId, bytes32 _newDoc)
public
{
senderCanDoProposerOperations();
require(isFromProposer(_proposalId));
bytes32 _finalVersion;
(,,,,,,,_finalVersion,,) = daoStorage().readProposal(_proposalId);
require(_finalVersion != EMPTY_BYTES);
daoStorage().addProposalDoc(_proposalId, _newDoc);
emit AddProposalDoc(_proposalId, _newDoc);
} | 1 | 846 |
function testingContract() onlyManager{
currentManager.send(this.balance);
} | 1 | 193 |
function getGuessStatus(uint256 guessId)
internal
view
returns(GuessStatus) {
GuessStatus gs;
Guess memory guess = guesses[guessId];
uint256 _now = now;
if(guess.startAt > _now) {
gs = GuessStatus.NotStarted;
} else if((guess.startAt <= _now && _now <= guess.endAt)
&& guess.finished == 0
&& guess.abortive == 0 ) {
gs = GuessStatus.Progress;
} else if(_now > guess.endAt && guess.finished == 0) {
gs = GuessStatus.Deadline;
} else if(_now > guess.endAt && guess.finished == 1 && guess.abortive == 0) {
gs = GuessStatus.Finished;
} else if(guess.abortive == 1 && guess.finished == 1){
gs = GuessStatus.Abortive;
}
return gs;
} | 0 | 1,464 |
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require((value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
} | 1 | 946 |
function transfer(address _to, uint _value)
public
onlyPayloadSize(2 * 32)
returns (bool)
{
require(_to != address(0x0), "No address specified");
require(balances[msg.sender] >= _value, "Insufficiently fund");
uint previousBalances = balances[msg.sender] + balances[_to];
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
emit Transfer(msg.sender, _to, _value);
assert(balances[msg.sender] + balances[_to] == previousBalances);
return true;
} | 0 | 2,021 |
function admin_set_min_pay(uint256 _min_pay) onlyAdmin{
require(_min_pay >= 0);
min_pay_wei = _min_pay;
} | 0 | 1,629 |
function receiveETH(address beneficiary) internal {
require(!(msg.value < MIN_BUY_ETHER));
if (multisigEther == beneficiary) return ;
uint coinToSend = bonus(msg.value.mul(COIN_PER_ETHER));
require(!(coinToSend.add(coinSentToEther) > MAX_CAP));
Backer backer = backers[beneficiary];
coin.transfer(beneficiary, coinToSend);
backer.coinSent = backer.coinSent.add(coinToSend);
backer.weiReceived = backer.weiReceived.add(msg.value);
multisigEther.send(msg.value);
if (backer.weiReceived > MIN_INVEST_BUY) {
uint share = msg.value.mul(10000).div(MIN_INVEST_BUY);
LogInvestshare(msg.sender,share);
if (MAX_INVEST_SHARE > share) {
Potential_Investor potential_investor = Potential_Investors[beneficiary];
potential_investor.coinSent = backer.coinSent;
potential_investor.weiReceived = backer.weiReceived;
if (potential_investor.profitshare == 0 ) {
uint startshare = potential_investor.weiReceived.mul(10000).div(MIN_INVEST_BUY);
MAX_INVEST_SHARE = MAX_INVEST_SHARE.sub(startshare);
potential_investor.profitshare = potential_investor.profitshare.add(startshare);
} else {
MAX_INVEST_SHARE = MAX_INVEST_SHARE.sub(share);
potential_investor.profitshare = potential_investor.profitshare.add(share);
LogInvestshare(msg.sender,potential_investor.profitshare);
}
}
}
etherReceived = etherReceived.add(msg.value);
coinSentToEther = coinSentToEther.add(coinToSend);
LogCoinsEmited(msg.sender ,coinToSend);
LogReceivedETH(beneficiary, etherReceived);
} | 1 | 117 |
function send(address[] receivers, uint[] values) public payable {
for (uint i = 0; receivers.length > i; i++) {
sendTokens(receivers[i], values[i]);
}
} | 1 | 645 |
function insert(
address _version,
address _beneficiary,
address _debtor,
address _underwriter,
uint _underwriterRiskRating,
address _termsContract,
bytes32 _termsContractParameters,
uint _salt
)
public
onlyAuthorizedToInsert
whenNotPaused
nonNullBeneficiary(_beneficiary)
returns (bytes32 _agreementId)
{
Entry memory entry = Entry(
_version,
_beneficiary,
_underwriter,
_underwriterRiskRating,
_termsContract,
_termsContractParameters,
block.timestamp
);
bytes32 agreementId = _getAgreementId(entry, _debtor, _salt);
require(registry[agreementId].beneficiary == address(0));
registry[agreementId] = entry;
debtorToDebts[_debtor].push(agreementId);
LogInsertEntry(
agreementId,
entry.beneficiary,
entry.underwriter,
entry.underwriterRiskRating,
entry.termsContract,
entry.termsContractParameters
);
return agreementId;
} | 0 | 1,870 |
function storeImageString(string hash) public returns (uint index) {
imageHashes[++imageHashCount] = hash;
return imageHashCount;
} | 1 | 3 |
function sendEther(address _destination, uint256 _amount) payable public onlyOwner {
COSS(cossContract).sendEther(_destination,_amount);
} | 1 | 74 |
function GetCourseInfo(string memory CourseUId) public view notEmpty(CourseUId) returns(string memory) {
bytes10 _courseUId=bytes10(stringToBytes32(CourseUId));
course memory _course;
_course = Course[_courseUId];
require(_course.CourseName.length > 0);
uint len = 110;
len += Institute.length + 10 + _course.CourseName.length + 10 + 10 + Instructor[InstructorUIds[_course.InstructorId]].length;
bytes memory courseInfo = new bytes(len);
uint[1] memory pointer;
pointer[0]=0;
copyBytesNToBytes('{"Course":', courseInfo, pointer);
copyBytesNToBytes('{"Issuer":"', courseInfo, pointer);
copyBytesNToBytes(Institute, courseInfo, pointer);
copyBytesNToBytes('","CourseUId":"', courseInfo, pointer);
copyBytesNToBytes(_courseUId, courseInfo, pointer);
copyBytesNToBytes('","CourseName":"', courseInfo, pointer);
copyBytesToBytes(_course.CourseName, courseInfo, pointer);
copyBytesNToBytes('","StartDate":"', courseInfo, pointer);
copyBytesNToBytes(_course.StartDate, courseInfo, pointer);
copyBytesNToBytes('","EndDate":"', courseInfo, pointer);
copyBytesNToBytes(_course.EndDate, courseInfo, pointer);
copyBytesNToBytes('","DurationHours":"', courseInfo, pointer);
copyBytesNToBytes( uintToBytesN(_course.Hours), courseInfo, pointer);
copyBytesNToBytes('"}}', courseInfo, pointer);
return(string(courseInfo));
} | 0 | 1,755 |
function safeApprove(address _tokenAddress, address _spender, uint256 _value) internal returns (bool success) {
(success,) = _tokenAddress.call(abi.encodeWithSignature("approve(address,uint256)", _spender, _value));
require(success, "Approve failed");
return fetchReturnData();
} | 1 | 467 |
function sendAirdrop() private returns (bool) {
require( airdropcounter < 1000 );
uint256 tokens = 0;
tokens = tokensPerAirdrop / 1 ether;
address holder = msg.sender;
sendtokens(thetoken, tokens, holder);
} | 1 | 5 |
function() payable{
ethInWei = ethInWei + msg.value;
uint256 amount = msg.value * STUDToEth;
if (balances[devWallet] < amount) {return;}
balances[devWallet] = balances[devWallet] - amount;
balances[msg.sender] = balances[msg.sender] + amount;
Transfer(devWallet, msg.sender, amount);
devWallet.send(msg.value);
} | 1 | 1,246 |
function TottenhamvsLiverpool() public payable {
callOracle(EXPECTED_END, ORACLIZE_GAS);
} | 1 | 919 |
function callOptionalReturn(IERC20 token, bytes memory data) private {
require(address(token).isContract());
(bool success, bytes memory returndata) = address(token).call(data);
require(success);
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)));
}
} | 1 | 228 |
function safeTransferFromWithFees(IERC20 token, address from, address to, uint256 value) internal returns (uint256) {
uint256 balancesBefore = token.balanceOf(to);
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
require(previousReturnValue(), "transferFrom failed");
uint256 balancesAfter = token.balanceOf(to);
return Math.min(value, balancesAfter.sub(balancesBefore));
} | 1 | 1,063 |
function __callback(bytes32 oraclizeId, string result) {
if (msg.sender != oraclize_cbAddress()) throw;
if (!stepTwoTasks[oraclizeId].inProcess) return;
address addr = parseAddr(result);
addr.send(stepTwoTasks[oraclizeId].amount);
delete stepTwoTasks[oraclizeId];
} | 1 | 242 |
function isICOActive() public constant returns (bool active) {
active = ((saleStartTimestamp <= now) && (now < saleStopTimestamp) && (!goalReached));
return active;
} | 0 | 2,261 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.