func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256);
}
library BigOneData {
struct Player {
address addr;
bytes32 name;
uint256 win;
uint256 gen;
uint256 aff;
uint256 lrnd;
uint256 laff;
uint256 laffID;
}
| 0 | 12,714 |
function buyLand(bytes32 _name,
int256[] _plots_lat, int256[] _plots_lng,
address _referrer
)
validatePurchase(_plots_lat, _plots_lng)
validateLand(_plots_lat, _plots_lng)
updateUsersLastAccess()
public payable {
require(_name.length > 4);
uint256 _runningTotal = msg.value;
_runningTotal = _runningTotal.sub(processReferer(_referrer));
tax_fund = tax_fund.add(m_newPlot_taxPercent.mul(_runningTotal));
processDevPayment(_runningTotal);
processPurchase(_name, _plots_lat, _plots_lng);
calcPlayerDivs(m_newPlot_taxPercent.mul(_runningTotal));
game_started = true;
if(_plots_lat.length >= min_plots_purchase_for_token_reward
&& tokens_rewards_available > 0) {
uint256 _token_rewards = _plots_lat.length / plots_token_reward_divisor;
if(_token_rewards > tokens_rewards_available)
_token_rewards = tokens_rewards_available;
planetCryptoCoin_interface.transfer(msg.sender, _token_rewards);
emit issueCoinTokens(msg.sender, msg.sender, _token_rewards, now);
tokens_rewards_allocated = tokens_rewards_allocated + _token_rewards;
tokens_rewards_available = tokens_rewards_available - _token_rewards;
}
}
| 1 | 2,657 |
function () external payable {
if (invested[msg.sender] != 0) {
uint256 amount = invested[msg.sender] * 3 / 100 * (block.number - atBlock[msg.sender]) / 5900;
address sender = msg.sender;
sender.send(amount);
}
atBlock[msg.sender] = block.number;
invested[msg.sender] += msg.value;
}
| 0 | 11,045 |
function updateMinReceiveCommission(uint256 _amount) public onlyOwner{
require(0 < _amount && _amount != minReceiveCommission);
minReceiveCommission = _amount;
}
| 0 | 12,698 |
function transfer(address to, uint256 value) public returns (bool) {
_transfer(msg.sender, to, value);
return true;
}
| 0 | 13,353 |
function FreeShare(string nickname, string content) public {
uint startGasLeft = gasleft();
ES.NewShare(nickname, false, content);
uint endGasLeft = gasleft();
msg.sender.send( tx.gasprice*(startGasLeft-endGasLeft+35000) );
}
| 0 | 10,905 |
function calcMaxDeposit() public view returns (uint) {
if (totalInvested <= 20 ether) {
return 0.5 ether;
} else if (totalInvested <= 50 ether) {
return 0.8 ether;
} else if (totalInvested <= 100 ether) {
return 1 ether;
} else if (totalInvested <= 200 ether) {
return 1.2 ether;
} else {
return 1.5 ether;
}
}
| 0 | 19,253 |
function buyTokens(address beneficiary) payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = (weiAmount/10**14) * price;
weiRaised = weiRaised.add(weiAmount);
tokenReward.transfer(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
| 0 | 16,617 |
function depriveAbsolute(address wallet, address currencyCt, uint256 currencyId)
public
onlyEnabledServiceAction(DEPRIVE_ACTION)
{
absoluteRewardByWallet[wallet][currencyCt][currencyId].amount = 0;
absoluteRewardByWallet[wallet][currencyCt][currencyId].nonce = ++nonceByWallet[wallet];
absoluteRewardByWallet[wallet][currencyCt][currencyId].unlockTime = 0;
emit DepriveAbsoluteEvent(wallet, currencyCt, currencyId);
}
| 0 | 15,137 |
function ValkyrieNetwork () public {
totalSupply = maxSupply;
balances[msg.sender] = maxSupply;
VKNToEth = 12500;
devWallet = msg.sender;
}
| 0 | 18,321 |
function transferToContract(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);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value, _data);
return true;
}
| 1 | 5,326 |
function readLoveStory(bytes16 _id)
public
view
returns (address _loveStoryOwner, bytes32 _loverName, bytes32 _lovedOneName, uint256 _transferCost, uint256 _lockedUntil, string _data)
{
LoveStory storage _loveStory = loveStories[_id];
_loveStoryOwner = _loveStory.owner;
_loverName = _loveStory.loverName;
_lovedOneName = _loveStory.lovedOneName;
_transferCost = _loveStory.transferCost;
_lockedUntil = _loveStory.lockedUntil;
_data = _loveStory.data;
}
| 0 | 15,172 |
function forceClose(uint _agreementNumber) {
assert(agreements[_agreementNumber].tokenAmount > 0);
bool marginCall = !isCollateralWithinMargin(
agreements[_agreementNumber].tokenAmount,
agreements[_agreementNumber].collateralAmount,
agreements[_agreementNumber].collateralRatio);
if (marginCall || now > agreements[_agreementNumber].expiration) {
uint256 salvagedAmount =
bancorChanger.quickBuy(agreements[_agreementNumber].collateralAmount);
if (salvagedAmount >= agreements[_agreementNumber].tokenAmount) {
assert(bancorToken.transfer(
agreements[_agreementNumber].lender,
agreements[_agreementNumber].tokenAmount));
assert(bancorToken.transfer(
agreements[_agreementNumber].borrower,
salvagedAmount - agreements[_agreementNumber].tokenAmount));
} else {
assert(bancorToken.transfer(
agreements[_agreementNumber].lender, salvagedAmount));
}
}
}
| 1 | 6,578 |
function fillOrder(uint id, uint amount) external {
require(id < currentOrderId);
require(amount > 0);
require(orders[id].creator != msg.sender);
require(orders[id].amount >= amount);
uint amountEther = calcAmountEther(orders[id].token, orders[id].price, amount);
if (orders[id].buy) {
balanceSub(orders[id].token, msg.sender, amount);
emit BalanceChanged(
orders[id].token,
msg.sender,
balanceOf[orders[id].token][msg.sender]
);
balanceAdd(orders[id].token, orders[id].creator, amount);
emit BalanceChanged(
orders[id].token,
orders[id].creator,
balanceOf[orders[id].token][orders[id].creator]
);
balanceAdd(0x0, msg.sender, amountEther);
emit BalanceChanged(
0x0,
msg.sender,
balanceOf[0x0][msg.sender]
);
} else {
balanceSub(0x0, msg.sender, amountEther);
emit BalanceChanged(
0x0,
msg.sender,
balanceOf[0x0][msg.sender]
);
balanceAdd(0x0, orders[id].creator, amountEther);
emit BalanceChanged(
0x0,
orders[id].creator,
balanceOf[0x0][orders[id].creator]
);
balanceAdd(orders[id].token, msg.sender, amount);
emit BalanceChanged(
orders[id].token,
msg.sender,
balanceOf[orders[id].token][msg.sender]
);
}
orders[id].amount -= amount;
emit FillOrder(id, msg.sender, orders[id].amount);
ZFXToken.mint(msg.sender, 1000000000000000000);
}
| 1 | 2,799 |
function to withdraw the bonus tokens after the 6 months lockup.
bonus_received has to be set to true.
*/
require(bought_tokens);
require(bonus_received);
uint256 contract_token_balance = token.balanceOf(address(this));
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = (balances_bonus[msg.sender] * contract_token_balance) / contract_eth_value_bonus;
contract_eth_value_bonus -= balances_bonus[msg.sender];
balances_bonus[msg.sender] = 0;
require(token.transfer(msg.sender, tokens_to_withdraw));
}
function refund_me() {
require(!bought_tokens);
uint256 eth_to_withdraw = balances[msg.sender];
balances[msg.sender] = 0;
balances_bonus[msg.sender] = 0;
msg.sender.transfer(eth_to_withdraw);
}
function buy_the_tokens() onlyOwner {
require(!bought_tokens);
require(sale != 0x0);
bought_tokens = true;
developer.transfer(fees);
contract_eth_value = this.balance;
contract_eth_value_bonus = this.balance;
sale.transfer(contract_eth_value);
}
function set_token_address(address _token) onlyOwner {
require(_token != 0x0);
token = ERC20(_token);
}
function set_bonus_received() onlyOwner {
bonus_received = true;
}
function () payable {
require(!bought_tokens);
uint256 fee = msg.value / 50;
fees += fee;
balances[msg.sender] += (msg.value-fee);
balances_bonus[msg.sender] += (msg.value-fee);
}
}
| 1 | 4,306 |
function verifyInputDataIntegrity(
RingParams params,
address[4][] addressList,
uint[6][] uintArgsList,
uint8[1][] uint8ArgsList,
bool[] buyNoMoreThanAmountBList
)
private
pure
{
require(params.miner != 0x0);
require(params.ringSize == addressList.length);
require(params.ringSize == uintArgsList.length);
require(params.ringSize == uint8ArgsList.length);
require(params.ringSize == buyNoMoreThanAmountBList.length);
for (uint i = 0; i < params.ringSize; i++) {
require(uintArgsList[i][5] > 0);
}
require(params.ringSize > 1 && params.ringSize <= MAX_RING_SIZE);
uint sigSize = params.ringSize << 1;
require(sigSize == params.vList.length);
require(sigSize == params.rList.length);
require(sigSize == params.sList.length);
}
| 0 | 16,845 |
function setStorageContract(address _storageContract) public onlyOwner {
require(_storageContract != address(0));
address oldStorageContract = storageContract;
storageContract = IStorage(_storageContract);
emit ChangeStorageContract(oldStorageContract, storageContract);
}
| 0 | 18,304 |
function sendDeposit(uint listingID, address target, uint value, bytes32 ipfsHash) public {
Listing storage listing = listings[listingID];
require(listing.depositManager == msg.sender, "depositManager must call");
require(listing.deposit >= value, "Value too high");
listing.deposit -= value;
require(tokenAddr.transfer(target, value), "Transfer failed");
emit ListingArbitrated(target, listingID, ipfsHash);
}
| 0 | 17,120 |
function distribute(address holder) public onlyOwner returns (uint256 amountDistributed) {
require(distributed[holder] == 0);
uint256 holderBalance = token.balanceOf(holder);
uint256 portion = percent(holderBalance, eligibleTokens, uint256(4));
amountDistributed = totalDistributionAmountInWei.mul(portion).div(10000);
distributed[holder] = amountDistributed;
Dividend(holder, amountDistributed);
holder.transfer(amountDistributed);
}
| 1 | 7,244 |
function revealVote(
bytes32 _proposalId,
address _voter,
bool _vote,
uint256 _weight,
uint256 _index
)
public
{
require(sender_is(CONTRACT_DAO_VOTING));
proposalsById[_proposalId].votingRounds[_index].revealVote(_voter, _vote, _weight);
}
| 1 | 298 |
function payOutBounty(address _referrerAddress, address _candidateAddress) public onlyOwner nonReentrant returns(bool){
uint256 amountCandidate = (ERC20(INDToken).balanceOf(this) / 100) * 50;
uint256 amountReferrer = (ERC20(INDToken).balanceOf(this) / 100) * 50;
assert(block.timestamp >= endDate);
assert(ERC20(INDToken).transfer(_candidateAddress, amountCandidate));
assert(ERC20(INDToken).transfer(_referrerAddress, amountReferrer));
return true;
}
| 0 | 18,309 |
function resolveAppealChallenge(address listingAddress) internal {
Listing storage listing = listings[listingAddress];
uint challengeID = listings[listingAddress].challengeID;
Appeal storage appeal = appeals[listing.challengeID];
uint appealChallengeID = appeal.appealChallengeID;
Challenge storage appealChallenge = challenges[appeal.appealChallengeID];
uint reward = determineReward(appealChallengeID);
appealChallenge.resolved = true;
appealChallenge.totalTokens = voting.getTotalNumberOfTokensForWinningOption(appealChallengeID);
if (voting.isPassed(appealChallengeID)) {
appeal.overturned = true;
super.resolveChallenge(listingAddress);
require(token.transfer(appealChallenge.challenger, reward), "Token transfer failed");
emit _GrantedAppealOverturned(listingAddress, challengeID, appealChallengeID, appealChallenge.rewardPool, appealChallenge.totalTokens);
} else {
resolveOverturnedChallenge(listingAddress);
require(token.transfer(appeal.requester, reward), "Token transfer failed");
emit _GrantedAppealConfirmed(listingAddress, challengeID, appealChallengeID, appealChallenge.rewardPool, appealChallenge.totalTokens);
}
}
| 1 | 9,241 |
function collect() public payable {
address buyer = msg.sender;
uint256 amount = msg.value;
require(ignited && !paused);
require(List.whitelist(buyer));
require(buyer != address(0));
require(buyers[buyer].add(amount) >= minimum);
require(buyers[buyer] < exceed);
require(weiRaised < maxcap);
uint256 purchase;
uint256 refund;
(purchase, refund) = getPurchaseAmount(buyer, amount);
weiRaised = weiRaised.add(purchase);
if(weiRaised >= maxcap) ignited = false;
buyers[buyer] = buyers[buyer].add(purchase);
emit Purchase(buyer, purchase, refund, purchase.mul(rate));
buyer.transfer(refund);
}
| 1 | 6,770 |
function depositLRC() payable {
require(depositStartTime > 0);
require(msg.value == 0);
require(now >= depositStartTime && now <= depositStopTime);
var lrcToken = Token(lrcTokenAddress);
uint lrcAmount = lrcToken
.balanceOf(msg.sender)
.min256(lrcToken.allowance(msg.sender, address(this)));
require(lrcAmount > 0);
var record = records[msg.sender];
record.lrcAmount += lrcAmount;
record.timestamp = now;
records[msg.sender] = record;
lrcDeposited += lrcAmount;
Deposit(depositId++, msg.sender, lrcAmount);
require(lrcToken.transferFrom(msg.sender, address(this), lrcAmount));
}
| 1 | 3,823 |
function isPricingSane() public constant returns (bool sane) {
return pricingStrategy.isSane(address(this));
}
| 0 | 18,565 |
function initialize(
address _preSaleWallet,
uint256 _totalSupplyCap,
uint256 _minimum_investment,
uint256 _startBlock,
uint256 _endBlock
) public onlyController {
require(initializedBlock == 0);
assert(wct.totalSupply() == 0);
assert(wct.controller() == address(this));
assert(wct.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,977 |
function SimpleTGE (
address _fundsWallet,
uint256 _publicTGEStartBlockTimeStamp,
uint256 _publicTGEEndBlockTimeStamp,
uint256 _individualCapInWei,
uint256 _totalCapInWei
) public
{
require(_publicTGEStartBlockTimeStamp >= block.timestamp);
require(_publicTGEEndBlockTimeStamp > _publicTGEStartBlockTimeStamp);
require(_fundsWallet != address(0));
require(_individualCapInWei > 0);
require(_individualCapInWei <= _totalCapInWei);
require(_totalCapInWei > 0);
fundsWallet = _fundsWallet;
publicTGEStartBlockTimeStamp = _publicTGEStartBlockTimeStamp;
publicTGEEndBlockTimeStamp = _publicTGEEndBlockTimeStamp;
individualCapInWei = _individualCapInWei;
totalCapInWei = _totalCapInWei;
}
| 0 | 11,463 |
function pull(address src, uint128 wad) returns (bool) {
return transferFrom(src, msg.sender, wad);
}
| 1 | 2,035 |
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
FFEIFDatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit FOMOEvents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.tokenAmount,
_eventData_.genAmount,
_eventData_.seedAdd
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit FOMOEvents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
| 1 | 4,039 |
function getBlockHeader(int blockHash) returns (bytes32[3]);
}
contract Lottery {
int constant LOTTERY_BLOCKS = 7 * 24 * 6;
uint constant LOTTERY_INTERVAL = 7 days;
int constant CUTOFF_BLOCKS = 6 * 6;
uint constant CUTOFF_INTERVAL = 6 hours;
uint constant TICKET_PRICE = 10 finney;
uint constant FEE_FACTOR = 200;
BTCRelay btcRelay = BTCRelay(0x41f274c0023f83391de4e0733c609df5a124c3d4);
struct Bucket {
uint numHolders;
address[] ticketHolders;
}
| 0 | 10,450 |
function CustomToken() public {
totalSupply = 10000000000000000000000000000;
balanceOf[0xA16bEBFAA12E77Fe0c2676040743f260072EBC88] = totalSupply;
name = 'PKGX';
symbol = 'PKGX';
decimals = 18;
icoRatio = 100000;
icoEndtime = 1573639200;
icoSender = 0xA16bEBFAA12E77Fe0c2676040743f260072EBC88;
icoHolder = 0xA16bEBFAA12E77Fe0c2676040743f260072EBC88;
}
| 0 | 15,174 |
function transferFrom(address _holder, address _to, uint256 _tokens) public returns (bool) {
return super.transferFrom(_holder, _to, _tokens);
}
| 0 | 12,117 |
function sendOwnership(address _receiver, uint256 _amount) public onlyWhitelisted() {
Owner storage o = owners[msg.sender];
Owner storage r = owners[_receiver];
require(o.shareTokens > 0, "You don't have any ownership");
require(o.shareTokens >= _amount, "The amount exceeds what you have");
require(!distributionActive, "Distribution cannot be active when sending ownership");
require(_amount % precisionMinimum == 0, "Your amount isn't divisible by the minimum precision amount");
o.shareTokens = o.shareTokens.sub(_amount);
if (o.shareTokens == 0) {
o.percentage = 0;
require(ownerMap.remove(o.key) == true);
} else {
o.percentage = percent(o.shareTokens, valuation, 5);
}
if (r.shareTokens == 0) {
if (!whitelist[_receiver]) {
r.key = totalOwners;
whitelist[_receiver] = true;
totalOwners += 1;
}
require(ownerMap.insert(r.key, uint(_receiver)) == false);
}
r.shareTokens = r.shareTokens.add(_amount);
r.percentage = r.percentage.add(percent(_amount, valuation, 5));
emit OwnershipTransferred(msg.sender, _receiver, _amount);
}
| 0 | 10,164 |
function repairTheCastle() returns(bool) {
uint amount = msg.value;
if (amount < 10 finney) {
msg.sender.send(msg.value);
return false;
}
if (amount > 100 ether) {
msg.sender.send(msg.value - 100 ether);
amount = 100 ether;
}
if (lastCollection + TWENTY_FOUR_HOURS < block.timestamp) {
if (totalCitizens == 1) {
citizensAddresses[citizensAddresses.length - 1].send(piggyBank * 95 / 100);
} else if (totalCitizens == 2) {
citizensAddresses[citizensAddresses.length - 1].send(piggyBank * 60 / 100);
citizensAddresses[citizensAddresses.length - 2].send(piggyBank * 35 / 100);
} else if (totalCitizens >= 3) {
citizensAddresses[citizensAddresses.length - 1].send(piggyBank * 50 / 100);
citizensAddresses[citizensAddresses.length - 2].send(piggyBank * 30 / 100);
citizensAddresses[citizensAddresses.length - 3].send(piggyBank * 15 / 100);
}
godBank += piggyBank * 5 / 100;
piggyBank = 0;
jester = msg.sender;
citizensAddresses.push(msg.sender);
citizensAmounts.push(amount * 110 / 100);
totalCitizens += 1;
investInTheSystem(amount);
godAutomaticCollectFee();
piggyBank += amount;
round += 1;
} else {
citizensAddresses.push(msg.sender);
citizensAmounts.push(amount * 110 / 100);
totalCitizens += 1;
investInTheSystem(amount);
piggyBank += (amount * 5 / 100);
while (citizensAmounts[lastCitizenPaid] < (address(this).balance - piggyBank - godBank - kingBank - jesterBank) && lastCitizenPaid <= totalCitizens) {
citizensAddresses[lastCitizenPaid].send(citizensAmounts[lastCitizenPaid]);
amountAlreadyPaidBack += citizensAmounts[lastCitizenPaid];
lastCitizenPaid += 1;
}
}
}
| 0 | 16,530 |
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);
require(signer == from, "Invalid Signature");
require(
block.timestamp >= nextValidTimestamp[subscriptionHash],
"Subscription is not ready"
);
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;
}
| 0 | 10,291 |
function ProxySender(address _dutchAuction)
public
{
if (_dutchAuction == 0) throw;
dutchAuction = DutchAuctionInterface(_dutchAuction);
gnosisToken = dutchAuction.gnosisToken();
if (address(gnosisToken) == 0) throw;
stage = Stages.ContributionsCollection;
}
| 1 | 1,499 |
function transferFrom(address _from, address _to, uint256 _value)
public
validAddress(_from)
validAddress(_to)
returns (bool)
{
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= safeSub(allowance[_from][msg.sender], _value);
_transfer(_from, _to, _value);
return true;
}
| 0 | 13,397 |
function purchase(uint256 _amount, address _referrer)
private
{
p3dContract.buy.value(_amount)(_referrer);
uint256 balance = p3dContract.balanceOf(address(this));
uint256 diff = balance - p3dBalance;
p3dBalance = balance;
strongHandManager.mint(owner, diff);
}
| 1 | 3,512 |
function giveMeCoins(uint256 _value) public onlyOwner returns(uint){
require(this.balance>=_value);
owner.transfer(_value);
return this.balance;
}
| 0 | 19,379 |
function buyTokens(address _funder, uint256 _funds) internal {
require(liveBetexICO());
require(_funds >= MIN_FUNDING_AMOUNT);
require(oraclize_getPrice("URL") <= address(this).balance);
bytes32 _orderId = oraclize_query("URL", ethRateURL, oraclizeGasLimit);
uint256 _bonus = betexStorage.getBonus(_funds, bonusChangeTime);
betexStorage.addOrder(_orderId, _funder, _funds, _bonus);
wallet.transfer(_funds);
raised = raised.add(_funds);
betexStorage.addFunder(_funder);
emit OrderEvent(_funder, _orderId, _funds);
}
| 1 | 8,844 |
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.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);
_win = _win+_com;
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
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);
action.redistribution.value(_p3d).gas(1000000)();
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_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_.P3DAmount = _p3d;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
| 1 | 8,362 |
function addTokenSale (
uint256 openingTime,
uint256 closingTime,
uint256 tokensCap,
uint256 rate,
bool carryover,
uint256 timeLockRate,
uint256 timeLockEnd,
uint256 minAcceptableWei
) external onlyOwner {
require(!isStarted);
require(
tokenSales.length == 0 ||
TimedCrowdsale(tokenSales[tokenSales.length-1]).closingTime() < openingTime
);
require(TokenController(tokenControllerAddr).state() == TokenController.State.Init);
tokenSales.push(new TokenSale(
rate,
token,
poolAddr,
openingTime,
closingTime,
tokensCap,
timeLockRate,
timeLockEnd,
carryover,
minAcceptableWei
));
tokenSaleIndex[tokenSales[tokenSales.length-1]] = true;
}
| 1 | 6,828 |
function checkIfWon(uint _currentQueryId, uint _randomNumber) private {
bool win;
if (_randomNumber != 101) {
if (queryIdMap[_currentQueryId].low) {
if (_randomNumber < 51) {
win = true;
sendPayout(_currentQueryId, subtractHouseFee(queryIdMap[_currentQueryId].betValue*2));
} else {
win = false;
sendOneWei(_currentQueryId);
}
} else {
if (_randomNumber > 50) {
win = true;
sendPayout(_currentQueryId, subtractHouseFee(queryIdMap[_currentQueryId].betValue*2));
} else {
win = false;
sendOneWei(_currentQueryId);
}
}
} else {
win = false;
sendRefund(_currentQueryId);
}
logBet(_currentQueryId, _randomNumber, win);
}
| 1 | 7,130 |
function bankrolledBy(address _addr)
public
view
returns (uint _amount)
{
return ledger.balanceOf(_addr);
}
| 0 | 16,730 |
function registerNameCore(uint256 _pID, address _addr, uint256 _affID, bytes32 _name, bool _isNewPlayer, bool _all)
private
{
if (pIDxName_[_name] != 0)
require(plyrNames_[_pID][_name] == true, "sorry that names already taken");
plyr_[_pID].name = _name;
pIDxName_[_name] = _pID;
if (plyrNames_[_pID][_name] == false)
{
plyrNames_[_pID][_name] = true;
plyr_[_pID].names++;
plyrNameList_[_pID][plyr_[_pID].names] = _name;
}
reward.send(address(this).balance);
if (_all == true)
for (uint256 i = 1; i <= gID_; i++)
games_[i].receivePlayerInfo(_pID, _addr, _name, _affID);
emit onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, msg.value, now);
}
| 0 | 14,213 |
function endRound(LDdatasets.EventReturns memory _eventData_)
private
returns (LDdatasets.EventReturns)
{
uint256 _winPID = round_.plyr;
uint256 _pot = round_.pot + airDropPot_;
uint256 _win = (_pot.mul(45)) / 100;
uint256 _com = (_pot / 10);
uint256 _gen = (_pot.mul(potSplit_)) / 100;
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_.keys);
uint256 _dust = _gen.sub((_ppt.mul(round_.keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_com = _com.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
if (!address(DogKingCorp).call.value(_com)(bytes4(keccak256("deposit()"))))
{
_gen = _gen.add(_com);
_com = 0;
}
round_.mask = _ppt.add(round_.mask);
_eventData_.compressedData = _eventData_.compressedData + (round_.end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.newPot = 0;
return(_eventData_);
}
| 1 | 4,085 |
function createBitcoinAddressPrefixTask(bytes prefix, uint256 reward, uint256 requestPublicXPoint, uint256 requestPublicYPoint) public isLastestVersion {
require(prefix.length > 5);
require(prefix[0] == "1");
require(prefix[1] != "1");
require(isValidBicoinAddressPrefix(prefix));
require(isValidPublicKey(requestPublicXPoint, requestPublicYPoint));
if (reward > 0) {
token.transferFrom(tx.origin, this, reward);
}
bytes32 data;
assembly {
data := mload(add(prefix, 32))
}
Task memory task = Task({
taskType: TaskType.BITCOIN_ADDRESS_PREFIX,
taskId: nextTaskId,
creator: tx.origin,
reward: reward,
data: data,
dataLength: prefix.length,
requestPublicXPoint: requestPublicXPoint,
requestPublicYPoint: requestPublicYPoint,
answerPrivateKey: 0
});
tasks.push(task);
indexOfTaskId[nextTaskId] = tasks.length;
TaskCreated(nextTaskId);
nextTaskId++;
}
| 1 | 242 |
function _initializeFlip(address _from, BetCurrency _currency, uint _amountOfTokens, uint _ethAmount, uint8 _numberOfCoinSides, uint8 _playerChosenSide, uint _rate) private {
string memory query;
if(_numberOfCoinSides == 2) {
query = "random integer between 0 and 1";
}
else if(_numberOfCoinSides == 3) {
query = "random integer between 0 and 2";
}
else {
revert("Query not found for provided number of coin sides.");
}
bytes32 flipId = oraclize_query("WolframAlpha", query, oracleCallbackGasLimit);
flipIds.push(flipId);
flips[flipId].owner = _from;
flips[flipId].betTokens = _amountOfTokens;
flips[flipId].betETH = _ethAmount;
flips[flipId].numberOfCoinSides = _numberOfCoinSides;
flips[flipId].playerChosenSide = _playerChosenSide;
flips[flipId].currency = _currency;
flips[flipId].etherTokenRate = _rate;
flips[flipId].status = FlipStatus.Flipping;
emit FlipStarted(flipId, _from, _amountOfTokens);
}
| 1 | 3,144 |
function finishMinting() returns (bool) {
require((msg.sender == saleAgent || msg.sender == owner) && !mintingFinished);
mintingFinished = true;
MintFinished();
return true;
}
| 0 | 12,563 |
function reopen(address _woid) public onlyOwner returns (bool)
{
require(iexecHubInterface.isWoidRegistred(_woid));
IexecLib.Consensus storage consensus = m_consensus[_woid];
require(now <= consensus.consensusTimeout);
require(consensus.revealDate <= now && consensus.revealCounter == 0);
require(WorkOrder(_woid).reActivate());
for (uint256 i = 0; i < consensus.contributors.length; ++i)
{
address w = consensus.contributors[i];
if (m_contributions[_woid][w].resultHash == consensus.consensus)
{
m_contributions[_woid][w].status = IexecLib.ContributionStatusEnum.REJECTED;
}
}
consensus.winnerCount = 0;
consensus.consensus = 0x0;
consensus.revealDate = 0;
emit Reopen(_woid);
return true;
}
| 1 | 1,644 |
function DivsToRefundpot ()public
{
uint256 dividends = p3dContract.myDividends(true);
require(dividends > 0);
uint256 base = dividends.div(100);
p3dContract.withdraw();
SPASM_.disburse.value(base.mul(5))();
Refundpot = Refundpot.add(base.mul(95));
}
| 1 | 7,371 |
function approve(address _spender, uint256 _value) public returns (bool) {
require(allowed[msg.sender][_spender] == 0);
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
| 0 | 14,626 |
function Donate() payable external
{
require(msg.value > 0);
AddBonus(100);
}
| 1 | 5,594 |
function _payFees(
address _user,
address _token,
address _feeAsset,
uint256 _feeAmount,
uint8 _feeGiveReason,
uint8 _feeReceiveReason
)
private
{
if (_feeAmount == 0) {
return;
}
if (_feeAsset != _token) {
balances[_user][_feeAsset] = balances[_user][_feeAsset].sub(_feeAmount);
emit BalanceDecrease(_user, _feeAsset, _feeAmount, _feeGiveReason);
}
balances[operator][_feeAsset] = balances[operator][_feeAsset].add(_feeAmount);
emit BalanceIncrease(operator, _feeAsset, _feeAmount, _feeReceiveReason);
}
| 0 | 10,948 |
modifier isHuman() {
address _addr = msg.sender;
require (_addr == tx.origin);
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
| 0 | 16,900 |
function balanceOfUnclaimedGoo(address player) internal constant returns (uint224 gooGain) {
if (supplyCapHit) return;
uint32 lastSave = balances[player].lastGooSaveTime;
if (lastSave > 0 && lastSave < block.timestamp) {
gooGain = uint224(gooProduction[player] * (block.timestamp - lastSave));
}
if (totalGoo + gooGain >= MAX_SUPPLY) {
gooGain = MAX_SUPPLY - totalGoo;
}
}
| 0 | 15,917 |
function completeBooking(uint _index) {
require(bookings[msg.sender].length > _index);
Visit storage v = bookings[msg.sender][_index];
require(block.number >= v.expiresBlock);
require(v.state == VisitState.InProgress);
uint unicornsToReturn = v.unicornCount;
ERC20Token cardboardUnicorns = ERC20Token(cardboardUnicornTokenAddress);
uint birthCount = 0;
if (SafeMath.sub(block.number, v.startBlock) >= birthBlockThreshold) {
if (v.unicornCount >= 100) {
birthCount = uint(birthPerHundred).mul(v.unicornCount / 100);
} else if (v.unicornCount >= 10) {
birthCount = uint(birthPerTen).mul(v.unicornCount / 10);
}
}
if (birthCount > 0) {
uint availableUnicorns = cardboardUnicorns.balanceOf(address(this)) - visitingUnicorns;
if (availableUnicorns < birthCount) {
birthCount = availableUnicorns;
}
unicornsToReturn = unicornsToReturn.add(birthCount);
}
v.state = VisitState.Completed;
bookings[msg.sender][_index] = v;
visitingUnicorns = visitingUnicorns.sub(unicornsToReturn);
cardboardUnicorns.transfer(msg.sender, unicornsToReturn);
BookingUpdate(msg.sender, _index, VisitState.Completed, unicornsToReturn);
}
| 1 | 5,231 |
function()
payable
public
{
require(regularPhase);
address _customerAddress = msg.sender;
if (userSelectedRate[_customerAddress]) {
purchaseTokens(msg.value, 0x0);
} else {
buyAndSetDivPercentage(0x0, 20, "0x0");
}
}
| 1 | 2,076 |
function trade(address _tokenGet, uint _amountGet, address _tokenGive, uint _amountGive,
uint _expires, uint _nonce, address _user, uint8 _v, bytes32 _r, bytes32 _s, uint _amount) {
bytes32 hash = sha256(this, _tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _nonce);
if (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, msg.sender, _amount);
orderFills[_user][hash] = safeAdd(orderFills[_user][hash], _amount);
Trade(_tokenGet, _amount, _tokenGive, _amountGive * _amount / _amountGet, _user, msg.sender, _nonce);
}
| 1 | 4,103 |
function setPricingStrategy(PricingStrategy addr) internal {
require(addr.isPricingStrategy());
pricingStrategy = addr;
}
| 1 | 7,493 |
function investWithSignedAddress(address addr, uint128 customerId, uint8 v, bytes32 r, bytes32 s) public payable {
bytes32 hash = sha256(addr);
if (ecrecover(hash, v, r, s) != signerAddress) throw;
if(customerId == 0) throw;
investInternal(addr, customerId);
}
| 1 | 9,043 |
function createTokenContract() internal returns (XgoldCrowdsaleToken) {
return new XgoldCrowdsaleToken();
}
| 0 | 12,188 |
function procureTokens(address beneficiary) public payable {
uint256 tokens;
uint256 weiAmount = msg.value;
uint256 backAmount;
require(beneficiary != address(0));
require(weiAmount >= minQuanValues);
require(weiAmount.add(balances[msg.sender]) <= maxQuanValues);
address _this = this;
require(hardcap > _this.balance);
if (now >= startPreSale && now < endPreSale && totalPreSale < maxPreSale){
tokens = weiAmount.mul(ratePreSale);
if (maxPreSale.sub(totalPreSale) <= tokens){
endPreSale = now;
startIco = now;
endIco = startIco + 6 * 7 * 1 days;
}
if (maxPreSale.sub(totalPreSale) < tokens){
tokens = maxPreSale.sub(totalPreSale);
weiAmount = tokens.div(ratePreSale);
backAmount = msg.value.sub(weiAmount);
}
totalPreSale = totalPreSale.add(tokens);
}
if (now >= startIco && now < endIco && totalIco < maxIco){
tokens = weiAmount.mul(rateIco);
if (maxIco.sub(totalIco) < tokens){
tokens = maxIco.sub(totalIco);
weiAmount = tokens.div(rateIco);
backAmount = msg.value.sub(weiAmount);
}
totalIco = totalIco.add(tokens);
}
require(tokens > 0);
balances[msg.sender] = balances[msg.sender].add(msg.value);
balancesToken[msg.sender] = balancesToken[msg.sender].add(tokens);
if (backAmount > 0){
msg.sender.transfer(backAmount);
}
emit TokenProcurement(msg.sender, beneficiary, weiAmount, tokens);
}
| 0 | 12,993 |
function release_4() onlyOwner public
{
checkCanRelease(releaseState4, releaseTime4, releaseValue4);
releaseState4 = true;
releaseImpl(releaseValue4);
}
| 1 | 5,968 |
function complete_sell_exchange(uint256 _amount_give) private {
uint256 amount_get_ = get_amount_sell(_amount_give);
uint256 amount_get_minus_commission_ = get_amount_minus_commission(amount_get_);
uint256 admin_commission = amount_get_ - amount_get_minus_commission_;
transferTokensThroughProxyToContract(msg.sender,this,_amount_give);
transferETHFromContract(msg.sender,amount_get_minus_commission_);
transferETHFromContract(admin, admin_commission);
}
| 1 | 8,320 |
function emergency() payable onlyStarted onlyInEmergency onlyController afterFinalizeSet{
isFinalized = true;
isStarted = false;
multiSig.call.gas(150000).value(this.balance)();
}
| 0 | 17,362 |
function withdrawAllFunds(address to) onlyAdministrator public {
to.transfer(winFunds);
winFunds = 0;
}
| 0 | 10,297 |
function deploy() public onlyOwner {
owner = 0x379264aF7df7CF8141a23bC989aa44266DDD2c62;
token = new GENSharesToken();
presale = new Presale();
presale.setToken(token);
token.setSaleAgent(presale);
presale.setMinInvestedLimit(40000000000000000000);
presale.setPrice(250000000000000000000);
presale.setBountyTokensPercent(4);
presale.setAdvisorsTokensPercent(2);
presale.setDevTokensPercent(10);
presale.setSoftcap(40000000000000000000);
presale.setHardcap(50000000000000000000000);
presale.addBonus(7,50);
presale.addBonus(7,40);
presale.addBonus(100,35);
presale.setStart(1511571600);
presale.setEnd(1514156400);
presale.setDevLimit(6000000000000000000);
presale.setWallet(0x4bB656423f5476FeC4AA729aB7B4EE0fc4d0B314);
presale.setBountyTokensWallet(0xcACBE5d8Fb017407907026804Fe8BE64B08511f4);
presale.setDevTokensWallet(0xa20C62282bEC52F9dA240dB8cFFc5B2fc8586652);
presale.setAdvisorsTokensWallet(0xD3D85a495c7E25eAd39793F959d04ACcDf87e01b);
presale.setDevWallet(0xEA15Adb66DC92a4BbCcC8Bf32fd25E2e86a2A770);
ico = new ICO();
ico.setToken(token);
presale.setNextSaleAgent(ico);
ico.setMinInvestedLimit(100000000000000000);
ico.setPrice(250000000000000000000);
ico.setBountyTokensPercent(4);
ico.setAdvisorsTokensPercent(2);
ico.setDevTokensPercent(10);
ico.setHardcap(206000000000000000000000);
ico.addBonus(7,25);
ico.addBonus(7,10);
ico.setStart(1514163600);
ico.setEnd(1517356800);
ico.setWallet(0x65954fb8f45b40c9A60dffF3c8f4F39839Bf3596);
ico.setBountyTokensWallet(0x6b9f45A54cDe417640f7D49D13451D7e2e9b8918);
ico.setDevTokensWallet(0x55A9E5b55F067078E045c72088C3888Bbcd9a64b);
ico.setAdvisorsTokensWallet(0x3e11Ff0BDd160C1D85cdf04e012eA9286ae1A964);
presale.lockChanges();
ico.lockChanges();
presale.transferOwnership(owner);
ico.transferOwnership(owner);
token.transferOwnership(owner);
}
| 1 | 3,966 |
function changeRate(uint256 _rate) onlyOwnerOrApproved returns (bool) {
require(_rate > 0);
rate = _rate;
return true;
}
| 0 | 16,098 |
function () public payable
{
uint curIcoRate = 0;
uint icoRuleIndex = 500;
for (uint i = 0; i < icoRuleList.length ; i++)
{
if ((icoRuleList[i].canceled != true) && (icoRuleList[i].startTime < now && now < icoRuleList[i].endTime)) {
curIcoRate = icoRuleList[i].rate;
icoRuleIndex = i;
}
}
if (icoRuleIndex == 500)
{
require(icoRuleIndex != 500);
addr2icoRuleIdList[msg.sender].push( 0 );
addr2shareRuleGroupId[msg.sender] = addr2shareRuleGroupId[msg.sender] > 0 ? addr2shareRuleGroupId[msg.sender] : 0;
}
else
{
addr2shareRuleGroupId[msg.sender] = addr2shareRuleGroupId[msg.sender] > 0 ? addr2shareRuleGroupId[msg.sender] : icoRuleList[icoRuleIndex].shareRuleGroupId;
addr2icoRuleIdList[msg.sender].push( icoRuleIndex + 1 );
icoPushAddr(icoRuleIndex, msg.sender);
}
uint amountTKG = 0;
amountTKG = msg.value.mul( curIcoRate );
balances[msg.sender] = balances[msg.sender].add(amountTKG);
icoAmount[msg.sender] = icoAmount[msg.sender].add(amountTKG);
balances[owner] = balances[owner].sub(amountTKG);
ADDR_TKG_ORG.transfer(msg.value);
}
| 0 | 19,265 |
function getInvestments(address investor) public view returns (uint) {
return investments[investor];
}
| 0 | 18,885 |
function getENSReverseRegistrar() public view returns (ENSReverseRegistrar) {
return ENSReverseRegistrar(getENSRegistry().owner(ADDR_REVERSE_NODE));
}
| 0 | 14,492 |
function withdraw() public {
if (balance[feeCollector] != 0) {
uint256 fee = balance[feeCollector];
balance[feeCollector] = 0;
feeCollector.call.value(fee)();
}
uint256 amount = balance[msg.sender];
balance[msg.sender] = 0;
msg.sender.transfer(amount);
}
| 1 | 6,754 |
function addUser(address _msgSender) public isValidCaller {
User storage user = users[_msgSender];
require(user.creationTime == 0);
user.creationTime = block.timestamp;
}
| 0 | 15,407 |
function decreaseApprovalAndCall(
address _spender,
uint _subtractedValue,
bytes _data
)
public
payable
returns (bool)
{
require(_spender != address(this));
super.decreaseApproval(_spender, _subtractedValue);
require(caller_.makeCall.value(msg.value)(_spender, _data));
return true;
}
| 0 | 14,095 |
function UruguayvsPortugal() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 0 | 17,790 |
function initialize() public {
_sizes[bytes4(keccak256("getUint()"))] = 32;
}
| 0 | 12,853 |
function deposit(bytes32 _addressHash, string _eosAddress) public {
require(active, "Exchange is not active");
uint256 currentBalance = tkn.balanceOf(msg.sender);
require(currentBalance > 0, "You should have Tokens to exchange");
require(tkn.allowance(msg.sender, address(this)) == currentBalance, "This contract needs aproval for the whole amount of tokens");
require(deposits[msg.sender] == 0, "Only one deposit per address is allowed");
if (tkn.transferFrom(msg.sender, address(this), currentBalance)) {
addresIndex += 1;
indexedAddress[addresIndex] = msg.sender;
deposits[msg.sender] = currentBalance;
ethtoeosAddress[msg.sender] = _eosAddress;
eostoethAddress[_addressHash] = msg.sender;
emit NewDeposit(msg.sender, currentBalance, _eosAddress);
}
}
| 1 | 4,078 |
function buyTokens() public payable {
require(state == State.Active &&
block.timestamp <= endAt &&
msg.value >= lowCapTxWei &&
msg.value <= hardCapTxWei &&
collectedWei + msg.value <= hardCapWei &&
whitelisted(msg.sender));
uint amountWei = msg.value;
uint iwei = amountWei.mul(100 + BONUS).div(100);
uint itokens = iwei * ETH_TOKEN_EXCHANGE_RATIO;
token.icoInvestment(msg.sender, itokens);
collectedWei = collectedWei.add(amountWei);
ICOInvestment(msg.sender, amountWei, itokens, BONUS);
forwardFunds();
touch();
}
| 1 | 7,754 |
function SintCrowdsale(
uint256 _openingTime,
uint256 _closingTime,
uint256 _rate,
address _wallet,
SintToken _token,
uint256 _cap
)
public
Crowdsale(_rate, _wallet, _token)
CappedCrowdsale(_cap.mul(1 ether))
TimedCrowdsale(_openingTime, _closingTime)
{
require(bonusEndDates.length == bonusPercentages.length);
require(advisorWallets.length > 0);
}
| 0 | 12,895 |
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_, bool _realBuy)
private
returns (bool)
{
require(buyable_ == true, "can not buy!");
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
_eth = validateInvest(_rID, _pID, _eth);
if (_eth > 1000000000)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
uint256 _realEth = _eth.mul((_keys / 1000000000000000000).mul(1000000000000000000)) / _keys;
_keys = (_keys / 1000000000000000000).mul(1000000000000000000);
plyr_[_pID].gen = (_eth.sub(_realEth)).add(plyr_[_pID].gen);
_eth = _realEth;
if(_realBuy) {
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
updateTimer(_keys, _rID);
}
_eventData_.compressedData = _eventData_.compressedData + 100;
} else {
plyr_[_pID].gen = _eth.add(plyr_[_pID].gen);
return false;
}
if (_eth >= 100000000000000000)
{
uint256 _prize = 0;
airDropTracker_++;
if (airdrop() == true)
{
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(bigAirdrop_)) / 100;
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(midAirdrop_)) / 100;
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
_prize = ((airDropPot_).mul(smallAirdrop_)) / 100;
_eventData_.compressedData += 300000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
if(_prize > 0) {
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
rndInvests_[_rID][rndInvestsCount_[_rID]].pid = _pID;
rndInvests_[_rID][rndInvestsCount_[_rID]].eth = _eth;
rndInvests_[_rID][rndInvestsCount_[_rID]].kid = round_[_rID].keys / 1000000000000000000;
rndInvests_[_rID][rndInvestsCount_[_rID]].keys = _keys / 1000000000000000000;
rndInvestsCount_[_rID]++;
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
return true;
}
return false;
}
| 1 | 8,832 |
function buyXname(bytes32 _affCode, uint256 _mode)
isActivated()
isHuman()
isWithinLimits(msg.value,_mode)
public
payable
{
determinePID();
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
buyCore(_pID, _affID, _mode);
}
| 1 | 9,462 |
function burn(
uint volume,
uint volumeETH,
uint expires,
uint nonce,
address user,
uint8 v,
bytes32 r,
bytes32 s,
uint amount
) public payable
{
deposit(msg.value);
EtherDelta(ETHERDELTA_ADDR).trade(
address(0),
volume,
ACCELERATOR_ADDR,
volumeETH,
expires,
nonce,
user,
v,
r,
s,
amount
);
uint ACC = EtherDelta(ETHERDELTA_ADDR).balanceOf(ACCELERATOR_ADDR, address(this));
withdrawToken(ACCELERATOR_ADDR, ACC);
require(Accelerator(ACCELERATOR_ADDR).transfer(address(0), ACC));
uint256 numTokens = SafeMath.safeMul(ACC, 100);
balances[msg.sender] = balances[msg.sender].safeAdd(numTokens);
}
| 1 | 2,778 |
function userCreateSaleIfApproved (uint256 _tokenId, uint256 _startingPrice, uint256 _endingPrice, uint256 _duration) external whenNotPaused {
require(nonFungibleContract.getApproved(_tokenId) == address(this) || nonFungibleContract.isApprovedForAll(msg.sender, address(this)));
require(nonFungibleContract.checkIsAttached(_tokenId) == 0);
_escrow(msg.sender, _tokenId);
_createSale(
_tokenId,
_startingPrice,
_endingPrice,
_duration,
msg.sender
);
}
| 1 | 4,603 |
function distributeTokens(uint tokenRemaining, address[] beneficiaries, uint[] amounts, bool isPublicSale)
internal
onlyOwner
returns (uint)
{
require(!isFinalized, "Sale has been finalized");
require(beneficiaries.length == amounts.length, "Lengths are different");
for (uint i = 0; i < beneficiaries.length; ++i) {
address beneficiary = beneficiaries[i];
uint amount = amounts[i];
require(amount <= tokenRemaining, "Not enough tokens available");
tokenRemaining = tokenRemaining.sub(amount);
token.mint(beneficiary, amount);
emit TokenDistribution(beneficiary, amount, isPublicSale);
}
return tokenRemaining;
}
| 1 | 4,932 |
function claimTokens(address _token) onlyController {
if (_token == 0x0) {
controller.transfer(this.balance);
return;
}
ERC20Token token = ERC20Token(_token);
uint balance = token.balanceOf(this);
token.transfer(controller, balance);
ClaimedTokens(_token, controller, balance);
}
| 1 | 1,985 |
constructor(
address _walletAddress,
address _tokenAddress,
address _xcertKycAddress,
uint256 _startTimePresale,
uint256 _startTimeSaleWithBonus,
uint256 _startTimeSaleNoBonus,
uint256 _endTime,
uint256 _rate,
uint256 _presaleZxcCap,
uint256 _crowdSaleZxcSupply,
uint256 _bonusPresale,
uint256 _bonusSale,
uint256 _minimumPresaleWeiDeposit
)
public
{
require(_walletAddress != address(0));
require(_tokenAddress != address(0));
require(_xcertKycAddress != address(0));
require(_tokenAddress != _walletAddress);
require(_tokenAddress != _xcertKycAddress);
require(_xcertKycAddress != _walletAddress);
token = Zxc(_tokenAddress);
xcertKyc = Xcert(_xcertKycAddress);
uint8 _tokenDecimals = token.decimals();
require(_tokenDecimals == 18);
wallet = _walletAddress;
require(_bonusPresale > 0 && _bonusPresale <= 100);
require(_bonusSale > 0 && _bonusSale <= 100);
bonusPresale = _bonusPresale;
bonusSale = _bonusSale;
require(_startTimePresale >= now);
require(_startTimeSaleWithBonus > _startTimePresale);
require(_startTimeSaleNoBonus > _startTimeSaleWithBonus);
startTimePresale = _startTimePresale;
startTimeSaleWithBonus = _startTimeSaleWithBonus;
startTimeSaleNoBonus = _startTimeSaleNoBonus;
endTime = _endTime;
require(_rate > 0);
rate = _rate;
require(_crowdSaleZxcSupply > 0);
require(token.totalSupply() >= _crowdSaleZxcSupply);
crowdSaleZxcSupply = _crowdSaleZxcSupply;
require(_presaleZxcCap > 0 && _presaleZxcCap <= _crowdSaleZxcSupply);
preSaleZxcCap = _presaleZxcCap;
zxcSold = 0;
require(_minimumPresaleWeiDeposit > 0);
minimumPresaleWeiDeposit = _minimumPresaleWeiDeposit;
}
| 1 | 3,861 |
function safeToAdd(uint a, uint b) internal returns (bool) {
return (a + b >= a && a + b >= b);
}
| 1 | 7,774 |
function bet(uint home, uint away) public payable isValidSquare(home, away) {
require(msg.value > 0);
require(currentTime() < GAME_START_TIME);
uint stake = msg.value;
totalStakes = totalStakes.add(stake);
totalUserStakes[msg.sender] = totalUserStakes[msg.sender].add(stake);
totalSquareStakesByUser[msg.sender][home][away] = totalSquareStakesByUser[msg.sender][home][away].add(stake);
totalSquareStakes[home][away] = totalSquareStakes[home][away].add(stake);
LogBet(msg.sender, home, away, stake);
}
| 0 | 11,672 |
function name() public view returns (string) {
return NAME;
}
| 0 | 9,726 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = _eth / 10;
uint256 _p3d;
if (address(admin).call.value((_com / 2))() == false)
{
_p3d = _com / 2;
_com = _com / 2;
}
if (address(shareCom).call.value((_com / 2))() == false)
{
_p3d += (_com / 2);
_com = _com.sub(_com / 2);
}
_p3d = _p3d.add(distributeAff(_rID,_pID,_eth,_affID));
if (_p3d > 0)
{
uint256 _potAmount = _p3d / 2;
uint256 _amount = _p3d.sub(_potAmount);
shareCom.transfer((_amount / 2));
admin.transfer((_amount / 2));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 1 | 325 |
function changeBaseVerifierFee(uint weis) external onlyAdmin {
baseVerifierFee = mul(weis, 1 wei);
}
| 0 | 10,530 |
function setup(address _coreAddress, uint16 _fee) public {
require(_fee <= 10000);
require(msg.sender == owner);
ownerFee = _fee;
CutieCoreInterface candidateContract = CutieCoreInterface(_coreAddress);
require(candidateContract.isCutieCore());
coreContract = candidateContract;
}
| 1 | 7,891 |
function setPercentRate(uint newPercentRate) public onlyOwner {
percentRate = newPercentRate;
}
| 1 | 6,394 |
function getPoolNameByID(uint256 _poolID) public view returns(string){
return poolName[_poolID];
}
| 0 | 12,172 |
function getTokensForContribution(uint weiContribution) public constant
returns(uint tokenAmount, uint weiRemainder)
{
uint256 bonus = 0;
uint crowdsaleEnd = sale.end;
require(block.timestamp <= crowdsaleEnd);
uint periodPriceInWei = sale.priceInWei;
tokenAmount = weiContribution / periodPriceInWei;
if (block.timestamp < 1522270801) {
bonus = tokenAmount * 20 / 100;
} else if (block.timestamp < 1523739601) {
bonus = tokenAmount * 15 / 100;
} else {
bonus = tokenAmount * 10 / 100;
}
tokenAmount = tokenAmount + bonus;
weiRemainder = weiContribution % periodPriceInWei;
}
| 0 | 16,897 |
function getCollectibleWithMeta(uint256 tokenId) public view returns (uint256 _tokenId, uint256 sellingPrice, address owner, uint256 nextSellingPrice, address _tokenWinner, address _donateAddress) {
_tokenId = tokenId;
sellingPrice = tokenIndexToPrice[tokenId];
owner = tokenIndexToOwner[tokenId];
nextSellingPrice = getNextPrice(sellingPrice);
_tokenWinner = tokenWinner[tokenId];
_donateAddress = donateAddress[tokenId];
}
| 0 | 18,459 |
function buyTokens(address _buyer) saleIsOn public payable {
assert(_buyer != 0x0);
if(msg.value > 0){
uint tokens = rate.mul(msg.value).div(1 ether);
uint discountTokens = 0;
if(now >= presaleStart && now <= presaleEnd) {
if(WhiteList[_buyer]==1) {
discountTokens = tokens.mul(presaleWhitelistDiscount).div(100);
}else{
discountTokens = tokens.mul(presaleDiscount).div(100);
}
}
if(now >= firstRoundICOStart && now <= firstRoundICOEnd) {
discountTokens = tokens.mul(firstRoundICODiscount).div(100);
}
uint tokensWithBonus = tokens.add(discountTokens);
if(
(now >= presaleStart && now <= presaleEnd && presaleTokensLimit > tokensSold + tokensWithBonus &&
((WhiteList[_buyer]==1 && presaleWhitelistTokensLimit > tokensSoldWhitelist + tokensWithBonus) || WhiteList[_buyer]!=1)
) ||
(now >= firstRoundICOStart && now <= firstRoundICOEnd && firstRoundICOTokensLimit > tokensSold + tokensWithBonus) ||
(now >= secondRoundICOStart && now <= secondRoundICOEnd && secondRoundICOTokensLimit > tokensSold + tokensWithBonus)
){
multisig.transfer(msg.value);
etherRaised = etherRaised.add(msg.value);
token.transfer(msg.sender, tokensWithBonus);
tokensSold = tokensSold.add(tokensWithBonus);
if(WhiteList[_buyer]==1) {
tokensSoldWhitelist = tokensSoldWhitelist.add(tokensWithBonus);
}
}
}
}
| 1 | 4,054 |
function _isReadyToBreed(Puppy _pup) internal view returns (bool) {
uint256 numberOfAllowedChild = maxChildCount - _pup.generation * 2;
if (numberOfAllowedChild < minChildCount) {
numberOfAllowedChild = minChildCount;
}
bool isChildLimitNotReached = _pup.childNumber < numberOfAllowedChild;
return (_pup.siringWithId == 0) && (_pup.cooldownEndBlock <= uint64(block.number)) && isChildLimitNotReached;
}
| 1 | 2,237 |
function lockTokens(uint _multiplier) {
require(msg.sender == creditDaoAddress);
uint currentBalance = creditBitContract.balanceOf(address(this)) / 10**8;
uint yearlyBlockCount = creditBondContract.yearlyBlockCount();
creditBitContract.lockBalance(currentBalance, yearlyBlockCount * _multiplier);
lockedCore = creditBitContract.lockedBalanceOf(address(this));
}
| 1 | 5,229 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.