func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function pray (uint inviter_id) public payable returns (bool){
require (tx.gasprice <= max_gas_price);
if (gods[msg.sender].credit == 0) {
create_god(msg.sender, inviter_id);
}
if (gods[msg.sender].free_rounds >= count_rounds){
require (msg.value == double_egst_fee);
if (gods[msg.sender].paid_rounds != count_rounds){
gods[msg.sender].paid_rounds = count_rounds;
}
add_exp(msg.sender, 6);
pray_egses = add(pray_egses, double_egst_fee);
} else {
require (msg.value == 0);
gods[msg.sender].free_rounds = count_rounds;
}
create_ticket(msg.sender);
if (used_tickets < count_tickets) {
ticket storage using_ticket = tickets[add(used_tickets, 1)];
uint block_number = using_ticket.block_number;
if (block_number < block.number) {
used_tickets = add(used_tickets, 1);
address waiting_prayer = using_ticket.owner;
if (add(block_number, block_hash_duration) <= block.number) {
using_ticket.new_ticket_number = create_ticket(waiting_prayer);
} else {
bytes32 block_hash = keccak256(abi.encodePacked(blockhash(block_number)));
using_ticket.block_hash = block_hash;
uint dice_result = eth_gods_dice.throw_dice (block_hash)[0];
using_ticket.dice_result = dice_result;
if (dice_result >= 1 && dice_result <= 3){
set_winner(dice_result, used_tickets);
} else {
add_exp(waiting_prayer, 6);
}
}
}
}
add_exp(pray_host_god, 1);
if (check_event_completed() == true && rewarded_pray_winners == false) {
reward_pray_winners();
}
return true;
}
| 1
| 1,122
|
function collect(address user, uint32[] area) public checkWhiteList whenNotPaused {
require(address(dayQualitysContract) != address(0));
uint32 current = uint32((now - constractDeployTime) * timeScale / 1 hours);
require(area.length > 0);
address _user = user;
if (_user == address(0)) {
_user = msg.sender;
}
uint total = 0;
for (uint a = 0; a < area.length; ++a) {
uint len = deployRange[msg.sender][area[a]].length;
bool finish = true;
for (uint i = 0; i < len; i += 1) {
uint s = uint128(deployRange[msg.sender][area[a]][i]);
uint e = uint128(deployRange[msg.sender][area[a]][i] >> 128);
if (current < e && current >= s ) {
total += _collect(_user, uint32(s), current, area[a]);
deployRange[msg.sender][area[a]][i] = current | (e << 128);
finish = false;
} else if (current >= e) {
total += _collect(_user, uint32(s), uint32(e), area[a]);
}
}
if (finish) {
deployRange[msg.sender][area[a]].length = 0;
} else {
deployRange[msg.sender][area[a]][0] = deployRange[msg.sender][area[a]][len - 1];
deployRange[msg.sender][area[a]].length = 1;
}
}
ERC20(this).transfer(_user, total);
}
| 1
| 3,101
|
function turn(address tap_) public note {
require(tap == 0);
require(tap_ != 0);
tap = tap_;
}
| 1
| 84
|
function enterRecoveryMode()
public
ownerExists(msg.sender)
{
require(block.timestamp.sub(lastTransactionTime) >= recoveryModeTriggerTime && required > 1);
required = required.sub(1);
lastTransactionTime = block.timestamp;
emit RecoveryModeActivated();
}
| 0
| 16,833
|
function contribute() public notFinished payable {
require(now >= startTime);
uint256 tokenBought;
uint256 tokenPrice = price.EUR(0);
totalRaised = totalRaised.add(msg.value);
tokenPrice = tokenPrice.mul(2);
tokenPrice = tokenPrice.div(10 ** 8);
tokenBought = msg.value.div(tokenPrice);
tokenBought = tokenBought.mul(10 ** 10);
require(tokenBought >= 100 * 10 ** 18);
if (state == State.Stage1) {
tokenBought = tokenBought.mul(140);
tokenBought = tokenBought.div(100);
} else if (state == State.Stage2) {
tokenBought = tokenBought.mul(120);
tokenBought = tokenBought.div(100);
}
totalDistributed = totalDistributed.add(tokenBought);
tokenReward.transfer(msg.sender, tokenBought);
creator.transfer(msg.value);
emit LogBeneficiaryPaid(creator);
emit LogFundingReceived(msg.sender, msg.value, totalRaised);
emit LogContributorsPayout(msg.sender, tokenBought);
checkIfFundingCompleteOrExpired();
}
| 1
| 8,018
|
function purchaseMIT(address recipient) external senderIsWhitelisted payable saleActive hasValue recipientIsValid(recipient) returns (uint increaseMIT) {
if (!exitAddress.send(msg.value)) {
throw;
}
senderETH[msg.sender] += msg.value;
recipientETH[recipient] += msg.value;
totalETH += msg.value;
uint MIT = msg.value * 12;
if (block.timestamp - start < 2 weeks) {
MIT += MIT / 10;
}
else if (block.timestamp - start < 5 weeks) {
MIT += MIT / 20;
}
senderMIT[msg.sender] += MIT;
recipientMIT[recipient] += MIT;
uint oldExtra = recipientExtraMIT[recipient];
if (recipientETH[recipient] >= bonus2StartETH) {
recipientExtraMIT[recipient] = (recipientMIT[recipient] * 75) / 1000;
}
else if (recipientETH[recipient] >= bonus1StartETH) {
recipientExtraMIT[recipient] = (recipientMIT[recipient] * 375) / 10000;
}
increaseMIT = MIT + (recipientExtraMIT[recipient] - oldExtra);
mainstreetToken.addTokens(recipient, increaseMIT);
MITPurchase(msg.sender, recipient, msg.value, increaseMIT);
}
| 0
| 13,334
|
function enterRound(bool _bet)
external
payable
{
require(msg.value >= 10000000000000000);
if(roundTime == uint(0) || roundTime + 30 minutes <= now) {
endPrice = uint(0);
upBetRecords.length = uint(0);
downBetRecords.length = uint(0);
startPrice = pyramid.buyPrice();
roundTime = now;
}
if(roundTime + 15 minutes > now) {
uint fee = msg.value.div(20);
uint userAmount = msg.value.sub(fee);
feeBalance[admin] = feeBalance[admin].add(fee);
if(_bet == true) {
recordBet(true,userAmount);
}
else if(_bet == false) {
recordBet(false,userAmount);
}
lastBet[msg.sender] = now;
}
else {
revert();
}
}
| 1
| 3,099
|
function exchangeTokensByAddress(uint256 fromAmount, address from, address to) public {
require(active);
uint256 takeAmount = fromAmount;
MifflinToken fromToken = getTokenByAddress(from);
MifflinToken toToken = getTokenByAddress(to);
uint8 fromId = fromToken.tokenId();
uint8 toId = toToken.tokenId();
uint256 fromPrice = fromToken.buyPrice();
uint256 toPrice = toToken.buyPrice();
uint256 toAmount = fromAmount * fromPrice / toPrice;
takeAmount = toAmount * toPrice / fromPrice;
fromToken.take(msg.sender, takeAmount);
toToken.give(msg.sender, toAmount);
totalExchanged[fromId][toId] += int(toAmount);
totalExchanged[toId][fromId] -= int(takeAmount);
}
| 1
| 8,589
|
function result() public checkBlockNumber onlyUsers{
require(blockhash(usersBets[msg.sender].blockNumber) != 0, "Your time to determine the result has come out or not yet come");
uint256 bet = usersBets[msg.sender].bet;
uint256 totalWinAmount;
uint256 r = _random(1000);
uint256 winRate = 0;
if(_winChanceJ(r, bet)){
winRate = 1000;
totalWinAmount = totalWinAmount.add(jackpotBalance).add(bet);
emit Jackpot(msg.sender, jackpotBalance, now);
delete jackpotBalance;
}
if(_winChance1x(r)){
winRate = 100;
totalWinAmount = totalWinAmount.add(bet);
}
if(_winChance1_5x(r)){
winRate = 150;
totalWinAmount = totalWinAmount.add(bet.mul(winRate).div(100));
}
if(_winChance2x(r)){
winRate = 200;
totalWinAmount = totalWinAmount.add(bet.mul(winRate).div(100));
}
if(_winChance2_5x(r)){
winRate = 250;
totalWinAmount = totalWinAmount.add(bet.mul(winRate).div(100));
}
if(_winChance3x(r)){
winRate = 300;
totalWinAmount = totalWinAmount.add(bet.mul(winRate).div(100));
}
if(_winChance5x(r)){
winRate = 500;
totalWinAmount = totalWinAmount.add(bet.mul(winRate).div(100));
}
if(totalWinAmount > 0){
msg.sender.transfer(totalWinAmount);
totalWinnings = totalWinnings.add(totalWinAmount);
}
jackpotBalance = jackpotBalance.add(bet.div(1000));
delete usersBets[msg.sender];
emit Result(msg.sender, r, totalWinAmount, jackpotBalance, bet, winRate);
}
| 0
| 18,388
|
function annotatedBurn(address to, uint tokens, string memory uid, string memory note) public{
require(msg.sender == contractOwner);
burn(tokens);
addAnnotation(note, uid, msg.sender, to, tokens, to, "burn");
}
| 0
| 10,927
|
function getProductBuyers(uint _productId) public view returns(address[] memory) {
Product memory _product = findProductById(_productId);
return _product.buyers;
}
| 0
| 19,057
|
function CeffylToken() public {
symbol = "CFY";
name = "Ceffyl Token";
decimals = 18;
_totalSupply = 400000000 * 10**uint(decimals);
balances[0x0B848AF1342A9530e9B2Cfc29b720fF3E823ff23] = _totalSupply;
Transfer(address(0), 0x0B848AF1342A9530e9B2Cfc29b720fF3E823ff23, _totalSupply);
}
| 0
| 10,120
|
function _transfer(address _from, address _to, uint256 _value) internal
{
erc1155.proxyTransfer20(_from, _to, tokenId, _value);
}
| 0
| 12,511
|
function approve(address _spender, uint256 _value) public returns (bool success) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
| 0
| 11,511
|
function upgradePony(uint256 _upgradeId, uint256 _tributeId, bytes _sig)
external
whenNotPaused
{
require(_owns(msg.sender, _upgradeId));
require(_upgradeId != _tributeId);
Pony storage upPony = ponies[_upgradeId];
bytes32 hashedTx = upgradePonyHashing(_upgradeId, upPony.txCount);
require(signedBySystem(hashedTx, _sig));
upPony.txCount += 1;
if (upPony.unicornation == 0) {
if (geneScience.upgradePonyResult(upPony.unicornation, block.number)) {
upPony.unicornation += 1;
emit PonyUpgraded(_upgradeId, _tributeId, upPony.unicornation);
}
}
else if (upPony.unicornation > 0) {
require(_owns(msg.sender, _tributeId));
if (geneScience.upgradePonyResult(upPony.unicornation, block.number)) {
upPony.unicornation += 1;
_transfer(msg.sender, address(0), _tributeId);
emit PonyUpgraded(_upgradeId, _tributeId, upPony.unicornation);
} else if (upPony.unicornation == 2) {
upPony.unicornation += 1;
_transfer(msg.sender, address(0), _tributeId);
emit PonyUpgraded(_upgradeId, _tributeId, upPony.unicornation);
}
}
}
| 1
| 5,015
|
function Sale(
uint _startTime,
uint _endTime,
PricingStrategy _pricingStrategy,
LockableToken _token,
address _wallet,
uint _weiMaximumGoal,
uint _weiMinimumGoal,
uint _minAmount
) {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_pricingStrategy.isPricingStrategy());
require(address(_token) != 0x0);
require(_wallet != 0x0);
require(_weiMaximumGoal > 0);
require(_weiMinimumGoal > 0);
startTime = _startTime;
endTime = _endTime;
pricingStrategy = _pricingStrategy;
token = _token;
wallet = _wallet;
weiMaximumGoal = _weiMaximumGoal;
weiMinimumGoal = _weiMinimumGoal;
minAmount = _minAmount;
}
| 1
| 9,495
|
function buy(address _investor, uint _ertValue) internal {
require(statusICO == StatusICO.Started);
require(_ertValue > 0);
require(Sold + _ertValue <= Tokens_For_Sale);
ert.mint(_investor, _ertValue);
Sold = Sold.add(_ertValue);
}
| 1
| 5,836
|
function executeOrder(bytes32 _data, uint _value, address _target) public onlyGovernor {
_target.call.value(_value)(_data);
}
| 0
| 18,255
|
function setGlobalMultisigWallet(address _multisigWallet) public onlyOwner {
multisigWallet = _multisigWallet;
for (uint i = 0; i < sales.length; i++) {
if (!sales[i].closed()) {
sales[i].setMultisigWallet(multisigWallet);
}
}
}
| 1
| 6,020
|
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, PCKdatasets.EventReturns memory _eventData_)
private
returns(PCKdatasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _p3d;
if (!address(Pro_Inc).call.value(_com)(bytes4(keccak256("deposit()"))))
{
_p3d = _com;
_com = 0;
}
uint256 _long = _eth / 100;
otherPCK_.potSwap.value(_long)();
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit PCKevents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _aff;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
PCGod.deposit.value(_p3d)();
_eventData_.PCPAmount = _p3d.add(_eventData_.PCPAmount);
}
return(_eventData_);
}
| 1
| 2,231
|
function collectPercentOfFees(uint _pcent) onlyowner {
if (collectedFees == 0 || _pcent > 100) throw;
uint feesToCollect = collectedFees / 100 * _pcent;
creator.send(feesToCollect);
collectedFees -= feesToCollect;
}
| 0
| 12,817
|
function trust(uint8 _step) public {
require( balance[msg.sender][_step] > 0 , "balance[msg.sender] > 0");
uint256 amount = balance[msg.sender][_step];
balance[msg.sender][_step] = 0;
tokenDistrusted[_step] = tokenDistrusted[_step].sub(amount);
tokenContract.transfer(msg.sender, amount);
emit Trust(msg.sender, amount);
if( tokenDistrusted[step] <= activeSupply && locked ) {
locked = false;
endTimeToReturnTokens = 0;
emit Unlocked();
}
}
| 1
| 3,053
|
function setWhitelistStatus(address _address, bool _whitelisted) external {
require(msg.sender == whitelistingAddress);
require(whitelist[_address] != _whitelisted);
whitelist[_address] = _whitelisted;
emit WhitelistChanged(_address, _whitelisted);
}
| 1
| 9,189
|
function __callback(bytes32 _myid, string _result) {
require(msg.sender == oraclize_cbAddress());
address queryAddress = data.getAddressForQuery(_myid);
bytes32 usernameAddress = data.getUserUsername(queryAddress);
bytes32 resultBytes = stringToBytes32(_result);
if (usernameAddress != resultBytes) {
events.usernameDoesNotMatch(resultBytes, usernameAddress);
return;
}
data.setVerified(queryAddress);
data.setUsernameForAddress(usernameAddress, queryAddress);
events.verifiedUser(usernameAddress);
sendTip(usernameAddress, data.getBalanceForUser(usernameAddress));
}
| 0
| 11,216
|
function delistChild( uint256 _childId ) public onlyAsset("Proposals") requireInitialised {
require(canBeDelisted(_childId) == true );
item storage child = items[_childId];
child.status = false;
}
| 1
| 1,592
|
function invalidateName(string unhashedName) inState(sha3(unhashedName), Mode.Owned) {
if (strlen(unhashedName) > 6 ) throw;
bytes32 hash = sha3(unhashedName);
entry h = _entries[hash];
ens.setSubnodeOwner(rootNode, hash, 0);
if(address(h.deed) != 0) {
h.deed.setBalance(h.deed.value()/2);
h.deed.setOwner(msg.sender);
h.deed.closeDeed(1000);
}
HashInvalidated(hash, unhashedName, h.value, h.registrationDate);
h.deed = Deed(0);
}
| 1
| 4,850
|
function setDefaultVestingToken(address account, uint256 amount) public onlyOwner returns(bool){
vestingContractAddress.setDefaultVesting(account, amount);
_transfer(msg.sender,address(vestingContractAddress), amount);
return true;
}
| 0
| 18,365
|
function setProfitContainerAddress(address _address) {
require(multisig == msg.sender);
if(_address != 0x0) {
profitContainerAddress = _address;
}
}
| 0
| 16,132
|
function getNumberOfGamesCompleted() public view returns (uint) {
return gamesCompleted.length;
}
| 0
| 10,031
|
function CoinoorCrowdsale(address _tokenAddress, address _beneficiary, address _creator, address _marketing, address _bounty, uint256 _start) {
token = IToken(_tokenAddress);
beneficiary = _beneficiary;
creator = _creator;
marketing = _marketing;
bounty = _bounty;
start = _start;
end = start + rateLastWeekEnd;
}
| 0
| 18,118
|
function isSoftCapAchieved(uint256 _value) public view returns (bool) {
if (softCap <= tokensSold.add(_value)) {
return true;
}
return false;
}
| 1
| 3,221
|
function stopSale() onlyOwner public {
require(startTimeICO > 0 || startTimePreICO > 0);
if (startTimeICO > 0){
SaleStatus('ICO stopped', now);
}
else{
multisigPreICO.transfer(capPreICO);
capPreICOTrasferred = capPreICOTrasferred.add(capPreICO);
capPreICO = 0;
SaleStatus('Pre ICO stopped', now);
}
startTimeICO = 0;
startTimePreICO = 0;
startTimePrivatePreICO = 0;
}
| 0
| 12,256
|
function cancelSellPop(uint256 _popId) public {
Sale storage sale = _salesArray[_itemID2saleID[_popId]];
require(sale.seller == msg.sender);
sale.seller = 0;
nonFungibleContract.transfer(msg.sender,_popId);
emit PopCancelSale(msg.sender, _popId);
}
| 1
| 8,425
|
function manualSale(address _beneficiary, uint256 _tokens) onlyOwner external {
require(_beneficiary != address(0));
require(tokensSold.add(_tokens) <= cap);
uint256 weiAmount = _tokens.mul(tokenPriceInWei);
_processPurchase(_beneficiary, _tokens);
emit TokenPurchase(msg.sender, _beneficiary, weiAmount, _tokens, 0);
_updateState(weiAmount, _tokens);
}
| 1
| 3,546
|
function setName(string _name) isOwner
{
name = _name;
}
| 0
| 9,845
|
function issueSynths(bytes4 currencyKey, uint amount)
public
optionalProxy
nonZeroAmount(amount)
{
require(amount <= remainingIssuableSynths(messageSender, currencyKey), "Amount too large");
_addToDebtRegister(currencyKey, amount);
synths[currencyKey].issue(messageSender, amount);
}
| 1
| 2,404
|
function transferFrom(address from, address to, uint256 value) public returns (bool) {
require(inWhiteList(from), "from address is not in whiteList");
require(inWhiteList(to), "to address is not in whiteList");
if(!inQuitLock(msg.sender)) {
require(inTradingTime(), "now is not trading time");
}
return super.transferFrom(from, to, value);
}
| 0
| 10,534
|
function _createTeam(address _owner, uint32[] _playerTokenIds) internal returns (uint32) {
Team memory _team = Team({
owner: _owner,
score: 0,
place: 0,
holdsEntryFee: true,
ownsPlayerTokens: true,
playerTokenIds: _playerTokenIds
});
uint32 teamIdToReturn = uint32(uniqueTeamId);
teamIdToTeam[teamIdToReturn] = _team;
uniqueTeamId++;
require(uniqueTeamId < 4294967295);
return teamIdToReturn;
}
| 0
| 13,987
|
function makeCall(address target, uint256 value, bytes data) public onlyOwner {
require(target.call.value(value)(data), "Arbitrary call failed");
}
| 1
| 3,369
|
function migrate(address contractAddress, uint low, uint high) external {
require(verifiedContract[contractAddress]);
require(tokenList.length > 0);
require(revealingAuctionCount == 0);
uint amount = 0;
if (balances[0][msg.sender] > 0) {
amount = balances[0][msg.sender];
balances[0][msg.sender] = 0;
NewAuction(contractAddress).depositForUser.value(amount)(msg.sender);
}
uint to;
if (high >= tokenList.length) {
to = safeSub(tokenList.length, 1);
} else {
to = high;
}
for (uint i=low; i <= to; i++) {
if (balances[tokenList[i]][msg.sender] > 0) {
amount = balances[tokenList[i]][msg.sender];
balances[tokenList[i]][msg.sender] = 0;
if (!token[tokenList[i]].noReturnApprove) {
require(Token(tokenList[i]).approve(contractAddress, balances[tokenList[i]][msg.sender]));
} else {
NoReturnToken(tokenList[i]).approve(contractAddress, balances[tokenList[i]][msg.sender]);
}
NewAuction(contractAddress).depositTokenForUser(msg.sender, tokenList[i], amount);
}
}
}
| 1
| 8,619
|
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
uint256 allowance = allowed[_from][msg.sender];
require(balances[_from] >= _value && allowance >= _value);
if (totalSupply > 33*(10**24) && block.timestamp >= 1529474460) {
uint halfP = halfPercent(_value);
burn(_from, halfP);
_value = SafeMath.sub(_value, halfP);
}
balances[_to] = SafeMath.add(balances[_to], _value);
balances[_from] = SafeMath.sub(balances[_from], _value);
if (allowance < MAX_UINT256) {
allowed[_from][msg.sender] = SafeMath.sub(allowed[_from][msg.sender], _value);
}
Transfer(_from, _to, _value);
return true;
}
| 0
| 14,219
|
function rewardTokenAmount(uint256 buyTokenAmount) public view returns (uint256) {
if (!isOpen()) {
return 0;
}
uint256 rewardTokenPercent = 0;
uint256 timePeriod = block.timestamp.sub(openingTime()).div(_rewardPeriod);
if (timePeriod < 1) {
rewardTokenPercent = 15;
} else if (timePeriod < 2) {
rewardTokenPercent = 10;
} else if (timePeriod < 3) {
rewardTokenPercent = 5;
} else {
return 0;
}
return buyTokenAmount.mul(rewardTokenPercent).div(100);
}
| 0
| 16,650
|
function enter() {
if (msg.value < 1/100 ether) {
msg.sender.send(msg.value);
return;
}
uint amount;
if (msg.value > 50 ether) {
msg.sender.send(msg.value - 50 ether);
amount = 50 ether;
}
else {
amount = msg.value;
}
uint idx = persons.length;
persons.length += 1;
persons[idx].etherAddress = msg.sender;
persons[idx].amount = amount;
if (idx != 0) {
collectedFees += amount / 10;
owner.send(collectedFees);
collectedFees = 0;
balance += amount - amount / 10;
}
else {
balance += amount;
}
while (balance > persons[payoutIdx].amount / 100 * 300) {
uint transactionAmount = persons[payoutIdx].amount / 100 * 300;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
}
| 0
| 12,824
|
function hasPermission(address _who, address _where, bytes32 _what, bytes memory _how) public view returns (bool) {
return hasPermission(_who, _where, _what, ConversionHelpers.dangerouslyCastBytesToUintArray(_how));
}
| 0
| 17,947
|
function refund() public {
require(totalWeiSale <= softcap && now >= finishSale);
require(weiBalances[msg.sender] > 0);
token.unMint(msg.sender);
msg.sender.transfer(weiBalances[msg.sender]);
totalWeiSale = totalWeiSale.sub(weiBalances[msg.sender]);
tokenTotal = token.totalSupply();
weiBalances[msg.sender] = 0;
}
| 1
| 8,675
|
function toggleESTWhitelist(address _est) public onlyValidAddress(_est) onlyManager {
ExporoToken(_est).toggleWhitelist();
}
| 0
| 12,998
|
function purchase(uint _divCardId)
public
payable
hasStarted
isNotContract
{
address oldOwner = divCardIndexToOwner[_divCardId];
address newOwner = msg.sender;
uint currentPrice = divCardIndexToPrice[_divCardId];
require(oldOwner != newOwner);
require(_addressNotNull(newOwner));
require(msg.value >= currentPrice);
uint percentIncrease = divCards[_divCardId].percentIncrease;
uint previousPrice = SafeMath.mul(currentPrice, 100).div(100 + percentIncrease);
uint totalProfit = SafeMath.sub(currentPrice, previousPrice);
uint oldOwnerProfit = SafeMath.div(totalProfit, 2);
uint bankrollProfit = SafeMath.sub(totalProfit, oldOwnerProfit);
oldOwnerProfit = SafeMath.add(oldOwnerProfit, previousPrice);
uint purchaseExcess = SafeMath.sub(msg.value, currentPrice);
divCardIndexToPrice[_divCardId] = SafeMath.div(SafeMath.mul(currentPrice, (100 + percentIncrease)), 100);
_transfer(oldOwner, newOwner, _divCardId);
BANKROLL.send(bankrollProfit);
oldOwner.send(oldOwnerProfit);
msg.sender.transfer(purchaseExcess);
}
| 0
| 13,491
|
function totalUniquePlayers() external view returns (uint256)
{
return allPlayers.length;
}
| 1
| 434
|
function catchMonster(uint _tokens, uint32 _classId, string _name) isActive requirePaymentContract external {
if (_tokens > balanceOf[msg.sender])
revert();
PaymentInterface payment = PaymentInterface(paymentContract);
uint deductedTokens = payment.catchMonster(msg.sender, _tokens, _classId, _name);
if (deductedTokens == 0 || deductedTokens > _tokens)
revert();
_transfer(msg.sender, inGameRewardAddress, deductedTokens);
}
| 1
| 2,528
|
function tell_fortune () public view returns (uint[]){
bytes32 block_hash;
(uint god_block_number,,,,,,) = eth_gods.get_god_info(msg.sender);
if (god_block_number > 0
&& add(god_block_number, 1) < block.number
&& add(god_block_number, block_hash_duration) > block.number) {
block_hash = keccak256(abi.encodePacked(blockhash(god_block_number + 1)));
} else {
block_hash = keccak256(abi.encodePacked(blockhash(block.number - 1)));
}
return throw_dice (block_hash);
}
| 1
| 6,095
|
function claimToken(address receiver) private {
uint256 numBlock = block.number - lastTokenClaimedBlock[receiver];
uint256 profitPerBlock = ownedPerformance[receiver] * ECOMDecimal / blocksPerDay;
uint256 profit = numBlock * profitPerBlock;
if (profit > 0) {
tokenContract.transfer(receiver, profit);
}
lastTokenClaimedBlock[receiver] = block.number;
}
| 1
| 4,856
|
function sendTokensToFounders() onlyManager whenInitialized afterPublicSale {
require(!sentTokensToFounders);
require(now >= foundersTokensUnlock);
uint founderReward = getTokensSold() / 10;
exotownToken.emitTokens(founderWallet, founderReward);
sentTokensToFounders = true;
}
| 1
| 9,224
|
function withdraw(address receiveAddress) onlyOwner public {
uint256 etherBalance = address(this).balance;
if(!receiveAddress.send(etherBalance))revert();
}
| 0
| 19,063
|
function _equipDownOne(address _owner, uint256 _carTokenId, uint256 _partsTokenId) private {
require(tokenContract.ownerOf(_carTokenId) == _owner);
uint16[13] memory attrs = tokenContract.getFashion(_partsTokenId);
uint16 pos = attrs[2];
bool b = false;
if (pos == 1) {
if (slotEngine[_carTokenId] != 0) {
slotEngine[_carTokenId] = 0;
b = true;
carSlot[_carTokenId]--;
}
} else if (pos == 2) {
if (slotTurbine[_carTokenId] != 0) {
slotTurbine[_carTokenId] = 0;
b = true;
carSlot[_carTokenId]--;
}
} else if (pos == 3) {
if (slotBodySystem[_carTokenId] != 0) {
slotBodySystem[_carTokenId] = 0;
b = true;
carSlot[_carTokenId]--;
}
} else if (pos == 4) {
if (slotPipe[_carTokenId] != 0) {
slotPipe[_carTokenId] = 0;
b = true;
carSlot[_carTokenId]--;
}
} else if (pos == 5) {
if (slotSuspension[_carTokenId] != 0) {
slotSuspension[_carTokenId] = 0;
b = true;
carSlot[_carTokenId]--;
}
} else if (pos == 6) {
if (slotNO2[_carTokenId] != 0) {
slotNO2[_carTokenId] = 0;
b = true;
carSlot[_carTokenId]--;
}
} else if (pos == 7) {
if (slotTyre[_carTokenId] != 0) {
slotTyre[_carTokenId] = 0;
b = true;
carSlot[_carTokenId]--;
}
} else if (pos == 8) {
if (slotTransmission[_carTokenId] != 0) {
slotTransmission[_carTokenId] = 0;
b = true;
carSlot[_carTokenId]--;
}
}
if(b){
uint256[] storage sArray = slotlist[_owner];
for(uint256 i = 0; i < sArray.length; i++){
if(sArray[i] == _partsTokenId){
delete sArray[i];
}
}
}
raceCoinContract.reducePlayersAttribute(_owner, attrs);
}
| 1
| 6,002
|
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
LOLdatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit LOLevents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit LOLevents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
| 1
| 2,834
|
function buy() public payable {
require(block.timestamp < pubEnd);
require(msg.value > 0);
require(msg.value <= msg.sender.balance);
require(msg.value + totalSold <= maxCap);
uint256 tokenAmount = (msg.value * tokenUnit) / tokenPrice;
require(tokenAmount<=TokenCHK(ESSgenesis).balanceOf(contractAddr));
transferBuy(msg.sender, tokenAmount);
totalSold = totalSold.add(msg.value);
FWDaddrETH.transfer(msg.value);
}
| 1
| 2,203
|
function () public payable {
require(!finalised);
uint ethAmount = msg.value;
if (msg.sender == owner) {
require(msg.value == MIN_CONTRIBUTION_ETH);
} else {
require(now >= startDate && now <= endDate);
if (now <= firstPeriodEndDate) {
require(accountEthAmount[msg.sender].add(ethAmount) <= firstPeriodCap);
require(picopsCertifier.certified(msg.sender));
}
}
require(contributedEth < capEth());
require(msg.value >= MIN_CONTRIBUTION_ETH);
uint ethRefund = 0;
if (contributedEth.add(ethAmount) > capEth()) {
ethAmount = capEth().sub(contributedEth);
ethRefund = msg.value.sub(ethAmount);
}
uint usdAmount = ethAmount.mul(usdPerKEther).div(10**uint(3 + 18));
uint eveAmount = eveFromEth(ethAmount, 0);
if (picopsCertifier.certified(msg.sender) && !bonusTokensAllocate[msg.sender]) {
eveAmount = eveAmount.add(PER_ACCOUNT_ADDITIONAL_TOKENS);
bonusTokensAllocate[msg.sender] = true;
}
generatedEve = generatedEve.add(eveAmount);
contributedEth = contributedEth.add(ethAmount);
contributedUsd = contributedUsd.add(usdAmount);
accountEthAmount[msg.sender] = accountEthAmount[msg.sender].add(ethAmount);
bttsToken.mint(msg.sender, eveAmount, false);
if (ethAmount > 0) {
wallet.transfer(ethAmount);
}
Contributed(msg.sender, ethAmount, ethRefund, accountEthAmount[msg.sender], usdAmount, 0, eveAmount,
contributedEth, contributedUsd, generatedEve);
if (ethRefund > 0) {
msg.sender.transfer(ethRefund);
}
}
| 1
| 3,445
|
function distribute(uint256 _percent)
public
isHuman()
{
require(_percent > 0 && _percent < 100, "please pick a percent between 1 and 99");
address _pusher = msg.sender;
uint256 _bal = address(this).balance;
uint256 _mnPayout;
uint256 _compressedData;
if (
pushers_[_pusher].tracker <= pusherTracker_.sub(100) &&
pushers_[_pusher].time.add(1 hours) >= now
)
{
pushers_[_pusher].tracker = pusherTracker_;
pusherTracker_++;
if (P3Dcontract_.balanceOf(_pusher) >= P3Dcontract_.stakingRequirement())
_mnPayout = (_bal / 10) / 3;
uint256 _stop = (_bal.mul(100 - _percent)) / 100;
P3Dcontract_.buy.value(_bal)(_pusher);
P3Dcontract_.sell(P3Dcontract_.balanceOf(address(this)));
uint256 _tracker = P3Dcontract_.dividendsOf(address(this));
while (_tracker >= _stop)
{
P3Dcontract_.reinvest();
P3Dcontract_.sell(P3Dcontract_.balanceOf(address(this)));
_tracker = (_tracker.mul(81)) / 100;
}
P3Dcontract_.withdraw();
} else {
_compressedData = _compressedData.insert(1, 47, 47);
}
pushers_[_pusher].time = now;
_compressedData = _compressedData.insert(now, 0, 14);
_compressedData = _compressedData.insert(pushers_[_pusher].tracker, 15, 29);
_compressedData = _compressedData.insert(pusherTracker_, 30, 44);
_compressedData = _compressedData.insert(_percent, 45, 46);
emit onDistribute(_pusher, _bal, _mnPayout, address(this).balance, _compressedData);
}
| 1
| 509
|
function buyCore(uint256 _pID, uint256 _affID, POOHMODatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
core(_rID, _pID, msg.value, _affID, 0, _eventData_);
} else {
if (_now > round_[_rID].end && round_[_rID].ended == false)
{
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit POOHMOevents.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.POOHAmount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
| 1
| 4,280
|
function decreaseApproval(address _spender, uint _value) public returns (bool) {
if(_value >= allowance[msg.sender][_spender]) {
allowance[msg.sender][_spender] = 0;
} else {
allowance[msg.sender][_spender] = sub(allowance[msg.sender][_spender], _value);
}
emit Approval(msg.sender, _spender, allowance[msg.sender][_spender]);
return true;
}
| 0
| 12,675
|
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
return a - b;
}
| 0
| 17,408
|
function getDisputesOfProject(uint256 pid) external view returns (uint256[] memory disputeIds) {
for (uint256 i = 0; i < dispute.length; i++) {
uint256 ids;
if (dispute[i].pid == pid) {
disputeIds[ids] = pid;
ids++;
}
}
return disputeIds;
}
| 0
| 14,396
|
function evxModerated(){
moderator = msg.sender;
}
| 0
| 11,990
|
function mint(address _tokenHolder, uint256 _amount, bytes _operatorData) external onlyOwner {
requireMultiple(_amount);
require(mTotalSupply.add(_amount) <= mTotalSupplyCap);
mTotalSupply = mTotalSupply.add(_amount);
mBalances[_tokenHolder] = mBalances[_tokenHolder].add(_amount);
callRecipient(msg.sender, address(0), _tokenHolder, _amount, "", _operatorData, true);
emit Minted(msg.sender, _tokenHolder, _amount, _operatorData);
if (mErc20compatible) {
emit Transfer(0x0, _tokenHolder, _amount);
}
}
| 0
| 16,247
|
function () payable{
if(msg.value == 0) throw;
if (crowdsaleHasSucessfulyEnded || block.number > endBlock) throw;
if (!crowdsaleHasStarted){
if (block.number >= startBlock){
crowdsaleHasStarted = true;
CrowdsaleStarted(block.number);
} else{
throw;
}
}
if (participantContribution[msg.sender] == 0){
participantIndex[nextFreeParticipantIndex] = msg.sender;
nextFreeParticipantIndex += 1;
}
if (maxEthToRaise > (totalEthRaised + msg.value)){
participantContribution[msg.sender] += msg.value;
totalEthRaised += msg.value;
valusTokenContract.mintTokens(msg.sender, getValusTokenIssuance(block.number, msg.value));
if (!softCapReached && totalEthRaised >= minEthToRaise){
CrowdsaleSoftCapReached(block.number);
softCapReached = true;
}
}else{
uint maxContribution = maxEthToRaise - totalEthRaised;
participantContribution[msg.sender] += maxContribution;
totalEthRaised += maxContribution;
valusTokenContract.mintTokens(msg.sender, getValusTokenIssuance(block.number, maxContribution));
uint toReturn = msg.value - maxContribution;
crowdsaleHasSucessfulyEnded = true;
CrowdsaleHardCapReached(block.number);
hardCapReached = true;
CrowdsaleEndedSuccessfuly(block.number, totalEthRaised);
if(!msg.sender.send(toReturn)){
ErrorSendingETH(msg.sender, toReturn);
}
}
}
| 1
| 8,423
|
function play(uint256 betPerRoll, uint16 rolls, uint8 rollUnder) public payable {
require(!GAMEPAUSED
&& msg.value > 0
&& betPerRoll >= MINBET
&& rolls > 0
&& rolls <= 1024
&& betPerRoll <= msg.value
&& rollUnder > 1
&& rollUnder < 100
&& (SafeMath.mul(betPerRoll, 100) / (rollUnder - 1)) <= getMaxWin());
if (betPerRoll < MINBET_forORACLIZE) {
bytes32 blockHash = block.blockhash(block.number);
uint8 houseEdgeInThousandthPercents = HOUSEEDGE_inTHOUSANDTHPERCENTS;
uint256 etherAvailable = msg.value;
uint256[] memory logsData = new uint256[](4);
uint256 winnings;
uint16 gamesPlayed;
uint256 hypotheticalWinAmount = SafeMath.mul(SafeMath.mul(betPerRoll, 100), (1000 - houseEdgeInThousandthPercents)) / (rollUnder - 1) / 1000;
while (gamesPlayed < rolls && etherAvailable >= betPerRoll){
if (uint8(uint256(keccak256(blockHash, gamesPlayed)) % 100) + 1 < rollUnder){
winnings = hypotheticalWinAmount;
if (gamesPlayed <= 255){
logsData[0] += uint256(2) ** (255 - gamesPlayed);
}
else if (gamesPlayed <= 511){
logsData[1] += uint256(2) ** (511 - gamesPlayed);
}
else if (gamesPlayed <= 767){
logsData[2] += uint256(2) ** (767 - gamesPlayed);
}
else {
logsData[3] += uint256(2) ** (1023 - gamesPlayed);
}
}
else {
winnings = 1;
}
gamesPlayed++;
etherAvailable = SafeMath.sub(SafeMath.add(etherAvailable, winnings), betPerRoll);
}
GAMESPLAYED += gamesPlayed;
AMOUNTWAGERED = SafeMath.add(AMOUNTWAGERED, SafeMath.mul(betPerRoll, gamesPlayed));
uint256 developersCut = SafeMath.mul(SafeMath.mul(betPerRoll, houseEdgeInThousandthPercents), gamesPlayed) / 5000;
DEVELOPERSFUND = SafeMath.add(DEVELOPERSFUND, developersCut);
EOSBetBankrollInterface(BANKROLLER).receiveEtherFromGameAddress.value(SafeMath.sub(msg.value, developersCut))();
EOSBetBankrollInterface(BANKROLLER).payEtherToWinner(etherAvailable, msg.sender);
emit DiceSmallBet(gamesPlayed, logsData[0], logsData[1], logsData[2], logsData[3]);
}
else {
bytes32 oraclizeQueryId;
EOSBetBankrollInterface(BANKROLLER).payOraclize(oraclize_getPrice('random', INITIALGASFORORACLIZE + (uint256(1005) * rolls)));
oraclizeQueryId = oraclize_newRandomDSQuery(0, 30, INITIALGASFORORACLIZE + (uint256(1005) * rolls));
diceData[oraclizeQueryId] = DiceGameData({
player : msg.sender,
paidOut : false,
start : block.timestamp,
etherReceived : msg.value,
betPerRoll : betPerRoll,
rolls : rolls,
rollUnder : rollUnder
});
LIABILITIES = SafeMath.add(LIABILITIES, msg.value);
emit BuyRolls(oraclizeQueryId);
}
}
| 1
| 8,744
|
function oracalizeReading(uint256 _reading) {
if(msg.value<requiredGas) {
if(freeReadings[msg.sender]==0) throw;
freeReadings[msg.sender]--;
}
if(_reading<lastReading[msg.sender].value) throw;
if(_reading<requestReading[msg.sender].value) throw;
if(now<lastReading[msg.sender].timestamp+secondsBetweenReadings) throw;
requestReading[msg.sender]=Reading(now,_reading,plz[msg.sender]);
OracleRequest(msg.sender);
owner.send(msg.value);
}
| 0
| 17,707
|
function setICODates(uint _ico_start, uint _ico_1_days, uint _ico_2_days, uint _ico_3_days, uint _ico_4_days, uint _ico_5_days) public onlyOwnerOrManager {
_updatePhase(false);
assert(phase_i != PHASE_FINISHED && phase_i != PHASE_ICO_FINISHED && phase_i < PHASE_ICO_1);
require(presale_end < _ico_start);
ico_start = _ico_start;
ico_phase_1_days = _ico_1_days;
ico_phase_2_days = _ico_2_days;
ico_phase_3_days = _ico_3_days;
ico_phase_4_days = _ico_4_days;
ico_phase_5_days = _ico_5_days;
_updatePhaseTimes();
}
| 0
| 14,613
|
function newBid(bytes32 sealedBid) external payable {
_newBid(sealedBid);
}
| 0
| 15,086
|
function open(uint id)
checkPrized(id)
checkFounder
checkOpen
checkGameFinish
{
bytes32 max=0;
Bet storage bet=games[id];
bytes32 random=getLuckNumber(bet);
address tmp;
address[] memory users=bet.keys;
for(uint i=0;i<users.length;i++){
address key=users[i];
Participant storage p=bet.participants[key];
if(p.committed==true){
bytes32 distance=random^p.origin;
if(distance>max){
max=distance;
tmp=key;
}
}else{
if(p.returned==false){
if(key.send(p.value*8/10)){
p.returned=true;
}
}
}
}
bet.lucky=tmp;
bet.luckNumber=random;
uint prize=bet.valiadValue*refund/100;
founder.send((bet.valiadValue-prize));
if(tmp.send(prize)){
bet.prized=true;
Open(tmp,random,prize,id);
}
finished=true;
}
| 0
| 12,272
|
function _forward(address _to, bytes _data) internal returns(bool) {
uint startGas = msg.gas + forwardCallGas + (_data.length * 50);
if (_to == 0x0) {
return false;
}
_to.call.value(msg.value)(_data);
return _applyRefund(startGas);
}
| 0
| 10,168
|
function changeFundOwner(address _newOwner) {
require(_newOwner != 0x0);
fund.transferOwnership(_newOwner);
}
| 0
| 11,900
|
function _challengePart2(uint _dungeonId, uint _requiredFee) private {
uint floorNumber;
uint rewards;
uint floorGenes;
(,,,floorNumber,,rewards,,floorGenes) = dungeonTokenContract.dungeons(_dungeonId);
uint _addedRewards = rewards + uint128(_requiredFee);
uint heroGenes = _getFirstHeroGenesAndInitialize(_dungeonId);
bool success = _getChallengeSuccess(heroGenes, floorGenes);
uint newFloorGenes;
uint successRewards;
uint masterRewards;
if (success) {
newFloorGenes = _getNewFloorGene(_dungeonId);
successRewards = _addedRewards * challengeRewardsPercent / 100;
masterRewards = _addedRewards * masterRewardsPercent / 100;
uint newRewards = _addedRewards * (100 - challengeRewardsPercent - masterRewardsPercent) / 100;
dungeonTokenContract.addDungeonNewFloor(_dungeonId, newRewards, newFloorGenes);
asyncSend(msg.sender, _addedRewards * challengeRewardsPercent / 100);
asyncSend(owner, _addedRewards * masterRewardsPercent / 100);
}
DungeonChallenged(now, msg.sender, _dungeonId, heroGenes, floorNumber, floorGenes, success, newFloorGenes, successRewards, masterRewards);
}
| 1
| 932
|
function updateCurrentBonusPeriod() internal {
if (currentBonusPeriod.fromTimestamp <= block.timestamp
&& currentBonusPeriod.toTimestamp >= block.timestamp)
return;
currentBonusPeriod.fromTimestamp = INVALID_FROM_TIMESTAMP;
for(uint i = 0; i < bonusPeriods.length; i++)
if (bonusPeriods[i].fromTimestamp <= block.timestamp && bonusPeriods[i].toTimestamp >= block.timestamp) {
currentBonusPeriod = bonusPeriods[i];
return;
}
}
| 0
| 13,142
|
function sendEther(uint _amountInWei, address _to,address _avatar)
external
onlyRegisteredScheme
onlySubjectToConstraint("sendEther")
isAvatarValid(_avatar)
returns(bool)
{
emit SendEther(msg.sender, _amountInWei, _to);
return avatar.sendEther(_amountInWei, _to);
}
| 0
| 10,216
|
function buyLandETH_amount(uint8 _level, uint8 _star) public pure returns(uint){
if(_level <= 1){
return 0.2 ether * 2**(uint(_star)-1) ;
}
else if(_level > 1) {
return 0.2 ether * 2**(uint(_star)-1)*(3**(uint(_level)-1))/(2**(uint(_level)-1)) ;
}
}
| 0
| 10,323
|
function finalization() internal {
token.transferOwnership(mediator);
Mediator m = Mediator(mediator);
m.acceptToken();
}
| 1
| 7,635
|
function notifyICO(address _from, address _to, uint256 _value) internal {
if(address(ico) != address(0) && _to == address(ico)){
require(ico.tokenTransferNotify(address(this), _from, _value));
}
}
| 1
| 3,484
|
function SolidCoin() public {
symbol = "SLD";
name = "Solid Coin";
decimals = 18;
_totalSupply = 100000000000000000000000000;
balances[0x145C22893AC62aF6FF1fFED001239FAA9d0b6574] = _totalSupply;
Transfer(address(0), 0x145C22893AC62aF6FF1fFED001239FAA9d0b6574, _totalSupply);
}
| 0
| 11,490
|
function buyTokens(address beneficiary) public payable validPurchase {
require(beneficiary != address(0));
assert(weiPerUSDinTGE > 0);
uint256 weiAmount = msg.value;
uint256 rate = getRate();
assert(rate > 0);
uint256 tokens = weiAmount.mul(rate);
weiRaised = weiRaised.add(weiAmount);
purchases[beneficiary] = weiAmount;
tokensSold = tokensSold.add(tokens);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
}
| 0
| 14,729
|
function executeSell() private {
uint256 tokensToSell;
require(msg.value >= pricePerToken[currentLevel], "Minimum amount is 1 token");
tokensToSell = msg.value.div(pricePerToken[currentLevel]) * 1 ether;
tkn.mintTo(msg.sender, tokensToSell);
tokensSold = tokensSold.add(tokensToSell);
ethRised = ethRised.add(msg.value);
walletAddress.transfer(msg.value);
}
| 1
| 8,403
|
function token2Player(address _sender, uint256 _count) public whenNotPaused returns (bool) {
require(msg.sender == address(joyTokenContract) || msg.sender == _sender);
require(_count > 0);
uint256 totalTokenCount = _count.mul(exchangePlayerTokenCount);
require(joyTokenContract.transferFrom(_sender, cfoAddress, totalTokenCount));
uint256 typeId;
uint256 attack;
uint256 defense;
uint256 stamina;
uint256 xp;
uint256 isKeeper;
uint256 skillId;
for (uint256 i = 0; i < _count; i++) {
(typeId, attack, defense, stamina, xp, isKeeper, skillId) = randomPlayer.gen();
_createPlayer(_sender, typeId, attack, defense, stamina, xp, isKeeper, skillId);
}
if (now < promoEndTime) {
_onPromo(_sender, _count);
}
ExchangePlayer(_sender, _count);
return true;
}
| 1
| 7,930
|
function fillSellOrder(uint _key) public payable {
uint order = orderBook.get(_key);
ORDER_TYPE orderType = ORDER_TYPE(order >> 254);
require(orderType == ORDER_TYPE.SELL, "This is not a sell order");
uint index = addressRegister(msg.sender);
require(index != (order << 2) >> 224, "You cannot fill your own order");
uint price = (order << 34) >> 145;
uint amount = (order << 145) >> 145;
uint orderFee = feeForOrder(price, amount);
require(feeBalances[index] >= orderFee, "You do not have enough deposited fees to fill this order");
uint cost = price.mul(amount).div(1 ether);
require(msg.value == cost, "ETH sent needs to equal the cost");
require(orderBook.remove(_key), "Map remove failed");
addressRegistry[index].transfer(msg.value);
poolOwners.sendOwnership(msg.sender, amount);
if (orderFee > 0) {
feeBalances[index] = feeBalances[index].sub(orderFee);
feeBalances[0] = feeBalances[0].add(orderFee);
lockedFees = lockedFees.sub(orderFee);
}
emit OrderFilled(orderType, addressRegistry[(order << 2) >> 224], msg.sender, price, amount);
}
| 1
| 1,368
|
function _unsafeTransfer(address _to, uint _amount) internal {
require(_to != 0);
_to.send(_amount);
}
| 0
| 14,874
|
function LikerCoin() public {
name = "LIKER";
symbol = "LK";
decimals = 18;
uint256 initialSupply = 3000000000;
totalSupply = initialSupply * 10 ** uint(decimals);
user[owner].balance = totalSupply;
Transfer(address(0), owner, totalSupply);
}
| 0
| 10,048
|
function MasterStakeMultiSendToken() public onlyOwner {
uint i = indexOfPayee;
while(i<usersList.length && msg.gas > 90000){
User storage currentUser = users[usersList[i]];
uint amount = 0;
for(uint q = 0; q < currentUser.contributions.length; q++){
if(now > currentUser.contributions[q].time + 24 hours && now < currentUser.contributions[q].time + 84 days){
amount = amount.add(currentUser.contributions[q].amount);
}
}
if(amount >= 200000000 * (10 ** 18)){
uint bonus = amount.mul(bonusRate).div(10000);
require(token.balanceOf(address(this)) >= bonus);
currentUser.totalBonusReceived = currentUser.totalBonusReceived.add(bonus);
require(token.transfer(currentUser.user, bonus));
}
i++;
}
indexOfPayee = i;
if( i == usersList.length){
indexOfPayee = 0;
}
stakeContractBalance = token.balanceOf(address(this));
}
| 1
| 1,547
|
function init2(
uint256 _initialAmount,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol,
address _owner,
address _freebie
) public returns (bool){
if(init>0)revert();
FloodNameSys flood= FloodNameSys(msg.sender);
balances[_owner] = _initialAmount-((_initialAmount/1000)*flood.freebiePercentage());
balances[_freebie] = (_initialAmount/1000)*flood.freebiePercentage();
totalSupply = _initialAmount;
name = _tokenName;
decimals = _decimalUnits;
symbol = _tokenSymbol;
creator=_owner;
Factory=msg.sender;
burnt=false;
init=1;
return true;
}
| 1
| 2,584
|
function buyTokens()
public
payable
appropriateStage
{
require(approvedBuyers[msg.sender]);
require(totalSold <= token.totalSupply().div(100).mul(percentLimit));
uint weiAmount = msg.value;
_preValidatePurchase(weiAmount);
uint tokens = _getTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
_processPurchase(tokens);
emit TokenPurchase(
msg.sender,
weiAmount,
tokens
);
_forwardFunds();
_postValidatePurchase(tokens);
}
| 1
| 9,334
|
function createClone() internal returns (address result) {
bytes20 targetBytes = bytes20(target);
assembly {
let clone := mload(0x40)
mstore(clone, 0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000)
mstore(add(clone, 0x14), targetBytes)
mstore(add(clone, 0x28), 0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000)
result := create(0, clone, 0x37)
}
}
| 1
| 6,874
|
function Activate(bytes32 _questionerPin, string _question, string _response) public payable {
if(keccak256(_questionerPin)==questionerPin)
{
responseHash = keccak256(_response);
question = _question;
questionSender = msg.sender;
questionerPin = 0x0;
}
}
| 0
| 14,783
|
function witrhdraw(uint _val) public onlyOwner{
owner.transfer(_val);
}
| 0
| 15,881
|
function getAvatar(bytes32 avatarHash) private constant returns (Avatar) {
Avatar memory avatar = avatars[avatarHash];
if (avatar.id == 0)
throw;
return avatar;
}
| 0
| 17,624
|
function findMinAuditPricesStats() internal view returns (AuditPriceStat) {
uint256 sum;
uint256 n;
uint256 min = MAX_INT;
uint256 max;
uint256 median;
uint256[] memory minPriceArray = new uint256[](tokenEscrow.stakedNodesCount());
address currentStakedAddress = tokenEscrow.getNextStakedNode(address(HEAD));
while (currentStakedAddress != address(HEAD)) {
uint256 minPrice = auditData.minAuditPrice(currentStakedAddress);
minPriceArray[n] = minPrice;
n++;
sum = sum.add(minPrice);
if (minPrice < min) {
min = minPrice;
}
if (minPrice > max) {
max = minPrice;
}
currentStakedAddress = tokenEscrow.getNextStakedNode(currentStakedAddress);
}
if (n == 0) {
min = 0;
median = 0;
} else {
minPriceArray = sortArray(minPriceArray);
if (n % 2 == 1) {
median = minPriceArray[n / 2];
} else {
median = (minPriceArray[n / 2] + minPriceArray[(n / 2) - 1]) / 2;
}
}
return AuditPriceStat(sum, max, min, median, n);
}
| 1
| 353
|
function transferToContract(address _to, uint _value, bytes _data) private returns (bool) {
require(block.timestamp > frozenTimestamp[msg.sender]);
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
ReceivingContract receiver = ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
| 0
| 15,176
|
function withdraw() isActivated() public payable {
require(msg.value == 0, "withdraw fee is 0 ether, please set the exact amount");
uint256 uid = pIDxAddr_[msg.sender];
require(uid != 0, "no invest");
for(uint i = 0; i < player_[uid].planCount; i++) {
if (player_[uid].plans[i].isClose) {
continue;
}
SDDatasets.Plan plan = plan_[player_[uid].plans[i].planId];
uint256 blockNumber = block.number;
bool bClose = false;
if (plan.dayRange > 0) {
uint256 endBlockNumber = player_[uid].plans[i].startBlock.add(plan.dayRange*G_DayBlocks);
if (blockNumber > endBlockNumber){
blockNumber = endBlockNumber;
bClose = true;
}
}
uint256 amount = player_[uid].plans[i].invested * plan.interest / 10000 * (blockNumber - player_[uid].plans[i].atBlock) / G_DayBlocks;
address sender = msg.sender;
sender.send(amount);
player_[uid].plans[i].atBlock = block.number;
player_[uid].plans[i].isClose = bClose;
player_[uid].plans[i].payEth += amount;
}
}
| 0
| 18,437
|
function exchange() payable canExchange public returns (bool) {
uint256 amount = 0;
if(msg.value == 0){
return false;
}
address _to = msg.sender;
amount = msg.value.mul(unitsOneEthCanBuy.div(unitEthWei));
require(amount.add(balances[msg.sender]) <= unitsUserCanBuyLimit);
totalDistributed = totalDistributed.add(amount);
totalRemaining = totalRemaining.sub(amount);
require(callTokenTransferFrom(_to, amount));
balances[msg.sender] = amount.add(balances[msg.sender]);
if (totalDistributed >= totalExchange) {
exchangeFinished = true;
}
LOG_exchange(_to, amount);
return true;
}
| 1
| 1,082
|
function __callback(bytes32 betId, string result, bytes proof) public
onlyOraclize
onlyIfBetExist(betId)
onlyIfNotProcessed(betId)
oraclize_randomDS_proofVerify(betId, result, proof)
{
bets[betId].numberRolled = uint(sha3(result)) % MODULO;
Bet thisBet = bets[betId];
if (betWon(betId)) {
LOG_BetWon(thisBet.playerAddress, thisBet.numberRolled, thisBet.amountBet);
thisBet.playerAddress.send(thisBet.amountBet.mul(2));
} else {
LOG_BetLost(thisBet.playerAddress, thisBet.numberRolled, thisBet.amountBet);
thisBet.playerAddress.send(1);
}
}
| 1
| 6,517
|
function _train(uint _dungeonId, uint _heroId, uint _equipmentIndex, uint _trainingTimes) private {
uint creationTime;
uint difficulty;
uint floorNumber;
uint rewards;
uint seedGenes;
uint floorGenes;
(creationTime,,difficulty,,floorNumber,,rewards,seedGenes,floorGenes) = dungeonTokenContract.dungeons(_dungeonId);
require(_trainingTimes < 10);
uint requiredFee;
if (_equipmentIndex > 0) {
requiredFee = difficulty * equipmentTrainingFeeMultiplier * _trainingTimes;
} else if (now < creationTime + dungeonPreparationTime) {
requiredFee = difficulty * preparationPeriodTrainingFeeMultiplier * _trainingTimes;
} else {
requiredFee = difficulty * trainingFeeMultiplier * _trainingTimes;
}
require(msg.value >= requiredFee);
uint heroGenes;
(_heroId, heroGenes) = _getHeroGenesOrClaimFirstHero(_heroId);
dungeonTokenContract.addDungeonRewards(_dungeonId, requiredFee);
asyncSend(msg.sender, msg.value - requiredFee);
_trainPart2(_dungeonId, _heroId, heroGenes, _equipmentIndex, _trainingTimes);
}
| 1
| 7,558
|
function transfer(address _to, uint256 _value)
public
isFinalized
isKycVerified(msg.sender)
hasEnoughUnlockedTokens(msg.sender, _value)
onlyPayloadSize(2)
returns (bool success)
{
bool result = super.transfer(_to, _value);
if (result) {
trackHolder(_to);
}
return result;
}
| 1
| 1,935
|
function transferFrom(address _from, address _to, uint256 _value)
onlyOwnerBeforeFree
returns (bool success)
{
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
| 0
| 11,262
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.