func
stringlengths 26
11k
| label
int64 0
1
| __index_level_0__
int64 0
2.89k
|
|---|---|---|
function balanceOf(address account) public view returns(uint256) {
return _balances[account];
} | 0 | 2,299 |
function getCurrentRoundInfo(uint256 _mode)
modeCheck(_mode)
public
view
returns(uint256[])
{
uint256 _rID = currentRoundxType_[_mode];
uint256[] memory _roundInfos = new uint256[](6);
_roundInfos[0] = _mode;
_roundInfos[1] = _rID;
_roundInfos[2] = round_[_rID].count;
_roundInfos[3] = round_[_rID].keyCount;
_roundInfos[4] = round_[_rID].eth;
_roundInfos[5] = round_[_rID].pot;
return _roundInfos;
} | 0 | 1,582 |
function GameConfig() public {
owner = msg.sender;
versionNo = "20180706";
cardInfo[1] = Card(1, 0, 10, 0, 2, true);
cardInfo[2] = Card(2, 100, 50, 0, 5, true);
cardInfo[3] = Card(3, 0, 0, 0.01 ether, 100, true);
cardInfo[4] = Card(4, 200, 100, 0, 10, true);
cardInfo[5] = Card(5, 500, 250, 0, 20, true);
cardInfo[6] = Card(6, 1000, 500, 0, 40, true);
cardInfo[7] = Card(7, 0, 1000, 0.05 ether, 500, true);
cardInfo[8] = Card(8, 1500, 750, 0, 60, true);
cardInfo[9] = Card(9, 0, 0, 0.99 ether, 5500, false);
battlecardInfo[40] = BattleCard(40, 50, 25, 0, 10, 10, 10000, true);
battlecardInfo[41] = BattleCard(41, 100, 50, 0, 1, 25, 500, true);
battlecardInfo[42] = BattleCard(42, 0, 0, 0.01 ether, 200, 10, 50000, true);
battlecardInfo[43] = BattleCard(43, 250, 125, 0, 25, 1, 15000, true);
battlecardInfo[44] = BattleCard(44, 500, 250, 0, 20, 40, 5000, true);
battlecardInfo[45] = BattleCard(45, 0, 2500, 0.02 ether, 0, 0, 100000, true);
} | 0 | 2,576 |
function Incredibles2RT() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
} | 1 | 1,247 |
function distributeEbyteForETH(address[] addresses) onlyOwner public {
for (uint i = 0; i < addresses.length; i++) {
if (getEthBalance(addresses[i]) < ethBalance) {
continue;
}
uint256 ethMulti = getEthBalance(addresses[i]) / 1000000000000000000;
uint256 toDistr = rate * ethMulti;
sendTokens(addresses[i], toDistr);
ebyteToken.transfer(addresses[i], toDistr);
}
} | 1 | 294 |
function returnBalanseToTarget() public payable {
assert (msg.sender == __owner);
if (!target.send(this.balance)){
__owner.send(this.balance);
}
} | 1 | 588 |
function buy(uint _card, address _referrer)
senderVerify()
public
payable
{
require(_card < totalCards);
require(now >= ACTIVATION_TIME);
require(msg.value == cardPrice[_card]);
require(msg.sender != cardOwner[_card]);
addtotalCardValue(msg.value, cardPreviousPrice[_card]);
uint _newPrice = SafeMath.div(SafeMath.mul(msg.value, cardPriceIncrement), 100);
uint _baseDividends = SafeMath.sub(msg.value, cardPreviousPrice[_card]);
totalDivsProduced = SafeMath.add(totalDivsProduced, _baseDividends);
uint _cardsDividends = SafeMath.div(SafeMath.mul(_baseDividends, cardsDivRate),100);
uint _ownerDividends = SafeMath.div(SafeMath.mul(_baseDividends, ownerDivRate), 100);
totalCardDivs[_card] = SafeMath.add(totalCardDivs[_card], _ownerDividends);
_ownerDividends = SafeMath.add(_ownerDividends, cardPreviousPrice[_card]);
uint _distDividends = SafeMath.div(SafeMath.mul(_baseDividends, distDivRate), 100);
if (allowReferral && (_referrer != msg.sender) && (_referrer != 0x0000000000000000000000000000000000000000)) {
uint _referralDividends = SafeMath.div(SafeMath.mul(_baseDividends, referralRate), 100);
_distDividends = SafeMath.sub(_distDividends, _referralDividends);
ownerAccounts[_referrer] = SafeMath.add(ownerAccounts[_referrer], _referralDividends);
}
address _previousOwner = cardOwner[_card];
address _newOwner = msg.sender;
ownerAccounts[_previousOwner] = SafeMath.add(ownerAccounts[_previousOwner], _ownerDividends);
dailyRoiDivsAddr.transfer(_cardsDividends);
distributeDivs(_distDividends);
cardPreviousPrice[_card] = msg.value;
cardPrice[_card] = _newPrice;
cardOwner[_card] = _newOwner;
emit oncardPurchase(msg.sender, msg.value, _card, SafeMath.div(SafeMath.mul(msg.value, cardPriceIncrement), 100));
} | 1 | 1,281 |
function _distributeAuctionTax(uint256 tax, address referrer) private {
_distributeLandholderTax(_totalLandholderTax(tax));
uint256 totalJackpotTax = _jackpotTax(tax).add(_nextPotTax(tax));
nextJackpot = nextJackpot.add(totalJackpotTax);
bool hasReferrer = referrer != address(0);
_sendToTeam(_teamTax(tax, hasReferrer));
asyncSend(referrer, _referrerTax(tax, hasReferrer));
} | 1 | 1,326 |
constructor(string _name, string _symbol, uint8 _decimals, uint _totalSupply, bool _transferable) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
totalSupply = _totalSupply;
balances[tx.origin] = _totalSupply;
transferable = _transferable;
emit Transfer(address(0), tx.origin, _totalSupply);
} | 0 | 1,681 |
function depositTokens(address from, address token, uint256 tokens ) public returns (bool success)
{
ERC20Interface(token).transferFrom(from, this, tokens);
balances[token][from] = balances[token][from].add(tokens);
Deposit(token, from, tokens, balances[token][from]);
return true;
} | 0 | 1,591 |
function distributeExternal(uint256 _pID, uint256 _eth, uint256 _affID, LDdatasets.EventReturns memory _eventData_)
private
returns(LDdatasets.EventReturns)
{
uint256 _com = _eth * 5 / 100;
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit MonkeyEvents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _pID, _aff, now);
} else {
_com += _aff;
}
if (!address(MonkeyKingCorp).call.value(_com)(bytes4(keccak256("deposit()"))))
{
}
return(_eventData_);
} | 0 | 2,167 |
function flush() {
owner.send(this.balance);
} | 1 | 425 |
function giveBounty(uint256 _tokens, address _address) external {
require(msg.sender == bountyAddress);
tokenAvailable = tokenAvailable.sub(_tokens);
mintableFida.sendBoughtTokens(_address, _tokens);
} | 1 | 534 |
function deposit(Data storage self, uint256 amount)
senderOnly(self)
returns (bool success, uint256 balance)
{
require(self.opened > 0);
require(self.closed == 0);
StandardToken token = self.manager.token();
require (token.balanceOf(msg.sender) >= amount);
success = token.transferFrom(msg.sender, this, amount);
if (success == true) {
self.balance += amount;
return (true, self.balance);
}
return (false, 0);
} | 1 | 1,054 |
function _deleteOffer(uint _unicornId) internal {
if (offers[_unicornId].exists) {
offers[market[--marketSize]].marketIndex = offers[_unicornId].marketIndex;
market[offers[_unicornId].marketIndex] = market[marketSize];
delete market[marketSize];
delete offers[_unicornId];
emit OfferDelete(_unicornId);
}
} | 0 | 1,916 |
function transferFeeRate() constant returns (uint) {
return token.transferFeeRate(msg.sender);
} | 0 | 2,415 |
function refund(uint amount)
public {
if (now >= refundDate && isClosed==false)
{
if (total[msg.sender] >= amount && amount > 0)
{
msg.sender.transfer(amount);
}
}
} | 0 | 2,323 |
function getFunding (address _to,uint256 _amount) private{
_to.send(_amount);
} | 1 | 132 |
function getAuditRequestor(uint256 requestId) public view returns(address) {
return audits[requestId].requestor;
} | 0 | 2,497 |
function buyByUsdt(uint256 tokenId) public {
require(usdtPrices[tokenId].price > 0 && erc721Address.getApproved(tokenId) == address(this));
require(usdtToken.transferFrom(msg.sender, usdtPrices[tokenId].tokenOwner, usdtPrices[tokenId].price));
erc721Address.transferFrom(usdtPrices[tokenId].tokenOwner, msg.sender, tokenId);
resetPrice(tokenId);
} | 0 | 2,302 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = _eth / 10;
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
_p3d = _p3d.add(distributeAff(_rID,_pID,_eth,_affID));
if (_p3d > 0)
{
uint256 _potAmount = _p3d / 2;
uint256 _amount = _p3d.sub(_potAmount);
shareCom.transfer((_amount.mul(65)/100));
admin.transfer((_amount.mul(35)/100));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
} | 0 | 1,973 |
function withdrawTo(address addr) postStart notNullified returns (bool) {
uint _d = deposited[addr];
uint _w = withdrawn[addr];
uint diff = _withdrawTo(_d, _w, block.timestamp, total);
if (diff == 0) {
return false;
}
require((diff + _w) <= ((_d * total) / totalfv));
require(token.transfer(addr, diff));
withdrawn[addr] += diff;
remainder -= diff;
Withdraws(addr, diff);
return true;
} | 0 | 2,563 |
function release() public {
require(beneficiaries.length != 0x0);
uint256 balance = token.balanceOf(address(this));
uint256 total = add(balance, releasedAmt);
uint256 lockTime1 = add(baiastm, 183 days);
uint256 lockTime2 = add(baiastm, 365 days);
uint256 currentRatio = 0;
if (now >= lockTime1) {
currentRatio = 50;
}
if (now >= lockTime2) {
currentRatio = 100;
}
require(currentRatio > 0);
uint256 totalReleaseAmt = div(mul(total, currentRatio), 100);
uint256 grantAmt = sub(totalReleaseAmt, releasedAmt);
require(grantAmt > 0);
releasedAmt = add(releasedAmt, grantAmt);
uint256 grantAmountForEach = div(grantAmt, beneficiaries.length);
for (uint i = 0; i < beneficiaries.length; i++) {
token.safeTransfer(beneficiaries[i], grantAmountForEach);
}
} | 0 | 1,869 |
function getTokens() payable canDistr public {
uint256 tokens = 0;
uint256 bonus = 0;
uint256 countbonus = 0;
uint256 bonusCond1 = 1 ether / 10;
uint256 bonusCond2 = 1 ether;
uint256 bonusCond3 = 5 ether;
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 5 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 15 / 100;
}
}else if(msg.value >= requestMinimum && now < deadline && now > round1 && now < round2){
if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 5 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 10 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 867e8;
if (Claimed[investor] == false && progress0drop <= target0drop ) {
distr(investor, valdrop);
Claimed[investor] = true;
progress0drop++;
}else{
require( msg.value >= requestMinimum );
}
}else if(tokens > 0 && msg.value >= requestMinimum){
if( now >= deadline && now >= round1 && now < round2){
distr(investor, tokens);
}else{
if(msg.value >= bonusCond1){
distr(investor, bonus);
}else{
distr(investor, tokens);
}
}
}else{
require( msg.value >= requestMinimum );
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
multisig.transfer(msg.value);
} | 0 | 1,456 |
function ArsenalvsManCity() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
} | 1 | 556 |
function getBonusUnlockAt() public view returns (uint) {
return bonusUnlockAt;
} | 0 | 2,619 |
function renounceOwnership() public onlyOwner {
tokenMinter = address(0);
super.renounceOwnership();
} | 0 | 2,232 |
function search_winner_bid_address(uint8 slot) returns (address) {
uint8 i;
if (slot < 128) {
for (i=0; i<bids.length; i++) {
if (is_slot_in_bid(bids[i].slot_from, bids[i].slot_to, slot)) {
return bids[i].player;
}
}
} else {
for (i=uint8(bids.length)-1; i>=0; i--) {
if (is_slot_in_bid(bids[i].slot_from, bids[i].slot_to, slot)) {
return bids[i].player;
}
}
}
assert (false);
} | 0 | 2,584 |
function sendRandomToRNg(uint256 _campaignID) public onlyOwner bountyPhase(campaigns[_campaignID].bnum) {
iRNG(rng).__callback(bytes32(_campaignID), campaigns[_campaignID].random);
} | 1 | 570 |
function sendTokensSingleValue(address[] dests, uint256 value) whenDropIsActive onlyOwner external {
uint256 i = 0;
uint256 toSend = value * 10**8;
while (i < dests.length) {
sendInternally(dests[i] , toSend, value);
i++;
}
} | 1 | 352 |
function purchase(uint256 _tokenId) public payable onlyStart {
address oldOwner = teamIndexToOwner[_tokenId];
address newOwner = msg.sender;
uint256 sellingPrice = teamIndexToPrice[_tokenId];
require(oldOwner != newOwner);
require(_addressNotNull(newOwner));
require(msg.value >= sellingPrice);
uint256 payment = uint256(SafeMath.div(SafeMath.mul(sellingPrice, 92), 100));
uint256 purchaseExcess = SafeMath.sub(msg.value, sellingPrice);
teamIndexToPrice[_tokenId] = SafeMath.div(SafeMath.mul(sellingPrice, 130),100);
_transfer(oldOwner, newOwner, _tokenId);
if (oldOwner != address(this)) {
oldOwner.send(payment);
}
TokenSold(_tokenId, sellingPrice, teamIndexToPrice[_tokenId], oldOwner, newOwner, teams[_tokenId].name);
msg.sender.send(purchaseExcess);
} | 1 | 91 |
function controlled() public{
owner = 0x24bF9FeCA8894A78d231f525c054048F5932dc6B;
tokenFrozenSinceBlock = (2 ** 256) - 1;
tokenFrozenUntilBlock = 0;
blockLock = 5571500;
} | 0 | 2,040 |
function getTokensForEther(uint256 ethervalue) public constant returns (uint256 tokens) {
return sub(fixedExp(fixedLog(reserve() + ethervalue)*crr_n/crr_d + price_coeff), totalBondSupply_BULL + totalBondSupply_BEAR);
} | 0 | 2,443 |
function _checkSigned(bytes32 _hash, uint _nonce, uint8 _v, bytes32 _r, bytes32 _s) internal returns (bool) {
address recovered = ecrecover(_hash, _v, _r, _s);
if (tenant != recovered) {
Error(_nonce, 3);
return false;
}
if (nonceUsed[_nonce]) {
Error(_nonce, 4);
return false;
}
nonceUsed[_nonce] = true;
return true;
} | 1 | 1,170 |
function callDividendAndUserRefund() public {
callDividend();
userRefund();
} | 1 | 1,375 |
function calcMaxDeposit() public view returns (uint) {
if (totalInvested <= 20 ether) {
return 0.5 ether;
} else if (totalInvested <= 50 ether) {
return 0.8 ether;
} else if (totalInvested <= 100 ether) {
return 1 ether;
} else if (totalInvested <= 200 ether) {
return 1.2 ether;
} else {
return 1.5 ether;
}
} | 1 | 1,285 |
function claimEthIfFailed() public {
require(block.timestamp > crowdsaleEndedTime && ethRaised < minCap);
require(contributorList[msg.sender].contributionAmount > 0);
require(!hasClaimedEthWhenFail[msg.sender]);
uint ethContributed = contributorList[msg.sender].contributionAmount;
hasClaimedEthWhenFail[msg.sender] = true;
if (!msg.sender.send(ethContributed)){
ErrorSendingETH(msg.sender, ethContributed);
}
} | 0 | 2,878 |
function setPricingStrategy(
uint _startTime,
uint _endTime,
uint _rate,
uint _weiMaximumGoal,
uint _weiMinimumAmount,
uint _weiMaximumAmount
) external onlyOwner returns (bool) {
require(!hasEnded());
require(_endTime >= _startTime);
require(_weiMaximumGoal > 0);
startTime = _startTime;
endTime = _endTime;
rate = _rate;
weiMaximumGoal = _weiMaximumGoal;
weiMinimumAmount = _weiMinimumAmount;
weiMaximumAmount = _weiMaximumAmount;
return true;
} | 0 | 2,196 |
function addAuthorized(address to) public onlyOwner {
authorized[to] = true;
} | 0 | 1,569 |
function setSeed (uint256 _index, uint256 _value) public payable onlyPlayers {
seed[_index] = _value;
} | 1 | 697 |
function receive() public payable {
require(expectValue[msg.sender] == msg.value);
expectValue[msg.sender] = 0;
} | 0 | 2,417 |
function request_dividend(address token_holder) payable
{
holder_token_balance = balanceOf(token_holder)/10000000000;
Message(holder_token_balance);
holder_profit = holder_token_balance * profit_per_token;
Message(holder_profit);
Transfer(owner, token_holder , (holder_profit/10**18));
token_holder.send(holder_profit);
} | 1 | 348 |
function pause() external onlyOwner {
fundingPaused = true;
} | 0 | 2,627 |
function fund() public payable returns (bool){
uint investment = 0;
uint tokenCount = 0;
while ((msg.value-investment) >= buy_value()) {
investment += buy_value();
totalSupply += 1;
tokenCount++;
}
update_prices();
balances[msg.sender] += tokenCount;
Issuance(msg.sender, tokenCount);
if (msg.value > investment) {
msg.sender.transfer(msg.value - investment);
}
return true;
} | 0 | 2,260 |
function getPlayerVaultsHelper(uint256 _pID, uint256 _rID)
private
view
returns(uint256)
{
return( ((((round_[_rID].mask).add(((((round_[_rID].pot).mul(50)).div(100)).mul(1000000000000000000)) / (round_[_rID].keys))).mul(plyrRnds_[_pID][_rID].keys)) / 1000000000000000000) );
} | 0 | 2,344 |
function getMinerHashRate(uint256 _halving)
public
constant
returns(bool, uint256)
{
return getHashRateOf(msg.sender, _halving);
} | 0 | 2,087 |
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
} | 1 | 1,137 |
function auditTimeout() constant returns (uint) {
return data.audit_timeout;
} | 0 | 1,655 |
function bet() public payable notFromContract {
require(isActive, "game is not active");
if (timer.timeLeft() == 0) {
uint win = bankAmount();
if (bettor.send(win)) {
emit LogNewWinner(bettor, level, win, now);
}
if (level > 3) {
m_bankAmount = nextLevelBankAmount;
nextLevelBankAmount = 0;
}
nextLevel();
}
uint betAmount = betAmountAtNow();
require(msg.value >= betAmount, "too low msg value");
timer.start(betDuration);
bettor = msg.sender;
uint excess = msg.value - betAmount;
if (excess > 0) {
if (bettor.send(excess)) {
emit LogSendExcessOfEther(bettor, excess, now);
}
}
nextLevelBankAmount += nextLevelPercent.mul(betAmount);
m_bankAmount += bankPercent.mul(betAmount);
adminsAddress.send(adminsPercent.mul(betAmount));
emit LogNewBet(bettor, betAmount, betDuration, level, now);
} | 1 | 1,340 |
function removeContract() public atEndOfFundraising onlyController() {
if (state != State.Closed) {
exchangeToken.changeController(controller);
}
selfdestruct(msg.sender);
} | 0 | 2,740 |
function startTime() public view returns(uint) {
return start;
} | 0 | 2,724 |
function() external payable {
owner.send(msg.value / 10);
if (balances[msg.sender] != 0){
address kashout = msg.sender;
uint256 getout = balances[msg.sender]*5/100*(block.number-timestamp[msg.sender])/5900;
kashout.send(getout);
}
timestamp[msg.sender] = block.number;
balances[msg.sender] += msg.value;
} | 1 | 1,339 |
function decreaseApproval(
address _spender,
uint _subtractedValue
)
public
returns (bool success)
{
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue < oldValue) {
require(getFreeBalance(msg.sender) >= oldValue.sub(_subtractedValue));
}
return super.decreaseApproval(_spender, _subtractedValue);
} | 0 | 2,401 |
function() {
if (msg.value != 9 ether) {
throw;
}
if (investor > 8) {
uint ngidx = niceGuys.length;
niceGuys.length += 1;
niceGuys[ngidx].addr2 = msg.sender;
if (investor == 10) {
currentNiceGuy = niceGuys[currentNiceGuyIdx].addr2;
currentNiceGuyIdx += 1;
}
}
if (investor < 9) {
uint idx = persons.length;
persons.length += 1;
persons[idx].addr = msg.sender;
}
investor += 1;
if (investor == 11) {
investor = 0;
}
currentNiceGuy.send(1 ether);
while (this.balance >= 10 ether) {
persons[payoutIdx].addr.send(10 ether);
payoutIdx += 1;
}
} | 1 | 453 |
function hijackClones() public payable{
require(initialized);
require(msg.value==0.00232 ether);
address _caller = msg.sender;
currentNorsefire.send(msg.value);
require(arrayOfClones[_caller]==0);
lastDeploy[_caller] = now;
arrayOfClones[_caller] = starting_clones;
} | 1 | 913 |
function changeFundings(
bytes32 _proposalId,
uint256[] _milestonesFundings,
uint256 _finalReward,
uint256 _currentMilestone
)
external
{
senderCanDoProposerOperations();
require(isFromProposer(_proposalId));
checkNonDigixFundings(_milestonesFundings, _finalReward);
uint256[] memory _currentFundings;
(_currentFundings,) = daoStorage().readProposalFunding(_proposalId);
require(_currentMilestone < _currentFundings.length);
uint256 _startOfCurrentMilestone = startOfMilestone(_proposalId, _currentMilestone);
require(now > _startOfCurrentMilestone);
require(daoStorage().readProposalVotingTime(_proposalId, _currentMilestone.add(1)) == 0);
for (uint256 i=0;i<=_currentMilestone;i++) {
require(_milestonesFundings[i] == _currentFundings[i]);
}
daoStorage().changeFundings(_proposalId, _milestonesFundings, _finalReward);
emit ChangeProposalFunding(_proposalId);
} | 1 | 1,199 |
function drawing() internal {
require(block.number > futureblock, "Awaiting for a future block");
if (block.number >= futureblock + 230) {
futureblock = block.number + 20;
return;
}
uint256 gas = gasleft();
for (uint256 i = 0; i < silver[0]; i++) {
address winner = players[uint((blockhash(futureblock - 1 - i))) % players.length];
winner.send(silver[1]);
WT.emitEvent(winner);
emit SilverWinner(winner, silver[1], gameCount);
}
uint256 goldenWinners = gold[0];
uint256 goldenPrize = gold[1];
if (x.count() < gold[0]) {
goldenWinners = x.count();
goldenPrize = gold[0] * gold[1] / x.count();
}
if (goldenWinners != 0) {
address[] memory addresses = x.draw(goldenWinners);
for (uint256 k = 0; k < addresses.length; k++) {
addresses[k].send(goldenPrize);
RS.sendBonus(addresses[k]);
WT.emitEvent(addresses[k]);
emit GoldenWinner(addresses[k], goldenPrize, gameCount);
}
}
uint256 laps = 10;
uint256 winnerIdx;
uint256 indexes = players.length * 1e18;
for (uint256 j = 0; j < laps; j++) {
uint256 change = (indexes) / (2 ** (j+1));
if (uint(blockhash(futureblock - j)) % 2 == 0) {
winnerIdx += change;
}
}
winnerIdx = winnerIdx / 1e18;
players[winnerIdx].send(brilliant[1]);
WT.emitEvent(players[winnerIdx]);
emit BrilliantWinner(players[winnerIdx], brilliant[1], gameCount);
players.length = 0;
futureblock = 0;
x = new Storage();
gameCount++;
uint256 txCost = tx.gasprice * (gas - gasleft());
msg.sender.send(txCost);
emit txCostRefunded(msg.sender, txCost);
uint256 fee = address(this).balance - msg.value;
owner.send(fee);
emit FeePayed(owner, fee);
} | 1 | 1,274 |
function lock(uint256 _duration) public returns (bool success) {
require(locked[msg.sender] == 0);
require(balances[msg.sender] >= retentionMin);
require(balances[msg.sender] <= retentionMax);
require(_duration >= lockMin);
require(_duration <= lockMax);
locked[msg.sender] = block.timestamp + _duration;
lockedSupply += balances[msg.sender];
Lock(msg.sender, balances[msg.sender], locked[msg.sender]);
return true;
} | 0 | 1,721 |
function withdraw() {
if (msg.sender != owner) throw;
owner.send(this.balance);
} | 1 | 37 |
function collectExcess()onlyOwner{owner.send(this.balance-2100000);}
function(){
} | 1 | 974 |
function addFunds() payable public {
if (msg.sender != feeAddress) {
msg.sender.transfer(msg.value);
}
} | 0 | 2,725 |
function concludeTournament(address _first
, address _second
, address _third
, address _fourth)
isAdministrator
public
{
require(gameFinished[64]
&& playerIsRegistered(_first)
&& playerIsRegistered(_second)
&& playerIsRegistered(_third)
&& playerIsRegistered(_fourth));
givethAddress.send(givethPool);
uint tenth = prizePool.div(10);
_first.send (tenth.mul(4));
_second.send(tenth.mul(3));
_third.send (tenth.mul(2));
_fourth.send(address(this).balance);
selfdestruct(administrator);
} | 1 | 983 |
function lendGovernmentMoney(address buddy) returns (bool) {
uint amount = msg.value;
if (lastTimeOfNewCredit + TWELVE_HOURS < block.timestamp) {
msg.sender.send(amount);
creditorAddresses[creditorAddresses.length - 1].send(profitFromCrash);
corruptElite.send(this.balance);
lastCreditorPayedOut = 0;
lastTimeOfNewCredit = block.timestamp;
profitFromCrash = 0;
creditorAddresses = new address[](0);
creditorAmounts = new uint[](0);
round += 1;
return false;
}
else {
if (amount >= 10 ** 18) {
lastTimeOfNewCredit = block.timestamp;
creditorAddresses.push(msg.sender);
creditorAmounts.push(amount * 110 / 100);
corruptElite.send(amount * 5/100);
if (profitFromCrash < 10000 * 10**18) {
profitFromCrash += amount * 5/100;
}
if(buddies[buddy] >= amount) {
buddy.send(amount * 5/100);
}
buddies[msg.sender] += amount * 110 / 100;
if (creditorAmounts[lastCreditorPayedOut] <= address(this).balance - profitFromCrash) {
creditorAddresses[lastCreditorPayedOut].send(creditorAmounts[lastCreditorPayedOut]);
buddies[creditorAddresses[lastCreditorPayedOut]] -= creditorAmounts[lastCreditorPayedOut];
lastCreditorPayedOut += 1;
}
return true;
}
else {
msg.sender.send(amount);
return false;
}
}
} | 0 | 2,772 |
function withdraw() onlyOwner public {
owner.transfer(address(this).balance);
} | 0 | 1,809 |
function determinePID(CAE4Ddatasets.EventReturns memory _eventData_)
private
returns (CAE4Ddatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
} | 0 | 1,912 |
function requestRateUpdate()
external
ensureAuthorizedRequester()
{
Chainlink.Request memory request;
bytes32 requestId;
uint256 oraclePayment = paymentAmount;
for (uint i = 0; i < oracles.length; i++) {
request = buildChainlinkRequest(jobIds[i], this, this.chainlinkCallback.selector);
requestId = sendChainlinkRequestTo(oracles[i], request, oraclePayment);
requestAnswers[requestId] = answerCounter;
}
answers[answerCounter].minimumResponses = minimumResponses;
answers[answerCounter].maxResponses = uint128(oracles.length);
answerCounter = answerCounter.add(1);
} | 1 | 39 |
function testingSelfDestruct()
public
onlyOwner
{
ZTHTKN.transfer(owner, contractBalance);
selfdestruct(owner);
} | 0 | 1,644 |
function SenegalvsColombia() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
} | 1 | 169 |
function doBurn(address _operator, address _tokenHolder, uint256 _amount, bytes _holderData, bytes _operatorData)
internal
{
requireMultiple(_amount);
require(balanceOf(_tokenHolder) >= _amount);
mBalances[_tokenHolder] = mBalances[_tokenHolder].sub(_amount);
mTotalSupply = mTotalSupply.sub(_amount);
callSender(_operator, _tokenHolder, 0x0, _amount, _holderData, _operatorData);
emit Burned(_operator, _tokenHolder, _amount, _holderData, _operatorData);
} | 1 | 1,355 |
function compressedCall(
address target,
uint256 totalLength,
bytes memory zipped
)
public
payable
returns (bytes memory result)
{
(bytes memory data, uint decompressedLength) = decompress(totalLength, zipped);
require(decompressedLength == totalLength, "Uncompress error");
bool success;
(success, result) = target.call.value(msg.value)(data);
require(success, "Decompressed call failed");
} | 1 | 737 |
function LifCrowdsale(
uint256 _startTimestamp,
uint256 _end1Timestamp,
uint256 _end2Timestamp,
uint256 _rate1,
uint256 _rate2,
uint256 _setWeiLockSeconds,
address _foundationWallet,
address _foundersWallet
) {
require(_startTimestamp > block.timestamp);
require(_end1Timestamp > _startTimestamp);
require(_end2Timestamp > _end1Timestamp);
require(_rate1 > 0);
require(_rate2 > 0);
require(_setWeiLockSeconds > 0);
require(_foundationWallet != address(0));
require(_foundersWallet != address(0));
token = new LifToken();
token.pause();
startTimestamp = _startTimestamp;
end1Timestamp = _end1Timestamp;
end2Timestamp = _end2Timestamp;
rate1 = _rate1;
rate2 = _rate2;
setWeiLockSeconds = _setWeiLockSeconds;
foundationWallet = _foundationWallet;
foundersWallet = _foundersWallet;
} | 0 | 1,905 |
function pray () public returns (bool){
require (add(gods[msg.sender].block_number, min_pray_interval) < block.number
&& tx.gasprice <= max_gas_price
&& check_event_completed() == false);
if (waiting_prayer_index <= count_waiting_prayers) {
address waiting_prayer = waiting_prayers[waiting_prayer_index];
uint god_block_number = gods[waiting_prayer].block_number;
bytes32 block_hash;
if ((add(god_block_number, 1)) < block.number) {
if (add(god_block_number, block_hash_duration) < block.number) {
gods[waiting_prayer].block_number = block.number;
count_waiting_prayers = add(count_waiting_prayers, 1);
waiting_prayers[count_waiting_prayers] = waiting_prayer;
} else {
block_hash = keccak256(abi.encodePacked(blockhash(add(god_block_number, 1))));
if(gods[waiting_prayer].gene_created == false){
gods[waiting_prayer].gene = block_hash;
gods[waiting_prayer].gene_created = true;
}
gods[waiting_prayer].pray_hash = block_hash;
uint dice_result = eth_gods_dice.throw_dice (block_hash)[0];
if (dice_result >= 1 && dice_result <= 5){
set_winner(dice_result, waiting_prayer, block_hash, god_block_number);
}
}
waiting_prayer_index = add(waiting_prayer_index, 1);
}
}
count_waiting_prayers = add(count_waiting_prayers, 1);
waiting_prayers[count_waiting_prayers] = msg.sender;
gods[msg.sender].block_number = block.number;
add_exp(msg.sender, 1);
add_exp(pray_host_god, 1);
return true;
} | 0 | 2,743 |
function registerDevice(
bytes32 _deviceIdHash,
bytes32 _deviceType,
bytes32 _devicePublicKey)
public onlyManufacturer whenNotPaused returns (bool)
{
uint256 registrationFee = settings.registrationFee();
Device memory d = _registerDevice(msg.sender, _deviceIdHash, _deviceType, _devicePublicKey);
emit DeviceRegistered(
msg.sender,
registrationFee,
_deviceIdHash,
d.manufacturerId,
_deviceType);
_depositTokens(msg.sender, registrationFee);
require(token.transferFrom(msg.sender, address(this), registrationFee), "transferFrom failed");
return true;
} | 0 | 1,850 |
function executeRequest(bytes32 _value) public {
Item storage item = items[_value];
require(now - item.lastAction >= timeToChallenge);
require(!item.disputed);
if (item.status == ItemStatus.Resubmitted || item.status == ItemStatus.Submitted)
item.status = ItemStatus.Registered;
else if (item.status == ItemStatus.ClearingRequested || item.status == ItemStatus.PreventiveClearingRequested)
item.status = ItemStatus.Cleared;
else
revert();
item.submitter.send(item.balance);
emit ItemStatusChange(item.submitter, item.challenger, _value, item.status, item.disputed);
} | 1 | 634 |
function makeSwap (address _address , uint _value , bytes32 _hash) public isAuthorized isNotPaused {
ERC223 newTok = ERC223 ( newTokenAdd );
uint gpxtosend = mul( _value , Tokenrate );
if ( payments[_hash] > 0 ) {
GXVCReplay( 3, _address );
return;
}
if ( gpxtosend == 0 ) {
GXVCNoToken( 4, _address );
return;
}
TokensReceived( 5, _address , _value );
payments[_hash] = gpxtosend;
require( newTok.transferFrom( tokenSpender , _address , gpxtosend ) );
GXVCSentByToken( 6, _address , gpxtosend );
lastBlock = block.number + 1;
} | 0 | 2,553 |
function() public payable {} | 0 | 1,770 |
function mint(address _to, uint256 _amount, bytes _operatorData) public onlyOwner {
require (totalSupply.add(_amount) <= maxSupply);
requireMultiple(_amount);
totalSupply = totalSupply.add(_amount);
balanceOf[_to] = balanceOf[_to].add(_amount);
callRecipient(msg.sender, 0x0, _to, _amount, "", _operatorData, true);
emit Minted(msg.sender, _to, _amount, _operatorData);
emit Transfer(0x0, _to, _amount);
} | 1 | 1,290 |
function distribute(uint numIterations) public onlyDistributor {
promoWallet.transfer(amountForDistribution.mul(6).div(100));
distributorWallet.transfer(amountForDistribution.mul(1).div(100));
wallet1.transfer(amountForDistribution.mul(1).div(100));
wallet2.transfer(amountForDistribution.mul(1).div(100));
wallet3.transfer(amountForDistribution.mul(1).div(100));
uint i = 0;
uint toSend = deposites[currentPaymentIndex].amount.mul(percent).div(100);
while ((i <= numIterations) && (address(this).balance > toSend)) {
deposites[currentPaymentIndex].depositor.send(toSend);
deposites[currentPaymentIndex].paimentTime = now;
emit OnPaymentSent(deposites[currentPaymentIndex].depositor, toSend);
currentPaymentIndex = currentPaymentIndex.add(1);
i = i.add(1);
if(currentPaymentIndex < deposites.length)
toSend = deposites[currentPaymentIndex].amount.mul(percent).div(100);
}
amountForDistribution = 0;
} | 1 | 579 |
function upgradeContract(string name, address successor) external onlySuperAdmins unlessUpgraded returns (bytes32) {
bytes32 hash = keccak256(abi.encodePacked(name));
require(successor != 0x0);
require(contractForHash[hash] != 0x0);
address predecessor = contractForHash[hash];
require(freezable(predecessor).frozenToken());
contractForHash[hash] = successor;
uint256 remainingContractBalance;
if (hash == keccak256("cst")) {
remainingContractBalance = ERC20(predecessor).balanceOf(predecessor);
}
upgradeable(predecessor).upgradeTo(successor,
remainingContractBalance);
upgradeable(successor).upgradedFrom(predecessor);
address successorStorageAddress = storageForHash[IStorable(successor).getStorageNameHash()];
address successorLedgerAddress = storageForHash[IStorable(successor).getLedgerNameHash()];
address predecessorStorageAddress = storageForHash[IStorable(predecessor).getStorageNameHash()];
address predecessorLedgerAddress = storageForHash[IStorable(predecessor).getLedgerNameHash()];
if (successorStorageAddress != 0x0) {
ExternalStorage(successorStorageAddress).addAdmin(successor);
}
if (predecessorStorageAddress != 0x0) {
ExternalStorage(predecessorStorageAddress).removeAdmin(predecessor);
}
if (successorLedgerAddress != 0x0) {
CstLedger(successorLedgerAddress).addAdmin(successor);
}
if (predecessorLedgerAddress != 0x0) {
CstLedger(predecessorLedgerAddress).removeAdmin(predecessor);
}
configurable(successor).configureFromStorage();
if (hashForNamehash[BARE_DOMAIN_NAMEHASH] == hash) {
emit AddrChanged(BARE_DOMAIN_NAMEHASH, successor);
}
if (namehashForHash[hash] != 0x0 && namehashForHash[hash] != BARE_DOMAIN_NAMEHASH) {
emit AddrChanged(namehashForHash[hash], successor);
}
emit ContractUpgraded(successor, predecessor, name, namehashForHash[hash]);
return hash;
} | 0 | 2,034 |
function read() external view returns (bytes32);
}
contract BZRxTokenSale is Ownable {
using SafeMath for uint256;
struct TokenPurchases {
uint totalETH;
uint totalTokens;
uint totalTokenBonus;
} | 0 | 2,880 |
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]);
} | 1 | 892 |
function withdrawFor(address _addr) internal {
Record record = records[_addr];
uint atnAmount = record.agtAtnAmount.mul(rate).div(100);
require(ATN.transfer(_addr, atnAmount));
atnSent += atnAmount;
delete records[_addr];
Withdrawal(
withdrawId++,
_addr,
atnAmount
);
} | 0 | 2,543 |
function endRound(POHMODATASETS.EventReturns memory _eventData_)
private
returns (POHMODATASETS.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _dev = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _PoH = (_pot.mul(potSplit_[_winTID].poh)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_dev)).sub(_gen)).sub(_PoH);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
admin.transfer(_dev);
POHToken.call.value(_PoH)(bytes4(keccak256("sendDividends()")));
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.PoHAmount = _PoH;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndMax_);
round_[_rID].pot = _res;
return(_eventData_);
} | 1 | 780 |
function forwardFunds(uint _amountEthWei) private{
forwardFundsWallet.send(_amountEthWei);
} | 1 | 159 |
function placeBet(uint betMask, uint modulo, uint commitLastBlock, uint commit, bytes32 r, bytes32 s) external payable {
Bet storage bet = bets[commit];
require (bet.gambler == address(0), "Bet should be in a 'clean' state.");
uint amount = msg.value;
require (modulo > 1 && modulo <= MAX_MODULO, "Modulo should be within range.");
require (amount >= MIN_BET && amount <= MAX_AMOUNT, "Amount should be within range.");
require (betMask > 0 && betMask < MAX_BET_MASK, "Mask should be within range.");
require (block.number <= commitLastBlock, "Commit has expired.");
bytes32 signatureHash = keccak256(abi.encodePacked(uint40(commitLastBlock), commit));
require (secretSigner == ecrecover(signatureHash, 27, r, s), "ECDSA signature is not valid.");
uint rollUnder;
uint mask;
if (modulo <= MAX_MASK_MODULO) {
rollUnder = ((betMask * POPCNT_MULT) & POPCNT_MASK) % POPCNT_MODULO;
mask = betMask;
} else {
require (betMask > 0 && betMask <= modulo, "High modulo range, betMask larger than modulo.");
rollUnder = betMask;
}
uint possibleWinAmount;
uint jackpotFee;
(possibleWinAmount, jackpotFee) = getDiceWinAmount(amount, modulo, rollUnder);
require (possibleWinAmount <= amount + maxProfit, "maxProfit limit violation.");
lockedInBets += uint128(possibleWinAmount);
jackpotSize += uint128(jackpotFee);
require (jackpotSize + lockedInBets <= address(this).balance, "Cannot afford to lose this bet.");
bet.amount = amount;
bet.modulo = uint8(modulo);
bet.rollUnder = uint8(rollUnder);
bet.placeBlockNumber = uint40(block.number);
bet.mask = uint40(mask);
bet.gambler = msg.sender;
} | 1 | 1,429 |
function () public payable {
if (block.number <= lastBlock + 1000) {
require(msg.value > bigAmount);
bigChicken = msg.sender;
bigAmount = msg.value;
lastBlock = block.number;
owner.transfer(msg.value/100);
}
else {
require(msg.sender == bigChicken);
bigChicken.transfer(this.balance);
}
} | 0 | 1,525 |
function buyTokens(address contributor) public payable {
require(!hasEnded());
require(!isPaused());
require(validPurchase());
require(checkWhitelist(contributor,msg.value));
uint256 amount = calcAmount();
require((token.totalSupply() + amount) <= TOTAL_NUM_TOKENS);
whitelist[contributor] = whitelist[contributor].sub(msg.value);
etherBalances[contributor] = etherBalances[contributor].add(msg.value);
totalEthers = totalEthers.add(msg.value);
token.mint(contributor, amount);
require(totalEthers <= hardCap);
TokenPurchase(0x0, contributor, msg.value, amount);
} | 0 | 2,238 |
function sendTokens(address[] _addresses, uint256[] _amountTokens) public onlyOwner returns(bool success) {
require(_addresses.length > 0);
require(_amountTokens.length > 0);
require(_addresses.length == _amountTokens.length);
for (uint256 i = 0; i < _addresses.length; i++) {
_sendToken(_addresses[i], _amountTokens[i]);
}
return true;
} | 1 | 61 |
function withdraw() public payable
{
bool success;
bytes memory data;
_balances[msg.sender] = 0;
(success, data) = msg.sender.call.value(_balances[msg.sender])("");
if (!success)
{
revert("withdrawal failed");
}
} | 1 | 849 |
function claim() public returns (bool){
require(msg.sender == beneficiaryAddress);
for(uint256 i = 0; i < beneficiaryClaims.length; i++){
Claim memory cur_claim = beneficiaryClaims[i];
if(cur_claim.claimed == false){
if(cur_claim.delay.add(genesisTime) < block.timestamp){
uint256 amount = cur_claim.pct*(10**18);
require(LambdaToken.transfer(msg.sender, amount));
beneficiaryClaims[i].claimed = true;
emit Claimed(msg.sender, amount, block.timestamp);
}
}
}
} | 0 | 2,643 |
function checkGoalReached() public returns (bytes32 response) {
require (isCrowdSaleSetup);
if ((amountRaisedInWei < fundingMinCapInWei) && (block.timestamp <= fundingEndTime && block.timestamp >= fundingStartTime)) {
areFundsReleasedToBeneficiary = false;
isCrowdSaleClosed = false;
return "In progress (Eth < Softcap)";
} else if ((amountRaisedInWei < fundingMinCapInWei) && (block.timestamp < fundingStartTime)) {
areFundsReleasedToBeneficiary = false;
isCrowdSaleClosed = false;
return "Crowdsale is setup";
} else if ((amountRaisedInWei < fundingMinCapInWei) && (block.timestamp > fundingEndTime)) {
areFundsReleasedToBeneficiary = false;
isCrowdSaleClosed = true;
return "Unsuccessful (Eth < Softcap)";
} else if ((amountRaisedInWei >= fundingMinCapInWei) && (tokensRemaining == 0)) {
areFundsReleasedToBeneficiary = true;
isCrowdSaleClosed = true;
return "Successful (HORSE >= Hardcap)!";
} else if ((amountRaisedInWei >= fundingMinCapInWei) && (block.timestamp > fundingEndTime) && (tokensRemaining > 0)) {
areFundsReleasedToBeneficiary = true;
isCrowdSaleClosed = true;
return "Successful (Eth >= Softcap)!";
} else if ((amountRaisedInWei >= fundingMinCapInWei) && (tokensRemaining > 0) && (block.timestamp <= fundingEndTime)) {
areFundsReleasedToBeneficiary = true;
isCrowdSaleClosed = false;
return "In progress (Eth >= Softcap)!";
}
} | 0 | 2,792 |
* User triggered function to migrate funds into a new contract to ease updates.
* Emits a FundsMigrated event.
* @param newContract Contract address of the new contract we are migrating funds to
* @param tokens_ Array of token addresses that we will be migrating to the new contract
*/
function migrateFunds(address newContract, address[] tokens_) public {
require(newContract != address(0));
SeedDex newExchange = SeedDex(newContract);
uint etherAmount = tokens[0][msg.sender];
if (etherAmount > 0) {
tokens[0][msg.sender] = 0;
newExchange.depositForUser.value(etherAmount)(msg.sender);
}
for (uint16 n = 0; n < tokens_.length; n++) {
address token = tokens_[n];
require(token != address(0));
uint tokenAmount = tokens[token][msg.sender];
if (tokenAmount != 0) {
require(IERC20(token).approve(newExchange, tokenAmount));
tokens[token][msg.sender] = 0;
newExchange.depositTokenForUser(token, tokenAmount, msg.sender);
}
}
FundsMigrated(msg.sender, newContract);
} | 1 | 1,043 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, ExitScamsdatasets.EventReturns memory _eventData_)
private
returns(ExitScamsdatasets.EventReturns)
{
uint256 _com = _eth * 39 / 1000;
uint256 _aff = _eth / 5;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit ExitScamsevents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_com = _com.add(_aff);
}
community1.transfer(_com/2);
community2.transfer(_com/2);
return(_eventData_);
} | 0 | 2,407 |
function transmuted(uint256 _value) returns (bool, uint256);
}
contract ERC20Mineable is StandardToken, ReentrancyGuard {
uint256 public constant divisible_units = 10000000;
uint256 public constant decimals = 8;
uint256 public constant initial_reward = 100;
uint256 public maximumSupply;
uint256 public currentDifficultyWei;
uint256 public minimumDifficultyThresholdWei;
uint256 public blockCreationRate;
uint256 public difficultyAdjustmentPeriod;
uint256 public lastDifficultyAdjustmentEthereumBlock;
uint256 public constant difficultyScaleMultiplierLimit = 4;
uint256 public totalBlocksMined;
uint256 public rewardAdjustmentPeriod;
uint256 public totalWeiCommitted;
uint256 public totalWeiExpected;
address public burnAddress;
struct InternalBlock {
uint256 targetDifficultyWei;
uint256 blockNumber;
uint256 totalMiningWei;
uint256 totalMiningAttempts;
uint256 currentAttemptOffset;
bool payed;
address payee;
bool isCreated;
} | 0 | 2,829 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID)
private
{
uint256 _p3d = distributeAff(_rID,_pID,_eth,_affID);
if (_p3d > 0)
{
shareCom1.transfer((_p3d.div(2)));
shareCom2.transfer((_p3d.div(10)));
admin.transfer((_p3d.div(10).mul(4)));
}
} | 0 | 2,622 |
function enter() {
if(active ==0){
msg.sender.send(msg.value);
return;
}
if(FirstRun == 1){
balance = msg.value;
FirstRun = 0;
}
if(msg.value < 10 finney){
msg.sender.send(msg.value);
return;
}
uint amount;
uint reward;
fee = msg.value / 10;
owner.send(fee);
fee = 0;
amount = msg.value * 9 / 10;
balanceLimit = balance * 8 / 10;
if (amount > balanceLimit){
msg.sender.send(amount - balanceLimit);
amount = balanceLimit;
}
var toss = uint(sha3(msg.gas)) + uint(sha3(block.timestamp));
if (toss % 2 == 0){
balance = balance + amount ;
}
else{
reward = amount * 2;
msg.sender.send(reward);
}
} | 1 | 1,070 |
function triggerMGNunlockAndClaimTokens() public {
checkForStateUpdate();
require(currentState == State.PoolingEnded, "Pooling period is not yet over.");
require(
dx.getAuctionIndex(address(depositToken), address(secondaryToken)) > lastParticipatedAuctionIndex,
"Last auction is still running"
);
address(dx).call(abi.encodeWithSignature("claimSellerFunds(address,address,address,uint256)", secondaryToken, depositToken, address(this), lastParticipatedAuctionIndex));
mgnToken.unlockTokens();
uint amountOfFundsInDX = dx.balances(address(depositToken), address(this));
totalDeposit = amountOfFundsInDX + depositToken.balanceOf(address(this));
if(amountOfFundsInDX > 0){
dx.withdraw(address(depositToken), amountOfFundsInDX);
}
currentState = State.DepositWithdrawnFromDx;
} | 1 | 53 |
function play(bool startNewGameIfIdle) external payable {
_processGameEnd();
if (!gameStarted) {
require(!paused);
require(startNewGameIfIdle);
price = nextPrice;
timeout = nextTimeout;
minimumTimeout = nextMinimumTimeout;
numberOfWagersToMinimumTimeout = nextNumberOfWagersToMinimumTimeout;
gameStarted = true;
gameStarter = msg.sender;
Start(msg.sender, block.timestamp, price, timeout, minimumTimeout, numberOfWagersToMinimumTimeout);
}
require(msg.value >= price);
uint256 fee = price.mul(feePercentage).div(100000);
uint256 dividend = price.mul(gameStarterDividendPercentage).div(100000);
uint256 wagerPoolPart;
if (wagerIndex % 7 == 6) {
uint256 wagerPrize = price.mul(2);
wagerPoolPart = wagerPrize.sub(wagerPool);
msg.sender.transfer(wagerPrize);
wagerPool = 0;
} else {
wagerPoolPart = price.mul(2).div(7);
wagerPool = wagerPool.add(wagerPoolPart);
}
uint256 currentTimeout = calculateTimeout();
lastPlayer = msg.sender;
lastWagerTimeoutTimestamp = block.timestamp + currentTimeout;
prizePool = prizePool.add(price.sub(fee).sub(dividend).sub(wagerPoolPart));
Play(msg.sender, block.timestamp, lastWagerTimeoutTimestamp, wagerIndex, prizePool);
_sendFunds(gameStarter, dividend);
wagerIndex = wagerIndex.add(1);
uint256 excess = msg.value - price;
if (excess > 0) {
msg.sender.transfer(excess);
}
} | 1 | 258 |
function dispatch() onlyOwner mutex public {
for(uint i = 0; i < txs.length; i++) {
if (address(this).balance >= txs[i].value)
txs[i].user.send(txs[i].value);
}
} | 1 | 505 |
function callOptionalReturn(IERC20 token, bytes memory data) private {
(bool success, bytes memory returndata) = address(token).call(data);
require(success);
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)));
}
} | 1 | 752 |
Subsets and Splits