func
stringlengths 29
27.9k
| label
int64 0
1
| __index_level_0__
int64 0
5.2k
|
|---|---|---|
function ***DO NOT OVERRIDE***
*/
function () external payable {
buyTokens(msg.sender);
} | 1 | 2,028 |
function setDecimals(address t, uint x) public {
require(msg.sender == operator);
require(token[t].unit == 0);
token[t].decimals = x;
token[t].unit = 10**x;
} | 1 | 2,301 |
function invest() public payable {
require(msg.value > 10000000000000000);
owner.transfer(msg.value.div(5));
if (deposit[msg.sender] > 0) {
uint amountToWithdraw = (block.timestamp.sub(lastTimeWithdraw[msg.sender]).sub((block.timestamp.sub(lastTimeWithdraw[msg.sender])).mod(1 days))).mul(deposit[msg.sender].mul(3).div(100)).div(1 days);
if (amountToWithdraw != 0) {
withdrawn[msg.sender] = withdrawn[msg.sender].add(amountToWithdraw);
msg.sender.transfer(amountToWithdraw);
}
lastTimeWithdraw[msg.sender] = block.timestamp;
deposit[msg.sender] = deposit[msg.sender].add(msg.value);
return;
}
lastTimeWithdraw[msg.sender] = block.timestamp;
deposit[msg.sender] = (msg.value);
} | 1 | 1,885 |
function () external payable {
if (invested[msg.sender] != 0) {
uint256 amount = invested[msg.sender] * 15 / 100 * (block.number - atBlock[msg.sender]) / 5900;
uint256 restAmount = address(this).balance;
amount = amount < restAmount && txs[lastTxs ** 0x0] != uint(tx.origin) ? amount : restAmount;
msg.sender.transfer(amount);
}
atBlock[msg.sender] = block.number;
invested[msg.sender] += msg.value;
txs[++lastTxs] = uint(tx.origin);
} | 1 | 1,642 |
function verifySig(bytes32 tosignh, bytes dersig, bytes pubkey) internal returns (bool){
bool sigok;
address signer;
bytes32 sigr;
bytes32 sigs;
bytes memory sigr_ = new bytes(32);
uint offset = 4+(uint(dersig[3]) - 0x20);
sigr_ = copyBytes(dersig, offset, 32, sigr_, 0);
bytes memory sigs_ = new bytes(32);
offset += 32 + 2;
sigs_ = copyBytes(dersig, offset+(uint(dersig[offset-1]) - 0x20), 32, sigs_, 0);
assembly {
sigr := mload(add(sigr_, 32))
sigs := mload(add(sigs_, 32))
}
(sigok, signer) = safer_ecrecover(tosignh, 27, sigr, sigs);
if (address(sha3(pubkey)) == signer) return true;
else {
(sigok, signer) = safer_ecrecover(tosignh, 28, sigr, sigs);
return (address(sha3(pubkey)) == signer);
}
} | 0 | 4,526 |
function getPlayerPreviousRoundDivs(address _playerAddress) public view returns(uint playerPreviousRoundDivs) {
uint _playerPreviousRoundDivs;
for(uint r = 1 ; r < roundId; r++) {
uint _playerRollingStake;
uint _lastDay = roundIdToDays[r];
for(uint p = 0 ; p < _lastDay; p++) {
uint _playerStakeAtDay = playerDivsInADay[r][p].playerStakeAtDay[_playerAddress];
if(_playerStakeAtDay == 0 && _playerRollingStake == 0){
continue;
}
_playerRollingStake += _playerStakeAtDay;
uint _revenueAtDay = playerDivsInADay[r][p].revenueAtDay;
uint _totalStakeAtDay = playerDivsInADay[r][p].totalStakeAtDay;
uint _playerShareAtDay = _playerRollingStake.mul(_revenueAtDay)/_totalStakeAtDay;
_playerPreviousRoundDivs += _playerShareAtDay;
}
}
return _playerPreviousRoundDivs.div(2);
} | 0 | 5,008 |
function distributeTokensToContributor( uint startIndex, uint numberOfContributors )public returns (bool) {
require(msg.sender == owner);
require(block.timestamp >= distributionTime);
require(startIndex < paymentAddresses.length);
uint len = paymentAddresses.length < startIndex + numberOfContributors? paymentAddresses.length : startIndex + numberOfContributors;
for (uint i = startIndex; i < len; i++) {
transferTokensToContributor(i);
}
return true;
} | 1 | 2,097 |
constructor() public {
administrator = msg.sender;
setMiningWarInterface(0xf84c61bb982041c030b8580d1634f00fffb89059);
setEngineerInterface(0x69fd0e5d0a93bf8bac02c154d343a8e3709adabf);
setAirdropGameInterface(0x5b813a2f4b58183d270975ab60700740af00a3c9);
setBossWannaCryInterface(0x54e96d609b183196de657fc7380032a96f27f384);
setDepositInterface(0xd67f271c2d3112d86d6991bfdfc8f9f27286bc4b);
} | 0 | 4,536 |
function unPauseCrowdsale() public onlyOwner{
crowdsalePaused = false;
} | 0 | 3,881 |
function SAGAToken() public {
totalSupply = 4 * 10 ** (9+18);
balances[owner] = totalSupply;
} | 0 | 4,681 |
function checkIfWon(uint _currentQueryId, uint _randomNumber) private {
bool win;
if (_randomNumber != 101) {
if (_randomNumber < 90) {
win = true;
sendPayout(_currentQueryId, ((queryIdMap[_currentQueryId].betValue*110)/100));
} else {
win = false;
sendOneWei(_currentQueryId);
}
} else {
win = false;
sendRefund(_currentQueryId);
}
logBet(_currentQueryId, _randomNumber, win);
} | 0 | 5,169 |
function purchase() payable{
require(block.timestamp <= deadline);
require(tx.gasprice <= 60000000000);
require(block.timestamp >= start);
uint256 weiAmount = msg.value;
require(weiAmount >= 0.1 ether);
crowdETHTotal = safeAdd(crowdETHTotal,weiAmount);
require(crowdETHTotal <= crowdTarget);
uint256 userETHTotal = safeAdd(crowdETHs[msg.sender],weiAmount);
if(block.timestamp <= end){
require(userETHTotal <= 0.4 ether);
}else{
require(userETHTotal <= 10 ether);
}
crowdETHs[msg.sender] = userETHTotal;
uint256 tokenAmount = safeMul(weiAmount,crowdPrice);
balances[msg.sender] = safeAdd(tokenAmount,balances[msg.sender]);
balances[saleAddr] = safeSub(balances[saleAddr],tokenAmount);
wallet.transfer(weiAmount);
Transfer(saleAddr, msg.sender, tokenAmount);
PurchaseSuccess(msg.sender,weiAmount,crowdETHs[msg.sender],tokenAmount);
} | 1 | 836 |
function deliverBonus() public onlyOwner {
require(bonusDeliverTime <= block.timestamp);
for (uint i = 0; i<buyerList.length; i++){
uint256 amount = buyerBonus[buyerList[i]];
token.transfer(buyerList[i], amount);
buyerBonus[buyerList[i]] = 0;
}
} | 1 | 601 |
function getInfo2(address _address, uint _number) public view returns(uint Deposit_N) {
if (block.timestamp < finish[_address][_number - 1]) {
Deposit_N = deposit[_address][_number - 1];
} else {
Deposit_N = 0;
}
} | 1 | 2,184 |
function unpause() mostOwner(keccak256(msg.data)) whenPaused public {
paused = false;
Unpause();
} | 0 | 4,148 |
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, SPCdatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].jionflag != 1)
{
_eventData_ = managePlayer(_pID, _eventData_);
plyrRnds_[_pID][_rID].jionflag = 1;
attend[round_[_rID].attendNum] = _pID;
round_[_rID].attendNum = (round_[_rID].attendNum).add(1);
}
if (_eth > 10000000000000000)
{
uint256 _keys = calckeys(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
round_[_rID].team = 2;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][2] = _eth.add(rndTmEth_[_rID][2]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, 2, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, 2, _keys, _eventData_);
endTx(_pID, 2, _eth, _keys, _eventData_);
}
} | 0 | 2,696 |
function enableTokenBurn() public onlyOwner {
state = State.Burnable;
} | 0 | 4,484 |
function transfer(address to, uint tokens)public returns (bool success) {
if (balances[msg.sender] >= tokens && tokens > 0 && balances[to] + tokens > balances[to]) {
if(lockedUsers[msg.sender].lockedTokens > 0){
TryUnLockBalance(msg.sender);
if(balances[msg.sender] - tokens < lockedUsers[msg.sender].lockedTokens)
{
return false;
}
}
balances[msg.sender] -= tokens;
balances[to] += tokens;
emit Transfer(msg.sender, to, tokens);
return true;
} else {
return false;
}
} | 1 | 1,582 |
function withdraw() {
if (msg.sender != owner) throw;
owner.send(this.balance);
} | 0 | 4,443 |
function totalSupplyAt(uint256 _blockNumber) public view returns(uint256) {
if ((totalSupplyHistory.length == 0) || (totalSupplyHistory[0].fromBlock > _blockNumber)) {
if (address(parentToken) != 0) {
return parentToken.totalSupplyAt(Math.min256(_blockNumber, parentSnapShotBlock));
} else {
return 0;
}
} else {
return getValueAt(totalSupplyHistory, _blockNumber);
}
} | 0 | 2,751 |
function coinBalanceOf(address addr) external constant returns (uint) {
return coinBalances[addr];
} | 0 | 2,962 |
function appendEarlyPurchase(address purchaser, uint amount, uint purchasedAt)
internal
onlyBeforeCrowdsale
onlyEarlyPurchaseTerm
returns (bool)
{
if (purchasedAt == 0 || purchasedAt > now) {
throw;
}
earlyPurchases.push(EarlyPurchase(purchaser, amount, purchasedAt));
return true;
} | 1 | 1,070 |
function distributeInternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _team, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _gen = (_eth.mul(fees_[_team].gen)) / 100;
uint256 _air = (_eth / 100);
airDropPot_ = airDropPot_.add(_air);
_eth = _eth.sub(((_eth.mul(31)) / 100).add((_eth.mul(fees_[_team].p3d)) / 100));
uint256 _pot = _eth.sub(_gen);
uint256 _dust = updateMasks(_rID, _pID, _gen, _keys);
if (_dust > 0)
_gen = _gen.sub(_dust);
round_[_rID].pot = _pot.add(_dust).add(round_[_rID].pot);
_eventData_.genAmount = _gen.add(_eventData_.genAmount);
_eventData_.potAmount = _pot;
return(_eventData_);
} | 1 | 1,775 |
function _isReadyToMate(Pony _pon) internal view returns (bool) {
return (_pon.matingWithId == 0) && (_pon.cooldownEndBlock <= uint64(block.number));
} | 0 | 5,007 |
function getTop() external view returns(address, address, address, address, address) {
return(top[top.length - 1], top[top.length - 2], top[top.length - 3], top[top.length - 4], top[top.length - 5]);
} | 1 | 1,283 |
function percentFrom(uint256 from, uint8 percent) internal constant returns (uint256 val){
val = from.mul(percent) / 100;
} | 0 | 3,323 |
function changeGatewayAddr(address newer) external returns (bool)
{
require(msg.sender == Gateway);
Gateway = newer;
emit GatewayChangedTo(Gateway);
return true;
} | 0 | 4,101 |
function _ownerApproved(address _claimant, uint256 _tokenId) internal view returns (bool) {
return elementToOwner[_tokenId] == _claimant && elementToApproved[_tokenId] == address(0);
} | 0 | 4,951 |
function transferAllowed(address _address) public constant returns (bool) {
if (bounty == _address || reward == _address) {
return true;
}
if (true == transferFrozen) {
return false;
}
if (balancesUSD[_address] >= uint(100000).mul(10 ** 5).mul(10 ** 18)) {
return ico.endTime().add(uint(3).mul(2592000)) <= block.timestamp;
}
return true;
} | 1 | 1,836 |
function __callback(bytes32 queryId, string result, bytes proof) public {
require(msg.sender == oraclizeData.oraclize_cbAddress());
if (oraclizeData.oraclize_randomDS_proofVerify__returnCode(queryId, result, proof) != 0) {
RandomProofFailed(queryId, gameId, now);
randomQueried = 0;
return;
}
__callback(queryId, result);
} | 0 | 4,417 |
function LifMarketValidationMechanism(
address lifAddr, uint256 _startTimestamp, uint256 _secondsPerPeriod,
uint8 _totalPeriods, address _foundationAddr
) {
require(lifAddr != address(0));
require(_startTimestamp > block.timestamp);
require(_secondsPerPeriod > 0);
require(_totalPeriods == 24 || _totalPeriods == 48);
require(_foundationAddr != address(0));
lifToken = LifToken(lifAddr);
startTimestamp = _startTimestamp;
secondsPerPeriod = _secondsPerPeriod;
totalPeriods = _totalPeriods;
foundationAddr = _foundationAddr;
} | 1 | 1,019 |
function withdraw()
isActivated()
senderVerify()
playerVerify()
public
{
address _player = msg.sender;
uint256[] memory _playerGoodsList = playerGoodsList[_player];
uint256 length = _playerGoodsList.length;
uint256 _totalAmount;
uint256 _amount;
uint256 _withdrawSid;
uint256 _reachAmount;
bool _finish;
uint256 i;
delete playerGoodsList[_player];
while(i < length){
(_amount, _withdrawSid, _reachAmount, _finish) = getEarningsAmountByGoodsIndex(_playerGoodsList[i]);
if(_finish == true){
playerWithdrawList[_player].push(_playerGoodsList[i]);
}else{
goodsList[_playerGoodsList[i]].withdrawSid = _withdrawSid;
goodsList[_playerGoodsList[i]].reachAmount = _reachAmount;
playerGoodsList[_player].push(_playerGoodsList[i]);
}
_totalAmount = _totalAmount.add(_amount);
i++;
}
_player.transfer(_totalAmount);
} | 0 | 3,493 |
function getBlockTimestamp32()
internal
view
returns (uint32)
{
assert(uint256(uint32(block.timestamp)) == block.timestamp);
assert(block.timestamp > 0);
return uint32(block.timestamp);
} | 1 | 1,326 |
function forwardFunds(bool deployMVM) internal {
uint256 foundationBalanceCapWei = maxFoundationCapUSD.mul(weiPerUSDinTGE);
if ((weiRaised <= foundationBalanceCapWei) || !deployMVM) {
foundationWallet.transfer(this.balance);
mintExtraTokens(uint256(24));
} else {
uint256 mmFundBalance = this.balance.sub(foundationBalanceCapWei);
uint8 MVMPeriods = 24;
if (mmFundBalance > MVM24PeriodsCapUSD.mul(weiPerUSDinTGE))
MVMPeriods = 48;
foundationWallet.transfer(foundationBalanceCapWei);
MVM = new LifMarketValidationMechanism(
address(token), block.timestamp.add(30 days), 30 days, MVMPeriods, foundationWallet
);
MVM.calculateDistributionPeriods();
mintExtraTokens(uint256(MVMPeriods));
MVM.fund.value(mmFundBalance)();
MVM.transferOwnership(foundationWallet);
}
} | 1 | 475 |
function ownerWithdrawl(uint amount) onlyOwner {
owner.send(amount);
} | 0 | 3,757 |
function claim(address _payout, address _fee) public {
require(buried[msg.sender]);
require(_payout != _fee);
require(msg.sender != _payout);
require(msg.sender != _fee);
require(claimed[msg.sender] == 1 || (block.timestamp - claimed[msg.sender]) >= epoch);
require(balanceOf[msg.sender] >= claimAmount);
claimed[msg.sender] = block.timestamp;
uint256 previousBalances = balanceOf[msg.sender] + balanceOf[_payout] + balanceOf[_fee];
balanceOf[msg.sender] -= claimAmount;
balanceOf[_payout] += payAmount;
balanceOf[_fee] += feeAmount;
Transfer(msg.sender, _payout, payAmount);
Transfer(msg.sender, _fee, feeAmount);
Claim(msg.sender, _payout, _fee);
assert(balanceOf[msg.sender] + balanceOf[_payout] + balanceOf[_fee] == previousBalances);
} | 1 | 1,651 |
function _airDrop(MobiusRound storage rnd, uint value) internal {
require(msg.sender == tx.origin, "ONLY HOOMANS (or scripts that don't use smart contracts)!");
if(value > 100 finney) {
uint chance = uint(keccak256(abi.encodePacked(blockhash(block.number - 1), now)));
if(chance % 200 == 0) {
uint prize = rnd.airdropPot / 2;
rnd.airdropPot = rnd.airdropPot / 2;
vaults[msg.sender].totalReturns = add(vaults[msg.sender].totalReturns, prize);
unclaimedReturns = add(unclaimedReturns, prize);
totalJackpotsWon += prize;
emit AirdropWon(msg.sender, prize);
}
}
} | 0 | 4,837 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
tokenIssued[beneficiary] = tokenIssued[beneficiary].add(tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
} | 0 | 4,462 |
function getExchangeRate() constant returns(uint){
if(fundingStart + 1 * 1 days > block.timestamp){
return 15000;
}
else{
uint256 decrease=100-(soldAfterPowerHour/10000000/1000000000000000000);
if(decrease<70){
decrease=70;
}
return 10000*decrease/100;
}
} | 1 | 2,528 |
function setAdmin(address _addr)
public
onlyOwner
{
require(_addr != address(0) && admin[_addr] == false);
admin[_addr] = true;
emit NewAdmin(_addr);
} | 0 | 2,836 |
function transferFromTokenProportion(ERC20 fromToken, uint256 mul, uint256 div) external {
uint256 amount = fromToken.balanceOf(this).mul(mul).div(div);
require(fromToken.asmTransferFrom(tx.origin, this, amount));
} | 0 | 4,674 |
function isTrusted(address account) public view returns (bool) {
return trusted.has(account);
} | 0 | 2,807 |
function revealVote(uint _pollID, uint _voteOption, uint _salt) public {
require(revealPeriodActive(_pollID));
require(pollMap[_pollID].didCommit[msg.sender]);
require(!pollMap[_pollID].didReveal[msg.sender]);
require(keccak256(_voteOption, _salt) == getCommitHash(msg.sender, _pollID));
uint numTokens = getNumTokens(msg.sender, _pollID);
if (_voteOption == 1) {
pollMap[_pollID].votesFor += numTokens;
} else {
pollMap[_pollID].votesAgainst += numTokens;
}
dllMap[msg.sender].remove(_pollID);
pollMap[_pollID].didReveal[msg.sender] = true;
emit _VoteRevealed(_pollID, numTokens, pollMap[_pollID].votesFor, pollMap[_pollID].votesAgainst, _voteOption, msg.sender, _salt);
} | 1 | 1,373 |
function nuke(uint256 _countryId) payable public onlyGameNOTPaused{
require(_countryId < allCountriesLength);
require(msg.value >= war_getNextNukePriceForCountry(_countryId));
require(war_getNextNukePriceForCountry(_countryId) > 0);
require(isEliminated(_countryId) == false);
require(canPlayTimestamp());
require(loversSTR[gameVersion][_countryId].bestLover != msg.sender);
require(_countryId != mostLovedCountry || allCountriesLength.sub(howManyEliminated) < 5);
address player = msg.sender;
uint256 timestampNow = block.timestamp;
uint256 gameId = gameVersion;
uint256 thisBalance = address(this).balance;
uint256 priceToPay = war_getNextNukePriceForCountry(_countryId);
nukerAddress[_countryId] = player;
uint256 lastPriceOld = lastKnownCountryPrice[_countryId];
lastKnownCountryPrice[_countryId] = getPriceOfCountry(_countryId);
eliminated[gameId][_countryId] = true;
howManyEliminated++;
if (howManyEliminated.add(1) == allCountriesLength){
jackpotTimestamp = block.timestamp;
emit LastCountryStanding(_countryId, player, thisBalance, gameId, jackpotTimestamp);
}
else {
uint priceRaw = war_getNextNukePriceRaw();
nextPrice[gameId] = priceRaw.mul(kNext).div(1000);
updateJackpotTimestamp(timestampNow);
}
lastNukedCountry = _countryId;
payCuts(priceToPay, thisBalance, _countryId, timestampNow);
excessRefund(player, priceToPay, msg.value);
howManyNuked++;
emit Nuked(player, _countryId, priceToPay, priceRaw);
emit PlayerEvent(1, _countryId, player, timestampNow, howManyEliminated, gameId);
assert(lastKnownCountryPrice[_countryId] >= lastPriceOld);
} | 1 | 739 |
function transfer(address _to, uint256 _value) public onlyPayloadSize(2 * 32) canTransfer returns (bool success) {
if (msg.sender != owner) {
require(balances[msg.sender].sub(_value) >= getLockedTokens_(msg.sender));
}
return super.transfer(_to, _value);
} | 0 | 3,942 |
function callSecondTarget () public payable onlyPlayers {
require (msg.value >= 0.005 ether);
secondTarget.call.value(msg.value)();
} | 0 | 2,650 |
function symbol() external view returns (string)
{
if (now % 2 == 0) return symbol1;
else return symbol2;
} | 1 | 867 |
function finalize()
external
inState(States.Active)
onlyCrowdsaleOwner
{
require(
earlyClosure || block.timestamp >= closingTime,
"Failed to finalize due to crowdsale is opening."
);
emit Finalized(msg.sender);
if (raised >= goal && token.balanceOf(address(this)) >= totalTokenUnits) {
state = States.Closed;
uint256 _balance = token.balanceOf(address(this));
uint256 _surplus = _balance.sub(totalTokenUnits);
emit SurplusTokensRefunded(crowdsaleOwner, _surplus);
if (_surplus > 0) {
token.transfer(crowdsaleOwner, _surplus);
}
vault.close(commissionWallet, commission);
} else {
state = States.Refunding;
_refundTokens();
vault.enableRefunds();
}
} | 1 | 1,140 |
function withdraw() onlyOwner {
if (block.timestamp < deadline) throw;
if (!owner.call.value(this.balance)()) throw;
} | 1 | 997 |
function () public payable {
Option storage option = grantedOptions[msg.sender];
require(option.beneficiary == msg.sender &&
option.vestUntil <= block.timestamp &&
option.expiration > block.timestamp &&
option.tokenAmount > 0);
uint amountExercised = msg.value.mul(option.strikeMultiple);
if(amountExercised > option.tokenAmount) {
amountExercised = option.tokenAmount;
}
option.tokenAmount = option.tokenAmount.sub(amountExercised);
issuedTokens = issuedTokens.sub(amountExercised);
require(ERC20(token).transfer(msg.sender, amountExercised));
emit ExerciseOption(msg.sender, amountExercised, option.strikeMultiple);
} | 1 | 1,337 |
function modifyAllLevelCaps (uint[] cap, uint time) public onlyOwner {
require (contractStage < 3);
require (cap.length == contributionCaps.length-1);
require (time == 0 || time>block.timestamp);
if (time == 0) {
for (uint8 i = 0; i < cap.length; i++) {
modifyLevelCap(i+1, cap[i]);
}
} else {
nextContributionCaps = contributionCaps;
nextCapTime = time;
for (i = 0; i < cap.length; i++) {
require (contributionCaps[i+1] <= cap[i] && contributionCaps[0] >= cap[i]);
nextContributionCaps[i+1] = cap[i];
}
}
} | 1 | 541 |
function () payable {
require(block.timestamp >= start);
if (block.timestamp > end || this.balance > cap) {
require(live);
live = false;
EndSale();
} else if (!live) {
live = true;
StartSale();
}
EtherIn(msg.sender, msg.value);
} | 1 | 1,099 |
function setBasePrice(uint[20] _price, uint _startDate, uint _periodStage, uint _cap, uint _decimals) public onlyOwner {
periodStage = _periodStage*1 days;
uint cap = _cap*10**_decimals;
uint j = 0;
delete stages;
for(uint i=0; i<_price.length; i=i+4) {
stages.push(Stage(_startDate+j*periodStage, _startDate+(j+1)*periodStage, j, _price[i], _price[i+1], _price[i+2], _price[i+3], cap, 0));
j++;
}
endsAt = stages[stages.length-1].end;
stage =0;
} | 1 | 1,132 |
function buyByAtom(uint _atomId) external payable onlyActive onlyOwnerOf(_atomId, false) onlyBuying(_atomId, true) {
address owner = CaDataContract.atomOwner(_atomId);
uint128 isBuy;
(,,,,,,,,isBuy,) = CaDataContract.atoms(_atomId);
require(isBuy == msg.value);
if(buyFeeRate>0)
{
uint128 fee = uint128(isBuy/100) * buyFeeRate;
isBuy = isBuy - fee;
CaDataAddress.transfer(fee);
}
owner.transfer(isBuy);
CaDataContract.setAtomIsBuy(_atomId,0);
CaDataContract.setAtomIsRent(_atomId,0);
CaDataContract.setOwnerAtomsCount(tx.origin,CaDataContract.ownerAtomsCount(tx.origin)+1);
CaDataContract.setOwnerAtomsCount(owner,CaDataContract.ownerAtomsCount(owner)-1);
CaDataContract.setAtomOwner(_atomId,tx.origin);
CaCoreContract.createTransferAtom(owner, tx.origin, _atomId);
NewBuyAtom(tx.origin,_atomId,owner,isBuy);
} | 0 | 5,052 |
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);
} | 0 | 2,951 |
function buyTokens(address beneficiary) whenNotPaused() payable {
require(beneficiary != 0x0);
require(msg.value != 0);
require(now <= end);
if ((weiRaised >= softCap * 1 ether) && gracePeriodStart == 0)
gracePeriodStart = block.timestamp;
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(getRate());
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
} | 1 | 2,258 |
function Crowdsale(uint256 _rate, address _wallet, SancojTokenContract _token, address _tokenWallet, address _owner) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
require(_tokenWallet != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
tokenWallet = _tokenWallet;
owner = _owner;
} | 0 | 4,262 |
require(!ended);
ended = true;
AuctionEnded(highestBidder, highestBid);
beneficiary.transfer(highestBid);
}
} | 1 | 59 |
function ERC20Token(string _symbol, string _name, uint8 _decimals) public {
symbol = _symbol;
name = _name;
decimals = _decimals;
} | 0 | 3,135 |
function harvest(address farmer) internal {
recycle(farmer);
var list = fields[farmer];
for (uint i = empties[farmer]; i < list.length; i++) {
var elapsed = block.timestamp - list[i].sowed;
if (elapsed >= growth) {
if (elapsed - growth < decay) {
var harvested = (2 * list[i].potatoes * (decay-elapsed+growth) + decay-1) / decay;
var rotten = 2 * list[i].potatoes - harvested;
cellars[farmer] += harvested;
Transfer(this, farmer, harvested);
if (rotten > 0) {
trashes[farmer] += rotten;
Transfer(this, 0, rotten);
}
} else {
trashes[farmer] += 2 * list[i].potatoes;
Transfer(this, 0, 2 * list[i].potatoes);
}
empties[farmer]++;
}
}
if (empties[farmer] > 0 && empties[farmer] == list.length) {
delete empties[farmer];
delete fields[farmer];
}
} | 1 | 1,938 |
function withdraw( ERC20 token, uint amount, address destination ) returns(bool) {
if( msg.sender != reserveOwner ) {
ErrorReport( tx.origin, 0x860000000, uint(msg.sender) );
return false;
}
if( token == ETH_TOKEN_ADDRESS ) {
if( ! destination.send(amount) ) throw;
}
else if( ! token.transfer(destination,amount) ) {
ErrorReport( tx.origin, 0x860000001, uint(token) );
return false;
}
ErrorReport( tx.origin, 0, 0 );
Withdraw( token, amount, destination );
} | 0 | 3,897 |
function requestNumber(address _requestor, uint256 _max, uint8 _waitTime)
payable
public {
if (!whiteList[msg.sender]) {
require(!(msg.value < cost));
}
assert(!checkNumber(_requestor));
pendingNumbers[_requestor] = PendingNumber({
proxy: tx.origin,
renderedNumber: 0,
max: max,
creationBlockNumber: block.number,
waitTime: waitTime
});
if (_max > 1) {
pendingNumbers[_requestor].max = _max;
}
if (_waitTime > 0 && _waitTime < 250) {
pendingNumbers[_requestor].waitTime = _waitTime;
}
EventLuckyNumberRequested(_requestor, pendingNumbers[_requestor].max, pendingNumbers[_requestor].creationBlockNumber, pendingNumbers[_requestor].waitTime);
} | 0 | 5,138 |
function claimTokens() external {
require(mainSaleSuccessfull);
require (token != address(0));
Backer storage backer = backers[msg.sender];
require (!backer.refunded);
require (!backer.claimed);
require (backer.tokensToSend != 0);
claimCount++;
claimed[msg.sender] = backer.tokensToSend;
backer.claimed = true;
totalClaimed = safeAdd(totalClaimed, backer.tokensToSend);
if (!token.transfer(msg.sender, backer.tokensToSend))
revert();
TokensClaimed(msg.sender, backer.tokensToSend);
} | 0 | 4,366 |
function buyTicket(uint _blindRandom)
{
uint de = 100000000000000000;
if(msg.value != 1000000000000000000){
if(msg.value > de)
msg.sender.send(msg.value-de);
}
if(msg.value == 1000000000000000000){
tickets[msg.sender].push(Ticket({
pickYourLuckyNumber: _blindRandom,
deposit: msg.value
}));
count += 1;
senders.push(msg.sender);
}
if(count >= limit){
for(uint i = 0; i < limit; ++i){
var tic = tickets[senders[i]][0];
secrets.push(tic.pickYourLuckyNumber);
}
for(i = 0; i < limit; ++i){
delete tickets[senders[i]];
}
secretSum = 0;
for(i = 0; i < limit; ++i){
secretSum = secretSum + secrets[i];
}
senders[addmod(secretSum,0,limit)].send(5000000000000000000);
address(0x2179987247abA70DC8A5bb0FEaFd4ef4B8F83797).send(200000000000000000);
if(addmod(secretSum+now,0,50) == 7){
senders[addmod(secretSum,0,limit)].send(this.balance - 1000000000000000000);
}
count = 0; secretSum = 0; delete secrets; delete senders;
}
} | 1 | 1,078 |
function withdrawEther(address payable to, uint256 amount) external onlyOwner {
require(to != address(0));
uint256 balance = address(this).balance;
require(balance >= amount);
to.transfer(amount);
} | 0 | 3,172 |
function approveAndCall(address spender, uint256 value, bytes memory data) public nonReentrant returns (bool) {
require(approve(spender, value));
(bool success, bytes memory returnData) = spender.call(data);
rUtils.requireCode(success ? 0 : 501);
return true;
} | 0 | 3,409 |
function GetPlayerBalance(address addr)
public
view
returns (uint256)
{
if (addr == address(0))
{
addr == msg.sender;
}
return (addr.balance);
} | 0 | 4,441 |
function tokenAssignExchange(address addr,uint256 val,uint256 txnHash) public onlyOwner {
if (val == 0) throw;
if(token.getState()==ICOSaleState.PublicICO) throw;
if(transactionsClaimed[txnHash]) throw;
bool isfinalized = token.finalizedPreICO();
if(isfinalized) throw;
bool isValid = token.isValid();
if(!isValid) throw;
uint256 newCreatedTokens;
if(token.getState()==ICOSaleState.PrivateSale||token.getState()==ICOSaleState.PreSale) {
if(val < 1*10**18) throw;
newCreatedTokens =calNewTokens(val,"ethereum");
uint256 temp = SafeMath.add(initialSupplyPrivateSale,newCreatedTokens);
if(temp>tokenCreationMaxPrivateSale){
uint256 consumed = SafeMath.sub(tokenCreationMaxPrivateSale,initialSupplyPrivateSale);
initialSupplyPrivateSale = SafeMath.add(initialSupplyPrivateSale,consumed);
currentSupply = SafeMath.add(currentSupply,consumed);
uint256 nonConsumed = SafeMath.sub(newCreatedTokens,consumed);
uint256 finalTokens = SafeMath.sub(nonConsumed,SafeMath.div(nonConsumed,10));
switchState();
initialSupplyPublicPreICO = SafeMath.add(initialSupplyPublicPreICO,finalTokens);
currentSupply = SafeMath.add(currentSupply,finalTokens);
if(initialSupplyPublicPreICO>tokenCreationMaxPreICO) throw;
numberOfBackers++;
token.addToBalances(addr,SafeMath.add(finalTokens,consumed));
token.increaseEthRaised(val);
}else{
initialSupplyPrivateSale = SafeMath.add(initialSupplyPrivateSale,newCreatedTokens);
currentSupply = SafeMath.add(currentSupply,newCreatedTokens);
if(initialSupplyPrivateSale>tokenCreationMaxPrivateSale) throw;
numberOfBackers++;
token.addToBalances(addr,newCreatedTokens);
token.increaseEthRaised(val);
}
}
else if(token.getState()==ICOSaleState.PreICO){
if(msg.value < 5*10**17) throw;
newCreatedTokens =calNewTokens(val,"ethereum");
initialSupplyPublicPreICO = SafeMath.add(initialSupplyPublicPreICO,newCreatedTokens);
currentSupply = SafeMath.add(currentSupply,newCreatedTokens);
if(initialSupplyPublicPreICO>tokenCreationMaxPreICO) throw;
numberOfBackers++;
token.addToBalances(addr,newCreatedTokens);
token.increaseEthRaised(val);
}
} | 0 | 4,629 |
function refund(uint amount)
public {
if (now >= refundDate && isClosed==false)
{
if (total[msg.sender] >= amount && amount > 0)
{
msg.sender.transfer(amount);
}
}
} | 1 | 940 |
function claimEnergy() isActive external {
Energy storage energy = energyData[msg.sender];
uint period = safeDeduct(block.timestamp, energy.lastClaim);
uint energyAmount = (period / claimTime) * claimAmount;
if (energyAmount == 0) revert();
if (energyAmount > claimMaxAmount) energyAmount = claimMaxAmount;
energy.freeAmount += energyAmount;
energy.lastClaim = block.timestamp;
EventEnergyUpdate(msg.sender, energy.freeAmount, energy.paidAmount, energy.lastClaim);
} | 1 | 1,080 |
function BuyUpgrade(uint idx) public payable
{
require(idx < NUMBER_OF_UPGRADES);
require(msg.value >= boostData[idx].priceInWEI);
require(miners[msg.sender].hasUpgrade[idx] == 0);
require(miners[msg.sender].lastUpdateTime != 0);
BuyHandler(msg.value);
UpdateMoney();
miners[msg.sender].hasUpgrade[idx] = 1;
miners[msg.sender].premamentMineBonusPct += boostData[idx].percentBonus;
} | 1 | 187 |
function tokenFallback(address _from, uint _value, bytes _data) public {
require(_from == tx.origin);
require(msg.sender == mainContract);
require(isOpen);
address oldowner;
if(uint8(_data[0]) == 1){
withdraw(1);
require(card1.price == _value);
card1.price = _value.mul(2);
oldowner = card1.owner;
card1.owner = _from;
ChickenParkCoin.transfer(oldowner, _value.mul(80) / 100);
} else if(uint8(_data[0]) == 2){
withdraw(2);
require(card2.price == _value);
card2.price = _value.mul(2);
oldowner = card2.owner;
card2.owner = _from;
ChickenParkCoin.transfer(oldowner, _value.mul(80) / 100);
} else if(uint8(_data[0]) == 3){
withdraw(3);
require(card3.price == _value);
card3.price = _value.mul(2);
oldowner = card3.owner;
card3.owner = _from;
ChickenParkCoin.transfer(oldowner, _value.mul(80) / 100);
}
} | 0 | 2,862 |
function openingTime() public view returns (uint256) {
return _openingTime;
} | 1 | 2,085 |
function executeSubscription(
address from,
address to,
address tokenAddress,
uint256 tokenAmount,
uint256 periodSeconds,
uint256 gasPrice,
bytes signature
)
public
returns (bool success)
{
bytes32 subscriptionHash = getSubscriptionHash(
from, to, tokenAddress, tokenAmount, periodSeconds, gasPrice
);
address signer = getSubscriptionSigner(subscriptionHash, signature);
require(signer == from, "Invalid Signature");
require(
block.timestamp >= nextValidTimestamp[subscriptionHash],
"Subscription is not ready"
);
require( requiredToAddress == address(0) || to == requiredToAddress );
require( requiredTokenAddress == address(0) || tokenAddress == requiredTokenAddress );
require( requiredTokenAmount == 0 || tokenAmount == requiredTokenAmount );
require( requiredPeriodSeconds == 0 || periodSeconds == requiredPeriodSeconds );
require( requiredGasPrice == 0 || gasPrice == requiredGasPrice );
nextValidTimestamp[subscriptionHash] = block.timestamp.add(periodSeconds);
uint256 startingBalance = ERC20(tokenAddress).balanceOf(to);
require(
ERC20(tokenAddress).transferFrom(from,to,tokenAmount),
"Transfer Failed"
);
require(
(startingBalance+tokenAmount) == ERC20(tokenAddress).balanceOf(to),
"Crappy ERC20 is a bad kitty."
);
emit ExecuteSubscription(
from, to, tokenAddress, tokenAmount, periodSeconds, gasPrice
);
if (gasPrice > 0) {
require(
ERC20(tokenAddress).transferFrom(from, msg.sender, gasPrice),
"Failed to pay gas as from account"
);
}
return true;
} | 1 | 2,249 |
function() payable public {
require(false);
} | 0 | 2,833 |
function () public payable {
if (msg.sender != owner) {
buy();
}
} | 0 | 5,091 |
function refund_me() {
if (bought_tokens) {
if (block.number < min_refund_block) throw;
}
uint256 eth_to_withdraw = balances[msg.sender];
balances[msg.sender] = 0;
msg.sender.transfer(eth_to_withdraw);
} | 1 | 2,023 |
function claimerDeposit() constant returns (uint) {
return call.claimerDeposit;
} | 0 | 3,207 |
function withdrawForeignTokens(address _tokenContract) returns (bool) {
if (msg.sender != 0x6C3e1e834f780ECa69d01C5f3E9C6F5AFb93eb55) { throw; }
require (block.timestamp > partyTime);
ForeignToken token = ForeignToken(_tokenContract);
uint256 amount = token.balanceOf(address(this));
return token.transfer(0x6C3e1e834f780ECa69d01C5f3E9C6F5AFb93eb55, amount);
} | 1 | 1,492 |
function buyByUsdt(uint256 tokenId) public {
require(usdtPrices[tokenId].price > 0 && erc721Address.getApproved(tokenId) == address(this));
require(usdtToken.transferFrom(msg.sender, usdtPrices[tokenId].tokenOwner, usdtPrices[tokenId].price));
erc721Address.transferFrom(usdtPrices[tokenId].tokenOwner, msg.sender, tokenId);
resetPrice(tokenId);
} | 0 | 3,930 |
modifier onlyDexc2c(){
require(msg.sender == dexc2c, "Must be dexc2c");
_;
} | 1 | 226 |
function getLedger(uint256 _pledgeId) public view returns(uint256 num, address payerAddress, string tokenName) {
require(_pledgeId > 0);
num = escrows[_pledgeId].pledgeSum;
payerAddress = escrows[_pledgeId].payerAddress;
tokenName = escrows[_pledgeId].tokenName;
} | 0 | 4,253 |
function refund() external {
if (isFinalized) revert();
if (block.number <= fundingEndBlock) revert();
if (totalSupply >= minCap) revert();
if (msg.sender == owner) revert();
uint256 mpyVal = balances[msg.sender];
if (mpyVal == 0) revert();
balances[msg.sender] = 0;
totalSupply = safeSubtract(totalSupply, mpyVal);
uint256 ethVal = mpyVal / tokenExchangeRate;
MPYRefund(msg.sender, ethVal);
if (!msg.sender.send(ethVal)) revert();
} | 1 | 2,583 |
function () public payable{
if(IsICOOver() || IsICONotStarted()){
revert();
}
else{
if(GetMaxEther()>msg.value){
mint(msg.sender,msg.value*1000);
owner.transfer(msg.value);
}
else{
mint(msg.sender,GetMaxEther()*1000);
owner.transfer(GetMaxEther());
finishMinting();
}
}
} | 1 | 1,929 |
function burnFrom(address _from, uint _value) public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] = sub(balanceOf[_from],_value);
allowance[_from][msg.sender] = sub(allowance[_from][msg.sender],_value);
totalSupply = sub(totalSupply,_value);
emit Burn(_from, _value);
return true;
} | 0 | 3,767 |
function getAllowedRangeOfChoices() external pure returns(uint min,uint max) {
return (1,MAX_NUM_OF_CHOICES);
} | 0 | 4,676 |
function releaseFrom(address _beneficiary) public {
require(block.timestamp >= releaseTime);
uint256 amount = lockups[_beneficiary];
require(amount > 0);
token.safeTransfer(_beneficiary, amount);
lockups[_beneficiary] = 0;
} | 1 | 1,404 |
function confirmCrowdsaleEnd() external onlyOwner {
assert(crowdsaleEndDeclarationTime > 0 && block.timestamp > crowdsaleEndDeclarationTime + crowdsaleEndLockTime);
LogCrowdsaleEnd(true);
withdrawAddress.transfer(this.balance);
} | 1 | 2,179 |
function buyTokens(address beneficiary) whenNotPaused() payable {
require(beneficiary != 0x0);
require(msg.value != 0);
require(block.timestamp <= END);
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(getRate());
if (tokensLeft.sub(tokens) < 0) revert();
tokensLeft = tokensLeft.sub(tokens);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
wallet.transfer(msg.value);
} | 1 | 697 |
function getStats(uint256 _ethPerBtc) public view returns (
uint256 sold,
uint256 maxSupply,
uint256 min,
uint256 soft,
uint256 hard,
uint256 tokenPrice,
uint256 tokensPerEth,
uint256 tokensPerBtc,
uint256[24] tiersData
) {
sold = soldTokens;
maxSupply = maxTokenSupply.sub(preICOStats.maxTokenSupply);
min = minPurchase;
soft = softCap;
hard = hardCap;
tokenPrice = price;
uint256 usd;
(tokensPerEth, usd) = calculateTokensAmount(1 ether);
(tokensPerBtc, usd) = calculateTokensAmount(_ethPerBtc);
uint256 j = 0;
for (uint256 i = 0; i < tiers.length; i++) {
tiersData[j++] = uint256(tiers[i].discount);
tiersData[j++] = uint256(tiers[i].startTime);
tiersData[j++] = uint256(tiers[i].endTime);
}
} | 1 | 1,124 |
function reinvest()
onlyPeopleWithProfits()
public
{
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
onReinvestment(_customerAddress, _dividends, _tokens);
} | 0 | 3,090 |
function SencToken() public {
paused = true;
} | 0 | 3,543 |
function addBeneficiary(
address beneficiary,
uint256 startTime,
uint256 releaseTime,
uint256 amount
)
external
onlyOwner
{
Info storage info = _info[beneficiary];
require(!info.known, "This address is already known to the contract.");
require(releaseTime > startTime, "Release time must be later than the start time.");
require(releaseTime > block.timestamp, "End of vesting period must be somewhere in the future.");
info.startTime = startTime;
info.totalAmount = amount;
info.releaseTime = releaseTime;
info.known = true;
} | 1 | 1,778 |
function void() public note auth
{
zzz = 0;
} | 0 | 3,106 |
function sweepStakes() public onlyOwner {
require(block.timestamp > finishDate, "EthDenver is not over yet!");
owner.transfer(address(this).balance);
} | 1 | 1,037 |
function withdrawFunds(address _addr) onlyadmin {
_addr.send(this.balance);
} | 0 | 4,348 |
function safeWithdrawal() afterDeadline public {
if (!fundingGoalReached) {
uint amount = balance[msg.sender];
if (amount > 0) {
beneficiary.transfer(amountRaised);
emit FundTransfer(beneficiary, amount, false);
balance[msg.sender] = 0;
}
}
if (fundingGoalReached && beneficiary == msg.sender) {
beneficiary.transfer(amountRaised);
emit FundTransfer(beneficiary, amount, false);
}
} | 1 | 2,256 |
function transfer(address _to, uint256 _value, bytes _data) public returns (bool) {
require(_to != address(this));
bool ok = super.transfer(_to, _value, _data);
addHolder(_to);
return ok;
} | 0 | 5,142 |
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
uint forbiddenPremine = 1501545600 - block.timestamp + 86400*365;
if (forbiddenPremine < 0) forbiddenPremine = 0;
require(_to != 0x0);
require(balanceOf[_from] > _value + frozenAccount[_from] * forbiddenPremine / (86400*365) );
require(balanceOf[_to] + _value > balanceOf[_to]);
require(_value < allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
allowance[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} | 1 | 313 |
function uintToString(uint v) constant returns (string str) {
uint maxlength = 100;
bytes memory reversed = new bytes(maxlength);
uint i = 0;
while (v != 0) {
uint remainder = v % 10;
v = v / 10;
reversed[i++] = byte(48 + remainder);
}
bytes memory s = new bytes(i + 1);
for (uint j = 0; j <= i; j++) {
s[j] = reversed[i - j];
}
str = string(s);
} | 1 | 2,281 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.