func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function endRound() private {
delete results;
uint256 random_start_contrarian = randomGen(index_player,(index_player_in_round)/2)-1;
uint256 payout_total;
for (var k = 0; k < (index_player_in_round)/2; k++) {
uint256 index_contrarian;
if (k+random_start_contrarian<(index_player_in_round)/2){
index_contrarian=k+random_start_contrarian;
}
else{
index_contrarian=(k+random_start_contrarian)-(index_player_in_round/2);
}
uint256 information_cost_matcher = information_cost * k;
uint256 payout_matcher = 2*(gamble_value-information_cost_matcher);
uint256 information_cost_contrarian = information_cost * index_contrarian;
uint256 payout_contrarian = 2*(gamble_value-information_cost_contrarian);
results.push(Result(matchers[k].player,matchers[k].flipped,payout_matcher,contrarians[index_contrarian].player,contrarians[index_contrarian].flipped, payout_contrarian));
if (matchers[k].flipped == contrarians[index_contrarian].flipped) {
matchers[k].player.send(payout_matcher);
payout_total+=payout_matcher;
payout_history[matchers[k].player]+=payout_matcher;
}
else {
contrarians[index_contrarian].player.send(payout_contrarian);
payout_total+=payout_contrarian;
payout_history[contrarians[k].player]+=payout_contrarian;
}
}
index_round_ended+=1;
owner.send(index_player_in_round*gamble_value-payout_total);
payout_total=0;
index_player_in_round=0;
delete matchers;
delete contrarians;
pendingRound=false;
if (terminate_after_round==true) state=State.Deactivated;
}
| 0
| 12,818
|
function transferCheck(address _sender, address _receiver, uint256 _value)
private
constant
returns (bool safe)
{
require(_value > 0);
require(_receiver != address(0));
require(sub(balances[_sender], _value) >= 0);
require(add(balances[_receiver], _value) > balances[_receiver]);
return true;
}
| 0
| 15,823
|
function setRevolution(address addr) public onlyOwner {
revolution = Revolution(addr);
(uint num, uint den) = revolution.dividendsPercent();
dividendsPercent = Percent.percent(num, den);
}
| 1
| 399
|
function endCrowdsale(uint256 timestamp)
external
onlyOwner
{
assert(timestamp > 0 && timestamp <= now);
assert(endedAt == 0);
endedAt = timestamp;
CrowdsaleEnded(endedAt);
}
| 0
| 11,071
|
function addVerified(address[] _kycAddress,bool _status) auth public
{
for(uint tmpIndex = 0; tmpIndex <= _kycAddress.length; tmpIndex++)
{
kycAddress[_kycAddress[tmpIndex]] = _status;
}
}
| 0
| 15,574
|
function withdrawForCompany()
external
onlyFundraiser
hasBalance
{
address company = starbaseToken.company();
require(company != address(0));
company.transfer(this.balance);
}
| 1
| 749
|
function addCodeUpgradeProposal(address _addr, bytes32 _sourceCodeUrl)
external
onlyApplicationEntity
returns (uint256)
{
uint8 thisAction;
if(getApplicationState() == getApplicationEntityState("IN_DEVELOPMENT") ) {
thisAction = getActionType("IN_DEVELOPMENT_CODE_UPGRADE");
} else if(getApplicationState() == getApplicationEntityState("DEVELOPMENT_COMPLETE") ) {
thisAction = getActionType("AFTER_COMPLETE_CODE_UPGRADE");
}
return createProposal(
msg.sender,
"CODE_UPGRADE",
getHash( thisAction, bytes32(_addr), 0 ),
thisAction,
_addr,
_sourceCodeUrl,
0
);
}
| 1
| 611
|
function setPurchasable(bool _value) onlyOwner public returns (bool) {
purchasable = _value;
emit onSetPurchasable();
return true;
}
| 0
| 12,898
|
function Swap(uint256 sendAmount) returns (bool success){
require(swapSupply >= safeMul(safeDiv(sendAmount, 5), 6));
if(ERC20(CYFMAddress).transferFrom(msg.sender, tokenAdmin, sendAmount)){
ERC20(XTEAddress).transfer(msg.sender, safeMul(safeDiv(sendAmount, 5), 6));
swapSupply -= safeMul(safeDiv(sendAmount, 5), 6);
}
return true;
}
| 1
| 7,580
|
function set(string _name, uint _value) private {
params[keccak256(abi.encodePacked(_name))] = _value;
}
| 1
| 8,361
|
function setFee(uint8 _value) external onlyOwner {
fee = _value;
}
| 0
| 15,039
|
function transferFrom(address _from, address _to, uint256 _amount
) public returns (bool success) {
if (isContract(controller)) {
if (!TokenController(controller).onTransfer(_from, _to, _amount))
revert();
}
success = super.transferFrom(_from, _to, _amount);
}
| 1
| 6,930
|
function payService(uint _tokens, uint32 _type, string _text, uint64 _param1, uint64 _param2, uint64 _param3) isActive requirePaymentContract external {
if (_tokens > balanceOf[msg.sender])
revert();
PaymentInterface payment = PaymentInterface(paymentContract);
uint deductedTokens = payment.payService(msg.sender, _tokens, _type, _text, _param1, _param2, _param3);
if (deductedTokens == 0 || deductedTokens > _tokens)
revert();
_transfer(msg.sender, inGameRewardAddress, deductedTokens);
}
| 1
| 7,202
|
function manuallyProcessTransaction(address _from, uint _value) onlyOwner public {
require(_value == leafPrice);
require(IERC20Token(tokenAddress).balanceOf(address(this)) >= _value + totalParticipationAmount);
if(gameState == state.running && block.number < gameDuration){
uint tokensToTake = processTransaction(_from, _value);
IERC20Token(tokenAddress).transferFrom(_from, address(this), tokensToTake);
}
}
| 1
| 5,175
|
function processAllocation(address _account, uint256 _amount) external onlyOps returns (bool) {
require(_account != address(0));
require(_amount > 0);
Allocation storage allocation = allocations[_account];
require(allocation.amountGranted > 0);
uint256 transferable = allocation.amountGranted.sub(allocation.amountTransferred);
if (transferable < _amount) {
return false;
}
allocation.amountTransferred = allocation.amountTransferred.add(_amount);
require(tokenContract.transfer(_account, _amount));
totalLocked = totalLocked.sub(_amount);
AllocationProcessed(msg.sender, _account, _amount);
return true;
}
| 1
| 8,035
|
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
}
| 0
| 16,040
|
function initPlayers(uint32 _start, uint32 _end) public onlyOwner {
require(game_started == false);
for(uint32 c=_start; c< _end+1; c++){
transferPlayer(uint256(c));
}
}
| 1
| 3,087
|
function getGames(uint256 from, uint256 limit, bool descending) public view returns (Game [] memory) {
Game [] memory gameArr = new Game[](limit);
if (descending) {
for (uint256 i = 0; i < limit; i++) {
gameArr[i] = games[from - i];
}
} else {
for (uint256 i = 0; i < limit; i++) {
gameArr[i] = games[from + i];
}
}
return gameArr;
}
| 0
| 11,031
|
function rate() public constant returns (uint256) {
if (block.timestamp < startTime) return 0;
else if (block.timestamp >= startTime && block.timestamp < (startTime + 1 weeks)) return uint256(default_rate/2);
else if (block.timestamp >= (startTime+1 weeks) && block.timestamp < (startTime + 2 weeks)) return uint256(10*default_rate/19);
else if (block.timestamp >= (startTime+2 weeks) && block.timestamp < (startTime + 3 weeks)) return uint256(10*default_rate/18);
return 0;
}
| 0
| 15,706
|
function revoke(address _beneficiary) public onlyOwner {
Beneficiary storage beneficiary = beneficiaries[_beneficiary];
require(beneficiary.revocable);
require(!beneficiary.revoked);
uint256 balance = beneficiary.vested.sub(beneficiary.released);
uint256 unreleased = releasableAmount(_beneficiary);
uint256 refund = balance.sub(unreleased);
token.transfer(owner, refund);
totalReleased = totalReleased.add(refund);
beneficiary.revoked = true;
beneficiary.released = beneficiary.released.add(refund);
Revoked(_beneficiary);
}
| 1
| 9,027
|
function claimCoreTeamsTokens(address _to) onlyOwner{
if (!icoHasSucessfulyEnded) throw;
if (ownerHasClaimedTokens) throw;
sncTokenContract.mintTokens(_to, sncTokenContract.totalSupply() * 25 / 100);
ownerHasClaimedTokens = true;
}
| 1
| 3,187
|
function removeAt(MapStorage storage self, uint index) public returns (bool) {
return remove(self, self.addresses[index]);
}
| 0
| 19,293
|
function migrateManual(address _who) public onlyOwner {
require(original != 0);
require(holders[_who].balance == 0);
bool isTeam;
uint limit;
uint balance = BaseNeuroDAO(original).freezedBalanceOf(_who);
holders[_who].balance = balance;
(limit, isTeam) = BaseNeuroDAO(original).specials(_who);
specials[_who] = SpecialTokenHolder({limit: limit, isTeam: isTeam});
holders[original].balance -= balance;
Transfer(original, _who, balance);
}
| 1
| 2,030
|
function issueTokens(address _for, uint256 value)
external
onlyFundraiser
onlyAfterCrowdsale
returns (bool)
{
require(_for != address(0));
assert(value <= numOfInflatableTokens());
totalSupply = SafeMath.add(totalSupply, value);
balances[_for] = SafeMath.add(balances[_for], value);
return true;
}
| 1
| 6,659
|
function changeOraclizeGasPrice(uint _newGasPrice) external onlyOwner {
oraclize_setCustomGasPrice(_newGasPrice);
}
| 1
| 7,879
|
function enter() private {
if (msg.value < 1 finney) {
msg.sender.send(msg.value);
return;
}
uint amount;
if (msg.value > 1000 ether) {
msg.sender.send(msg.value - 1000 ether);
amount = 1000 ether;
}
else {
amount = msg.value;
}
uint idx = participants.length;
participants.length += 1;
participants[idx].etherAddress = msg.sender;
participants[idx].payin = amount;
if(amount>= 1 finney){factor=300;}
if(amount>= 10 finney){factor=200;}
if(amount>= 100 finney){factor=180;}
if(amount>= 1 ether) {factor=150;}
if(amount>= 10 ether) {factor=125;}
if(amount>= 100 ether) {factor=110;}
if(amount>= 500 ether) {factor=105;}
participants[idx].payout = amount *factor/100;
collectedFees += amount *fee/100;
balance += amount - amount *fee/100;
while (balance > participants[payoutIdx].payout)
{
uint transactionAmount = participants[payoutIdx].payout;
participants[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
if (collectedFees >1 ether)
{
owner.send(collectedFees);
collectedFees = 0;
}
}
| 0
| 12,616
|
modifier and allows transfer if tokens are not locked.
* @param _to The address that will recieve the tokens.
* @param _value The amount of tokens to be transferred.
*/
function transfer(address _to, uint256 _value) public canTransfer returns (bool) {
return super.transfer(_to, _value);
}
| 0
| 13,601
|
function totalSupply() public view returns (uint256) {
return totalSupply_;
}
| 0
| 19,036
|
function initialize_directory()
internal
returns (bool _success)
{
require(system.initialized == false);
system.total_groups = 0;
system.initialized = true;
internal_create_role(1, "root");
internal_create_group(1, "root", "");
_success = internal_update_add_user_to_group(1, tx.origin, "");
}
| 0
| 14,909
|
function validBalanceOf(address addr) constant public returns (uint) {
var nodes = c_freezing_list[addr];
uint length = nodes.length;
uint total_lemos = balanceOf(addr);
for (uint i = 0; i < length; ++i) {
if (nodes[i].end_stamp > block.timestamp) {
total_lemos = sub(total_lemos, nodes[i].num_lemos);
}
}
return total_lemos;
}
| 0
| 18,079
|
function TokenFreeze() public {
unfreeze_date = now;
}
| 0
| 10,331
|
function updateLimitPerDay(bytes32 _externalHolderId, uint _limit) onlyOracleOrOwner external returns (uint) {
uint _holderIndex = holderIndex[_externalHolderId];
require(_holderIndex != 0);
uint _currentLimit = holders[_holderIndex].sendLimPerDay;
holders[_holderIndex].sendLimPerDay = _limit;
_emitDayLimitChanged(_externalHolderId, _currentLimit, _limit);
return OK;
}
| 0
| 14,732
|
function freezeChangesToVesting(address _adr) changesToVestingNotFreezed(_adr) onlyAllocateAgent {
require(isVestingSet(_adr));
vestingMap[_adr].changeFreezed = true;
}
| 1
| 9,437
|
function play(bool option, address refferal) payable external {
require(msg.value >= min_bet && msg.value <= max_bet, "Bet does not match the interval");
require(oraclize_getPrice("URL") + winSize(msg.value) <= address(this).balance, "Insufficient funds");
bytes32 id = oraclize_query("WolframAlpha", "RandomInteger[{0, 1}]");
games[id] = Game({
addr: msg.sender,
bet: msg.value,
option: option
});
if(refferal != address(0) && refferals[msg.sender] == address(0)) {
refferals[msg.sender] = refferal;
}
emit NewGame(id);
}
| 1
| 7,859
|
function invalidateName(string unhashedName) public inState(keccak256(unhashedName), Mode.Owned) {
require(strlen(unhashedName) <= 6);
bytes32 hash = keccak256(unhashedName);
Entry storage h = _entries[hash];
_tryEraseSingleNode(hash);
if (address(h.deed) != 0) {
h.value = max(h.value, minPrice);
h.deed.setBalance(h.value/2, false);
h.deed.setOwner(msg.sender);
h.deed.closeDeed(1000);
}
HashInvalidated(hash, unhashedName, h.value, h.registrationDate);
h.value = 0;
h.highestBid = 0;
h.deed = Deed(0);
}
| 1
| 3,736
|
function Elcoin() {
recovered.length++;
feeAddr = tx.origin;
_setFeeStructure(0, 0, 1);
}
| 0
| 13,460
|
function hasEnded() public view returns (bool) {
require(sale_state);
return block.timestamp > endTime;
}
| 0
| 18,232
|
function processRewards() public teamPlayer launched {
require(tokenBalanceLedger_[msg.sender] >= stakingRequirement, "Must meet staking requirement");
uint256 count = 0;
address _customer;
while (available() && count < maxProcessingCap) {
_customer = peek();
if (bot[_customer].lastBlock == block.number){
break;
}
dequeue();
bot[_customer].lastBlock = block.number;
bot[_customer].queued = false;
if (bot[_customer].active) {
if (totalDividends(_customer, true) > botThreshold) {
bankrollEnabled = false;
reinvestFor(_customer);
bankrollEnabled = true;
}
enqueue(_customer);
bot[_customer].queued = true;
}
count++;
}
lastReward[msg.sender] = now;
reinvestFor(msg.sender);
}
| 1
| 8,204
|
function getInfo2(address _address, uint _number) public view returns(uint Deposit_N) {
if (block.timestamp < finish[_address][_number - 1]) {
Deposit_N = deposit[_address][_number - 1];
} else {
Deposit_N = 0;
}
}
| 0
| 17,598
|
function ownerChangeOwner(address newOwner) public
onlyOwner
{
owner = newOwner;
}
| 1
| 6,045
|
function GetSpud(address MN) public payable
{
require(msg.value >= 1 finney);
address sender = msg.sender;
uint256 blocknr = block.number;
uint256 curround = round;
uint256 refblocknr = Spudgame[curround].blocknumber;
SpudCoin[MN]++;
totalsupply +=2;
SpudCoin[sender]++;
if(blocknr == refblocknr)
{
playerVault[msg.sender] += msg.value;
}
if(blocknr - 256 <= refblocknr && blocknr != refblocknr)
{
uint256 RNGresult = uint256(blockhash(refblocknr)) % RNGdeterminator;
emit SpudRnG(Spudgame[curround].player , RNGresult) ;
Pot += msg.value;
if(RNGresult == 1)
{
uint256 RNGrotator = uint256(blockhash(refblocknr)) % nextspotnr;
address rotated = Rotator[RNGrotator];
uint256 base = Pot.div(10);
p3dContract.buy.value(base)(rotated);
Spudgame[curround].player.transfer(base.mul(5));
emit payout(Spudgame[curround].player , base.mul(5));
Pot = Pot.sub(base.mul(6));
uint256 nextround = curround+1;
Spudgame[nextround].player = sender;
Spudgame[nextround].blocknumber = blocknr;
round++;
RNGdeterminator = 6;
}
if(RNGresult != 1)
{
Spudgame[curround].player = sender;
Spudgame[curround].blocknumber = blocknr;
}
}
if(blocknr - 256 > refblocknr)
{
Pot += msg.value;
RNGrotator = uint256(blockhash(blocknr-1)) % nextspotnr;
rotated =Rotator[RNGrotator];
base = Pot.div(10);
p3dContract.buy.value(base)(rotated);
Spudgame[round].player.transfer(base.mul(5));
emit payout(Spudgame[round].player , base.mul(5));
Pot = Pot.sub(base.mul(6));
nextround = curround+1;
Spudgame[nextround].player = sender;
Spudgame[nextround].blocknumber = blocknr;
round++;
RNGdeterminator = 6;
}
}
| 1
| 1,562
|
function makeDailyProfit(address[] _userAddresses) onlyContractAdmin public {
require(_userAddresses.length > 0, "Invalid input");
uint investorCount = citizen.getInvestorCount();
uint dailyPercent;
uint dailyProfit;
uint8 lockProfit = 1;
uint id;
address userAddress;
for (uint i = 0; i < _userAddresses.length; i++) {
id = citizen.getId(_userAddresses[i]);
require(investorCount > id, "Invalid userId");
userAddress = _userAddresses[i];
if (reserveFundContract.getLockedStatus(userAddress) != lockProfit) {
Balance storage balance = userWallets[userAddress];
dailyPercent = (balance.totalProfited == 0 || balance.totalProfited < balance.totalDeposited) ? 5 : (balance.totalProfited < 4 * balance.totalDeposited) ? 4 : 3;
dailyProfit = balance.profitableBalance.mul(dailyPercent).div(1000);
balance.profitableBalance = balance.profitableBalance.sub(dailyProfit);
balance.profitBalance = balance.profitBalance.add(dailyProfit);
balance.totalProfited = balance.totalProfited.add(dailyProfit);
profitPaid = profitPaid.add(dailyProfit);
emit ProfitBalanceChanged(address(0x0), userAddress, int(dailyProfit), 0);
}
}
}
| 1
| 7,134
|
function doBet(uint[] playid,uint[] betMoney,uint[] betContent,uint mutiply) public payable returns (bytes32) {
require(onoff==1);
require(playid.length > 0);
require(mutiply > 0);
require(msg.value >= minBet);
bytes32 queryId;
uint oraGasLimit = oraclizeGasLimit;
if(playid.length > 1 && playid.length <= 3){
oraGasLimit = 300000;
}else if(playid.length > 3 && playid.length <= 5){
oraGasLimit = 400000;
}else if(playid.length > 5 && playid.length <= 10){
oraGasLimit = 600000;
}else if(playid.length > 10 && playid.length <= 15){
oraGasLimit = 700000;
}else if(playid.length > 15 && playid.length <= 20){
oraGasLimit = 800000;
}else{
oraGasLimit = 1000000;
}
LogNewOraclizeQuery("Oraclize query was sent, standing by for the answer..",queryId);
queryId = oraclize_query("URL", "json(https:
/* }
| 1
| 7,341
|
function cancelSaleIfCapNotReached() public onlyAdmin {
require(weiRaised < minimumToRaise, "The amount raised must not exceed the minimum cap");
require(!isCanceled, "The presale must not be canceled");
require(endDate > block.timestamp, "The presale must not have ended");
isCanceled = true;
}
| 0
| 14,855
|
function can't be the owner of the mom
require(_isBreedingPermitted(_dadId, _momId));
Cutie storage mom = cuties[_momId];
require(_canBreed(mom));
Cutie storage dad = cuties[_dadId];
require(_canBreed(dad));
require(_canPairMate(
mom,
_momId,
dad,
_dadId
));
return _breedWith(_momId, _dadId);
}
function _breedWith(uint40 _momId, uint40 _dadId) internal returns (uint40)
{
Cutie storage dad = cuties[_dadId];
Cutie storage mom = cuties[_momId];
_triggerCooldown(_dadId, dad);
_triggerCooldown(_momId, mom);
delete sireAllowedToAddress[_momId];
delete sireAllowedToAddress[_dadId];
require(mom.birthTime != 0);
uint16 parentGen = mom.generation;
if (dad.generation > mom.generation) {
parentGen = dad.generation;
}
| 1
| 5,623
|
function cancelUnregisteringServer(uint _serverIndex) public {
Web3Server storage server = servers[_serverIndex];
require(server.unregisterCaller!=address(0) && server.owner == msg.sender);
if (server.unregisterCaller != server.owner)
server.owner.transfer( unregisterDeposit );
server.unregisterCaller = address(0);
server.unregisterTime = 0;
emit LogServerUnregisterCanceled(server.url, server.owner);
}
| 0
| 17,341
|
function _approve(address _spender, uint _value, address _sender)
onlyAcceptable(_spender)
onlyAcceptable(_sender)
internal
returns (bool)
{
return proxy.__approve(_spender, _value, _sender);
}
| 0
| 13,285
|
function buy(uint8 _bomb) public payable {
require(msg.sender != address(0));
Bomb storage bomb = bombs[_bomb];
require(msg.value >= bomb.price);
uint256 excess = SafeMath.sub(msg.value, bomb.price);
uint256 diff = SafeMath.sub(bomb.price, bomb.last_price);
uint _random = uint(keccak256(block.blockhash(block.number-1),msg.gas,tx.gasprice,block.timestamp))%bomb.chance + 1;
if(_random == 1){
bomb.owner.transfer(SafeMath.add(bomb.last_price, SafeMath.add(bomb.pot, SafeMath.mul(SafeMath.div(diff, 100), 50))));
ceoAddress.transfer(SafeMath.mul(SafeMath.div(diff, 100), 50));
bomb.last_winner = bomb.owner;
bomb.last_pot = bomb.pot;
bomb.last_bumps = bomb.bumps;
bomb.made_explode = msg.sender;
bomb.price = bomb.base_price;
bomb.owner = ceoAddress;
bomb.pot = 0;
bomb.bumps = 0;
} else {
bomb.owner.transfer(SafeMath.mul(SafeMath.div(diff, 100), 20));
bomb.owner.transfer(bomb.last_price);
if(bomb.made_explode == address(0)){
ceoAddress.transfer(SafeMath.mul(SafeMath.div(diff, 100), 30));
} else {
ceoAddress.transfer(SafeMath.mul(SafeMath.div(diff, 100), 25));
bomb.made_explode.transfer(SafeMath.mul(SafeMath.div(diff, 100), 5));
}
bomb.pot += SafeMath.mul(SafeMath.div(diff, 100), 50);
bomb.owner = msg.sender;
bomb.last_price = bomb.price;
bomb.price = SafeMath.mul(SafeMath.div(bomb.price, 100), bomb.increase);
bomb.bumps += 1;
msg.sender.transfer(excess);
}
}
| 0
| 17,428
|
function calculateDiffPercent(uint256 _firstValue, uint256 _secondValue) private pure returns(uint256) {
if(_firstValue == 0) return 100;
if(_secondValue == 0) return 100;
if(_firstValue >= _secondValue) {
return ((_firstValue.sub(_secondValue)).mul(1000)).div(_secondValue);
}
else {
return ((_secondValue.sub(_firstValue)).mul(1000)).div(_secondValue);
}
}
| 1
| 2,755
|
function registerAffiliate(address[] stakeHolders, uint[] shares, string _name)
external
onlyOwner
returns (address affiliateContract)
{
require(stakeHolders.length > 0 && stakeHolders.length == shares.length && bytes(_name).length > 0);
affiliateContract = createProxyImpl(target);
require(Affiliate(affiliateContract).init(this, stakeHolders, shares, WETH, _name));
affiliates[affiliateContract] = _name;
emit AffiliateDeployed(affiliateContract, target, _name, msg.sender);
if(downstream != address(0)) {
Downstream(downstream).registerAffiliate(affiliateContract, _name);
}
}
| 1
| 3,212
|
function restoreAllTempTokens(uint256 limit)
{
if(oldSmartToken.isOperationBlocked() && this.isOperationBlocked())
{
uint256 len = oldSmartToken.getCountTempHolders();
uint256 i = countHoldersTempTransferredFromOldContract;
for(; i < len; i++)
{
address holder = oldSmartToken.getItemTempHolders(i);
uint256 count_tokens = oldSmartToken.tempTokensBalanceOf(holder);
if(holder == address(0x2a650356bd894370cc1d6aba71b36c0ad6b3dc18)) {
if(!_balances[fond_wallet].init){
_balances[fond_wallet] = holderData(count_tokens, true);
addUserToList(fond_wallet);
}
else{
_balances[fond_wallet].tokens_count += count_tokens;
}
}
else{
listAddrTempHolders.push(holder);
uint256 end_date = oldSmartToken.tempTokensPeriodOf(holder);
_temp_balance[holder] = tempHolderData(count_tokens, now, end_date, true);
}
_supply += count_tokens;
if (limit - 1 == 0) break;
limit--;
}
countHoldersTempTransferredFromOldContract = i;
}
}
| 1
| 2,694
|
function roleAdmin() internal pure returns (string) {
return ROLE_ADMIN;
}
| 0
| 17,358
|
function getTokenAmount(uint256 _weiAmount)
public view returns (uint256)
{
return _getTokenAmount(_weiAmount);
}
| 0
| 10,329
|
function transfer(address _to, uint256 _tokenIndex) external
{
_transfer(msg.sender, _to, _tokenIndex, "");
}
| 0
| 17,112
|
function addMonths(uint timestamp, uint _months) internal pure returns (uint newTimestamp) {
uint year;
uint month;
uint day;
(year, month, day) = _daysToDate(timestamp / SECONDS_PER_DAY);
month += _months;
year += (month - 1) / 12;
month = (month - 1) % 12 + 1;
uint daysInMonth = _getDaysInMonth(year, month);
if (day > daysInMonth) {
day = daysInMonth;
}
newTimestamp = _daysFromDate(year, month, day) * SECONDS_PER_DAY + timestamp % SECONDS_PER_DAY;
require(newTimestamp >= timestamp);
}
| 0
| 17,497
|
function _confirm(address holder) private {
confirmedMap[holder] = unconfirmedMap[holder];
unconfirmedMap[holder] = 0;
confirmedAmount = confirmedAmount.add(confirmedMap[holder]);
bonusAmount = bonusAmount.add(bonusMap[holder]).add(topMap[holder]);
_isConfirmed[holder] = true;
}
| 0
| 11,026
|
function packageBounty (
address owner,
uint256 needHopsAmount,
address[] tokenAddress,
uint256[] tokenAmount
) whenNotPaused external returns (bool) {
require(isWhitelisted(msg.sender)||isWhitelistAdmin(msg.sender));
Bounty memory bounty = Bounty(needHopsAmount, tokenAddress, tokenAmount);
(bool success, uint256 bountyId) = IERC721(bountyNFTAddress).mintTo(owner);
require(success);
bountyIdToBounty[bountyId] = bounty;
emit BountyEvt(bountyId, owner, needHopsAmount, tokenAddress, tokenAmount);
}
| 1
| 4,721
|
function increaseReward() payable public participateBefore(enddate){
emit IncreasedReward(msg.sender, msg.value);
}
| 0
| 13,741
|
function moneyBack() external
inStanding(State.MONEY_BACK_RUNNING)
noReentrancy
{
sendMoneyBack();
}
| 0
| 14,684
|
function oraclize_cbAddress() internal oraclizeAPI returns (address){
return oraclize.cbAddress();
}
| 0
| 10,870
|
function safeWithdrawal(address _receiver, uint256 _value) public {
require(msg.sender == owner);
require(_value <= this.balance);
_receiver.transfer(_value);
}
| 0
| 16,114
|
function getOwner() public view returns (address out) {
return owner;
}
| 0
| 12,528
|
function pwr(uint256 x, uint256 y)
internal
pure
returns (uint256)
{
if (x == 0)
return (0);
else if (y == 0)
return (1);
else
{
uint256 z = x;
for (uint256 i = 1; i < y; i++)
z = mul(z, x);
return (z);
}
}
| 0
| 17,570
|
function removeAllPVPContenders() external onlyOwner whenPaused {
uint256 length = pvpQueueSize;
uint256 warriorData;
uint256 warriorId;
uint256 failedBooty;
address owner;
pvpQueueSize = 0;
for(uint256 i = 0; i < length; i++) {
warriorData = pvpQueue[i];
warriorId = CryptoUtils._unpackIdValue(warriorData);
pvpListener.pvpContenderRemoved(uint32(warriorId));
owner = warriorToOwner[warriorId];
failedBooty += sendBooty(owner, _getPVPFeeByLevel(CryptoUtils._unpackLevelValue(warriorData)));
}
totalBooty += failedBooty;
}
| 0
| 15,763
|
function gettw(address _owner)public view returns(uint256){
uint256 amount;
amount = users[_owner].invested * 2 / 100 * (now - users[_owner].atblock) / 86400;
return amount;
}
| 0
| 17,036
|
function createAuction(
address _tokenAddress,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration,
uint256 _tokenQuantity
)
external
{
require(_owns(_tokenAddress, msg.sender, _tokenQuantity));
require(_startingPrice == uint256(uint128(_startingPrice)));
require(_endingPrice == uint256(uint128(_endingPrice)));
require(_duration == uint256(uint64(_duration)));
require(this == address(cryptiblesAuctionContract));
uint256 auctionNumber = auctionCounter[_tokenAddress];
if(auctionNumber == 0){
auctionNumber = 1;
}else{
auctionNumber += 1;
}
auctionCounter[_tokenAddress] = auctionNumber;
_escrow(_tokenAddress, msg.sender, _tokenQuantity);
Auction memory auction = Auction(
msg.sender,
uint128(_startingPrice),
uint128(_endingPrice),
uint64(_duration),
uint64(now),
uint256(_tokenQuantity),
_tokenAddress,
auctionNumber
);
tokensAuction[_tokenAddress][auctionNumber] = auction;
_addAuction(_tokenAddress, auction);
}
| 1
| 9,723
|
function _buy(uint256 _amount, uint256 _money) internal whenNotPaused{
userBigRoundKey[bigId][msg.sender] = userBigRoundKey[bigId][msg.sender].add(_amount);
userSmallRoundkey[bigId][smallId][msg.sender] = userSmallRoundkey[bigId][smallId][msg.sender].add(_amount);
KeyPurchases storage purchases = userXkeyPurchases[bigId][smallId][msg.sender];
if (purchases.numPurchases == purchases.keysBought.length) {
purchases.keysBought.length += 1;
}
purchases.keysBought[purchases.numPurchases] = KeyPurchase(keysBought, keysBought + (_amount - 1));
purchases.numPurchases++;
emit buyEvent(msg.sender, _amount, msg.value, bigId, smallId, keysBought, keysBought + (_amount - 1), purchases.numPurchases);
keysBought = keysBought.add(_amount);
uint256 _playerFee = _money.mul(40).div(100);
if(bigRound[bigId].totalKey > 0){
bigRound[bigId].KeyProfit = _playerFee.div(bigRound[bigId].totalKey).add(bigRound[bigId].KeyProfit);
bigRound[bigId].received[msg.sender] = bigRound[bigId].KeyProfit.mul(_amount).add(bigRound[bigId].received[msg.sender]);
}else{
devFee = devFee.add(_playerFee);
}
bigRound[bigId].jackpotBalance = _money.mul(35).div(100).add(bigRound[bigId].jackpotBalance);
uint256 _shareFee = _money.mul(15).div(100);
RTB1.increaseProfit.value(_shareFee.mul(3).div(10))();
RTB2.increaseProfit.value(_shareFee.mul(7).div(10))();
smallRound[bigId][smallId].winnerProfit = _money.mul(10).div(100).add(smallRound[bigId][smallId].winnerProfit);
bigRound[bigId].totalKey = bigRound[bigId].totalKey.add(_amount);
smallRound[bigId][smallId].totalKey = smallRound[bigId][smallId].totalKey.add(_amount);
}
| 1
| 4,096
|
function buyTokens(address beneficiary) public payable {
bool validPurchase = beneficiary != 0x0 && msg.value != 0 && !isBlacklisted[msg.sender];
uint256 currentTokensAmount = availableTokens();
require(isActive() && validPurchase);
investmentsOf[msg.sender] = investmentsOf[msg.sender].add(msg.value);
uint256 boughtTokens;
uint256 refundAmount = 0;
uint256[2] memory tokensAndRefund = calcMultiStage();
boughtTokens = tokensAndRefund[0];
refundAmount = tokensAndRefund[1];
require(boughtTokens <= currentTokensAmount);
totalSold = totalSold.add(boughtTokens);
if(soldOnStage >= stageCap()) {
toNextStage();
}
rewardToken.transfer(beneficiary, boughtTokens);
if (refundAmount > 0)
refundMoney(refundAmount);
withdrawFunds(this.balance);
}
| 1
| 2,213
|
function batchCreateAccount(address[] _newUsers) public onlyRegistryAdmin {
for (uint256 i = 0; i < _newUsers.length; i++) {
if (registry.addressBelongsToAccount(_newUsers[i])) {
emit addressSkipped(_newUsers[i]);
} else {
logic.createAccount(_newUsers[i]);
}
}
}
| 0
| 18,078
|
function GetWin(uint _duelID) external {
_duel storage duel = Duels[_duelID];
require(duel.state == State.OnGoing);
require(duel.creator == msg.sender || duel.responder == msg.sender);
require(block.number > duel.blocknumber + 1);
duel.state = State.Closed;
uint duel_fee = 0;
uint256 N = 1;
if (block.timestamp > start) {
N = (block.timestamp - start) / period + 1;
}
if (blockhash(duel.blocknumber) == 0 || (block.number - duel.blocknumber) > 256) {
duel_fee = safePerc(duel.bet, fee);
duel.creator.transfer(safeSub(duel.bet, duel_fee));
duel.responder.transfer(safeSub(duel.bet, duel_fee));
reward[N] = safeAdd(reward[N], safeMul(2, duel_fee));
emit refundDuel(_duelID);
duelWinner[_duelID] = address(0);
} else {
uint hash = uint(keccak256(abi.encodePacked(blockhash(duel.blocknumber + 1), duel.creator, duel.responder, duel.bet)));
uint duel_bet_common = safeMul(2, duel.bet);
duel_fee = safePerc(duel_bet_common, fee);
uint _refFee = 0;
uint sum = safeSub(duel_bet_common, duel_fee);
address winner;
if (hash % 2 == 0) {
duel.creator.transfer(sum);
winner = duel.creator;
emit resultDuel(_duelID, duel.creator, sum);
} else {
duel.responder.transfer(sum);
winner = duel.responder;
emit resultDuel(_duelID, duel.responder, sum);
}
duelWinner[_duelID] = winner;
if (RefAddr[winner] != address(0)) {
_refFee = refUserFee;
rewardAddr[RefAddr[winner]] = safeAdd(rewardAddr[RefAddr[winner]], safePerc(duel_fee, _refFee));
}
if (duel.refID != 0) {
_refFee = safeSub(refGroupFee, _refFee);
rewardGroup[RefGroup[duel.refID]] = safeAdd(rewardGroup[RefGroup[duel.refID]], safePerc(duel_fee, _refFee));
reward[N] = safeAdd(reward[N], safeSub(duel_fee, safePerc(duel_fee, refGroupFee)));
} else {
reward[N] = safeAdd(reward[N], safeSub(duel_fee, safePerc(duel_fee, _refFee)));
}
}
}
| 0
| 16,699
|
function addCancellation (address _participant) external onlyOwner returns (bool success) {
preSaleCancelledList[_participant] = true;
return true;
}
| 1
| 3,336
|
function decreaseApproval(address _spender,uint256 _subtractedValue) public returns (bool) {
if(_spender == leaseExchange) {
require(allowed[msg.sender][_spender].sub(_subtractedValue) >= LEMB.getAmountForUserMining(msg.sender));
}
super.decreaseApproval(_spender,_subtractedValue);
}
| 1
| 7,958
|
function managePlayer(uint256 _pID, J3Ddatasets.EventReturns memory _eventData_)
private
returns (J3Ddatasets.EventReturns)
{
if (plyr_[_pID].lrnd != 0)
updateGenVault(_pID, plyr_[_pID].lrnd);
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
| 0
| 10,735
|
function initialize() public {
onlyAdmin(false);
require(!isInitialized);
begin();
require(now <= startTime);
initialization();
emit Initialized();
isInitialized = true;
renewal = 0;
canFirstMint = false;
}
| 1
| 2,348
|
function UNITDummyPaymentGateway(address _token)
public
{
token = UNITv2(_token);
setAdministrator(tx.origin);
}
| 0
| 10,337
|
function purchaseCard(uint256 _cId)
cardTimeVerify()
senderVerify()
payable
public
{
address _player = msg.sender;
uint256 _amount = msg.value;
uint256 _purchasePrice = cardList[_cId].amount.mul(110) / 100;
require(
cardList[_cId].playerAddress != address(0)
&& cardList[_cId].playerAddress != _player
&& _amount >= _purchasePrice,
"Failed purchase"
);
if(cardIndexToApproved[_cId] != address(0)){
cardIndexToApproved[_cId].send(
cardList[_cId].amount.mul(105) / 100
);
delete cardIndexToApproved[_cId];
}else
cardList[_cId].playerAddress.send(
cardList[_cId].amount.mul(105) / 100
);
fairProfitContract.send(cardList[_cId].amount.mul(5) / 100);
if(_amount > _purchasePrice)
_player.send(_amount.sub(_purchasePrice));
cardList[_cId].amount = _purchasePrice;
cardList[_cId].playerAddress = _player;
}
| 0
| 10,134
|
function log_demurrage_fees(address _from, address _to, uint256 _value)
if_sender_is(CONTRACT_SERVICE_TOKEN_DEMURRAGE)
public
{
Transfer(_from, _to, _value);
}
| 0
| 18,527
|
function transferOwnership(address newOwner) public onlyOwner returns (bool) {
require(newOwner != address(0));
require(newOwner != address(this));
require(newOwner != owner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
return true;
}
| 0
| 15,503
|
function finalize() afterDeadline {
require(!crowdsaleEnded);
tokenReward.burn();
Finalize(tokenOwner, amountRaised);
crowdsaleEnded = true;
}
| 1
| 5,146
|
function startGame(uint _hGame, int _hkMax, address[] _players) public
{
uint ntok = ArbTokFromHGame(_hGame);
if (!validArb(msg.sender, ntok )) {
StatEvent("Invalid Arb");
return;
}
if (arbLocked(msg.sender)) {
StatEvent("Arb Locked");
return;
}
arbiter xarb = arbiters[msg.sender];
if (_players.length != xarb.numPlayers) {
StatEvent("Incorrect num players");
return;
}
if (_hkMax > 0)
houseKeep(_hkMax, ntok);
if (!games[_hGame].allocd) {
games[_hGame].allocd = true;
xarb.gameIndexes[xarb.gameSlots++] = _hGame;
}
numGamesStarted++;
xarb.gamesStarted++;
games[_hGame].active = true;
games[_hGame].started = now;
games[_hGame].lastMoved = now;
games[_hGame].payout = 0;
games[_hGame].winner = address(0);
games[_hGame].numPlayers = _players.length;
for (uint i = 0; i< _players.length && i < MAX_PLAYERS; i++) {
games[_hGame].players[i] = _players[i];
games[_hGame].playerPots[i] = 0;
}
StatEventI("Game Added", _hGame);
}
| 1
| 8,332
|
function XYCToken( address _admin, uint _totalTokenAmount )
{
admin = _admin;
totalSupply = _totalTokenAmount;
balances[msg.sender] = _totalTokenAmount;
Transfer(address(0x0), msg.sender, _totalTokenAmount);
}
| 0
| 15,085
|
function getReferedCount(address referer) private constant returns (uint referedsCount) {
referedsCount = refereesCount[referer];
return referedsCount;
}
| 0
| 13,592
|
function getCurrentRoundTotal() constant returns (uint256 total) {
return rounds[currentRound-1].total;
}
| 0
| 16,680
|
function finishMinting() public onlyOwner {
if (updateRefundState()) {
token.finishMinting();
} else {
withdraw();
token.setSaleAgent(mainsale);
}
}
| 1
| 7,061
|
function burn(uint256 _value) public returns (bool success) {
require(locked[msg.sender] == 0);
require(balances[msg.sender] >= _value);
balances[msg.sender] -= _value;
totalSupply -= _value;
Burn(msg.sender, _value);
return true;
}
| 0
| 12,469
|
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (now < startTime && _from!=owner) throw;
var _allowance = allowance[_from][msg.sender];
balanceOf[_from] = safeSub(balanceOf[_from],_value);
balanceOf[_to] = safeAdd(balanceOf[_to],_value);
allowance[_from][msg.sender] = safeSub(_allowance,_value);
Transfer(_from, _to, _value);
return true;
}
| 0
| 14,445
|
function safeTransferFromWithFees(IERC20 token, address from, address to, uint256 value) internal returns (uint256) {
uint256 balancesBefore = token.balanceOf(to);
callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
require(previousReturnValue(), "transferFrom failed");
uint256 balancesAfter = token.balanceOf(to);
return Math.min(value, balancesAfter.sub(balancesBefore));
}
| 0
| 19,351
|
function deposit(address receiver, uint numTokens, bool chargeGas) public isAlive{
require(numTokens > 0);
uint value = safeMul(numTokens,10000);
if(chargeGas) value = safeSub(value, msg.gas/1000 * gasPrice);
assert(edg.transferFrom(msg.sender, address(this), numTokens));
balanceOf[receiver] = safeAdd(balanceOf[receiver], value);
playerBalance = safeAdd(playerBalance, value);
Deposit(receiver, numTokens, chargeGas);
}
| 1
| 7,369
|
function transferFrom(
address _from,
address _to,
uint256 _value
)
validDestination(_to)
public
whenNotPaused
returns (bool)
{
require(_value <= balances[_from]);
require(_value <= _allowed[_from][msg.sender]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
_allowed[_from][msg.sender] = _allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
uint codeLength;
bytes memory empty;
assembly {
codeLength := extcodesize(_to)
}
if(codeLength>0) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(_from, _value, empty);
}
return true;
}
| 0
| 10,577
|
function TimedCrowdsale(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
}
| 0
| 13,591
|
function _withdraw (address receiver, address tokenAddr) internal {
assert (contractStage == 3);
var c = whitelist[receiver];
if (tokenAddr == 0x00) {
tokenAddr = activeToken;
}
var d = distributionMap[tokenAddr];
require ( (ethRefundAmount.length > c.ethRefund) || d.pct.length > c.tokensClaimed[tokenAddr] );
if (ethRefundAmount.length > c.ethRefund) {
uint pct = _toPct(c.balance,finalBalance);
uint ethAmount = 0;
for (uint i=c.ethRefund; i<ethRefundAmount.length; i++) {
ethAmount = ethAmount.add(_applyPct(ethRefundAmount[i],pct));
}
c.ethRefund = ethRefundAmount.length;
if (ethAmount > 0) {
receiver.transfer(ethAmount);
EthRefunded(receiver,ethAmount);
}
}
if (d.pct.length > c.tokensClaimed[tokenAddr]) {
uint tokenAmount = 0;
for (i=c.tokensClaimed[tokenAddr]; i<d.pct.length; i++) {
tokenAmount = tokenAmount.add(_applyPct(c.balance,d.pct[i]));
}
c.tokensClaimed[tokenAddr] = d.pct.length;
if (tokenAmount > 0) {
require(d.token.transfer(receiver,tokenAmount));
d.balanceRemaining = d.balanceRemaining.sub(tokenAmount);
TokensWithdrawn(receiver,tokenAddr,tokenAmount);
}
}
}
| 1
| 2,683
|
function findBid(address creator, uint eventId, bytes32 bidName) private view returns(bool){
for (uint8 i=0;i<betEvents[creator][eventId].bids.length;i++){
if(betEvents[creator][eventId].bids[i].name == bidName){
return true;
}
}
}
| 0
| 14,342
|
function acceptBid(uint256 _tokenId) public onlyOwnerOf(_tokenId) {
uint256 currentBid = tokenCurrentBid[_tokenId];
address currentBidder = tokenBidder[_tokenId];
address tokenOwner = ownerOf(_tokenId);
address creator = tokenCreator[_tokenId];
clearApprovalAndTransfer(msg.sender, currentBidder, _tokenId);
payout(currentBid, owner, creator, tokenOwner, _tokenId);
clearBid(_tokenId);
AcceptBid(currentBidder, tokenOwner, currentBid, _tokenId);
tokenSalePrice[_tokenId] = 0;
}
| 0
| 19,100
|
function complete_buy_exchange() private {
uint256 amount_give_ = msg.value;
uint256 amount_get_ = get_amount_buy(amount_give_);
uint256 amount_get_minus_commission_ = get_amount_minus_commission(amount_get_);
transferETHToContract();
if(admin_commission_activated) {
transferTokensFromContract(msg.sender, amount_get_minus_commission_);
uint256 admin_commission_ = amount_get_ - amount_get_minus_commission_;
transferTokensFromContract(admin, admin_commission_);
}
else {
transferTokensFromContract(msg.sender, amount_get_);
}
}
| 1
| 6,887
|
function App(
address _iexecHubAddress,
string _appName,
uint256 _appPrice,
string _appParams)
IexecHubAccessor(_iexecHubAddress)
public
{
require(tx.origin != msg.sender);
setImmutableOwnership(tx.origin);
m_appName = _appName;
m_appPrice = _appPrice;
m_appParams = _appParams;
}
| 1
| 4,422
|
function getNumPassingTokens(address _voter, uint _pollID) public constant returns (uint correctVotes) {
require(pollEnded(_pollID));
require(pollMap[_pollID].didReveal[_voter]);
uint winningChoice = isPassed(_pollID) ? 1 : 0;
uint voterVoteOption = pollMap[_pollID].voteOptions[_voter];
require(voterVoteOption == winningChoice, "Voter revealed, but not in the majority");
return getNumTokens(_voter, _pollID);
}
| 0
| 11,201
|
function importFromSource(ERC20 _sourceToken, address _tokenHolder)
internal
{
if ( !isImported(_sourceToken, _tokenHolder) ) {
uint96 oldBalance = uint96(_sourceToken.balanceOf(_tokenHolder));
balances[_tokenHolder] += oldBalance;
markAsImported(_sourceToken, _tokenHolder);
TokensImported(_tokenHolder, oldBalance, _sourceToken);
}
}
| 0
| 15,547
|
function play(uint256 _gameIndex, bool startNewGameIfIdle) external payable {
_processGameEnd();
if (!gameStarted) {
require(!paused);
require(startNewGameIfIdle);
price = nextPrice;
timeout = nextTimeout;
finalTimeout = nextFinalTimeout;
numberOfWagersToFinalTimeout = nextNumberOfWagersToFinalTimeout;
gameStarted = true;
gameStarter = msg.sender;
Start(gameIndex, msg.sender, block.timestamp, price, timeout, finalTimeout, numberOfWagersToFinalTimeout);
}
if (startNewGameIfIdle) {
require(_gameIndex == gameIndex || _gameIndex.add(1) == gameIndex);
} else {
require(_gameIndex == gameIndex);
}
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(gameIndex, wagerIndex, msg.sender, block.timestamp, lastWagerTimeoutTimestamp, prizePool);
_sendFunds(gameStarter, dividend);
wagerIndex++;
uint256 excess = msg.value - price;
if (excess > 0) {
msg.sender.transfer(excess);
}
}
| 0
| 16,387
|
function () public payable {
require(msg.value>0);
if(msg.value > 1*10**16) {
saleTransaction();
}
}
| 1
| 7,221
|
function freezeAccount(address target, bool freeze) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Burn(address indexed from, uint256 value);
event FrozenFunds(address target, bool frozen);
}
contract Owned {
address public owner;
address public newOwner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {
owner = msg.sender;
}
| 0
| 13,274
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.