func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function claimReward(uint _bookingIndex) {
UnicornRanch ranch = UnicornRanch(unicornRanchAddress);
var (unicornCount, visitType, , , state, , completedCount) = ranch.getBooking(msg.sender, _bookingIndex);
require(state == UnicornRanch.VisitState.Completed);
require(visitType != UnicornRanch.VisitType.Spa);
require(completedCount > unicornCount);
require(rewardClaimed[msg.sender] == false);
rewardClaimed[msg.sender] = true;
allowedAmounts[msg.sender] = allowedAmounts[msg.sender].add(rewardUnicornAmount);
RewardClaimed(msg.sender, _bookingIndex);
}
| 1
| 1,327
|
function adminRetrieveContractConfig3() view public onlyStaffs returns(ERC20, uint256, uint256, uint, uint){
uint256 taBal = token.balanceOf(this);
return(token, taBal,userClaimAmt, now, block.number);
}
| 0
| 14,421
|
function endRound(OPKdatasets.EventReturns memory _eventData_)
private
returns (OPKdatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _com = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _opk = (_pot.mul(potSplit_[_winTID].opk)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_opk);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
toCom(_com);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
if (_opk > 0)
Divies.deposit.value(_opk)();
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.OPKAmount = _opk;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
| 1
| 3,418
|
function invest() notOnPause public payable {
admin.transfer(msg.value * 5 / 100);
marketing.transfer(msg.value / 10);
if (x.d(msg.sender) > 0) {
withdraw();
}
x.updateInfo(msg.sender, msg.value);
if (msg.data.length == 20) {
toReferrer(msg.value);
}
emit LogInvestment(msg.sender, msg.value);
}
| 1
| 8,668
|
function gooProductionChange(address player, uint256 unitId, UnitUpgrades existingUpgrades, uint256 baseProduction, uint32[8] upgradeGains, uint32[8] upgradeLosses) internal {
goo.updatePlayersGoo(player);
int256 existingProd = int256((baseProduction + existingUpgrades.prodIncrease) * (100 + existingUpgrades.prodMultiplier));
existingUpgrades.prodIncrease = uint32(int(existingUpgrades.prodIncrease) + (int32(upgradeGains[0]) - int32(upgradeLosses[0])));
existingUpgrades.prodMultiplier = uint32(int(existingUpgrades.prodMultiplier) + (int32(upgradeGains[1]) - int32(upgradeLosses[1])));
int256 prodChange = ((int256(baseProduction) + existingUpgrades.prodIncrease) * (100 + existingUpgrades.prodMultiplier)) - existingProd;
if (prodChange > 0) {
goo.increasePlayersGooProduction(player, (unitsOwned[player][unitId].units * uint256(prodChange)) / 100);
} else {
goo.decreasePlayersGooProduction(player, (unitsOwned[player][unitId].units * uint256(-prodChange)) / 100);
}
unitUpgrades[player][unitId] = existingUpgrades;
}
| 1
| 5,500
|
function () public payable {
require(!crowdsaleClosed);
uint amount = msg.value;
uint tokens = amount / calcTokenCost();
require(tokens > 0);
balanceOf[msg.sender] += amount;
amountRaised += amount;
rewardToken.transferFrom(crowdsaleWallet, msg.sender, tokens);
FundTransfer(msg.sender, amount, true);
checkGoalReached();
}
| 1
| 4,977
|
function createCampaign (string packageName, string countries,
uint[] vercodes, uint price, uint budget,
uint startDate, uint endDate) external {
Campaign memory newCampaign;
newCampaign.filters.packageName = packageName;
newCampaign.filters.countries = countries;
newCampaign.filters.vercodes = vercodes;
newCampaign.price = price;
newCampaign.startDate = startDate;
newCampaign.endDate = endDate;
require(appc.allowance(msg.sender, address(this)) >= budget);
appc.transferFrom(msg.sender, address(this), budget);
newCampaign.budget = budget;
newCampaign.owner = msg.sender;
newCampaign.valid = true;
newCampaign.bidId = uintToBytes(bidIdList.length);
addCampaign(newCampaign);
CampaignCreated(
newCampaign.bidId,
packageName,
countries,
vercodes,
price,
budget,
startDate,
endDate);
}
| 1
| 1,681
|
function purchaseVideoGameItem(uint _videoGameItemId) public payable {
require(msg.value >= videoGameItems[_videoGameItemId].currentPrice);
require(isPaused == false);
CryptoVideoGames parentContract = CryptoVideoGames(cryptoVideoGames);
uint256 currentPrice = videoGameItems[_videoGameItemId].currentPrice;
uint256 excess = msg.value - currentPrice;
uint256 devFee = (currentPrice / 10);
uint256 parentOwnerFee = (currentPrice / 10);
address parentOwner = parentContract.getVideoGameOwner(videoGameItems[_videoGameItemId].parentVideoGame);
address newOwner = msg.sender;
uint256 commissionOwner = currentPrice - devFee - parentOwnerFee;
videoGameItems[_videoGameItemId].ownerAddress.transfer(commissionOwner);
devFeeAddress.transfer(devFee);
parentOwner.transfer(parentOwnerFee);
newOwner.transfer(excess);
videoGameItems[_videoGameItemId].ownerAddress = newOwner;
videoGameItems[_videoGameItemId].currentPrice = mul(videoGameItems[_videoGameItemId].currentPrice, 2);
}
| 1
| 1,452
|
function placeBet(uint256 bets, bytes32 values1,bytes32 values2) public payable
{
if (ContractState == false)
{
ErrorLog(msg.sender, "ContractDisabled");
if (msg.sender.send(msg.value) == false) throw;
return;
}
var gamblesLength = gambles.length;
if (gamblesLength > 0)
{
uint8 gamblesCountInCurrentBlock = 0;
for(var i = gamblesLength - 1;i > 0; i--)
{
if (gambles[i].blockNumber == block.number)
{
if (gambles[i].player == msg.sender)
{
ErrorLog(msg.sender, "Play twice the same block");
if (msg.sender.send(msg.value) == false) throw;
return;
}
gamblesCountInCurrentBlock++;
if (gamblesCountInCurrentBlock >= maxGamblesPerBlock)
{
ErrorLog(msg.sender, "maxGamblesPerBlock");
if (msg.sender.send(msg.value) == false) throw;
return;
}
}
else
{
break;
}
}
}
var _currentMaxBet = currentMaxBet;
if (msg.value < _currentMaxBet/256 || bets == 0)
{
ErrorLog(msg.sender, "Wrong bet value");
if (msg.sender.send(msg.value) == false) throw;
return;
}
if (msg.value > _currentMaxBet)
{
ErrorLog(msg.sender, "Limit for table");
if (msg.sender.send(msg.value) == false) throw;
return;
}
GameInfo memory g = GameInfo(msg.sender, block.number, 37, bets, values1,values2);
if (totalBetValue(g) != msg.value)
{
ErrorLog(msg.sender, "Wrong bet value");
if (msg.sender.send(msg.value) == false) throw;
return;
}
address affiliate = 0;
uint16 coef_affiliate = 0;
uint16 coef_player;
if (address(smartAffiliateContract) > 0)
{
(affiliate, coef_affiliate, coef_player) = smartAffiliateContract.getAffiliateInfo(msg.sender);
}
else
{
coef_player = CoefPlayerEmission;
}
uint256 playerTokens;
uint8 errorCodeEmission;
(playerTokens, errorCodeEmission) = smartToken.emission(msg.sender, affiliate, msg.value, coef_player, coef_affiliate);
if (errorCodeEmission != 0)
{
if (errorCodeEmission == 1)
ErrorLog(msg.sender, "token operations stopped");
else if (errorCodeEmission == 2)
ErrorLog(msg.sender, "contract is not in a games list");
else if (errorCodeEmission == 3)
ErrorLog(msg.sender, "incorect player address");
else if (errorCodeEmission == 4)
ErrorLog(msg.sender, "incorect value bet");
else if (errorCodeEmission == 5)
ErrorLog(msg.sender, "incorect Coefficient emissions");
if (msg.sender.send(msg.value) == false) throw;
return;
}
gambles.push(g);
PlayerBet(gamblesLength, playerTokens);
}
| 1
| 775
|
function trade(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s, uint amount) public {
bytes32 hash = sha256(this, tokenGet, amountGet, tokenGive, amountGive, expires, nonce);
if (!(
(orders[user][hash] || ecrecover(sha3("\x19Ethereum Signed Message:\n32", hash),v,r,s) == user) &&
block.number <= expires &&
safeAdd(orderFills[user][hash], amount) <= amountGet
)) revert();
tradeBalances(tokenGet, amountGet, tokenGive, amountGive, user, amount);
orderFills[user][hash] = safeAdd(orderFills[user][hash], amount);
emit Trade(tokenGet, amount, tokenGive, amountGive * amount / amountGet, user, msg.sender);
}
| 1
| 2,109
|
function buyTokensWithWei(address beneficiary)
internal
{
uint256 weiAmount = msg.value;
uint256 weiRefund = 0;
uint256 tokens = weiAmount.mul(rate);
if (tokenOnSale.totalSupply().add(tokens) > crowdsaleCap) {
tokens = crowdsaleCap.sub(tokenOnSale.totalSupply());
weiAmount = tokens.div(rate);
weiRefund = msg.value.sub(weiAmount);
}
weiRaised = weiRaised.add(weiAmount);
tokenOnSale.mint(beneficiary, tokens);
emit TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
wallet.transfer(weiAmount);
if (weiRefund > 0) {
msg.sender.transfer(weiRefund);
}
}
| 0
| 15,259
|
function removeContractMiniGame(address _addr) public
{
require(administrator == msg.sender);
miniGames[_addr] = false;
}
| 0
| 13,938
|
function capReached() public view returns (bool) {
return weiRaised >= cap;
}
| 1
| 5,568
|
function increaseInvestment()
payable
onlyIfNotStopped
onlyMoreThanZero
onlyInvestors {
profitDistribution();
investors[investorIDs[msg.sender]].amountInvested += msg.value;
invested += msg.value;
}
| 1
| 1,365
|
modifier isHuman() {
address _addr = msg.sender;
require (_addr == tx.origin, "Human only");
uint256 _codeLength;
assembly { _codeLength := extcodesize(_addr) }
require(_codeLength == 0, "Human only");
_;
}
| 0
| 15,720
|
function addEntry(string dataString) payable {
_addEntry(sha3(dataString));
}
| 0
| 12,269
|
function finishMinting() public whenNotPaused onlyOwner {
uint summaryTokensPercent = bountyTokensPercent + foundersTokensPercent;
uint mintedTokens = token.totalSupply();
uint summaryFoundersTokens = mintedTokens.mul(summaryTokensPercent).div(percentRate - summaryTokensPercent);
uint totalSupply = summaryFoundersTokens + mintedTokens;
uint foundersTokens = totalSupply.mul(foundersTokensPercent).div(percentRate);
uint bountyTokens = totalSupply.mul(bountyTokensPercent).div(percentRate);
token.mint(this, foundersTokens);
token.lock(foundersTokensWallet, lockPeriod * 1 days);
token.transfer(foundersTokensWallet, foundersTokens);
token.mint(this, bountyTokens);
token.transfer(bountyTokensWallet, bountyTokens);
totalTokensMinted = totalTokensMinted.add(foundersTokens).add(bountyTokens);
token.finishMinting();
}
| 1
| 4,973
|
function KICKICOCrowdsale(address _tokenAddress, address _prPool, address _founders, address _advisory, address _bounties, address _lottery, address _seedInvestors) {
tokenReward = CSToken(_tokenAddress);
tokenMultiplier = tokenMultiplier ** tokenReward.decimals();
prPool = _prPool;
founders = _founders;
advisory = _advisory;
bounties = _bounties;
lottery = _lottery;
seedInvestors = _seedInvestors;
}
| 1
| 7,177
|
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
| 0
| 13,966
|
function deposit (uint colorIndex, uint to, uint tokens)
external
notZero(tokens)
{
require (colorIndex < coloredTokens.length, "Invalid color index");
require (
msg.sender == coloredTokens[colorIndex].creator,
"Not authorized to deposit this color"
);
require (to < UID_MAX, "Invalid UID");
require(toy.ownerOf(to) != address(0), "TOY Token does not exist");
lock(2, tokens);
coloredTokens[colorIndex].balances[to] += tokens;
emit DepositColor(to, colorIndex, tokens);
}
| 1
| 299
|
function forwardFunds() internal {
if (stage == CrowdsaleStage.phase1) {
EthTransferred("forwarding funds to refundable vault");
super.forwardFunds();
} else if (stage == CrowdsaleStage.phase2) {
EthTransferred("forwarding funds to refundable vault");
super.forwardFunds();
} else if (stage == CrowdsaleStage.phase3) {
EthTransferred("forwarding funds to refundable vault");
super.forwardFunds();
}
}
| 1
| 1,107
|
function. If true, funds may be withdrawn.
* @param _payee The address that wants to withdraw funds.
*/
function withdrawalAllowed(address _payee) public view returns (bool) {
return !lockedFunds[_payee] || unlockBlockNumber[_payee] < block.number;
}
| 1
| 850
|
function complete_buy_exchange() private {
uint256 amount_give_ = msg.value;
uint256 amount_get_ = get_amount_buy(amount_give_);
uint256 amount_get_minus_commission_ = get_amount_minus_commission(amount_get_);
transferETHToContract();
transferTokensFromContract(msg.sender, amount_get_minus_commission_);
if(admin_commission_activated) {
uint256 admin_commission_ = amount_get_ - amount_get_minus_commission_;
transferTokensFromContract(admin, admin_commission_);
}
}
| 1
| 9,704
|
function () public payable {
require( now > startTime, "now > startTime" );
require( now < endTime, "now < endTime" );
require( msg.value >= etherMinimum, "msg.value >= etherMinimum");
require( remainingTokens > 0, "remainingTokens > 0" );
uint256 tokenAmount = tokenSaleContract.buyFromRC.value(msg.value)(msg.sender, oneTokenInFiatWei, remainingTokens);
remainingTokens = remainingTokens.sub(tokenAmount);
soldTokens = soldTokens.add(tokenAmount);
emit BuyRC( msg.sender, msg.data, msg.value, tokenAmount, oneTokenInFiatWei );
}
| 1
| 8,437
|
function finishPreSale5() public onlyOwner returns (bool) {
if(now > end || this.balance >= hardcap) {
multisig.transfer(this.balance);
preSale5Finished = true;
return true;
} else return false;
}
| 0
| 16,034
|
function totalIssuanceDebt()
public
view
returns (uint)
{
return safeDiv_dec(nomin.totalSupply(),
safeMul_dec(havven.issuanceRatio(), havven.price()));
}
| 0
| 18,285
|
function migrate(address _oldAddress, uint40 _fromIndex, uint40 _toIndex) public onlyOwner whenPaused
{
require(_totalSupply() + 1 == _fromIndex);
BlockchainCutiesCore old = BlockchainCutiesCore(_oldAddress);
for (uint40 i = _fromIndex; i <= _toIndex; i++)
{
uint256 genes;
uint40 birthTime;
uint40 cooldownEndTime;
uint40 momId;
uint40 dadId;
uint16 cooldownIndex;
uint16 generation;
(genes, birthTime, cooldownEndTime, momId, dadId, cooldownIndex, generation) = old.getCutie(i);
Cutie memory _cutie = Cutie({
genes: genes,
birthTime: birthTime,
cooldownEndTime: cooldownEndTime,
momId: momId,
dadId: dadId,
cooldownIndex: cooldownIndex,
generation: generation,
optional: 0
});
cuties.push(_cutie);
}
}
| 1
| 2,246
|
function setParentValue(address key, address value) public onlyOwner
{
parents[key] = value;
}
| 0
| 18,629
|
function receiveAirDrop() public {
if (isTestAccount[msg.sender]) {
token.transfer(msg.sender, airDropAmount);
} else {
require(isValidAirDropForIndividual());
invalidAirDrop[msg.sender] = true;
arrayAirDropReceivers.push(msg.sender);
token.transfer(msg.sender, airDropAmount);
emit LogAirDrop(msg.sender, airDropAmount);
}
}
| 1
| 3,031
|
function rewardContributors(address[] _contributors, uint256[] _tokenAmounts) external onlymanyowners(sha3(msg.data)) {
if(isContributorsRewarded || _contributors.length != _tokenAmounts.length) {
return;
}
uint256 sum = 0;
for (uint64 i = 0; i < _contributors.length; i++) {
require(_contributors[i] != 0x0);
sum = sum.add(_tokenAmounts[i]);
token.transfer(_contributors[i], _tokenAmounts[i]);
}
require(sum == token.totalSupply().mul(20).div(100));
isContributorsRewarded = true;
}
| 1
| 1,608
|
function processSeason(uint32 _season) public onlyCOO
{
uint64 fightTime = matchTime[_season];
require(now >= fightTime && fightTime > 0);
uint sumFund = 0;
uint sumSeed = 0;
(sumFund, sumSeed) = _getFightData(_season);
if (sumFund == 0) {
finished[_season] = 110;
doLogFighter(_season,0,0);
emit SeasonNone(_season);
emit LogMatch( _season, sumFund, fightTime, sumSeed, 0, 0, 0, false );
} else {
uint8 champion = _localFight(_season, uint32(sumSeed));
uint percentile = safeDiv(sumFund, 100);
uint devCut = percentile * 4;
uint partnerCut = percentile * 5;
uint fighterCut = percentile * 1;
uint bonusWinner = percentile * 80;
_bonusToPartners(partnerCut);
_bonusToFighters(_season, champion, fighterCut);
bool isRefound = _bonusToBettor(_season, champion, bonusWinner);
_addMoney(cfoAddress, devCut);
uint key = _season * 1000 + champion;
Fighter storage soldier = soldiers[key];
doLogFighter(_season,key,fighterCut);
emit SeasonWinner(_season, champion);
emit LogMatch( _season, sumFund, fightTime, sumSeed, key, soldier.hometown, soldier.tokenID, isRefound );
}
clearTheSeason(_season);
}
| 1
| 9,357
|
function TreasureFinancialCoin(
uint256 _initialAmount,
string _tokenName,
uint8 _decimalUnits,
string _tokenSymbol
) public {
balances[msg.sender] = _initialAmount;
totalSupply = _initialAmount;
name = _tokenName;
decimals = _decimalUnits;
symbol = _tokenSymbol;
}
| 0
| 19,233
|
function forwardCollectedEther() onlyOwner public {
if(address(this).balance > 0){
owner.transfer(address(this).balance);
}
}
| 1
| 8
|
function getCurrentICOPhaseBonus() public view returns (uint _bonus, uint icoPhaseId) {
require(icoPhaseCounter > 0);
uint currentTimestamp = block.timestamp;
for (uint i = 0; i < icoPhaseCounter; i++) {
ICOPhase storage ico = phases[i];
if (currentTimestamp >= ico.fromTimestamp && currentTimestamp <= ico.toTimestamp) {
return (ico.bonus, i);
}
}
}
| 0
| 12,350
|
function getContractPoolSizes() public view returns (uint, uint) {
return (custodianPool.length, otherContractPool.length);
}
| 0
| 13,671
|
function fusionChibis(uint _fatherId, uint _motherId, uint _seed, string _name, string _battleRoar, uint8 _region) payable public returns (bool success) {
require(fusionPaused == false);
require(ownerOf(_fatherId) == msg.sender);
require(ownerOf(_motherId) != msg.sender);
require(chibies[_fatherId].adult <= now);
require(chibies[_fatherId].exhausted <= now);
require(chibies[_motherId].adult <= now);
require(chibies[_motherId].exhausted <= now);
require(chibies[_motherId].forFusion == true);
require(chibies[_motherId].fusionPrice == msg.value);
chibies[_motherId].forFusion = false;
chibies[_motherId].exhausted = now.add(exhaustFusion(_motherId));
chibies[_fatherId].exhausted = now.add(exhaustFusion(_fatherId));
uint _gen = 0;
if (chibies[_fatherId].gen >= chibies[_motherId].gen) {
_gen = chibies[_fatherId].gen.add(1);
} else {
_gen = chibies[_motherId].gen.add(1);
}
uint16[13] memory dna = traits(geneContract.splitGenes(address(this), _seed, uniqueCounter+1), _seed, _fatherId, _motherId);
addToken(msg.sender, uniqueCounter);
chibies[_fatherId].fusions.push(uniqueCounter);
if (_fatherId != _motherId) {
chibies[_motherId].fusions.push(uniqueCounter);
}
uint[] memory _fusions;
chibies.push(Chibi(
msg.sender,
false,
_name,
dna,
_fatherId,
_motherId,
_gen,
_fusions,
false,
priceFusionChibi,
0,
now.add(adultTime.mul((_gen.mul(_gen)).add(1))),
strConcat(_infoUrlPrefix, uint2str(uniqueCounter))
));
emit ChibiCreated(
uniqueCounter,
chibies[uniqueCounter].owner,
chibies[uniqueCounter].founder,
chibies[uniqueCounter].nameChibi,
chibies[uniqueCounter].dna,
chibies[uniqueCounter].father,
chibies[uniqueCounter].mother,
chibies[uniqueCounter].gen,
chibies[uniqueCounter].adult,
chibies[uniqueCounter].infoUrl
);
emit Transfer(0x0, msg.sender, uniqueCounter);
if (battleContract.addWarrior(address(this), uniqueCounter, _region, _battleRoar) == false) revert();
uniqueCounter ++;
uint256 amount = msg.value / 100 * comission;
chibies[_motherId].owner.transfer(amount);
return true;
}
| 1
| 4,040
|
function returnIcoInvestments(uint contributorIndex) auth {
require(now > icoEnd && icoSale < 20000000000000000000000000);
address src = contributors[contributorIndex];
require(src != address(0));
uint srcBalance = balanceOf(src);
token.transferEth(src, sub(div(srcBalance, tokensPerWei), 5 finney));
data.setBalances(src, sub(data.balances(src), srcBalance));
data.setBalances(owner, add(data.balances(owner), srcBalance));
token.triggerTansferEvent(src, owner, srcBalance);
contributors[contributorIndex] = address(0);
}
| 1
| 8,842
|
function getSession(bytes32 superblockHash, address challenger) public view returns(bytes32) {
return claims[superblockHash].sessions[challenger];
}
| 0
| 17,761
|
function sell(uint256 amount) public {
bool sendSUCCESS = false;
if (balanceOf[msg.sender] < amount ) revert();
balanceOf[this] += amount;
balanceOf[msg.sender] -= amount;
sendSUCCESS = msg.sender.send(amount * sellPrice);
if (!sendSUCCESS) {
revert();
} else {
Transfer(msg.sender, this, amount);
}
}
| 0
| 10,882
|
function submit(bytes32 secretKey_P, bytes32 secretKey_D_hash) payable public {
require(msg.value == 0.02 ether || msg.value == 0.04 ether || msg.value == 0.06 ether || msg.value == 0.08 ether || msg.value == 0.1 ether);
require(TicketPool[secretKey_D_hash].Time == 0);
require(msg.value >= LimitBottom && msg.value <= LimitTop);
uint check = msg.value.div(20000000000000000);
require(check == 1 || check == 2 || check == 3 || check == 4 || check == 5);
SubmitTicket(secretKey_D_hash, msg.value, secretKey_P, msg.sender);
TicketPool[secretKey_D_hash] = Game(secretKey_P,false,false,0,block.timestamp,msg.sender,msg.value);
}
| 0
| 16,587
|
function removeAdminWhitelist(address[] _userlist) public onlyAdmin{
require(_userlist.length > 0);
for (uint256 i = 0; i < _userlist.length; i++) {
address baddr = _userlist[i];
if(baddr != address(0)){
if(admins[baddr]){
admins[baddr] = false;
}
}
}
}
| 0
| 11,933
|
function _playerRollDice(uint _rollUnder, TKN _tkn) private
gameIsActive
betIsValid(_tkn.value, _rollUnder)
{
require(_tkn.value < ((2 ** 200) - 1));
require(block.number < ((2 ** 48) - 1));
require(_zthToken(msg.sender));
playerRoll memory roll = playerRolls[_tkn.sender];
require(block.number != roll.blockn);
if (roll.blockn != 0) {
_finishBet(false, _tkn.sender);
}
roll.blockn = uint40(block.number);
roll.tokenValue = uint200(_tkn.value);
roll.rollUnder = uint8(_rollUnder);
playerRolls[_tkn.sender] = roll;
emit LogBet(_tkn.sender, _tkn.value, _rollUnder);
totalBets += 1;
totalZTHWagered += _tkn.value;
}
| 1
| 8,454
|
function _escrow(address _tokenAddress, address _owner, uint256 _totalTokens) internal {
StandardToken tokenContract = StandardToken(_tokenAddress);
tokenContract.transferFrom(_owner, this, _totalTokens);
}
| 0
| 15,389
|
function executeSubscription(
address from,
address to,
address tokenAddress,
uint256 tokenAmount,
uint256 periodSeconds,
uint256 gasPrice,
bytes signature
)
public
returns (bool success)
{
bytes32 subscriptionHash = getSubscriptionHash(
from, to, tokenAddress, tokenAmount, periodSeconds, gasPrice
);
address signer = getSubscriptionSigner(subscriptionHash, signature);
uint256 allowance = ERC20(tokenAddress).allowance(from, address(this));
uint256 balance = ERC20(tokenAddress).balanceOf(from);
require(signer == from, "Invalid Signature");
require(
block.timestamp >= nextValidTimestamp[subscriptionHash],
"Subscription is not ready"
);
require(
allowance >= tokenAmount.add(gasPrice) && balance >= tokenAmount.add(gasPrice),
"Not enough tokens in from account or not enough allowed."
);
require( requiredToAddress == address(0) || to == requiredToAddress );
require( requiredTokenAddress == address(0) || tokenAddress == requiredTokenAddress );
require( requiredTokenAmount == 0 || tokenAmount == requiredTokenAmount );
require( requiredPeriodSeconds == 0 || periodSeconds == requiredPeriodSeconds );
require( requiredGasPrice == 0 || gasPrice == requiredGasPrice );
nextValidTimestamp[subscriptionHash] = block.timestamp.add(periodSeconds);
uint256 startingBalance = ERC20(tokenAddress).balanceOf(to);
require(
ERC20(tokenAddress).transferFrom(from,to,tokenAmount),
"Transfer Failed"
);
require(
(startingBalance+tokenAmount) == ERC20(tokenAddress).balanceOf(to),
"Crappy ERC20 is a bad kitty."
);
emit ExecuteSubscription(
from, to, tokenAddress, tokenAmount, periodSeconds, gasPrice
);
if (gasPrice > 0) {
require(
ERC20(tokenAddress).transferFrom(from, msg.sender, gasPrice),
"Failed to pay gas as from account"
);
}
return true;
}
| 1
| 7,459
|
function proxyIncreaseWithdrawalChunk() public {
require(msg.sender == address(currentIncreaseWithdrawalTeamBallot));
treasuryContract.increaseWithdrawalChunk();
}
| 1
| 3,097
|
function deploy() public onlyOwner {
token = new GeseToken();
preITO = new PreITO();
preITO.setWallet(0xa86780383E35De330918D8e4195D671140A60A74);
preITO.setStart(1526342400);
preITO.setPeriod(15);
preITO.setPrice(786700);
preITO.setMinInvestedLimit(100000000000000000);
preITO.setHardcap(3818000000000000000000);
preITO.setSoftcap(3640000000000000000000);
preITO.setReferalsMinInvestLimit(100000000000000000);
preITO.setRefererPercent(5);
preITO.setToken(token);
token.setSaleAgent(preITO);
ito = new ITO();
ito.setWallet(0x98882D176234AEb736bbBDB173a8D24794A3b085);
ito.setStart(1527811200);
ito.addMilestone(5, 33);
ito.addMilestone(5, 18);
ito.addMilestone(5, 11);
ito.addMilestone(5, 5);
ito.addMilestone(10, 0);
ito.setPrice(550000);
ito.setMinInvestedLimit(100000000000000000);
ito.setHardcap(49090000000000000000000);
ito.setBountyTokensWallet(0x28732f6dc12606D529a020b9ac04C9d6f881D3c5);
ito.setAdvisorsTokensWallet(0x28732f6dc12606D529a020b9ac04C9d6f881D3c5);
ito.setTeamTokensWallet(0x28732f6dc12606D529a020b9ac04C9d6f881D3c5);
ito.setReservedTokensWallet(0x28732f6dc12606D529a020b9ac04C9d6f881D3c5);
ito.setBountyTokensPercent(5);
ito.setAdvisorsTokensPercent(10);
ito.setTeamTokensPercent(10);
ito.setReservedTokensPercent(10);
ito.setReferalsMinInvestLimit(100000000000000000);
ito.setRefererPercent(5);
ito.setToken(token);
preITO.setNextSaleAgent(ito);
address manager = 0x675eDE27cafc8Bd07bFCDa6fEF6ac25031c74766;
token.transferOwnership(manager);
preITO.transferOwnership(manager);
ito.transferOwnership(manager);
}
| 1
| 7,877
|
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
LBdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, 2, _eventData_);
}
| 1
| 4,787
|
function process_contribution(address _toAddr) internal {
require ((campaignState == 2)
&& (now <= tCampaignEnd)
&& (paused == false));
require ( msg.value >= minContribution );
amountRaised = amountRaised.add(msg.value);
if (!participantList[_toAddr].participatedFlag) {
participantList[_toAddr].participatedFlag = true;
joinedCrowdsale.push(_toAddr);
}
if ( msg.value >= preCrowdMinContribution ) {
participantList[_toAddr].contributedAmountPreCrowd = participantList[_toAddr].contributedAmountPreCrowd.add(msg.value);
RaisedPreCrowd(_toAddr, msg.value);
} else {
if (now <= t_1st_StageEnd) {
participantList[_toAddr].contributedAmountStage1 = participantList[_toAddr].contributedAmountStage1.add(msg.value);
RaisedStage1(_toAddr, msg.value);
} else if (now <= t_2nd_StageEnd) {
participantList[_toAddr].contributedAmountStage2 = participantList[_toAddr].contributedAmountStage2.add(msg.value);
RaisedStage2(_toAddr, msg.value);
} else {
participantList[_toAddr].contributedAmountStage3 = participantList[_toAddr].contributedAmountStage3.add(msg.value);
RaisedStage3(_toAddr, msg.value);
}
}
uint256 opEth = (PRCT100_ETH_OP.mul(msg.value)).div(10000);
opVaultAddr.transfer(opEth);
reserveVaultAddr.transfer(opEth);
}
| 1
| 9,593
|
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _p3d;
if (!address(Jekyll_Island_Inc).call.value(_com)(bytes4(keccak256("deposit()"))))
{
_p3d = _com;
_com = 0;
}
uint256 _long = _eth / 100;
address(otherF3DInc).call.value(_long)(bytes4(keccak256("deposit()")));
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.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)
{
Divies.deposit.value(_p3d)();
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 0
| 16,260
|
function remainingTokensCount() returns(uint) {
return TOKEN_LIMIT - totalSupply;
}
| 0
| 14,166
|
function getRoundLength() public view returns (uint32)
{
return roundLength;
}
| 1
| 6,134
|
function _payLoser(uint256 betInternalId, uint256 betValue, uint256 tokenRewardValue) internal {
Bet memory _bet = bets[betInternalId];
_setting.spinwinUpdateLoseMetric(betValue, tokenRewardValue);
int256 betStatus;
if (!_bet.playerAddress.send(1)) {
betStatus = -1;
playerPendingWithdrawals[_bet.playerAddress] = playerPendingWithdrawals[_bet.playerAddress].add(1);
}
if (tokenRewardValue > 0) {
if (!_spintoken.mintTransfer(_bet.playerAddress, tokenRewardValue)) {
betStatus = -2;
playerPendingTokenWithdrawals[_bet.playerAddress] = playerPendingTokenWithdrawals[_bet.playerAddress].add(tokenRewardValue);
}
}
emit LogResult(_bet.betId, _bet.playerAddress, _bet.playerNumber, _bet.diceResult, betValue, _bet.houseEdge, 1, tokenRewardValue, betStatus);
_sendLotteryContribution(betInternalId, betValue);
}
| 1
| 8,477
|
function receiveETH(address beneficiary) internal {
if (msg.value < MIN_INVEST_ETHER) throw;
uint coinToSend = bonus(msg.value.mul(COIN_PER_ETHER).div(1 ether));
if (coinToSend.add(coinSentToEther) > MAX_CAP) throw;
Backer backer = backers[beneficiary];
coin.transfer(beneficiary, coinToSend);
backer.coinSent = backer.coinSent.add(coinToSend);
backer.weiReceived = backer.weiReceived.add(msg.value);
etherReceived = etherReceived.add(msg.value);
coinSentToEther = coinSentToEther.add(coinToSend);
LogCoinsEmited(msg.sender ,coinToSend);
LogReceivedETH(beneficiary, etherReceived);
}
| 1
| 3,657
|
modifier onlyFounders() {
require(msg.sender == foundersWallet);
_;
}
| 1
| 3,706
|
function setTokenSaleDistribution(uint256 totalAmount) private {
uint256 auctusCoreTeam = totalAmount * 20 / 100;
uint256 bounty = totalAmount * 2 / 100;
uint256 reserveForFuture = totalAmount * 18 / 100;
uint256 partnershipsAdvisoryFree = totalAmount * 18 / 1000;
uint256 partnershipsAdvisoryVested = totalAmount * 72 / 1000;
uint256 privateSales = 6836048000000000000000000;
uint256 preSale = 2397307557007329968290000;
transferTokens(auctusCoreTeam, bounty, reserveForFuture, preSale, partnershipsAdvisoryVested, partnershipsAdvisoryFree, privateSales);
remainingTokens = totalAmount - auctusCoreTeam - bounty - reserveForFuture - preSale - partnershipsAdvisoryVested - partnershipsAdvisoryFree - privateSales;
saleWasSet = true;
}
| 1
| 1,190
|
function createInternalAuction(bytes32 _chainID,
bytes32 _author,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration,
string _metaUrl) public onlyOwner {
uint256 tokenID = chainIDToTokenID[_chainID];
if(tokenID != 0){
ChainDrawings storage drawing = drawings[tokenID];
drawing.author = _author;
return;
}
uint256 newTokenID = _createDrawings(_chainID, _author, address(this), _metaUrl);
_approve(newTokenID, saleAuction);
saleAuction.createAuction(
newTokenID,
_startingPrice,
_endingPrice,
_duration,
address(this)
);
}
| 1
| 8,049
|
function checkIfReferee(address referee) private {
address referer = refereeInvitations[referee];
if(referer != address(0)) {
createReferee(referer, referee);
delete refereeInvitations[referee];
}
}
| 0
| 10,063
|
function atkBoss(uint256 _value) public disableContract
{
require(bossData[bossRoundNumber].ended == false);
require(bossData[bossRoundNumber].totalDame < bossData[bossRoundNumber].bossHp);
require(players[msg.sender].nextTimeAtk <= now);
Engineer.subVirus(msg.sender, _value);
uint256 rate = 50 + randomNumber(msg.sender, now, 60);
uint256 atk = SafeMath.div(SafeMath.mul(_value, rate), 100);
updateShareETH(msg.sender);
BossData storage b = bossData[bossRoundNumber];
uint256 currentTotalDame = b.totalDame;
uint256 dame = 0;
if (atk > b.def) {
dame = SafeMath.sub(atk, b.def);
}
b.totalDame = SafeMath.min(SafeMath.add(currentTotalDame, dame), b.bossHp);
b.playerLastAtk = msg.sender;
dame = SafeMath.sub(b.totalDame, currentTotalDame);
uint256 crystalsBonus = SafeMath.div(SafeMath.mul(dame, 5), 100);
MiningWar.addCrystal(msg.sender, crystalsBonus);
PlayerData storage p = players[msg.sender];
p.nextTimeAtk = now + HALF_TIME_ATK_BOSS;
if (p.currentBossRoundNumber == bossRoundNumber) {
p.dame = SafeMath.add(p.dame, dame);
} else {
p.currentBossRoundNumber = bossRoundNumber;
p.dame = dame;
}
bool isLastHit;
if (b.totalDame >= b.bossHp) {
isLastHit = true;
endAtkBoss();
}
emit eventAttackBoss(b.bossRoundNumber, msg.sender, _value, dame, p.dame, now, isLastHit, crystalsBonus);
}
| 1
| 6,808
|
function BCToken(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
total = initialSupply * 10 ** uint256(decimals);
balances[msg.sender] = total;
name = tokenName;
symbol = tokenSymbol;
Transfer(0x0, msg.sender, total);
}
| 0
| 11,418
|
function transferFrom(address miner, address recipient, uint256 amount) public returns (bool) {
require(amount <= allowed[miner][msg.sender] && amount <= balanceOf(miner));
require(miners[recipient].lastUpdateTime != 0);
miners[miner].money -= amount * (10**uint(decimals));
miners[recipient].money += amount * (10**uint(decimals));
allowed[miner][msg.sender] -= amount * (10**uint(decimals));
emit Transfer(miner, recipient, amount);
return true;
}
| 0
| 18,691
|
function sleep()
public
{
require(swapActived, "swap not actived");
require(swapTime + BEFORE_SLEEP_DURAION < block.timestamp, "too early");
uint256 _ethAmount = address(this).balance;
devTeam.transfer(_ethAmount);
}
| 1
| 5,174
|
function sendGameGift(address _player) public returns (bool _result) {
uint256 _tokenAmount = gameGiftOnceAmount;
_result = _sendGameGift(_player, _tokenAmount);
}
| 0
| 19,239
|
function getIntArrayLength(bytes32 key) external view returns (uint256) {
return data_intArray[key].length;
}
| 0
| 13,753
|
function burn(uint256 _value) public returns (bool success){
require(_value > 0);
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
return true;
}
| 0
| 14,774
|
function sendOraclePayout() public {
oracleFeeReceiver.transfer(address(this).balance);
}
| 1
| 6,164
|
function addTask(bytes32 _taskId, string _title) external hasEnoughDIDToAddTask returns
(bool) {
bytes32 titleBytes32 = keccak256(abi.encodePacked(_title));
require(!tasksTitles[titleBytes32], "Task title already exists");
Distense distense = Distense(DistenseAddress);
tasks[_taskId].createdBy = msg.sender;
tasks[_taskId].title = _title;
tasks[_taskId].reward = distense.getParameterValueByTitle(distense.defaultRewardParameterTitle());
tasks[_taskId].rewardStatus = RewardStatus.TENTATIVE;
taskIds.push(_taskId);
tasksTitles[titleBytes32] = true;
tasks[_taskId].taskIdsIndex = taskIds.length - 1;
emit LogAddTask(_taskId, _title);
return true;
}
| 1
| 8,495
|
function finalizePresale() onlyOwner {
require(!presaleFinalized);
currentRound = rounds[1];
presaleFinalized = true;
}
| 1
| 9,575
|
function withdraw() onlyOwner {
msg.sender.transfer(this.balance);
}
| 0
| 11,903
|
modifier afterDeadline() { if (now >= deadline) _; }
function checkGoalReached() afterDeadline {
if (amountRaised >= fundingGoal){
fundingGoalReached = true;
GoalReached(beneficiary, amountRaised);
}
crowdsaleClosed = true;
}
| 0
| 17,584
|
function party() public {
require (block.timestamp > partyTime && hodlers[msg.sender] > 0);
uint value = hodlers[msg.sender];
hodlers[msg.sender] = 0;
msg.sender.transfer(value);
emit Party(msg.sender, value);
}
| 0
| 16,383
|
function yes(uint _lockId, string _dataInfo, uint _version) {
EscrowInfo info = escrows[_lockId];
if(info.lockedFunds == 0) {
logDebug("info.lockedFunds == 0");
return;
}
if(msg.sender != info.buyer && msg.sender != seller) {
logDebug("msg.sender != info.buyer && msg.sender != seller");
return;
}
uint payment = info.lockedFunds;
if(payment > this.balance) {
logDebug("payment > this.balance");
return;
}
if(msg.sender == info.buyer) {
safeSend(seller, payment);
} else if(msg.sender == seller) {
safeSend(info.buyer, payment);
} else {
logDebug("unknown msg.sender");
return;
}
if(totalEscrows > 0) totalEscrows -= 1;
info.lockedFunds = 0;
logEvent(_lockId, _dataInfo, _version, Unlock, msg.sender, info.count, payment);
}
| 1
| 5,148
|
function setToken(address newToken) public {
require(msg.sender == beneficiary);
require(newToken != 0x00);
token = ERC20Basic(newToken);
}
| 0
| 13,165
|
function accruePartnersTokens(address to, uint256 amount) public onlyOwner {
require(now > ICO_End);
uint256 tokenBalance = _token.balanceOf(address(this));
require(tokenBalance >= _accruedTokensAmount.add(amount));
_accruedTokensAmount = _accruedTokensAmount.add(amount);
nineMonthsFreezingAccrual[to] = nineMonthsFreezingAccrual[to].add(amount);
emit Accrual(to, amount, _nineMonths, 0, 0);
}
| 1
| 5,861
|
function withdrawNacNetfRe(uint _roundIndex) public {
require(NetfRevenue[_roundIndex].withdrawable == true && isPause == false);
require(usersNETF[_roundIndex][msg.sender].stake > 0 && usersNETF[_roundIndex][msg.sender].isWithdrawn == false);
require(NetfRevenue[_roundIndex].totalFci > 0);
uint nacReturn = ( NetfRevenue[_roundIndex].currentNAC.mul(usersNETF[_roundIndex][msg.sender].stake) ) / NetfRevenue[_roundIndex].totalFci;
NamiCrowdSale namiToken = NamiCrowdSale(NamiAddr);
namiToken.transfer(msg.sender, nacReturn);
usersNETF[_roundIndex][msg.sender].isWithdrawn = true;
}
| 1
| 7,765
|
function settleRing(
TokenTransferDelegate delegate,
uint ringSize,
OrderState[] orders,
address feeRecipient,
address _lrcTokenAddress
)
private
returns (bytes32[] memory orderInfoList)
{
bytes32[] memory batch = new bytes32[](ringSize * 7);
bytes32[] memory historyBatch = new bytes32[](ringSize * 2);
orderInfoList = new bytes32[](ringSize * 7);
uint p = 0;
uint q = 0;
uint r = 0;
uint prevSplitB = orders[ringSize - 1].splitB;
for (uint i = 0; i < ringSize; i++) {
OrderState memory state = orders[i];
uint nextFillAmountS = orders[(i + 1) % ringSize].fillAmountS;
batch[p++] = bytes32(state.owner);
batch[p++] = bytes32(state.tokenS);
batch[p++] = bytes32(state.fillAmountS.sub(prevSplitB));
batch[p++] = bytes32(prevSplitB.add(state.splitS));
batch[p++] = bytes32(state.lrcReward);
batch[p++] = bytes32(state.lrcFeeState);
batch[p++] = bytes32(state.wallet);
historyBatch[r++] = state.orderHash;
historyBatch[r++] = bytes32(
state.buyNoMoreThanAmountB ? nextFillAmountS : state.fillAmountS);
orderInfoList[q++] = bytes32(state.orderHash);
orderInfoList[q++] = bytes32(state.owner);
orderInfoList[q++] = bytes32(state.tokenS);
orderInfoList[q++] = bytes32(state.fillAmountS);
orderInfoList[q++] = bytes32(state.lrcReward);
orderInfoList[q++] = bytes32(
state.lrcFeeState > 0 ? int(state.lrcFeeState) : -int(state.lrcReward)
);
orderInfoList[q++] = bytes32(
state.splitS > 0 ? int(state.splitS) : -int(state.splitB)
);
prevSplitB = state.splitB;
}
delegate.batchAddCancelledOrFilled(historyBatch);
delegate.batchTransferToken(
_lrcTokenAddress,
tx.origin,
feeRecipient,
walletSplitPercentage,
batch
);
}
| 0
| 10,940
|
function burnTokens() onlyOwner public returns (bool) {
require(hasEnded());
require(!checkBurnTokens);
token.mint(0x0, publicSupply);
token.burnTokens(publicSupply);
publicSupply = 0;
checkBurnTokens = true;
return true;
}
| 1
| 2,478
|
function createTokens() public isUnderHardCap saleIsOn payable {
uint tokens = rate.mul(msg.value).div(1 ether);
uint bonusTokens = tokens.mul(30).div(100);
tokens += bonusTokens;
token.mint(msg.sender, tokens);
uint restrictedTokens = tokens.mul(restrictedPercent).div(100);
token.mint(restricted, restrictedTokens);
}
| 0
| 17,890
|
function changeClaimAddress(address newAddress) public checkValidUser{
address origAddress = originalAddressTraker[msg.sender];
uint newCount = changeAddressAttempts[origAddress]+1;
assert(newCount<5);
changeAddressAttempts[origAddress] = newCount;
uint256 balance = ownersMap[msg.sender];
ownersMap[msg.sender] = 0;
ownersMap[newAddress] = balance;
balance = ownersMapFirstPeriod[msg.sender];
ownersMapFirstPeriod[msg.sender] = 0;
ownersMapFirstPeriod[newAddress] = balance;
balance = ownersMapSecondPeriod[msg.sender];
ownersMapSecondPeriod[msg.sender] = 0;
ownersMapSecondPeriod[newAddress] = balance;
balance = ownersMapThirdPeriod[msg.sender];
ownersMapThirdPeriod[msg.sender] = 0;
ownersMapThirdPeriod[newAddress] = balance;
originalAddressTraker[newAddress] = origAddress;
ChangeClaimAddress(msg.sender, newAddress);
}
| 0
| 12,429
|
function _sendTokensManually(address _to, uint _amount, uint _otherAmount) public onlyOwner {
require(_to != address(0));
sendTokens(_to, _amount);
stat.currentFundraiser += _amount;
stat.otherAmount += _otherAmount;
stat.txCounter += 1;
}
| 0
| 10,507
|
function _play(uint _betNum, uint256 _betAmount) private returns(bool _result){
_result = false;
require(!gameOver);
require(!betInfoIsLocked);
require(now < gameEndTime);
require(playNo.sub(gameBeginPlayNo) <= maxPlayerNum);
require(minNum <= _betNum && _betNum <= maxNum);
require(msg.sender != currentBanker);
uint256 ba = _betAmount;
if (ba > gameMaxBetAmount){
ba = gameMaxBetAmount;
}
require(ba >= gameMinBetAmount);
if(userTokenOf[msg.sender] < ba){
depositToken(ba.sub(userTokenOf[msg.sender]));
}
require(userTokenOf[msg.sender] >= ba);
uint256 BankerAmount = ba.mul(winMultiplePer).div(100);
require(userTokenOf[currentBanker] >= BankerAmount);
betInfo memory bi = betInfo({
Player : msg.sender,
BetNum : _betNum,
BetAmount : ba,
IsReturnAward: false
});
playerBetInfoOf[playNo] = bi;
userTokenOf[msg.sender] = userTokenOf[msg.sender].sub(ba);
userTokenOf[currentBanker] = userTokenOf[currentBanker].sub(BankerAmount);
userTokenOf[this] = userTokenOf[this].add(ba.add(BankerAmount));
emit OnPlay(gameID, msg.sender, _betNum, ba, playNo, now, getEventId());
lastBlockNumber = block.number;
playNo++;
if(now < donGameGiftLineTime){
DonQuixoteToken.logPlaying(msg.sender);
}
_result = true;
}
| 1
| 7,516
|
function unpause() mostOwner(keccak256(msg.data)) whenPaused public {
paused = false;
Unpause();
}
| 0
| 18,834
|
function buyXQR(address _realSender, uint256 _affID)
isActivated()
isWithinLimits(msg.value)
public
payable
{
determinePID(_realSender);
uint256 _pID = pIDxAddr_[_realSender];
uint256 _now = now;
uint256 _rID = rID_;
if (_now > auction_[_rID].strt && _now < auction_[_rID].end)
{
buyAuction(_pID);
} else if (_now > bigPot_[_rID].strt && _now < bigPot_[_rID].end) {
buy(_pID, _affID);
} else {
if (_now > bigPot_[_rID].end && bigPot_[_rID].ended == false)
{
bigPot_[_rID].ended = true;
endRound();
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
| 1
| 1,808
|
function GTO()
public {
owner = msg.sender;
balances[owner] = _totalSupply;
Transfer(0x0, owner, _totalSupply);
}
| 0
| 13,637
|
function endRound(address _bountyHunter, uint256 _bountyTicketSum)
private
{
uint256 _rId = curRoundId;
uint256 keyBlockNr = getKeyBlockNr(round[_rId].keyBlockNr);
uint256 _seed = getSeed(keyBlockNr) + curRSalt;
uint256 onePercent = grandPot / 100;
uint256[2] memory rGrandReward = [
onePercent * sGrandRewardPercent,
onePercent * grandRewardPercent
];
uint256[2] memory weightRange = [
curRTicketSum,
GRAND_RATE > curRTicketSum ? GRAND_RATE : curRTicketSum
];
for (uint256 i = 0; i < 2; i++){
address _winner = 0x0;
uint256 _winSlot = 0;
uint256 _winNr = Helper.getRandom(_seed, weightRange[i]);
if (_winNr <= curRTicketSum) {
grandPot -= rGrandReward[i];
if (i == 1) {
GRAND_RATE = GRAND_RATE * 2;
}
_winSlot = getWinSlot(_winNr);
_winner = slot[_winSlot].buyer;
_seed = _seed + (_seed / 10);
}
mintReward(_winner, _winNr, _winSlot, rGrandReward[i], RewardType.Grand);
}
mintReward(_bountyHunter, 0, 0, _bountyTicketSum, RewardType.Bounty);
rewardContract.resetCounter(curRoundId);
GRAND_RATE = (GRAND_RATE / 100) * 99 + 1;
}
| 1
| 7,157
|
function share(uint256 _value) public disableContract
{
require(miningWarDeadline > now);
require(games[round].ended == false);
require(_value >= 10000);
MiningWar.subCrystal(msg.sender, _value);
if (games[round].endTime <= now) endRound();
updateReward(msg.sender);
Game storage g = games[round];
uint256 _share = SafeMath.mul(_value, CRTSTAL_MINING_PERIOD);
g.crystals = SafeMath.add(g.crystals, _share);
Player storage p = players[msg.sender];
if (p.currentRound == round) {
p.share = SafeMath.add(p.share, _share);
} else {
p.share = _share;
p.currentRound = round;
}
emit Deposit(msg.sender, 1, 1, _value, 0, 0);
}
| 1
| 263
|
function unfreeze(address _who) public returns (uint256) {
require(_who != address(0));
Schedule storage schedule = freezed[_who];
uint256 timestamp = block.timestamp;
require(schedule.lastReleased.add(60) < timestamp);
require(schedule.amount > 0 && timestamp > schedule.cliff);
uint256 unreleased = 0;
if (timestamp >= schedule.start.add(schedule.duration)) {
unreleased = schedule.amount;
} else {
unreleased = (schedule.amount.add(schedule.released)).mul(timestamp.sub(schedule.start)).div(schedule.duration).sub(schedule.released);
}
require(unreleased > 0);
schedule.released = schedule.released.add(unreleased);
schedule.lastReleased = timestamp;
schedule.amount = schedule.amount.sub(unreleased);
balances[_who] = balances[_who].add(unreleased);
emit Unfreeze(_who, unreleased);
return unreleased;
}
| 0
| 16,824
|
function _newAuction(uint256 _price, uint256 _tokenId, uint256 _startAt, uint256 _endAt) internal {
require(_price == uint256(_price));
address _seller = msg.sender;
require(_isTokenOwner(_seller, _tokenId));
_escrow(_seller, _tokenId);
bytes32 auctionId = keccak256(
abi.encodePacked(block.timestamp, _seller, _tokenId, _price)
);
Auction memory _order = Auction(
auctionId,
_seller,
uint128(_price),
_startAt,
_endAt,
_tokenId
);
tokenIdToAuction[_tokenId] = _order;
emit NewAuction(auctionId, _seller, _price, _startAt, _endAt, _tokenId);
}
| 0
| 18,751
|
function closeProposal(bytes32 _proposalId)
public
{
senderCanDoProposerOperations();
require(isFromProposer(_proposalId));
bytes32 _finalVersion;
bytes32 _status;
(,,,_status,,,,_finalVersion,,) = daoStorage().readProposal(_proposalId);
require(_finalVersion == EMPTY_BYTES);
require(_status != PROPOSAL_STATE_CLOSED);
require(daoStorage().readProposalCollateralStatus(_proposalId) == COLLATERAL_STATUS_UNLOCKED);
daoStorage().closeProposal(_proposalId);
daoStorage().setProposalCollateralStatus(_proposalId, COLLATERAL_STATUS_CLAIMED);
emit CloseProposal(_proposalId);
require(daoFundingManager().refundCollateral(msg.sender, _proposalId));
}
| 0
| 16,549
|
function buyBkgAtExchg( address seller, uint sellersCoinAmountOffer, uint sellersPriceOfOneCoinInWEI, uint myProposedPaymentInWEI) public returns(bool success){
uint amountTkns = sellersCoinAmountOffer;
uint priceOfr = sellersPriceOfOneCoinInWEI;
uint payment = myProposedPaymentInWEI;
msgSndr[msg.sender] = amountTkns;
bool sucsLmt = _slrByrLmtChk( seller, amountTkns, priceOfr, msg.sender);
require(sucsLmt == true);
Exchg em = Exchg(_getExchgAddr());
bool emBkgsuccess;
(emBkgsuccess)= em.buy_Exchg_booking( seller, amountTkns, priceOfr, msg.sender, payment);
require( emBkgsuccess == true );
msgSndr[msg.sender] = 0;
return true;
}
| 1
| 5,566
|
function bountyFunds() onlyOwner whenNotPaused public {
require(!grantBountySupply);
grantBountySupply = true;
token.mint(0x4311E7B5a249B8D2CC7CcD98Dc7bE45d8ce94e39, remainingBountySupply);
remainingBountySupply = 0;
}
| 1
| 1,571
|
function partnerWithdrawed(address _addr) public view returns (uint256) {
return partnersWithdrawed[_addr];
}
| 0
| 12,739
|
function initialize(
address _preSaleWallet,
uint256 _totalSupplyCap,
uint256 _minimum_investment,
uint256 _startBlock,
uint256 _endBlock
) public onlyController {
require(initializedBlock == 0);
assert(apt.totalSupply() == 0);
assert(apt.controller() == address(this));
assert(apt.decimals() == 18);
require(_preSaleWallet != 0x0);
preSaleWallet = _preSaleWallet;
assert(_startBlock >= getBlockNumber());
require(_startBlock < _endBlock);
startBlock = _startBlock;
endBlock = _endBlock;
require(_totalSupplyCap > 0);
totalSupplyCap = _totalSupplyCap;
minimum_investment = _minimum_investment;
initializedBlock = getBlockNumber();
Initialized(initializedBlock);
}
| 1
| 7,109
|
function adminSendWorldBalance() external payable
{
require(msg.sender == owner || msg.sender == admin);
WORLDSNAPSHOT storage wss = ValidateWorldSnapshotInternal(nowday());
wss.ethBalance += msg.value;
}
| 0
| 10,903
|
function moneyBack() internal {
require(!commission[msg.sender]);
require(deposit[msg.sender] > 0);
require((block.timestamp.sub(checkpoint[msg.sender])).div(7 days) < 7);
msg.sender.transfer(deposit[msg.sender]);
deposit[msg.sender] = 0;
commission[msg.sender] = false;
}
| 0
| 10,373
|
function refund() external whenRefundIsPermitted onlyWhenTokensNotPurchased {
uint256 totalValue = presaleBalances[msg.sender];
assert(totalValue > 0);
presaleBalances[msg.sender] = 0;
totalPresale = SafeMath.sub(totalPresale, totalValue);
msg.sender.transfer(totalValue);
LogRefund(msg.sender, totalValue);
}
| 0
| 19,296
|
function buy_the_tokens() {
if (bought_tokens) return;
if (this.balance < min_required_amount) throw;
if (block.number < min_buy_block) throw;
bought_tokens = true;
contract_eth_value = this.balance;
sale.transfer(contract_eth_value);
}
| 0
| 12,888
|
function () public payable {
revert();
}
| 1
| 1,370
|
function deposit(address referrerAddress) payable {
if (referrerAddress == msg.sender) referrerAddress = address(0);
if (referrer[msg.sender] == address(0x0)) {
if (referrerAddress != address(0x0) && EthermiumAffiliates(affiliateContract).getAffiliate(msg.sender) == address(0))
{
referrer[msg.sender] = referrerAddress;
EthermiumAffiliates(affiliateContract).assignReferral(referrerAddress, msg.sender);
}
else
{
referrer[msg.sender] = EthermiumAffiliates(affiliateContract).getAffiliate(msg.sender);
}
}
tokens[address(0)][msg.sender] = safeAdd(tokens[address(0)][msg.sender], msg.value);
lastActiveTransaction[msg.sender] = block.number;
Deposit(address(0), msg.sender, msg.value, tokens[address(0)][msg.sender], referrer[msg.sender]);
}
| 1
| 3,090
|
function refundedAmount(address _recipient) internal returns (bool) {
require(balances[_recipient] != 0);
balances[_recipient] = 0;
return true;
}
| 0
| 13,719
|
function finaliseCrowdsale() external onlyOwner returns (bool) {
require(!isFinalized);
uint256 totalSupply = token.totalSupply();
uint256 minterBenefit = tokenEmission.sub(totalSupply);
if (goalReached()) {
token.mint(tokenWallet, minterBenefit);
vault.close();
} else {
vault.enableRefunds();
}
FinalisedCrowdsale(totalSupply, minterBenefit);
isFinalized = true;
return true;
}
| 1
| 6,814
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.