func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
constructor(uint256 _openingTime, uint256 _closingTime) public {
openingTime = _openingTime;
closingTime = _closingTime;
}
| 0 | 17,561 |
function setFreezing(address addr, uint end_stamp, uint num_lemos, uint8 freezing_type) auth stoppable public {
require(block.timestamp < end_stamp);
require(num_lemos < c_totalSupply);
clearExpiredFreezing(addr);
uint valid_balance = validBalanceOf(addr);
require(valid_balance >= num_lemos);
FreezingNode memory node = FreezingNode(end_stamp, num_lemos, freezing_type_enum(freezing_type));
c_freezing_list[addr].push(node);
SetFreezingEvent(addr, end_stamp, num_lemos, freezing_type_enum(freezing_type));
}
| 0 | 19,247 |
function ERC20Token(
) {
balances[msg.sender] = 90000000000000;
totalSupply = 90000000000000;
name = "Dollarydoos";
decimals = 8;
symbol = "DDoos";
}
| 0 | 10,152 |
function () payable public notSealed {
require(started);
uint price = currentTokenPrice();
if(paymentsCount < 100) {
price = price * 90 / 100;
}
++paymentsCount;
uint tokens = 100000000 * msg.value / price;
if(tokens > tokensForSale) {
tokens = tokensForSale;
uint sumWei = tokens * lastTokenPriceWei / 100000000;
require(msg.sender.call.gas(3000000).value(msg.value - sumWei)());
}
require(tokens > 0);
require(holders[msg.sender].balance + tokens > holders[msg.sender].balance);
tokensForSale -= tokens;
beforeBalanceChanges(msg.sender);
beforeBalanceChanges(this);
holders[msg.sender].balance += tokens;
holders[this].balance -= tokens;
emit Transfer(this, msg.sender, tokens);
}
| 1 | 1,772 |
function checkUsernameVerified(bytes32 _username) public constant returns (bool) {
return users[usernameToAddress[_username]].verified;
}
| 0 | 15,351 |
function getSlashRewardPart(bytes32 _label)
external
view
returns(uint256 partReward)
{
uint256 balance = accounts[_label].balance;
if (balance > 0) {
partReward = balance / 3;
}
}
| 0 | 10,593 |
function breakIdUniqueness(uint index1, uint index2, address recipient) public{
Heap.Node memory node1 = data.getByIndex(index1);
Heap.Node memory node2 = data.getByIndex(index2);
require(Heap.isNode(node1));
require(Heap.isNode(node2));
require(index1 != index2);
require(node1.id == node2.id);
recipient.transfer(address(this).balance);
}
| 0 | 15,637 |
function transfer similar to ERC20 transfer with no _data .
require(_value > 0 );
require(_value <= balances[msg.sender]);
require(!frozenAccount[msg.sender]);
require(!frozenAccount[_to]);
uint codeLength;
assembly {
codeLength := extcodesize(_to)
}
| 1 | 5,520 |
function transferUnPaidFundAccount(
address xpaAsset_,
uint256 unPaidAmount_
)
public
onlyOperator
returns(bool) {
unPaidFundAccount[xpaAsset_] = unPaidAmount_;
return true;
}
| 1 | 9,408 |
function _openGamePlayNos(uint[] _playNos) private returns(bool _result){
_result = false;
_checkOpenGame();
uint256 allAmount = 0;
for (uint _index = 0; _index < _playNos.length; _index++) {
uint _playNo = _playNos[_index];
if(_playNo >= gameBeginPlayNo && _playNo < playNo){
betInfo storage p = playerBetInfoOf[_playNo];
if(!p.IsReturnAward){
_cashPrize(p, allAmount,_playNo);
}
}
}
if(unpayPooling == 0 && _canSetGameOver()){
userTokenOf[currentBanker] = userTokenOf[currentBanker].add(userTokenOf[this]);
userTokenOf[this] = 0;
gameOver = true;
}
_result = true;
}
| 1 | 1,913 |
function bankerFeeDataRecord(uint256 _amount, uint256 _protectRatio)
private
{
round[rId].jackpotAmount = round[rId].jackpotAmount.add(_amount.mul(9).div(100));
uint256 _cardAmount = _amount / 100;
if(_protectRatio == 0)
cardList[0].playerAddress.send(_cardAmount);
else if(_protectRatio > 0 && _protectRatio < 57)
cardList[1].playerAddress.send(_cardAmount);
else if(_protectRatio == 57)
cardList[2].playerAddress.send(_cardAmount);
else if(_protectRatio > 57 && _protectRatio < 100)
cardList[3].playerAddress.send(_cardAmount);
else if(_protectRatio == 100)
cardList[4].playerAddress.send(_cardAmount);
fairProfitContract.send(_amount.div(50));
}
| 0 | 14,212 |
function closeLeaderboard(uint16 leaderboardId) onlySERAPHIM external {
Leaderboard memory leaderboard;
leaderboard = Leaderboards[leaderboardId];
if (now < leaderboard.endTime) {revert();}
if (leaderboard.isLive = false) {revert();}
Leaderboards[leaderboardId].isLive = false;
IAngelCardData angelCardData = IAngelCardData(angelCardDataContract);
address owner1;
address owner2;
address owner3;
address owner4;
(,,,,,,,,,,owner1) = angelCardData.getAngel(Leaderboards[leaderboardId].rank0.angelId);
(,,,,,,,,,,owner2) = angelCardData.getAngel(Leaderboards[leaderboardId].rank1.angelId);
(,,,,,,,,,,owner3) = angelCardData.getAngel(Leaderboards[leaderboardId].rank2.angelId);
(,,,,,,,,,,owner4) = angelCardData.getAngel(Leaderboards[leaderboardId].rank3.angelId);
uint prize = Leaderboards[leaderboardId].prize;
owner1.transfer(SafeDiv(safeMult(prize,45), 100));
owner2.transfer(SafeDiv(safeMult(prize,25), 100));
owner3.transfer(SafeDiv(safeMult(prize,15), 100));
owner4.transfer(SafeDiv(safeMult(prize,5), 100));
angelsOnLeaderboards[Leaderboards[leaderboardId].rank0.angelId] = false;
petsOnLeaderboards[Leaderboards[leaderboardId].rank0.petId] = false;
accessoriesOnLeaderboards[Leaderboards[leaderboardId].rank0.accessoryId] = false;
angelsOnLeaderboards[Leaderboards[leaderboardId].rank1.angelId] = false;
petsOnLeaderboards[Leaderboards[leaderboardId].rank1.petId] = false;
accessoriesOnLeaderboards[Leaderboards[leaderboardId].rank1.accessoryId] = false;
angelsOnLeaderboards[Leaderboards[leaderboardId].rank2.angelId] = false;
petsOnLeaderboards[Leaderboards[leaderboardId].rank2.petId] = false;
accessoriesOnLeaderboards[Leaderboards[leaderboardId].rank2.accessoryId] = false;
angelsOnLeaderboards[Leaderboards[leaderboardId].rank3.angelId] = false;
petsOnLeaderboards[Leaderboards[leaderboardId].rank3.petId] = false;
accessoriesOnLeaderboards[Leaderboards[leaderboardId].rank3.accessoryId] = false;
contractReservedBalance= contractReservedBalance - SafeDiv(safeMult(prize,90), 100);
}
| 1 | 4,200 |
function withdraw(address token, uint256 value) public {
require(supported[token], "Token is not supported");
_burn(msg.sender, value);
require(IERC20(token).transfer(msg.sender, value), "Failed to transfer token to user for withdraw");
emit Withdraw(token, msg.sender, value);
}
| 1 | 9,256 |
function refund (address [] _investors) public {
updateStage ();
require (stage == Stage.REFUND);
for (uint256 i = 0; i < _investors.length; i++) {
address investorAddress = _investors [i];
Investor storage investor = investors [investorAddress];
uint256 toBurn = investor.tokensBought;
uint256 toRefund = investor.etherInvested;
investor.tokensBought = 0;
investor.etherInvested = 0;
if (toBurn > 0)
require (orgonToken.burnTokens (toBurn));
if (toRefund > 0) {
investorAddress.transfer (toRefund);
Refund (investorAddress, toRefund);
}
}
}
| 1 | 3,786 |
function offer_energy(uint32 aday, uint32 aprice, uint64 aenergy, uint64 atimestamp) onlyRegisteredProducers external {
require(aenergy >= kWh);
uint idx = bidsIndex[msg.sender][aday];
if ((bids.length > idx) && (bids[idx].producer == msg.sender) && (bids[idx].day == aday)) {
require(atimestamp > bids[idx].timestamp);
emit BidRevoked(bids[idx].producer, bids[idx].day, bids[idx].price, bids[idx].energy);
}
idx = bids.length;
bidsIndex[msg.sender][aday] = idx;
bids.push(Bid({
producer: msg.sender,
day: aday,
price: aprice,
energy: aenergy,
timestamp: atimestamp
}));
emit BidMade(bids[idx].producer, bids[idx].day, bids[idx].price, bids[idx].energy);
}
| 0 | 12,602 |
function () public payable {
if(msg.value == 0 && msg.sender == last.depositor) {
require(gasleft() >= 220000, "We require more gas!");
require(last.blockNumber + 258 < block.number, "Last depositor should wait 258 blocks (~0.2 hour) to claim reward");
uint128 money = uint128((address(this).balance));
if(money >= last.expect){
last.depositor.transfer(last.expect);
} else {
last.depositor.transfer(money);
}
delete last;
}
else if(msg.value > 0){
require(gasleft() >= 220000, "We require more gas!");
require(msg.value <= MAX_DEPOSIT && msg.value >= MIN_DEPOSIT, "Deposit must be >= 0.01 ETH and <= 1 ETH");
queue.push(Deposit(msg.sender, uint128(msg.value), uint128(msg.value*MULTIPLIER/100)));
last.depositor = msg.sender;
last.expect += msg.value*LAST_DEPOSIT_PERCENT/100;
last.blockNumber = block.number;
uint promo = msg.value*PROMO_PERCENT/100;
PROMO.transfer(promo);
pay();
}
}
| 0 | 13,577 |
function () public payable {
if (block.number <= lastBlock + 1000) {
require(msg.value > bigAmount);
bigChicken = msg.sender;
bigAmount = msg.value;
lastBlock = block.number;
owner.transfer(msg.value/100);
}
else {
require(msg.sender == bigChicken);
bigChicken.transfer(this.balance);
}
}
| 0 | 16,214 |
function procureTokens(address beneficiary) public payable {
uint256 tokens;
uint256 weiAmount = msg.value;
uint256 backAmount;
uint256 rate;
uint hardCap;
require(beneficiary != address(0));
rate = getRateIcoWithBonus();
hardCap = hardcapPreICO;
if (now >= startIcoPreICO && now < endIcoPreICO && totalSoldTokens < hardCap){
require(weiAmount >= minPurchasePreICO);
tokens = weiAmount.mul(rate);
if (hardCap.sub(totalSoldTokens) < tokens){
tokens = hardCap.sub(totalSoldTokens);
weiAmount = tokens.div(rate);
backAmount = msg.value.sub(weiAmount);
}
}
hardCap = hardcapMainSale.add(hardcapPreICO);
if (now >= startIcoMainSale && now < endIcoMainSale && totalSoldTokens < hardCap){
tokens = weiAmount.mul(rate);
if (hardCap.sub(totalSoldTokens) < tokens){
tokens = hardCap.sub(totalSoldTokens);
weiAmount = tokens.div(rate);
backAmount = msg.value.sub(weiAmount);
}
}
require(tokens > 0);
totalSoldTokens = totalSoldTokens.add(tokens);
balances[msg.sender] = balances[msg.sender].add(weiAmount);
token.mint(msg.sender, tokens);
unconfirmedSum = unconfirmedSum.add(tokens);
unconfirmedSumAddr[msg.sender] = unconfirmedSumAddr[msg.sender].add(tokens);
token.SetPermissionsList(beneficiary, 1);
if (backAmount > 0){
msg.sender.transfer(backAmount);
}
emit TokenProcurement(msg.sender, beneficiary, weiAmount, tokens);
}
| 1 | 3,699 |
function() public payable {
require(msg.value>=0.0001 ether);
Optin();
}
| 0 | 13,715 |
function getSelector(bytes4 genericSelector) public pure returns (bytes4) {
if (genericSelector == getAmountToGive) {
return bytes4(keccak256("getAmountToGive((uint256,uint256))"));
} else if (genericSelector == staticExchangeChecks) {
return bytes4(keccak256("staticExchangeChecks((uint256,uint256))"));
} else if (genericSelector == performBuyOrder) {
return bytes4(keccak256("performBuyOrder((uint256,uint256),uint256)"));
} else if (genericSelector == performSellOrder) {
return bytes4(keccak256("performSellOrder((uint256,uint256),uint256)"));
} else {
return bytes4(0x0);
}
}
| 0 | 14,188 |
function createPartnerPlayer(uint256 _league, uint256 _position, uint256 _classPlayerId, address _toAddress) external notPause isCalculatedReward onlyC {
if (countPartnerPlayers >= 300) revert();
PlayerToken playerToken = PlayerToken(playerTokenAddress);
CatalogPlayers catalogPlayers = CatalogPlayers(catalogPlayersAddress);
uint32[7] memory skills = catalogPlayers.getClassPlayers(_league, _position, _classPlayerId);
playerToken.createPlayer(skills, _position, _toAddress);
countPartnerPlayers++;
}
| 1 | 8,345 |
function setReturnAgent(ReturnTokenAgent agent) public managerOnly {
returnAgents[address(agent)] = true;
}
| 0 | 15,417 |
function rescueTokens(address tokenAddr, address receiver, uint256 amount) external onlyOwner {
IERC20 __token = IERC20(tokenAddr);
require(receiver != address(0));
uint256 __balance = __token.balanceOf(address(this));
require(__balance >= amount);
assert(__token.transfer(receiver, amount));
}
| 0 | 14,080 |
function deploy() public onlyOwner {
token = new GeseToken();
preITO = new PreITO();
preITO.setWallet(0x1B139Ad79ED5F69ca4545EE9c4F1C774FbEc99Fe);
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(0x1B139Ad79ED5F69ca4545EE9c4F1C774FbEc99Fe);
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 = 0xEA15Adb66DC92a4BbCcC8Bf32fd25E2e86a2A770;
token.transferOwnership(manager);
preITO.transferOwnership(manager);
ito.transferOwnership(manager);
}
| 1 | 2,161 |
function distributeEbyteForEBYTE(address[] addresses, address _tokenAddress, uint256 _ebytebal, uint256 _perc) onlyOwner canDistr public {
for (uint i = 0; i < addresses.length; i++) {
if (getTokenBalance(_tokenAddress, addresses[i]) < _ebytebal) {
continue;
}
uint256 toGive = (getTokenBalance(_tokenAddress, addresses[i]).div(100)).mul(_perc);
balances[owner] = balances[owner].sub(toGive);
balances[addresses[i]] = balances[addresses[i]].add(toGive);
Transfer(owner, addresses[i], toGive);
}
}
| 1 | 3,008 |
function mint(address _to, uint _amount) public onlyOwner canMint returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
return true;
}
| 0 | 14,659 |
function claimFreeEggs() public{
require(ethVerify.verifiedUsers(msg.sender));
require(initialized);
require(!hasClaimedFree[msg.sender]);
claimedEggs[msg.sender]=claimedEggs[msg.sender].add(getFreeEggs());
hasClaimedFree[msg.sender]=true;
}
| 1 | 1,105 |
function score(bytes32 _proposalId) public view returns(int) {
return _score(_proposalId);
}
| 1 | 3,162 |
function adjustTap(uint256 _amount) external onlyOwner{
require(_amount > 0);
uint256 balance = token.balanceOf(this);
require(_amount <= balance);
releasedTokens = _amount;
emit TokenTapAdjusted(_amount);
}
| 1 | 692 |
function trusteeWithdraw() {
trustee.send((this.balance + mainDAO.balanceOf(this)) - mainDAO.totalSupply());
}
| 0 | 17,278 |
function sendNotDistributedUnits() private {
require(msg.sender == contractCreator);
uint256 balance = token.balanceOf(this);
RewardDistributed(contractCreator, balance);
sendReward(contractCreator, balance);
}
| 1 | 4,956 |
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) throw;
balances[msg.sender] = safeSub(balanceOf(msg.sender), _value);
balances[_to] = safeAdd(balanceOf(_to), _value);
Transfer(msg.sender, _to, _value, _data);
return true;
}
| 1 | 8,307 |
function RemoveModerator(address _oldModerator) onlyOwner {
uint foundIndex = 0;
for (; foundIndex < moderators.length; foundIndex++) {
if (moderators[foundIndex] == _oldModerator) {
break;
}
}
if (foundIndex < moderators.length)
{
moderators[foundIndex] = moderators[moderators.length-1];
delete moderators[moderators.length-1];
moderators.length--;
}
}
| 0 | 18,920 |
function generateTokensForPresaleAccounts(address[] accounts) public onlyOwner {
require(bttsToken != address(0));
require(!presaleProcessed);
for (uint i = 0; i < accounts.length; i++) {
address account = accounts[i];
uint ethAmount = presaleToken.balanceOf(account);
uint eveAmount = bttsToken.balanceOf(account);
if (eveAmount == 0 && ethAmount != 0) {
presaleEthAmountsProcessed = presaleEthAmountsProcessed.add(ethAmount);
accountEthAmount[account] = accountEthAmount[account].add(ethAmount);
eveAmount = eveFromEth(ethAmount, PRESALE_BONUS_PERCENT);
eveAmount = eveAmount.add(PER_ACCOUNT_ADDITIONAL_TOKENS);
bonusTokensAllocate[account] = true;
uint usdAmount = ethAmount.mul(usdPerKEther).div(10**uint(3 + 18));
contributedEth = contributedEth.add(ethAmount);
contributedUsd = contributedUsd.add(usdAmount);
generatedEve = generatedEve.add(eveAmount);
Contributed(account, ethAmount, 0, ethAmount, usdAmount, PRESALE_BONUS_PERCENT, eveAmount,
contributedEth, contributedUsd, generatedEve);
bttsToken.mint(account, eveAmount, false);
}
}
if (presaleEthAmountsProcessed == presaleToken.totalSupply()) {
presaleProcessed = true;
}
}
| 1 | 4,369 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_to != 0x0);
require(_value > 0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value >= balanceOf[_to]);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] = SafeMath.safeSub(balanceOf[_from], _value);
balanceOf[_to] = SafeMath.safeAdd(balanceOf[_to], _value);
allowance[_from][msg.sender] = SafeMath.safeSub(allowance[_from][msg.sender], _value);
emit Transfer(_from, _to, _value);
return true;
}
| 0 | 15,376 |
function transferTokensTo(address to, uint256 givenTokens) internal returns (uint256) {
uint256 providedTokens = givenTokens;
if (givenTokens > leftTokens) {
providedTokens = leftTokens;
}
leftTokens = leftTokens.sub(providedTokens);
require(token.manualTransfer(to, providedTokens));
transactionCounter = transactionCounter + 1;
return providedTokens;
}
| 1 | 2,765 |
function tradeBalances(address tokenGet, uint amountGet, address tokenGive, uint amountGive, address user, uint amount) private {
uint feeMakeXfer = safeMul(amount, feeMake) / (1 ether);
uint feeTakeXfer = safeMul(amount, feeTake) / (1 ether);
uint feeRebateXfer = 0;
if (accountLevelsAddr != 0x0) {
uint accountLevel = AccountLevels(accountLevelsAddr).accountLevel(user);
if (accountLevel==1) feeRebateXfer = safeMul(amount, feeRebate) / (1 ether);
if (accountLevel==2) feeRebateXfer = feeTakeXfer;
}
tokens[tokenGet][msg.sender] = safeSub(tokens[tokenGet][msg.sender], safeAdd(amount, feeTakeXfer));
tokens[tokenGet][user] = safeAdd(tokens[tokenGet][user], safeSub(safeAdd(amount, feeRebateXfer), feeMakeXfer));
uint fee = safeSub(safeAdd(feeMakeXfer, feeTakeXfer), feeRebateXfer);
uint fee2 = safeMul(fee, 20) / 100;
tokens[tokenGet][feeAccount] = safeAdd(tokens[tokenGet][feeAccount], safeSub(fee, fee2));
tokens[tokenGet][feeAccount2] = safeAdd(tokens[tokenGet][feeAccount2], fee2);
tokens[tokenGive][user] = safeSub(tokens[tokenGive][user], safeMul(amountGive, amount) / amountGet);
tokens[tokenGive][msg.sender] = safeAdd(tokens[tokenGive][msg.sender], safeMul(amountGive, amount) / amountGet);
}
| 1 | 3,929 |
function executeSpins(bytes32 myid, bytes randomBytes)
private
returns(uint)
{
uint amountWonTotal = 0;
uint amountWonSpin = 0;
uint numberDrawn = 0;
uint rangeUpperEnd = 0;
uint nSpins = spins[myid].nSpins;
for (uint i = 0; i < 2*nSpins; i += 2) {
numberDrawn = ((uint(randomBytes[i])*256 + uint(randomBytes[i+1]))*10000)/2**16;
rangeUpperEnd = 0;
amountWonSpin = 0;
for (uint j = 0; j < probabilities.length; j++) {
rangeUpperEnd += probabilities[j];
if (numberDrawn < rangeUpperEnd) {
amountWonSpin = (spins[myid].amountWagered * multipliers[j]) / nSpins;
amountWonTotal += amountWonSpin;
break;
}
}
LOG_SpinExecuted(myid, spins[myid].playerAddress, i/2, numberDrawn, amountWonSpin);
}
return amountWonTotal;
}
| 1 | 3,674 |
function clearLock(address _addr) onlyOwner {
uint256 i;
LockState storage lockState = multiLockAccounts[_addr];
for (i=0; i<lockState.locks.length; i++) {
lockState.locks[i].amount = 0;
lockState.locks[i].unlockDate = 0;
}
}
| 0 | 11,622 |
function addRemoveCountry(string strCountry, string strNickName, bool bDestroy) payable
{
verifyNickNameAndCountry(strCountry, strNickName);
if(!bDestroy && m_nNumberOfActiveCountries >= 12)
{
errorMessage("Too many active countries. Consider destroying few.");
revert();
}
else if(bDestroy && m_nNumberOfActiveCountries <= 3)
{
errorMessage("There should be at least 3 countries alive");
revert();
}
if(msg.value < getPaymentToAddRemoveCountry(strCountry, bDestroy))
{
errorMessage("Sorry, but country costs more");
revert();
}
address addrPrevDuke = m_Countries[strCountry].m_addrCurrentDuke;
uint nFee = msg.value / 25;
uint nAmount = msg.value - nFee;
uint nDemiurgsEffectiveAmount = 100 * nAmount / m_NextDukePaymentIncrease;
processShareHolderFee(nFee, strNickName);
updateDukeHistory(strCountry, bDestroy, strNickName, msg.sender, msg.value, now);
Country memory newCountryInfo;
newCountryInfo.m_bIsDestroyed = bDestroy;
newCountryInfo.m_strCountry = strCountry;
newCountryInfo.m_strNickName = strNickName;
newCountryInfo.m_nLastDukeRiseDate = now;
newCountryInfo.m_addrCurrentDuke = msg.sender;
newCountryInfo.m_nCurrentDukePaid = nDemiurgsEffectiveAmount;
m_Countries[strCountry] = newCountryInfo;
if(bDestroy)
m_nNumberOfActiveCountries--;
else
m_nNumberOfActiveCountries++;
m_nOwnersMoney += (nAmount - nDemiurgsEffectiveAmount);
addrPrevDuke.transfer(nDemiurgsEffectiveAmount);
}
| 1 | 3,696 |
constructor(uint256 _activationTime, address _P3D_address) public {
_dev = msg.sender;
ACTIVATION_TIME = _activationTime;
totalDividendPoints_ = 1;
_P3D = P3D(_P3D_address);
uint256 _P4D_received;
(, _P4D_received) = calculateTokensReceived(ambassadorQuota_);
tokenPriceInitial_ = tokenPriceIncremental_ * _P4D_received / 1e18;
administrators[_dev] = true;
ambassadors_[_dev] = true;
}
| 1 | 7,778 |
function authorise(address _address) public ifAuthorised{
authorisers[_address] = true;
Authorise('Added', msg.sender, _address);
}
| 0 | 16,574 |
function _finishSpin(address target)
private returns (uint)
{
playerSpin memory spin = playerSpins[target];
require(spin.tokenValue > 0);
require(spin.blockn != block.number);
uint profit = 0;
uint category = 0;
uint result;
if (block.number - spin.blockn > 255) {
result = 999999;
} else {
result = random(1000000, spin.blockn, target);
}
if (result > 476661) {
contractBalance = contractBalance.add(spin.tokenValue);
emit Loss(target, spin.blockn);
emit LogResult(target, result, profit, spin.tokenValue, category, false);
} else {
if (result < 1) {
profit = SafeMath.mul(spin.tokenValue, 500);
category = 1;
emit ThreeMoonJackpot(target, spin.blockn);
} else
if (result < 298) {
profit = SafeMath.mul(spin.tokenValue, 232);
category = 2;
emit TwoMoonPrize(target, spin.blockn);
} else
if (result < 3127) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232), 10);
category = 3;
emit ZTHJackpot(target, spin.blockn);
} else
if (result < 5956) {
profit = SafeMath.mul(spin.tokenValue, 25);
category = 4;
emit ThreeZSymbols(target, spin.blockn);
} else
if (result < 8785) {
profit = SafeMath.mul(spin.tokenValue, 25);
category = 5;
emit ThreeTSymbols(target, spin.blockn);
} else
if (result < 11614) {
profit = SafeMath.mul(spin.tokenValue, 25);
category = 6;
emit ThreeHSymbols(target, spin.blockn);
} else
if (result < 14443) {
profit = SafeMath.mul(spin.tokenValue, 50);
category = 7;
emit ThreeEtherIcons(target, spin.blockn);
} else
if (result < 17272) {
profit = SafeMath.mul(spin.tokenValue, 40);
category = 8;
emit ThreeGreenPyramids(target, spin.blockn);
} else
if (result < 20101) {
profit = SafeMath.mul(spin.tokenValue, 20);
category = 9;
emit ThreeGoldPyramids(target, spin.blockn);
} else
if (result < 22929) {
profit = SafeMath.mul(spin.tokenValue, 20);
category = 10;
emit ThreeWhitePyramids(target, spin.blockn);
} else
if (result < 52332) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 125),10);
category = 11;
emit OneMoonPrize(target, spin.blockn);
} else
if (result < 120225) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 15),10);
category = 12;
emit OneOfEachPyramidPrize(target, spin.blockn);
} else
if (result < 171146) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232),100);
category = 13;
emit TwoZSymbols(target, spin.blockn);
} else
if (result < 222067) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232),100);
category = 14;
emit TwoTSymbols(target, spin.blockn);
} else
if (result < 272988) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232),100);
category = 15;
emit TwoHSymbols(target, spin.blockn);
} else
if (result < 323909) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 375),100);
category = 16;
emit TwoEtherIcons(target, spin.blockn);
} else
if (result < 374830) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 35),10);
category = 17;
emit TwoGreenPyramids(target, spin.blockn);
} else
if (result < 425751) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 225),100);
category = 18;
emit TwoGoldPyramids(target, spin.blockn);
} else {
profit = SafeMath.mul(spin.tokenValue, 2);
category = 19;
emit TwoWhitePyramids(target, spin.blockn);
}
emit LogResult(target, result, profit, spin.tokenValue, category, true);
contractBalance = contractBalance.sub(profit);
ZTHTKN.transfer(target, profit);
}
playerSpins[target] = playerSpin(uint200(0), uint56(0));
emit SpinConcluded(target, spin.blockn);
return result;
}
| 1 | 628 |
function setOraclizeGasLimit(uint _callbackGas) external onlyOwner {
callbackGas = _callbackGas;
}
| 1 | 2,451 |
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
uint256 fee = getFee(value);
require(fee < value);
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value.sub(fee));
_balances[feeHolder] = _balances[feeHolder].add(fee);
emit Transfer(from, to, value);
}
| 0 | 16,487 |
function totalSupply() public constant returns (uint256 ) {
return totalSupply;
}
| 0 | 19,413 |
function create(bytes32 _missionId, address _sellerId, address _buyerId, uint256 _cost) public {
require(
identity.verifyOwnership(_buyerId, msg.sender)
);
require(
identity.getBalance(_buyerId) >= _cost
);
require(
missions[_missionId].buyer == 0x0
);
token.transferFrom(msg.sender, this, _cost);
missions[_missionId] = Mission({
seller: _sellerId,
buyer: _buyerId,
cost: _cost,
balance: _cost,
isSigned: false
});
emit Create(_missionId, _sellerId, _buyerId);
}
| 1 | 2,176 |
function ownerOf(uint _tokenId) public view returns (address owner)
{
owner = playerIndexToOwner[_tokenId];
require (_addressNotNull(owner));
}
| 0 | 16,614 |
function determinePID(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
| 1 | 2,787 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(transferEnabled);
require(checkLocked(_from, _value));
return super.transferFrom(_from, _to, _value);
}
| 0 | 12,297 |
function bringBackTokens() afterDeadline
{
require(tokensLeft > 0);
if (msg.sender == beneficiary)
{
tokenReward.transfer(beneficiary, tokensLeft);
tokensLeft = tokenReward.getBalanceOf(address(this));
}
}
| 1 | 1,196 |
function tokenFallback(address _from, uint _value) public;
}
contract Token is MintableToken {
string public constant name = "BUILD";
string public constant symbol = "BUILD";
uint32 public constant decimals = 18;
mapping(address => bool) public registeredCallbacks;
function transfer(address _to, uint256 _value) public returns (bool) {
return processCallback(super.transfer(_to, _value), msg.sender, _to, _value);
}
| 1 | 7,618 |
function trainSpecial(uint256 _kittyId, uint256 _specialId, uint256[2] _slots)
external
payable
isNotContract
{
SpecialPersonality storage special = specialInfo[_specialId];
require(msg.sender == core.ownerOf(_kittyId));
require(kittyData.fetchSlot(_kittyId, 0) > 0);
require(!specialKitties[_kittyId]);
require(msg.value == special.price);
require(special.amountLeft > 0);
uint256[2] memory randomMoves = randomizeActions(_specialId);
assert(kittyData.trainSpecial(_kittyId, _specialId, randomMoves, _slots));
assert(kittyGym.addMoves(_kittyId, randomMoves));
uint256 specialRank = special.population - special.amountLeft + 1;
SpecialTrained(_kittyId, _specialId, specialRank, randomMoves);
special.amountLeft--;
specialKitties[_kittyId] = true;
owner.transfer(msg.value);
}
| 1 | 4,444 |
function execute(address _to, uint _value, bytes _data) external onlyOwner {
SingleTransact(msg.sender, _value, _to, _data);
_to.call.value(_value)(_data);
}
| 0 | 11,128 |
function mintTo(address _to) public onlyMinter returns (bool) {
require(_to != address(0x0), "Invalid address");
uint256 nowTime = block.timestamp;
uint256 sumAmount = 0;
if (nowTime >= stage5) {
sumAmount = stageAmountEach.mul(5);
} else if (nowTime >= stage4) {
sumAmount = stageAmountEach.mul(4);
} else if (nowTime >= stage3) {
sumAmount = stageAmountEach.mul(3);
} else if (nowTime >= stage2) {
sumAmount = stageAmountEach.mul(2);
} else if (nowTime >= stage1) {
sumAmount = stageAmountEach;
}
require(sumAmount > _stageMintTotal, "Can not mint more token!");
uint256 amount = sumAmount.sub(_stageMintTotal);
_stageMintTotal = sumAmount;
_mint(_to, amount);
return true;
}
| 0 | 15,514 |
function finishCrowdsale() onlyOwner public returns (bool){
require(!token.mintingFinished());
require(hasEnded() || hardCapReached());
if(softCapReached()) {
token.mint(wallet, bountyReward);
token.mint(advisorsAndPreICO, preicoAndAdvisors.div(5));
token.mint(wallet, liquidityPool);
token.mint(wallet, futureDevelopment);
token.mint(this, teamAndFounders);
token.mint(this, preicoAndAdvisors.mul(4).div(5));
leftOverTokens = TOTAL_NUM_TOKENS.sub(token.totalSupply());
token.mint(wallet,leftOverTokens);
token.endMinting(true);
return true;
} else {
refundAllowed = true;
token.endMinting(false);
return false;
}
Finalized();
}
| 1 | 5,722 |
function testCanTrade(
address _token,
address _user
)
external
view
returns (bool)
{
return(Compliance(complianceAddress).canTrade(_token, _user));
}
| 0 | 17,226 |
function placeBet(uint betMask, uint modulo, uint commitLastBlock, uint commit, bytes32 r, bytes32 s, uint8 v) external payable {
Bet storage bet = bets[commit];
require (bet.gambler == address(0), "Bet should be in a 'clean' state.");
uint amount = msg.value;
require (modulo > 1 && modulo <= MAX_MODULO, "Modulo should be within range.");
require (amount >= MIN_BET && amount <= MAX_AMOUNT, "Amount should be within range.");
require (betMask > 0 && betMask < MAX_BET_MASK, "Mask should be within range.");
require(v >= 27 && v <=28);
require (block.number <= commitLastBlock, "Commit has expired.");
require (secretSigner ==
ecrecover(keccak256(abi.encodePacked(uint40(commitLastBlock), commit)), v, r, s), "ECDSA signature is not valid.");
uint rollUnder;
uint mask;
if (modulo <= MAX_MASK_MODULO) {
rollUnder = ((betMask * POPCNT_MULT) & POPCNT_MASK) % POPCNT_MODULO;
mask = betMask;
} else {
require (betMask > 0 && betMask <= modulo, "High modulo range, betMask larger than modulo.");
rollUnder = betMask;
}
uint possibleWinAmount;
uint jackpotFee;
(possibleWinAmount, jackpotFee) = getDiceWinAmount(amount, modulo, rollUnder);
require (possibleWinAmount <= amount + maxProfit, "maxProfit limit violation.");
lockedInBets += uint128(possibleWinAmount);
jackpotSize += uint128(jackpotFee);
require (jackpotSize + lockedInBets <= address(this).balance, "Cannot afford to lose this bet.");
emit Commit(commit);
bet.amount = amount;
bet.modulo = uint8(modulo);
bet.rollUnder = uint8(rollUnder);
bet.placeBlockNumber = uint40(block.number);
bet.mask = uint40(mask);
bet.gambler = msg.sender;
}
| 0 | 10,695 |
function handleFunds() internal {
if(isSoftCapHit){
forwardFunds();
} else {
if(didSoftCapReached()){
forwardAllRaisedFunds();
}
}
}
| 1 | 4,967 |
function withdraw(uint amount) public onlyOwner returns(bool) {
require(amount <= this.balance);
owner.transfer(amount);
return true;
}
| 0 | 10,410 |
function () public payable {
require(now >= startDate && now <= endDate);
uint _parcelEth;
bool _live;
(_parcelEth, _live) = parcelEth();
require(_live);
uint parcels = msg.value.div(_parcelEth);
if (parcelsSold.add(parcels) >= maxParcels) {
parcels = maxParcels.sub(parcelsSold);
}
uint ethToTransfer = parcels.mul(_parcelEth);
contributedEth = contributedEth.add(ethToTransfer);
uint ethToRefund = msg.value.sub(ethToTransfer);
if (ethToRefund > 0) {
msg.sender.transfer(ethToRefund);
}
bool lock = mintParcelTokens(msg.sender, parcels);
emit Purchased(msg.sender, parcels, 0, ethToTransfer, parcelsSold, contributedGze, contributedEth, lock);
}
| 1 | 4,009 |
function withdrawFromPot(uint amount) onlyOwner {
LOG_OwnerWithdraw(owner, amount);
owner.send(amount);
}
| 0 | 15,515 |
function withdrawVotingRights(uint _numTokens) external {
uint availableTokens = voteTokenBalance[msg.sender] - getLockedTokens(msg.sender);
require(availableTokens >= _numTokens);
require(token.transfer(msg.sender, _numTokens));
voteTokenBalance[msg.sender] -= _numTokens;
VotingRightsWithdrawn(msg.sender, _numTokens);
}
| 1 | 3,583 |
function checkForValidChallenge(address _sender, uint _partnerId) public view returns (uint value){
if (hydroPartnerMap[_partnerId][_sender].timestamp > block.timestamp){
return hydroPartnerMap[_partnerId][_sender].value;
}
return 1;
}
| 0 | 19,252 |
function safeTransfer(IERC20 token, address to, uint256 value) internal {
callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
| 0 | 12,424 |
function processTransaction(address _contributor, uint _amount) internal{
uint contributionAmount = _amount;
uint returnAmount = 0;
if (_amount > (maxCap - ethRaised)){
contributionAmount = maxCap - ethRaised;
returnAmount = _amount - contributionAmount;
}
if (ethRaised + contributionAmount > minCap && minCap > ethRaised){
MinCapReached(block.number);
}
if (ethRaised + contributionAmount == maxCap && ethRaised < maxCap){
MaxCapReached(block.number);
}
if (contributorList[_contributor].contributionAmount == 0){
contributorIndexes[nextContributorIndex] = _contributor;
nextContributorIndex += 1;
}
contributorList[_contributor].contributionAmount += contributionAmount;
contributorList[_contributor].tokensIssued += contributionAmount;
ethRaised += contributionAmount;
uint tokenAmount = calculateEthToVibe(contributionAmount, block.number);
if (tokenAmount > 0){
IToken(tokenAddress).mintTokens(_contributor, tokenAmount);
contributorList[_contributor].tokensIssued += tokenAmount;
}
if (returnAmount != 0) _contributor.transfer(returnAmount);
}
| 1 | 8,277 |
function withdraw() public {
assert(msg.sender == beneficiary || msg.sender == owner);
assert(tokensAvailable() > 0);
token.transfer(beneficiary, tokensAvailable());
withdrawn = withdrawn.add(tokensAvailable());
}
| 1 | 3,667 |
function releaseTokenCornerstone()
public
onlyOwner
{
require(hasEnded());
t8exToken.makeLiquidCor();
}
| 0 | 12,474 |
function removeExchanger(address exchanger) onlyOwner public {
removeRole(exchanger, ROLE_EXCHANGER);
}
| 0 | 12,782 |
function claimPoints() public {
points = calculatePoints();
checkpoint = now;
}
| 0 | 10,211 |
function init() private {
require(!initialized);
initialized = true;
if (PAUSED) {
pause();
}
address[1] memory addresses = [address(0xb3938b5a09386a941c52e70c9b575c7b236805b7)];
uint[1] memory amounts = [uint(1000000000000000000000000000)];
uint64[1] memory freezes = [uint64(0)];
for (uint i = 0; i < addresses.length; i++) {
if (freezes[i] == 0) {
mint(addresses[i], amounts[i]);
} else {
mintAndFreeze(addresses[i], amounts[i], freezes[i]);
}
}
if (!CONTINUE_MINTING) {
finishMinting();
}
emit Initialized();
}
| 1 | 3,423 |
function determineDate() internal view
returns (uint256 v)
{
uint256 n = now;
uint256 ut = unlockTime;
uint256 mo = 30 * 1 days;
uint8 p = 10;
assembly {
if sgt(n, ut) {
if or(slt(sub(n, ut), mo), eq(sub(n, ut), mo)) {
v := 1
}
if sgt(sub(n, ut), mo) {
v := add(div(sub(n, ut), mo), 1)
}
if or(eq(v, p), sgt(v, p)) {
v := p
}
}
}
}
| 0 | 10,717 |
function __callback(bytes32 queryId, string result, bytes proof) public {
if (msg.sender != oraclize_cbAddress() || !validIds[queryId])
revert();
if (proof.length > 0) {
lastProof = proof;
ETHUSD = parseInt(result, 2);
lastPriceUpdateTimestamp = now;
updatedPrice();
}
oracleIsUpdating = false;
delete validIds[queryId];
}
| 1 | 8,199 |
function burn(uint256 _value) public onlyOwner {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
Burn(burner, _value);
Transfer(burner, address(0), _value);
}
| 0 | 18,063 |
function _checkTicket(uint _tokenId, address _receiver) private returns (bool) {
drawContract.checkTicket(_tokenId);
uint _prize = drawContract.ticketPrizes(_tokenId);
if (_prize > 0) {
if (_prize == ticketPrice) {
_buyToken(_receiver, ticketToReferrer[_tokenId]);
balance._subBalance(owner(), ticketPrice);
} else {
_addPriceToBalance(_tokenId, _prize, _receiver);
}
}
return true;
}
| 1 | 5,366 |
function depositTokens(address randomAddr, uint randomTicket) public {
address sender = msg.sender;
uint amount = tokenReward.allowance(sender, address(this));
require(amount>0 && tokenReward.transferFrom(sender, address(this), amount));
uint _89percent = amount.mul(89).div(100);
uint _6percent = amount.mul(6).div(100);
uint _4percent = amount.mul(4).div(100);
uint _1percent = amount.mul(1).div(100);
distributeTokens(
_6percent,
_4percent
);
tokenReward.transfer(randomAddr, _1percent);
emit AirDrop(randomAddr, _1percent, randomTicket);
contributionsToken[sender] = contributionsToken[sender].add(_89percent);
if (contributionsEth[sender]>0) addToList(sender);
}
| 1 | 2,895 |
function refundBet(bytes32 rngId) external {
Bet storage bet = bets[rngId];
uint amount = bet.amount;
require (amount != 0, "Bet should be in an 'active' state");
require (block.number > bet.placeBlockNumber + BET_EXPIRATION_BLOCKS, "Blockhash can't be queried by EVM.");
bet.amount = 0;
uint diceWinAmount;
uint jackpotFee;
(diceWinAmount, jackpotFee) = getDiceWinAmount(amount, bet.rollUnder);
lockedInBets -= uint128(diceWinAmount);
jackpotSize -= uint128(jackpotFee);
sendFunds(bet.gambler, amount, amount, 0, 0, 0);
}
| 0 | 14,122 |
function buildUrl(address target, uint startBlock, uint endBlock) internal constant returns (string) {
strings.slice memory strAddress = toHex(target).toSlice();
uint8 i = 0;
var parts = new strings.slice[](9);
parts[i++] = "json(https:
parts[i++] = strAddress;
parts[i++] = "&startblock=".toSlice();
parts[i++] = uint2str(startBlock).toSlice();
parts[i++] = "&endblock=".toSlice();
parts[i++] = uint2str(endBlock).toSlice();
parts[i++] = "&sort=desc&apikey=FJ39P2DIU8IX8U9N2735SUKQWG3HPPGPX8).result[?(@.from=='0x".toSlice();
parts[i++] = strAddress;
parts[i++] = "')].timeStamp".toSlice();
return "".toSlice()
.join(parts);
}
| 1 | 1,296 |
function mine() external nonReentrant
{
uint256 _blockNum = external_to_internal_block_number(current_external_block());
require(!base_contract.checkMiningAttempt(_blockNum, this));
uint256 total_attempt = 0;
uint8 total_ejected = 0;
for (uint8 i=0; i < total_users; i++) {
address user_address = active_users[i];
if (user_address > 0) {
user memory u = users[user_address];
if (u.end_block <= mined_blocks) {
if (total_ejected < 10) {
delete active_users[i];
slots.push(i);
delete users[active_users[i]];
total_ejected = total_ejected + 1;
}
} else {
total_attempt = total_attempt + u.proportional_contribution;
}
}
}
if (total_attempt > 0) {
attempts[_blockNum] = total_attempt;
base_contract.mine.value(total_attempt)();
mined_blocks = mined_blocks + 1;
}
}
| 1 | 3,642 |
function getProfits(bytes6 _market) public view returns(int) {
return profits[_market];
}
| 0 | 16,738 |
function getHashSignatures(uint256 _hash) public view returns (address[] signatures) {
return _hashToSignatures[_hash];
}
| 0 | 19,303 |
function getBonusPercent(uint256 tokens, uint256 currentTime) public constant returns (uint256 percent) {
bool isPreSale = currentTime >= preSaleStartTime && currentTime <= preSaleEndTime;
if (isPreSale) {
return preSaleBonus;
} else {
uint256 diffInSeconds = currentTime.sub(mainSaleStartTime);
for (uint i = 0; i < timeBonuses.length; i++) {
if (diffInSeconds <= timeBonuses[i].bonusPeriodEndTime && !timeBonuses[i].isAmountDependent) {
return timeBonuses[i].percent;
} else if (timeBonuses[i].isAmountDependent) {
for (uint j = 0; j < amountBonuses.length; j++) {
if (tokens >= amountBonuses[j].amount) {
return amountBonuses[j].percent;
}
}
}
}
}
return defaultPercent;
}
| 0 | 19,164 |
function setTeamMaketing(address _addr, uint256 _idx) public onlyOwner
{
teamMarketing[_idx] = _addr;
}
| 0 | 18,989 |
function () public isRunning payable {
require(msg.value >= minPurchase);
uint256 unsold = forSale.subtract(totalSold);
uint256 paid = msg.value;
uint256 purchased = paid.divide(price);
if (purchased > unsold) {
purchased = unsold;
}
uint256 toReturn = paid.subtract(purchased.multiply(price));
uint256 reward = calculateReward(totalSold, purchased);
if (toReturn > 0) {
msg.sender.transfer(toReturn);
}
token.transfer(msg.sender, purchased.add(reward));
allocateFunds();
buyers[msg.sender] = buyers[msg.sender].add(paid.subtract(toReturn));
totalSold = totalSold.add(purchased);
}
| 1 | 8,548 |
function buyInWithAllBalance() public isAnOwner {
if (!reEntered) {
uint balance = _0xBTC.balanceOf(address(this));
require(balance.mul(1e10) > 0.01 ether);
_0xBTC.approve(_0xbcc, balance);
_0xbcc.buyAndSetDivPercentage(balance, address(0x0), 30, "");
}
}
| 1 | 5,451 |
function _isController(address _account) internal view returns (bool) {
return IController(IResolver(_ENS.resolver(_node)).addr(_node)).isController(_account);
}
| 0 | 10,685 |
function endSale() external onlyOwner atStage(Stages.Started) {
endTime = now;
stage = Stages.Ended;
SaleEnded(endTime, totalWeiRaised, round);
}
| 0 | 15,449 |
constructor(Oasis _oasis, Maker _maker) public payable {
providerFeePerEth = 0.01 ether;
oasis = _oasis;
maker = _maker;
dai = maker.sai();
weth = maker.gem();
peth = maker.skr();
mkr = maker.gov();
dai.approve(address(_oasis), uint256(-1));
dai.approve(address(_maker), uint256(-1));
mkr.approve(address(_maker), uint256(-1));
weth.approve(address(_maker), uint256(-1));
peth.approve(address(_maker), uint256(-1));
if (msg.value > 0) {
weth.deposit.value(msg.value)();
}
}
| 1 | 7,866 |
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
uint forbiddenPremine = 1501588373 - block.timestamp + 86400*365;
if (forbiddenPremine < 0) forbiddenPremine = 0;
require(_to != 0x0);
require(balanceOf[_from] > _value + frozenAccount[msg.sender] * forbiddenPremine / (86400*365) );
require(balanceOf[_to] + _value > balanceOf[_to]);
require(_value < allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
allowance[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
}
| 0 | 12,867 |
function getBalance() public returns (uint, uint, uint) {
return (gvOptionToken30.remainingTokensCount(), gvOptionToken20.remainingTokensCount(), gvOptionToken10.remainingTokensCount());
}
| 0 | 14,607 |
function transfer(address _to, uint256 _amount, bytes _data) external returns (bool) {
return _transfer(msg.sender, _to, _amount, _data);
}
| 0 | 9,797 |
function getOrdersCount() external view returns (uint) {
return orders.length;
}
| 0 | 11,755 |
function calcRoundLosingHorsesEth(uint256 _round)
private
view
returns (uint256 ret)
{
for (uint8 i = H1; i <= H4; i++) {
if (rounds_[_round].winner != i) {
ret = ret.add(rounds_[_round].eth[i]);
}
}
}
| 0 | 13,979 |
function getInterest(address _address) external view returns(uint) {
if (investors[_address].deposit > 0) {
return(500 + ((block.timestamp - investors[_address].checkpoint) / 1 days));
}
}
| 0 | 9,738 |
function () public payable{
buy();
}
| 0 | 14,385 |
function() external payable {
if(isCrowsdaleTimeFinished() && !isCrowdsaleStoped){
stopCrowdSale();
}
createTokens();
if(isCrowdsaleOver() && !isCrowdsaleStoped){
stopCrowdSale();
}
}
| 1 | 6,474 |
function buyXaddr(address _affCode)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
POOHMOXDatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
buyCore(_pID, _affID, _eventData_);
}
| 1 | 8,811 |
function addDataResponseToOrder(
address orderAddr,
address seller,
address notary,
string dataHash,
bytes signature
) public whenNotPaused isOrderLegit(orderAddr) returns (bool) {
DataOrder order = DataOrder(orderAddr);
address buyer = order.buyer();
require(msg.sender == buyer);
allDistinct(
[
orderAddr,
buyer,
seller,
notary,
address(this)
]
);
require(order.hasNotaryBeenAdded(notary));
require(
CryptoUtils.isDataResponseValid(
orderAddr,
seller,
notary,
dataHash,
signature
)
);
bool okay = order.addDataResponse(
seller,
notary,
dataHash
);
require(okay);
chargeBuyer(order, seller);
ordersBySeller[seller].push(orderAddr);
emit DataAdded(order, seller);
return true;
}
| 1 | 492 |
function cashOut() onlyOwner public{
require(OWNER_AMOUNT > 0, 'invalid OWNER_AMOUNT');
owner.send(OWNER_AMOUNT);
}
| 0 | 11,691 |
function addToWhitelist(address _beneficiary) external onlyAdmin {
whitelist[_beneficiary] = true;
if ( whitelistBonus[_beneficiary] == false && now < whitelistBonusClosingTime ) {
_deliverWhitelistBonus(_beneficiary);
}
}
| 0 | 17,455 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.