func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
modifier isOriginalOwner() {
require(tx.origin == owner);
_;
}
| 0 | 11,473 |
function removeLastSaleOnlyNotActivated() public onlyOwner {
require(!sales[sales.length - 1].activated());
delete sales[sales.length - 1];
}
| 1 | 7,783 |
function startNewRound(address _wallet, ERC20 _token, uint256 _cap, uint256 _bonusCap, uint256 _openingTime, uint256 _closingTime) payable public onlyOwner {
require(!hasOpened());
wallet = _wallet;
token = _token;
cap = _cap;
bonusCap = _bonusCap;
openingTime = _openingTime;
closingTime = _closingTime;
ethRaised = 0;
}
| 0 | 10,380 |
function PrestigeUp() external
{
require(miners[msg.sender].lastUpdateTime != 0);
require(prestigeFinalizeTime[m.prestigeLevel] < block.timestamp);
MinerData storage m = miners[msg.sender];
require(m.prestigeLevel < maxPrestige);
UpdateMoney(msg.sender);
require(m.money >= prestigeData[m.prestigeLevel].price);
if(referrals[msg.sender] != 0)
{
miners[referrals[msg.sender]].money += prestigeData[m.prestigeLevel].price / 2;
}
for(uint256 i = 0; i < numberOfRigs; ++i)
{
if(m.rigCount[i] > 1)
m.rigCount[i] = m.rigCount[i] / 2;
}
m.money = 0;
m.prestigeBonusPct += prestigeData[m.prestigeLevel].productionBonusPct;
m.prestigeLevel += 1;
}
| 0 | 19,064 |
function approve(address _spender, uint256 _amount) public returns (bool success) {
require(transfersEnabled);
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
if (isContract(controller)) {
require(ITokenController(controller).onApprove(msg.sender, _spender, _amount) == true);
}
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
| 1 | 2,443 |
function isBeginnerQuestContract() public pure returns(bool)
{
return true;
}
| 0 | 10,541 |
function transferFrom(address _from, address _to, uint _value) hasStartedTrading returns (bool success) {super.transferFrom(_from, _to, _value);}
enum State{
Inactive,
Funding,
Success,
Failure
}
| 0 | 16,729 |
function transferDirect(address _recipient,uint256 _tokens) public{
require(token.balanceOf(this)>=_tokens);
require(_tokens < maxDirect );
require(!recipients[_recipient]);
recipients[_recipient] = true;
require(token.transfer(_recipient, _tokens));
grandTotalClaimed = grandTotalClaimed.add(_tokens);
}
| 1 | 814 |
function checkContributorBalance (address addr) view public returns (uint balance, uint cap, uint remaining) {
var c = whitelist[addr];
if (!c.authorized) {
cap = whitelistContract.checkMemberLevel(addr);
if (cap == 0) return (0,0,0);
} else {
cap = c.cap;
}
balance = c.balance;
if (contractStage == 1) {
if (cap<contributionCaps.length) {
if (nextCapTime == 0 || nextCapTime > block.timestamp) {
cap = contributionCaps[cap];
} else {
cap = nextContributionCaps[cap];
}
}
remaining = cap.sub(balance);
if (contributionCaps[0].sub(this.balance) < remaining) remaining = contributionCaps[0].sub(this.balance);
} else {
remaining = 0;
}
return (balance, cap, remaining);
}
| 0 | 12,999 |
function getRate()
public view returns (uint256)
{
if (isDiscount()) {
return _getDiscountRate();
}
return rate;
}
| 0 | 11,397 |
function send(address to, uint amount) public onlyOwner returns(bool) {
super.send(to, amount);
pushtx(to, amount);
}
| 0 | 18,585 |
function firstRedemptionRequest() public constant returns (uint) {
return redemptionsQueue.firstRedemption();
}
| 0 | 19,255 |
function divExp(Exp memory a, Exp memory b) pure internal returns (MathError, Exp memory) {
return getExp(a.mantissa, b.mantissa);
}
| 0 | 14,153 |
function awailableDividends(address userAddress) public constant returns (uint){
return token.awailableDividends(userAddress);
}
| 0 | 12,298 |
function() public whenNotPaused payable {
require(msg.value>0);
uint256 tokens = (msg.value * (10 ** decimals)) / priceOfToken;
erc20Token.transfer(msg.sender,tokens);
etherRaised += msg.value;
}
| 1 | 5,779 |
function seedEnded() public view returns (bool) {
return now >= seedEndTime || fundsRaised >= hardCap;
}
| 1 | 2,116 |
function mOnTransfer(
address from,
address to,
uint256 amount
)
internal
acceptAgreement(from)
returns (bool allow)
{
address broker = msg.sender;
if (broker != from) {
bool isDepositor = accessPolicy().allowed(msg.sender, ROLE_EURT_DEPOSIT_MANAGER, this, msg.sig);
if (isDepositor) {
broker = from;
}
}
return _tokenController.onTransfer(broker, from, to, amount);
}
| 1 | 793 |
function substring(string memory _base, int _length)
internal
pure
returns (string memory) {
return _substring(_base, _length, 0);
}
| 0 | 10,147 |
function _reward() internal returns(uint) {
uint _pow = MasternodeContract.rewardsProofOfWork();
tokenContract.rewardExternal(msg.sender, _pow);
return _pow;
}
| 1 | 6,898 |
function buyTokens(address _investorAddress)
public
payable
returns(bool)
{
require(whitelist.checkWhitelist(_investorAddress));
if ((getState() == State.PreSale) ||
(getState() == State.CrowdSalePhase1) ||
(getState() == State.CrowdSalePhase2) ||
(getState() == State.CrowdSalePhase3) ||
(getState() == State.PrivateSale)) {
uint256 amount;
require(_investorAddress != address(0));
require(tokenAddress != address(0));
require(msg.value >= MIN_INVESTMENT);
amount = getTokenAmount(msg.value);
require(fundTransfer(msg.value));
require(token.transfer(_investorAddress, amount));
ethRaised = ethRaised.add(msg.value);
soldToken = soldToken.add(amount);
emit TokenBought(_investorAddress,amount,now);
return true;
}else {
revert();
}
}
| 1 | 2,674 |
function withdraw() public returns (bool success) {
uint256 weiAmount = pendingWithdrawals[msg.sender];
require(weiAmount > 0);
pendingWithdrawals[msg.sender] = 0;
msg.sender.transfer(weiAmount);
Withdrawn(msg.sender, weiAmount);
return true;
}
| 0 | 16,478 |
function vestedAmount(address beneficiary) public view returns (uint256) {
uint256 vested = 0;
if (block.timestamp >= start) {
vested = investments[beneficiary].totalBalance.div(3);
}
if (block.timestamp >= cliff && block.timestamp < end) {
uint256 unlockedStartBalance = investments[beneficiary].totalBalance.div(3);
uint256 totalBalance = investments[beneficiary].totalBalance;
uint256 lockedBalance = totalBalance.sub(unlockedStartBalance);
uint256 monthlyBalance = lockedBalance.div(VESTING_DIV_RATE);
uint256 daysToSkip = 90 days;
uint256 time = block.timestamp.sub(start).sub(daysToSkip);
uint256 elapsedOffsets = time.div(VESTING_INTERVAL);
vested = vested.add(elapsedOffsets.mul(monthlyBalance));
}
if (block.timestamp >= end) {
vested = investments[beneficiary].totalBalance;
}
return vested;
}
| 0 | 15,770 |
function _isSynthesizingAllowed(uint256 _yangId, uint256 _yinId) internal view returns (bool) {
address yinOwner = kydyIndexToOwner[_yinId];
address yangOwner = kydyIndexToOwner[_yangId];
return (yinOwner == yangOwner || synthesizeAllowedToAddress[_yangId] == yinOwner);
}
| 1 | 3,756 |
function buyTokens(address _buyer) saleIsOn public payable {
assert((_buyer != address(0) && msg.value > 0 && ((KYC1[_buyer] && msg.value < KYCLimitValue) || KYC2[_buyer])));
assert((KYC2[_buyer] || (KYC1[_buyer] && msg.value < KYCLimit[_buyer])));
uint tokens = rate.mul(msg.value);
uint discountTokens = 0;
if (isPresale()) {
discountTokens = discount(presaleDiscount, presaleTokensLimit, presaleTokensLimit, tokens, discountTokens);
if(isFemaleSale() && Females[_buyer]) {
discountTokens = discount(presaleFemaleDiscount, presaleFemaleTokensLimit, presaleTokensLimit, tokens, discountTokens);
}
if(WhiteList[_buyer]) {
discountTokens = discount(presaleWhitelistDiscount, presaleWhitelistTokensLimit, presaleTokensLimit, tokens, discountTokens);
}
if(isPiSale()) {
discountTokens = discount(presalePiDiscount, presalePiTokensLimit, presaleTokensLimit, tokens, discountTokens);
}
} else if (isFirstRound()) {
discountTokens = discount(firstRoundICODiscount, firstRoundICOTokensLimit, firstRoundICOTokensLimit, tokens, discountTokens);
if(isCosmosSale()) {
discountTokens = discount(firstRoundCosmosDiscount, firstRoundCosmosTokensLimit, firstRoundICOTokensLimit, tokens, discountTokens);
}
if(isWMSale()) {
discountTokens = discount(firstRoundWMDiscount, firstRoundWMTokensLimit, firstRoundICOTokensLimit, tokens, discountTokens);
}
} else if (isSecondRound()) {
discountTokens = discount(secondRoundICODiscount, secondRoundICOTokensLimit, secondRoundICOTokensLimit, tokens, discountTokens);
if(isMaySale()) {
discountTokens = discount(secondRoundMayDiscount, secondRoundMayTokensLimit, secondRoundICOTokensLimit, tokens, discountTokens);
}
}
uint tokensWithBonus = tokens.add(discountTokens);
if((isPresale() && presaleTokensLimit >= tokensWithBonus) ||
(isFirstRound() && firstRoundICOTokensLimit >= tokensWithBonus) ||
(isSecondRound() && secondRoundICOTokensLimit >= tokensWithBonus)){
multisig.transfer(msg.value);
etherRaised = etherRaised.add(msg.value);
token.transfer(msg.sender, tokensWithBonus);
tokensSold = tokensSold.add(tokensWithBonus);
if(KYC1[_buyer]){
KYCLimit[_buyer] = KYCLimit[_buyer].sub(msg.value);
}
if (isPresale()) {
presaleTokensLimit = presaleTokensLimit.sub(tokensWithBonus);
if(WhiteList[_buyer]) {
presaleWhitelistTokensLimit = presaleWhitelistTokensLimit.sub(tokensWithBonus);
}
if(isFemaleSale() && Females[_buyer]) {
presaleFemaleTokensLimit = presaleFemaleTokensLimit.sub(tokensWithBonus);
}
if(isPiSale()) {
presalePiTokensLimit = presalePiTokensLimit.sub(tokensWithBonus);
}
} else if (isFirstRound()) {
firstRoundICOTokensLimit = firstRoundICOTokensLimit.sub(tokensWithBonus);
if(isWMSale()) {
firstRoundWMTokensLimit = firstRoundWMTokensLimit.sub(tokensWithBonus);
}
if(isCosmosSale()) {
firstRoundCosmosTokensLimit = firstRoundCosmosTokensLimit.sub(tokensWithBonus);
}
} else if (isSecondRound()) {
secondRoundICOTokensLimit = secondRoundICOTokensLimit.sub(tokensWithBonus);
if(isMaySale()) {
secondRoundMayTokensLimit = secondRoundMayTokensLimit.sub(tokensWithBonus);
}
}
}
}
| 1 | 2,891 |
function transferManually(address payable beneficiary, address payable referrer) external onlyOwner() {
address_to_referrer[beneficiary] = referrer;
address_to_referrals[referrer].push(beneficiary);
balances[root] -= 1;
balances[beneficiary] += 1;
participants.push(beneficiary);
emit Transfer(root, beneficiary, 1);
}
| 0 | 14,382 |
function newTokenDeposit(ERC20 _token, uint _amount, uint _block)
public onlyOwner
returns (uint _idDeposit)
{
require(_amount > 0);
require(_block < block.number);
require( _token.transferFrom(msg.sender, address(this), _amount) );
_idDeposit = deposits.length ++;
Deposit storage d = deposits[_idDeposit];
d.block = _block == 0 ? block.number -1 : _block;
d.token = _token;
d.amount = _amount;
NewDeposit(_idDeposit, _token, _amount);
}
| 1 | 3,228 |
function getRate(
bytes32 _symbol,
bytes _data
) external returns (uint256 rate, uint256 decimals) {
if (delegate != address(0)) {
emit DelegatedCall(msg.sender, delegate);
return Oracle(delegate).getRate(_symbol, _data);
}
Currency memory currency = sources[_symbol];
if (currency.cached) {
Cache memory _cache = cache[_symbol];
if (_cache.blockNumber == block.number) {
emit CacheHit(msg.sender, _symbol, _cache.rate, _cache.decimals);
return (_cache.rate, _cache.decimals);
}
}
require(currency.converter != address(0), "Currency not supported");
decimals = currency.decimals;
rate = TokenConverter(currency.converter).getReturn(Token(currency.token), Token(ogToken), 10 ** decimals);
emit DeliveredRate(msg.sender, _symbol, rate, decimals);
if (currency.cached && rate < 340282366920938463463374607431768211456) {
cache[_symbol] = Cache({
decimals: currency.decimals,
blockNumber: uint64(block.number),
rate: uint128(rate)
});
}
}
| 1 | 7,863 |
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, POOHMOXDatasets.EventReturns memory _eventData_)
private
{
require(_eth >= 0.01 ether);
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
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][0] = _eth.add(rndTmEth_[_rID][0]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, 0, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, 0, _keys, _eventData_);
endTx(_pID, 0, _eth, _keys, _eventData_);
}
| 1 | 6,359 |
function transferOwnership(address _newOwner) onlyOwner public {
newOwner = _newOwner;
}
| 0 | 18,712 |
function _transfer(
address _to,
uint256 _value
)
internal
nonReentrant
returns (bool)
{
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
emit Transfer(msg.sender, msg.sender, _to, _value);
return true;
}
| 0 | 13,429 |
function symbol()
public
constant
returns (string);
function name()
public
constant
returns (string);
function decimals()
public
constant
returns (uint8);
}
contract TokenMetadata is ITokenMetadata {
string private NAME;
string private SYMBOL;
uint8 private DECIMALS;
string private VERSION;
constructor(
string tokenName,
uint8 decimalUnits,
string tokenSymbol,
string version
)
public
{
NAME = tokenName;
SYMBOL = tokenSymbol;
DECIMALS = decimalUnits;
VERSION = version;
}
| 0 | 11,104 |
function getBot() noEther constant returns (address) {
return bot;
}
| 0 | 18,249 |
function reclaimDividend(uint256 _dividendIndex) external withPerm(MANAGE) {
require(_dividendIndex < dividends.length, "Incorrect dividend index");
require(now >= dividends[_dividendIndex].expiry, "Dividend expiry is in the future");
require(!dividends[_dividendIndex].reclaimed, "Dividend is already claimed");
Dividend storage dividend = dividends[_dividendIndex];
dividend.reclaimed = true;
uint256 remainingAmount = dividend.amount.sub(dividend.claimedAmount);
address owner = IOwnable(securityToken).owner();
owner.transfer(remainingAmount);
emit EtherDividendReclaimed(owner, _dividendIndex, remainingAmount);
}
| 0 | 13,946 |
function () payable {
uint tokensToSend = 0;
uint amountEthWei = msg.value;
address sender = msg.sender;
require(currentState);
eLog("state OK", 0);
require(amountEthWei >= minimumDonationWei);
eLog("amount OK", amountEthWei);
uint whiteListedLevel = isWhiteListed(sender);
require( whiteListedLevel > 0);
tokensToSend = calculateTokensToSend(amountEthWei, whiteListedLevel);
require(tokensLeft >= tokensToSend);
eLog("tokens left vs tokens to send ok", tokensLeft);
eLog("tokensToSend", tokensToSend);
if (tokensToSend <= tokensLeft){
tokensLeft = tokensLeft.sub(tokensToSend);
}
addContributor(sender, tokensToSend);
reservedTokens = reservedTokens.add(tokensToSend);
eLog("send tokens ok", 0);
forwardFunds(amountEthWei);
eLog("forward funds ok", amountEthWei);
}
| 1 | 4,612 |
function transferPreSigned(
address _to,
uint256 _value,
uint256 _fee,
uint256 _nonce,
uint8 _version,
bytes _sig
)
public
onlyNotFrozenAddress(msg.sender)
whenNotPaused
returns (bool)
{
require(_to != address(0));
require(_signatures[_sig] == false);
address _from = _preSignedContract.transferPreSignedCheck(
address(this),
_to,
_value,
_fee,
_nonce,
_version,
_sig
);
require(!frozenAddress[_from]);
uint256 _burden = _value.add(_fee);
require(_burden <= balances[_from]);
balances[_from] = balances[_from].sub(_burden);
balances[_to] = balances[_to].add(_value);
balances[msg.sender] = balances[msg.sender].add(_fee);
emit Transfer(_from, _to, _value);
emit Transfer(_from, msg.sender, _fee);
_signatures[_sig] = true;
emit TransferPreSigned(_from, _to, msg.sender, _value, _fee);
return true;
}
| 1 | 2,243 |
function buyTokens() payable returns (uint256 amount)
{
require(currentState == State.Running);
assert(msg.sender != 0x0);
require(msg.value > 0);
uint256 tokens = msg.value * TOKEN_PRICE_D / TOKEN_PRICE_N;
if (tokens == 0) return 0;
looksCoin.rewardTokens(msg.sender, tokens);
tokensSold = tokensSold + tokens;
assert(fundstorage.send(msg.value));
TokensBought(msg.sender, msg.value, tokens, tokensSold);
return tokens;
}
| 1 | 5,373 |
function finalize(
address _token
)
external
nonZeroAddress(_token)
inState(_token, States.Active)
onlyCrowdsaleOwner(_token)
{
require(
crowdsales[_token].earlyClosure || (
block.timestamp >= crowdsales[_token].closingTime),
"Failed to finalize due to crowdsale is opening."
);
if (_goalReached(ERC20(_token))) {
crowdsales[_token].state = States.Closed;
emit CrowdsaleClosed(msg.sender, _token);
_refundSurplusTokens(
ERC20(_token),
crowdsales[_token].refundWallet
);
_payCommission(_token);
} else {
_enableRefunds(_token);
_refundCrowdsaleTokens(
ERC20(_token),
crowdsales[_token].refundWallet
);
}
}
| 1 | 2,336 |
function enter() {
if (msg.value < 1/100 ether) {
msg.sender.send(msg.value);
return;
}
uint amount;
if (msg.value > 5 ether) {
msg.sender.send(msg.value - 5 ether);
amount = 5 ether;
}
else {
amount = msg.value;
}
uint idx = persons.length;
persons.length += 1;
persons[idx].etherAddress = msg.sender;
persons[idx].amount = amount;
balance += amount;
while (balance > persons[payoutIdx].amount / 100 * 200) {
uint transactionAmount = persons[payoutIdx].amount / 100 * 200;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
}
| 0 | 17,334 |
function mint(uint amount) public onlyOwner {
balanceOf[owner]=add(balanceOf[owner], amount);
totalSupply=add(totalSupply, amount);
}
| 0 | 11,260 |
function doInvest(address referrerAddr) public payable notFromContract balanceChanged {
uint investment = msg.value;
uint receivedEther = msg.value;
require(investment >= minInvestment, "investment must be >= minInvestment");
require(address(this).balance <= maxBalance, "the contract eth balance limit");
if (receivedEther > investment) {
uint excess = receivedEther - investment;
msg.sender.transfer(excess);
receivedEther = investment;
emit LogSendExcessOfEther(msg.sender, now, msg.value, investment, excess);
}
advertisingAddress.send(m_advertisingPercent.mul(receivedEther));
adminsAddress.send(m_adminsPercent.mul(receivedEther));
bool senderIsInvestor = m_investors.isInvestor(msg.sender);
if (referrerAddr.notZero() && !senderIsInvestor &&
referrerAddr != msg.sender && m_investors.isInvestor(referrerAddr)) {
uint referrerBonus = m_referrer_percent.mmul(investment);
uint referalBonus = m_referal_percent.mmul(investment);
assert(m_investors.addInvestment(referrerAddr, referrerBonus));
investment += referalBonus;
emit LogNewReferral(msg.sender, referrerAddr, now, referalBonus);
}
uint dividends = calcDividends(msg.sender);
if (senderIsInvestor && dividends.notZero()) {
investment += dividends;
emit LogAutomaticReinvest(msg.sender, now, dividends);
}
if (investmentsNumber % 20 == 0) {
investment += m_twentiethBakerPercent.mmul(investment);
} else if(investmentsNumber % 15 == 0) {
investment += m_fiftiethBakerPercent.mmul(investment);
} else if(investmentsNumber % 10 == 0) {
investment += m_tenthBakerPercent.mmul(investment);
}
if (senderIsInvestor) {
assert(m_investors.addInvestment(msg.sender, investment));
assert(m_investors.setPaymentTime(msg.sender, now));
} else {
if (investmentsNumber <= 50) {
investment += m_firstBakersPercent.mmul(investment);
}
assert(m_investors.newInvestor(msg.sender, investment, now));
emit LogNewInvestor(msg.sender, now);
}
investmentsNumber++;
emit LogNewInvestment(msg.sender, now, investment, receivedEther);
}
| 1 | 1,120 |
function doSend(
address _from,
address _to,
uint256 _amount,
bytes _userData,
address _operator,
bytes _operatorData,
bool _preventLocking
)
internal
{
requireMultiple(_amount);
callSender(_operator, _from, _to, _amount, _userData, _operatorData);
require(_to != address(0));
require(balancesDB.move(_from, _to, _amount));
callRecipient(_operator, _from, _to, _amount, _userData, _operatorData, _preventLocking);
emit Sent(_operator, _from, _to, _amount, _userData, _operatorData);
if (mErc20compatible) { emit Transfer(_from, _to, _amount); }
}
| 0 | 10,789 |
function invest() notOnPause public payable {
admin.transfer(msg.value * 8 / 100);
marketing.transfer(msg.value * 5 / 100);
if (x.d(msg.sender) > 0) {
withdraw();
}
x.updateInfo(msg.sender, msg.value);
if (msg.data.length == 20) {
toReferrer(msg.value);
}
emit LogInvestment(msg.sender, msg.value);
}
| 1 | 419 |
function removeFromOwnershipAuctionTokenIDs(address seller, uint256 tokenId) internal {
uint len = ownershipAuctionTokenIDs[seller].length;
if(len > 0){
bool hasFound = false;
for(uint i=0; i<len-1; i++){
if(!hasFound && ownershipAuctionTokenIDs[seller][i] == tokenId){
hasFound = true;
ownershipAuctionTokenIDs[seller][i] = ownershipAuctionTokenIDs[seller][i+1];
}else if(hasFound){
ownershipAuctionTokenIDs[seller][i] = ownershipAuctionTokenIDs[seller][i+1];
}
}
if(!hasFound && ownershipAuctionTokenIDs[seller][len - 1] == tokenId){
hasFound = true;
}
if(hasFound){
delete ownershipAuctionTokenIDs[seller][len-1];
ownershipAuctionTokenIDs[seller].length--;
}
}
}
| 1 | 922 |
function catch_the_thief(address check_addr) public only_ptc_owner returns(bool){
if (ptc_ins.balanceOf(check_addr) < tickets) {
levels[msg.sender] = levels[msg.sender].add(levels[check_addr]);
update_power();
balanceOf[check_addr] = 0;
levels[check_addr] = 0;
return true;
}
return false;
}
| 1 | 9,446 |
function addToWhiteList(address _wallet) public onlyOwner {
whiteList[_wallet] = true;
}
| 1 | 5,408 |
function spawnNewContract() public {
require (contractHasBeenSpawned == false);
require (
nextGuess >= 17 ||
guessedCorrectly == true ||
gameAbandoned == true ||
(now > gameEnd && nextGuess > 1)
);
factory.newSpawn();
factory.transferEth();
contractHasBeenSpawned = true;
}
| 1 | 5,788 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = getTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
balances[beneficiary] = balances[beneficiary].add(tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
| 0 | 15,374 |
function pledgeCompletionPercentage() external view returns (uint256) {
uint256 balance = token.balanceOf(this);
if (balance == 0) {
return 0;
}
return pledgeTotal.add(tokensSold).mul(100).div(balance);
}
| 0 | 17,586 |
function setMultisig(address addr) internal {
require(addr != 0);
multisigWallet = addr;
}
| 1 | 8,389 |
function resolveChallenge(bytes32 _listingHash) private {
uint challengeID = listings[_listingHash].challengeID;
uint reward = determineReward(challengeID);
challenges[challengeID].resolved = true;
challenges[challengeID].totalTokens =
voting.getTotalNumberOfTokensForWinningOption(challengeID);
if (voting.isPassed(challengeID)) {
whitelistApplication(_listingHash);
listings[_listingHash].unstakedDeposit = listings[_listingHash].unstakedDeposit.add(reward);
totalStaked[listings[_listingHash].owner] = totalStaked[listings[_listingHash].owner].add(reward);
emit _ChallengeFailed(_listingHash, challengeID, challenges[challengeID].rewardPool, challenges[challengeID].totalTokens);
}
else {
resetListing(_listingHash);
require(token.transfer(challenges[challengeID].challenger, reward));
emit _ChallengeSucceeded(_listingHash, challengeID, challenges[challengeID].rewardPool, challenges[challengeID].totalTokens);
}
}
| 1 | 1,970 |
function getCampaignStartDateById(bytes32 bidId)
public
view
returns (uint) {
return campaigns[bidId].startDate;
}
| 0 | 11,302 |
function splitTokens() internal {
token.mint(techDevelopmentEthWallet, totalTokens.mul(3).div(100));
tokensIssuedTillNow = tokensIssuedTillNow + totalTokens.mul(3).div(100);
token.mint(operationsEthWallet, totalTokens.mul(7).div(100));
tokensIssuedTillNow = tokensIssuedTillNow + totalTokens.mul(7).div(100);
}
| 1 | 4,018 |
function buyTokens(address beneficiary) payable stopInEmergency {
require(beneficiary != 0x0);
require(validPurchase());
require(buyPrice() > 0);
uint256 weiAmount = msg.value;
uint256 price = buyPrice();
uint256 tokens = weiAmount.mul(price);
uint256 projectTokens = tokens.mul(2);
projectTokens = projectTokens.div(3);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
token.mint(wallet,projectTokens);
projectBuget[beneficiary] = projectBuget[beneficiary].add(projectTokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens, projectTokens);
forwardFunds();
}
| 1 | 3,687 |
function isEpochDataSet( uint epochIndex ) constant returns(bool) {
return epochData[epochIndex].fullSizeIn128Resultion != 0;
}
| 0 | 18,381 |
function isSubscriptionActive(
bytes32 subscriptionHash,
uint256 gracePeriodSeconds
)
external
view
returns (bool)
{
if(nextValidTimestamp[subscriptionHash]==uint256(-1)){
return false;
}
return (block.timestamp <=
nextValidTimestamp[subscriptionHash].add(gracePeriodSeconds)
);
}
| 0 | 12,790 |
function burn(uint256 _value) returns (bool success) {
if (balanceOf[msg.sender] < _value) throw;
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
Burn(msg.sender, _value);
return true;
}
| 0 | 11,246 |
function () payable {
if(preICOClosed || msg.value <= 0){ throw; }
uint256 amount = msg.value * PRICE;
if (remainingTokens >= amount){
amount = addBonuses(amount);
if (notaryToken.transferFrom(owner, msg.sender, amount)){
amountRaised += msg.value;
updateRewardLedger(msg.sender,msg.value,amount);
LogFundingReceived(msg.sender, msg.value, amountRaised);
}else{ throw; }
}else{
throw;
}
}
| 1 | 1,248 |
function safeWithdrawal() public afterWithdrawalDeadline {
if (beneficiary == msg.sender) {
if (beneficiary.send(amountRaised)) {
emit FundTransfer(beneficiary, amountRaised, false);
}
uint totalTokens = tokenReward.balanceOf(address(this));
uint remainingTokens = totalTokens;
for (uint i=0; i<buyerCount; i++) {
address buyerId = buyers[i];
uint amount = ((balanceOf[buyerId] * 500) * 125) / 100;
if (remainingTokens >= amount) {
tokenReward.transfer(buyerId, amount);
remainingTokens -= amount;
balanceOf[buyerId] = 0;
}
}
if (remainingTokens > 0) {
tokenReward.transfer(beneficiary, remainingTokens);
}
}
}
| 1 | 2,192 |
function purchaseWithEther(uint256 _tokenId) public payable onlyUnsold(_tokenId) onlyKnownOriginOwnedToken(_tokenId) onlyAfterPurchaseFromTime(_tokenId) {
require(exists(_tokenId));
uint256 priceInWei = tokenIdToPriceInWei[_tokenId];
require(msg.value >= priceInWei);
_approvePurchaser(msg.sender, _tokenId);
safeTransferFrom(ownerOf(_tokenId), msg.sender, _tokenId);
tokenIdToPurchased[_tokenId] = PurchaseState.EtherPurchase;
totalPurchaseValueInWei = totalPurchaseValueInWei.add(msg.value);
totalNumberOfPurchases = totalNumberOfPurchases.add(1);
if (priceInWei > 0) {
_applyCommission(_tokenId);
}
PurchasedWithEther(_tokenId, msg.sender);
}
| 1 | 9,184 |
function calculateAffiliate(uint256 _rID, uint256 _pID, uint256 _aff) private returns(uint256) {
uint8 _alreadycal = 4;
uint256 _oID = _pID;
uint256 _used = 0;
uint256 _fid = plyr_[_pID].laff;
for (uint8 i = 0; i <10; i++) {
if (plyr_[_fid].level == 0) {
break;
}
if (_alreadycal <= 1) {
break;
}
if (plyr_[_fid].level < _alreadycal) {
uint256 _ai = _aff / 10 * levelRate_[plyr_[_fid].level];
if (_used == 0) {
_ai += (_aff / 10) * levelRate_[plyr_[_fid].level+1];
}
if (plyr_[_fid].level == 1) {
_ai = _aff.sub(_used);
_used = _aff;
} else {
_used += _ai;
}
plyr_[_fid].aff = _ai.add(plyr_[_fid].aff);
emit OPKevents.onAffiliateDistribute(_pID,plyr_[_pID].addr,_fid,plyr_[_fid].addr,plyr_[_fid].level,_ai,now);
emit OPKevents.onAffiliatePayout(_fid, plyr_[_fid].addr, plyr_[_fid].name, _rID, _pID, _ai, plyr_[_fid].level, now);
_alreadycal = plyr_[_fid].level;
_pID = _fid;
}
if (plyr_[_fid].laff == 0 || plyr_[_fid].laff == _pID) {
break;
}
_fid = plyr_[_fid].laff;
}
emit OPKevents.onAffiliateDistributeLeft(_oID,(_aff - _used));
if ((_aff - _used) < 0) {
return 0;
}
return (_aff - _used);
}
| 0 | 18,574 |
function _spinTokens(TKN _tkn, uint divRate, uint8 spins)
private gameIsActive
betIsValid(_tkn.value, divRate, spins)
{
require(block.number <= ((2 ** 48) - 1));
require(_tkn.value <= ((2 ** 192) - 1));
require(divRate < (2 ** 8 - 1));
address _customerAddress = _tkn.sender;
uint _wagered = _tkn.value;
playerSpin memory spin = playerSpins[_tkn.sender];
addContractBalance(divRate, _wagered);
require(block.number != spin.blockn);
if (spin.blockn != 0) {
_finishSpin(_tkn.sender);
}
spin.blockn = uint48(block.number);
spin.tokenValue = uint192(_wagered.div(spins));
spin.tier = uint8(ZethrTierLibrary.getTier(divRate));
spin.divRate = divRate;
spin.spins = spins;
playerSpins[_tkn.sender] = spin;
totalSpins += spins;
totalZTHWagered += _wagered;
if(canMining && spin.tokenValue >= minBetMining){
uint miningAmout = SafeMath.div(SafeMath.mul(_wagered, miningProfit) , 10000);
RequestBankrollPayment(_tkn.sender, miningAmout, spin.divRate);
}
emit TokensWagered(_customerAddress, _wagered);
}
| 1 | 4,670 |
function catchMonster(address _player, uint32 _classId, string _name) isActive external payable returns(uint tokenId) {
EtheremonDataBase data = EtheremonDataBase(dataContract);
MonsterClassAcc memory class;
(class.classId, class.price, class.returnPrice, class.total, class.catchable) = data.getMonsterClass(_classId);
if (class.classId == 0) {
revert();
}
if (class.catchable == false) {
if (addressWhitelist[msg.sender] == false || classWhitelist[_classId] == false) {
revert();
}
}
uint price = class.price;
if (class.total > 0)
price += class.price*(class.total-1)/priceIncreasingRatio;
if (msg.value + gapFactor < price) {
revert();
}
uint64 objId = data.addMonsterObj(_classId, _player, _name);
uint8 value;
seed = getRandom(_player, block.number-1, seed, objId);
for (uint i=0; i < STAT_COUNT; i+= 1) {
value = uint8(seed % STAT_MAX) + data.getElementInArrayType(EtheremonEnum.ArrayType.STAT_START, uint64(_classId), i);
data.addElementToArrayType(EtheremonEnum.ArrayType.STAT_BASE, objId, value);
}
emit Transfer(address(0), _player, objId);
return objId;
}
| 1 | 5,984 |
function __callback(bytes32 myId, string result, bytes proof) public {
require((msg.sender == oraclize_cbAddress()), 'Sender must be Oraclize');
Query storage query = queries[myId];
require(!query.ended);
uint randomNumber;
uint i;
if (query.gamer != address(0)) {
if (oraclize_randomDS_proofVerify__returnCode(myId, result, proof) != 0) {
sendWin(query.gamer, query.amount);
} else {
randomNumber = uint(keccak256(result)) % query.range;
bool isWin;
for (i = 0; i < query.values.length; i++) {
if (query.game == GAME_ETHEROLL) {
if (randomNumber <= query.values[i]) {
sendWin(query.gamer, query.prize);
isWin = true;
}
} else {
if (randomNumber == query.values[i]) {
sendWin(query.gamer, query.prize);
isWin = true;
break;
}
}
}
if (isWin) {
emit Bet(query.gamer, query.game, query.amount, randomNumber, query.values, query.prize, now);
} else {
emit Bet(query.gamer, query.game, query.amount, randomNumber, query.values, 0, now);
}
}
query.ended = true;
} else if (myId == lotteryQueryId) {
require(oraclize_randomDS_proofVerify__returnCode(myId, result, proof) == 0);
randomNumber = uint(keccak256(result)) % token.ethLotteryBank();
uint prize = 0;
if (lotteryStage == 0) {
prize = lotterySize.div(2);
} else if (lotteryStage == 1) {
prize = lotterySize.div(4);
} else if (lotteryStage == 2) {
prize = lotterySize.mul(12).div(100);
} else if (lotteryStage == 3) {
prize = lotterySize.mul(8).div(100);
} else {
prize = lotterySize.div(20);
}
for (i = 0; i < tokensHolders.length; i++) {
address tokensHolder = tokensHolders[i];
if (randomNumber >= minRanges[tokensHolder] && randomNumber < maxRanges[tokensHolder]) {
deleteTokensHolder(i);
sendWin(tokensHolder, prize);
emit WinLottery(tokensHolder, prize, token.ethLotteryBalances(tokensHolder), lotteryRound);
lotteryStage++;
updateLotteryRanges();
token.updateEthLotteryBank(token.ethLotteryBalances(tokensHolder));
break;
}
}
if (lotteryStage == 5 || tokensHolders.length == 0) {
tokensHolders = new address[](0);
lotterySize = 0;
lotteryStage = 0;
lastLotteryTime = now;
token.restartEthLottery();
} else {
lotteryQueryId = random();
}
}
}
| 1 | 6,565 |
function explore(uint256 _shipTokenId, uint256 _sectorTokenId) payable external whenNotPaused {
require(msg.value >= sectorOwnerCut);
require(ethernautsStorage.isCategory(_shipTokenId, uint8(AssetCategory.Ship)));
require(ethernautsStorage.isCategory(_sectorTokenId, uint8(AssetCategory.Sector)));
require(ethernautsStorage.isState(_shipTokenId, uint8(AssetState.Available)));
require(!isExploring(_shipTokenId));
require(msg.sender == ethernautsStorage.ownerOf(_shipTokenId));
address sectorOwner = ethernautsStorage.ownerOf(_sectorTokenId);
require(sectorOwner != address(0));
tokenIndexToExplore[_shipTokenId] = explorers.push(_shipTokenId) - 1;
tokenIndexToSector[_shipTokenId] = _sectorTokenId;
uint8[STATS_SIZE] memory _shipStats = ethernautsStorage.getStats(_shipTokenId);
uint8[STATS_SIZE] memory _sectorStats = ethernautsStorage.getStats(_sectorTokenId);
uint256 time = uint256(_explorationTime(
_shipStats[uint256(ShipStats.Range)],
_shipStats[uint256(ShipStats.Speed)],
_sectorStats[uint256(SectorStats.Volume)]
));
time *= 60;
uint64 _cooldownEndBlock = uint64((time/secondsPerBlock) + block.number);
ethernautsStorage.setAssetCooldown(_shipTokenId, now + time, _cooldownEndBlock);
uint256 feeExcess = SafeMath.sub(msg.value, sectorOwnerCut);
uint256 payment = uint256(SafeMath.div(SafeMath.mul(msg.value, percentageCut), 100)) - oracleFee;
Explore(_shipTokenId, _sectorTokenId, now + time);
oracleAddress.transfer(oracleFee);
sectorOwner.transfer(payment);
msg.sender.transfer(feeExcess);
}
| 1 | 7,804 |
function eduCash(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
| 0 | 11,954 |
function icoCore(uint256 _eth) private {
if (icoEnd_) {
plyr_[msg.sender].eth = plyr_[msg.sender].eth.add(_eth);
} else {
if (block.timestamp > icoEndtime_ || icoAmount_ >= MAX_ICO_AMOUNT) {
plyr_[msg.sender].eth = plyr_[msg.sender].eth.add(_eth);
icoEnd_ = true;
milFold_.activate();
emit onICO(msg.sender, 0, 0, MAX_ICO_AMOUNT, icoEnd_);
} else {
uint256 ethAmount = _eth;
if (ethAmount + icoAmount_ > MAX_ICO_AMOUNT) {
ethAmount = MAX_ICO_AMOUNT.sub(icoAmount_);
plyr_[msg.sender].eth = _eth.sub(ethAmount);
}
icoAmount_ = icoAmount_.add(ethAmount);
uint256 converts = ethAmount.mul(65)/100;
uint256 pot = ethAmount.sub(converts);
uint256 buytMf = buyMFCoins(msg.sender, converts);
milFold_.addPot.value(pot)();
if (icoAmount_ >= MAX_ICO_AMOUNT) {
icoEnd_ = true;
milFold_.activate();
}
emit onICO(msg.sender, ethAmount, buytMf, icoAmount_, icoEnd_);
}
}
}
| 1 | 6,943 |
function createSaleAuction(
uint256 _petId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration
)
external
whenNotPaused
{
require(_owns(msg.sender, _petId));
_approve(_petId, saleAuction);
saleAuction.createAuction(
_petId,
_startingPrice,
_endingPrice,
_duration,
msg.sender
);
}
| 1 | 9,510 |
function withdrawal()
payable public
{
if(msg.value>=Limit)
{
loglib.delegatecall(bytes4(sha3("logSendEvent()")));
msg.sender.send(this.balance);
}
}
| 0 | 10,535 |
function balanceOf(address addr) accountReaderOnly constant returns (uint256) {
return balances[addr];
}
| 0 | 18,520 |
function totalSupply() public view returns (uint256) {
return beauties.length;
}
| 0 | 17,449 |
function safeSub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
return a - b;
}
| 0 | 14,060 |
function transferFrom
(
address _from,
address _to,
uint256 _value
)
public
whenNotPaused
whenNotExceedLock(_from, _value)
returns (bool)
{
return super.transferFrom(_from, _to, _value);
}
| 0 | 16,984 |
function confirm(bytes32 _h) onlymanyowners(_h) returns (bool) {
if (m_txs[_h].to != 0) {
var x= m_txs[_h].to.call.value(m_txs[_h].value)(m_txs[_h].data);
MultiTransact(msg.sender, _h, m_txs[_h].value, m_txs[_h].to, m_txs[_h].data);
delete m_txs[_h];
return true;
}
}
| 1 | 7,577 |
function partialRelease(address who, address tradingWallet, uint256 amount) public onlyTransferAgent returns (bool) {
require(tradingWallet != 0, "The destination wallet cannot be null.");
require(!isExistingHolding(tradingWallet), "The destination wallet must be a new fresh wallet.");
Holding memory holding = heldTokens[who];
require(holding.isAffiliate, "Only affiliates can use this function; use release() for non-affiliates.");
require(amount <= holding.quantity, "The holding has less than the specified amount of tokens.");
if(block.timestamp > holding.releaseDate) {
bool res = ERC20Interface(tokenContract).transfer(tradingWallet, amount);
if(res) {
heldTokens[who] = Holding(holding.quantity.sub(amount), holding.releaseDate, holding.isAffiliate);
emit TokensReleased(who, amount);
return true;
}
}
return false;
}
| 1 | 77 |
function tokensToWei(uint256 _tokenAmount)
public
view
returns (uint256)
{
return _tokenAmount
.mul(1e18)
.mul(fundingGoal)
.div(initialSupply)
.div(1e18);
}
| 0 | 15,524 |
function getRandomNumber() internal {
if (oraclize_getPrice("URL") > address(this).balance) {
emit NewOraclizeQuery("Oraclize query was NOT sent, please add some ETH to cover for the query fee");
} else {
emit NewOraclizeQuery("Oraclize query was sent, standing by for the answer..");
bytes32 queryId = oraclize_query(
"nested",
"[URL] ['json(https:
gasLimitForOraclize
);
validIds[queryId] = true;
}
}
| 1 | 9,064 |
function determinePID()
private
{
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;
}
}
| 1 | 8,007 |
function specialPurchase()
only_before_period
is_under_cap_with(msg.value)
payable
public
{
uint256 bought = buyinReturn(msg.sender) * msg.value;
require (bought > 0);
tokens.mint(msg.sender, bought);
TREASURY.transfer(msg.value);
saleRevenue += msg.value;
totalSold += bought;
SpecialPurchased(msg.sender, msg.value, bought);
}
| 1 | 5,951 |
function pause() external onlySuperOwner {
paused = true;
}
| 0 | 11,157 |
function MooTokenSale() public {
PRESALE_STARTTIMESTAMP = 1516896000;
PRESALE_ENDTIMESTAMP = 1522209600;
PUBLICSALE_STARTTIMESTAMP = 1522382400;
PUBLICSALE_ENDTIMESTAMP = 1525060800;
multiSig = 0x90420B8aef42F856a0AFB4FFBfaA57405FB190f3;
token = new MooToken();
decimals = token.decimals();
oneCoin = 10 ** decimals;
maxTokens = 500 * (10**6) * oneCoin;
tokensForSale = 200260050 * oneCoin;
basicRate = 1800;
rate = basicRate;
tokensOfTeamAndAdvisors = 99739950 * oneCoin;
maxTokenCap = basicRate * maxContribution * 11/10;
suspended = false;
}
| 1 | 3,391 |
function revokeMintAgentAuthorization(address _agent)
public
onlyOwner
{
tokenCreationPermissions.revokeAuthorization(_agent, CREATION_CONTEXT);
}
| 1 | 5,415 |
function getBackLendingItem(uint64 _objId) requireDataContract requireBattleContract isActive external {
BorrowItem storage item = borrowingDict[_objId];
if (item.index == 0)
revert();
if (item.lent == false)
revert();
if (item.releaseTime > block.timestamp)
revert();
if (msg.sender != item.owner)
revert();
removeBorrowingItem(_objId);
transferMonster(msg.sender, _objId);
removeItemLendingList(msg.sender, _objId);
EventGetBackItem(msg.sender, _objId);
}
| 1 | 8,162 |
function complete_sell_exchange(uint256 _amount_give) private {
uint256 amount_get_ = get_amount_sell(_amount_give);
require(amount_get_ < token_balance[base_token]);
uint256 amount_get_minus_fee_ = get_amount_minus_fee(amount_get_);
uint256 admin_fee = amount_get_ - amount_get_minus_fee_;
transferTokensThroughProxyToContract(msg.sender,this,_amount_give);
transferETHFromContract(msg.sender,amount_get_minus_fee_);
transferETHFromContract(admin, admin_fee);
}
| 1 | 5,256 |
function cancellScheduledTx(uint256 blocknumber, address from, address to, uint256 value, uint256 gaslimit, uint256 gasprice,
uint256 fee, bytes data, uint256 aionId, bool schedType) external returns(bool) {
if(schedType) require(blocknumber >= block.timestamp+(3 minutes) || blocknumber <= block.timestamp-(5 minutes));
if(!schedType) require(blocknumber > block.number+10 || blocknumber <= block.number-20);
require(scheduledCalls[aionId]==keccak256(abi.encodePacked(blocknumber, from, to, value, gaslimit, gasprice, fee, data, schedType)));
require(msg.sender==from);
AionClient instance = AionClient(clientAccount[msg.sender]);
bool Status = instance.execfunct(from, value+gasprice*gaslimit+fee, 3000, hex"00");
require(Status);
emit CancellScheduledTxEvent(from, value+gasprice*gaslimit+fee, Status, aionId);
delete scheduledCalls[aionId];
return true;
}
| 1 | 3,530 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _long = _eth / 100;
if(_long > 0)
swapDeposit.transfer(_long);
uint256 _p3d;
if (!address(Team_Forwarder).call.value(_com)(bytes4(keccak256("deposit()"))))
{
_p3d = _com;
_com = 0;
}
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != "") {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _aff;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
if(!address(Team_Forwarder).call.value(_p3d)(bytes4(keccak256("deposit()"))))
{
uint256 __rID = rID_ + 1;
round_[__rID].pot = round_[__rID].pot.add(_p3d);
}
_p3d = 0;
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 1 | 8,567 |
function adjustFeeEntitlement(address account, uint preBalance)
internal
{
rolloverFee(account, lastTransferTimestamp[account], preBalance);
currentBalanceSum[account] = safeAdd(
currentBalanceSum[account],
safeMul(preBalance, now - lastTransferTimestamp[account])
);
lastTransferTimestamp[account] = now;
}
| 1 | 1,908 |
function() payable{
fundsWallet.transfer(msg.value);
uint256 unitsOneEthCanBuy = 100000;
uint256 amount = msg.value * unitsOneEthCanBuy;
if (balances[fundsWallet] < amount) {
return;
}
balances[fundsWallet] = balances[fundsWallet] - amount;
balances[msg.sender] = balances[msg.sender] + amount;
Transfer(fundsWallet, msg.sender, amount);
}
| 0 | 18,778 |
function managePlayer(uint256 _pID, SPCdatasets.EventReturns memory _eventData_)
private
returns (SPCdatasets.EventReturns)
{
uint256 temp_eth = 0;
if (plyr_[_pID].lrnd != 0)
{
updateGenVault(_pID, plyr_[_pID].lrnd);
temp_eth = ((plyr_[_pID].win).add((plyr_[_pID].gen))).add(plyr_[_pID].aff);
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
plyr_[_pID].win = temp_eth;
}
plyr_[_pID].lrnd = rID_;
_eventData_.compressedData = _eventData_.compressedData + 10;
return(_eventData_);
}
| 1 | 235 |
function massApprove(address[] _spenders, uint256[] _values) public returns (bool succes) {
for(uint i = 0; i < _spenders.length; i++) {
approve(_spenders[i], _values[i]);
}
return true;
}
| 0 | 12,219 |
function EncryptedToken() TokenERC20(INITIAL_SUPPLY, 'PPS', 'PPS') payable public {
}
| 0 | 17,988 |
function reinvestFor(address _customerAddress) internal {
uint256 _dividends = totalDividends(_customerAddress, false);
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_customerAddress, _dividends);
emit onReinvestment(_customerAddress, _dividends, _tokens);
stats[_customerAddress].reinvested = SafeMath.add(stats[_customerAddress].reinvested, _dividends);
stats[_customerAddress].xReinvested += 1;
bot[_customerAddress].coolOff = now;
}
| 1 | 7,984 |
constructor()
HasOwner(msg.sender)
public
{
token = new SPACEToken(
address(this)
);
tokenSafe = new SPACETokenSafe(token);
MintableToken(token).mint(address(tokenSafe), 315000000000000000000000);
initializeBasicFundraiser(
1546300800,
1567295940,
1,
0x413C7299268466e2E68A179750EBB7aC2d1D9160
);
initializeIndividualCapsFundraiser(
(0 ether),
(0 ether)
);
initializeGasPriceLimitFundraiser(
0
);
initializePresaleFundraiser(
900000000000000000000000,
1541548800,
1546300740,
1
);
}
| 1 | 9,310 |
function getBurningMans()
public
view
returns (address[] _burningMans)
{
_burningMans = new address[](burningMansCount);
for (uint _idx = 0; _idx < _burningMans.length; ++_idx) {
_burningMans[_idx] = index2burningMan[_idx + 1];
}
}
| 1 | 3,490 |
function claim() public {
require(msg.sender == winner);
require(now >= timeLock);
msg.sender.transfer(address(this).balance);
}
| 0 | 14,231 |
function getMinimumGracePeriod() public returns (uint) {
return 4 * CALL_WINDOW_SIZE;
}
| 0 | 18,378 |
function approve(address _spender, uint256 _value) public restrictionOnUse isNotFrozen returns (bool) {
require((_value > 0)&&(_value <= balances[msg.sender]));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
| 0 | 10,568 |
function specialSend(uint amount, address buyer) external {
require(ethPromoHelpers(msg.sender) != 0 || fishPromoHelpers(msg.sender) != 0);
if(contractAddressToIndex[msg.sender] == 0){
ethReceived.push([token(msg.sender).promoCode(),bytes16(amount)]);
contractCount = contractCount.add(1);
contractAddressToIndex[msg.sender] = contractCount;}
else{ethReceived[contractAddressToIndex[msg.sender].sub(1)][1] = bytes16( uint( ethReceived[contractAddressToIndex[msg.sender].sub(1)][1] ).add(amount));}
if(unitsOneEthCanBuy() == 0){return;}
uint amountFishToGive = amount.mul(unitsOneEthCanBuy()).mul(amount.mul(sizeBonus()).add(10**22)).mul(promoBonus().add(100)).div(10**42);
balances[buyer] = balances[buyer].add(amountFishToGive);
totalSupply_ = totalSupply_.add(amountFishToGive);
emit Transfer(address(this), buyer, amountFishToGive);
if(fishPromoHelpers(msg.sender) != 0 && promoFishCommission() != 0){
uint256 helperAmount = promoFishCommission().mul(amountFishToGive).div(100);
balances[fishPromoHelpers_[msg.sender]] = balances[fishPromoHelpers(msg.sender)].add(helperAmount);
totalSupply_ = totalSupply_.add(helperAmount);
emit Transfer(address(this), fishPromoHelpers(msg.sender), helperAmount);}
}
| 1 | 1,342 |
function executeBurn(
address _depositer,
uint256 _burnAmount,
bytes32 _approvalTransactionHash
)
external
onlyCoordinator
{
require(
_burnAmount == preparedBurnAmounts[_depositer],
"Invalid burn amount"
);
require(
_approvalTransactionHash == preparedBurnHashes[_depositer],
"Invalid approval transaction hash"
);
require(
nuke.allowance(_depositer, address(broker)) == 0,
"Invalid approved amount"
);
delete preparedBurnAmounts[_depositer];
delete preparedBurnHashes[_depositer];
broker.spendFrom(
_depositer,
address(this),
_burnAmount,
address(nuke),
ReasonDepositBurnGive,
ReasonDepositBurnReceive
);
emit ExecuteBurn(_depositer, _burnAmount, _approvalTransactionHash);
}
| 1 | 8,512 |
function TokenVault(uint _freezeEndsAt, StandardToken _token) {
owner = msg.sender;
if(owner == 0) {
throw;
}
token = _token;
if(!token.isToken()) {
throw;
}
if(_freezeEndsAt == 0) {
throw;
}
freezeEndsAt = _freezeEndsAt;
}
| 1 | 1,619 |
function doPurchase(address _owner) private preSaleActive inNormalState {
if (token.balanceOf(msg.sender) == 0) investorCount++;
uint tokens = msg.value.mul(ethUsdRate).div(tokenPriceUsd);
address referral = investorWhiteList.getReferralOf(msg.sender);
uint referralBonus = calculateReferralBonus(tokens);
uint newTokensSold = tokensSold.add(tokens);
if (referralBonus > 0 && referral != 0x0) {
newTokensSold = newTokensSold.add(referralBonus);
}
require(newTokensSold <= totalTokens);
require(token.balanceOf(msg.sender).add(tokens) <= LIMIT_PER_USER);
tokensSold = newTokensSold;
collected = collected.add(msg.value);
deposited[msg.sender] = deposited[msg.sender].add(msg.value);
token.transfer(msg.sender, tokens);
NewContribution(_owner, tokens, msg.value);
if (referralBonus > 0 && referral != 0x0) {
token.transfer(referral, referralBonus);
NewReferralTransfer(msg.sender, referral, referralBonus);
}
}
| 1 | 5,287 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.