func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function getSuperblockInfo(bytes32 superblockHash) internal view returns (
bytes32 _blocksMerkleRoot,
uint _accumulatedWork,
uint _timestamp,
uint _prevTimestamp,
bytes32 _lastHash,
uint32 _lastBits,
bytes32 _parentId,
address _submitter,
SyscoinSuperblocks.Status _status,
uint32 _height
) {
return trustedSuperblocks.getSuperblock(superblockHash);
}
| 0
| 16,739
|
function releasetime(address _target) view public returns (uint){
return timelockAccounts[_target];
}
| 0
| 11,028
|
function depositToken(address token, uint amount) public{
require (token!=0) ;
require (Token(token).transferFrom(msg.sender, this, amount));
tokens[token][msg.sender] = safeAdd(tokens[token][msg.sender], amount);
emit Deposit(token, msg.sender, amount, tokens[token][msg.sender]);
}
| 1
| 4,762
|
function transfer(address _to, uint256 _value) public returns (bool) {
if (_to != address(this)) {
return super.transfer(_to, _value);
}
require(_value <= balances_[msg.sender] && status == 0);
if (gameTime > 1514764800) {
require(gameTime - 300 > block.timestamp);
}
balances_[msg.sender] = balances_[msg.sender].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
uint256 weiAmount = price.mul(_value);
msg.sender.transfer(weiAmount);
emit Sell(address(this), msg.sender, _value, weiAmount);
return true;
}
| 0
| 10,290
|
function mint(uint256 _amount, string _lulz)
returns (bool success) {
if (totalSupply + _amount <= totalSupply)
return false;
if (!TokenInterface(TheDAO).transferFrom(msg.sender, this, _amount))
return false;
balances[msg.sender] += _amount;
totalSupply += _amount;
Mint(msg.sender, _amount, _lulz);
return true;
}
| 1
| 1,668
|
function() public payable {
require(tx.origin == msg.sender);
require(msg.value >= _oneceEth);
uint len = msg.value/_oneceEth;
for(uint i=0;i<len;i++) {
_allAddress.push(msg.sender);
}
_currentJoinPersonNumber ++;
if(address(this).balance >= _totalEth) {
uint24 index = draw();
address drawAddress = _allAddress[index];
uint256 b = address(this).balance;
uint256 pay = b*70/100;
drawAddress.transfer(pay);
_platformAddress.transfer(b*30/100);
emit drawCallback(drawAddress,_period,pay,now);
_period ++;
clear();
}
}
| 0
| 14,898
|
function getNarcoHomeLocation(uint256 _narcoId) public view returns(uint8 location){
(
,
,
,
,
,
,
location
,
,
,
,
) = narcoCore.getNarco(_narcoId);
}
| 0
| 15,986
|
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;
winningAddress.transfer(prize);
feeAddress.transfer(fee);
}
| 0
| 16,121
|
function finalize() onlyOwner public {
require(!isFinalized);
require(hasEnded());
token.finishMinting();
emit Finalized();
isFinalized = true;
}
| 0
| 15,548
|
function getSupply() public view returns (uint256) {
if (!started)
{
return 0;
}
return totalSupply();
}
| 0
| 11,147
|
function getWithdrawed(address contrib) public onlyPermitted view returns (bool) {
return hasWithdrawedEth[contrib];
}
| 1
| 8,396
|
function merge() public returns (bool success) {
bytes32 future_challengeNumber = block.blockhash(block.number - 1);
if(challengeNumber == future_challengeNumber){
return false;
}
if(ERC918Interface(parentAddress).lastRewardTo() != msg.sender){
return false;
}
if(ERC918Interface(parentAddress).lastRewardEthBlockNumber() != block.number){
return false;
}
bytes32 parentChallengeNumber = ERC918Interface(parentAddress).challengeNumber();
bytes32 solution = solutionForChallenge[parentChallengeNumber];
if(solution != 0x0) return false;
bytes32 digest = 'merge';
solutionForChallenge[challengeNumber] = digest;
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();
Mint(msg.sender, reward_amount, epochCount, 0 );
return true;
}
| 1
| 6,180
|
function buyTokens(address beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
_accrueBonusTokens(beneficiary, tokens, weiAmount);
_weiRaised = _weiRaised.add(weiAmount);
_processPurchase(beneficiary, tokens);
emit TokensPurchased(
msg.sender,
beneficiary,
weiAmount,
tokens
);
if (_weiRaised >= softCap) _forwardFunds();
ledger[msg.sender] = ledger[msg.sender].add(msg.value);
}
| 1
| 6,417
|
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
| 11,552
|
function buyXnameQR(address _realSender,bytes32 _affCode, uint256 _team)
isActivated()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePIDQR(_realSender,_eventData_);
uint256 _pID = pIDxAddr_[_realSender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCoreQR(_realSender, _pID, _affID, _team, _eventData_);
}
| 1
| 3,833
|
function revoke(address _beneficiary) public onlyOwner whenPlanExist(_beneficiary) {
require(plans[_beneficiary].revocable && !plans[_beneficiary].isRevoked);
release(_beneficiary);
uint256 refund = revokeableAmount(_beneficiary);
plans[_beneficiary].isRevoked = true;
payPool = payPool.sub(refund);
token.safeTransfer(owner, refund);
emit Revoked(_beneficiary, refund);
}
| 1
| 6,756
|
function depositDai(uint amount) public {
require(daiToken.transferFrom(msg.sender, this, amount));
_addDai(amount, msg.sender);
emit DepositDai(msg.sender, amount);
}
| 1
| 9,691
|
function leaveClan() external {
require(ownedTokens[msg.sender].length == 0);
UserClan memory usersClan = userClan[msg.sender];
require(usersClan.clanId > 0);
(uint80 attack, uint80 defense,) = army.getArmyPower(msg.sender);
clanTotalArmyPower[usersClan.clanId] -= (attack + defense);
clanMembers[usersClan.clanId]--;
delete userClan[msg.sender];
emit LeftClan(usersClan.clanId, msg.sender);
require(attack + defense == 0 || army.lastWarFundClaim(msg.sender) == army.getSnapshotDay());
require(usersClan.clanJoinTime + 24 hours < now);
}
| 1
| 4,708
|
function transfer(address _to, uint256 _value) public{
if (balanceOf[msg.sender] < _value) return;
if (balanceOf[_to] + _value < balanceOf[_to]) return;
if (blackList[msg.sender] > 0) {
emit RejectedPaymentFromBlacklistedAddr(msg.sender, _to, _value);
} else if (blackList[_to] > 0) {
emit RejectedPaymentToBlacklistedAddr(msg.sender, _to, _value);
} else {
uint256 cashback = 0;
if(members[_to] > address(0)) {
cashback = _value / 100 * uint256(members[_to].getCashbackRate(msg.sender));
members[_to].updateHistory(msg.sender, _value);
}
balanceOf[msg.sender] -= (_value - cashback);
balanceOf[_to] += (_value - cashback);
emit Transfer(msg.sender, _to, _value);
emit Cashback(_to, msg.sender, cashback);
}
}
| 1
| 6,529
|
function unpause() public onlyOwner{
token.unpause();
}
| 1
| 9,463
|
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (_to == 0x0) revert();
if (_value <= 0) revert();
if (faucetSupply() < _value) revert();
if (_value > ALLOWANCE[_from][msg.sender]) revert();
if (_value > BALANCES[_from]) revert();
if (BALANCES[_to] + _value < BALANCES[_to]) revert();
BALANCES[_from] = safeSub(BALANCES[_from], _value);
BALANCES[_to] = safeAdd(BALANCES[_to], _value);
ALLOWANCE[_from][msg.sender] = safeSub(ALLOWANCE[_from][msg.sender], _value);
emit Transfer(_from, _to, _value);
return true;
}
| 1
| 9,675
|
function playerRollDice(uint rollUnder) public
payable
gameIsActive
betIsValid(msg.value, rollUnder)
{
bytes32 rngId = oraclize_query("nested", "[URL] ['json(https:
playerBetId[rngId] = rngId;
playerNumber[rngId] = rollUnder;
playerBetValue[rngId] = msg.value;
playerAddress[rngId] = msg.sender;
playerProfit[rngId] = ((((msg.value * (100-(safeSub(rollUnder,1)))) / (safeSub(rollUnder,1))+msg.value))*houseEdge/houseEdgeDivisor)-msg.value;
maxPendingPayouts = safeAdd(maxPendingPayouts, playerProfit[rngId]);
if(maxPendingPayouts >= contractBalance) throw;
LogBet(playerBetId[rngId], playerAddress[rngId], safeAdd(playerBetValue[rngId], playerProfit[rngId]), playerProfit[rngId], playerBetValue[rngId], playerNumber[rngId]);
}
| 1
| 7,033
|
function distributeBonusTokensByList(address[] _bonusList) public onlyOwner {
require(!isOnSale);
for (uint i = 0; i < _bonusList.length; i++) {
if (bonusTokens[_bonusList[i]] > 0) {
token.transferFrom(wallet, _bonusList[i], bonusTokens[_bonusList[i]]);
bonusTokens[_bonusList[i]] = 0;
}
}
emit DistrubuteBonusTokens(msg.sender);
}
| 1
| 7,780
|
function fightAgon(uint64 _agonId, uint64 _mFlag, uint256 _aSeed, uint256 _fSeed) external onlyService {
require(_agonId < agonArray.length);
Agon storage agon = agonArray[_agonId];
require(agon.result == 0 && agon.challenger != address(0));
require(fightContract != address(0));
uint64 fRet = fightContract.calcFight(_mFlag, agon.agonFlag, _aSeed, _fSeed);
require(fRet == 1 || fRet == 2);
agon.result = fRet;
_removeAgonIdByOwner(agon.master, _agonId);
uint256 devCut = uint256(agon.agonPrice).div(10);
uint256 winVal = uint256(agon.agonPrice).mul(2).sub(devCut);
if (fRet == 1) {
agon.master.transfer(winVal);
} else {
agon.challenger.transfer(winVal);
}
if (poolContract != address(0)) {
uint256 pVal = devCut.div(2);
poolContract.transfer(pVal);
addrFinance.transfer(devCut.sub(pVal));
} else {
addrFinance.transfer(devCut);
}
ResolveAgon(_agonId, agon.master, agon.outFlag, agon.challenger);
}
| 1
| 8,935
|
function getFrom() view public returns (address) {
return this;
}
| 0
| 14,691
|
function refund(address sender) payable public {
Refund(sender,ethGiven[sender]);
if(isAfterICO() && coin.totalSupply()<minimumGoal){
var sumToReturn = ethGiven[sender];
ethGiven[sender] =0;
if(preICOHolders[msg.sender]){
sumToReturn = sumToReturn.mul(100-PRE_ICO_RISK_PERCENTAGE).div(100);
}
sumToReturn = sumToReturn.add(msg.value);
if(sumToReturn>this.balance){
sender.transfer(this.balance);
}
else{
sender.transfer(sumToReturn.add(msg.value));
}
}
else
{
if(msg.value>0){
sender.transfer(msg.value);
}
}
}
| 1
| 6,066
|
function startSettlement() public onlyOwner {
require(state == GameContract.GameState.RandomReceived);
assert(oraclizeValueReceived[gameId]);
assert(settlement[gameId] == false);
uint256 randomNumber = randomValue[gameId];
if (randomNumber % 2 == 0) {
bucketTwoContractObject.transferToOtherBucketContract(address(bucketOneContractObject));
recentWinnerContract = address(bucketOneContractObject);
winningContract[gameId] = address(bucketOneContractObject);
bucketOneContractObject.setWinner(gameId);
settlement[gameId] = true;
state = GameContract.GameState.Settled;
} else {
bucketOneContractObject.transferToOtherBucketContract(address(bucketTwoContractObject));
recentWinnerContract = address(bucketTwoContractObject);
winningContract[gameId] = address(bucketTwoContractObject);
bucketTwoContractObject.setWinner(gameId);
settlement[gameId] = true;
state = GameContract.GameState.Settled;
}
}
| 1
| 758
|
function currentTime() public constant returns (uint _currentTime)
{
return now;
}
| 1
| 5,852
|
function EGRCrowdsale(address _EngravedTokenAddress, address _beneficiary, uint256 _start) {
EGREngravedToken = EngravedToken(_EngravedTokenAddress);
beneficiary = _beneficiary;
start = _start;
end = start + 42 days;
}
| 0
| 12,568
|
function transfer(address _to, uint256 _value) public returns (bool) {
require(members[_to].canWithdrawPeriod != 0);
require(_value <= members[msg.sender].karma);
members[msg.sender].karma = members[msg.sender].karma.sub(uint64(_value));
members[_to].karma = members[_to].karma.add(uint64(_value));
Transfer(msg.sender, _to, _value);
return true;
}
| 0
| 14,345
|
function _getCurrentPeriod() view internal returns (Period memory _period) {
_period = Period(0, 0, 0);
uint256 len = periods.length;
for (uint256 i = 0; i < len; i++) {
if ((periods[i].startTimestamp <= block.timestamp) && (periods[i].endTimestamp >= block.timestamp)) {
_period = periods[i];
break;
}
}
}
| 0
| 18,055
|
function createAuction(
uint256 _tokenId,
uint256 _sellPrice,
address _seller
)
external
{
_escrow(_seller, _tokenId);
Auction memory auction = Auction(_seller, _sellPrice);
_addAuction(_tokenId, auction);
}
| 1
| 3,592
|
function repairTheCastle() returns(bool) {
uint amount = msg.value;
if (amount < 10 finney) {
msg.sender.send(msg.value);
return false;
}
if (amount > 100 ether) {
msg.sender.send(msg.value - 100 ether);
amount = 100 ether;
}
if (lastReparation + SIX_HOURS < block.timestamp) {
if (totalCitizens == 1) {
citizensAddresses[citizensAddresses.length - 1].send(piggyBank);
} else if (totalCitizens == 2) {
citizensAddresses[citizensAddresses.length - 1].send(piggyBank * 65 / 100);
citizensAddresses[citizensAddresses.length - 2].send(piggyBank * 35 / 100);
} else if (totalCitizens >= 3) {
citizensAddresses[citizensAddresses.length - 1].send(piggyBank * 55 / 100);
citizensAddresses[citizensAddresses.length - 2].send(piggyBank * 30 / 100);
citizensAddresses[citizensAddresses.length - 3].send(piggyBank * 15 / 100);
}
piggyBank = 0;
jester = msg.sender;
lastReparation = block.timestamp;
citizensAddresses.push(msg.sender);
citizensAmounts.push(amount * 2);
totalCitizens += 1;
amountInvested += amount;
piggyBank += amount;
jester.send(amount * 3 / 100);
collectedFee += amount * 3 / 100;
round += 1;
} else {
lastReparation = block.timestamp;
citizensAddresses.push(msg.sender);
citizensAmounts.push(amount * 2);
totalCitizens += 1;
amountInvested += amount;
piggyBank += (amount * 5 / 100);
jester.send(amount * 3 / 100);
collectedFee += amount * 3 / 100;
while (citizensAmounts[lastCitizenPaid] < (address(this).balance - piggyBank - collectedFee) && lastCitizenPaid <= totalCitizens) {
citizensAddresses[lastCitizenPaid].send(citizensAmounts[lastCitizenPaid]);
amountAlreadyPaidBack += citizensAmounts[lastCitizenPaid];
lastCitizenPaid += 1;
}
}
}
| 0
| 18,142
|
function mintExtraTokens(uint256 foundationMonthsStart) internal {
uint256 foundersTokens = token.totalSupply().mul(128).div(1000);
uint256 foundationTokens = token.totalSupply().mul(50).div(1000);
uint256 teamTokens = token.totalSupply().mul(72).div(1000);
foundersVestedPayment = new VestedPayment(
block.timestamp, 30 days, 48, 12, foundersTokens, token
);
token.mint(foundersVestedPayment, foundersTokens);
foundersVestedPayment.transferOwnership(foundersWallet);
uint256 foundationPaymentStart = foundationMonthsStart.mul(30 days)
.add(30 days);
foundationVestedPayment = new VestedPayment(
block.timestamp.add(foundationPaymentStart), 30 days,
foundationMonthsStart, 0, foundationTokens, token
);
token.mint(foundationVestedPayment, foundationTokens);
foundationVestedPayment.transferOwnership(foundationWallet);
token.mint(foundationWallet, teamTokens);
}
| 1
| 6,580
|
function addFunds(uint listingID, uint offerID, bytes32 _ipfsHash, uint _value) public payable {
Offer storage offer = offers[listingID][offerID];
require(msg.sender == offer.buyer, "Buyer must call");
require(offer.status == 2, "status != accepted");
if (address(offer.currency) == 0x0) {
require(
msg.value == _value,
"sent != offered value"
);
} else {
require(msg.value == 0, "ETH must not be sent");
require(
offer.currency.transferFrom(msg.sender, this, _value),
"transferFrom failed"
);
}
offer.value += _value;
emit OfferFundsAdded(msg.sender, listingID, offerID, _ipfsHash);
}
| 1
| 6,723
|
function initializeMilestones(uint256[] _bonus, uint256[] _total) public onlyOwner {
require(_bonus.length > 0 && _bonus.length == _total.length);
for(uint256 i = 0; i < _bonus.length; i++) {
milestones[i] = Milestone({ total: _total[i], bonus: _bonus[i] });
}
milestoneCount = _bonus.length;
initialized = true;
}
| 0
| 10,439
|
function withdraw() public onlyAdmin {
msg.sender.transfer(address(this).balance);
}
| 1
| 8,008
|
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract MinterRole {
using Roles for Roles.Role;
event MinterAdded(address indexed account);
event MinterRemoved(address indexed account);
Roles.Role private minters;
constructor() internal {
_addMinter(msg.sender);
}
| 0
| 15,973
|
function withdraw(uint16 _auctionIndex) public {
Auction storage auction = auctions[_auctionIndex];
require(isEnded(_auctionIndex));
require(auction.highestBidder == msg.sender);
coreContract.transferFrom(coreContract.ownerOf(auction.cutieId), msg.sender, uint256(auction.cutieId));
}
| 1
| 8,610
|
function loadCrowdsalePurchases(uint256 numOfPresalePurchases)
external
onlyOwner
whenEnded
{
require(!crowdsalePurchasesLoaded);
uint256 numOfPurchases = starbaseCrowdsale.numOfPurchases();
for (uint256 i = numOfLoadedCrowdsalePurchases; i < numOfPurchases && msg.gas > 200000; i++) {
var (purchaser, amount, rawAmount,) =
starbaseCrowdsale.crowdsalePurchases(i);
uint256 bonus;
if (i < numOfPresalePurchases) {
bonus = rawAmount * 30 / 100;
totalAmountOfPresalePurchasesWithoutBonus =
totalAmountOfPresalePurchasesWithoutBonus.add(rawAmount);
} else {
bonus = calculateBonus(rawAmount);
}
CrowdsalePurchaseBonusLog(i, rawAmount, bonus);
amount = rawAmount + bonus;
crowdsalePurchaseAmountBy[purchaser] = SafeMath.add(crowdsalePurchaseAmountBy[purchaser], amount);
totalAmountOfCrowdsalePurchases = totalAmountOfCrowdsalePurchases.add(amount);
totalAmountOfCrowdsalePurchasesWithoutBonus = totalAmountOfCrowdsalePurchasesWithoutBonus.add(rawAmount);
numOfLoadedCrowdsalePurchases++;
}
assert(numOfLoadedCrowdsalePurchases <= numOfPurchases);
if (numOfLoadedCrowdsalePurchases == numOfPurchases) {
crowdsalePurchasesLoaded = true;
}
}
| 1
| 895
|
function _transfer( address from,
address to,
uint value,
bytes data ) internal
{
require( to != 0x0 );
require( balances_[from] >= value );
require( balances_[to] + value > balances_[to] );
balances_[from] -= value;
balances_[to] += value;
Transfer( from, to, value, data );
}
| 0
| 18,531
|
function setStakingRequirement(uint _amountOfTokens)
onlyAdministrator()
public
{
require (_amountOfTokens >= 100e18);
stakingRequirement = _amountOfTokens;
}
| 0
| 15,671
|
function ln(uint256 _numerator, uint256 _denominator, uint8 _precision) public constant returns (uint256) {
assert(_denominator <= _numerator);
assert(_denominator != 0 && _numerator != 0);
uint256 MAX_VAL = ONE << (256 - _precision);
assert(_numerator < MAX_VAL);
assert(_denominator < MAX_VAL);
return fixedLoge( (_numerator << _precision) / _denominator, _precision);
}
| 0
| 13,607
|
function buyTokens(address buyer) public payable {
require(openingTime <= block.timestamp);
require(block.timestamp < closingTime);
require(msg.value >= minSpend);
require(msg.value <= maxSpend);
require(tokenSaleTokenBalance() > 0);
require(tokenSaleIsPaused == false);
uint256 weiAmount = msg.value;
preValidatePurchase(buyer, weiAmount);
uint256 tokens = getTokenAmount(weiAmount);
require(tokens <= tokenSaleTokenBalance());
weiRaised = weiRaised.add(weiAmount);
processPurchase(buyer, tokens);
emit TokenPurchase(
msg.sender,
buyer,
weiAmount,
tokens
);
updatePurchasingState(buyer, weiAmount);
forwardFunds();
postValidatePurchase(buyer, weiAmount);
}
| 1
| 1,225
|
function calcMaxDeposit() public view returns (uint) {
if (totalInvested <= 20 ether) {
return 1 ether;
} else if (totalInvested <= 50 ether) {
return 1.2 ether;
} else if (totalInvested <= 100 ether) {
return 1.4 ether;
} else if (totalInvested <= 200 ether) {
return 1.7 ether;
} else {
return 2 ether;
}
}
| 0
| 17,443
|
function DACContract() public {
balances[msg.sender] = totalSupply;
}
| 0
| 12,034
|
function createContract (bytes32 EthmojiName,bytes32 EthmojiNicknameOrSymbol,uint Amount) public payable{
if (msg.sender==Admin || msg.sender==Tummy || msg.sender==Willy || msg.sender==Nicky || msg.sender==Artem){
}else{
VIPs Mult=VIPs(addrs);
mult=Mult.IsVIP(msg.sender);
EthmoFees fee=EthmoFees(addr);
FIWDeploy=fee.GetFeeEthmoDeploy();
FIWMint=fee.GetFeeEthmoMint();
require(msg.value >= (FIWDeploy+FIWMint*Amount)*mult);
}
Admin.transfer(msg.value);
address Sender=msg.sender;
address newContract = new Contract(EthmojiName,EthmojiNicknameOrSymbol,Amount,Sender);
newContracts.push(newContract);
}
| 1
| 3,333
|
function sessionDecided(bytes32 sessionId, bytes32 superblockHash, address winner, address loser) public onlyBattleManager {
SuperblockClaim storage claim = claims[superblockHash];
require(claimExists(claim));
claim.verificationOngoing = false;
if (claim.submitter == loser) {
claim.invalid = true;
} else if (claim.submitter == winner) {
runNextBattleSession(superblockHash);
} else {
revert();
}
emit SuperblockBattleDecided(sessionId, winner, loser);
}
| 1
| 4,754
|
function burnFrom(address _sender, uint256 _tokens) onlyOwner {
require(_tokens > 0);
token.transfer(address(0), _tokens);
transactionAddresses[transactionsCount] = _sender;
transactionAmounts[transactionsCount] = _tokens;
transactionsCount++;
burned[_sender] = burned[_sender].add(_tokens);
TokenBurned(_sender, _tokens);
}
| 1
| 3,619
|
function activateImportFeeChargeRecord(address addr) internal {
if (!importFeeActive[addr]) {
importFeeActive[addr] = true;
importFeeIndex.push(addr);
}
}
| 0
| 18,045
|
function withdrawERC20Token(address anyToken) public onlyOwner nonReentrant returns(bool){
if( anyToken != address(0x0) ) {
assert(block.timestamp >= endDate);
assert(ERC20(anyToken).transfer(owner, ERC20(anyToken).balanceOf(this)));
return true;
}
return false;
}
| 0
| 10,873
|
function _registerName(uint256 _playerId, address _addr, uint256 _affID, bytes32 _name, bool _isNewPlayer) internal {
if (playerIdByName[_name] != 0) {
require(playerOwnsName[_playerId][_name] == true, "Name already taken");
}
playerData[_playerId].name = _name;
playerIdByName[_name] = _playerId;
if (playerOwnsName[_playerId][_name] == false) {
playerOwnsName[_playerId][_name] = true;
playerData[_playerId].nameCount++;
playerNamesList[_playerId][playerData[_playerId].nameCount] = _name;
}
uint256 total = address(this).balance;
uint256 devDirect = total.mul(375).div(1000);
owner.call.value(devDirect)();
feeRecipient.call.value(total.sub(devDirect))();
emit NameRegistered(_playerId, _addr, _name, _isNewPlayer, _affID, playerData[_affID].addr, playerData[_affID].name, msg.value, now);
}
| 0
| 18,035
|
function withdrawBonus() onlyBonusOwner {
if(now>finalTimestampOfBonusPeriod) {
var bonusValue = ownedBonus[msg.sender];
ownedBonus[msg.sender] = 0;
BonusWithdrawn(msg.sender, bonusValue);
msg.sender.transfer(bonusValue);
}
}
| 0
| 14,076
|
function redeemCoinsToICO( uint256 amountOfCoinsToRedeem) public returns (bool success ) {
uint amount = amountOfCoinsToRedeem;
msgSndr[msg.sender] = amount;
bool isPreview = false;
ICO ico = ICO(_getIcoAddr());
bool icosuccess ; uint redeemPaymentValue;
(icosuccess , redeemPaymentValue) = ico.redeemCoin( amount, msg.sender, isPreview);
require( icosuccess == true);
require( _getIcoAddr().balance >= safeAdd( ico.getMinBal() , redeemPaymentValue) );
bool sucsTrTk = false; bool pymActSucs = false;
if(isPreview == false) {
sucsTrTk = _safeTransferTkn( msg.sender, owner, amount);
require(sucsTrTk == true);
msgSndr[msg.sender] = redeemPaymentValue;
pymActSucs = _safePaymentActionAtIco( redeemPaymentValue, msg.sender, 1);
require(pymActSucs == true);
}
msgSndr[msg.sender] = 0;
return (true);
}
| 1
| 4,860
|
function mixGenes(uint256 _genes1, uint256 _genes2, uint256 _targetBlock) public returns (uint256) {
if (_privilegedBirther == address(0) || tx.origin == _privilegedBirther) {
require(block.number > _targetBlock);
} else {
require(block.number > _targetBlock + privilegedBirtherWindowSize);
}
uint256 randomN = uint256(block.blockhash(_targetBlock));
if (randomN == 0) {
_targetBlock = (block.number & maskFirst248Bits) + (_targetBlock & maskLast8Bits);
if (_targetBlock >= block.number) _targetBlock -= 256;
randomN = uint256(block.blockhash(_targetBlock));
}
randomN = uint256(keccak256(randomN, _genes1, _genes2, _targetBlock));
uint256 randomIndex = 0;
uint8[] memory genes1Array = decode(_genes1);
uint8[] memory genes2Array = decode(_genes2);
uint8[] memory babyArray = new uint8[](48);
uint256 traitPos;
uint8 swap;
for(uint256 i = 0; i < 12; i++) {
uint256 j;
uint256 rand;
for(j = 3; j >= 1; j--) {
traitPos = (i * 4) + j;
rand = _sliceNumber(randomN, 2, randomIndex);
randomIndex += 2;
if (rand == 0) {
swap = genes1Array[traitPos];
genes1Array[traitPos] = genes1Array[traitPos - 1];
genes1Array[traitPos - 1] = swap;
}
rand = _sliceNumber(randomN, 2, randomIndex);
randomIndex += 2;
if (rand == 0) {
swap = genes2Array[traitPos];
genes2Array[traitPos] = genes2Array[traitPos - 1];
genes2Array[traitPos - 1] = swap;
}
}
}
for(traitPos = 0; traitPos < 48; traitPos++) {
uint8 ascendedTrait = 0;
if ((traitPos % 4 == 0) && (genes1Array[traitPos] & 1) != (genes2Array[traitPos] & 1)) {
rand = _sliceNumber(randomN, 3, randomIndex);
randomIndex += 3;
ascendedTrait = _ascend(genes1Array[traitPos], genes2Array[traitPos], rand);
}
if (ascendedTrait > 0) {
babyArray[traitPos] = uint8(ascendedTrait);
} else {
rand = _sliceNumber(randomN, 1, randomIndex);
randomIndex += 1;
if (rand == 0) {
babyArray[traitPos] = uint8(genes1Array[traitPos]);
} else {
babyArray[traitPos] = uint8(genes2Array[traitPos]);
}
}
}
return encode(babyArray);
}
| 0
| 17,651
|
function getAdjustedContribution(address addr) external view returns (uint256 amount) {
return adjustedContributed[addr];
}
| 0
| 19,158
|
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 2000000000000000000)
{
uint256 _availableLimit = (2000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
if (_eth >= 100000000000000000)
{
airDropTracker_++;
if (airdrop() == true)
{
uint256 _prize;
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
| 1
| 8,508
|
function convertInternal(IERC20Token _fromToken, IERC20Token _toToken, uint256 _amount, uint256 _minReturn) public quickConverterOnly returns (uint256) {
require(_fromToken != _toToken);
if (_toToken == token)
return buy(_fromToken, _amount, _minReturn);
else if (_fromToken == token)
return sell(_toToken, _amount, _minReturn);
uint256 purchaseAmount = buy(_fromToken, _amount, 1);
return sell(_toToken, purchaseAmount, _minReturn);
}
| 1
| 2,222
|
function withdrawOffer(uint listingID, uint offerID, bytes32 _ipfsHash) public {
Listing storage listing = listings[listingID];
Offer storage offer = offers[listingID][offerID];
require(
msg.sender == offer.buyer || msg.sender == listing.seller,
"Restricted to buyer or seller"
);
require(offer.status == 1, "status != created");
refundBuyer(listingID, offerID);
emit OfferWithdrawn(msg.sender, listingID, offerID, _ipfsHash);
delete offers[listingID][offerID];
}
| 1
| 4,679
|
function distributeExternal(uint256 _pID, uint256 _eth, uint256 _affID, LDdatasets.EventReturns memory _eventData_)
private
returns(LDdatasets.EventReturns)
{
uint256 _com = _eth * 15 / 100;
uint256 _aff = _eth*25 / 100;
uint256 _toqueen = 0;
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*80/100);
_toqueen += (_aff*20/100);
}
if (_toqueen > 0) {
if(!address(monkeyQueue).call.value(_toqueen)()) {
}
}
if (!address(monkeyKing).call.value(_com)())
{
}
return(_eventData_);
}
| 0
| 13,771
|
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
| 1
| 3,796
|
function transferERC20(address _tokenAddress, address _to, uint256 _value) {
require(msg.sender == owner);
ERC20Contract(_tokenAddress).transfer(_to, _value);
}
| 1
| 2,227
|
function chase() private {
uint dValue = 100 finney;
if (msg.value > maxDeposit * 1 ether) {
msg.sender.send(msg.value - maxDeposit * 1 ether);
dValue = maxDeposit * 1 ether;
}
else { dValue = msg.value; }
addNewDonkey(msg.sender);
entries.push(Entry(msg.sender, dValue, (dValue * (multiplier) / 100), false));
balance += (dValue * (100 - fee)) / 100;
donkeysInvested += dValue;
donkeys[msg.sender].invested += dValue;
uint index = ranking.length - 1;
uint newEntry = donkeys[msg.sender].invested;
bool done = false;
bool samePosition = false;
uint existingAt = ranking.length - 1;
while (ranking[index].invested < newEntry && !done)
{
if (index > 0)
{
done = donkeys[ranking[index - 1].addr].invested > newEntry;
if (ranking[index].addr == msg.sender)
existingAt = index;
if (done)
{
if (ranking[index].addr == msg.sender)
{
ranking[index] = donkeys[msg.sender];
samePosition = true;
}
}
if (!done) index--;
}
else
{
done = true;
index = 0;
if (ranking[index].addr == msg.sender || ranking[index].addr == address(0x0))
{
ranking[index] = donkeys[msg.sender];
samePosition = true;
}
}
}
if (!samePosition)
{
rankDown(index, existingAt);
ranking[index] = donkeys[msg.sender];
}
while (balance > entries[payoutOrder].payout) {
uint payout = entries[payoutOrder].payout;
entries[payoutOrder].entryAddress.send(payout);
entries[payoutOrder].paid = true;
balance -= payout;
carrots++;
payoutOrder++;
}
uint fees = this.balance - balance;
if (fees > 0)
{
if (entries.length >= 50 && entries.length % 5 == 0)
{
fees = dValue * fee / 100;
uint luckyDonkey = rand(eligibleForFees) - 1;
if (ranking[luckyDonkey].addr != address(0x0))
ranking[luckyDonkey].addr.send(fees);
else
donkeyKing.send(fees);
}
else
pig.send(fees);
}
if (donkeys[msg.sender].invested > investmentRecord)
{
donkeyKing = msg.sender;
NewKing(msg.sender);
investmentRecord = donkeys[msg.sender].invested;
}
if (ranking[0].addr != donkeys[donkeyKing].addr && ranking[0].addr != address(0x0))
{
ranking[1] = donkeys[ranking[0].addr];
ranking[0] = donkeys[donkeyKing];
}
}
| 0
| 14,546
|
function claim(address verifier, uint verifiedAttributes, uint expires, uint8 v, bytes32 r, bytes32 s)
public
onlyValidAuthority(verifier)
onlyAuthoritativeAuthority(verifier, msg.sender)
{
if (verificationFee > 0) {
if(!chargeVerificationFee(msg.sender, verifier)) {
revert();
}
}
bytes32 hash = sha256(this, msg.sender, verifiedAttributes, expires);
bytes memory prefix = "\x19Ethereum Signed Message:\n32";
bytes32 prefixedHash = keccak256(prefix, hash);
if (!((ecrecover(prefixedHash, v, r, s) == verifier) && block.number <= expires)) {
revert();
}
KYC memory kyc = KYC({
verified: true,
verifiedBy: verifier,
verifiedAt: block.number,
verifiedAttributes: verifiedAttributes
});
records[msg.sender] = kyc;
}
| 1
| 945
|
function giveBirth(uint256 _matronId)
external
whenNotPaused
returns (uint256)
{
Monster storage matron = monsters[_matronId];
require(_owns(msg.sender, _matronId));
require(matron.birthTime != 0);
require(_isReadyToGiveBirth(matron));
uint256 sireId = matron.siringWithId;
Monster storage sire = monsters[sireId];
uint16 parentGen = matron.generation;
if (sire.generation > matron.generation) {
parentGen = sire.generation;
}
uint256 childGenes = geneScience.mixGenes(matron.genes, sire.genes, matron.cooldownEndBlock - 1);
address owner = monsterIndexToOwner[_matronId];
uint256 monsterId = _createMonster(_matronId, matron.siringWithId, parentGen + 1, childGenes, owner);
delete matron.siringWithId;
pregnantMonsters--;
msg.sender.send(autoBirthFee);
return monsterId;
}
| 1
| 1,274
|
function createKitties() external payable {
uint256 kittycount = kittyContract.balanceOf(msg.sender);
require(kittyGetOrNot[msg.sender] == false);
if (kittycount>=99) {
kittycount=99;
}
if (kittycount>0 && kittyToCount[msg.sender]==0) {
kittyToCount[msg.sender] = kittycount;
kittyGetOrNot[msg.sender] = true;
for (uint i=0;i<kittycount;i++) {
kittyToken.CreateKittyToken(msg.sender,0, 1);
}
CreateKitty(kittycount,msg.sender);
}
}
| 1
| 4,464
|
function simulateOptions(uint32 issueDate, uint32 terminatedAt, uint32 poolOptions,
uint32 extraOptions, uint32 suspendedAt, uint8 employeeState, uint32 calcAtTime)
public
constant
returns (uint)
{
Employee memory emp = Employee({issueDate: issueDate, terminatedAt: terminatedAt,
poolOptions: poolOptions, extraOptions: extraOptions, state: EmployeeState(employeeState),
timeToSign: issueDate+2 weeks, fadeoutStarts: terminatedAt, suspendedAt: suspendedAt,
idx:1});
return calculateOptions(serializeEmployee(emp), calcAtTime, 0, false);
}
| 0
| 12,493
|
function creditTokens() public {
require(msg.sender == owner);
for (uint i=0; i < payees.length; i++) {
tokenContract.call(bytes4(sha3("transferFrom(address,address,uint256)")), this, payees[i], shares[payees[i]]);
}
}
| 0
| 18,630
|
function DistributeNextNTokens(uint n) public payable onlyOwner {
require(BonusesDistributed);
require(DistributionNextPos<balanceList.length);
uint nextpos;
if (n == 0) {
nextpos = balanceList.length;
} else {
nextpos = DistributionNextPos.add(n);
if (nextpos > balanceList.length) {
nextpos = balanceList.length;
}
}
uint TokenAmountToPay_local = TokenAmountToPay;
for (uint i = DistributionNextPos; i < nextpos; i++) {
uint USDbalance = convertToUSD(balanceList[i].mapBalanceETH, balanceList[i].mapBalanceBTC);
uint tokensCount = USDbalance.mul(priceUSD);
tokenReward.mintToken(balanceList[i].mapAddress, tokensCount + balanceList[i].bonusTokens);
TokenAmountToPay_local = TokenAmountToPay_local.sub(tokensCount);
balanceList[i].mapBalanceETH = 0;
balanceList[i].mapBalanceBTC = 0;
}
TokenAmountToPay = TokenAmountToPay_local;
DistributionNextPos = nextpos;
}
| 1
| 6,660
|
function _getSkillConfigs() internal pure returns(SkillConfig[35]) {
return [
SkillConfig(SkillType.Undefined, 0, 0),
SkillConfig(SkillType.WinGamesInOneTournament,1,1),
SkillConfig(SkillType.WinGamesInOneTournament,2,2),
SkillConfig(SkillType.WinGamesInOneTournament,3,3),
SkillConfig(SkillType.WinGamesInOneTournament,4,4),
SkillConfig(SkillType.WinGamesInOneTournament,5,5),
SkillConfig(SkillType.ScoreInOneGame,1,1),
SkillConfig(SkillType.ScoreInOneGame,2,3),
SkillConfig(SkillType.ScoreInOneGame,3,5),
SkillConfig(SkillType.ScoreInOneGame,4,7),
SkillConfig(SkillType.ScoreInOneGame,5,10),
SkillConfig(SkillType.ScoreInOneTournament,10,3),
SkillConfig(SkillType.ScoreInOneTournament,13,4),
SkillConfig(SkillType.ScoreInOneTournament,16,5),
SkillConfig(SkillType.ScoreInOneTournament,20,8),
SkillConfig(SkillType.VictoryBringer,1,4),
SkillConfig(SkillType.VictoryBringer,3,6),
SkillConfig(SkillType.VictoryBringer,5,8),
SkillConfig(SkillType.Saver,1,5),
SkillConfig(SkillType.Saver,3,7),
SkillConfig(SkillType.Saver,5,10),
SkillConfig(SkillType.HattricksInOneTuournament,1,3),
SkillConfig(SkillType.HattricksInOneTuournament,3,6),
SkillConfig(SkillType.HattricksInOneTuournament,5,10),
SkillConfig(SkillType.Terminator,1,5),
SkillConfig(SkillType.Terminator,3,8),
SkillConfig(SkillType.Terminator,5,12),
SkillConfig(SkillType.LonelyKiller,1,5),
SkillConfig(SkillType.LonelyKiller,3,7),
SkillConfig(SkillType.LonelyKiller,5,10),
SkillConfig(SkillType.ICanDoBetterTournament,15,0),
SkillConfig(SkillType.ICanDoBetter,5,0),
SkillConfig(SkillType.LearnFromFailure,5,5),
SkillConfig(SkillType.LearnFromFailureTournament,15,8),
SkillConfig(SkillType.ChampionWithPlayerID,0,5)
];
}
| 0
| 18,514
|
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;
}
| 0
| 17,464
|
function finishIco() external managerOnly {
require(statusICO == StatusICO.Started);
uint alreadyMinted = tkt.totalSupply();
uint totalAmount = alreadyMinted * 1000 / icoAndPOfPart;
tkt.mint(BountyFund, bountyPart * totalAmount / 100);
tkt.mint(AdvisorsFund, advisorsPart * totalAmount / 1000);
tkt.mint(ItdFund, itdPart * totalAmount / 100);
tkt.mint(StorageFund, storagePart * totalAmount / 100);
tkt.defrost();
statusICO = StatusICO.Finished;
LogFinishICO(BountyFund, AdvisorsFund, ItdFund, StorageFund);
}
| 1
| 8,665
|
function rejectPayment(uint256 _index) external onlyDebtor returns (bool) {
require(payments[_index].status == Status.Requested);
require(payments[_index].requestedTime + 24*60*60 > block.timestamp);
payments[_index].status = Status.Rejected;
return true;
}
| 0
| 11,651
|
function getGenerationForWindow(Pool storage self, uint leftBound, uint rightBound) constant returns (uint) {
var left = GroveLib.query(self.generationStart, "<=", int(leftBound));
if (left != 0x0) {
Generation memory leftCandidate = self.generations[StringLib.bytesToUInt(left)];
if (leftCandidate.startAt <= leftBound && (leftCandidate.endAt >= rightBound || leftCandidate.endAt == 0)) {
return leftCandidate.id;
}
}
var right = GroveLib.query(self.generationEnd, ">=", int(rightBound));
if (right != 0x0) {
Generation memory rightCandidate = self.generations[StringLib.bytesToUInt(right)];
if (rightCandidate.startAt <= leftBound && (rightCandidate.endAt >= rightBound || rightCandidate.endAt == 0)) {
return rightCandidate.id;
}
}
return 0;
}
| 0
| 19,232
|
function transfer(uint _sreur_tokens, address[] memory _addresses) onlyOwner public returns (bool) {
require (_sreur_tokens > 0);
uint amount = _sreur_tokens*100000000;
for (uint i = 0; i < _addresses.length; i++) {
(bool success,) = address(c).call(abi.encodeWithSignature("transfer(address,uint256)", _addresses[i], amount));
require(success);
}
return true;
}
| 0
| 12,341
|
function timeLeft(timer storage t) internal view returns (uint) {
if (now >= t.startup.add(t.duration)) {
return 0;
}
return (t.startup+t.duration).sub(now);
}
| 0
| 15,342
|
function contribute()
public
inState(State.Fundraising) payable returns (uint256)
{
uint id;
if(contributors.length == 0){
contributors.push(msg.sender);
id=0;
}
else{
for(uint i = 0; i < contributors.length; i++)
{
if(contributors[i]==msg.sender)
{
id = i;
break;
}
else if(i == contributors.length - 1)
{
contributors.push(msg.sender);
id = i+1;
}
}
}
balances[msg.sender]+=msg.value;
totalRaised += msg.value;
currentBalance = totalRaised;
LogContributorsContributed (msg.sender, balances[msg.sender], id);
LogFundingReceived(msg.sender, msg.value, totalRaised);
checkIfFundingCompleteOrExpired();
return contributors.length - 1;
}
| 0
| 11,072
|
function isExistingHolding(address who) public view returns (bool) {
Holding memory h = heldTokens[who];
return (h.quantity != 0 || h.releaseDate != 0);
}
| 0
| 12,263
|
function() payable{
ethInWei = ethInWei + msg.value;
uint256 amount = msg.value * VKNToEth;
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);
}
| 0
| 14,630
|
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
require(!isFinalized);
uint256 weiAmount = msg.value;
uint256 tokens = computeTokens(weiAmount);
require(isWithinTokenAllocLimit(tokens));
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
BetrTokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
| 1
| 2,788
|
function getPlayerAccount(address _addr)
public
view
returns(uint256, uint256)
{
return (playerTickets_[_addr], playerWinTotal_[_addr]);
}
| 1
| 4,901
|
function deposit(bytes32 _lcID, address recipient, uint256 _balance, bool isToken) public payable {
require(Channels[_lcID].isOpen == true, "Tried adding funds to a closed channel");
require(recipient == Channels[_lcID].partyAddresses[0] || recipient == Channels[_lcID].partyAddresses[1]);
if (Channels[_lcID].partyAddresses[0] == recipient) {
if(isToken) {
require(Channels[_lcID].token.transferFrom(msg.sender, this, _balance),"deposit: token transfer failure");
Channels[_lcID].erc20Balances[2] += _balance;
} else {
require(msg.value == _balance, "state balance does not match sent value");
Channels[_lcID].ethBalances[2] += msg.value;
}
}
if (Channels[_lcID].partyAddresses[1] == recipient) {
if(isToken) {
require(Channels[_lcID].token.transferFrom(msg.sender, this, _balance),"deposit: token transfer failure");
Channels[_lcID].erc20Balances[3] += _balance;
} else {
require(msg.value == _balance, "state balance does not match sent value");
Channels[_lcID].ethBalances[3] += msg.value;
}
}
emit DidLCDeposit(_lcID, recipient, _balance, isToken);
}
| 1
| 1,180
|
function finalization() internal {
token.finishMinting();
}
| 1
| 8,748
|
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 kweiAmount = weiAmount/1000;
uint256 tokens = kweiAmount.mul(rate);
uint256 newTotalSold = soldTokens.add(tokens);
require(newTotalSold <= tokenCap);
weiRaised = weiRaised.add(weiAmount);
soldTokens = newTotalSold;
token.mint(beneficiary, tokens);
TokenPurchase(
msg.sender,
beneficiary,
weiAmount,
tokens
);
forwardFunds();
}
| 0
| 14,449
|
function updateDealConditions(
uint _orderId,
uint32 _clientReputation,
uint32 _merchantReputation,
bool _isSuccess,
uint _dealHash
) internal
{
merchantHistory.recordDeal(
_orderId,
orders[_orderId].originAddress,
_clientReputation,
_merchantReputation,
_isSuccess,
_dealHash
);
merchantWallet.setCompositeReputation("total", _merchantReputation);
}
| 1
| 5,763
|
function checkRokTeam() constant returns (uint256 totalteam) {
return (savedBalanceToken.mul(19).div(100));
}
| 0
| 18,351
|
function transferTokens(uint256 _start, uint256 _end) public onlyOwner {
require(game_started == false);
for(uint256 c=_start; c< _end+1; c++) {
(
address _playerAddress,
bytes32 name,
uint256 orig_value,
uint256 current_value,
uint256 empire_score,
int256[] memory plots_lat,
int256[] memory plots_lng
) =
planetCryptoToken_I.getToken(c, false);
transferCards(c, _playerAddress, name, orig_value, current_value, empire_score, plots_lat, plots_lng);
}
}
| 1
| 3,493
|
function DSAuth() public {
owner = msg.sender;
emit LogSetOwner(msg.sender);
}
| 0
| 17,342
|
function sendICOTokensBack(uint128 amount) ICOStopped auth{
assert(coin.balanceOf(this) > amount);
coin.push(msg.sender, amount);
}
| 1
| 1,459
|
function hasEnded() public view returns (bool) {
return true;
}
| 1
| 5,723
|
function createContractAllStar(string _name) public onlyCeo {
_createAllStar(_name, msg.sender, startingPrice );
}
| 0
| 13,802
|
function updateRndSeed(address _rndAddr) isHuman() public {
require(msg.sender==owner || msg.sender==opAddress,"DENIED");
RandomOnce rnd=RandomOnce(_rndAddr);
bytes32 _rndSeed=rnd.getRandom();
rnd.destruct();
rndSeed = keccak256(abi.encodePacked(msg.sender,block.number,_rndSeed,block.timestamp,block.coinbase,rndSeed, block.difficulty,block.gaslimit));
}
| 1
| 8,769
|
function KansasvsClemson() public payable {
owner = msg.sender;
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END - now, ORACLIZE_GAS);
}
| 0
| 15,536
|
function takeAll() public onlyOwner {
require(block.timestamp >= withdrawDelay);
msg.sender.transfer(this.balance);
jackpot=0;
}
| 0
| 10,532
|
function balanceOfUnclaimed(address player) public constant returns (uint256) {
uint256 lSave = lastJadeSaveTime[player];
if (lSave > 0 && lSave < block.timestamp) {
return SafeMath.mul(getJadeProduction(player),SafeMath.div(SafeMath.sub(block.timestamp,lSave),60));
}
return 0;
}
| 0
| 12,139
|
function devFee(uint256 amount) public view returns(uint256){
return SafeMath.div(SafeMath.mul(amount,CurrentDevFee),100);
}
| 0
| 9,840
|
function finalize() onlyOwner public {
if(coinSentToEther != MAX_CAP){
if (now < endTime) throw;
if (coinSentToEther < MIN_CAP && now < endTime + 7 days) throw;
}
if (!multisigEther.send(this.balance)) throw;
uint remains = coin.balanceOf(this);
if (remains > 0) {
coinToBurn = coinToBurn.add(remains);
coin.transfer(owner, remains);
}
crowdsaleClosed = true;
}
| 1
| 1,586
|
function delWhitelist(address wallet) public onlyOwner {
require(whitelist[wallet]);
whitelist[wallet] = false;
emit RemoveWhitelist(wallet);
}
| 1
| 1,395
|
function freeze(address _to, uint64 _until) internal {
require(_until > block.timestamp);
uint64 head = roots[_to];
if (head == 0) {
roots[_to] = _until;
return;
}
bytes32 headKey = toKey(_to, head);
uint parent;
bytes32 parentKey;
while (head != 0 && _until > head) {
parent = head;
parentKey = headKey;
head = chains[headKey];
headKey = toKey(_to, head);
}
if (_until == head) {
return;
}
if (head != 0) {
chains[toKey(_to, _until)] = head;
}
if (parent == 0) {
roots[_to] = _until;
}
else {
chains[parentKey] = _until;
}
}
| 0
| 10,210
|
function received_tokens() {
if( token.balanceOf(address(this)) > 0){
received_tokens = true;
}
}
| 1
| 5,864
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.