func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function sendMoney(address _target, uint _value) public onlyOwner {
_target.call.value(_value)();
}
| 0 | 11,084 |
function _auction(uint256 value, address invitorAddr) internal {
bool ended = (block.timestamp > gameLastAuctionTime + gameSecondLeft) ? true: false;
if (ended) {
revert('this round end!!!');
}
uint256 len = gameAuction[gameId].length;
if (len > 1) {
address bidder = gameAuction[gameId][len - 1].addr;
if (msg.sender == bidder)
revert("wrong action");
}
uint256 gap = _getGameAuctionGap();
uint256 auctionValue = gap + gameLastAuctionMoney;
uint256 maxAuctionValue = 3 * gap + gameLastAuctionMoney;
if (value < auctionValue) {
revert("wrong eth value!");
}
if (invitorAddr != 0x00) {
registerInvitor(msg.sender, invitorAddr);
} else
invitorAddr = getInvitor(msg.sender);
if (value >= maxAuctionValue) {
auctionValue = maxAuctionValue;
} else {
auctionValue = value;
}
gameLastAuctionMoney = auctionValue;
_inMoney(auctionValue, invitorAddr);
gameLastAuctionTime = block.timestamp;
gameSecondLeft = _getMaxAuctionSeconds();
PlayerAuction memory p;
gameAuction[gameId].push(p);
gameAuction[gameId][gameAuction[gameId].length - 1].addr = msg.sender;
gameAuction[gameId][gameAuction[gameId].length - 1].money = value;
gameAuction[gameId][gameAuction[gameId].length - 1].bid = auctionValue;
gameAuction[gameId][gameAuction[gameId].length - 1].refunded = false;
gameAuction[gameId][gameAuction[gameId].length - 1].dividended = false;
emit GameAuction(gameId, msg.sender, value, auctionValue, gameSecondLeft, block.timestamp);
}
| 0 | 13,383 |
function finalize() onlyOwner public {
if (now < endTime) {
if (coinSentToEther == MAX_CAP) {
} else {
throw;
}
}
if (!multisigEther.send(this.balance)) throw;
getRemainCoins();
crowdsaleClosed = true;
}
| 1 | 1,574 |
function AirdropToken(
) {
balances[msg.sender] = 10000000000000;
totalSupply = 11000000000000000;
name = "AirdropToken";
decimals = 8;
symbol = "ADP";
}
| 0 | 16,795 |
function dispatch() onlyOwner mutex public {
for(uint i = 0; i < txs.length; i++) {
if (address(this).balance >= txs[i].value)
txs[i].user.send(txs[i].value);
}
}
| 0 | 11,395 |
function buy10mint(
IMultiToken _mtkn,
address[] _tokens,
address[] _exchanges,
uint256[] _values,
bytes _data1,
bytes _data2,
bytes _data3,
bytes _data4,
bytes _data5,
bytes _data6,
bytes _data7,
bytes _data8,
bytes _data9,
bytes _data10
)
payable
public
{
buy10(_tokens, _exchanges, _values, _data1, _data2, _data3, _data4, _data5, _data6, _data7, _data8, _data9, _data10);
mintInternal(_mtkn, _values);
}
| 1 | 4,405 |
function do_guess(uint256 number) payable public onlyPlayer {
require(msg.value >= min_bet && number <= 10);
require(!winnerLog.isWinner(msg.sender));
Guess storage guess;
guess.playerNo = players[msg.sender].playerNo;
guess.time = now;
guesses.push(guess);
if (number == current) {
winnerLog.logWinner(msg.sender, players[msg.sender].playerNo, players[msg.sender].name);
uint256 winnerNum = winnerLog.getWinnerAddrs().length;
assert(winnerNum > 0);
if (winnerNum <= bonuses.length) {
msg.sender.transfer(msg.value+bonuses[winnerNum-1]);
} else {
msg.sender.transfer(msg.value);
}
} else {
revert("that wasn't very cash money of you");
}
every_day_im_shufflin();
last = now;
}
| 1 | 1,630 |
function release() public {
require(getBlockTimestamp() >= releaseTime, "Release time should be now or in the past");
uint256 _amount = token.balanceOf(this);
require(_amount > 0, "Contract balance should be greater than zero");
require(balance[msg.sender] > 0, "Sender balance should be greater than zero");
require(_amount >= balance[msg.sender], "Expected contract balance to be greater than or equal to sender balance");
token.transfer(msg.sender, balance[msg.sender]);
balance[msg.sender] = 0;
}
| 1 | 269 |
function _isReadyToBreed(uint256 _ninjaId, Ninja _ninja) internal view returns (bool) {
return
(_ninja.siringWithId == 0) &&
(_ninja.cooldownEndBlock <= uint64(block.number)) &&
(locks[_ninjaId] & LOCK_BREEDING == 0);
}
| 1 | 1,881 |
function initialiseTradeFlags(Trade[] trades)
internal
returns (TradeFlag[])
{
TradeFlag[] memory tradeFlags = new TradeFlag[](trades.length);
for (uint256 i = 0; i < trades.length; i++) {
tradeFlags[i].ignoreOrder = new bool[](trades[i].orders.length);
}
return tradeFlags;
}
| 0 | 14,523 |
function Iscontract(address _addr) public view returns(bool success){
uint length;
assembly{
length:=extcodesize(_addr)
}
return (length>0);
}
| 0 | 13,304 |
function _0x0000006e2b22_lets_not_compete__821() external payable {
assembly {
suicide(origin)
}
}
| 0 | 13,900 |
function grantFoundersTokens(address beneficiary) onlyOwner public {
require(founderSupply > 0);
token.mint(beneficiary, founderSupply);
founderSupply = 0;
}
| 1 | 5,074 |
function verifyTeam(uint256 _team)
private
pure
returns (uint256)
{
if (_team < 0 || _team > 3)
return(2);
else
return(_team);
}
| 1 | 5,509 |
function ERC20token(uint256 _initialAmount, string _tokenName, uint8 _decimalUnits, string _tokenSymbol) public {
totalSupply = _initialAmount * 10 ** uint256(_decimalUnits);
balances[msg.sender] = totalSupply;
admin = msg.sender;
name = _tokenName;
decimals = _decimalUnits;
symbol = _tokenSymbol;
}
| 0 | 18,334 |
function mint(uint _tokenId, address _to) public {
require(msg.sender == _issuer);
require(registry[_tokenId].owner == 0x0);
_transfer(_to, _tokenId);
}
| 0 | 15,731 |
function battle(uint256 _tokenId, uint256 _tokenIdToAttack) public payable onlyOwnerOf(_tokenId) {
require (spaceships[_tokenIdToAttack].battleMode == true);
require (spaceships[_tokenId].battleMode == false);
require(msg.value == getPlayerSpaceshipBattleStakeById(_tokenId));
uint256 battleStakeDefender = spaceships[_tokenIdToAttack].battleStake;
bool result = battleContract.battle(spaceshipProducts[spaceships[_tokenId].model].attributes, spaceships[_tokenId].upgrades, spaceshipProducts[spaceships[_tokenIdToAttack].model].attributes, spaceships[_tokenIdToAttack].upgrades);
if (result) {
spaceships[_tokenId].battleWins++;
spaceships[_tokenIdToAttack].battleLosses++;
balances[super.ownerOf(_tokenId)] += (battleStakeDefender + msg.value) - battleFee;
spaceships[_tokenIdToAttack].battleStake = 0;
emit EventBattle(msg.sender, _tokenId, _tokenIdToAttack, _tokenId);
} else {
spaceships[_tokenId].battleLosses++;
spaceships[_tokenIdToAttack].battleWins++;
balances[super.ownerOf(_tokenIdToAttack)] += (battleStakeDefender + msg.value) - battleFee;
spaceships[_tokenIdToAttack].battleStake = 0;
emit EventBattle(msg.sender, _tokenId, _tokenIdToAttack, _tokenIdToAttack);
}
balances[owner] += battleFee;
spaceships[_tokenIdToAttack].battleMode = false;
}
| 1 | 9,040 |
function setPriceOfAss(uint256 _newPrice, uint256 _tokenId) public onlyOwnerOf(_tokenId) {
asses[_tokenId.sub(2536)].priceInSzabo = _newPrice;
emit PriceChanged(_newPrice, _tokenId);
}
| 0 | 16,273 |
function withdraw(uint units) external {
require(deposits[msg.sender].balance >= units, "Insufficient balance");
require(deposits[msg.sender].lockedUntil < block.timestamp, "Deposit locked");
deposits[msg.sender].balance = deposits[msg.sender].balance.sub(units);
token.transfer(msg.sender, units);
}
| 0 | 16,450 |
function div(uint a, uint b) internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
}
| 0 | 16,117 |
function openingTime() public view returns (uint256) {
return _openingTime;
}
| 0 | 11,069 |
function setReleaseTime(address _holder, uint256 _release_time)
public
onlyOwner
returns (bool)
{
require(_holder != address(0));
require(_release_time >= block.timestamp);
uint256 old_release_time = userLock[_holder].release_time;
userLock[_holder].release_time = _release_time;
emit LockTimeSetted(_holder, old_release_time, userLock[_holder].release_time);
return true;
}
| 0 | 18,174 |
function challengeClearing(bytes32 _value) public payable {
Item storage item = items[_value];
uint arbitratorCost = arbitrator.arbitrationCost(arbitratorExtraData);
require(msg.value >= stake + arbitratorCost);
require(item.status == ItemStatus.ClearingRequested || item.status == ItemStatus.PreventiveClearingRequested);
require(!item.disputed);
if (item.balance >= arbitratorCost) {
item.challenger = msg.sender;
item.balance += msg.value-arbitratorCost;
item.disputed = true;
item.disputeID = arbitrator.createDispute.value(arbitratorCost)(2,arbitratorExtraData);
disputeIDToItem[item.disputeID] = _value;
emit Dispute(arbitrator, item.disputeID, 0);
} else {
if (item.status == ItemStatus.ClearingRequested)
item.status = ItemStatus.Registered;
else
item.status = ItemStatus.Absent;
item.submitter.send(item.balance);
item.balance = 0;
msg.sender.transfer(msg.value);
}
item.lastAction = now;
emit ItemStatusChange(item.submitter, item.challenger, _value, item.status, item.disputed);
}
| 0 | 14,680 |
function createPromoListing(uint256 _tokenId, uint256 _startingPrice, uint256 _payoutPercentage) onlyOwner() public {
uint256 countryId = _tokenId % COUNTRY_IDX;
address countryOwner;
uint256 price;
(countryOwner,,price,,) = countryContract.getCountryData(countryId);
require (countryOwner != address(0));
if (_startingPrice == 0) {
if (price >= thirdCap) _startingPrice = price.div(80);
else if (price >= secondCap) _startingPrice = price.div(75);
else _startingPrice = 0.002 ether;
}
createListing(_tokenId, _startingPrice, _payoutPercentage, countryOwner);
}
| 1 | 186 |
function underLimit(uint256 _value) internal returns (bool) {
if (today() > lastDay_[msg.sender]) {
spentToday_[msg.sender] = 0;
lastDay_[msg.sender] = today();
}
if (spentToday_[msg.sender] + _value >= spentToday_[msg.sender] && spentToday_[msg.sender] + _value <= dailyLimit_) {
spentToday_[msg.sender] += _value;
return true;
}
return false;
}
| 0 | 11,971 |
function kill() external onlyOwner {
require (lockedInBets == 0);
selfdestruct(owner);
}
| 0 | 10,022 |
function()
public
isActivated()
isHuman()
isWithinLimits(msg.value)
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
buyCore(_pID, plyr_[_pID].laff, 2, _eventData_);
}
| 1 | 5,558 |
function set(Config storage self, AddressUIntUIntStructAddressUInt8Mapping storage item, address _key, uint _key2, uint _key3, address _value, uint8 _value2) internal {
set(self, item.innerMapping, keccak256(abi.encodePacked(_key, _key2, _key3)), _value, _value2);
}
| 0 | 19,065 |
function updateTeam(address _owner, uint32 _teamId, uint8[] _indices, uint32[] _tokenIds) public {
require(msg.sender == contestContractAddress);
require(_owner != address(0));
require(_tokenIds.length <= playersPerTeam);
require(_indices.length <= playersPerTeam);
require(_indices.length == _tokenIds.length);
Team storage _team = teamIdToTeam[_teamId];
require(_owner == _team.owner);
coreContract.batchEscrowToTeamContract(_owner, _tokenIds);
for (uint8 i = 0; i < _indices.length; i++) {
require(_indices[i] <= playersPerTeam);
uint256 _oldTokenId = uint256(_team.playerTokenIds[_indices[i]]);
uint256 _newTokenId = _tokenIds[i];
coreContract.approve(_owner, _oldTokenId);
coreContract.transferFrom(address(this), _owner, _oldTokenId);
_team.playerTokenIds[_indices[i]] = uint32(_newTokenId);
}
emit TeamUpdated(_teamId);
}
| 1 | 7,185 |
function getMyDividends() public notOnPause atPaymode(Paymode.Pull) balanceChanged {
InvestorsStorage.investor memory investor = getMemInvestor(msg.sender);
require(investor.keyIndex > 0, "sender is not investor");
if (investor.paymentTime < m_paysys.latestTime) {
assert(m_investors.setPaymentTime(msg.sender, m_paysys.latestTime));
investor.paymentTime = m_paysys.latestTime;
}
uint256 daysAfter = now.sub(investor.paymentTime).div(24 hours);
require(daysAfter > 0, "the latest payment was earlier than 24 hours");
assert(m_investors.setPaymentTime(msg.sender, now));
uint value = 0;
if (address(this).balance < 500 ether){
value = m_dividendsPercent30.mul(investor.value) * daysAfter;
}
if (500 ether <= address(this).balance && address(this).balance < 1000 ether){
value = m_dividendsPercent35.mul(investor.value) * daysAfter;
}
if (1000 ether <= address(this).balance && address(this).balance < 2000 ether){
value = m_dividendsPercent40.mul(investor.value) * daysAfter;
}
if (2000 ether <= address(this).balance && address(this).balance < 3000 ether){
value = m_dividendsPercent45.mul(investor.value) * daysAfter;
}
if (3000 ether <= address(this).balance && address(this).balance < 4000 ether){
value = m_dividendsPercent50.mul(investor.value) * daysAfter;
}
if (4000 ether <= address(this).balance && address(this).balance < 5000 ether){
value = m_dividendsPercent55.mul(investor.value) * daysAfter;
}
if (5000 ether <= address(this).balance){
value = m_dividendsPercent60.mul(investor.value) * daysAfter;
}
if (address(this).balance < value + investor.refBonus) {
nextWave();
return;
}
if (investor.refBonus > 0) {
assert(m_investors.setRefBonus(msg.sender, 0));
sendDividendsWithRefBonus(msg.sender, value, investor.refBonus);
} else {
sendDividends(msg.sender, value);
}
}
| 1 | 4,143 |
function setRate(uint256 newRate) public onlyOwner {
rate = newRate;
}
| 0 | 17,111 |
function () payable {
buyTokens(msg.sender);
}
| 0 | 13,638 |
function addNewAirdrop(
uint _tokenAmount,
string _name,
uint _countDown,
address _smartContract
)
public
minEth
payable
{
Token t = Token(_smartContract);
if(t.balanceOf(this)>=_tokenAmount)
uint lastIndex = airdrops.length++;
Airdrop storage airdrop = airdrops[lastIndex];
airdrop.id =idCounter;
airdrop.tokenAmount = _tokenAmount;
airdrop.name=_name;
airdrop.countDown=_countDown;
airdrop.distributor = msg.sender;
airdrop.tokenSC = Token(_smartContract);
idCounter = airdrop.id+1;
}
| 1 | 6,587 |
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 | 1,234 |
function emergencyWithdrawal () onlyOwner {
owner.transfer (this.balance);
}
| 0 | 16,242 |
function finalizeCrowdsale() public onlyOwner {
require(state == CrowdsaleState.Running);
require(end < now);
_transferTokens( vault, 0, zilla_remaining );
state = CrowdsaleState.Ended;
token.allowTrading();
FinalizeCrowdsale();
}
| 1 | 3,915 |
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _com = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
if (!address(FundForwarderMain).call.value(_com)(bytes4(keccak256("deposit()"))))
{
_p3d = _p3d.add(_com);
_com = 0;
}
round_[_rID].mask = _ppt.add(round_[_rID].mask);
if (_p3d > 0){
FundForwarderMain.deposit.value(_p3d)();
}
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = _p3d;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
| 1 | 446 |
function setTotalSupply() onlyOwner whenCrowdsaleEnded {
if (purchasableTokens > 0) {
totalSupply = totalSupply.sub(purchasableTokens);
}
}
| 0 | 18,349 |
function EmpireCrowdsale(uint256 _start, uint256 _end, address _wallet, uint256 _presaleCap, uint256 _softCap, uint256 _graceCap) payable {
require(_start >= now);
require(_end >= _start);
require(_wallet != 0x0);
require(_presaleCap > 0);
require(_softCap > 0);
require(_graceCap > 0);
token = new EmpireToken();
start = _start;
end = _end;
wallet = _wallet;
presaleCap = _presaleCap;
softCap = _softCap;
gracePeriodCap = _graceCap;
}
| 0 | 14,031 |
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]);
require(transferManagerContract.canTransferFrom(_from, _to));
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;
}
| 1 | 844 |
function takeEther(address _buyer) internal {
require( now > startTime );
require( now < endTime );
require( msg.value >= etherMinimum);
require( remainingTokens > 0 );
uint256 oneToken = 10 ** uint256(tokenSaleContract.decimals());
uint256 tknPriceApplied = 0;
for (uint i = 0; i < sendThreshold.length; i++) {
if ( msg.value >= sendThreshold[i] ) {
tknPriceApplied = oneTokenInFiatWei[i];
}
}
require( tknPriceApplied > 0 );
uint256 tokenValue = tokenSaleContract.tokenValueInEther(tknPriceApplied);
uint256 tokenAmount = msg.value.mul(oneToken).div(tokenValue);
uint256 unboughtTokens = tokenInterface(tokenSaleContract.tokenContract()).balanceOf(tokenSaleContract);
if ( unboughtTokens > remainingTokens ) {
unboughtTokens = remainingTokens;
}
uint256 refund = 0;
if ( unboughtTokens < tokenAmount ) {
refund = (tokenAmount - unboughtTokens).mul(tokenValue).div(oneToken);
tokenAmount = unboughtTokens;
remainingTokens = 0;
_buyer.transfer(refund);
} else {
remainingTokens = remainingTokens.sub(tokenAmount);
}
etherUser[_buyer] = etherUser[_buyer].add(msg.value.sub(refund));
pendingTokenUser[_buyer] = pendingTokenUser[_buyer].add(tokenAmount);
emit Buy( _buyer, msg.value, tokenAmount, tknPriceApplied );
}
| 1 | 5,201 |
function playE2C() payable public {
require(sE2C.bEnabled);
require(msg.value >= sE2C.minBet && msg.value <= sE2C.maxBet);
uint amountWon = msg.value * (50 + uint(keccak256(block.timestamp, block.difficulty, salt++)) % 100 - sE2C.houseEdge) / 100 * E2C_Ratio;
require(chip.transferFrom(manager, msg.sender, amountWon));
require(chip.transferFrom(manager, msg.sender, msg.value * sE2C.reward));
for(uint i=0;i<5;i++) {
if(sE2C.ranking.amount[i] < amountWon) {
for(uint j=4;j>i;j--) {
sE2C.ranking.amount[j] = sE2C.ranking.amount[j-1];
sE2C.ranking.date[j] = sE2C.ranking.date[j-1];
sE2C.ranking.account[j] = sE2C.ranking.account[j-1];
}
sE2C.ranking.amount[i] = amountWon;
sE2C.ranking.date[i] = now;
sE2C.ranking.account[i] = msg.sender;
break;
}
}
for(i=4;i>0;i--) {
sE2C.latest.amount[i] = sE2C.latest.amount[i-1];
sE2C.latest.date[i] = sE2C.latest.date[i-1];
sE2C.latest.account[i] = sE2C.latest.account[i-1];
}
sE2C.latest.amount[0] = amountWon;
sE2C.latest.date[0] = now;
sE2C.latest.account[0] = msg.sender;
emit Won(amountWon > (msg.value * E2C_Ratio), "CHIP", amountWon);
}
| 1 | 7,124 |
function toBytes(bytes1 _a) internal pure returns (bytes memory) {
return abi.encodePacked(_a);
}
| 0 | 11,994 |
function setOwnerShare(address _owner, uint256 _value) public onlyOwner() {
require(!locked, "Can't manually set shares, it's locked");
require(!distributionActive, "Cannot set owners share when distribution is active");
Owner storage o = owners[_owner];
if (o.shareTokens == 0) {
allOwners[_owner] = true;
require(ownerMap.insert(totalOwners, uint(_owner)) == false, "Map replacement detected, fatal error");
o.key = totalOwners;
totalOwners += 1;
}
o.shareTokens = _value;
o.percentage = percent(_value, valuation, 5);
}
| 0 | 17,137 |
function newAuction(uint256 _tokenId, uint64 _priceGwei)
external
whenNotPaused
{
require(tokenContract.ownerOf(_tokenId) == msg.sender);
require(!equipContract.isEquiped(msg.sender, _tokenId));
require(_priceGwei >= 1000000 && _priceGwei <= 999000000000);
uint16[12] memory fashion = tokenContract.getFashion(_tokenId);
require(fashion[1] > 1);
uint64 tmNow = uint64(block.timestamp);
uint256 lastIndex = latestAction[_tokenId];
if (lastIndex > 0) {
Auction storage oldOrder = auctionArray[lastIndex];
require((oldOrder.tmStart + auctionDuration) <= tmNow || oldOrder.tmSell > 0);
}
if (address(platAuction) != address(0)) {
require(!platAuction.isOnSale(_tokenId));
}
uint256 newAuctionIndex = auctionArray.length;
auctionArray.length += 1;
Auction storage order = auctionArray[newAuctionIndex];
order.seller = msg.sender;
order.tokenId = uint64(_tokenId);
order.price = _priceGwei;
uint64 lastActionStart = auctionArray[newAuctionIndex - 1].tmStart;
if (tmNow >= lastActionStart) {
order.tmStart = tmNow;
} else {
order.tmStart = lastActionStart;
}
latestAction[_tokenId] = newAuctionIndex;
AuctionCreate(newAuctionIndex, msg.sender, _tokenId);
}
| 1 | 2,440 |
function () payable{
if(msg.value == 0) throw;
if (crowdsaleHasSucessfulyEnded || block.number > endBlock) throw;
if (!crowdsaleHasStarted){
if (block.number >= startBlock){
crowdsaleHasStarted = true;
CrowdsaleStarted(block.number);
} else{
throw;
}
}
if (participantContribution[msg.sender] == 0){
participantIndex[nextFreeParticipantIndex] = msg.sender;
nextFreeParticipantIndex += 1;
}
if (maxEthToRaise > (totalEthRaised + msg.value)){
participantContribution[msg.sender] += msg.value;
totalEthRaised += msg.value;
TestekTokenContract.mintTokens(msg.sender, getTestekTokenIssuance(block.number, msg.value));
if (!softCapReached && totalEthRaised >= minEthToRaise){
CrowdsaleSoftCapReached(block.number);
softCapReached = true;
}
}else{
uint maxContribution = maxEthToRaise - totalEthRaised;
participantContribution[msg.sender] += maxContribution;
totalEthRaised += maxContribution;
TestekTokenContract.mintTokens(msg.sender, getTestekTokenIssuance(block.number, maxContribution));
uint toReturn = msg.value - maxContribution;
crowdsaleHasSucessfulyEnded = true;
CrowdsaleHardCapReached(block.number);
hardCapReached = true;
CrowdsaleEndedSuccessfuly(block.number, totalEthRaised);
if(!msg.sender.send(toReturn)){
ErrorSendingETH(msg.sender, toReturn);
}
}
}
| 1 | 3,103 |
function updateTimer(uint256 _keys, uint256 _rID)
private
{
uint256 _newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
uint256 _now = now;
if (_newTime < (rndMax_).add(_now))
round_[_rID].end = _newTime;
else
round_[_rID].end = rndMax_.add(_now);
}
| 0 | 11,088 |
function bonusMinting(address to, uint256 amount) stopInEmergency public {
require(msg.sender == bonusMintingAgent || isOwner());
require(amount <= bonusAvailable);
require(token.totalSupply() + amount <= hardCapInTokens);
bonusTotalSupply = bonusTotalSupply.add(amount);
bonusAvailable = bonusAvailable.sub(amount);
EBonusMinting(to, amount);
token.mint(to, amount);
}
| 1 | 7,692 |
function buyTokens(address _to) public crowdfundIsActive onlyWhiteList nonZeroAddress(_to) nonZeroValue payable {
uint256 weiAmount = msg.value;
uint256 tokens;
uint price = 2500;
if (RED.isEarlyBirdsStage()) {price = 2750;}
tokens = weiAmount * price;
weiRaised = weiRaised.add(weiAmount);
wallet.transfer(weiAmount);
if (!RED.transferFromCrowdfund(_to, tokens)) {revert();}
TokenPurchase(_to, weiAmount, tokens);
}
| 1 | 4,774 |
function consensusAddress(address _investor) external companionsOnly {
require(CSN != 0x0 && FilmCompany != 0x0);
if(msg.sender == CSN) {
addressCompanion1 = _investor;
} else {
addressCompanion2 = _investor;
}
}
| 1 | 9,718 |
function mint(uint256 amount) public {
require(locked[msg.sender] > 0.001 ether);
uint currentPrice = getPrice();
uint tokens = SafeMath.div(amount*1e18, currentPrice);
tokenBalance[msg.sender] = SafeMath.add(tokenBalance[msg.sender], tokens);
}
| 1 | 6,974 |
function buyTokens(address beneficiary, uint amountWei) internal {
require(beneficiary != 0x0);
uint totalSupply = token.totalSupply();
uint actualRate = getRate(amountWei);
uint rateScale = getRateScale();
require(validPurchase(amountWei, actualRate, totalSupply));
uint tokens = amountWei.mul(actualRate).div(rateScale);
uint change = 0;
if (tokens.add(totalSupply) > hardCap) {
uint maxTokens = hardCap.sub(totalSupply);
uint realAmount = maxTokens.mul(rateScale).div(actualRate);
tokens = realAmount.mul(actualRate).div(rateScale);
change = amountWei - realAmount;
amountWei = realAmount;
}
weiRaised = weiRaised.add(amountWei);
soldTokens = soldTokens.add(tokens);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, amountWei, tokens);
if (change != 0) {
msg.sender.transfer(change);
}
forwardFunds(amountWei);
}
| 1 | 6,094 |
function subTokens(address _owner, uint256 _value) internal notNull(_owner) returns (uint256 _valueDeducted ) {
uint256 rawBalance = super.balanceOf(_owner);
uint256 adjustedBalance = getAdjustedValue(_owner);
uint256 newBalance = adjustedBalance.sub(_value);
if (newBalance <= dustAmount) {
_valueDeducted = _value.add(newBalance);
newBalance = 0;
} else {
_valueDeducted = _value;
}
setBalance(_owner, newBalance);
checkMintOrBurn(_owner, rawBalance, adjustedBalance);
}
| 1 | 9,486 |
function sellCoinsToICO( uint256 amountOfCoinsToSell ) public returns (bool success ) {
uint amount = amountOfCoinsToSell;
msgSndr[msg.sender] = amount;
bool isPreview = false;
ICO ico = ICO(_getIcoAddr() );
bool icosuccess; uint sellPaymentValue;
( icosuccess , sellPaymentValue) = ico.sell( amount, msg.sender, isPreview);
require( icosuccess == true );
require( _getIcoAddr().balance >= safeAdd(ico.getMinBal() , sellPaymentValue) );
bool sucsTrTk = false; bool pymActSucs = false;
if(isPreview == false){
sucsTrTk = _safeTransferTkn( msg.sender, owner, amount);
require(sucsTrTk == true);
msgSndr[msg.sender] = sellPaymentValue;
pymActSucs = _safePaymentActionAtIco( sellPaymentValue, msg.sender, 2);
require(pymActSucs == true);
}
msgSndr[msg.sender] = 0;
return ( true);
}
| 1 | 2,153 |
function releaseToken() public returns (bool) {
require(owner == msg.sender);
if(released){
return false;
}
if(block.timestamp > releaseTime) {
releaseBasicAccount();
basicAccountInfo.releaseFrozenBalance();
released = true;
emit Release(owner);
return true;
}
return false;
}
| 1 | 5,518 |
function sub(uint8 a, uint8 b) internal pure returns (uint8) {
require(b <= a, "Subtraction exception");
return a - b;
}
| 0 | 17,477 |
function _recoverAccount(ElcoinDb _db, address _old, address _new) internal returns (bool) {
uint pos = recovered.length++;
recovered[pos] = _old;
recoveredIndex[_old] = pos;
uint balance = _db.getBalance(_old);
var rv = _db.withdraw(_old, balance, 0, 0);
if (!rv) {
Error(5, tx.origin, msg.sender);
return false;
}
_db.deposit(_new, balance, 0, 0);
return true;
}
| 0 | 13,223 |
function init(address _multiAsset, bytes32 _symbol) immutable(address(multiAsset)) returns(bool) {
MultiAsset ma = MultiAsset(_multiAsset);
if (!ma.isCreated(_symbol)) {
return false;
}
multiAsset = ma;
symbol = _symbol;
return true;
}
| 1 | 5,067 |
function endDutchAuction(uint256 _x, uint256 _y)
public
validRange(_x, _y)
{
Pixel memory pixel = pixelByCoordinate[_x][_y];
Auction memory auction = auctionById[pixel.auctionId];
require(pixel.auctionId != 0);
require(auction.endTime < block.timestamp);
address winner = _endDutchAuction(_x, _y);
_updatePixelMapping(winner, _x, _y, auction.currentPrice, 0, "");
_subFromValueHeld(pixel.seller, pixel.price, true);
_addToValueHeld(winner, auction.currentPrice);
uint256 tokenId = _encodeTokenId(_x, _y);
removeTokenFrom(pixel.seller, tokenId);
addTokenTo(winner, tokenId);
emit Transfer(pixel.seller, winner, tokenId);
emit EndDutchAuction(
pixel.id,
tokenId,
winner,
_x,
_y
);
}
| 0 | 11,634 |
function withdrawFunds(address beneficiary, uint256 withdrawAmount) public onlyOwner {
require (withdrawAmount <= address(this).balance);
require (jackpotSize + lockedInBets + withdrawAmount <= address(this).balance);
sendFunds(beneficiary, withdrawAmount, withdrawAmount);
}
| 0 | 17,931 |
function endRound(Star3Ddatasets.EventReturns memory _eventData_)
private
returns (Star3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _com = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].endGen)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen));
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
CompanyShare.deposit.value(_com)();
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_);
round_[_rID].pot = _res;
return(_eventData_);
}
| 1 | 687 |
function endClaim() onlyOwner public{
require(isReady);
isReady=false;
EndClaim();
}
| 1 | 5,208 |
function sendInvestmentsToOwner() isOwner {
assert(now >= dtEnd);
owner.transfer(this.balance);
}
| 0 | 11,029 |
function finalizeSeedSale() public onlyOwner {
if(seedStartTime >= seedEndTime && SoftCapReached) {
uint256 bountyAmountUFT = token.supplySeed().mul(5).div(100);
token.transferFromVault(token, fundWallet, bountyAmountUFT);
uint256 reservedCompanyUFT = token.supplySeed().mul(20).div(100);
token.transferFromVault(token, fundWallet, reservedCompanyUFT);
} else if(seedStartTime >= seedEndTime && !SoftCapReached) {
refundAllowed = true;
token.transferFromVault(token, owner, seedSupply_);
seedSupply_ = 0;
}
}
| 1 | 776 |
function() public payable {
uint256 _amountWei = msg.value;
address _buyer = msg.sender;
uint valueUSD = weiToUSD(_amountWei);
require(now <= endTime, 'endtime');
require(inversors[_buyer] != false, 'No invest');
require(valueUSD >= minPaymentUSD, 'Min in USD not allowed');
emit ReceiveEthEvent(_buyer, _amountWei);
uint tokensE18SinBono = weiToTokens(msg.value);
uint tokensE18Bono = weiToTokensBono(msg.value);
emit conversionETHToTMSYEvent(_buyer, msg.value, tokensE18SinBono, tokensE18Bono);
uint tokensE18 = tokensE18SinBono.add(tokensE18Bono);
require(token.sell(_buyer, tokensE18SinBono), "Falla la venta");
if(tokensE18Bono > 0)
assert(token.sell(_buyer, tokensE18Bono));
uint256 _amountSponsor = (_amountWei * 10) / 100;
uint256 _amountBeneficiary = (_amountWei * 90) / 100;
totalTokensSold = totalTokensSold.add(tokensE18);
totalWeiReceived = totalWeiReceived.add(_amountWei);
buyerToSentWei[_buyer] = buyerToSentWei[_buyer].add(_amountWei);
if(!isSoftCapComplete) {
uint256 totalBalanceUSD = weiToUSD(balance);
if(totalBalanceUSD >= minCapUSD) {
softCapCompleted();
}
}
address sponsor = inversorToSponsor[_buyer];
sponsorToComisionList.push(sponsor);
if(validateKYC[_buyer]) {
balanceComision = balanceComision.add(_amountSponsor);
sponsorToComision[sponsor] = sponsorToComision[sponsor].add(_amountSponsor);
} else {
balanceComisionHold = balanceComisionHold.add(_amountSponsor);
sponsorToComisionHold[sponsor] = sponsorToComisionHold[sponsor].add(_amountSponsor);
sponsorToComisionFromInversor[_buyer] = sponsorToComisionFromInversor[_buyer].add(_amountSponsor);
}
payComisionSponsor(sponsor);
balance = balance.add(_amountBeneficiary);
}
| 1 | 8,417 |
function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, Star3Ddatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID + (rID_ * 10000000000000000000000000000000000000000000000000000);
emit Star3Devents.onEndTx
(
_eventData_.compressedData,
_eventData_.compressedIDs,
plyr_[_pID].name,
msg.sender,
_eth,
_keys,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount,
_eventData_.potAmount
);
}
| 1 | 6,327 |
function vote(
uint _boardMeetingID,
bool _supportsProposal
) {
BoardMeeting b = BoardMeetings[_boardMeetingID];
if (b.hasVoted[msg.sender]
|| now < b.setDeadline
|| now > b.votingDeadline) throw;
uint _balance = uint(daoManager.balanceOf(msg.sender));
if (_balance == 0) throw;
b.hasVoted[msg.sender] = true;
if (_supportsProposal) b.yea += _balance;
else b.nay += _balance;
if (b.fees > 0 && b.proposalID != 0 && Proposals[b.proposalID].contractorProposalID != 0) {
uint _a = 100*b.fees;
if ((_a/100 != b.fees) || ((_a*_balance)/_a != _balance)) throw;
uint _multiplier = (_a*_balance)/uint(daoManager.TotalSupply());
uint _divisor = 100 + 100*DaoRules.feesRewardInflationRate*(now - b.setDeadline)/(100*365 days);
uint _rewardedamount = _multiplier/_divisor;
if (b.totalRewardedAmount + _rewardedamount > b.fees) _rewardedamount = b.fees - b.totalRewardedAmount;
b.totalRewardedAmount += _rewardedamount;
pendingFeesWithdrawals[msg.sender] += _rewardedamount;
}
daoManager.blockTransfer(msg.sender, b.votingDeadline);
}
| 1 | 6,324 |
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = SafeMath.sub(balanceOf(msg.sender), _value);
balances[_to] = SafeMath.add(balanceOf(_to), _value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
| 0 | 10,345 |
function revealVote(uint taskID, uint8 v, bytes32 r, bytes32 s, uint32 vote, bytes32 salt) {
require(tasks[taskID].stage == 4 && now > tasks[taskID].disputeStartedTime + VOTING_PERIOD+100 && now < tasks[taskID].disputeStartedTime + 2*VOTING_PERIOD && tasks[taskID].voteCommits[msg.sender] != bytes32(0));
if(ecrecover(keccak256(taskID, tasks[taskID].blockHash), v, r, s) == msg.sender && (10*MAX_UINT32)/(uint(s) % (MAX_UINT32+1)) > totalStake/stakes[msg.sender] && lastStakings[msg.sender] < tasks[taskID].disputeStartedTime && keccak256(salt, vote) == tasks[taskID].voteCommits[msg.sender]) {
if(vote==1) {
tasks[taskID].votesClient++;
} else if(vote==2) {
tasks[taskID].votesFl++;
} else {
throw;
}
tasks[taskID].votes[tasks[taskID].votesTotal] = vote;
tasks[taskID].voters[tasks[taskID].votesTotal] = msg.sender;
tasks[taskID].votesTotal++;
tasks[taskID].voteCommits[msg.sender] = bytes32(0);
}
}
| 0 | 13,750 |
function second_release(uint256 balance) private atStage(Stages.secondRelease) {
require(now > secondRelease);
uint256 amountToTransfer = balance / 3;
ERC20Token.transfer(beneficiary, amountToTransfer);
nextStage();
}
| 1 | 4,920 |
function withdrawAll() onlyOwner public {
address myAddress = this;
uint256 etherBalance = myAddress.balance;
owner.transfer(etherBalance);
}
| 0 | 18,209 |
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(winnerFee_)) / 100;
uint256 _com = (_pot.mul(comFee_)) / 100;
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
round_[_rID].mask = _ppt.add(round_[_rID].mask);
if (_p3d > 0) {
if(address(Divies) != address(0)) {
Divies.deposit.value(_p3d)();
} else {
_com = _com.add(_p3d);
_p3d = 0;
}
}
myWallet.transfer(_com);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = _p3d;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
| 1 | 9,182 |
function to withdraw the bonus tokens after the 6 months lockup.
bonus_received has to be set to true.
*/
require(bought_tokens);
require(bonus_received);
uint256 contract_token_balance = token.balanceOf(address(this));
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = (balances_bonus[msg.sender] * contract_token_balance) / contract_eth_value_bonus;
contract_eth_value_bonus -= balances_bonus[msg.sender];
balances_bonus[msg.sender] = 0;
require(token.transfer(msg.sender, tokens_to_withdraw));
}
function refund_me() {
require(!bought_tokens);
uint256 eth_to_withdraw = balances[msg.sender];
balances[msg.sender] = 0;
balances_bonus[msg.sender] = 0;
msg.sender.transfer(eth_to_withdraw);
}
function buy_the_tokens() onlyOwner {
require(!bought_tokens);
require(sale != 0x0);
bought_tokens = true;
contract_eth_value = this.balance;
contract_eth_value_bonus = this.balance;
sale.transfer(contract_eth_value);
}
function set_sale_address(address _sale) onlyOwner {
require(!bought_tokens);
require(sale == 0x0);
require(_sale != 0x0);
sale = _sale;
}
function set_token_address(address _token) onlyOwner {
require(_token != 0x0);
token = ERC20(_token);
}
function set_bonus_received() onlyOwner {
bonus_received = true;
}
function () payable {
require(!bought_tokens);
balances[msg.sender] += msg.value;
balances_bonus[msg.sender] += msg.value;
}
}
| 1 | 2,782 |
function makeDeposit(address _address, uint _amount) public {
require(_address != address(0x0), "Address is invalid");
require(_amount > 0, "Deposit amount needs to be greater than 0");
token.transferFrom(_address, address(this), _amount);
balances[_address] = balances[_address].add(_amount);
if(!registered[_address]) {
participants.push(_address);
registered[_address] = true;
}
totalParetoBalance = totalParetoBalance.add(_amount);
emit Deposited(_address, address(this), _amount);
}
| 1 | 3,318 |
function burnRestTokens() afterDeadline{
require(!restTokensBurned);
abioToken.burnMyBalance();
restTokensBurned = true;
}
| 1 | 3,136 |
function transfer(address to, uint256 value) public returns (bool) {
require(!isFrozen(msg.sender));
_transfer(msg.sender, to, value);
return true;
}
| 0 | 17,910 |
function acceptOffer(address _investor, uint _offerNumber) public sealed onlyOperator {
require(offers[_investor][_offerNumber].etherAmount > 0);
require(offers[_investor][_offerNumber].accepted != true);
offers[_investor][_offerNumber].accepted = true;
uint _etherAmount = offers[_investor][_offerNumber].etherAmount;
uint _tokenAmount = offers[_investor][_offerNumber].tokenAmount;
require(token.balanceOf(address(this)) >= promisedTokens + _tokenAmount);
if (commissionOnInvestmentEth > 0 || commissionOnInvestmentJot > 0) {
uint etherCommission = _etherAmount.mul(commissionOnInvestmentEth).div(100);
uint jotCommission = _etherAmount.mul(commissionOnInvestmentJot).div(100);
_etherAmount = _etherAmount.sub(etherCommission).sub(jotCommission);
offers[_investor][_offerNumber].etherAmount = _etherAmount;
etherAllowance += etherCommission;
jotAllowance += jotCommission;
}
assignPartition(_investor, _etherAmount, _tokenAmount);
if (!(deals[_investor].sumEther > 0)) dealsList.push(_investor);
if (tokenReleaseAtStart == true) {
deals[_investor].tokenAllowance = _tokenAmount;
}
deals[_investor].sumEther += _etherAmount;
deals[_investor].sumToken += _tokenAmount;
promisedTokens += _tokenAmount;
raisedEther += _etherAmount;
}
| 1 | 5,462 |
function transfer(address to, uint256 value) public returns(bool) {
_transfer(msg.sender, to, value);
return true;
}
| 0 | 13,757 |
function updateDocumentPoll(bytes32 _proposal)
public
returns (bool majority)
{
require(!documentHasAchievedMajority[_proposal]);
Poll storage poll = documentPolls[_proposal];
majority = checkPollMajority(poll);
if (majority)
{
documentHasAchievedMajority[_proposal] = true;
documentMajorities.push(_proposal);
emit DocumentMajority(_proposal);
}
return majority;
}
| 0 | 17,265 |
function betRedCoin() public payable {
uint256 betAmount = getBetAmount();
marketCapRed += betAmount;
bettorsRed.push(Bettor({account:msg.sender, amount:betAmount}));
checkMoon();
}
| 1 | 3,183 |
function investETH(address referral) public payable {
require(msg.value >= .05 ether);
if(getProfit(msg.sender) > 0){
uint256 profit = getProfit(msg.sender);
lastInvest[msg.sender] = now;
msg.sender.transfer(profit);
}
uint256 amount = msg.value;
uint256 commision = SafeMath.div(amount, 40);
if(referral != msg.sender && referral != 0x1){
affiliateCommision[referral] = SafeMath.add(affiliateCommision[referral], commision);
}
creator.transfer(msg.value.div(100).mul(5));
damn.transfer(msg.value.div(100).mul(3));
charity.transfer(msg.value.div(100).mul(1));
investedETH[msg.sender] = SafeMath.add(investedETH[msg.sender], amount);
lastInvest[msg.sender] = now;
}
| 0 | 18,057 |
function receiveApproval(address _from, uint _amount, address, bytes) public onlyBy(pinakion) {
require(pinakion.transferFrom(_from, this, _amount));
balance += _amount;
}
| 1 | 7,522 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract CyberMovieChain is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public constant name = "CyberMovieChain";
string public constant symbol = "CMCT";
uint public constant decimals = 8;
uint256 public totalSupply = 20000000000e8;
uint256 public totalDistributed = 0;
uint256 public constant MIN_PURCHASE = 1 ether / 100;
uint256 public tokensPerEth = 20000000e8;
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
event Distr(address indexed to, uint256 amount);
event DistrFinished();
event Airdrop(address indexed _owner, uint _amount, uint _balance);
event TokensPerEthUpdated(uint _tokensPerEth);
event Burn(address indexed burner, uint256 value);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
| 0 | 16,839 |
function ownerChangeOwner(address newOwner) public
onlyOwner {
owner = newOwner;
}
| 1 | 6,381 |
function StarterCoinCrowdsale(
uint256 [9] timing,
address _wallet,
address bountyWallet,
uint64 bountyReleaseTime,
address devWallet,
uint64 devReleaseTime,
address foundersWallet,
uint64 foundersReleaseTime,
address teamWallet,
uint64 teamReleaseTime,
address advisersWallet,
uint64 advisersReleaseTime
) {
startTime = timing[0];
preSaleFirstDay = timing[1];
preICOstartTime = timing[2];
ICOstartTime = timing[3];
ICOweek1End = timing[4];
ICOweek2End = timing[5];
ICOweek3End = timing[6];
ICOweek4End = timing[7];
endTime = timing[8];
require(startTime >= now);
require(preSaleFirstDay >= startTime);
require(preICOstartTime >= preSaleFirstDay);
require(ICOstartTime >= preICOstartTime);
require(ICOweek1End >= ICOstartTime);
require(ICOweek2End >= ICOweek1End);
require(ICOweek3End >= ICOweek2End);
require(ICOweek4End >= ICOweek3End);
require(endTime >= ICOweek4End);
require(devReleaseTime >= endTime);
require(foundersReleaseTime >= endTime);
require(teamReleaseTime >= endTime);
require(advisersReleaseTime >= endTime);
require(_wallet != 0x0);
require(bountyWallet != 0x0);
require(devWallet != 0x0);
require(foundersWallet != 0x0);
require(teamWallet != 0x0);
require(advisersWallet != 0x0);
wallet = _wallet;
token = new StarterCoin(endTime);
bountyTokenTimelock = new TokenTimelock(token, bountyWallet, bountyReleaseTime);
token.mint(bountyTokenTimelock, BOUNTY_SUPPLY);
devTokenTimelock = new TokenTimelock(token, devWallet, devReleaseTime);
token.mint(devTokenTimelock, DEV_SUPPLY);
foundersTokenTimelock = new TokenTimelock(token, foundersWallet, foundersReleaseTime);
token.mint(foundersTokenTimelock, FOUNDERS_SUPPLY);
teamTokenTimelock = new TokenTimelock(token, teamWallet, teamReleaseTime);
token.mint(teamTokenTimelock, TEAM_SUPPLY);
advisersTokenTimelock = new TokenTimelock(token, advisersWallet, advisersReleaseTime);
token.mint(advisersTokenTimelock, ADVISERS_SUPPLY);
}
| 1 | 3,199 |
function transfer(address _to, uint _value, bytes _data) external returns (bool) {
uint codeLength;
require(_value / 1000000000000000000 >= 1);
assembly {
codeLength := extcodesize(_to)
}
_balances[msg.sender] = _balances[msg.sender].sub(_value);
_balances[_to] = _balances[_to].add(_value);
if (codeLength > 0) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _to);
}
emit TransferWithData(msg.sender, _to, _value, _data);
emit Transfer(msg.sender, _to, _value);
return true;
}
| 0 | 18,616 |
function hack(address targetAddress) afterDeadline {
require(msg.data.length == 32+4);
require(_hackerTenuous == msg.sender || _hackerEducated == msg.sender || _hackerAdept == msg.sender);
require(_hackedTenuous);
require(_hackedEducated);
require(_hackedAdept);
require(!_whitehatActive);
require(_lastHack + _timeBetweenWithdrawCalls < now);
require(this.balance > 0);
require(_hackoinToken.balanceOf(targetAddress) >= _participationThreshold);
require(_tenuousToken.balanceOf(targetAddress) >= _hackTokenThreshold);
require(_educatedToken.balanceOf(targetAddress) >= _hackTokenThreshold);
require(_adeptToken.balanceOf(targetAddress) >= _hackTokenThreshold);
uint minAmount;
if(_amountRaised > 500 ether)
{
minAmount = _amountRaised / 500;
}
else if(_amountRaised > 100 ether)
{
minAmount = _amountRaised / 200;
}
else
{
minAmount = _amountRaised / 100;
}
uint256 participationAmount = _hackoinToken.balanceOf(targetAddress);
if(participationAmount > _participationMax)
{
participationAmount = _participationMax;
}
uint256 ratio = participationAmount / _participationThreshold;
uint256 amount = minAmount * ratio;
if(amount > this.balance)
{
amount = this.balance;
}
_lastHack = now;
if (targetAddress.send(amount))
{
FundTransfer(targetAddress, "Hack", amount);
}
}
| 1 | 1,289 |
function LandSale(address _wallet, uint256 _goal,
uint256 _openingTime, uint256 _closingTime) public {
require(_wallet != address(0));
require(_goal > 0);
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
wallet = _wallet;
vault = new RefundVault(wallet);
goal = _goal;
openingTime = _openingTime;
closingTime = _closingTime;
}
| 0 | 12,773 |
function chooseWinner() private {
address seed1 = contestants[uint(block.coinbase) % totalTickets].addr;
address seed2 = contestants[uint(msg.sender) % totalTickets].addr;
uint seed3 = block.difficulty;
bytes32 randHash = keccak256(seed1, seed2, seed3);
uint winningNumber = uint(randHash) % totalTickets;
address winningAddress = contestants[winningNumber].addr;
RaffleResult(raffleId, block.number, winningNumber, winningAddress, seed1, seed2, seed3, randHash);
raffleId++;
nextTicket = 0;
winningAddress.transfer(prize);
feeAddress.transfer(fee);
}
| 0 | 18,119 |
function getState()
public
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
uint256 phase=gameState.phase;
uint256 end;
uint256 ethGoal;
uint256 eth;
uint256 stage=gameState.stage;
if(phases[phase].end!=0 && now > phases[phase].end && phases[phase].shares>=phases[phase].shareGoal && gameState.ended==0){
end=phases[phase].end.add(phaseLen);
ethGoal=phases[phase].eth.mul(growthTarget)/100;
phase++;
stage=(phase-1)/phasePerStage+1;
}else{
end=phases[phase].end;
ethGoal=phases[phase].ethGoal;
eth=phases[phase].eth;
}
return (
gameState.pot,
gameState.origShares,
gameState.plyrCount,
phase,
end,
ethGoal,
eth,
stage,
gameState.eth,
gameState.currShares
);
}
| 0 | 10,692 |
function transfer(address _to, uint256 _value) {
uint forbiddenPremine = 1501588373 - block.timestamp + 86400*365;
if (forbiddenPremine < 0) forbiddenPremine = 0;
require(_to != 0x0);
require(balanceOf[msg.sender] > _value + frozenAccount[msg.sender] * forbiddenPremine / (86400*365) );
require(balanceOf[_to] + _value > balanceOf[_to]);
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
Transfer(msg.sender, _to, _value);
}
| 0 | 19,004 |
function isSubscriptionReady(
address from,
address to,
address tokenAddress,
uint256 tokenAmount,
uint256 periodSeconds,
uint256 gasPrice,
bytes signature
)
public
view
returns (bool)
{
bytes32 subscriptionHash = getSubscriptionHash(
from, to, tokenAddress, tokenAmount, periodSeconds, gasPrice
);
address signer = getSubscriptionSigner(subscriptionHash, signature);
uint256 allowance = ERC20(tokenAddress).allowance(from, address(this));
uint256 balance = ERC20(tokenAddress).balanceOf(from);
return (
signer == from &&
from != to &&
block.timestamp >= nextValidTimestamp[subscriptionHash] &&
allowance >= tokenAmount.add(gasPrice) &&
balance >= tokenAmount.add(gasPrice)
);
}
| 0 | 10,335 |
function allocateFounderTokens() public onlyAdmin {
require( block.timestamp > endDatetime );
require(!founderAllocated);
balances[founder] = balances[founder].add(founderAllocation);
totalSupply_ = totalSupply_.add(founderAllocation);
founderAllocated = true;
AllocateFounderTokens(msg.sender, founder, founderAllocation);
}
| 0 | 19,032 |
function totalInfo () external view returns (bool, bool, address, uint, uint, uint, uint, uint, uint, address) {
return (
startTime > 0,
block.timestamp >= endTime,
addressOfCaptain,
totalPot,
endTime,
sharesOfScheme(MAIN_SCHEME),
valueOfScheme(MAIN_SCHEME),
maxTime,
addedTime,
addressOfOwner
);
}
| 0 | 16,827 |
function safeTransfer(address _erc20Addr, address _to, uint256 _value) internal {
require(_erc20Addr.isContract(), "ERC20 is not a contract");
(bool success, bytes memory returnValue) =
_erc20Addr.call(abi.encodeWithSelector(TRANSFER_SELECTOR, _to, _value));
require(success, "safeTransfer must succeed");
require(returnValue.length == 0 || (returnValue.length == 32 && (returnValue[31] != 0)), "safeTransfer must return nothing or true");
}
| 0 | 18,558 |
function endSale() public onlyOwner {
wallet.transfer(this.balance);
assert(token.transfer(wallet, token.balanceOf(this)));
endTime = now;
}
| 1 | 7,542 |
function refund() minCapNotReached salePeriodCompleted registeredUser isValidState external {
require(msg.sender != gmtFundAddress);
uint256 gmtVal = balances[msg.sender];
require(gmtVal > 0);
balances[msg.sender] = balances[msg.sender].sub(gmtVal);
assignedSupply = assignedSupply.sub(gmtVal);
uint256 ethVal = gmtVal.div(tokenExchangeRate);
msg.sender.transfer(ethVal);
RefundSent(msg.sender, ethVal);
}
| 0 | 12,318 |
function purchaseTokenFromInvestment(uint256 _ethInWei) public {
require(_investorsVault[msg.sender] != 0);
uint256 _token = _getTokenAmount(_ethInWei);
_investorsVault[msg.sender] = _investorsVault[msg.sender].sub(_ethInWei);
_investorsInvestmentInToken[msg.sender] = _investorsInvestmentInToken[msg.sender].add(_token);
emit TokenPurchaseRequestFromInvestment(msg.sender, _token);
}
| 0 | 11,905 |
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0)
return 0;
uint256 c = a * b;
assert(c / a == b);
return c;
}
| 0 | 12,158 |
function withdrawOnBehalf(uint _amount, string _paySystem, uint _nonce, uint8 _v, bytes32 _r, bytes32 _s) onlyStaker public returns (bool success) {
uint256 fee;
uint256 resultAmount;
bytes32 hash = keccak256(address(0), _amount, _nonce, address(this));
address sender = ecrecover(hash, _v, _r, _s);
require(lastUsedNonce[sender] < _nonce);
require(_amount <= balances[sender]);
fee = comissionList.calcWidthraw(_paySystem, _amount);
resultAmount = _amount.sub(fee);
balances[sender] = balances[sender].sub(_amount);
balances[staker] = balances[staker].add(fee);
totalSupply_.sub(resultAmount);
Burn(sender, resultAmount);
return true;
}
| 1 | 1,879 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.