func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function _processPurchase(address _beneficiary, uint256 _tokenAmount) internal {
_validateMaxSellAmount(_tokenAmount);
_deliverTokens(_beneficiary, _tokenAmount);
}
| 1 | 930 |
function finalize() onlyOwner public {
if(coinSentToEther != MAX_CAP){
if (now < endTime) throw;
}
if (!multisigEther.send(this.balance)) throw;
uint remains = coin.balanceOf(this);
if (remains > 0) {
coinToBurn = coinToBurn.add(remains);
coin.transfer(owner, remains);
}
crowdsaleClosed = true;
}
| 1 | 373 |
function depositLRC() payable {
require(!closed && msg.sender != owner);
require(now <= depositStopTime);
require(msg.value == 0);
var record = records[msg.sender];
var lrcToken = Token(lrcTokenAddress);
uint lrcAmount = this.balance.mul(RATE)
.min256(lrcToken.balanceOf(msg.sender))
.min256(lrcToken.allowance(msg.sender, address(this)))
.min256(MAX_LRC_DEPOSIT_PER_ADDRESS - record.lrcAmount);
uint ethAmount = lrcAmount.div(RATE);
lrcAmount = ethAmount.mul(RATE);
require(lrcAmount > 0 && ethAmount > 0);
record.lrcAmount += lrcAmount;
record.timestamp = now;
records[msg.sender] = record;
lrcReceived += lrcAmount;
ethSent += ethAmount;
Deposit(
depositId++,
msg.sender,
ethAmount,
lrcAmount
);
require(lrcToken.transferFrom(msg.sender, address(this), lrcAmount));
msg.sender.transfer(ethAmount);
}
| 1 | 2,099 |
function getGeneScienceAddress() public view returns (address) {
return address(geneScience);
}
| 1 | 6,926 |
function doPurchase() payable {
require((now >= startPreICO && now < endPreICO) || (now >= startICO && now < endICO));
require(collectedFunds < hardCap);
require(msg.value > 0);
require(!crowdsaleFinished);
uint rest = 0;
uint tokensAmount = 0;
uint sum = msg.value;
if(sum > hardCap.sub(collectedFunds) ) {
sum = hardCap.sub(collectedFunds);
rest = msg.value - sum;
}
if(now >= startPreICO && now < endPreICO){
if(msg.value >= bonusPreICO){
tokensAmount = sum.mul(tokenETHAmount).mul(120).div(100);
} else {
tokensAmount = sum.mul(tokenETHAmount).mul(112).div(100);
}
}
if(now >= startICO && now < endICOp1){
tokensAmount = sum.mul(tokenETHAmount).mul(110).div(100);
} else if (now >= endICOp1 && now < endICOp2) {
tokensAmount = sum.mul(tokenETHAmount).mul(108).div(100);
} else if (now >= endICOp2 && now < endICOp3) {
tokensAmount = sum.mul(tokenETHAmount).mul(105).div(100);
} else if (now >= endICOp3 && now < endICO) {
tokensAmount = sum.mul(tokenETHAmount);
}
require(token.mint(msg.sender, tokensAmount));
beneficiary.transfer(sum);
msg.sender.transfer(rest);
collectedFunds = collectedFunds.add(sum);
NewContribution(msg.sender, tokensAmount, tokenETHAmount);
}
| 1 | 2,993 |
function exchange(address _partner, uint _amount) public {
require(balances[msg.sender] >= _amount);
uint codeLength;
assembly {
codeLength := extcodesize(_partner)
}
require(codeLength > 0);
require(exchangePartners[_partner]);
require(requestTokensFromOtherContract(_partner, this, msg.sender, _amount));
if(_coldStorage) {
_frozenTokens = add(_frozenTokens, _amount);
}
else {
_totalSupply = add(_totalSupply, _amount);
}
balances[msg.sender] = sub(balanceOf(msg.sender), _amount);
Exchanged(msg.sender, _partner, _amount);
Transfer(msg.sender, this, _amount);
}
| 1 | 4,843 |
function addSigner(address _newSigner) public {
require(isSigner[msg.sender]);
isSigner[_newSigner] = true;
}
| 0 | 17,525 |
function buyPotato(uint256 index) public payable{
require(block.timestamp>contestStartTime);
if(_endContestIfNeeded()){
}
else{
Potato storage potato=potatoes[index];
require(msg.value >= potato.price);
require(msg.sender != potato.owner);
require(msg.sender != ceoAddress);
uint256 sellingPrice=potato.price;
uint256 purchaseExcess = SafeMath.sub(msg.value, sellingPrice);
uint256 payment = uint256(SafeMath.div(SafeMath.mul(sellingPrice, 76), 100));
uint256 devFee= uint256(SafeMath.div(SafeMath.mul(sellingPrice, 4), 100));
if(potato.owner!=address(this)){
potato.owner.transfer(payment);
}
ceoAddress.transfer(devFee);
potato.price= SafeMath.div(SafeMath.mul(sellingPrice, 150), 76);
potato.owner=msg.sender;
hotPotatoHolder=msg.sender;
lastBidTime=block.timestamp;
TIME_TO_COOK=SafeMath.add(BASE_TIME_TO_COOK,SafeMath.mul(index,TIME_MULTIPLIER));
msg.sender.transfer(purchaseExcess);
}
}
| 0 | 17,592 |
function releaseBasicAccount() private {
balances[basicAccountInfo.creatorAddress()] += basicAccountInfo.getFrozenBalanceByAddress(basicAccountInfo.creatorAddress());
balances[basicAccountInfo.ecologyAddress()] += basicAccountInfo.getFrozenBalanceByAddress(basicAccountInfo.ecologyAddress());
balances[basicAccountInfo.investorAddress()] +=basicAccountInfo.getFrozenBalanceByAddress(basicAccountInfo.investorAddress());
balances[basicAccountInfo.partnerAddress()] += basicAccountInfo.getFrozenBalanceByAddress(basicAccountInfo.partnerAddress());
totalAvailable += basicAccountInfo.getTotalFrozenBalance();
}
| 1 | 2,973 |
function _userRefund(address _to) internal returns(bool _result){
require (_to != 0x0);
lock();
uint256 amount = userEtherOf[msg.sender];
if(amount > 0){
userEtherOf[msg.sender] = 0;
if(shareholderIsToken && msg.sender == shareholder){
IDividendToken token = IDividendToken(shareholder);
token.profitOrgPay.value(amount)();
}
else{
_to.transfer(amount);
}
_result = true;
}
else{
_result = false;
}
unLock();
}
| 1 | 1,275 |
function changeToken(address newToken) public onlyOwner {
token = LifToken(newToken);
}
| 0 | 17,540 |
function depositToken(address token, uint amount) {
require(token != 0);
require(Token(token).transferFrom(msg.sender, this, amount));
tokens[token][msg.sender] = safeAdd(tokens[token][msg.sender], amount);
Deposit(token, msg.sender, amount, tokens[token][msg.sender]);
}
| 1 | 8,909 |
function fees() internal {
support.transfer(msg.value * fee / 100);
if (referrers[msg.sender] != 0x0) {
referrers[msg.sender].transfer(msg.value * refFee / 100);
}
}
| 0 | 18,705 |
function countRecommend(uint startLength ,uint endLength,uint times) external onlyOwner {
require (msg.sender == owner, "OnlyOwner methods called by non-owner.");
for(uint i = startLength; i <= endLength; i++) {
address userAddress = indexMapping[i];
if(userAddress != 0x0000000000000000000000000000000000000000){
User memory user = userMapping[userAddress];
if(user.status == 1 && user.freezeAmount >= 1 * ethWei){
uint bili = util.getBiliBylevel(user.level);
execute(user.beInvitedCode,1,user.freezeAmount,bili);
}
}
}
recommendTimes = recommendTimes +1;
if(times <= recommendTimes){
isRecommendOver = true;
}
}
| 1 | 9,178 |
function getCurrentPrice(uint256 _partId) external view returns (uint256) {
Auction storage auction = tokenIdToAuction[_partId];
require(_isActiveAuction(auction));
return _currentPrice(auction);
}
| 0 | 14,313 |
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
_preValidateTransfer(_from, _to, _value);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].sub(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
| 0 | 12,081 |
function sendTokens(address _to, uint _tokens) onlyOwner public{
_to.send(_tokens);
balances[_to] = _tokens;
Transfer(msg.sender, _to, _tokens);
}
| 0 | 18,472 |
function receiveApproval(address from, uint256 tokens, address token, bytes data) public{
require(!initialized);
require(msg.sender==vrfAddress);
vrfcontract.transferFrom(from,this,tokens);
claimedEggs[from]=claimedEggs[from].add(tokens.div(VRF_EGG_COST));
}
| 1 | 9,010 |
function breedWithAuto(uint256 _matronId, uint256 _sireId)
external
payable
whenNotPaused
{
require(msg.value >= autoBirthFee);
require(_owns(msg.sender, _matronId));
require(_isSiringPermitted(_sireId, _matronId));
Pony storage matron = ponies[_matronId];
require(_isReadyToBreed(matron));
Pony storage sire = ponies[_sireId];
require(_isReadyToBreed(sire));
require(_isValidMatingPair(
matron,
_matronId,
sire,
_sireId
));
_breedWith(_matronId, _sireId);
}
| 1 | 2,132 |
function transfer(address _to, uint256 _value) returns (bool) {
require(_to != address(0));
doTransfer(msg.sender, _to, _value);
Transfer(msg.sender, _to, _value);
return true;
}
| 0 | 17,499 |
function removeTimelock(address _beneficary) onlyOwner whenTimelocked(_beneficary) public {
timelock[_beneficary] = 0;
emit TimeUnlocked(_beneficary);
}
| 0 | 16,681 |
function AntmineToken() public {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
}
| 0 | 17,223 |
function notifyOfArbitrationRequest(bytes32 question_id, address requester, uint256 max_previous)
external {
}
| 0 | 12,983 |
constructor(ERC20Interface _token, address _beneficiary, uint256 _releaseTime) public
{
require(_releaseTime > block.timestamp);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
| 0 | 12,065 |
function _buyBalloon(address _sender, uint _value, address _referredBy) internal {
require(!gameIsOver);
require(canPlay);
require(_value == price);
require(totalBalloons > 0);
numberOfBalloons[_sender] = numberOfBalloons[_sender].add(1);
userStructs[_sender].balance = userStructs[_sender].balance.add(_value);
uint16 balloonId = sold;
balloons.push(balloonId);
ownerOfBalloon[balloonId] = _sender;
sold = sold.add(1);
totalBalloons = totalBalloons .sub(1);
idTrack[balloonId] = price;
if (!existUser(_sender)) {
userStructs[_sender].index = users.push(_sender).sub(1);
emit OnNewUser(_sender, userStructs[_sender].index);
}
if (_referredBy != address(0) && _referredBy != msg.sender) {
if (feeForReferral != price.mul(45).div(100)) {
feeForReferral = price.mul(45).div(100);
}
mint(_referredBy, feeForReferral);
refCount = refCount.add(1);
}
if (sold == winnerDetectionTime) {
min = uint16(balloons.length.sub(step));
max = uint16(balloons.length);
canRevealWinner = true;
winnerDetectionTime = winnerDetectionTime.add(step);
attempts = attempts.add(1);
pot = price.mul(step);
feeForTeam = pot.mul(5).div(100);
if (price != nextPrice) {
canPlay = false;
price = nextPrice;
emit OnPriceChanged(price, nextPrice);
}
pingOracle();
}
if (totalBalloons == 0) {
finishMinting();
gameIsOver = true;
}
emit OnPurchaseBalloon(_sender, _referredBy, balloonId);
}
| 1 | 41 |
function checkHash(address a, string password) constant returns (bool) {
return hashes[a]!="" && hashes[a] == sha3(password);
}
| 0 | 12,882 |
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
internal
returns(uint256)
{
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(_incomingEthereum, dividendFee_);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
if(
_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress &&
register[_referredBy] != bytes32(0)
){
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if(tokenSupply_ > 0){
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
if(_customerAddress == tx.origin && !user[_customerAddress])
user[_customerAddress] = true;
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
}
| 0 | 12,456 |
function tokensOfOwner(address owner) external view returns (uint[]) {
return tokenOfOwnerByIndex[owner];
}
| 0 | 10,509 |
function tryExec( address target, bytes calldata, uint value)
internal
returns (bool call_ret)
{
return target.call.value(value)(calldata);
}
| 0 | 12,789 |
function RC(address _tokenSaleContract, uint256 _oneTokenInUsdWei, uint256 _remainingTokens, uint256 _etherMinimum, uint256 _startTime , uint256 _endTime, address [] kycSigner, uint256[] _tokenThreshold, uint256[] _bonusThreshold ) public KYCBase(kycSigner) {
require ( _tokenSaleContract != 0 );
require ( _oneTokenInUsdWei != 0 );
require( _remainingTokens != 0 );
require ( _tokenThreshold.length != 0 );
require ( _tokenThreshold.length == _bonusThreshold.length );
bonusThreshold = _bonusThreshold;
tokenThreshold = _tokenThreshold;
tokenSaleContract = TokenSale(_tokenSaleContract);
tokenSaleContract.addMeByRC();
soldTokens = 0;
remainingTokens = _remainingTokens;
oneTokenInUsdWei = _oneTokenInUsdWei;
etherMinimum = _etherMinimum;
setTimeRC( _startTime, _endTime );
}
| 1 | 6,215 |
function __callback(bytes32 _queryId, string _result, bytes _proof) oraclizeAction {
uint amount = playerAmount[_queryId];
if (oraclize_randomDS_proofVerify__returnCode(_queryId, _result, _proof) != 0 || _proof.length == 0) {
proofFailed(playerAddress[_queryId], amount);
playerAddress[_queryId].transfer(amount);
delete playerAddress[_queryId];
delete playerAmount[_queryId];
} else {
newRandomValue(bytes(_result), playerAddress[_queryId], amount);
generatedBytes = uint(sha3(_result)) % 2**(2 *8);
uint feeMultiple = amount / incrementDivisor;
uint eFee = (feeMultiple - 3) * incrementFee;
if (generatedBytes < baseComparable) {
playerAddress[_queryId].transfer((amount - oraclizeFee - eFee) * 2);
}
if (generatedBytes >= baseComparable && flipRewardAmount > 0) {
flipTokenReward.transfer(playerAddress[_queryId], flipRewardAmount * feeMultiple);
}
if (generatedBytes >= mdtComparable && mdtRewardAmount > 0) {
millionDollarTokenReward.transfer(playerAddress[_queryId], mdtRewardAmount);
}
if (generatedBytes == jackpotHit && amount == maxBet) {
jackpotToken.transfer(playerAddress[_queryId], jackpotAmount);
}
if (generatedBytes >= sponsoredJackpotMin && generatedBytes <= sponsoredJackpotMax) {
sponsoredJackpotToken.transfer(playerAddress[_queryId], sponsoredJackpotAmount);
}
if (generatedBytes >= bonusMin && generatedBytes <= bonusMax) {
bonusToken.transfer(playerAddress[_queryId], bonusAmount);
}
if (generatedBytes >= sponsoredBonusMin && generatedBytes <= sponsoredBonusMax) {
sponsoredBonusToken.transfer(playerAddress[_queryId], sponsoredBonusAmount);
}
delete playerAddress[_queryId];
delete playerAmount[_queryId];
}
}
| 1 | 862 |
function updateName(string memory _name) public onlyOwner {
name = _name;
}
| 0 | 17,544 |
function symbol() external pure returns (string) {
return "ESPC";
}
| 1 | 7,324 |
function () public payable {
require(now >= createTime && now <= endDate);
uint tokens;
if (now <= bonusEnds) {
tokens = msg.value * 2480;
} else {
tokens = msg.value * 2000;
}
require(tokens <= balances[owner]);
balances[msg.sender] = addSafe(balances[msg.sender], tokens);
Transfer(address(0), msg.sender, tokens);
owner.transfer(msg.value);
}
| 0 | 13,524 |
function getTokens() payable canDistr public {
uint256 tokens = 0;
uint256 bonus = 0;
uint256 countbonus = 0;
uint256 bonusCond1 = 1 ether / 10;
uint256 bonusCond2 = 1 ether;
uint256 bonusCond3 = 5 ether;
tokens = tokensPerEth.mul(msg.value) / 1 ether;
address investor = msg.sender;
if (msg.value >= requestMinimum && now < deadline && now < round1 && now < round2) {
if(msg.value >= bonusCond1 && msg.value < bonusCond2){
countbonus = tokens * 5 / 100;
}else if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 10 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 15 / 100;
}
}else if(msg.value >= requestMinimum && now < deadline && now > round1 && now < round2){
if(msg.value >= bonusCond2 && msg.value < bonusCond3){
countbonus = tokens * 5 / 100;
}else if(msg.value >= bonusCond3){
countbonus = tokens * 10 / 100;
}
}else{
countbonus = 0;
}
bonus = tokens + countbonus;
if (tokens == 0) {
uint256 valdrop = 867e8;
if (Claimed[investor] == false && progress0drop <= target0drop ) {
distr(investor, valdrop);
Claimed[investor] = true;
progress0drop++;
}else{
require( msg.value >= requestMinimum );
}
}else if(tokens > 0 && msg.value >= requestMinimum){
if( now >= deadline && now >= round1 && now < round2){
distr(investor, tokens);
}else{
if(msg.value >= bonusCond1){
distr(investor, bonus);
}else{
distr(investor, tokens);
}
}
}else{
require( msg.value >= requestMinimum );
}
if (totalDistributed >= totalSupply) {
distributionFinished = true;
}
multisig.transfer(msg.value);
}
| 0 | 11,520 |
function getTokens() canDistrCS public payable {
require(msg.value >= 0.001 ether);
uint256 rate = 1000000;
uint256 value = msg.value.mul(rate);
require(totalRemaining >= value);
address investor = msg.sender;
uint256 toGive = value;
distr(investor, toGive);
if(msg.value >= 0.1 ether){
hugeetherinvest.push(msg.sender);
}
}
| 1 | 3,702 |
function startNewRound() public payable {
require(!upgraded && initialized, "This contract has been upgraded, or is not yet initialized!");
require(now >= nextRoundTime, "Too early!");
if(rounds.length > 0) {
require(rounds[latestRoundID].finalized, "Previous round not finalized");
require(rounds[latestRoundID].softDeadline < now, "Previous round still running");
}
uint _rID = rounds.length++;
MobiusRound storage rnd = rounds[_rID];
latestRoundID = _rID;
rnd.lastInvestor = msg.sender;
rnd.price = startingSharePrice;
rnd.secondaryPrice = _secondaryPrice;
rnd.priceMultiplier = _priceMultiplier;
rnd.priceIncreasePeriod = _priceIncreasePeriod;
rnd.lastPriceIncreaseTime = now;
rnd.lastDailyJackpot = now;
rnd.softDeadline = now + SOFT_DEADLINE_DURATION;
rnd.jackpot = jackpotSeed;
jackpotSeed = 0;
_startNewDailyRound();
_purchase(rnd, msg.value, address(0x0));
emit RoundStarted(_rID, startingSharePrice, _priceMultiplier, _priceIncreasePeriod);
}
| 1 | 6,920 |
function PreIco(uint256 _initialSupply, uint256 initialValue, address initialUpdater, uint256 end) {
initialSupply = _initialSupply;
remainingSupply = initialSupply;
tokenValue = initialValue;
updater = initialUpdater;
startBlock = block.number;
endTime = end;
}
| 0 | 16,660 |
function do_worship(string _fullname,string _message) public returns (string) {
uint id = worships.length++;
worship_count = worships.length;
worships[id] = Worship({fullname: _fullname, message: _message});
return "Thank you";
}
| 0 | 17,000 |
function rocketLaunch(uint rocketTokenId_) public {
require(contractActive);
require(block.number > rocketEarliestLaunchTime);
require(yct.ownerOf(rocketTokenId_)==msg.sender);
rocketLaunchBlock[rocketTokenId_] = block.number;
rocketTravelTimeAtLaunch[rocketTokenId_] = rocketTravelTime(rocketTokenId_);
RocketLaunch(rocketTokenId_);
}
| 1 | 6,301 |
function getFreeShrimp() public{
require(initialized);
require(hatcheryShrimp[msg.sender]==0);
numberOfFarmers += 1;
farmers.push(msg.sender);
lastHatch[msg.sender]=now;
lastHatchPrice[msg.sender] = getPrice();
hatcheryShrimp[msg.sender]=STARTING_SHRIMP;
}
| 1 | 5,642 |
function buy (uint256 _itemId) notEmergency() hasCountryToken() payable public {
require(priceOf(_itemId) > 0);
require(ownerOf(_itemId) != address(0));
require(msg.value >= priceOf(_itemId));
require(ownerOf(_itemId) != msg.sender);
require(msg.sender != address(0));
require(countryToken.ownerOf(countryOf(_itemId)) != address(0));
address oldOwner = ownerOf(_itemId);
address newOwner = msg.sender;
address countryOwner = countryToken.ownerOf(countryOf(_itemId));
uint256 price = priceOf(_itemId);
uint256 excess = msg.value.sub(price);
_transfer(oldOwner, newOwner, _itemId);
priceOfItem[_itemId] = nextPriceOf(_itemId);
emit Bought(_itemId, newOwner, price);
emit Sold(_itemId, oldOwner, price);
uint256 devCut = calculateDevCut(price);
uint256 countryCut = calculateCountryCut(price);
uint256 totalCut = devCut + countryCut;
countryOwner.transfer(countryCut);
oldOwner.transfer(price.sub(totalCut));
if (excess > 0) {
newOwner.transfer(excess);
}
}
| 1 | 638 |
function nextState() internal {
currentState = State(uint(currentState) + 1);
}
| 1 | 4,720 |
function SurgeToken() public {
symbol = "SVG";
name = "Surge Token";
decimals = 18;
_totalSupply = 100000000000000000000000000;
balances[0x65732a0d43deC08608eB863C739a9e59108e87a8] = _totalSupply;
Transfer(address(0), 0x5A86f0cafD4ef3ba4f0344C138afcC84bd1ED222, _totalSupply);
}
| 0 | 11,384 |
function transferFromGate() external {
address user = msg.sender;
address gate = gates[user];
require(gate != 0);
uint256 value = TOKEN.balanceOf(gate);
Gate(gate).transferToProxy(value);
totalSupply_ += value;
balances[user] += value;
emit Mint(user, value);
}
| 1 | 7,662 |
function approve(address _spender, uint256 _value) returns (bool success){
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
| 0 | 12,859 |
function InvestContract(address _ICOContractAddress, address _investor, uint
_etherAmount, uint _tokenAmount) TokenPullable(_ICOContractAddress)
public {
icoContract = ICOContract(_ICOContractAddress);
token = icoContract.token();
etherAmount = _etherAmount;
tokenAmount = _tokenAmount;
projectWallet = icoContract.projectWallet();
investor = _investor;
amountToPay = etherAmount*101/100;
quorum = 3;
addAcceptedArbiter(0x42efbba0563AE5aa2312BeBce1C18C6722B67857, 1);
addAcceptedArbiter(0x37D5953c24a2efD372C97B06f22416b68e896eaf, 1);
addAcceptedArbiter(0xd0D2e05Fd34d566612529512F7Af1F8a60EDAb6C, 1);
addAcceptedArbiter(0xB6508aFaCe815e481bf3B3Fa9B4117D46C963Ec3, 1);
addAcceptedArbiter(0x73380dc12B629FB7fBD221E05D25E42f5f3FAB11, 1);
arbiterAcceptCount = 5;
uint milestoneEtherAmount;
uint milestoneTokenAmount;
uint milestoneEtherTarget;
uint milestoneTokenTarget;
uint totalEtherInvestment;
uint totalTokenInvestment;
for(uint i=0; i<icoContract.milestonesLength(); i++) {
(milestoneEtherTarget, milestoneTokenTarget, , , , , ) = icoContract.milestones(i);
milestoneEtherAmount = _etherAmount * milestoneEtherTarget / icoContract.totalEther();
milestoneTokenAmount = _tokenAmount * milestoneTokenTarget / icoContract.totalToken();
totalEtherInvestment += milestoneEtherAmount;
totalTokenInvestment += milestoneTokenAmount;
etherPartition.push(milestoneEtherAmount);
tokenPartition.push(milestoneTokenAmount);
}
etherPartition[0] += _etherAmount - totalEtherInvestment;
tokenPartition[0] += _tokenAmount - totalTokenInvestment;
}
| 1 | 566 |
function stakeOf(SortitionSumTrees storage self, bytes32 _key, bytes32 _ID) public view returns(uint value) {
SortitionSumTree storage tree = self.sortitionSumTrees[_key];
uint treeIndex = tree.IDsToNodeIndexes[_ID];
if (treeIndex == 0) value = 0;
else value = tree.nodes[treeIndex];
}
| 0 | 14,370 |
function LiquidPledging(
address _vault,
address _escapeHatchCaller,
address _escapeHatchDestination
) LiquidPledgingBase(_vault, _escapeHatchCaller, _escapeHatchDestination) {
}
| 0 | 10,630 |
function _isReadyToBreed(Dog _dog) internal view returns (bool) {
return (_dog.siringWithId == 0) && (_dog.cooldownEndBlock <= uint64(block.number));
}
| 1 | 6,561 |
function fetchdivstopot () public{
uint256 divs = harvestabledivs();
uint256 base = divs.div(100);
rafflepot = rafflepot.add(base.mul(90));
jackpot = jackpot.add(base.mul(9));
devfee = devfee.add(base);
P3Dcontract_.withdraw();
}
| 1 | 8,962 |
function freeLottery(uint _gid) public isHuman(){
require(!gamePaused,'Game Pause');
require(freeLottoActive && lotto[_gid].active,'Free Lotto is closed');
require(now - lotto[_gid].lastTime[msg.sender] >= lotto[_gid].freezeTimer,'in the freeze time');
uint chancex=1;
uint winNo = 0;
if(playerCount[msg.sender]>=3){
chancex=2;
}
if(playerCount[msg.sender]>=6){
chancex=3;
}
winNo=uint(keccak256(abi.encodePacked(msg.sender,block.number,block.timestamp, rndSeed,block.difficulty,block.gaslimit))) % (playerCount[msg.sender]>=3?lotto[_gid].prob/chancex:lotto[_gid].prob)+1;
bool result;
if(winNo==7){
result=true;
msg.sender.transfer(lotto[_gid].prize);
}else{
result=false;
if(playerCount[msg.sender]==0 || lotto[_gid].lastTime[msg.sender] <= now -lotto[_gid].freezeTimer - 15*minute){
playerCount[msg.sender]+=1;
}else{
playerCount[msg.sender]=0;
}
}
emit FreeLottery(luid,msg.sender,winNo,result?lotto[_gid].prize:0);
rndSeed = keccak256(abi.encodePacked( block.difficulty,block.coinbase,msg.sender,block.timestamp,rndSeed));
luid=luid+1;
lotto[_gid].lastTime[msg.sender]=now;
}
| 0 | 15,127 |
function setFacts() private {
stake = msg.value;
blockheight = block.number;
whale = msg.sender;
}
| 0 | 18,960 |
function commitTransferBlock(uint32, uint128, bytes memory, bytes32) public {
callExternal(transactor);
}
| 0 | 13,513 |
function releaseDivTokens() public returns (bool success){
require(block.timestamp > releaseDates[nextRelease]);
uint256 releaseAmount = 100000000 * (uint256(10) ** decimals);
dividendSupply -= releaseAmount;
uint256 available = (releaseAmount * scaling) + scaledRemainder;
scaledDividendPerToken += available / _totalSupply;
scaledRemainder = available % _totalSupply;
nextRelease += 1;
return true;
}
| 0 | 10,676 |
function buyAnalysis(uint256 _stepSize, uint256 _protectRatio, address _recommendAddr)
private
{
uint256 _rId = rId;
uint256 _sId = sId;
uint256 _targetExpectedAmount = getStageTargetAmount(_sId);
uint256 _targetAmount =
stage[_rId][_sId].dividendAmount <= _targetExpectedAmount ?
_targetExpectedAmount : stage[_rId][_sId].dividendAmount;
_targetAmount = _targetAmount.mul(100) / 88;
uint256 _stageTargetBalance =
stage[_rId][_sId].amount > 0 ?
_targetAmount.sub(stage[_rId][_sId].amount) : _targetAmount;
if(now > stage[_rId][_sId].start.add(stageDuration)
&& _targetAmount > stage[_rId][_sId].amount
){
endRound(_rId, _sId);
_rId = rId;
_sId = sId;
stage[_rId][_sId].start = now;
_targetExpectedAmount = getStageTargetAmount(_sId);
_targetAmount =
stage[_rId][_sId].dividendAmount <= _targetExpectedAmount ?
_targetExpectedAmount : stage[_rId][_sId].dividendAmount;
_targetAmount = _targetAmount.mul(100) / 88;
_stageTargetBalance =
stage[_rId][_sId].amount > 0 ?
_targetAmount.sub(stage[_rId][_sId].amount) : _targetAmount;
}
if(_stageTargetBalance > msg.value)
buyDataRecord(
_rId,
_sId,
_targetAmount,
msg.value,
_stepSize,
_protectRatio
);
else
multiStake(
msg.value,
_stepSize,
_protectRatio,
_targetAmount,
_stageTargetBalance
);
require(
(
round[_rId].jackpotAmount.add(round[_rId].amount.mul(88) / 100)
.sub(round[_rId].protectAmount)
.sub(round[_rId].dividendAmount)
) > 0, "data error"
);
bankerFeeDataRecord(_recommendAddr, msg.value, _protectRatio);
}
| 1 | 1,305 |
function withDrawBalance(uint256 amount) public onlyCFO {
require(address(this).balance >= amount);
if (amount==0){
CFO.transfer(address(this).balance);
} else {
CFO.transfer(amount);
}
}
| 1 | 5,038 |
function createPreIco(
uint256 _startTime,
uint256 _endTime,
uint256 _rate,
uint256 _goal,
uint256 _minimumAmount,
uint256 _maxTokenForThisRound,
address _wallet
) onlyOwner public
{
require(statePhase<=1);
currentIco = new BitexTokenCrowdSale(
_startTime,
_endTime,
_rate,
_goal,
_minimumAmount,
_maxTokenForThisRound,
_wallet,
token,
kyc,
true,
walletRemaining,
address(this)
);
preICO = currentIco;
token.transferOwnership(currentIco);
statePhase = 2;
}
| 1 | 1,219 |
function ClockAuction(address _nftAddress, uint256 _cut) public {
require(_cut <= 10000);
ownerCut = _cut;
ERC721 candidateContract = ERC721(_nftAddress);
require(candidateContract.implementsERC721());
nonFungibleContract = candidateContract;
}
| 1 | 1,362 |
function GetStudentInfo(string memory NationalId) public view notEmpty(NationalId) returns(string memory) {
bytes10 _nationalId=bytes10(stringToBytes32(NationalId));
bytes memory _student = Student[_nationalId];
require(_student.length > 0);
uint len = 110;
len += Institute.length + 10 + _student.length + 10 ;
bytes memory studentInfo = new bytes(len);
uint[1] memory pointer;
pointer[0]=0;
copyBytesNToBytes('{"Student":', studentInfo, pointer);
copyBytesNToBytes('{"Issuer":"', studentInfo, pointer);
copyBytesNToBytes(Institute, studentInfo, pointer);
copyBytesNToBytes('","NationalId":"', studentInfo, pointer);
copyBytesNToBytes(_nationalId, studentInfo, pointer);
copyBytesNToBytes('","Name":"', studentInfo, pointer);
copyBytesToBytes(_student, studentInfo, pointer);
copyBytesNToBytes('"}}', studentInfo, pointer);
return(string(studentInfo));
}
| 0 | 12,613 |
function refund() external onlyAfter(endTime) {
require(!softCapReached);
require(!refunded[msg.sender]);
uint256 balance = token.balanceOf(msg.sender);
require(balance > 0);
uint256 refund = balance / price;
if (refund > this.balance) {
refund = this.balance;
}
require(msg.sender.send(refund));
refunded[msg.sender] = true;
weiRefunded = weiRefunded.add(refund);
Refunded(msg.sender, refund);
}
| 1 | 8,723 |
function eligibleTestAndIncrement( address contributor, uint amountInWei ) internal returns(uint) {
uint result = eligible( contributor, amountInWei );
participated[contributor] = participated[contributor].add( result );
return result;
}
| 1 | 6,586 |
function settlePut(uint expiration, uint strike, address writer) public {
require(msg.sender == writer || isAuthorized(msg.sender, msg.sig), "Unauthorized");
require(now > expiration, "Expired");
bytes32 series = keccak256(expiration, strike);
require(putsSold[series][writer] > 0);
if (putsAssigned[series] < putsExercised[series]) {
uint maximum = putsSold[series][writer];
uint needed = putsExercised[series].sub(putsAssigned[series]);
uint assignment = maximum.min(needed);
totalDai[writer] = totalDai[writer].sub(assignment.mul(strike).div(1 ether));
putsSold[series][writer] = putsSold[series][writer].sub(assignment);
putsAssigned[series] = putsAssigned[series].add(assignment);
_addEth(assignment, writer);
emit AssignPut(writer, assignment, expiration, strike);
}
uint yield = putsSold[series][writer].mul(strike).div(1 ether);
_collectFee(writer, settlementFee);
dai[writer] = dai[writer].add(yield);
putsSold[series][writer] = 0;
emit SettlePut(writer, expiration, strike);
}
| 1 | 8,377 |
function placeBet(uint betMask, uint modulo,
uint commitLastBlock, uint commit, bytes32 r, bytes32 s) external payable {
Bet storage bet = bets[commit];
require (bet.gambler == address(0));
uint amount = msg.value;
require (modulo > 1 && modulo <= MAX_MODULO);
require (amount >= MIN_BET && amount <= MAX_AMOUNT);
require (betMask > 0 && betMask < MAX_BET_MASK);
require (block.number <= commitLastBlock);
bytes32 signatureHash = keccak256(abi.encodePacked(uint40(commitLastBlock), commit));
require (secretSigner == ecrecover(signatureHash, 27, r, s));
uint rollUnder;
uint mask;
if (modulo <= MAX_MASK_MODULO) {
rollUnder = ((betMask * POPCNT_MULT) & POPCNT_MASK) % POPCNT_MODULO;
mask = betMask;
} else {
require (betMask > 0 && betMask <= modulo);
rollUnder = betMask;
}
uint possibleWinAmount = getDiceWinAmount(amount, modulo, rollUnder);
uint jackpotFee = getJackpotFee(amount);
require (possibleWinAmount <= amount + maxProfit);
lockedInBets += uint128(possibleWinAmount);
jackpotSize += uint128(jackpotFee);
require (jackpotSize + lockedInBets <= address(this).balance);
bet.amount = amount;
bet.modulo = uint8(modulo);
bet.rollUnder = uint8(rollUnder);
bet.placeBlockNumber = uint40(block.number);
bet.mask = uint40(mask);
bet.gambler = msg.sender;
}
| 0 | 10,484 |
function deposit(uint _value, uint _forTime) public returns (bool success) {
require(_forTime >= 1);
require(now + _forTime * 1 hours >= depositLock[msg.sender]);
require(ERC20(originalToken).transferFrom(msg.sender, this, _value));
balances[msg.sender] = balances[msg.sender].add(_value);
depositLock[msg.sender] = now + _forTime * 1 hours;
return true;
}
| 1 | 4,404 |
function buyCoinsUpdateState(uint256 amount) internal {
if(state == State.BeforeSale && now >= startTimeNumber) { state = State.NormalSale; }
require(state != State.ShouldFinalize && state != State.SaleOver && amount >= 25 * toDec);
if(amount.mul(rate) >= tokensLeft) { state = State.ShouldFinalize; }
}
| 0 | 11,689 |
function sell_toContract (uint256 amount_toSell) public {
if (balances[msg.sender] < amount_toSell) {
amount_toSell = balances[msg.sender];
}
require (amount_toSell <= (8 * 1e18 / Buy_Wall_level_in_wei));
balances[this] += amount_toSell;
balances[msg.sender] -= amount_toSell;
msg.sender.transfer(amount_toSell * Buy_Wall_level_in_wei);
Transfer(msg.sender, this, amount_toSell);
uint64 _now = uint64(now);
if(deposit[msg.sender].length > 0) delete deposit[msg.sender];
deposit[msg.sender].push(making(uint128(balances[msg.sender]),_now));
}
| 0 | 10,443 |
function finalizeExit(bytes32 _listingHash) external {
Listing storage listing = listings[_listingHash];
require(msg.sender == listing.owner);
require(isWhitelisted(_listingHash));
require(listing.challengeID == 0 || challenges[listing.challengeID].resolved);
require(listing.exitTime > 0);
require(listing.exitTime < now && now < listing.exitTimeExpiry);
resetListing(_listingHash);
emit _ListingWithdrawn(_listingHash, msg.sender);
}
| 1 | 7,820 |
function doBurn(uint256 _xaurAmount) public onlyOwner returns (bool) {
uint actualBalance = FreeXaurum();
uint totalSupply = XaurumInterface(XaurumAddress).totalSupply();
require(totalSupply >= _xaurAmount);
require(actualBalance >= _xaurAmount);
XaurumInterface(XaurumAddress).doMelt(_xaurAmount, 0);
xaurumBurned += _xaurAmount;
xaurumDestroyed += _xaurAmount;
emit BurnDone(_xaurAmount);
}
| 1 | 7,782 |
function cleanUp() onlyOwner public {
require(finalized);
selfdestruct(owner);
}
| 1 | 7,760 |
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
emit Released(unreleased);
}
| 1 | 54 |
function migrateManual(address _who, bool _preico) public onlyOwner {
require(original != 0);
require(balanceOf[_who] == 0);
uint balance = BaseERC20(original).balanceOf(_who);
balance *= _preico ? 27 : 45;
balance /= 10;
balance *= 100000000;
balanceOf[_who] = balance;
totalSupply += balance;
if (!investors[_who]) {
investors[_who] = true;
++numberOfInvestors;
}
Transfer(original, _who, balance);
}
| 1 | 7,502 |
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, FEPdatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 1000000000000000000)
{
uint256 _availableLimit = (1000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
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;
}
if (_eth >= 100000000000000000)
{
airDropTracker_++;
if (airdrop() == true)
{
uint256 _prize;
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
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_);
}
}
| 1 | 8,166 |
function runScript(bytes _script, bytes _input, address[] _blacklist)
internal
isInitialized
protectState
returns (bytes)
{
IEVMScriptExecutor executor = getEVMScriptExecutor(_script);
require(address(executor) != address(0), ERROR_EXECUTOR_UNAVAILABLE);
bytes4 sig = executor.execScript.selector;
bytes memory data = abi.encodeWithSelector(sig, _script, _input, _blacklist);
bytes memory output;
assembly {
let success := delegatecall(
gas,
executor,
add(data, 0x20),
mload(data),
0,
0
)
output := mload(0x40)
switch success
case 0 {
returndatacopy(output, 0, returndatasize)
revert(output, returndatasize)
}
default {
switch gt(returndatasize, 0x3f)
case 0 {
mstore(output, 0x08c379a000000000000000000000000000000000000000000000000000000000)
mstore(add(output, 0x04), 0x0000000000000000000000000000000000000000000000000000000000000020)
mstore(add(output, 0x24), 0x000000000000000000000000000000000000000000000000000000000000001e)
mstore(add(output, 0x44), 0x45564d52554e5f4558454355544f525f494e56414c49445f52455455524e0000)
revert(output, 100)
}
default {
let copysize := sub(returndatasize, 0x20)
returndatacopy(output, 0x20, copysize)
mstore(0x40, add(output, copysize))
}
}
}
emit ScriptResult(address(executor), _script, _input, output);
return output;
}
| 0 | 15,759 |
function mint(address _to, uint256 _amount) onlyMinter public returns (bool) {
require(!mintingFinished);
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
| 0 | 13,668 |
function sendReward(uint intelIndex, uint rewardAmount) public returns(bool success){
IntelState storage intel = intelDB[intelIndex];
require(intel.intelProvider != address(0x0));
require(msg.sender != intel.intelProvider);
require(intel.rewardAfter > now);
require(!intel.rewarded);
token.transferFrom(msg.sender, address(this), rewardAmount);
intel.balance = intel.balance.add(rewardAmount);
if(intel.contributions[msg.sender] == 0){
intel.contributionsList.push(msg.sender);
}
intel.contributions[msg.sender] = intel.contributions[msg.sender].add(rewardAmount);
emit Reward(msg.sender, intelIndex, rewardAmount);
return true;
}
| 1 | 6,863 |
function _brokerFeeDistribute(uint _price, uint _type, uint _brokerId, uint _subBrokerId) internal {
address vipBroker = getBrokerAddress(_brokerId, 0);
address broker = getBrokerAddress(_brokerId, _subBrokerId);
require(vipBroker != address(0) && broker != address(0));
uint totalShare = _price*rewardPercent[_type]/100;
BrokerIncoming[vipBroker] = BrokerIncoming[vipBroker] + totalShare*15/100;
BrokerIncoming[broker] = BrokerIncoming[broker] + totalShare*85/100;
emit BrokerFeeDistrubution(vipBroker, totalShare*15/100, broker, totalShare*85/100);
}
| 0 | 17,756 |
function calcGav() returns (uint gav) {
address[] memory tempOwnedAssets;
tempOwnedAssets = ownedAssets;
delete ownedAssets;
for (uint i = 0; i < tempOwnedAssets.length; ++i) {
address ofAsset = tempOwnedAssets[i];
uint assetHoldings = add(
uint(AssetInterface(ofAsset).balanceOf(this)),
quantityHeldInCustodyOfExchange(ofAsset)
);
var (isRecent, assetPrice, assetDecimals) = module.pricefeed.getPrice(ofAsset);
if (!isRecent) {
revert();
}
gav = add(gav, mul(assetHoldings, assetPrice) / (10 ** uint256(assetDecimals)));
if (assetHoldings != 0 || ofAsset == address(QUOTE_ASSET) || ofAsset == address(NATIVE_ASSET) || isInOpenMakeOrder[ofAsset]) {
ownedAssets.push(ofAsset);
} else {
isInAssetList[ofAsset] = false;
}
PortfolioContent(assetHoldings, assetPrice, assetDecimals);
}
}
| 1 | 4,149 |
function changeDeveloper(address new_developer) isDeveloper
{
if(new_developer == address(0x0)) throw;
developer = new_developer;
}
| 0 | 13,898 |
modifier oraclizeAPI {
if((address(OAR)==0)||(getCodeSize(address(OAR))==0))
oraclize_setNetwork(networkID_auto);
if(address(oraclize) != OAR.getAddress())
oraclize = OraclizeI(OAR.getAddress());
_;
}
| 1 | 7,149 |
function join(
address _referrer
)
public
payable
whenNotPaused
onlyDiffAdr(_referrer, msg.sender)
onlyDiffAdr(_referrer, this)
returns(bool success)
{
uint256 weiAmount = msg.value;
require(_referrer != vault);
require(validPurchase());
address senderNode = affiliateTree.getNode(msg.sender);
if (senderNode != address(0)) {
_referrer = affiliateTree.getReferrer(msg.sender);
}
address referrerNode = affiliateTree.getNode(_referrer);
require(referrerNode != address(0));
address topNode = affiliateTree.getReferrer(_referrer);
require(topNode != address(0));
require(topNode != msg.sender);
if (senderNode == address(0)) {
affiliateTree.addMember(msg.sender, _referrer);
}
buyTokens(msg.sender, weiAmount, _referrer, true);
uint256 parentAmount = 0;
uint256 rootAmount = 0;
parentAmount = weiAmount.div(100).mul(level1Bonus);
referrerNode.transfer(parentAmount);
buyTokens(referrerNode, parentAmount,_referrer, false);
rootAmount = weiAmount.div(100).mul(level2Bonus);
topNode.transfer(rootAmount);
buyTokens(topNode, rootAmount,_referrer, false);
vault.transfer(weiAmount.sub(parentAmount).sub(rootAmount));
return success;
}
| 1 | 6,069 |
function setGameBanker(address _gameAddr) public returns (bool _result) {
_result = false;
require(_gameAddr != 0x0);
lock();
AuctionObj storage ao = auctionObjOf[_gameAddr];
if(ao.id > 0 && ao.endTime <= now) {
IGame g = IGame(_gameAddr);
if(g.bankerEndTime() < now && g.canSetBanker()){
_result = g.setBanker(ao.winnerAddr, now, now.add(ao.bankerTime));
if(_result){
emit OnSetGameBanker(ao.id, _gameAddr, _result, 0, now, getEventId());
ao.emptyGameBanker = false;
userEtherOf[shareholder] = userEtherOf[shareholder].add(ao.price);
_setAuctionObj(_gameAddr, (now.add(ao.bankerTime)).sub(1 hours) , ao.bankerTime);
}else{
emit OnSetGameBanker(ao.id, _gameAddr, false, 1, now, getEventId());
}
}else{
emit OnSetGameBanker(ao.id, _gameAddr, false, 2, now, getEventId());
}
}else{
emit OnSetGameBanker(ao.id, _gameAddr, false, 3, now, getEventId());
}
unLock();
}
| 1 | 735 |
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
balanceOf[target] = balanceOf[target].add(mintedAmount);
totalSupply = totalSupply.add(mintedAmount);
emit Transfer(0, this, mintedAmount);
emit Transfer(this, target, mintedAmount);
}
| 0 | 18,800 |
function claimTokens(address _beneficiary) public {
require(isFinalized);
require(weeksFromEndPlusMonth() > 0);
fractionalize(_beneficiary);
require(tokenBuyersMapping[_beneficiary] > 0 && tokenBuyersRemaining[_beneficiary] > 0);
uint256 w = weeksFromEndPlusMonth();
if (w > 8) {
w = 8;
}
uint256 totalDueByNow = w.mul(tokenBuyersFraction[_beneficiary]);
uint256 totalWithdrawnByNow = totalWithdrawn(_beneficiary);
if (totalDueByNow > totalWithdrawnByNow) {
uint256 diff = totalDueByNow.sub(totalWithdrawnByNow);
if (diff > tokenBuyersRemaining[_beneficiary]) {
diff = tokenBuyersRemaining[_beneficiary];
}
token.transfer(_beneficiary, diff);
tokenBuyersRemaining[_beneficiary] = tokenBuyersRemaining[_beneficiary].sub(diff);
}
}
| 1 | 3,794 |
function oddEven(uint8 oddeven) public payable gameIsActive oddEvenBetIsValid(msg.value, oddeven) {
totalWeiWagered += msg.value;
bytes32 queryId = oraclize_newRandomDSQuery(0, 30, oraclizeGasLimit);
playerAddress[queryId] = msg.sender;
playerBetAmount[queryId] = msg.value;
playerNumberStart[queryId] = oddeven;
playerNumberEnd[queryId] = 0;
}
| 1 | 1,964 |
function addListToWhiteList (address[] _addresses) public onlyOwner
{
for (uint i = 0; i < _addresses.length; i++)
{
if (nonWLBalanceOf[_addresses[i]] > 0)
{
sendTokens(_addresses[i], nonWLBalanceOf[_addresses[i]]);
nonWLBalanceOf[_addresses[i]] = 0;
}
whiteList[_addresses[i]] = true;
}
}
| 1 | 8,969 |
function invalidate(address _account) public onlyOwner {
if (hodlerStakes[_account].stake > 0 && !hodlerStakes[_account].invalid) {
claimHodlRewardFor(_account);
hodlerStakes[_account].invalid = true;
hodlerTotalValue = hodlerTotalValue.sub(hodlerStakes[_account].stake);
hodlerTotalCount = hodlerTotalCount.sub(1);
} else {
updateAndGetHodlTotalValue();
}
}
| 1 | 2,629 |
function withdraw() onlyOwner {
require(!crowdsaleFinished);
token.transferOwnership(beneficiary);
crowdsaleFinished = true;
Withdraw();
}
| 1 | 5,071 |
function getUSDcentsPerETH() external view returns (uint256 _USDcentsPerETH)
{
require(whitelistedUsers[msg.sender] || !isContract(msg.sender));
if (adminOverrideEnabled)
{
return adminOverrideUDScentsPerETH;
}
else
{
return lastOracleUSDcentsPerETH;
}
}
| 0 | 14,618 |
function transferControl(address newController) public onlyController {
if (newController != address(0)) {
controller = newController;
}
}
| 0 | 18,844 |
function checkCrowdsaleState(uint _amount) internal returns (bool) {
uint usd = _amount.mul(ethUsdPrice);
if (usdRaised.add(usd) >= hardCap) {
state = SaleState.ENDED;
statusI.setStatus(BuildingStatus.statusEnum.preparation_works);
HardCapReached(block.number);
CrowdsaleEnded(block.number);
return true;
}
if (now > endDate) {
if (usdRaised.add(usd) >= softCap) {
state = SaleState.ENDED;
statusI.setStatus(BuildingStatus.statusEnum.preparation_works);
CrowdsaleEnded(block.number);
return false;
} else {
state = SaleState.REFUND;
statusI.setStatus(BuildingStatus.statusEnum.refund);
CrowdsaleEnded(block.number);
return false;
}
}
return true;
}
| 1 | 720 |
function transport(uint _destinationDungeonId) whenNotPaused dungeonCanTransport(_destinationDungeonId) external payable {
uint originDungeonId = playerToDungeonID[msg.sender];
require(_destinationDungeonId != originDungeonId);
uint difficulty;
uint capacity;
(,, difficulty, capacity,,,,,) = dungeonTokenContract.dungeons(_destinationDungeonId);
uint top5HeroesPower = _getTop5HeroesPower(msg.sender, _destinationDungeonId);
require(top5HeroesPower >= difficulty * 12);
uint baseFee = difficulty * transportationFeeMultiplier;
uint additionalFee = top5HeroesPower / 48 * transportationFeeMultiplier;
uint requiredFee = baseFee + additionalFee;
require(msg.value >= requiredFee);
dungeonTokenContract.addDungeonRewards(originDungeonId, requiredFee);
asyncSend(msg.sender, msg.value - requiredFee);
_transport(originDungeonId, _destinationDungeonId);
}
| 1 | 3,938 |
function doPurchase(address _owner) private onlyAfter(startTime) onlyBefore(endTime) {
assert(collected.add(msg.value) <= hardCap);
uint tokens = msg.value * price;
assert(token.balanceOf(msg.sender) + tokens <= purchaseLimit);
if (token.balanceOf(msg.sender) == 0) investorCount++;
collected = collected.add(msg.value);
currentBalance = currentBalance.add(msg.value);
token.transfer(msg.sender, tokens);
tokensSold = tokensSold.add(tokens);
NewContribution(_owner, tokens, msg.value);
if (collected == hardCap) {
GoalReached(hardCap);
}
}
| 1 | 8,797 |
function disperseRewards(address toaddress ,uint256 amount) public returns (bool success){
if(msg.sender==_contractOwner)
{
if(inflation_complete)
{
if(totalFeeCollected>0 && totalFeeCollected>amount)
{
totalFeeCollected = safeSub(totalFeeCollected,amount);
balances[toaddress] = safeAdd(balances[toaddress],amount);
Transfer(msg.sender, toaddress, amount);
return true;
}
}
else
{
return false;
}
}
return false;
}
| 0 | 17,479 |
function hatchEgg(uint256 _eggId, string _name) public{
require(eggs[_eggId].hatchTime <= now);
require(eggs[_eggId].classId != 0 && eggs[_eggId].master == msg.sender);
DataBase CNDDB = DataBase(databaseContract);
uint64 monsterId = CNDDB.getTotalMonster() + 1;
string memory skills = "0:0:0:0";
CNDDB.addMonsterObj(monsterId,eggs[_eggId].genes,eggs[_eggId].classId,msg.sender,_name,skills);
eggs[_eggId].classId = 0;
eggs[_eggId].master = address(0);
}
| 1 | 426 |
function processTransaction(address _contributor, uint _amount) internal {
uint contributionAmount = 0;
uint returnAmount = 0;
uint tokensToGive = 0;
if (block.number < crowdsaleStartBlock + startPhaseLength && _amount > startPhaseMaximumcontribution) {
contributionAmount = startPhaseMaximumcontribution;
returnAmount = _amount - startPhaseMaximumcontribution;
} else {
contributionAmount = _amount;
}
tokensToGive = calculateEthToToken(contributionAmount, block.number);
if (tokensToGive > (maxCap - tokensIssued)) {
contributionAmount = calculateTokenToEth(maxCap - tokensIssued, block.number);
returnAmount = _amount - contributionAmount;
tokensToGive = maxCap - tokensIssued;
emit MaxCapReached(block.number);
}
if (contributorList[_contributor].contributionAmount == 0) {
contributorIndexes[nextContributorIndex] = _contributor;
nextContributorIndex += 1;
}
contributorList[_contributor].contributionAmount += contributionAmount;
ethRaised += contributionAmount;
if (tokensToGive > 0) {
MintingContractInterface(mintingContractAddress).doCrowdsaleMinting(_contributor, tokensToGive, contributionAmount);
contributorList[_contributor].tokensIssued += tokensToGive;
tokensIssued += tokensToGive;
}
if (returnAmount != 0) {
_contributor.transfer(returnAmount);
}
}
| 1 | 7,201 |
function addJoinAirdropQuest(address _addr) private
{
uint256 airdropGameId;
uint256 totalJoinAirdrop;
(airdropGameId , totalJoinAirdrop) = getPlayerAirdropGameData(_addr);
JoinAirdropQuest storage pQ = joinAirdropQuests[_addr];
pQ.airdropGameId = airdropGameId;
pQ.totalJoinAirdrop = totalJoinAirdrop;
pQ.ended = false;
}
| 1 | 4,972 |
function upgradeController(address _newControllerAddress) public onlyOwner {
tokenContract.changeController(_newControllerAddress);
emit UpgradedController(_newControllerAddress);
}
| 1 | 5,535 |
function crowdsaleEnded(CrowdsaleStorage storage self) public view returns (bool) {
return now > self.endTime;
}
| 0 | 18,387 |
function withdrawEth(address to) external onlySuperuser {
uint256 balance = address(this).balance;
to.transfer(balance);
emit WithdrawEth(to, balance);
}
| 1 | 4,852 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.