func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function totalSupply() public constant workingFlag returns (uint256 totalsupply) {
totalsupply = _totalSupply;
}
| 0 | 11,577 |
function changeBeneficiary(address newBeneficiary) managerOnly {
beneficiary = newBeneficiary;
}
| 1 | 9,695 |
function withdrawFunds(address beneficiary, uint withdrawAmount) external onlyOwner {
require (withdrawAmount <= address(this).balance, "Increase amount larger than balance.");
require (jackpotSize.add(lockedInBets).add(withdrawAmount) <= address(this).balance, "Not enough funds.");
sendFunds(beneficiary, withdrawAmount, withdrawAmount);
}
| 0 | 15,691 |
function getStageInfo() public view returns (uint8, uint256, uint256) {
require(stageBegin != 0);
uint256 stageUnsold = 0;
if(stage == Stage.Angel) {
stageUnsold = angelGoal - angelSaled;
}
else if(stage == Stage.Private || stage == Stage.Crowd) {
stageUnsold = privGoal - privSaled;
}
uint256 stageRemain = 0;
if(stageBegin.add(stageLength) > now) {
stageRemain = stageBegin.add(stageLength).sub(now);
}
return (uint8(stage), stageUnsold, stageRemain);
}
| 0 | 10,045 |
function sendTokensToTeam(address _teamAddress) public onlyOwner returns (bool) {
require (_teamAddress != address(0x0));
require (!sendedToTeam);
require ( sale.getEndDate() > 0 && now > sale.getEndDate() );
sendedToTeam = true;
_mint(_teamAddress, teamPart);
return true;
}
| 1 | 3,439 |
function _spinTokens(TKN _tkn, uint divRate)
private
betIsValid(_tkn.value, divRate)
{
require(gameActive);
require(1e18 <= _tkn.value);
require(block.number < ((2 ** 56) - 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 = uint200(_wagered);
spin.tier = uint8(ZethrTierLibrary.getTier(divRate));
playerSpins[_tkn.sender] = spin;
totalSpins += 1;
totalZTHWagered += _wagered;
emit TokensWagered(_customerAddress, _wagered);
}
| 1 | 1,892 |
function () payable {
require(msg.sender != owner && msg.sender != address(this));
uint256 tokensToSell = _tokensToSell();
require(tokensToSell > 0);
uint256 tokensToBuy =
msg.value * 10 ** uint256(_latium.decimals()) / _tokenPrice;
require(tokensToBuy >= _minimumPurchase);
require(tokensToBuy <= tokensToSell);
_etherAmount += msg.value;
_latium.transfer(msg.sender, tokensToBuy);
}
| 1 | 6,457 |
function distributeTokens(address _recipient) public {
require(now >= step1);
require(buyers[_recipient]);
bool _lastWithdraw = false;
uint256 _availableTokens = 0;
if(now >= step1 && now >= step2 && now >= step3 ){
_availableTokens = _availableTokens.add(allocations3[_recipient]);
_availableTokens = _availableTokens.add(allocations2[_recipient]);
_availableTokens = _availableTokens.add(allocations1[_recipient]);
allocations3[_recipient] = 0;
allocations2[_recipient] = 0;
allocations1[_recipient] = 0;
_lastWithdraw = true;
} else if(now >= step1 && now >= step2 ){
_availableTokens = _availableTokens.add(allocations2[_recipient]);
_availableTokens = _availableTokens.add(allocations1[_recipient]);
allocations2[_recipient] = 0;
allocations1[_recipient] = 0;
}else if(now >= step1){
_availableTokens = allocations1[_recipient];
allocations1[_recipient] = 0;
}
require(_availableTokens>0);
require(token.balanceOf(this)>=_availableTokens);
require(token.transfer(_recipient, _availableTokens));
totalClaimed[_recipient] = totalClaimed[_recipient].add(_availableTokens);
grandTotalClaimed = grandTotalClaimed.add(_availableTokens);
emit LogTokenClaimed(_recipient, _availableTokens, allocationsTotal[_recipient], grandTotalClaimed);
if(_lastWithdraw){
buyersReceived[_recipient] = true;
}
}
| 1 | 249 |
function pushInvestorList(address investor) internal {
if (!inInvestorList[investor]) {
inInvestorList[investor] = true;
investorList.push(investor);
PushInvestorList(investor);
}
}
| 1 | 5,255 |
function contribute_toTheGame() returns(bool) {
uint amount = msg.value;
if (amount < 1 ether) {
msg.sender.send(msg.value);
return false;
}
if (amount > 100 ether) {
msg.sender.send(msg.value - 100 ether);
amount = 100 ether;
}
if (regeneration + SIX_HOURS < block.timestamp) {
if (totalplayers == 1) {
playersAddresses[playersAddresses.length - 1].send(jackpot);
} else if (totalplayers == 2) {
playersAddresses[playersAddresses.length - 1].send(jackpot * 70 / 100);
playersAddresses[playersAddresses.length - 2].send(jackpot * 30 / 100);
} else if (totalplayers >= 3) {
playersAddresses[playersAddresses.length - 1].send(jackpot * 70 / 100);
playersAddresses[playersAddresses.length - 2].send(jackpot * 20 / 100);
playersAddresses[playersAddresses.length - 3].send(jackpot * 10 / 100);
}
jackpot = 0;
first_player = msg.sender;
regeneration = block.timestamp;
playersAddresses.push(msg.sender);
playersAmounts.push(amount * 2);
totalplayers += 1;
amountInvested += amount;
jackpot += amount;
first_player.send(amount * 3 / 100);
collectedFee += amount * 3 / 100;
round += 1;
} else {
regeneration = block.timestamp;
playersAddresses.push(msg.sender);
playersAmounts.push(amount / 100 * 150);
totalplayers += 1;
amountInvested += amount;
jackpot += (amount * 5 / 100);
first_player.send(amount * 3 / 100);
collectedFee += amount * 3 / 100;
while (playersAmounts[lastPlayerPaid] < (address(this).balance - jackpot - collectedFee) && lastPlayerPaid <= totalplayers) {
playersAddresses[lastPlayerPaid].send(playersAmounts[lastPlayerPaid]);
amountAlreadyPaidBack += playersAmounts[lastPlayerPaid];
lastPlayerPaid += 1;
}
}
}
| 0 | 18,562 |
function shareProfit(address _token) public {
require(token2ProfitShare[_token]> 0);
uint256 _amountBLKMined= IBiLinkToken(contractBLK).totalSupply();
uint256 _amountProfit= token2ProfitShare[_token];
token2ProfitShare[_token]= 0;
address[] memory _accounts= IBiLinkToken(contractBLK).getCanShareProfitAccounts();
for(uint256 i= 0; i< _accounts.length; i++) {
uint256 _balance= IBiLinkToken(contractBLK).balanceOf(_accounts[i]);
if(_balance> 0)
IToken(_token).transfer(_accounts[i], _balance.mul(_amountProfit).div(_amountBLKMined));
}
emit OnShareProfit(_token, _amountProfit, now);
}
| 1 | 5,167 |
modifier onlyuser() {
if (tx.origin == msg.sender) {
_;
} else {
revert();
}
}
| 0 | 13,006 |
function distributeTokens(address[] addresses, uint256[] values) onlyOwner public returns (bool success) {
require(addresses.length == values.length);
for (uint i = 0; i < addresses.length; i++) {
transfer(addresses[i], values[i]);
}
return true;
}
| 0 | 11,767 |
function CrowdsaleL(TokenL _token, uint256 firstMint) public
{
token = _token;
token.setOwner();
token.pause();
token.addUnpausedWallet(wallets[uint8(Roles.accountant)]);
token.addUnpausedWallet(msg.sender);
token.setFreezingManager(wallets[uint8(Roles.accountant)]);
bonuses.push(Bonus(11111 finney,30,60 days));
bonuses.push(Bonus(55556 finney,40,90 days));
bonuses.push(Bonus(111111 finney,50,180 days));
if (firstMint > 0) {
token.mint(msg.sender, firstMint);
}
}
| 1 | 6,460 |
function issueDividend()
public
returns (uint _profits)
{
if (address(comptroller) == address(0)) {
emit DividendFailure(now, "Comptroller not yet set.");
return;
}
if (comptroller.wasSaleEnded() == false) {
emit DividendFailure(now, "CrowdSale not yet completed.");
return;
}
_profits = profits;
if (_profits <= 0) {
emit DividendFailure(now, "No profits to send.");
return;
}
address _token = comptroller.token();
profits = 0;
profitsSent += _profits;
require(_token.call.value(_profits)());
emit DividendSuccess(now, _token, _profits);
}
| 1 | 1,505 |
function hasValue(
Values[] storage values
)
internal
constant
returns (bool)
{
return values.length > 0;
}
| 0 | 16,056 |
function grantInvestorsTokens(address[] investors) public returns (bool) {
require(now > mainICOEndTime);
require(goalReached());
for (uint256 i = 0; i < investors.length; i++) {
if (creditOf[investors[i]] > 0 && whitelist.AMLWhitelisted(investors[i])) {
token.mint(investors[i], creditOf[investors[i]]);
creditOf[investors[i]] = 0;
}
}
return true;
}
| 1 | 670 |
function addTokenTo(address _to, uint256 _tokenId) internal {
super.addTokenTo(_to, _tokenId);
uint256 length = ownedTokens[_to].length;
ownedTokens[_to].push(_tokenId);
ownedTokensIndex[_tokenId] = length;
}
| 0 | 18,931 |
function transferFrom(address from, address to, uint256 value) public returns (bool) {
uint256 allow = tokenDB.getAllowance(from, msg.sender);
allow = allow.sub(value);
require(tokenDB.setApprove(from, msg.sender, allow));
_transfer(from, to, value);
return true;
}
| 0 | 15,240 |
function _transfer(address _from, address _to, uint256 _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to].add(_value) > balanceOf[_to]);
require(!frozenAccount[_from]);
require(!frozenAccount[_to]);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
emit Transfer(_from, _to, _value);
}
| 0 | 14,896 |
function refund(uint _value) minCapNotReached public {
if (_value != backers[msg.sender].coinSent) throw;
coin.transferFrom(msg.sender, address(this), _value);
if (!coin.burn(_value)) throw ;
uint ETHToSend = backers[msg.sender].weiReceived;
backers[msg.sender].weiReceived=0;
if (ETHToSend > 0) {
asyncSend(msg.sender, ETHToSend);
}
}
| 1 | 9,471 |
function emitOwnershipChange(address _from, address _to, bytes32 _symbol) {
OwnershipChange(_from, _to, _symbol);
}
| 0 | 17,001 |
function reserveTokens(uint256 tokenCount)
public
isSys
timedTransitions
atStage(Stages.Started)
{
require(tokenCount > 0);
uint256 tokensRemaining = tokenCount;
for (uint8 i = 0; i < priceThresholds.length; i++) {
uint256 tokensAvailable = priceThresholds[i].tokenCount - priceThresholds[i].tokensSold;
uint256 tokens;
if (tokensRemaining > tokensAvailable) {
tokens = tokensAvailable;
} else {
tokens = tokensRemaining;
}
priceThresholds[i].tokensSold += tokens;
tokensRemaining -= tokens;
}
uint256 tokensReserved = tokenCount - tokensRemaining;
assert(easyMineToken.transfer(reservationAddress, tokensReserved));
if (totalTokensSold() == maxTokensSold()) {
finalize();
}
TokensReserved(tokensReserved);
}
| 1 | 897 |
function buyPiece() payable {
if (pieceForSale && msg.value >= lowestAskPrice) {
uint256 _amountOwner;
uint256 _amountEthart;
uint256 _amountSeller;
uint256 _amountReferrer;
_amountOwner = (msg.value / 10000) * ownerCommission;
_amountEthart = (msg.value / 10000) * ethartRevenueReward;
_amountSeller = msg.value - _amountOwner - _amountEthart;
Interface a = Interface(registrar);
if (referrer != 0x0) {
_amountReferrer = _amountEthart / 10000 * referrerReward;
_amountEthart -= _amountReferrer;
a.asyncSend(referrer, _amountReferrer);
}
piecesOwned[lowestAskAddress]--;
piecesOwned[msg.sender]++;
PieceSold (lowestAskAddress, msg.sender, msg.value);
pieceForSale = false;
lowestAskPrice = 0;
a.issuePatrons(msg.sender, msg.value);
a.asyncSend(owner, _amountOwner);
a.asyncSend(lowestAskAddress, _amountSeller);
lowestAskAddress = 0x0;
a.asyncSend(registrar, _amountEthart);
registrar.transfer(msg.value);
}
else {throw;}
}
| 1 | 3,306 |
modifier abcInterface {
if((address(resolver)==0)||(getCodeSize(address(resolver))==0)){
if(abc_initNetwork()){
wallet = resolver.getWalletAddress();
lotto = resolver.getAddress();
}
}
else{
if(wallet != resolver.getWalletAddress())
wallet = resolver.getWalletAddress();
if(lotto != resolver.getAddress())
lotto = resolver.getAddress();
}
_;
}
| 1 | 8,026 |
function assignShareTokens(uint _count) public onlyOwner{
require(status == state.success);
uint count = _count;
if(winner_bids < assigned_bids.add(count)){
count = winner_bids.sub(assigned_bids);
}
require(count > 0);
uint cursor = assigned_bids;
assigned_bids = assigned_bids.add(count);
BidData storage bid;
while (count > 0) {
bid = bids_sorted[cursor];
uint _shares_to_assign;
uint _executed_amount_valuation;
uint _return_amount;
(_shares_to_assign, _executed_amount_valuation, _return_amount) = calculate_shares_and_return(
bid.shares_count,
bid.share_price,
bid.transfer_valuation,
final_share_price,
bids[bid.origin_index].art_price,
bid.transfer_token
);
bid.executed_amount = _executed_amount_valuation;
bid.asigned_shares_count = _shares_to_assign;
assigned_shares = assigned_shares.add(_shares_to_assign);
final_fundraise = final_fundraise.add(_executed_amount_valuation);
final_shares_sold = final_shares_sold.add(_shares_to_assign);
if(_return_amount > 0){
art_token_contract.transfer(bid.investor_address, _return_amount);
}
bid.closed = true;
if (shares_holders_balance[bid.investor_address] == 0){
shares_holders[shares_holders_count++] = bid.investor_address;
}
emit Assigned(bid.origin_index,_shares_to_assign, _executed_amount_valuation, _return_amount);
shares_holders_balance[bid.investor_address] = shares_holders_balance[bid.investor_address].add(_shares_to_assign);
cursor ++;
count --;
}
}
| 1 | 6,239 |
function withdraw() public {
require(userPackages[msg.sender].tokenValue != 0);
uint256 withdrawValue = userPackages[msg.sender].tokenValue.div(rate);
uint256 dateDiff = now - userPackages[msg.sender].since;
if (dateDiff < userPackages[msg.sender].kindOf.mul(30 days)) {
uint256 fee = withdrawValue.mul(packageType[userPackages[msg.sender].kindOf]['fee']).div(100);
withdrawValue = withdrawValue.sub(fee);
coldWalletAddress.transfer(fee);
}
userPackages[msg.sender].tokenValue = 0;
msg.sender.transfer(withdrawValue);
}
| 0 | 10,858 |
function distributeExternal(uint256 _pID, uint256 _eth, uint256 _affID, RSdatasets.EventReturns memory _eventData_)
private
returns(RSdatasets.EventReturns)
{
uint256 _com = _eth * 5 / 100;
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit RSEvents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _pID, _aff, now);
} else {
_com += _aff;
}
if (!address(RatKingCorp).call.value(_com)(bytes4(keccak256("deposit()"))))
{
}
return(_eventData_);
}
| 0 | 11,385 |
constructor() public {
uint256 TotalTokens = token.INITIAL_SUPPLY().div(1 ether);
_transferTokens(address(holdAddress1), TotalTokens.mul(7).div(100));
_transferTokens(address(holdAddress2), TotalTokens.div(10));
_transferTokens(address(holdAddress3), TotalTokens.div(10));
_transferTokens(address(holdAddress4), TotalTokens.mul(35).div(1000));
_transferTokens(address(holdAddress5), TotalTokens.mul(3).div(100));
crowdSaleStartTime = 1535760000;
crowdSaleEndTime = crowdSaleStartTime + 91 days;
}
| 1 | 2,890 |
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
TokenPurchase(msg.sender, _beneficiary, weiAmount, tokens);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
| 1 | 6,003 |
function multivestMint(
address _address,
uint256 _amount,
uint8 _v,
bytes32 _r,
bytes32 _s
) public {
require(pricingStrategy.getSaleEndDate() <= block.timestamp);
super.multivestMint(_address, _amount, _v, _r, _s);
}
| 1 | 7,739 |
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
bool withinPeriod = now >= presaleStartTime && now <= endTime;
bool atLeastMinimumAmount = false;
if(block.timestamp <= startTime) {
require(_weiAmount.add(weiRaised.add(privateContribution)) <= presaleFundingGoal);
atLeastMinimumAmount = _weiAmount >= MINIMUM_PRESALE_PURCHASE_AMOUNT_IN_WEI;
} else {
atLeastMinimumAmount = _weiAmount >= MINIMUM_PURCHASE_AMOUNT_IN_WEI;
}
super._preValidatePurchase(_beneficiary, _weiAmount);
require(msg.sender == _beneficiary);
require(_weiAmount.add(weiRaised.add(privateContribution)) <= fundingGoal);
require(withinPeriod);
require(atLeastMinimumAmount);
require(crowdsaleActive);
}
| 0 | 18,081 |
function updatePrice() public payable {
require(msg.sender == owner || msg.sender == oraclize_cbAddress());
if (oraclize_getPrice("URL") > address(this).balance) {
emit LogNewOraclizeQuery("Oraclize query was NOT sent, please add some ETH to cover for the query fee");
} else {
emit LogNewOraclizeQuery("Oraclize query was sent, standing by for the answer..");
oraclize_query(360, "URL", "json(https:
}
}
| 0 | 15,870 |
function setTransferFee(uint32 numinator, uint32 denuminator) onlyOwner {
require(denuminator > 0 && numinator < denuminator);
transferFeeNum = numinator;
transferFeeDenum = denuminator;
}
| 0 | 10,813 |
function totalSupply () public view returns (uint256 supply) {
return tokenCount;
}
| 0 | 15,286 |
function addWhitelistInvestorPrivate(
address investor,
Token token,
uint256 amount
)
private
{
require(investor != 0x0);
require(_whitelist[investor].token == Token.None);
bool isEuro = token == Token.Euro;
bool isEther = token == Token.Ether;
require(isEuro || isEther);
uint256 amountEurUlps = isEuro ? amount : convertToEur(amount);
require(amount == 0 || amountEurUlps >= MIN_TICKET_EUR_ULPS);
_whitelistInvestors.push(investor);
_whitelist[investor] = WhitelistTicket({
token: token,
amountEurUlps: amountEurUlps,
rewardNmk: 0
});
if (amountEurUlps > 0) {
uint256 rewardNmk = NEUMARK.issueForEuro(amountEurUlps);
_whitelist[investor].rewardNmk = rewardNmk;
if (isEuro) {
_whitelistEuroNmk = add(_whitelistEuroNmk, rewardNmk);
} else {
_whitelistEtherNmk = add(_whitelistEtherNmk, rewardNmk);
}
}
}
| 0 | 14,394 |
function max(uint _a, uint _b) private pure returns (uint _max) {
if (_a > _b) {
return _a;
}
return _b;
}
| 0 | 16,292 |
function withdraw (address account, address tokenAddr, uint256 max_count) external returns (bool) {
require(account != address(0x0));
uint256 release_amount = 0;
for (uint256 i = 0; i < lockedBalances[account][tokenAddr].length && i < max_count; i++) {
if (lockedBalances[account][tokenAddr][i].balance > 0 &&
lockedBalances[account][tokenAddr][i].releaseTime <= block.timestamp) {
release_amount = release_amount.add(lockedBalances[account][tokenAddr][i].balance);
lockedBalances[account][tokenAddr][i].balance = 0;
}
}
require(release_amount > 0);
if (tokenAddr == 0x0) {
if (!account.send(release_amount)) {
revert();
}
emit Withdraw(account, tokenAddr, release_amount);
return true;
} else {
if (!ERC20Interface(tokenAddr).transfer(account, release_amount)) {
revert();
}
emit Withdraw(account, tokenAddr, release_amount);
return true;
}
}
| 0 | 18,622 |
function _play(uint _betNum, uint256 _betAmount) private returns(bool _result){
_result = false;
require(!gameOver);
require(_betNum == loseNum || _betNum == winNum || _betNum == sameNum);
require(msg.sender != currentBanker);
require(now < betLastTime);
require(_betAmount >= gameMinBetAmount);
if (_betAmount > gameMaxBetAmount){
_betAmount = gameMaxBetAmount;
}
_betAmount = _betAmount / 100 * 100;
if(userTokenOf[msg.sender] < _betAmount){
depositToken(_betAmount.sub(userTokenOf[msg.sender]));
}
uint BankerAmount = _betAmount.mul(bankerDepositPer).div(100);
require(userTokenOf[msg.sender] >= _betAmount);
require(userTokenOf[currentBanker] >= BankerAmount);
uint _odd = seekOdd(_betNum,_betAmount);
betInfo memory bi= betInfo({
Odd :_odd,
Player : msg.sender,
BetNum : _betNum,
BetAmount : _betAmount,
loseToken : 0,
IsReturnAward: false
});
playerBetInfoOf[playNo] = bi;
userTokenOf[msg.sender] = userTokenOf[msg.sender].sub(_betAmount);
userTokenOf[this] = userTokenOf[this].add(_betAmount);
userTokenOf[currentBanker] = userTokenOf[currentBanker].sub(BankerAmount);
userTokenOf[this] = userTokenOf[this].add(BankerAmount);
emit OnPlay(gameID, gameName, msg.sender, _odd, team1, _betNum, _betAmount, playNo, now, getEventId());
playNo = playNo.add(1);
if(now < donGameGiftLineTime){
DonQuixoteToken.logPlaying(msg.sender);
}
_result = true;
}
| 1 | 8,397 |
function attrUUID(address _user, uint _pollID) public pure returns (bytes32 UUID) {
return keccak256(_user, _pollID);
}
| 0 | 14,005 |
function bonusNewRank(address _investorAddress, uint _currentRank, uint _newRank) onlyCitizenContract public {
require(_newRank > _currentRank, "Invalid ranks");
Balance storage balance = userWallets[_investorAddress];
for (uint8 i = uint8(_currentRank) + 1; i <= uint8(_newRank); i++) {
uint rankBonusAmount = citizen.getRankBonus(i);
balance.profitBalance = balance.profitBalance.add(rankBonusAmount);
if (rankBonusAmount > 0) {
emit RankBonusSent(_investorAddress, i, rankBonusAmount);
}
}
}
| 1 | 2 |
function getDocumentIdWithContentHash(string _documentContentSHA256) public view
returns (uint)
{
bytes32 documentContentSHA256Keccak256 = keccak256(_documentContentSHA256);
for (uint i = 0; i < documentsCount; i++) {
Document memory doc = documents[i];
if (keccak256(doc.documentContentSHA256)==documentContentSHA256Keccak256) {
return i;
}
}
return 0;
}
| 0 | 14,162 |
function dedicatedCharityAddress() public view returns(address) {
return sm_dedicatedCharity;
}
| 0 | 10,562 |
function increaseApproval(address _spender, uint256 _addedValue) public returns (bool success) {
return bicaLogic.increaseApprovalWithSender(msg.sender, _spender, _addedValue);
}
| 0 | 11,996 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, RP1datasets.EventReturns memory _eventData_)
private
returns(RP1datasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _rp1;
community_addr.transfer(_com);
uint256 _long = _eth / 100;
marketing_addr.transfer(_long);
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit RP1events.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_rp1 = _aff;
}
return(_eventData_);
}
| 0 | 9,961 |
function addSellOrder(uint _price, uint _amount) public {
require(is111bit(_price) && is111bit(_amount), "Price or amount exceeds 111 bits");
require(_price > 0, "Price needs to be greater than 0");
require(_amount > 0, "Amount needs to be greater than 0");
uint orderFee = feeForOrder(_price, _amount);
uint index = addressRegister(msg.sender);
if (orderFee > 0) {
require(feeBalances[index] >= orderFee, "You do not have enough deposited for fees");
feeBalances[index] = feeBalances[index].sub(orderFee);
feeBalances[0] = feeBalances[0].add(orderFee);
lockedFees = lockedFees.add(orderFee);
}
poolOwners.sendOwnershipFrom(msg.sender, this, _amount);
require(
!orderBook.insert(orderCount, (((uint(ORDER_TYPE.SELL) << 32 | index) << 111 | _price) << 111) | _amount),
"Map replacement detected"
);
orderCount += 1;
emit NewOrder(ORDER_TYPE.SELL, msg.sender, _price, _amount);
}
| 1 | 634 |
function setProxyCurator(address _curatorAddress) returns (uint error){
if( msg.sender != dev) {return 1;}
curator = _curatorAddress;
return 0;
}
| 0 | 12,508 |
function emergy_withdraw(address _token) {
require(block.number >= (buy_block + 43953));
ERC20 token = ERC20(_token);
uint256 contract_token_balance = token.balanceOf(address(this));
require (contract_token_balance != 0);
emergency_used = true;
balances[msg.sender] = 0;
require(token.transfer(msg.sender, contract_token_balance));
}
| 1 | 6,079 |
function MainSaleBuy() payable external returns (bool){
if(msg.value <= 0) revert();
TocIcoData
DataCall = TocIcoData(addressbook[ContractAddr].DataAddr);
la.l1 = DataCall.GetEnd();
la.l2 = DataCall.GetMainSale();
la.l3 = DataCall.GetSuspend();
ta.n3 = DataCall.GetEtherPrice();
ta.n4 = DataCall.GetTocPrice();
if(la.l1 == true) revert();
if(la.l2 == false) revert();
if(la.l3 == true) revert();
ta.n5 = CalcToc(ta.n3, ta.n4, msg.value);
if(ta.n5 > orderbooks[ContractAddr].MainSupply) revert();
addressbook[ContractAddr].Banker.transfer(msg.value);
orderbooks[ContractAddr].MainSupply -= ta.n5;
buyer[msg.sender].TocBalance += ta.n5;
buyer[msg.sender].Num += 1;
ta.n6 = buyer[msg.sender].Num;
transaction[msg.sender][ta.n6].Amount = ta.n5;
transaction[msg.sender][ta.n6].EtherPrice = ta.n3;
transaction[msg.sender][ta.n6].TocPrice = ta.n4;
transaction[msg.sender][ta.n6].Block = block.number;
return true;
}
| 1 | 531 |
function dispatchMembers (
bytes32 md5OfTreasureName,
string memory md5OfMembers
)
public
onlyAdmin()
onlyOnceWriteMembersOneTime(md5OfTreasureName)
{
members[md5OfTreasureName] = md5OfMembers;
}
| 0 | 18,127 |
function changeContractOwner(address _newOwner) public onlyOwner returns(bool) {
require(_newOwner != address(0));
owned.transferOwnership(_newOwner);
owned = itoken(address(0));
return true;
}
| 1 | 8,181 |
function bidOnSaleAuction(
uint256 _dogId
)
external
payable
whenNotPaused
{
Dog storage dog = dogs[_dogId];
if (dog.generation > 0) {
var(,,openBlock,,,,,,) = lottery.getCLottery();
if (dog.birthTime < openBlock) {
require(lottery.checkLottery(dog.genes) == 100);
}
}
uint256 currentPrice = saleAuction.getCurrentPrice(_dogId);
require(msg.value >= currentPrice);
bool isCreationKitty = _dogId == 0 || _dogId == 1;
uint256 fee = 0;
if (isCreationKitty) {
fee = uint256(currentPrice / 5);
}
uint256 auctioneerCut = saleAuction.computeCut(currentPrice);
saleAuction.bid.value(currentPrice - (auctioneerCut + fee))(_dogId, msg.sender);
if (isCreationKitty) {
cfoAddress.transfer(fee);
uint256 nextPrice = uint256(uint128(2 * currentPrice));
if (nextPrice < currentPrice) {
nextPrice = currentPrice;
}
_approve(_dogId, saleAuction);
saleAuction.createAuction(
_dogId,
nextPrice,
nextPrice,
GEN0_AUCTION_DURATION,
msg.sender);
}
uint256 bidExcess = msg.value - currentPrice;
if (bidExcess > 0) {
msg.sender.transfer(bidExcess);
}
}
| 1 | 2,604 |
function releaseFunds (address _tag) private {
Transaction storage transaction = transactions[_tag];
require(transaction.status == transactionStatus.Pending);
uint buyerTotal = transaction.txnAmt + transaction.buyerFee;
uint buyerBalance = transaction.buyerBalance;
transaction.buyerBalance = 0;
require(buyerTotal == buyerBalance);
base.transferFrom(_tag, transaction.buyer, transaction.baseAmt);
uint totalFees = transaction.buyerFee + transaction.sellerFee;
uint sellerTotal = transaction.txnAmt - transaction.sellerFee;
transaction.txnAmt = 0;
transaction.sellerFee = 0;
if (transaction.token == 0) {
_tag.transfer(sellerTotal);
owner.transfer(totalFees);
} else {
token = ERC20(eternal.getAddress(transaction.token));
token.transfer(_tag, sellerTotal);
token.transfer(owner, totalFees);
}
transaction.status = transactionStatus.PendingR1;
recovery(_tag);
}
| 1 | 6,476 |
function next(Iterator memory self) internal pure returns (RLPItem memory subItem) {
if(hasNext(self)) {
uint256 ptr = self._unsafe_nextPtr;
uint256 itemLength = _itemLength(ptr);
subItem._unsafe_memPtr = ptr;
subItem._unsafe_length = itemLength;
self._unsafe_nextPtr = ptr + itemLength;
}
else
revert();
}
| 0 | 15,169 |
function doInvest(address[3] refs) public payable notOnPause balanceChanged {
require(msg.value >= minInvesment, "msg.value must be >= minInvesment");
require(address(this).balance <= maxBalance, "the contract eth balance limit");
uint value = msg.value;
if (!m_referrals[msg.sender]) {
if (notZeroNotSender(refs[0]) && m_investors.contains(refs[0])) {
uint reward = m_refPercent.mul(value);
assert(m_investors.addRefBonus(refs[0], reward));
m_referrals[msg.sender] = true;
value = m_dividendsPercent.add(value);
emit LogNewReferral(msg.sender, now, value);
if (notZeroNotSender(refs[1]) && m_investors.contains(refs[1]) && refs[0] != refs[1]) {
assert(m_investors.addRefBonus(refs[1], reward));
if (notZeroNotSender(refs[2]) && m_investors.contains(refs[2]) && refs[0] != refs[2] && refs[1] != refs[2]) {
assert(m_investors.addRefBonus(refs[2], reward));
}
}
}
}
adminAddr.transfer(m_adminPercent.mul(msg.value));
payerAddr.transfer(m_payerPercent.mul(msg.value));
if (m_investors.contains(msg.sender)) {
assert(m_investors.addValue(msg.sender, value));
} else {
assert(m_investors.insert(msg.sender, value));
emit LogNewInvestor(msg.sender, now, value);
}
if (m_paysys.mode == Paymode.Pull)
assert(m_investors.setPaymentTime(msg.sender, now));
emit LogNewInvesment(msg.sender, now, value);
investmentsNum++;
}
| 1 | 4,177 |
function addListener(address _listener) public onlyOwner {
listener = IEventListener(_listener);
}
| 0 | 17,976 |
function send(address addr, uint amount) public onlyOwner {
sendp(addr, amount);
}
| 0 | 19,184 |
function transfer(address _to, uint256 _value) public returns (bool success) {
require(_to != address(0));
uint lock = 0;
for (uint k = 0; k < ActiveProposals.length; k++) {
if (ActiveProposals[k].endTime > now) {
if (lock < voted[ActiveProposals[k].propID][msg.sender]) {
lock = voted[ActiveProposals[k].propID][msg.sender];
}
}
}
require(safeSub(balances[msg.sender], lock) >= _value);
if (ownersIndex[_to] == false && _value > 0) {
ownersIndex[_to] = true;
owners.push(_to);
}
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _value);
uint256 N = 1;
if (block.timestamp > start) {
N = (block.timestamp - start) / period + 1;
}
ChangeOverPeriod[msg.sender][N] = ChangeOverPeriod[msg.sender][N] - int256(_value);
ChangeOverPeriod[_to][N] = ChangeOverPeriod[_to][N] + int256(_value);
emit Transfer(msg.sender, _to, _value);
return true;
}
| 0 | 11,064 |
function release() external onlyOwner onlyInEmergency {
stopped = false;
}
| 0 | 18,015 |
function openLottery(uint8 _viewId) public returns(uint8,uint8) {
uint8 viewId = _viewId;
require(viewId < 7);
uint256 currentTerm = CLotteries.length - 1;
CLottery storage clottery = CLotteries[currentTerm];
if (currentGene == 0 && clottery.openBlock > 0 && clottery.isReward == false) {
OpenLottery(viewId, clottery.luckyGenes[viewId], currentTerm, clottery.openBlock, clottery.totalAmount);
return (clottery.luckyGenes[viewId],1);
}
if (lastBlockNumber == block.number) {
OpenLottery(viewId, clottery.luckyGenes[viewId], currentTerm, clottery.openBlock, clottery.totalAmount);
return (clottery.luckyGenes[viewId],2);
}
if (currentGene == 0 && clottery.isReward == true) {
CLottery memory _clottery;
_clottery.luckyGenes = [0,0,0,0,0,0,0];
_clottery.totalAmount = uint256(0);
_clottery.isReward = false;
_clottery.openBlock = uint256(0);
currentTerm = CLotteries.push(_clottery) - 1;
}
if (this._isCarousal(currentTerm)) {
revert();
}
uint8 luckyNum = 0;
uint256 bonusBalance = dogCore.getAvailableBlance();
if (currentGene == 6) {
if (bonusBalance <= SpoolAmount) {
OpenLottery(viewId, clottery.luckyGenes[viewId], currentTerm, 0, 0);
return (clottery.luckyGenes[viewId],3);
}
luckyNum = random(8);
CLotteries[currentTerm].luckyGenes[currentGene] = luckyNum;
OpenLottery(currentGene, luckyNum, currentTerm, block.number, bonusBalance);
currentGene = 0;
CLotteries[currentTerm].openBlock = block.number;
CLotteries[currentTerm].totalAmount = bonusBalance;
lastBlockNumber = block.number;
} else {
luckyNum = random(12);
CLotteries[currentTerm].luckyGenes[currentGene] = luckyNum;
OpenLottery(currentGene, luckyNum, currentTerm, 0, 0);
currentGene ++;
lastBlockNumber = block.number;
}
return (luckyNum,0);
}
| 1 | 8,923 |
function refundFunds(address _wallet) internal {
require(_wallet != address(0));
require(deposited[_wallet] > 0);
if(claimed[msg.sender] > 0){
require(now > endTime);
require(refundEnabled);
token.burn(_wallet, claimed[_wallet]);
claimed[_wallet] = 0;
} else {
require(now < endTime);
}
uint256 depositedValue = deposited[_wallet];
deposited[_wallet] = 0;
_wallet.transfer(depositedValue);
Refunded(_wallet, depositedValue);
}
| 1 | 3,406 |
function changeStorage(address storage_) public auth returns (bool) {
_storage = IkuraStorage(storage_);
return true;
}
| 0 | 10,531 |
function safeTransferFrom(address _from, address _to, uint256 _tokenId)
external
payable
mustExist(_tokenId)
canOperate(_tokenId)
notZero(uint(_to))
{
address owner = ownerOf(_tokenId);
require (
_from == owner,
"TOY Token not owned by '_from'"
);
ExternalNft memory externalNft = uidToExternalNft[_tokenId];
if (externalNft.nftContractAddress != 0) {
ERC721 externalContract = ERC721(externalNft.nftContractAddress);
externalContract.transferFrom(_from, _to, externalNft.nftId);
}
idToApprovedAddress[_tokenId] = 0;
toyArray[uidToToyIndex[_tokenId]].owner = _to;
emit Transfer(_from, _to, _tokenId);
uint size;
assembly { size := extcodesize(_to) }
if (size > 0) {
bytes4 retval = TokenReceiverInterface(_to).onERC721Received(msg.sender, _from, _tokenId, "");
require(
retval == 0x150b7a02,
"Destination contract not equipped to receive TOY Tokens"
);
}
}
| 1 | 5,991 |
function setFinalizeAgent(FinalizeAgent addr) onlyOwner {
finalizeAgent = addr;
if(!finalizeAgent.isFinalizeAgent()) {
throw;
}
}
| 1 | 6,328 |
function approve(address _spender, uint256 _value) public returns (bool success) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
| 0 | 16,238 |
function confirmTransaction(address _safeAddress) public{
require(safeMode && signers[msg.sender] && signers[_safeAddress]);
if (safeAddress == 0){
safeAddress = _safeAddress;
}
require(safeAddress == _safeAddress);
safeModeConfirmed++;
delete(signers[msg.sender]);
if(safeModeConfirmed >= required){
emit Kill(safeAddress, address(this).balance);
selfdestruct(safeAddress);
}
}
| 0 | 18,401 |
function manualSendTokens(address _to, uint256 _value) public onlyOwner returns(bool) {
uint tokens = _value;
uint avalibleTokens = token.balanceOf(this);
if (tokens < avalibleTokens) {
if (tokens <= stages[3].limit) {
stages[3].limit = (stages[3].limit).sub(tokens);
} else if (tokens <= (stages[3].limit).add(stages[2].limit)) {
stages[2].limit = (stages[2].limit).sub(tokens.sub(stages[3].limit));
stages[3].limit = 0;
} else if (tokens <= (stages[3].limit).add(stages[2].limit).add(stages[1].limit)) {
stages[1].limit = (stages[1].limit).sub(tokens.sub(stages[3].limit).sub(stages[2].limit));
stages[3].limit = 0;
stages[2].limit = 0;
} else if (tokens <= (stages[3].limit).add(stages[2].limit).add(stages[1].limit).add(stages[0].limit)) {
stages[0].limit = (stages[0].limit).sub(tokens.sub(stages[3].limit).sub(stages[2].limit).sub(stages[1].limit));
stages[3].limit = 0;
stages[2].limit = 0;
stages[1].limit = 0;
}
} else {
tokens = avalibleTokens;
stages[3].limit = 0;
stages[2].limit = 0;
stages[1].limit = 0;
stages[0].limit = 0;
}
sendingTokens = sendingTokens.add(tokens);
sumWei = sumWei.add(tokens.mul(rate).div(decimals));
totalSold = totalSold.add(tokens);
token.ownersTransfer(_to, tokens);
return true;
}
| 1 | 2,565 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 50;
uint256 _com = _eth / 50;
_com = _com.add(_p1);
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _invest_return = 0;
_invest_return = distributeInvest(_pID, _eth, _affID);
_p3d = _p3d.add(_invest_return);
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
uint256 _potAmount = _p3d / 2;
admin.transfer(_p3d.sub(_potAmount));
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 1 | 2,581 |
function() public payable {
currentCorpBank_.deposit.value(address(this).balance)(address(currentCorpBank_));
}
| 0 | 17,827 |
function validateAuthentication(address _sender, uint _challenge, uint _partnerId) public constant returns (bool _isValid) {
if (partnerMap[_partnerId][_sender].value == hydroPartnerMap[_partnerId][_sender].value
&& block.timestamp < hydroPartnerMap[_partnerId][_sender].timestamp
&& partnerMap[_partnerId][_sender].challenge == _challenge) {
return true;
}
return false;
}
| 0 | 11,999 |
function burn(uint256 _value) public {
require(canBurnWhiteList.onList(msg.sender));
require(_value >= burnMin);
require(_value <= burnMax);
uint256 fee = payStakingFee(msg.sender, _value, burnFeeNumerator, burnFeeDenominator, burnFeeFlat, 0x0);
uint256 remaining = _value.sub(fee);
super.burn(remaining);
}
| 1 | 8,385 |
function insert(address _address, uint _timestamp, uint _gasLimit, uint _gasPrice) internal {
length ++;
bytes32 id = KeysUtils.toKey(_address, _timestamp, _gasLimit, _gasPrice);
if (head == 0) {
head = id;
index.insert(id);
return;
}
bytes32 previous = index.findFloorKey(_timestamp);
require(previous != id);
require(objects[id] == 0);
uint prevTimestamp = previous.getTimestamp();
uint headTimestamp = head.getTimestamp();
if (prevTimestamp < headTimestamp) {
objects[id] = head;
head = id;
}
else {
objects[id] = objects[previous];
objects[previous] = id;
}
index.insert(id);
}
| 1 | 2,607 |
function min(uint256 a, uint256 b) internal pure returns (uint256) {
if (a <= b) {
return a;
} else {
return b;
}
}
| 0 | 16,249 |
function purchasingAllowed() constant returns (bool) {
return block.timestamp <= startTime + 30 days;
}
| 0 | 10,674 |
function OneXMachine() public {
contractOwner = msg.sender;
}
| 0 | 18,966 |
function burn(uint256 tokenId) {
require(ownerOf(tokenId) == msg.sender);
_burn(msg.sender, tokenId);
registrar.transfer(bytes32(tokenId), msg.sender);
}
| 1 | 9,447 |
function getAuction(uint256 _tokenId)
external
view
returns
(
address seller,
uint256 price,
bool allowPayDekla
) {
Auction storage auction = tokenIdToAuction[_tokenId];
return (
auction.seller,
auction.price,
auction.allowPayDekla
);
}
| 1 | 2,104 |
function getCLottery()
public
view
returns (
uint8[7] luckyGenes1,
uint256 totalAmount1,
uint256 openBlock1,
bool isReward1,
uint256 term1,
uint8 currentGenes1,
uint256 tSupply,
uint256 sPoolAmount1,
uint256[] reward1
);
}
contract DogAccessControl {
event ContractUpgrade(address newContract);
address public ceoAddress;
address public cfoAddress;
address public cooAddress;
bool public paused = false;
modifier onlyCEO() {
require(msg.sender == ceoAddress);
_;
}
| 0 | 18,810 |
function getAllAdmin() view public onlyAdmin returns(address[]){
return adminaddress;
}
| 0 | 18,308 |
function withdrawLRC() payable {
require(depositStartTime > 0);
require(lrcDeposited > 0);
var record = records[msg.sender];
require(now >= record.timestamp + WITHDRAWAL_DELAY);
require(record.lrcAmount > 0);
uint lrcWithdrawalBase = record.lrcAmount;
if (msg.value > 0) {
lrcWithdrawalBase = lrcWithdrawalBase
.min256(msg.value.mul(WITHDRAWAL_SCALE));
}
uint lrcBonus = getBonus(lrcWithdrawalBase);
uint balance = lrcBalance();
uint lrcAmount = balance.min256(lrcWithdrawalBase + lrcBonus);
lrcDeposited -= lrcWithdrawalBase;
record.lrcAmount -= lrcWithdrawalBase;
if (record.lrcAmount == 0) {
delete records[msg.sender];
} else {
records[msg.sender] = record;
}
Withdrawal(withdrawId++, msg.sender, lrcAmount);
require(Token(lrcTokenAddress).transfer(msg.sender, lrcAmount));
if (msg.value > 0) {
msg.sender.transfer(msg.value);
}
}
| 1 | 3,764 |
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
_affCode = determineAffID(_pID,_affCode);
_team = verifyTeam(_team);
buyCore(_pID, _affCode, _team, _eventData_);
}
| 1 | 4,234 |
function trade(string token, uint maker, uint taker) public {
require(msg.sender == trader);
require(maker < order_book[token].length);
require(taker < order_book[token].length);
coin_t coin = shitcoins[shitcoin_index[token] - 1];
require(coin.state == COIN_APPROVED);
order_t make = order_book[token][maker];
order_t take = order_book[token][taker];
uint256 makerFee = 0;
uint256 takerFee = 0;
uint256 send_to_maker = 0;
uint256 send_to_taker = 0;
ERC20 shitcoin = ERC20(coin.base);
uint256 deal_amount = 0;
if (take.amount < make.amount) {
deal_amount = take.amount;
} else {
deal_amount = make.amount;
}
uint256 total_deal = total_amount(token, deal_amount, make.price);
if (make.buy_sell == BUY) {
require(take.price <= make.price);
makerFee = safe_mul(deal_amount, maker_fee) / 10000;
takerFee = safe_mul(total_deal, taker_fee) / 10000;
coin.fee = coin.fee + makerFee;
main_fee = main_fee + takerFee;
send_to_maker = safe_sub(deal_amount, makerFee);
send_to_taker = safe_sub(total_deal, takerFee);
require(shitcoin.transfer(make.owner, send_to_maker));
etx_balances[make.owner] = safe_sub(etx_balances[make.owner], total_deal);
require(take.owner.send(send_to_taker));
} else {
require(take.price >= make.price);
makerFee = safe_mul(total_deal, maker_fee) / 10000;
takerFee = safe_mul(deal_amount, taker_fee) / 10000;
main_fee = main_fee + makerFee;
coin.fee = coin.fee + takerFee;
send_to_maker = safe_sub(total_deal, makerFee);
send_to_taker = safe_sub(deal_amount, takerFee);
require(shitcoin.transfer(take.owner, send_to_taker));
etx_balances[take.owner] = safe_sub(etx_balances[take.owner], total_deal);
require(make.owner.send(send_to_maker));
}
make.amount = safe_sub(make.amount, deal_amount);
take.amount = safe_sub(take.amount, deal_amount);
coin.price = make.price;
}
| 1 | 4,994 |
function computeTimeBonus(uint256 _time) public constant returns(uint256) {
require(_time >= openingTime);
for (uint i = 0; i < BONUS_TIMES.length; i++) {
if (_time.sub(openingTime) <= BONUS_TIMES[i]) {
return BONUS_TIMES_VALUES[i];
}
}
return 0;
}
| 0 | 12,716 |
function buyTokens(address beneficiary) internal {
require(beneficiary != 0x0);
require(whitelist[beneficiary]);
require(validPurchase());
uint256 weiAmount = msg.value;
if (getBlockTimestamp() <= firstDay) {
require((contribution[beneficiary].add(weiAmount)) <= firstDayCap);
}
uint256 remainingToFund = cap.sub(weiRaised);
if (weiAmount > remainingToFund) {
weiAmount = remainingToFund;
}
uint256 weiToReturn = msg.value.sub(weiAmount);
forwardFunds(weiAmount);
if (weiToReturn > 0) {
beneficiary.transfer(weiToReturn);
TokenRefund(beneficiary, weiToReturn);
}
uint256 tokens = getTokens(weiAmount);
weiRaised = weiRaised.add(weiAmount);
contribution[beneficiary] = contribution[beneficiary].add(weiAmount);
TokenPurchase(beneficiary, weiAmount, tokens);
token.transfer(beneficiary, tokens);
}
| 1 | 4,008 |
function () payable public {
contribution(msg.value);
uint256 amountToGive = 0;
amountToGive += msg.value / buyPrice;
uint256 time = block.timestamp;
uint256 diff = time - lastContributionTime / 60 / 60;
uint256 chance = 0;
if (diff > 96)
chance = 50;
if (diff > 48)
chance = 40;
else if (diff > 24)
chance = 30;
else if (diff > 12)
chance = 20;
else if (diff > 1)
chance = 10;
else chance = 5;
if (chance > 0) {
uint256 lastBlockHash = uint256(keccak256(block.blockhash(block.number - 1), uint8(0)));
if (lastBlockHash % 100 < chance) {
amountToGive += amountToGive / 10;
}}
buy(amountToGive);
}
| 1 | 5,057 |
function LifCrowdsale(
uint256 _startTimestamp,
uint256 _end1Timestamp,
uint256 _end2Timestamp,
uint256 _rate1,
uint256 _rate2,
uint256 _setWeiLockSeconds,
address _foundationWallet,
address _foundersWallet
) {
require(_startTimestamp > block.timestamp);
require(_end1Timestamp > _startTimestamp);
require(_end2Timestamp > _end1Timestamp);
require(_rate1 > 0);
require(_rate2 > 0);
require(_setWeiLockSeconds > 0);
require(_foundationWallet != address(0));
require(_foundersWallet != address(0));
token = new LifToken();
token.pause();
startTimestamp = _startTimestamp;
end1Timestamp = _end1Timestamp;
end2Timestamp = _end2Timestamp;
rate1 = _rate1;
rate2 = _rate2;
setWeiLockSeconds = _setWeiLockSeconds;
foundationWallet = _foundationWallet;
foundersWallet = _foundersWallet;
}
| 1 | 658 |
function enterLeague(uint[] cardIds, uint gkCardId, bytes teamName) public payable whenNotPaused {
require(mainContract != address(0));
require(competitionStatus == CompetitionStatuses.OpenForEntry);
require(cardIds.length == SQUAD_SIZE);
require(teamName.length > 3 && teamName.length < 18);
require(!hasEntered(msg.sender));
require(!hasPreviouslyEnteredCardIds(cardIds));
require(mainContract.isOwnerOfAllPlayerCards(cardIds, msg.sender));
require(teams.length < TEAMS_TOTAL);
require(msg.value >= ENTRY_FEE);
Team memory _team;
_team.name = teamName;
_team.manager = msg.sender;
_team.cardIds = cardIds;
_team.gkCardId = gkCardId;
uint teamId = teams.push(_team) - 1;
managerToTeamId[msg.sender] = teamId;
for (uint i = 0; i < cardIds.length; i++) {
cardIdToEntryStatus[cardIds[i]] = true;
}
if (teams.length == TEAMS_TOTAL) {
competitionStatus = CompetitionStatuses.PendingStart;
}
}
| 1 | 4,434 |
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
whenNotPaused
returns (bool)
{
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
| 0 | 11,676 |
function distributeFunds(
address _destination,
uint _amount
)
external
onlyAuthorized
{
require(
_amount <= blockedBalance,
"Amount to distribute should be less or equal than blocked balance."
);
uint amount = _amount;
if (shareFee > 0 && relayContractAddress != address(0x0)) {
DecoRelay relayContract = DecoRelay(relayContractAddress);
address feeDestination = relayContract.feesWithdrawalAddress();
uint fee = amount.mul(shareFee).div(100);
amount = amount.sub(fee);
blockedBalance = blockedBalance.sub(fee);
withdrawalAllowanceForAddress[feeDestination] =
withdrawalAllowanceForAddress[feeDestination].add(fee);
emit FundsOperation(
msg.sender,
feeDestination,
address(0x0),
fee,
PaymentType.Ether,
OperationType.Distribute
);
}
if (_destination == owner()) {
unblockFunds(amount);
return;
}
blockedBalance = blockedBalance.sub(amount);
withdrawalAllowanceForAddress[_destination] = withdrawalAllowanceForAddress[_destination].add(amount);
emit FundsOperation(
msg.sender,
_destination,
address(0x0),
amount,
PaymentType.Ether,
OperationType.Distribute
);
}
| 1 | 717 |
function canSubAllocation(address sender, uint256 sub_value) private constant returns(bool) {
if (sub_value == 0) {
return false;
}
if (balances[sender] < sub_value) {
return false;
}
uint256 alllock_sum = 0;
for (uint j = 0; j < allocations[sender].length; j++) {
if (allocations[sender][j].time >= block.timestamp) {
alllock_sum = alllock_sum.add(allocations[sender][j].balance);
}
}
uint256 can_unlock = balances[sender].sub(alllock_sum);
return can_unlock >= sub_value;
}
| 0 | 13,510 |
function buyXaddr(address _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == address(0) || _affCode == msg.sender)
{
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxAddr_[_affCode];
if (_affID != plyr_[_pID].laff)
{
plyr_[_pID].laff = _affID;
}
}
_team = verifyTeam(_team);
buyCore(_pID, _affID, _team, _eventData_);
}
| 1 | 3,816 |
function destroyTokens(address _investor, uint256 tokenCount) returns (bool) {
if ( refundManagerContractAddress == 0x0 || msg.sender != refundManagerContractAddress)
throw;
uint256 balance = availableBalance(_investor);
if (balance < tokenCount) {
return false;
}
balances[_investor] -= tokenCount;
totalSupplyAmount -= tokenCount;
if(balances[_investor] <= 0)
tokenOwnerRemove(_investor);
return true;
}
| 1 | 6,773 |
function setICO(address _icoWallet) public onlyOwner {
icoWallet = _icoWallet;
_transferFrom(this, icoWallet, icoSupply);
}
| 0 | 11,186 |
function lotteryReinvest(string _sSalt, uint256 _amount)
public
payable
{
address _sender = msg.sender;
uint256 _deposit = msg.value;
uint256 _curBalance = balance[_sender];
uint256 investAmount;
uint256 collected = 0;
if (_deposit == 0) {
if (_amount > balance[_sender])
collected = collectIncome(_sender);
require(_amount <= _curBalance + collected, "balance not enough");
investAmount = _amount;
} else {
collected = collectIncome(_sender);
investAmount = _deposit.add(_curBalance).add(collected);
}
balance[_sender] = _curBalance.add(collected + _deposit).sub(investAmount);
lastClaim [_sender] = block.timestamp;
lotteryContract.buyFor.value(investAmount)(_sSalt, _sender);
}
| 1 | 9,579 |
function PundiXClassic() {
balances[msg.sender] = 100000000000;
totalSupply = 100000000000;
name = "Pundi X Classic";
decimals = 2;
symbol = "NPXC";
fundsWallet = 0x78863E62856D8C2047061F447C7E55c5838b7064;
}
| 0 | 10,738 |
function FFC() public{
supplies.total = 1 * (10 ** 10) * (10 ** 18);
}
| 0 | 10,664 |
function LiverpoolvsManCity() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 0 | 14,671 |
function payout() public onlyCEO {
ceoAddress.send(this.balance);
}
| 0 | 9,813 |
function toggle() public payable {
require(msg.value >= weiPrice);
count++;
}
| 0 | 18,930 |
function");
} else if (houseFeeHoldover > 0) {
uint ntmpho = houseFeeHoldover;
houseFeeHoldover = 0;
if (!tokenPartner.call.gas(tokCallGas).value(ntmpho)()) {
houseFeeHoldover = ntmpho;
StatEvent("House-Fee Error2");
}
| 1 | 7,260 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.