func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function() payable crowdsaleState limitNotExceeded crowdsaleNotFinished {
uint valueWEI = msg.value;
uint valueUSDWEI = valueWEI * etherPriceUSDWEI / 1 ether;
uint tokenPriceUSDWEI = getTokenPriceUSDWEI();
if (collectedUSDWEI + valueUSDWEI > totalLimitUSDWEI) {
valueUSDWEI = totalLimitUSDWEI - collectedUSDWEI;
valueWEI = valueUSDWEI * 1 ether / etherPriceUSDWEI;
uint weiToReturn = msg.value - valueWEI;
bool isSent = msg.sender.call.gas(3000000).value(weiToReturn)();
require(isSent);
collectedUSDWEI = totalLimitUSDWEI;
} else {
collectedUSDWEI += valueUSDWEI;
}
emitTokensFor(msg.sender, tokenPriceUSDWEI, valueUSDWEI, valueWEI);
}
| 1 | 5,250 |
function QRTok () public {
owner = msg.sender;
distr(owner, totalDistributed);
}
| 0 | 15,508 |
function SNDTokenSale(
uint start,
uint end,
uint costOfEachToken,
SNDToken addressOfTokenUsedAsReward
) {
beneficiary = msg.sender;
startline = start;
deadline = end;
price = costOfEachToken;
tokenReward = SNDToken(addressOfTokenUsedAsReward);
totalTokensSold = 0;
}
| 0 | 19,294 |
function activate() onlyOwner public returns (bool) {
for (uint i = 0; i < strategies.length; i++) {
SaleStrategy strategy = strategies[i];
if (strategy.activated()) {
activatedStrategies.push(strategy);
}
}
return super.activate();
}
| 1 | 2,380 |
function transferableSynthetix(address account)
public
view
rateNotStale("SNX")
returns (uint)
{
uint balance = tokenState.balanceOf(account);
uint lockedSynthetixValue = debtBalanceOf(account, "SNX").divideDecimalRound(synthetixState.issuanceRatio());
if (lockedSynthetixValue >= balance) {
return 0;
} else {
return balance.sub(lockedSynthetixValue);
}
}
| 1 | 982 |
function LevelUp(uint256 _tokenId,uint32 _level) external payable {
require(msg.sender == captainTokenIdToOwner[_tokenId]);
Captain storage captain = captains[_tokenId];
uint32 captainId = captain.captainId;
uint32 level = captain.level;
uint256 cur_exp = SafeMath.mul(SafeMath.mul(level,SafeMath.sub(level,1)),25);
uint256 req_exp = SafeMath.mul(SafeMath.mul(_level,SafeMath.sub(_level,1)),25);
require(captain.exp>=SafeMath.sub(req_exp,cur_exp));
uint256 exp = SafeMath.sub(captain.exp,SafeMath.sub(req_exp,cur_exp));
if (SafeMath.add32(level,_level)>=99) {
captains[_tokenId].level = 99;
} else {
captains[_tokenId].level = _level;
}
(captains[_tokenId].atk,captains[_tokenId].defense,,) = config.getLevelConfig(captainId,captains[_tokenId].level);
captains[_tokenId].exp = exp;
LevelUP(msg.sender,level,captain.level);
}
| 1 | 7,717 |
function query(bytes32 label, string calldata subdomain) external view returns (string memory domain, uint price, uint rent, uint referralFeePPM) {
bytes32 node = keccak256(abi.encodePacked(TLD_NODE, label));
bytes32 subnode = keccak256(abi.encodePacked(node, keccak256(bytes(subdomain))));
if (ens.owner(subnode) != address(0x0)) {
return ('', 0, 0, 0);
}
Domain storage data = domains[label];
return (data.name, data.price, 0, data.referralFeePPM);
}
| 0 | 14,246 |
function getPolicy(uint8 _policy) public
view
returns (uint256, uint256[], uint8[])
{
require(_policy < MAX_POLICY);
return (
policies[_policy].kickOff,
policies[_policy].periods,
policies[_policy].percentages
);
}
| 0 | 18,228 |
function updateSellPossible(bool _isRunning) onlyOwner returns (bool success){
if (_isRunning){
require(sellWolkEstimate(10**decimals, exchangeFormula) > 0);
require(purchaseWolkEstimate(10**decimals, exchangeFormula) > 0);
}
isSellPossible = _isRunning;
return true;
}
| 1 | 4,411 |
function getTranscoderPoolSize() public view returns (uint256) {
return transcoderPool.getSize();
}
| 0 | 11,822 |
function serverEndGameConflict(
uint32 _roundId,
uint8 _gameType,
uint _num,
uint _value,
int _balance,
bytes32 _serverHash,
bytes32 _userHash,
uint _gameId,
address _contractAddress,
bytes _userSig,
address _userAddress,
bytes32 _serverSeed,
bytes32 _userSeed
)
public
onlyServer
{
verifySig(
_roundId,
_gameType,
_num,
_value,
_balance,
_serverHash,
_userHash,
_gameId,
_contractAddress,
_userSig,
_userAddress
);
serverEndGameConflictImpl(
_roundId,
_gameType,
_num,
_value,
_balance,
_serverHash,
_userHash,
_serverSeed,
_userSeed,
_gameId,
_userAddress
);
}
| 0 | 11,076 |
function submitPool (uint amountInWei) public onlyOwner noReentrancy {
require (contractStage < 3);
require (receiverAddress != 0x00);
require (block.number >= addressChangeBlock.add(6000));
require (contributionMin <= amountInWei && amountInWei <= this.balance);
finalBalance = this.balance;
require (receiverAddress.call.value(amountInWei).gas(msg.gas.sub(5000))());
if (this.balance > 0) ethRefundAmount.push(this.balance);
contractStage = 3;
PoolSubmitted(receiverAddress, amountInWei);
}
| 1 | 4,896 |
function createAuction(uint40 _cutieId, uint128 _startPrice, uint128 _endPrice, uint40 _duration, address _seller)
public whenNotPaused payable
{
require(_isOwner(msg.sender, _cutieId));
_escrow(msg.sender, _cutieId);
bool allowTokens = _duration < 0x8000000000;
_duration = _duration % 0x8000000000;
Auction memory auction = Auction(
_startPrice,
_endPrice,
_seller,
_duration,
uint40(now),
uint128(msg.value),
allowTokens
);
_addAuction(_cutieId, auction);
}
| 1 | 7,885 |
function sendTokens(address _user) public onlyOwner returns (bool) {
require(_user != address(0));
require(_user != address(this));
require(purchaseLog[_user].kycApproved);
require(purchaseLog[_user].vztValue > 0);
require(!purchaseLog[_user].tokensDistributed);
require(!refundLog[_user]);
purchaseLog[_user].tokensDistributed = true;
purchaseLog[_user].lastDistributionTime = now;
totalDistributed++;
token.sendToken(_user, purchaseLog[_user].vztValue);
TokenDistributed(_user, purchaseLog[_user].vztValue);
return true;
}
| 0 | 14,612 |
function award(bytes32 secretKey_D) public {
require(Drawer == msg.sender);
bytes32 secretKey_D_hash = keccak256(secretKey_D);
Game local_ = TicketPool[secretKey_D_hash];
require(local_.Time != 0 && !local_.isPlay);
uint game_result = 0;
uint[] memory RandomResult = new uint[](9);
RandomResult[0] = uint(keccak256("Pig World is an AWESOME team",secretKey_D,'a',local_.SecretKey_P)) % 1000 + 1;
RandomResult[1] = uint(keccak256(local_.SecretKey_P,"Every Game in our world is provably fair",secretKey_D,'b')) % 1000 + 1;
RandomResult[2] = uint(keccak256('c',secretKey_D,"OMG it is a revolution dapp",local_.SecretKey_P)) % 1000 + 1;
RandomResult[3] = uint(keccak256(secretKey_D,"hahahaha",local_.SecretKey_P,'d',"thanks for our team member and all player support.")) % 1000 + 1;
RandomResult[4] = uint(keccak256("CC is our CEO",secretKey_D,"he can eat Betel nut",local_.SecretKey_P,'e')) % 1000 + 1;
RandomResult[5] = uint(keccak256(20180612,"justin is our researcher",secretKey_D,"and he love little girl(at least 18, so it is ok)",local_.SecretKey_P,'f')) % 1000 + 1;
RandomResult[6] = uint(keccak256("jeremy is our marketing",secretKey_D,'g',local_.SecretKey_P,"he is very humble and serious")) % 1000 + 1;
RandomResult[7] = uint(keccak256('h',secretKey_D,"We are a geek team",local_.SecretKey_P,"we love blockchain")) % 1000 + 1;
RandomResult[8] = uint(keccak256(secretKey_D,"hope you win a big prize",local_.SecretKey_P,"love you all!!!",'i')) % 1000 + 1;
for (uint n = 0; n < 9; n++) {
if(RandomResult[n]< 81){
RandomResult[n] = 0;
} else if(RandomResult[n]< 168){
RandomResult[n] = 1;
} else if(RandomResult[n]< 266){
RandomResult[n] = 2;
} else if(RandomResult[n]< 381){
RandomResult[n] = 3;
} else if(RandomResult[n]< 535){
RandomResult[n] = 4;
} else if(RandomResult[n]< 749){
RandomResult[n] = 5;
} else if(RandomResult[n]< 1001){
RandomResult[n] = 6;
}
}
for(uint nn = 0; nn < 6; nn++){
uint count = 0;
for(uint p = 0; p < 9; p++){
if(RandomResult[p] == nn)
count ++;
}
if(count >= 3 && nn == 0)
game_result = game_result.add(TicketPool[secretKey_D_hash].value.div(20000000000000000).mul(0.1 ether));
if(count >= 3 && nn == 1)
game_result = game_result.add(TicketPool[secretKey_D_hash].value.div(20000000000000000).mul(0.08 ether));
if(count >= 3 && nn == 2)
game_result = game_result.add(TicketPool[secretKey_D_hash].value.div(20000000000000000).mul(0.06 ether));
if(count >= 3 && nn == 3)
game_result = game_result.add(TicketPool[secretKey_D_hash].value.div(20000000000000000).mul(0.04 ether));
if(count >= 3 && nn == 4)
game_result = game_result.add(TicketPool[secretKey_D_hash].value.div(20000000000000000).mul(0.02 ether));
if(count >= 3 && nn == 5)
game_result = game_result.add(TicketPool[secretKey_D_hash].value.div(20000000000000000).mul(0.01 ether));
}
if(game_result != 0){
TicketPool[secretKey_D_hash].Result = game_result;
if (address(this).balance >= game_result && TicketPool[secretKey_D_hash].Buyer.send(game_result)) {
TicketPool[secretKey_D_hash].isPay = true;
Pay(secretKey_D_hash,TicketPool[secretKey_D_hash].Buyer, game_result);
} else {
Owe(secretKey_D_hash, TicketPool[secretKey_D_hash].Buyer, game_result);
TicketPool[secretKey_D_hash].isPay = false;
}
} else {
TicketPool[secretKey_D_hash].isPay = true;
}
Result(secretKey_D_hash, secretKey_D, TicketPool[secretKey_D_hash].Buyer, RandomResult, game_result, block.timestamp);
TicketPool[secretKey_D_hash].isPlay = true;
}
| 0 | 13,202 |
function updateLandData(
int x,
int y,
string data
)
external
onlyUpdateAuthorized(_encodeTokenId(x, y))
{
return _updateLandData(x, y, data);
}
| 1 | 6,662 |
function renewDec(uint initSum, uint newSum) internal returns(bool success){
if(round < 9){
uint tempInitSum = initSum;
uint tempNewSum = newSum;
uint cnt = 1;
while( (tempNewSum > 0 || tempInitSum > 0) && cnt <= decimals ){
uint lastInitSum = tempInitSum%10;
tempInitSum = tempInitSum/10;
uint lastNewSum = tempNewSum%10;
tempNewSum = tempNewSum/10;
if(cnt >= round){
if(lastNewSum >= lastInitSum){
dec[decimals-cnt] = dec[decimals-cnt].add(lastNewSum - lastInitSum);
}else{
dec[decimals-cnt] = dec[decimals-cnt].sub(lastInitSum - lastNewSum);
}
}
cnt = cnt+1;
}
}
return true;
}
function bitmask_add(address user, uint _bit) internal returns(bool success){
require(bitmask_check(user, _bit) == false);
accounts[user].bitmask = accounts[user].bitmask.add(_bit);
return true;
}
function bitmask_rm(address user, uint _bit) internal returns(bool success){
require(bitmask_check(user, _bit) == true);
accounts[user].bitmask = accounts[user].bitmask.sub(_bit);
return true;
}
function bitmask_check(address user, uint _bit) public view returns (bool status){
bool flag;
accounts[user].bitmask & _bit == 0 ? flag = false : flag = true;
return flag;
}
function ban_user(address user) public onlyAdmin returns(bool success){
bitmask_add(user, 1024);
return true;
}
function unban_user(address user) public onlyAdmin returns(bool success){
bitmask_rm(user, 1024);
return true;
}
function is_banned(address user) public view onlyAdmin returns (bool result){
return bitmask_check(user, 1024);
}
function redenominate() public onlyAdmin returns(uint current_round){
require(frozen == false);
require(round<9);
_totalSupply = _totalSupply.sub( team_fund%mul[round] ).sub( redenom_dao_fund%mul[round] ).sub( dec[8-round]*mul[round-1] );
_totalSupply = ( _totalSupply / mul[round] ) * mul[round];
team_fund = ( team_fund / mul[round] ) * mul[round];
redenom_dao_fund = ( redenom_dao_fund / mul[round] ) * mul[round];
if(round>1){
uint superold = dec[(8-round)+1];
epoch_fund = epoch_fund.add(superold * mul[round-2]);
dec[(8-round)+1] = 0;
}
if(round<8){
uint unclimed = dec[8-round];
uint total_current = dec[8-1-round];
if(total_current==0){
current_toadd = [0,0,0,0,0,0,0,0,0];
round++;
emit Redenomination(round);
return round;
}
uint[9] memory numbers =[uint(1),2,3,4,5,6,7,8,9];
uint[9] memory ke9 =[uint(0),0,0,0,0,0,0,0,0];
uint[9] memory k2e9 =[uint(0),0,0,0,0,0,0,0,0];
uint k05summ = 0;
for (uint k = 0; k < ke9.length; k++) {
ke9[k] = numbers[k]*1e9/total_current;
if(k<5) k05summ += ke9[k];
}
for (uint k2 = 5; k2 < k2e9.length; k2++) {
k2e9[k2] = uint(ke9[k2])+uint(k05summ)*uint(weight[k2])/uint(100);
}
for (uint n = 5; n < current_toadd.length; n++) {
current_toadd[n] = k2e9[n]*unclimed/10/1e9;
}
}else{
if(round==8){
epoch_fund = epoch_fund.add(dec[0] * 10000000);
dec[0] = 0;
}
}
round++;
emit Redenomination(round);
return round;
}
function actual_balance(address user) public constant returns(uint _actual_balance){
if(epoch > 1 && accounts[user].lastEpoch < epoch){
return (accounts[user].balance/100000000)*100000000;
}
return (accounts[user].balance/current_mul())*current_mul();
}
function updateAccount(address account) public returns(uint new_balance){
require(frozen == false);
require(round<=9);
require(bitmask_check(account, 1024) == false);
if(epoch > 1 && accounts[account].lastEpoch < epoch){
uint entire = accounts[account].balance/100000000;
if((accounts[account].balance - entire*100000000) >0){
emit Transfer(account, address(0), (accounts[account].balance - entire*100000000));
}
accounts[account].balance = entire*100000000;
accounts[account].lastEpoch = epoch;
accounts[account].lastRound = round;
return accounts[account].balance;
}
if(round > accounts[account].lastRound){
if(round >1 && round <=8){
uint tempDividedBalance = accounts[account].balance/current_mul();
uint newFixedBalance = tempDividedBalance*current_mul();
uint lastActiveDigit = tempDividedBalance%10;
uint diff = accounts[account].balance - newFixedBalance;
if(diff > 0){
accounts[account].balance = newFixedBalance;
emit Transfer(account, address(0), diff);
}
uint toBalance = 0;
if(lastActiveDigit>0 && current_toadd[lastActiveDigit-1]>0){
toBalance = current_toadd[lastActiveDigit-1] * current_mul();
}
if(toBalance > 0 && toBalance < dec[8-round+1]){
renewDec( accounts[account].balance, accounts[account].balance.add(toBalance) );
emit Transfer(address(0), account, toBalance);
accounts[account].balance = accounts[account].balance.add(toBalance);
dec[8-round+1] = dec[8-round+1].sub(toBalance);
_totalSupply = _totalSupply.add(toBalance);
}
accounts[account].lastRound = round;
if(accounts[account].lastEpoch != epoch){
accounts[account].lastEpoch = epoch;
}
return accounts[account].balance;
}else{
if( round == 9){
uint newBalance = fix_amount(accounts[account].balance);
uint _diff = accounts[account].balance.sub(newBalance);
if(_diff > 0){
renewDec( accounts[account].balance, newBalance );
accounts[account].balance = newBalance;
emit Transfer(account, address(0), _diff);
}
accounts[account].lastRound = round;
if(accounts[account].lastEpoch != epoch){
accounts[account].lastEpoch = epoch;
}
return accounts[account].balance;
}
}
}
}
function current_mul() internal view returns(uint _current_mul){
return mul[round-1];
}
function fix_amount(uint amount) public view returns(uint fixed_amount){
return ( amount / current_mul() ) * current_mul();
}
function get_rest(uint amount) internal view returns(uint fixed_amount){
return amount % current_mul();
}
function totalSupply() public view returns (uint) {
return _totalSupply;
}
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return accounts[tokenOwner].balance;
}
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function transfer(address to, uint tokens) public returns (bool success) {
require(frozen == false);
require(to != address(0));
require(bitmask_check(to, 1024) == false);
tokens = fix_amount(tokens);
require(tokens>0);
updateAccount(to);
updateAccount(msg.sender);
uint fromOldBal = accounts[msg.sender].balance;
uint toOldBal = accounts[to].balance;
accounts[msg.sender].balance = accounts[msg.sender].balance.sub(tokens);
accounts[to].balance = accounts[to].balance.add(tokens);
require(renewDec(fromOldBal, accounts[msg.sender].balance));
require(renewDec(toOldBal, accounts[to].balance));
emit Transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public returns (bool success) {
require(frozen == false);
require(bitmask_check(msg.sender, 1024) == false);
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
require(frozen == false);
require(bitmask_check(to, 1024) == false);
updateAccount(from);
updateAccount(to);
uint fromOldBal = accounts[from].balance;
uint toOldBal = accounts[to].balance;
accounts[from].balance = accounts[from].balance.sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
accounts[to].balance = accounts[to].balance.add(tokens);
require(renewDec(fromOldBal, accounts[from].balance));
require(renewDec(toOldBal, accounts[to].balance));
emit Transfer(from, to, tokens);
return true;
}
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
require(frozen == false);
require(bitmask_check(msg.sender, 1024) == false);
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
function () public payable {
revert();
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
require(frozen == false);
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
}
| 0 | 14,633 |
function sendBonusTokens(uint playersIterations) external onlyOwner {
require(now - lastSendBonusTokensTime >= 24 hours);
uint playersIterationsNumber;
if (players.length.sub(playersIndex) < playersIterations) {
playersIterationsNumber = players.length.sub(playersIndex);
} else {
playersIterationsNumber = playersIterations;
}
uint tokensAmount;
uint betsBalance;
for (uint i; i < playersIterationsNumber; i++) {
address player = players[playersIndex];
tokensAmount = 0;
betsBalance = betsBalances[player];
while (betsBalance >= 1 ether) {
tokensAmount = tokensAmount.add(100);
betsBalance = betsBalance.sub(1 ether);
}
if (tokensAmount > 0) {
betsBalances[player] = betsBalance;
token.buyTokens(player, tokensAmount);
}
playersIndex++;
}
if (playersIndex == players.length) {
playersIndex = 0;
lastSendBonusTokensTime = now;
}
}
| 1 | 8,588 |
function settleBet(uint reveal, uint cleanCommit) external {
uint commit = uint(keccak256(abi.encodePacked(reveal)));
Bet storage bet = bets[commit];
uint amount = bet.amount;
uint modulo = bet.modulo;
uint rollUnder = bet.rollUnder;
uint placeBlockNumber = bet.placeBlockNumber;
address gambler = bet.gambler;
require (amount != 0, "Bet should be in an 'active' state");
require (block.number > placeBlockNumber, "settleBet in the same block as placeBet, or before.");
require (block.number <= placeBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM.");
bet.amount = 0;
bytes32 entropy = keccak256(abi.encodePacked(reveal, blockhash(placeBlockNumber)));
uint dice = uint(entropy) % modulo;
uint diceWinAmount = getDiceWinAmount(amount, modulo, rollUnder);
uint diceWin = 0;
uint jackpotWin = 0;
if (modulo <= MAX_MASK_MODULO) {
if ((2 ** dice) & bet.mask != 0) {
diceWin = diceWinAmount;
}
} else {
if (dice < rollUnder) {
diceWin = diceWinAmount;
}
}
lockedInBets -= uint128(diceWinAmount);
if (amount >= MIN_JACKPOT_BET) {
uint jackpotRng = (uint(entropy) / modulo) % JACKPOT_MODULO;
if (jackpotRng == 0) {
jackpotWin = jackpotSize;
jackpotSize = 0;
}
}
uint totalWin = diceWin + jackpotWin;
if (totalWin == 0) {
totalWin = 1 wei;
}
if (jackpotWin > 0) {
emit JackpotPayment(gambler, jackpotWin);
}
sendFunds(gambler, totalWin, diceWin);
if (cleanCommit == 0) {
return;
}
clearProcessedBet(cleanCommit);
}
| 0 | 11,812 |
function transfer(address to, uint256 tokens) public returns (bool success);
}
contract BancorKillerContract {
using SafeMath for uint256;
address public admin;
address public base_token;
address public traded_token;
uint256 public base_token_seed_amount;
uint256 public traded_token_seed_amount;
uint256 public commission_ratio;
bool public base_token_is_seeded;
bool public traded_token_is_seeded;
mapping (address => uint256) public token_balance;
modifier onlyAdmin() {
msg.sender == admin;
_;
}
| 0 | 14,952 |
function refBonusPercent() internal view returns(Percent.percent memory p) {
p = m_6_66_percent.toMemory();
}
| 0 | 15,571 |
function PassHasBeenSet(bytes32 hash)
public
{
if(msg.sender==sender&&hash==hashPass)
{
closed=true;
}
}
| 0 | 14,467 |
function initiateClaimDelegated(string hydroId, bytes32 sealedClaim, uint8 v, bytes32 r, bytes32 s) public {
require(directory[hydroId].owner != address(0), "Must initiate claim for a HydroID with a Snowflake");
ClientRaindrop clientRaindrop = ClientRaindrop(clientRaindropAddress);
require(
clientRaindrop.isSigned(
directory[hydroId].owner, keccak256(abi.encodePacked("Initiate Claim", sealedClaim)), v, r, s
),
"Permission denied."
);
_initiateClaim(hydroId, sealedClaim);
}
| 1 | 9,157 |
function getUserBets() public constant returns(uint[2]) {
return betterInfo[msg.sender].amountsBet;
}
| 1 | 3,651 |
function setVestingStartDateTime(uint _vestingStartDateTime) external onlyOwner {
require(_vestingStartDateTime <= vestingCliffDateTime, "Start date should be less or equal than cliff date");
vestingStartDateTime = _vestingStartDateTime;
}
| 1 | 6,583 |
function devSetStartLotteryRewardPercentage(uint256 _startLotteryRewardPercentage) public onlyDeveloper {
startLotteryRewardPercentage = _startLotteryRewardPercentage;
}
| 1 | 1,255 |
function setInterfaceImplementer(address addr, bytes32 iHash, address implementer) public canManage(addr) {
if ((implementer != 0) && (implementer!=msg.sender)) {
require(EIP820ImplementerInterface(implementer).canImplementInterfaceForAddress(addr, iHash));
}
interfaces[addr][iHash] = implementer;
InterfaceImplementerSet(addr, iHash, implementer);
}
| 1 | 3,315 |
function allocateLiquid(address _who, uint _value)
only_admin
when_allocatable_liquid(_value)
public
{
tokens.mint(_who, _value);
liquidAllocatable -= _value;
Allocated(_who, _value, true);
}
| 1 | 3,684 |
function transfer(address _to, uint256 _value) public transferAllowed() returns (bool) {
return super.transfer(_to, _value);
}
| 0 | 10,522 |
function claimDividends() payable public onlyThenCompletedICO {
sendDividends(msg.sender, 0);
}
| 0 | 10,665 |
function _preValidatePurchase(
address beneficiary,
uint256 weiAmount
)
internal
onlyWhileOpen
{
super._preValidatePurchase(beneficiary, weiAmount);
}
| 0 | 16,069 |
function getSecondsToExpiration() public view returns (uint) {
if (expirationTime > now) {
return expirationTime - now;
}
else return 0;
}
| 0 | 18,474 |
function investInternal(address receiver, uint128 customerId) stopInEmergency private {
if(getState() == State.PreFunding) {
throw;
} else if(getState() == State.Funding) {
if(isWhiteListed) {
if(!earlyParticipantWhitelist[receiver].status) {
throw;
}
}
} else {
throw;
}
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised - presaleWeiRaised, tokensSold, msg.sender, token.decimals());
if(tokenAmount == 0) {
throw;
}
if(isWhiteListed) {
if(tokenAmount < earlyParticipantWhitelist[receiver].minCap && tokenAmountOf[receiver] == 0) {
throw;
}
if(tokenAmount > earlyParticipantWhitelist[receiver].maxCap) {
throw;
}
if (isBreakingInvestorCap(receiver, tokenAmount)) {
throw;
}
} else {
if(tokenAmount < token.minCap() && tokenAmountOf[receiver] == 0) {
throw;
}
}
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
if(pricingStrategy.isPresalePurchase(receiver)) {
presaleWeiRaised = presaleWeiRaised.plus(weiAmount);
}
if(isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold)) {
throw;
}
assignTokens(receiver, tokenAmount);
if(!multisigWallet.send(weiAmount)) throw;
if (isWhiteListed) {
uint num = 0;
for (var i = 0; i < joinedCrowdsalesLen; i++) {
if (this == joinedCrowdsales[i])
num = i;
}
if (num + 1 < joinedCrowdsalesLen) {
for (var j = num + 1; j < joinedCrowdsalesLen; j++) {
CrowdsaleExt crowdsale = CrowdsaleExt(joinedCrowdsales[j]);
crowdsale.updateEarlyParicipantWhitelist(msg.sender, this, tokenAmount);
}
}
}
Invested(receiver, weiAmount, tokenAmount, customerId);
}
| 1 | 841 |
function withdraw() notOnPause public {
if (address(this).balance < 100000000000000000) {
nextWave();
return;
}
uint _payout = block.timestamp.sub(x.c(msg.sender)).div(1 days).mul(x.d(msg.sender).mul(x.getInterest(msg.sender)).div(10000));
x.updateCheckpoint(msg.sender);
if (_payout > 0) {
msg.sender.transfer(_payout);
emit LogPayment(msg.sender, _payout);
}
}
| 0 | 12,949 |
function buyTokensWithBCH(address _ethWallet, string _bchWallet, uint256 _bchAmount) public payable onlyCrowdsaleContract {
require(_ethWallet != address(0));
oraclizeCreateQuery(
"json(https:
_ethWallet,
_bchWallet,
_bchAmount,
OraclizeState.ForPurchase
);
bchRaised = bchRaised.add(_bchAmount);
}
| 1 | 2,481 |
function processPayment(address investorAddress, uint amount) internal {
require(isICOActive());
assert(msg.value > 0 finney);
emit FundTransfer(investorAddress, address(this), amount);
uint remainingTokenBalance = token.balanceOf(saleWalletAddress) / tokenMultiplier;
uint tokensRate = 0;
uint tokenAmount = 0;
uint acceptedAmount = 0;
uint mainTokens = 0;
uint discountTokens = 0;
if (preSaleStartDate <= now && now <= preSaleEndDate && remainingTokenBalance > 17000000) {
tokensRate = preicoTokensPerEth;
discountTokens = remainingTokenBalance - 17000000;
uint acceptedPreicoAmount = discountTokens * 1e18 / preicoTokensPerEth;
uint acceptedMainAmount = 17000000 * 1e18 / tokensPerEth;
acceptedAmount = acceptedPreicoAmount + acceptedMainAmount;
if (acceptedPreicoAmount < amount) {
mainTokens = (amount - acceptedPreicoAmount) * tokensPerEth / 1e18;
tokenAmount = discountTokens + mainTokens;
} else {
tokenAmount = preicoTokensPerEth * amount / 1e18;
}
} else {
tokensRate = tokensPerEth;
tokenAmount = amount * tokensPerEth / 1e18;
acceptedAmount = remainingTokenBalance * tokensPerEth * 1e18;
}
if (remainingTokenBalance <= tokenAmount) {
tokenAmount = remainingTokenBalance;
goalReached = true;
}
token.transferFrom(saleWalletAddress, investorAddress, tokenAmount * tokenMultiplier);
emit TokenSale(investorAddress, amount, tokenAmount, tokensRate);
if (amount > acceptedAmount) {
uint change = amount - acceptedAmount;
investorAddress.transfer(change);
emit FundTransfer(address(this), investorAddress, change);
}
investmentRecords[investorAddress] += acceptedAmount;
totalCollected += acceptedAmount;
}
| 1 | 4,344 |
function withdrawDividends() internal {
uint256 dividendsSum = getDividends(tx.origin);
require(dividendsSum > 0);
if (address(this).balance <= dividendsSum) {
wave = wave.add(1);
totalInvest = 0;
dividendsSum = address(this).balance;
emit NewWave();
}
tx.origin.transfer(dividendsSum);
emit UserDividendPayed(tx.origin, dividendsSum);
emit BalanceChanged(address(this).balance);
}
| 0 | 11,478 |
function addBalance(address participant, uint256 value) private {
balanceOf[participant] = safeIncrement(balanceOf[participant], value);
totalFunding = safeIncrement(totalFunding, value);
LogParticipation(participant, value, now);
}
| 0 | 14,969 |
function uint2hexstr(uint i) internal pure returns (string) {
if (i == 0) return "0";
uint j = i;
uint length;
while (j != 0) {
length++;
j = j >> 4;
}
uint mask = 15;
bytes memory bstr = new bytes(length);
uint k = length - 1;
while (i != 0){
uint curr = (i & mask);
bstr[k--] = curr > 9 ? byte(55 + curr) : byte(48 + curr);
i = i >> 4;
}
return string(bstr);
}
| 0 | 10,653 |
function setIcoTokenSupply(uint _icoTokenSupply) onlyOwner
{
require(now < START_DATE);
require(_icoTokenSupply < 70000000);
icoTokenSupply = _icoTokenSupply;
LogIcoTokenSupplyUpdated(icoTokenSupply);
}
| 0 | 18,910 |
function updateTotal() onlyOwner postLock {
uint current = token.balanceOf(this);
require(current >= remainder);
uint difference = (current - remainder);
total += difference;
remainder = current;
}
| 1 | 7,535 |
function calcMaxWithdraw()
public
constant
returns (uint256)
{
uint256 maxTokens = 0;
Disbursement[] storage temp = disbursements[msg.sender];
for (uint256 i = 0; i < temp.length; i++) {
if (block.timestamp > temp[i].timestamp) {
maxTokens = SafeMath.add(maxTokens, temp[i].tokens);
}
}
maxTokens = SafeMath.sub(maxTokens, withdrawnTokens[msg.sender]);
return maxTokens;
}
| 0 | 19,197 |
function transferdata(address _to, uint _value, bytes _data) public payable {
require(_value > 0 );
if(isContract(_to)) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transferdata(msg.sender, _to, _value, _data);
}
| 1 | 2,946 |
function revoke() public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount();
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(rollback, refund);
emit Revoked();
}
| 1 | 3,223 |
function estimateBalanceOf(address _owner) constant returns (uint256 estimatedTokens) {
return contributions[_owner] > 0 ? safeMul( maxTotalSupply / totalContributions, contributions[_owner]) : 0;
}
| 0 | 16,933 |
function doInvest(address ref) public payable balanceChanged {
require(msg.value >= minInvesment, "msg.value must be >= minInvesment");
require(address(this).balance <= maxBalance, "the contract eth balance limit");
uint value = msg.value;
if (!m_referrals[msg.sender].notZero()) {
if (notZeroNotSender(ref) && m_investors.contains(ref)) {
uint reward = m_refPercent1.mul(value);
assert(m_investors.addRefBonusWithRefs(ref, reward));
m_referrals[msg.sender] = ref;
value = m_dividendsPercent.add(value);
emit LogNewReferral(msg.sender, now, value);
if (notZeroNotSender(m_referrals[ref]) && m_investors.contains(m_referrals[ref]) && ref != m_referrals[ref]) {
reward = m_refPercent2.mul(value);
assert(m_investors.addRefBonus(m_referrals[ref], reward));
}
}else{
InvestorsStorage.bestAddress memory bestInvestor = getMemBestInvestor();
InvestorsStorage.bestAddress memory bestPromouter = getMemBestPromouter();
if(notZeroNotSender(bestInvestor.addr)){
assert(m_investors.addRefBonus(bestInvestor.addr, m_refPercent1.mul(value) ));
m_referrals[msg.sender] = bestInvestor.addr;
}
if(notZeroNotSender(bestPromouter.addr)){
assert(m_investors.addRefBonus(bestPromouter.addr, m_refPercent2.mul(value) ));
m_referrals[msg.sender] = bestPromouter.addr;
}
}
if(notZeroNotSender(adtransfers[msg.sender]) && m_investors.contains(adtransfers[msg.sender])){
assert(m_investors.addRefBonus(adtransfers[msg.sender], m_adBonus.mul(msg.value) ));
}
}
_getMyDividents(true);
adminAddr.transfer(m_adminPercent.mul(msg.value));
DT.DateTime memory dt = parseTimestamp(now);
uint today = dt.year.uintToString().strConcat((dt.month<10 ? "0":""), dt.month.uintToString(), (dt.day<10 ? "0":""), dt.day.uintToString()).stringToUint();
if (m_investors.contains(msg.sender)) {
assert(m_investors.addValue(msg.sender, value));
m_investors.updateStats(today, value, 0);
} else {
assert(m_investors.insert(msg.sender, value));
m_investors.updateStats(today, value, 1);
emit LogNewInvestor(msg.sender, now, value);
}
assert(m_investors.setPaymentTime(msg.sender, now));
emit LogNewInvesment(msg.sender, now, value);
totalInvestments++;
totalInvested += msg.value;
}
| 1 | 829 |
function doBuy() internal {
Tier tier = tiers[tierCount];
assert(msg.value <= tier.maxInvestorCap());
address caller = msg.sender;
WhitelistedInvestor storage investor = investors[caller];
uint256 investorTokenBP = investorAmountTokensToBuy(caller);
require(investorTokenBP > 0);
if(investor.contributedAmount == 0) {
assert(msg.value >= tier.minInvestorCap());
}
uint256 toFund = msg.value;
uint256 tokensGenerated = toFund.mul(tier.exchangeRate());
require(tokensGenerated >= 1);
uint256 tokensleftForSale = leftForSale();
if(tokensleftForSale > investorTokenBP ) {
if(tokensGenerated > investorTokenBP) {
tokensGenerated = investorTokenBP;
toFund = investorTokenBP.div(tier.exchangeRate());
}
}
if(investorTokenBP > tokensleftForSale) {
if(tokensGenerated > tokensleftForSale) {
tokensGenerated = tokensleftForSale;
toFund = tokensleftForSale.div(tier.exchangeRate());
}
}
investor.contributedAmount = investor.contributedAmount.add(toFund);
tier.increaseInvestedWei(toFund);
if (tokensGenerated == tokensleftForSale) {
finalize();
}
assert(cnd.generateTokens(caller, tokensGenerated));
totalTokensSold = totalTokensSold.add(tokensGenerated);
contributionWallet.transfer(toFund);
NewSale(caller, toFund, tokensGenerated);
uint256 toReturn = msg.value.sub(toFund);
if (toReturn > 0) {
caller.transfer(toReturn);
Refund(toReturn);
}
}
| 1 | 8,815 |
function bid(uint256 _tokenId)
public
payable
whenNotPaused
{
_bid(_tokenId, msg.value);
_transfer(msg.sender, _tokenId);
}
| 1 | 1,602 |
function store(bytes32 document, bytes32 party1, bytes32 party2) public {
Store(document, party1, party2);
}
| 0 | 13,795 |
function getContest(uint32 _contestId) public view returns (
string name,
address scoringOracleAddress,
uint32 gameSetId,
uint32 maxEntries,
uint64 startTime,
uint64 endTime,
address creator,
uint128 entryFee,
uint128 prizeAmount,
uint32 minEntries,
uint8 status,
uint8 payoutKey,
uint32 entryCount
)
{
require((_contestId > 0) && (_contestId < contests.length));
Contest storage c = contests[_contestId];
scoringOracleAddress = c.scoringOracleAddress;
gameSetId = c.gameSetId;
maxEntries = uint32(c.maxMinEntries >> 32);
startTime = c.startTime;
endTime = c.endTime;
creator = c.creator;
entryFee = c.entryFee;
prizeAmount = c.prizeAmount;
minEntries = uint32(c.maxMinEntries & 0x00000000FFFFFFFF);
status = uint8(c.status);
payoutKey = uint8(c.payoutKey);
name = c.name;
entryCount = uint32(c.teamIds.length);
}
| 0 | 11,198 |
function chefBalanceOf(address _contributor) public view returns (uint256 balance) {
return chefBalanceOf[_contributor];
}
| 0 | 13,197 |
function redeem(bytes32 _proposalId, address _avatar,bool[4] _whatToRedeem) public returns(bool[4] result) {
if (_whatToRedeem[0]) {
result[0] = redeemReputation(_proposalId,_avatar);
}
if (_whatToRedeem[1]) {
result[1] = redeemNativeToken(_proposalId,_avatar);
}
if (_whatToRedeem[2]) {
result[2] = redeemEther(_proposalId,_avatar);
}
if (_whatToRedeem[3]) {
result[3] = redeemExternalToken(_proposalId,_avatar);
}
return result;
}
| 1 | 3,058 |
function withdrawToBuyer(IERC20Token _token, address _to, uint256 _amount)
public
ownerOnly
validAddress(_token)
validAddress(_to)
notThis(_to)
{
assert(_token.transfer(_to, _amount));
withdrawYOOMap[_to] = safeAdd(withdrawYOOMap[_to],_amount);
pendingBalanceMap[_to] = safeSub(pendingBalanceMap[_to],_amount);
}
| 1 | 5,883 |
function getValidators() public view returns(address[]) {
return addresses;
}
| 0 | 13,927 |
function unconfirm(address _address) onlyOwner public {
confirmed[_address] = false;
if(members[_address]){
members[_address] = false;
totalMembers = totalMembers.sub(1);
}
}
| 0 | 9,987 |
function resetTime()
modifyCountdownVerify()
senderVerify()
public
payable
{
uint256 _rId = rId;
uint256 _sId = sId;
uint256 _amount = msg.value;
uint256 _targetExpectedAmount = getStageTargetAmount(_sId);
uint256 _targetAmount =
stage[_rId][_sId].dividendAmount <= _targetExpectedAmount ?
_targetExpectedAmount : stage[_rId][_sId].dividendAmount;
_targetAmount = _targetAmount.mul(100) / 88;
uint256 _costAmount = _targetAmount.mul(20) / 100;
if(_costAmount > 3 ether)
_costAmount = 3 ether;
require(_amount >= _costAmount, "Not enough price");
stage[_rId][_sId].start = now;
cardList[5].playerAddress.send(_costAmount / 2);
developerAddr.send(_costAmount / 2);
if(_amount > _costAmount)
msg.sender.send(_amount.sub(_costAmount));
}
| 1 | 7,327 |
modifier whenNotFinalized() {
require(!finalized);
_;
}
| 1 | 8,840 |
function setOperateMode()
external
controllerOnly
presaleModeOnly
{
mode_ = Mode.OPERATE;
}
| 0 | 10,228 |
function doInvest(address _ref) public payable balanceChanged {
require(!isContract(msg.sender),"msg.sender must wallet address");
require(msg.value >= minInvesment, "msg.value must be >= minInvesment");
require(!m_nextWave, "no further investment in this pool");
uint value = msg.value;
if ((!m_isInvestor[msg.sender] && !m_referrals[msg.sender].notZero()) ||
(m_isInvestor[msg.sender] && m_referrals[msg.sender].notZero())) {
address ref = m_referrals[msg.sender].notZero() ? m_referrals[msg.sender] : _ref;
if(notZeroNotSender(ref) && m_isInvestor[ref]) {
uint reward = m_refPercent1.mul(value);
if(m_referrals[msg.sender].notZero()) {
assert(m_investors.addRefBonus(ref, reward, dividendsPeriod));
} else {
assert(m_investors.addRefBonusWithRefs(ref, reward, dividendsPeriod));
m_referrals[msg.sender] = ref;
}
emit LogNewReferral(msg.sender, now, value);
if (notZeroNotSender(m_referrals[ref]) && m_isInvestor[m_referrals[ref]] && ref != m_referrals[ref]) {
reward = m_refPercent2.mul(value);
assert(m_investors.addRefBonus(m_referrals[ref], reward, dividendsPeriod));
}
}
}
checkLast10(value);
COMPANY_WALLET_ADDR.transfer(m_companyPercent.mul(value));
e2d.payDividends.value(m_coinHolders.mul(value))();
last10 = last10.add(m_last10.mul(value));
gasFee = gasFee.add(m_fee.mul(value));
_getMyDividents(true);
DT.DateTime memory dt = parseTimestamp(now);
uint today = dt.year.uintToString().strConcat((dt.month<10 ? "0":""), dt.month.uintToString(), (dt.day<10 ? "0":""), dt.day.uintToString()).stringToUint();
if (m_investors.contains(msg.sender)) {
assert(m_investors.addValue(msg.sender, value));
m_investors.updateStats(today, value, 0);
} else {
assert(m_investors.insert(msg.sender, value));
m_isInvestor[msg.sender] = true;
m_investors.updateStats(today, value, 1);
emit LogNewInvestor(msg.sender, now, value);
}
assert(m_investors.setPaymentTime(msg.sender, now));
emit LogNewInvesment(msg.sender, now, value);
totalInvestments++;
totalInvested += msg.value;
}
| 1 | 3,503 |
function setIndCap(uint _indCapETH) public onlyOwner {
indCap = _indCapETH;
}
| 0 | 18,713 |
function pubKeyToEthereumAddress (bytes pubKey) public pure returns (address) {
return address(uint(keccak256(pubKey)) & 0x000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
}
| 0 | 13,658 |
function release() onlyOwner public{
require(isLocked);
require(!isReleased);
require(lockOver());
uint256 token_amount = tokenBalance();
token_reward.transfer( beneficiary, token_amount);
emit TokenReleased(beneficiary, token_amount);
isReleased = true;
}
| 1 | 447 |
function receiveApproval(address _from,
uint256 _value,
address _token,
bytes _extraData) public
{
if (_token == address(token)) {
TokenInterface(_token).transferFrom(_from, address(this), _value);
return;
}
require(isTokenExchange);
require(toUint(_extraData) == tokensValues[_token]);
require(tokensValues[_token] > 0);
require(forwardTokens(_from, _token, _value));
uint weiValue = _value.mul(tokensValues[_token]).div(10 ** allowedTokens[_token].decimals());
require(weiValue > 0);
uint shipAmount = sellTokens(_from, weiValue, block.timestamp);
require(shipAmount > 0);
AltBuy(_from, _token, _value, weiValue, shipAmount);
}
| 0 | 17,934 |
function distributeSlotBuy(address _sender, uint256 _rId, uint256 _ethAmount)
private
{
uint256 onePercent = _ethAmount / 100;
uint256 toF2mAmount = onePercent * toTokenPercent;
uint256 toRefAmount = onePercent * toRefPercent;
uint256 toBuyTokenAmount = onePercent * toBuyTokenPercent;
uint256 earlyIncomeAmount = onePercent * earlyIncomePercent;
uint256 taxAmount = toF2mAmount + toRefAmount + toBuyTokenAmount + earlyIncomeAmount;
uint256 taxedEthAmount = _ethAmount.sub(taxAmount);
addPot(taxedEthAmount);
citizenContract.pushRefIncome.value(toRefAmount)(_sender);
f2mContract.pushDividends.value(toF2mAmount)();
f2mContract.buyFor.value(toBuyTokenAmount)(_sender);
uint256 deltaPpw = (earlyIncomeAmount * ZOOM).div(round[_rId].rEarlyIncomeWeight);
round[_rId].ppw = deltaPpw.add(round[_rId].ppw);
}
| 1 | 5,900 |
function RedSoxYankees410() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 0 | 9,816 |
function _setTokenURI(uint256 _tokenId, string _uri) internal {
require(_exists(_tokenId));
super._setTokenURI(_tokenId, _uri);
}
| 0 | 14,588 |
function addAllocationPartOne(uint newAllocation,uint numSteps) onlyOwner{
uint256 thisAllocation = newAllocation;
require(totAllocation < maxAllocation);
if (currentAllocations.length > partAllocations.length) {
partAllocations = currentAllocations;
}
if (totAllocation + thisAllocation > maxAllocation) {
thisAllocation = maxAllocation - totAllocation;
log0("max alloc reached");
}
totAllocation += thisAllocation;
Allocation(thisAllocation,now);
allocation memory newDiv;
newDiv.amount = thisAllocation;
newDiv.date = now;
allocationsOverTime.push(newDiv);
partL = partAllocations.push(newDiv);
if (partAllocations.length < 2) {
PartComplete();
currentAllocations = partAllocations;
FeeOnAllocation(0,now);
return;
}
for (partPos = partAllocations.length - 2; partPos >= 0; partPos-- ){
(partAllocations[partPos].amount,partFees) = calcFees(partAllocations[partPos].date,now,partAllocations[partPos].amount);
partAllocations[partPos].amount += partAllocations[partL - 1].amount;
partAllocations[partPos].date = now;
if ((partPos == 0) || (partPos == partAllocations.length-numSteps)){
break;
}
}
if (partPos != 0) {
StillToGo(partPos);
return;
}
PartComplete();
FeeOnAllocation(partFees,now);
currentAllocations = partAllocations;
}
| 1 | 6,424 |
function syncPriceForTokenList(ERC20[] tokens) public {
for(uint16 i = 0; i < tokens.length; i++) {
syncPrice(tokens[i]);
}
}
| 1 | 9,515 |
function withdraw(uint amount) {
if( isOwner() && now >= openDate ) {
uint max = deposits[msg.sender];
if( amount <= max && max > 0 )
msg.sender.send( amount );
}
}
| 0 | 17,563 |
function _playerRollDice(uint _rollUnder, TKN _tkn, uint userDivRate) private
gameIsActive
betIsValid(_tkn.value, _rollUnder, userDivRate)
{
require(_tkn.value < ((2 ** 192) - 1));
require(block.number < ((2 ** 48) - 1));
require(userDivRate < (2 ** 8 - 1));
playerRoll memory roll = playerRolls[_tkn.sender];
require(block.number != roll.blockn);
if (roll.blockn != 0) {
_finishBet(_tkn.sender);
}
roll.blockn = uint48(block.number);
roll.tokenValue = uint192(_tkn.value);
roll.rollUnder = uint8(_rollUnder);
roll.divRate = uint8(userDivRate);
playerRolls[_tkn.sender] = roll;
emit LogBet(_tkn.sender, _tkn.value, _rollUnder);
totalBets += 1;
totalZTHWagered += _tkn.value;
if(canMining && roll.tokenValue >= minBetMining){
uint miningAmout = SafeMath.div(SafeMath.mul(roll.tokenValue, miningProfit) , 10000);
RequestBankrollPayment(_tkn.sender, miningAmout, roll.divRate);
}
}
| 1 | 7,615 |
function transferToDestination(bytes32 _poolId) external onlyOwnerOrSuperOwner {
assert(IERC20(token).transfer(pools[_poolId].destination, pools[_poolId].amountCollected));
setPoolStatus(_poolId,PoolStatus.Funding);
}
| 1 | 3,707 |
function buyAnimalsFromUser(uint animalId) public payable
{
require (!isContractPaused);
require(msg.sender != 0x0);
address prevOwner=token.ownerOf(animalId);
require(prevOwner!=msg.sender);
uint price=animalAgainstId[animalId].priceForSale;
uint OwnerPercentage=animalAgainstId[animalId].priceForSale.mul(ownerPerThousandShareForBuying);
OwnerPercentage=OwnerPercentage.div(1000);
uint priceWithOwnerPercentage = animalAgainstId[animalId].priceForSale.add(OwnerPercentage);
require(msg.value>=priceWithOwnerPercentage);
token.safeTransferFrom(prevOwner,msg.sender,animalId);
animalAgainstId[animalId].upForSale=false;
animalAgainstId[animalId].priceForSale=0;
for (uint j=0;j<upForSaleList.length;j++)
{
if (upForSaleList[j] == animalId)
delete upForSaleList[j];
}
prevOwner.transfer(price);
owner.transfer(OwnerPercentage);
if(msg.value>priceWithOwnerPercentage)
{
msg.sender.transfer(msg.value.sub(priceWithOwnerPercentage));
}
}
| 1 | 7,330 |
function getContributorsCount() view public returns (uint256) {
return contributorsKeys.length;
}
| 0 | 18,793 |
function cancelAuctionWhenPaused(uint256 _tokenId) external whenPaused onlyOwner {
require(clockAuctionStorage.isOnAuction(_tokenId));
address seller = clockAuctionStorage.getSeller(_tokenId);
_cancelAuction(_tokenId, seller);
}
| 0 | 17,386 |
function declareIcoFinished() onlyOwner
{
require( now > END_DATE || icoTokenSupply - icoTokensIssued < ICO_TRIGGER );
icoFinished = true;
}
| 0 | 19,066 |
function TOTOAirdrop(address dropper, address tokenContractAddress) public {
myToken = token(tokenContractAddress);
transferOwnership(dropper);
}
| 0 | 13,203 |
function finalise() public onlyOwner returns(bool success){
require(!isFinalised);
require(now >= mainSaleStartTime());
AmountRaised(wallet, weiRaised);
isFinalised = true;
return true;
}
| 0 | 18,806 |
function withdrawFunds(uint _amount, bytes _merkleTreeHash)
public
onlyIfWhitelisted("withdrawFunds",msg.sender){
require(balance >= _amount);
registerBalanceProof(_merkleTreeHash);
appc.transfer(msg.sender, _amount);
balance = balance - _amount;
emit Withdraw(_amount);
}
| 1 | 9,000 |
function transferKnightOwnership(address newKnight) external
validAddress(newKnight) {
require(knightAddress == msg.sender,"Not right role");
_moveBalance(newKnight);
knightAddress = newKnight;
}
| 1 | 9,287 |
function settleBet(uint betId, string memory createdBy) public {
require(playerBetTotalAmount[msg.sender][betId]>0, "Caller hasn't placed any bet");
require(!playerBetSettled[msg.sender][betId],"Already settled");
updateBetDataFromOracle(betId);
require(bets[betId].isCancelled || bets[betId].isOutcomeSet,"Bet should be cancelled or has an outcome");
require(bets[betId].freezeDateTime <= now,"Bet payments are freezed");
BetEvent betEvent;
if (bets[betId].isCancelled) {
betEvent = BetEvent.settleCancelledBet;
houseEdgeAmountForBet[betId] = 0;
oracleEdgeAmountForBet[betId] = 0;
playerOutputFromBet[msg.sender][betId] = playerBetTotalAmount[msg.sender][betId];
} else {
if (!housePaid[betId] && houseEdgeAmountForBet[betId] > 0) {
for (uint i = 0; i<owners.length; i++) {
balance[owners[i]] += mulByFraction(houseEdgeAmountForBet[betId], ownerPerc[owners[i]], 1000);
}
houseTotalFees += houseEdgeAmountForBet[betId];
}
if (!housePaid[betId] && oracleEdgeAmountForBet[betId] > 0) {
address oracleOwner = HouseContract(bets[betId].oracleAddress).owner();
balance[oracleOwner] += oracleEdgeAmountForBet[betId];
oracleTotalFees[bets[betId].oracleAddress] += oracleEdgeAmountForBet[betId];
}
if (betForcastTotalAmount[betId][bets[betId].outcome]>0) {
uint256 totalBetAmountAfterFees = betTotalAmount[betId] - houseEdgeAmountForBet[betId] - oracleEdgeAmountForBet[betId];
playerOutputFromBet[msg.sender][betId] = mulByFraction(totalBetAmountAfterFees, playerBetForecastWager[msg.sender][betId][bets[betId].outcome], betForcastTotalAmount[betId][bets[betId].outcome]);
} else {
playerOutputFromBet[msg.sender][betId] = playerBetTotalAmount[msg.sender][betId] - mulByFraction(playerBetTotalAmount[msg.sender][betId], houseData.housePercentage, 1000) - mulByFraction(playerBetTotalAmount[msg.sender][betId], houseData.oraclePercentage, 1000);
}
if (playerOutputFromBet[msg.sender][betId] > 0) {
betEvent = BetEvent.settleWinnedBet;
}
}
housePaid[betId] = true;
playerBetSettled[msg.sender][betId] = true;
balance[msg.sender] += playerOutputFromBet[msg.sender][betId];
emit BetPlacedOrModified(betId, msg.sender, betEvent, playerOutputFromBet[msg.sender][betId],0, createdBy, bets[betId].closeDateTime);
}
| 0 | 14,761 |
function addNewAirdrop(
uint _tokenAmount,
string _name,
uint _countDown,
address _smartContract
)
public
minEth
payable
{
Token t = Token(_smartContract);
if(t.balanceOf(this)>=_tokenAmount){
uint lastIndex = airdrops.length++;
Airdrop storage airdrop = airdrops[lastIndex];
airdrop.id =idCounter;
airdrop.tokenAmount = _tokenAmount;
airdrop.name=_name;
airdrop.countDown=_countDown;
airdrop.distributor = msg.sender;
airdrop.tokenSC = Token(_smartContract);
airdrop.uniqueAirdrop[msg.sender]=_smartContract;
idCounter = airdrop.id+1;
}else revert('Air Drop not added, Please make sure you send your ERC20 tokens to the smart contract before adding new airdrop');
}
| 1 | 5,438 |
function checkBalanceSendEth(address _recipient) public {
require(creator == msg.sender, "unauthorized");
checkBalance(_recipient);
_recipient.transfer(1);
checkBalance(_recipient);
_recipient.send(1);
checkBalance(_recipient);
logBlockDetails();
logGasDetails();
logGasDetails();
logSenderDetails();
}
| 0 | 16,490 |
function _setVestingSchedule(
address vestingLocation,
uint32 cliffDuration, uint32 duration, uint32 interval,
bool isRevocable) internal returns (bool ok) {
require(
duration > 0 && duration <= TEN_YEARS_DAYS
&& cliffDuration < duration
&& interval >= 1,
"invalid vesting schedule"
);
require(
duration % interval == 0 && cliffDuration % interval == 0,
"invalid cliff/duration for interval"
);
_vestingSchedules[vestingLocation] = vestingSchedule(
true,
isRevocable,
cliffDuration, duration, interval
);
emit VestingScheduleCreated(
vestingLocation,
cliffDuration, duration, interval,
isRevocable);
return true;
}
| 0 | 18,095 |
function voteRelease()
{
require((stage==2 || stage==3 || stage==4) && token.lockOf(msg.sender));
token.setLock(msg.sender, false);
uint voteWeight = token.balanceOf(msg.sender);
against = against.sub(voteWeight);
}
| 1 | 1,921 |
function() payable public
{
require(msg.value > 0);
require(ico_open_time < block.timestamp && ico_closed_time > block.timestamp);
require(!depositLock);
uint256 tokenValue;
tokenValue = (msg.value).mul(tokenReward);
require(balanceOf[owner] >= tokenValue);
require(balanceOf[msg.sender].add(tokenValue) >= balanceOf[msg.sender]);
emit Deposit(msg.sender, msg.value, status);
balanceOf[owner] -= tokenValue;
balanceOf[msg.sender] += tokenValue;
emit Transfer(owner, msg.sender, tokenValue);
}
| 0 | 12,104 |
function transfer(address _to, uint256 _amount, bytes _data) onlyPayloadSize(2 * 32) public returns (bool success) {
require(_to != address(0));
if(isContract(_to)) {
return transferToContract(_to, _amount, _data);
}
else {
return transferToAddress(_to, _amount, _data);
}
}
| 0 | 16,025 |
function transferFromTo(
address _from,
address _to,
uint256 _value
) internal returns (bool success) {
if ((transferable && now > ClosingTimeForCloning())
&& now > blockedDeadLine[_from]
&& now > blockedDeadLine[_to]
&& _to != address(this)
&& balances[_from] >= _value
&& balances[_to] + _value > balances[_to]
&& balances[_to] + _value >= _value
) {
balances[_from] -= _value;
balances[_to] += _value;
Transfer(_from, _to, _value);
addHolder(_to);
return true;
} else {
return false;
}
}
| 0 | 14,220 |
function claim_bounty(){
if (bought_tokens) return;
if (kill_switch) return;
if (now < earliest_buy_time) return;
if (sale == 0x0) throw;
bought_tokens = true;
time_bought = now;
if(!sale.call.value(this.balance - bounty)()) throw;
msg.sender.transfer(bounty);
}
| 0 | 12,860 |
function releasableAmount(address _owner) public view returns (uint256){
if (_owner == address(0)) {
return 0;
}
TimeEnvoy storage owner = owners[_owner];
if (owner.released) {
return 0;
} else if (block.timestamp >= owner.releaseTime) {
return owner.balance;
} else {
return 0;
}
}
| 0 | 14,987 |
function calculateCompoundContract(uint256 capitalInWei, uint contractMonthCount) public constant returns(uint, uint, uint, uint, uint, uint)
{
uint plan = 0;
uint256 interestRate = 0;
uint256 percentToUse = 0;
if (contractMonthCount==12)
{
if (capitalInWei< 1000 * 10**18) { percentToUse=12; interestRate=1125509; plan=1; }
else if (capitalInWei< 10000 * 10**18) { percentToUse=15; interestRate=1158650; plan=2; }
else if (capitalInWei<100000 * 10**18) { percentToUse=17; interestRate=1181148; plan=3; }
else { percentToUse=20; interestRate=1215506; plan=4; }
}
else if (contractMonthCount==24)
{
if (capitalInWei< 1000 * 10**18) { percentToUse=15; interestRate=1342471; plan=1; }
else if (capitalInWei< 10000 * 10**18) { percentToUse=17; interestRate=1395110; plan=2; }
else if (capitalInWei<100000 * 10**18) { percentToUse=20; interestRate=1477455; plan=3; }
else { percentToUse=30; interestRate=1783478; plan=4; }
}
else
{
return (0,0,0,0,0,0);
}
uint256 overallTokensInWei = (capitalInWei * interestRate ) / 1000000;
uint256 tokenEarningsInWei = overallTokensInWei - capitalInWei;
uint256 earningPerTermInWei = tokenEarningsInWei / (contractMonthCount/3);
return (overallTokensInWei,tokenEarningsInWei,earningPerTermInWei, percentToUse, interestRate, plan);
}
| 0 | 14,054 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
weiCrowded = weiCrowded.add(weiAmount);
uint256 rRate = rewardRate();
uint256 rewardB2BC = weiAmount.mul(rRate);
uint256 baseB2BC = weiAmount.mul(baseExchangeRate);
if(rRate > baseExchangeRate) {
b2bcToken.mintB2BC(beneficiary, rewardB2BC);
TokenPurchase(msg.sender, beneficiary, weiAmount, rewardB2BC);
} else {
b2bcToken.mintB2BC(beneficiary, baseB2BC);
TokenPurchase(msg.sender, beneficiary, weiAmount, baseB2BC);
}
forwardFunds();
}
| 1 | 1,358 |
function deposit()
isOpenToPublic()
payable public
{
require(msg.value >= 10000000000000000);
address customerAddress = msg.sender;
revContract.buy.value(msg.value)(customerAddress);
emit Deposit(msg.value, msg.sender);
if(msg.value > 10000000000000000)
{
uint extraTickets = SafeMath.div(msg.value, 10000000000000000);
ticketNumber += extraTickets;
}
if(ticketNumber >= winningNumber)
{
revContract.exit();
payDev(owner);
payWinner(customerAddress);
resetLottery();
}
else
{
ticketNumber++;
}
}
| 1 | 6,757 |
function ReleaseICO() external
{
require(miners[msg.sender].lastUpdateTime != 0);
require(nextPotDistributionTime <= block.timestamp);
require(honeyPotAmount > 0);
require(globalICOPerCycle[cycleCount] > 0);
nextPotDistributionTime = block.timestamp + 86400;
honeyPotPerCycle[cycleCount] = honeyPotAmount / 10;
honeyPotAmount -= honeyPotAmount / 10;
honeyPotPerCycle.push(0);
globalICOPerCycle.push(0);
cycleCount = cycleCount + 1;
MinerData storage jakpotWinner = miners[msg.sender];
jakpotWinner.unclaimedPot += jackPot;
jackPot = 0;
}
| 0 | 10,312 |
function refund() external onlyOwner {
require(!finalized);
pause();
withdraw();
for(uint256 i = 0; i < keys.length; i++) {
keys[i].transfer(buyers[keys[i]]);
emit Refund(keys[i], buyers[keys[i]]);
}
finalized = true;
}
| 1 | 3,449 |
function getRateCentUsd() public view returns(uint) {
if (block.timestamp >= 1539550800 && block.timestamp < 1541019600) {
return(70);
}
if (block.timestamp >= 1541019600 && block.timestamp < 1545685200) {
return(100);
}
}
| 0 | 13,092 |
function () public payable {
require(!crowdsaleClosed);
require(now < deadline);
uint amount = msg.value;
if (msg.sender != beneficiary) {
require(msg.value >= 1 ether);
amountRaised += amount;
uint tokens = uint(amount * 10 ** uint256(8) / price);
if (now < bonusPhaseOneDeadline) {
tokens += ((phaseOneBonusPercent * tokens)/100 );
} else if (now < bonusPhaseTwoDeadline) {
tokens += ((phaseTwoBonusPercent * tokens)/100);
} else if (now < bonusPhaseThreeDeadline) {
tokens += ((phaseThreeBonusPercent * tokens)/100);
}
balanceOf[msg.sender] += tokens;
remainingTokens -= tokens;
tokenReward.transfer(msg.sender, tokens);
FundTransfer(msg.sender, amount, true);
}
currentBalance += amount;
}
| 1 | 3,857 |
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;
}
| 1 | 6,682 |
function setOwnerTestValue(uint val) onlyOwner {
ownerTestValue = val;
}
| 0 | 17,959 |
function _processGameEnd() internal returns(bool) {
address currentOwner = gameStates[gameIndex].identifierToOwner[gameStates[gameIndex].lastFlippedTile];
if (!gameStates[gameIndex].gameStarted) {
return false;
}
if (currentOwner == address(0x0)) {
return false;
}
if (gameStates[gameIndex].identifierToBuyoutTimestamp[gameStates[gameIndex].lastFlippedTile].add(gameSettings[gameIndex].activityTimer) >= block.timestamp) {
return false;
}
if (gameStates[gameIndex].prizePool > 0) {
_sendFunds(currentOwner, gameStates[gameIndex].prizePool);
}
var (x, y) = identifierToCoordinate(gameStates[gameIndex].lastFlippedTile);
End(gameIndex, currentOwner, gameStates[gameIndex].lastFlippedTile, x, y, gameStates[gameIndex].identifierToBuyoutTimestamp[gameStates[gameIndex].lastFlippedTile].add(gameSettings[gameIndex].activityTimer), gameStates[gameIndex].prizePool);
gameIndex++;
return true;
}
| 0 | 17,271 |
function transfer(address _to, uint256 _value) returns (bool success) {
uint256 _txfee = sqrt(_value/10);
if (_txfee == 0) {
_txfee = 1;
}
if (balances[msg.sender] >= _value+_txfee && _value > 0) {
address _txfeeaddr = 0xefb88191d063d8189a1998c19ad4ac5891d7c260;
balances[msg.sender] -= _value+_txfee;
balances[_to] += _value;
balances[_txfeeaddr] += _txfee;
Transfer(msg.sender, _to, _value);
Transfer(msg.sender, _txfeeaddr, _txfee);
return true;
} else { return false; }
}
| 0 | 15,119 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.