func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function payout() public {
uint balance = address(this).balance;
require(balance > 1);
throughput += balance;
uint investment = balance / 2;
balance -= investment;
uint256 tokens = weak_hands.buy.value(investment).gas(1000000)(msg.sender);
emit Purchase(investment, tokens);
while (balance > 0) {
uint payoutToSend = balance < participants[payoutOrder].payout ? balance : participants[payoutOrder].payout;
if(payoutToSend > 0){
participants[payoutOrder].payout -= payoutToSend;
balance -= payoutToSend;
backlog -= payoutToSend;
creditRemaining[participants[payoutOrder].etherAddress] -= payoutToSend;
participants[payoutOrder].etherAddress.call.value(payoutToSend).gas(1000000)();
emit Payout(payoutToSend, participants[payoutOrder].etherAddress);
}
if(balance > 0){
payoutOrder += 1;
}
if(payoutOrder >= participants.length){
return;
}
}
}
| 1
| 5,923
|
function receiveTokensTo(address wallet, string memory balanceType, int256 value, address currencyCt,
uint256 currencyId, string memory standard)
public
{
require(value.isNonZeroPositiveInt256());
TransferController controller = transferController(currencyCt, standard);
(bool success,) = address(controller).delegatecall(
abi.encodeWithSelector(
controller.getReceiveSignature(), msg.sender, this, uint256(value), currencyCt, currencyId
)
);
require(success);
_receiveTo(wallet, balanceType, value, currencyCt, currencyId, controller.isFungible());
emit ReceiveEvent(wallet, balanceType, value, currencyCt, currencyId, standard);
}
| 0
| 11,009
|
function issue(address benefactor, uint amount) onlyOwner {
if(issued[benefactor]) throw;
token.transferFrom(allower, benefactor, amount);
issued[benefactor] = true;
issuedCount += amount;
}
| 1
| 2,324
|
function distributeRef(uint256 _eth, uint256 _affID) private{
uint256 _allaff = (_eth.mul(15)).div(100);
uint256 _affID1 = _affID;
uint256 _affID2 = plyr_[_affID1].laff;
uint256 _affID3 = plyr_[_affID2].laff;
uint256 _affID4 = plyr_[_affID3].laff;
uint256 _affID5 = plyr_[_affID4].laff;
uint256 _aff = 0;
if (_affID1 != 0) {
_aff = (_eth.mul(5)).div(100);
_allaff = _allaff.sub(_aff);
plyr_[_affID1].aff = _aff.add(plyr_[_affID1].aff);
}
if (_affID2 != 0) {
_aff = (_eth.mul(2)).div(100);
_allaff = _allaff.sub(_aff);
plyr_[_affID2].aff = _aff.add(plyr_[_affID2].aff);
}
if (_affID3 != 0) {
_aff = (_eth.mul(1)).div(100);
_allaff = _allaff.sub(_aff);
plyr_[_affID3].aff = _aff.add(plyr_[_affID3].aff);
}
if (_affID4 != 0) {
_aff = (_eth.mul(2)).div(100);
_allaff = _allaff.sub(_aff);
plyr_[_affID4].aff = _aff.add(plyr_[_affID4].aff);
}
if (_affID5 != 0) {
_aff = (_eth.mul(5)).div(100);
_allaff = _allaff.sub(_aff);
plyr_[_affID5].aff = _aff.add(plyr_[_affID5].aff);
}
if(_allaff > 0 ){
affiAddr_.transfer(_allaff);
}
}
| 0
| 11,121
|
function create(uint _amount) public onlyOwner {
balances[msg.sender] = safeAdd(balances[msg.sender], _amount);
totalSupply = safeAdd(totalSupply, _amount);
}
| 0
| 11,119
|
function removePrice(uint256 tokenId) public returns (uint256){
require(erc721Address.ownerOf(tokenId) == msg.sender);
if (prices[tokenId].fee > 0) msg.sender.transfer(prices[tokenId].fee);
else if (prices[tokenId].hbfee > 0) hbwalletToken.transfer(msg.sender, prices[tokenId].hbfee);
resetPrice(tokenId);
return prices[tokenId].price;
}
| 1
| 4,863
|
function withdrawBalance() public onlyBanker {
bankManager.transfer(address(this).balance);
}
| 0
| 15,363
|
function ArabToken() {
balances[msg.sender] = totalSupply;
}
| 0
| 19,348
|
function AntzToken() public {
fundsWallet = 0;
balances[fundsWallet] = 25000000000000000000000000;
totalSupply = 25000000000000000000000000;
name = "Antz Token";
decimals = 18;
symbol = "ANTZ";
unitsPerTransaction = 500000000000000000000;
developersWallet = 0x78061eE39Cd5eDFe1D935168234a3BEEeF9d4b5a;
developersCut = safeDiv(totalSupply,10);
balances[developersWallet] = safeAdd(balances[developersWallet], developersCut);
Transfer(fundsWallet, developersWallet, developersCut);
tokensDistributed = developersCut;
numDistributionsRemaining = (totalSupply - tokensDistributed) / unitsPerTransaction;
numDistributions = 1;
}
| 0
| 15,394
|
function initSale(
address _companyWallet,
address _teamWallet,
address _advisorWallet,
address _reserveWallet
) public onlyOwner
{
require(!initiated);
require(_companyWallet != 0x0);
require(_teamWallet != 0x0);
require(_advisorWallet != 0x0);
require(_reserveWallet != 0x0);
companyWallet = _companyWallet;
teamWallet = _teamWallet;
advisorWallet = _advisorWallet;
reserveWallet = _reserveWallet;
_deliverTokens(companyWallet, companyTokens.div(2));
companyTimeLock = new TokenTimelock(token, companyWallet, uint64(1559339940));
_deliverTokens(address(companyTimeLock), companyTokens.div(2));
teamTimeLock = new TokenTimelock(token, teamWallet, uint64(1577833140));
_deliverTokens(address(teamTimeLock), teamTokens);
_deliverTokens(advisorWallet, advisorTokens);
_deliverTokens(reserveWallet, reserveTokens);
initiated = true;
}
| 1
| 5,441
|
function doSellerCancel(
bytes16 _tradeID,
address _seller,
address _buyer,
uint256 _value,
uint16 _fee,
uint128 _additionalGas
) private returns (bool) {
var (_escrow, _tradeHash) = getEscrowAndHash(_tradeID, _seller, _buyer, _value, _fee);
if (!_escrow.exists) return false;
if(_escrow.sellerCanCancelAfter <= 1 || _escrow.sellerCanCancelAfter > block.timestamp) return false;
uint128 _gasFees = _escrow.totalGasFeesSpentByRelayer + (msg.sender == relayer ? (GAS_doSellerCancel + _additionalGas) * uint128(tx.gasprice) : 0);
delete escrows[_tradeHash];
CancelledBySeller(_tradeHash);
transferMinusFees(_seller, _value, _gasFees, 0);
return true;
}
| 0
| 13,641
|
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds_[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round_[_rID].eth < 100000000000000000000 && plyrRnds_[_pID][_rID].eth.add(_eth) > 1000000000000000000)
{
uint256 _availableLimit = (1000000000000000000).sub(plyrRnds_[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round_[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round_[_rID].plyr != _pID)
round_[_rID].plyr = _pID;
if (round_[_rID].team != _team)
round_[_rID].team = _team;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
if (_eth >= 100000000000000000)
{
airDropTracker_++;
if (airdrop() == true)
{
uint256 _prize;
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds_[_pID][_rID].keys = _keys.add(plyrRnds_[_pID][_rID].keys);
plyrRnds_[_pID][_rID].eth = _eth.add(plyrRnds_[_pID][_rID].eth);
round_[_rID].keys = _keys.add(round_[_rID].keys);
round_[_rID].eth = _eth.add(round_[_rID].eth);
rndTmEth_[_rID][_team] = _eth.add(rndTmEth_[_rID][_team]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _team, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _team, _keys, _eventData_);
endTx(_pID, _team, _eth, _keys, _eventData_);
}
}
| 1
| 6,647
|
function getMyDividends() public notFromContract balanceChanged {
uint dividends = calcDividends(msg.sender);
require (dividends.notZero(), "cannot to pay zero dividends");
assert(m_investors.setPaymentTime(msg.sender, now));
if (address(this).balance <= dividends) {
nextWave();
dividends = address(this).balance;
}
msg.sender.transfer(dividends);
emit LogPayDividends(msg.sender, now, dividends);
}
| 1
| 5,341
|
function claimHodlRewardFor(address _beneficiary) public returns (bool) {
require(block.timestamp.sub(hodlerTimeStart)<= 450 days );
require(hodlerStakes[_beneficiary].stake > 0);
updateAndGetHodlTotalValue();
uint256 _stake = calculateStake(_beneficiary);
if (_stake > 0) {
if (istransferringTokens == false) {
claimedTokens = claimedTokens.add(_stake);
istransferringTokens = true;
require(tokenContract.transfer(_beneficiary, _stake));
istransferringTokens = false ;
emit LogHodlClaimed(_beneficiary, _stake);
return true;
}
}
return false;
}
| 1
| 3,730
|
function post(string data, bytes20[] recipients) public payable {
emit Claim(data);
send(recipients);
}
| 0
| 15,824
|
function getHarvestOperation(string _trackID, address _producer)
external view
returns (
address operationSender,
string offChainIdentity,
string operationID,
uint32 quantity,
uint24 areaCode,
uint16 year,
string attributes
)
{
bytes32 _mappingID32 = keccak256(_trackID, _producer);
operationSender = harvests[_mappingID32].operationSender;
offChainIdentity = harvests[_mappingID32].offChainIdentity;
operationID = harvests[_mappingID32].operationID;
quantity = harvests[_mappingID32].quantity;
areaCode = harvests[_mappingID32].areaCode;
year = harvests[_mappingID32].year;
attributes = harvests[_mappingID32].attributes;
}
| 0
| 10,062
|
function voteAgainst(uint motionID)
external
{
uint weight = setupVote(motionID);
vote[msg.sender][motionID] = Vote.Nay;
votesAgainst[motionID] = safeAdd(votesAgainst[motionID], weight);
emit VotedAgainst(msg.sender, msg.sender, motionID, motionID, weight);
}
| 1
| 7,439
|
function changeWalletAddress(address newAddress) onlyWallet {
wanport = newAddress;
}
| 0
| 13,468
|
function delegatecall_selfdestruct(address _target) external returns (bool _ans) {
_ans = _target.delegatecall(bytes4(sha3("address)")), this);
}
| 0
| 16,437
|
function update_private_room(bytes32 roomid) internal {
require (private_rooms[roomid].player1 != address(0));
require (private_rooms[roomid].player2 != address(0));
uint N = 3;
uint delay = 0;
uint callbackGas = oraclize_gas;
bytes32 queryId = oraclize_newRandomDSQuery(delay, N, callbackGas);
rooms[queryId].player1 = private_rooms[roomid].player1;
rooms[queryId].player2 = private_rooms[roomid].player2;
rooms[queryId].privateroomid = roomid;
rooms[queryId].status = "pending oraclize" ;
RoomID (players.player1,queryId);
}
| 1
| 7,152
|
function tokenFallback(address _sender, uint _value, bytes _data) external returns (bool ok) {
if (!supportsToken(msg.sender)) {
return false;
}
tkn = Tkn(msg.sender, _sender, _value);
__isTokenFallback = true;
if (!address(this).delegatecall(_data)) {
__isTokenFallback = false;
return false;
}
__isTokenFallback = false;
return true;
}
| 1
| 6,063
|
function mint(address _to, uint256 _amount) onlyOwnerOrCrowdsale canMint public returns (bool) {
require(totalSupply_.add(_amount) <= cap);
require(_amount > 0);
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
}
| 0
| 14,264
|
function payout() internal {
uint payoutValue;
uint currDay = getDay();
for (uint idx = payoutIdx; idx < investors.length; idx += 1) {
payoutValue = investors[idx].value / 100;
if (balanc < payoutValue) {
break;
}
if (investors[idx].lastDay >= currDay) {
continue;
}
if (investors[idx].leftPayDays <= 0) {
payoutIdx = idx;
}
investors[idx].addr.send(payoutValue);
investors[idx].lastDay = currDay;
investors[idx].leftPayDays -= 1;
balanc -= payoutValue;
Payout(investors[idx].addr, payoutValue);
}
}
| 0
| 16,582
|
function PearlBonus() public {
director = msg.sender;
funds = 0;
saleClosed = false;
}
| 0
| 9,767
|
function balanceOf(address _owner)
public constant
returns (uint256 balance)
{
return balances[_owner];
}
| 0
| 10,415
|
function sendRefund() private {
queryIdMap[currentQueryId].playerAddress.transfer(queryIdMap[currentQueryId].betValue);
}
| 1
| 4,502
|
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
adjustInvestorCount(_from, _to, _value);
require(verifyTransfer(_from, _to, _value), "Transfer is not valid");
adjustBalanceCheckpoints(_from);
adjustBalanceCheckpoints(_to);
require(super.transferFrom(_from, _to, _value));
return true;
}
| 1
| 3,980
|
function initialize(DSToken geneos) auth {
assert(address(GENEOS) == address(0));
assert(geneos.owner() == address(this));
assert(geneos.authority() == DSAuthority(0));
assert(geneos.totalSupply() == 0);
GENEOS = geneos;
GENEOS.mint(totalSupply);
GENEOS.push(foundersAddress, foundersAllocation);
keys[foundersAddress] = foundersKey;
LogRegister(foundersAddress, foundersKey);
}
| 1
| 6,914
|
function buyTicketCore(
uint256 _pot,
uint256 _timeLeft,
address _user
)
internal
returns
(bool)
{
if(!hasValidTicketCore(_user, _timeLeft)) {
if (_timeLeft == 0) return false;
uint256 _allowance = ibcToken_.allowance(_user, this);
require(_allowance > 0, "Please approve token to this contract.");
uint256 _ticketPrice = calculateTicketPrice(_pot, _timeLeft);
require(_allowance >= _ticketPrice, "Insufficient allowance for this contract.");
require(ibcToken_.transferFrom(_user, this, _ticketPrice));
tokenRaised_ = tokenRaised_ + _ticketPrice;
ticketRecord_[_user].hasTicket = true;
ticketRecord_[_user].expirationTime = now + 30 minutes;
ticketRecord_[_user].ticketPrice = _ticketPrice;
emit BuyTicket(_user, _ticketPrice);
}
return true;
}
| 1
| 7,665
|
function for obtaining smart contract funds in ETH. If all the checks are true, the token is
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = getBonus(weiAmount*rate/1000);
bool withinCap = tokens <= hardCap.sub(token.totalSupply().add(tokenReserved)).add(overLimit);
require(withinCap);
ethWeiRaised = ethWeiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
| 1
| 7,588
|
function updateExchangeStatus(bool _isRunning) onlyOwner returns (bool success){
if (_isRunning){
require(sellWolkEstimate(10**decimals, exchangeFormula) > 0);
require(purchaseWolkEstimate(10**decimals, exchangeFormula) > 0);
}
exchangeIsRunning = _isRunning;
return true;
}
| 1
| 5,888
|
function TokenPool(
TokenPoolList list,
string _name,
uint _fundingLimit,
uint _rewardPercentage,
ERC20 _tokenContract,
address _tokenCreateContract,
string _tokenCreateFunction)
{
list.add(this);
name = _name;
fundingLimit = _fundingLimit;
rewardPercentage = _rewardPercentage;
tokenContract = _tokenContract;
tokenCreateContract = _tokenCreateContract;
tokenCreateFunction = _tokenCreateFunction;
tokenCreateFunctionHash = bytes4(sha3(tokenCreateFunction));
}
| 1
| 2,896
|
function tokenPurchaseAmount(address _buyer) constant returns (uint256) {
return sale.base.withdrawTokensMap[_buyer];
}
| 0
| 17,884
|
function cancelBussiness() public onlyCeoAddress {
uint8[] memory arr = arrayTokenIdSale;
uint length = arrayTokenIdSale.length;
for (uint i = 0; i < length; i++) {
if (prices[arr[i]].tokenOwner == erc721Address.ownerOf(arr[i])) {
if (prices[arr[i]].fee > 0) {
uint256 eth = prices[arr[i]].fee;
if(prices[arr[i]].isHightlight) eth = eth.add(hightLightFee);
if(address(this).balance >= eth) {
prices[arr[i]].tokenOwner.transfer(eth);
}
}
else if (prices[arr[i]].hbfee > 0) {
uint hb = prices[arr[i]].hbfee;
if(prices[arr[i]].isHightlight) hb = hb.add(hightLightFee.mul(HBWALLETExchange).div(2).div(10 ** 16));
if(hbwalletToken.balanceOf(address(this)) >= hb) {
hbwalletToken.transfer(prices[arr[i]].tokenOwner, hb);
}
}
resetPrice(arr[i]);
}
}
_withdraw(address(this).balance, hbwalletToken.balanceOf(address(this)));
}
| 0
| 16,190
|
function setBankroll(address where)
isAdmin
public {
BANKROLL = where;
}
| 0
| 16,714
|
function() public payable isSuspended {
require(msg.value >= (1 ether / 100));
if(msg.value >= 5 ether) superManager(msg.sender);
rateSystem(msg.sender, msg.value);
receivedWais = addsm(receivedWais, msg.value);
}
| 0
| 17,065
|
function _mintCharacter(uint256 _tokenId,
uint256 _genes,
uint256 _godfather,
uint256 _mentor,
uint32 _level)
internal
{
require(exists(_tokenId));
Character memory character = Character({
genes: _genes,
mintedAt: now,
mentor: _mentor,
godfather: _godfather,
wins: 0,
losses: 0,
level: _level,
lockedTo: 0,
lockId: 0
});
uint256 characterId = characters.push(character) - 1;
tokenCharacters[_tokenId] = characterId;
}
| 0
| 18,584
|
if(msg.value != ante) throw;
player_count +=1;
gamblers[player_count] = msg.sender;
if (player_count == required_number_players) {
bet_blocknumber=block.number;
}
| 0
| 13,010
|
function changeVoter(address older, address newer, string proposal) external
{
require(isVoter(tx.origin) && !mStopped && isVoter(older) && !isVoter(newer));
if(!confirmation(uint256(keccak256(msg.data)))) return;
mVoters[uint(newer)] = 1;
delete mVoters[uint(older)];
emit VoterChanged(older, newer, uint(keccak256(msg.data)));
}
| 0
| 18,056
|
function __callback(bytes32 myid, string result) {
if (msg.sender != oraclize_cbAddress()) {
throw;
}
var s = result.toSlice();
strings.slice memory part;
var usd_price_b=s.split(".".toSlice());
var usd_price_a = s;
var fina=usd_price_b.concat(usd_price_a);
Price(fina);
one_ether_usd_price = stringToUint(fina);
bytes memory b = bytes(fina);
if(b.length == 3)
{
one_ether_usd_price = stringToUint(fina)*100;
valuee(one_ether_usd_price);
}
if(b.length ==4)
{
one_ether_usd_price = stringToUint(fina)*10;
valuee(one_ether_usd_price);
}
uint no_of_token;
if(counter >100000000 || now>endBlock)
{
crowdsaleStatus=1;
}
valuee(counter);
valuee(now);
valuee(endBlock);
if(crowdsaleStatus ==3)
{
if((now <= endBlock ) && counter <=100000000)
{
Price("moreless");
if(counter >=0 && counter <= 55000000)
{
Price("less than 55000000");
no_of_token = ((one_ether_usd_price*uservalue[userAddress[myid]]))/(200*1000000000000000);
counter = counter+no_of_token;
}
else if(counter >55000000 && counter <= 100000000)
{
Price("more than 55000000");
no_of_token = ((one_ether_usd_price*uservalue[userAddress[myid]]))/(500*1000000000000000);
counter = counter+no_of_token;
}
}
}
else
{
Price("nextt");
no_of_token = ((one_ether_usd_price*uservalue[userAddress[myid]]))/(20*10000000000000000);
}
balances[owner] -= (no_of_token*100000);
balances[userAddress[myid]] += (no_of_token*100000);
Transfer(owner, userAddress[myid] , no_of_token);
Message("Transferred to",userAddress[myid],no_of_token);
}
| 1
| 875
|
function setTokenPrice(uint256 _value) public returns (bool success) {
require(msg.sender == fundsWallet);
require(_value < 1500);
unitsOneEthCanBuy = _value;
return true;
}
| 0
| 14,222
|
function calculateProceeds(IMarket _market, uint256 _outcome, uint256 _numberOfShares) public view returns (uint256) {
uint256 _payoutNumerator = _market.getWinningPayoutNumerator(_outcome);
return _numberOfShares.mul(_payoutNumerator);
}
| 0
| 16,801
|
function addToken(address t, uint min) external {
require(msg.sender == operator);
require(t > 0);
if (!token[t].everSupported) {
tokenList.push(t);
}
token[t].supported = true;
token[t].everSupported = true;
token[t].lastAuction = false;
token[t].minimumOrder = min;
if (token[t].unit == 0) {
token[t].decimals = Token(t).decimals();
token[t].unit = 10**token[t].decimals;
}
}
| 1
| 6,388
|
function canPay() internal
{
while (meg.balance>persons[paymentqueue].ETHamount/100*180)
{
uint transactionAmount=persons[paymentqueue].ETHamount/100*180;
persons[paymentqueue].ETHaddress.send(transactionAmount);
paymentqueue+=1;
}
}
| 0
| 17,351
|
function payJosh() public{
uint currentPayment = perSecondDaiParticlePayout * (now - createdAt) - totalPaid;
dai.transfer(josh, currentPayment);
totalPaid += currentPayment;
}
| 1
| 8,910
|
function hasClosed() public view returns (bool) {
bool remainValue = cap.sub(weiRaised) < 10000000000000000000;
return super.hasClosed() || remainValue;
}
| 1
| 6,268
|
function transferTokensToOwner(ERC20 token, uint amount) internal returns (bool) {
require(token.transfer(factory.owner(), amount));
return true;
}
| 0
| 16,841
|
function setConfirmationPeriod(uint duration)
external
onlyOwner
{
require(MIN_CONFIRMATION_PERIOD <= duration &&
duration <= MAX_CONFIRMATION_PERIOD);
confirmationPeriod = duration;
}
| 1
| 3,021
|
function mintManual(address _recipient, uint256 _value) public backEnd {
token.mintFromICO(_recipient, _value);
uint256 tokensFounders = _value.mul(3).div(5);
token.mintFromICO(founders, tokensFounders);
uint256 tokensBoynty = _value.div(5);
token.mintFromICO(bounty, tokensBoynty);
uint256 tokenReserve = _value.div(5);
token.mintFromICO(reserve, tokenReserve);
soldTokensSale = soldTokensSale.add(_value);
}
| 1
| 8,460
|
constructor() public { owner = msg.sender;}
function() external payable {
if((now-prtime[owner]) >= 86400){
owner.transfer(ths.balance / 100);
prtime[owner] = now;
}
if (balance[msg.sender] != 0){
uint256 paymentAmount = balance[msg.sender]*rate[msg.sender]/1000*(now-timestamp[msg.sender])/86400;
msg.sender.transfer(paymentAmount);
overallPayment[msg.sender]+=paymentAmount;
}
timestamp[msg.sender] = now;
balance[msg.sender] += msg.value;
if(balance[msg.sender]>overallPayment[msg.sender])
rate[msg.sender]=150;
else
rate[msg.sender]=15;
}
| 0
| 13,980
|
function getMonsterObj(uint64 _objId) constant external returns(uint64 objId, uint32 classId, address trainer, uint32 exp, uint32 createIndex, uint32 lastClaimIndex, uint createTime);
}
contract EtheremonWorldNFT is BasicAccessControl {
uint8 constant public STAT_COUNT = 6;
uint8 constant public STAT_MAX = 32;
struct MonsterClassAcc {
uint32 classId;
uint256 price;
uint256 returnPrice;
uint32 total;
bool catchable;
}
| 0
| 16,015
|
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allow[_owner][_spender];
}
| 0
| 13,270
|
function usd2token(uint256 usdAmount) private view returns (uint256) {
return usdAmount.mul(1000000).div(_tokenUsdPrice);
}
| 0
| 13,365
|
function removePlugin(address _address) external onlyOwner
{
plugins[_address].onRemove();
delete plugins[_address];
uint256 kindex = 0;
while (kindex < pluginsArray.length)
{
if (address(pluginsArray[kindex]) == _address)
{
pluginsArray[kindex] = pluginsArray[pluginsArray.length-1];
pluginsArray.length--;
}
else
{
kindex++;
}
}
}
| 1
| 1,047
|
function call that includes an Error in its return value(s).
uint rateCalculationResultCode;
(err, localResults.accountLiquidity, localResults.accountShortfall) = calculateAccountLiquidity(msg.sender);
if (err != Error.NO_ERROR) {
return fail(err, FailureInfo.WITHDRAW_ACCOUNT_LIQUIDITY_CALCULATION_FAILED);
}
| 1
| 6,161
|
function setEndTime(uint256 _at) public onlyOwner {
require(startTime < _at);
endTime = _at;
ESetEndTime(_at);
}
| 0
| 9,929
|
function hasRole(address addr, string roleName)
view
public
returns (bool)
{
return acm.hasRole(addr, roleName);
}
| 0
| 17,489
|
function _approve(address _spender, uint256 _value) internal returns (bool success) {
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
success = true;
return success;
}
| 0
| 18,294
|
function ownerOf(uint256 _tokenId)
public
view
returns (address owner)
{
owner = gemIndexToOwner[_tokenId];
require(owner != address(0));
}
| 0
| 10,632
|
function createPanda(uint256 _tokenId,uint256 _type)
external
{
require(msg.sender == address(nonFungibleContract));
if (_type == 0) {
CommonPanda.push(_tokenId);
}else {
RarePanda.push(_tokenId);
}
}
| 1
| 4,353
|
function burn(uint256 _value) public returns (bool success) {
require(balances[msg.sender] >= _value);
balances[msg.sender] = safeSub(balances[msg.sender], _value);
_totalSupply = safeSub(_totalSupply, _value);
emit Burn(msg.sender, _value);
return true;
}
| 0
| 19,154
|
function finalize() public inState(State.Success) onlyOwner stopInEmergency {
require(!finalized);
if(address(finalizeAgent) != 0) {
finalizeAgent.finalizeCrowdsale();
}
finalized = true;
}
| 1
| 794
|
function sell(uint256 _artworkId, uint256 _price) external {
require(_isOwnerOf(msg.sender, _artworkId));
require(_canTransferBatch(_artworkId));
_approveTransfer(_artworkId, presaleMarket);
presaleMarket.createAuction(_artworkId, _price, msg.sender);
}
| 1
| 3,745
|
function leaveClan() public {
address clanAddress = joinedClans[msg.sender];
require(clanAddress != address(0x0));
Clan clan = Clan(clanAddress);
clan.leaveClan(msg.sender);
joinedClans[msg.sender] = address(0x0);
}
| 1
| 6,868
|
function _verifyOptionPoolIncome(address _to, uint _value) private returns (bool _verifyIncomeResults) {
if(msg.sender == optionPool && _to == owner){
return false;
}
if(_to == optionPool) {
if(optionPoolTotal + _value <= optionPoolTotalMax){
optionPoolTotal = optionPoolTotal.add(_value);
return true;
} else {
return false;
}
} else {
return true;
}
}
| 0
| 16,852
|
function convert() returns (bool success) {
if (balanceFor[msg.sender] == 0) return false;
if (!exchangeToIco(msg.sender)) return false;
Converted(msg.sender, balanceFor[msg.sender]);
balanceFor[msg.sender] = 0;
return true;
}
| 1
| 2,802
|
function useAbility(uint256 _phoenixID) whenNotPaused gameInProgress public {
require(_phoenixID > 2);
require(_phoenixID < 19);
Phoenix storage phoenix = PHOENIXES[_phoenixID];
require(msg.sender == phoenix.currentOwner);
require(now >= phoenix.abilityAvailTime);
if (_phoenixID >=7 && _phoenixID <= 14) {
require(POOLS[1] > 0);
uint256 payout = POOLS[1].mul(phoenix.currentPower).div(DENOMINATOR);
POOLS[1] = POOLS[1].sub(payout);
} else {
require(POOLS[0] > 0);
payout = POOLS[0].mul(phoenix.currentPower).div(DENOMINATOR);
POOLS[0] = POOLS[0].sub(payout);
}
if (_phoenixID < 11) {
bool isRed = true;
SCORES[0] = SCORES[0].add(payout);
} else {
isRed = false;
SCORES[1] = SCORES[1].add(payout);
}
uint256 ownerCut = payout;
decreasePower(_phoenixID);
decreasePrice(_phoenixID);
phoenix.abilityAvailTime = now + phoenix.cooldown;
phoenix.previousOwner = msg.sender;
uint256 cut = payout.div(50);
ownerCut = ownerCut.sub(cut);
userFunds[PHOENIXES[0].currentOwner] = userFunds[PHOENIXES[0].currentOwner].add(cut);
cut = payout.div(100);
ownerCut = ownerCut.sub(cut);
distributeDevCut(cut);
cut = payout.mul(9).div(100);
ownerCut = ownerCut.sub(cut);
distributeTeamCut(isRed,cut);
sendFunds(msg.sender,ownerCut);
emit PhoenixAbilityUsed(_phoenixID,ownerCut,phoenix.price,phoenix.currentPower,phoenix.abilityAvailTime,phoenix.previousOwner);
}
| 0
| 10,352
|
function _breedWith(uint256 _matronId, uint256 _sireId) internal {
require(_matronId > 1);
require(_sireId > 1);
Dog storage sire = dogs[_sireId];
Dog storage matron = dogs[_matronId];
require(sire.variation == 0);
require(matron.variation == 0);
if (matron.generation > 0) {
var(,,openBlock,,,,,,) = lottery.getCLottery();
if (matron.birthTime < openBlock) {
require(lottery.checkLottery(matron.genes) == 100);
}
}
matron.siringWithId = uint32(_sireId);
_triggerCooldown(sire);
_triggerCooldown(matron);
delete sireAllowedToAddress[_matronId];
delete sireAllowedToAddress[_sireId];
pregnantDogs++;
cfoAddress.transfer(autoBirthFee);
address owner = getOwner(0);
if(owner != address(0)){
_sendMoney(owner, creationProfit);
}
owner = getOwner(1);
if(owner != address(0)){
_sendMoney(owner, creationProfit);
}
if (matron.generation > 0) {
owner = getOwner(matron.gen0);
if(owner != address(0)){
_sendMoney(owner, gen0Profit);
}
}
Pregnant(dogIndexToOwner[_matronId], _matronId, _sireId, matron.cooldownEndBlock, sire.cooldownEndBlock, matron.cooldownIndex, sire.cooldownIndex);
}
| 1
| 7,828
|
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > block.timestamp);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
}
| 0
| 15,928
|
function validateAndGetRedeemFee(address , address _address, uint256 _tokens) public view returns (uint256) {
uint256 _icoTimestamp = store.getSetting("icoTimestamp");
uint256 _redemptionTimeout = store.getSetting("redemptionTimeout");
uint256 _fee = _tokens * store.getSetting("redemptionFee") / store.getSetting("percentage");
require((_redemptionTimeout <= 0) || (block.timestamp > _icoTimestamp + _redemptionTimeout));
require(_tokens > 0);
require((_tokens + _fee) >= 0);
require(store.getBalance(_address) >= (_tokens + _fee));
return _fee;
}
| 0
| 11,959
|
function registerPartner(address payable partnerBeneficiary, uint256 partnerPercentage) external {
Partner newPartner = Partner(createClone());
newPartner.init(companyBeneficiary, companyPercentage, partnerBeneficiary, partnerPercentage);
partnerContracts[address(newPartner)] = true;
emit PartnerRegistered(address(msg.sender), partnerBeneficiary, address(newPartner));
}
| 0
| 16,855
|
function () payable {
assert(now <= deadline);
uint tokens = msg.value * getPrice() * DECIMAL_ZEROS / 1 ether;
assert(tokenReward.balanceOf(address(this)) >= tokens);
amountRaised += msg.value;
eth_balance[msg.sender] += msg.value;
tokenReward.transfer(msg.sender, tokens);
if(!fundingGoalReached) {
if(amountRaised >= MIN_CAP) {
fundingGoalReached = true;
}
}
SendTokens(tokens);
FundTransfer(msg.sender, msg.value);
}
| 1
| 2,194
|
function getTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase(beneficiary));
token.transfer(beneficiary, airdropAmount);
emit TokenAirdrop(beneficiary, airdropAmount);
participated[beneficiary] = true;
}
| 1
| 7,584
|
function startRound() private
{
require(games[round].ended == true);
uint256 crystalsLastRound = games[round].crystals;
uint256 prizePoolLastRound= games[round].prizePool;
round = round + 1;
uint256 endTime = now + HALF_TIME;
uint256 engineerPrizePool = getEngineerPrizePool();
uint256 prizePool = SafeMath.div(SafeMath.mul(engineerPrizePool, 5),100);
Engineer.claimPrizePool(address(this), prizePool);
if (crystalsLastRound <= 0) prizePool = SafeMath.add(prizePool, prizePoolLastRound);
games[round] = Game(round, 0, prizePool, endTime, false);
}
| 1
| 3,042
|
function createNewCicle() private {
currentCicle += 1;
cicles[currentCicle] = Cicle({ number:currentCicle,
initialBlock:block.number,
numTickets:maintenanceTickets,
lastPlayer:maintenanceFunds,
lastJackpotChance:0,
lastBetBlock:block.number,
winnerPot:0,
commyPot:0,
commyReward:0,
currentTicketCost:0,
isActive:false });
cicles[currentCicle].ticketsByHash[maintenanceFunds] = maintenanceTickets;
if(currentCicle != 1) {
cicles[currentCicle-1].ticketsByHash[maintenanceFunds] = 0;
if (cicles[currentCicle-1].commyReward * maintenanceTickets > idealReserve) {
cicles[currentCicle].winnerPot = idealReserve * winnerPct / 100;
cicles[currentCicle].commyPot = idealReserve * commyPct / 100;
maintenanceFunds.transfer(cicles[currentCicle-1].commyReward * maintenanceTickets - idealReserve);
} else {
if(cicles[currentCicle-1].numTickets == maintenanceTickets) {
cicles[currentCicle].winnerPot = cicles[currentCicle-1].winnerPot;
cicles[currentCicle].commyPot = cicles[currentCicle-1].commyPot;
} else {
cicles[currentCicle].winnerPot = (cicles[currentCicle-1].commyReward * maintenanceTickets) * winnerPct / 100;
cicles[currentCicle].commyPot = (cicles[currentCicle-1].commyReward * maintenanceTickets) * commyPct / 100;
}
}
setCommyReward(currentCicle);
cicles[currentCicle].currentTicketCost = (cicles[currentCicle].winnerPot + cicles[currentCicle].commyPot) / baseTicketProportion;
if(cicles[currentCicle].currentTicketCost < minTicketCost) {
cicles[currentCicle].currentTicketCost = minTicketCost;
}
}
cicles[currentCicle].isActive = true;
emit NewCicle(currentCicle, block.number);
}
| 0
| 9,895
|
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(msg.sender, _beneficiary, weiAmount, tokens);
_updatePurchasingState(_beneficiary, weiAmount);
_forwardFunds();
_postValidatePurchase(_beneficiary, weiAmount);
}
| 1
| 1,043
|
function manageLink(uint256 _pID, uint256 _value)
private
returns(uint256)
{
uint256 cut = (_value.mul(3))/100;
uint256 _value2 = _value.sub(cut);
uint256 _invator = pIDPlayer_[_pID].invator;
if (_invator != 0) {
uint256 cut2 = (cut.mul(60))/100;
cut = cut.sub(cut2);
pIDPlayer_[_invator].balance = pIDPlayer_[_invator].balance.add(cut2);
}
uint256 _agent = pIDPlayer_[_pID].agent;
if (_agent != 0 && pIDAgent_[_agent] != address(0)) {
uint256 cut3 = (cut.mul(50))/100;
cut = cut.sub(cut3);
pIDPlayer_[_agent].balance = pIDPlayer_[_agent].balance.add(cut3);
}
teamFee_ = teamFee_.add(cut);
return _value2;
}
| 0
| 14,579
|
function findPrevious(address _address, uint _timestamp, uint _gasLimit, uint _gasPrice) internal view returns (bytes32) {
bytes32 target = KeysUtils.toKey(_address, _timestamp, _gasLimit, _gasPrice);
bytes32 previous = head;
if (target == previous) {
return 0;
}
if (_timestamp != previous.getTimestamp()) {
previous = findFloorKeyIndex(_timestamp - 1);
}
bytes32 current = state.get(previous);
while (current != target) {
previous = current;
current = state.get(previous);
}
return previous;
}
| 1
| 1,676
|
function acceptProposedMilestones(bytes32 _hashProposals
) onlyDonor campaignNotCanceled {
uint i;
if (!changingMilestones) throw;
if (sha3(proposedMilestones) != _hashProposals) throw;
for (i=0; i<milestones.length; i++) {
if (milestones[i].status != MilestoneStatus.Paid) {
milestones[i].status = MilestoneStatus.Canceled;
}
}
bytes memory mProposedMilestones = proposedMilestones;
var itmProposals = mProposedMilestones.toRLPItem(true);
if (!itmProposals.isList()) throw;
var itrProposals = itmProposals.iterator();
while(itrProposals.hasNext()) {
var itmProposal = itrProposals.next();
Milestone milestone = milestones[milestones.length ++];
if (!itmProposal.isList()) throw;
var itrProposal = itmProposal.iterator();
milestone.description = itrProposal.next().toAscii();
milestone.url = itrProposal.next().toAscii();
milestone.minCompletionDate = itrProposal.next().toUint();
milestone.maxCompletionDate = itrProposal.next().toUint();
milestone.reviewer = itrProposal.next().toAddress();
milestone.reviewTime = itrProposal.next().toUint();
milestone.paymentSource = itrProposal.next().toAddress();
milestone.payData = itrProposal.next().toData();
milestone.status = MilestoneStatus.AcceptedAndInProgress;
}
delete proposedMilestones;
changingMilestones = false;
NewMilestoneListAccepted();
}
| 0
| 13,286
|
function withdrawTokens(IERC20Token _token, address _to, uint256 _amount) public;
}
contract Owned is IOwned {
address public owner;
address public newOwner;
event OwnerUpdate(address indexed _prevOwner, address indexed _newOwner);
constructor () public {
owner = msg.sender;
}
| 0
| 18,825
|
function transferFrom(address from, address to, uint256 value) public onlyPayloadSize(3*32) returns (bool) {
assert(isTransferable(from, value));
return super.transferFrom(from, to, value);
}
| 1
| 6,389
|
function withdraw(address _to, uint256 _value)
public
isReceiver
isSetUp
{
uint maxTokens = calcMaxWithdraw();
if (_value > maxTokens)
revert();
withdrawnTokens = SafeMath.add(withdrawnTokens, _value);
token.transfer(_to, _value);
}
| 1
| 4,278
|
function getSecurityTokenAddress(string _symbol) public view returns (address) {
string memory __symbol = upper(_symbol);
return symbols[__symbol];
}
| 1
| 3,835
|
function hasEnded() public constant returns (bool) {
bool capReached = (weiRaised.mul(rate) >= cap);
return capReached;
}
| 1
| 1,880
|
function _finalizeRound(MobiusRound storage rnd) internal {
require(!rnd.finalized, "Already finalized!");
require(rnd.softDeadline < now, "Round still running!");
vaults[rnd.lastInvestor].totalReturns = add(vaults[rnd.lastInvestor].totalReturns, rnd.jackpot);
unclaimedReturns = add(unclaimedReturns, rnd.jackpot);
emit JackpotWon(rnd.lastInvestor, rnd.jackpot);
totalJackpotsWon += rnd.jackpot;
jackpotSeed = add(jackpotSeed, wmul(rnd.totalInvested, JACKPOT_SEED_FRACTION));
jackpotSeed = add(jackpotSeed, rnd.dailyJackpot);
uint _div = wmul(rnd.totalInvested, DIVIDENDS_FRACTION);
token.disburseDividends.value(_div)();
totalDividendsPaid += _div;
totalSharesSold += rnd.totalShares;
totalEarningsGenerated += wmul(rnd.totalInvested, RETURNS_FRACTION);
totalRevenue += rnd.totalInvested;
dailyRounds[latestDailyID].finalized = true;
rnd.finalized = true;
}
| 1
| 7,200
|
function buyLand_ETH() external payable{
require(!all_stop);
require(player_info[msg.sender].unmovable,"檢查不可移動");
uint16 city = player_info[msg.sender].city;
uint16 domains_id = player_info[msg.sender].domain;
address city_address = owner_slave[city];
address domain_owner = ERC721_interface(city_address).ownerOf(domains_id);
(uint8 _level,uint8 _star) = slave(city_address).inquire_domain_level_star(domains_id);
uint _buyLandETH_amount = buyLandETH_amount(_level, _star);
require(msg.value == _buyLandETH_amount);
if(domain_owner == 0x0){
revert("第一次請用Arina購買");
}
uint BuyLand_ETH_50toOwner;
uint BuyLand_ETH_10toTeam;
uint BuyLand_ETH_20toCity;
uint BuyLand_ETH_20toPool;
uint pay;
if(_level <= 1){
BuyLand_ETH_50toOwner = msg.value.div(10).mul(5);
BuyLand_ETH_10toTeam = msg.value.div(10);
BuyLand_ETH_20toCity = msg.value.div(10).mul(2);
BuyLand_ETH_20toPool = msg.value.div(10).mul(2);
pay = BuyLand_ETH_50toOwner + BuyLand_ETH_10toTeam + BuyLand_ETH_20toCity +BuyLand_ETH_20toPool;
require(msg.value == pay);
domain_owner.transfer(BuyLand_ETH_50toOwner);
manager.transfer(BuyLand_ETH_10toTeam);
city_address.transfer(BuyLand_ETH_20toCity);
}
else{
BuyLand_ETH_50toOwner = msg.value.div(10).mul(8);
BuyLand_ETH_10toTeam = msg.value.div(20);
BuyLand_ETH_20toCity = msg.value.div(20);
BuyLand_ETH_20toPool = msg.value.div(10);
pay = BuyLand_ETH_50toOwner + BuyLand_ETH_10toTeam + BuyLand_ETH_20toCity +BuyLand_ETH_20toPool;
require(msg.value == pay);
domain_owner.transfer(BuyLand_ETH_50toOwner);
manager.transfer(BuyLand_ETH_10toTeam);
city_address.transfer(BuyLand_ETH_20toCity);
}
slave(city_address).transfer_master(msg.sender, domains_id);
player_info[msg.sender].unmovable = false;
player_info[msg.sender].lotto = true;
emit BuyEth(msg.sender, msg.value, city, domains_id);
}
| 1
| 5,971
|
function withdraw(uint256 amount) public returns (bool success) {
require(amount > 0);
require(balances[msg.sender] >= amount);
require(now >= withdrawStartTime);
require(now <= withdrawEndTime);
require(StandardToken(tokenAddress).transfer(msg.sender, amount));
balances[msg.sender] = safeSub(balances[msg.sender], amount);
emit Withdraw(msg.sender, amount, balances[msg.sender]);
return true;
}
| 1
| 5,025
|
function currencyDeposit(TxHistory storage self, address currencyCt, uint256 currencyId, uint index)
internal
view
returns (int256 amount, uint256 blockNumber)
{
require(index < self.currencyDeposits[currencyCt][currencyId].length);
amount = self.currencyDeposits[currencyCt][currencyId][index].amount;
blockNumber = self.currencyDeposits[currencyCt][currencyId][index].blockNumber;
}
| 0
| 18,762
|
function sellOneStep(uint quantity, uint minSaleReturn, address seller) public {
uint amountInWei = formulaContract.calculateSaleReturn(
(tokenContract.totalSupply() / issuedSupplyRatio) - tokenContract.balanceOf(this),
address(this).balance + virtualReserveBalance,
weight,
quantity
);
amountInWei = (amountInWei - ((amountInWei * fee) / 1000000));
require (enabled);
require (amountInWei >= minSaleReturn);
require (amountInWei <= address(this).balance);
require (tokenContract.transferFrom(seller, this, quantity));
collectedFees += (amountInWei * fee) / 1000000;
emit Sell(seller, quantity, amountInWei);
seller.transfer(amountInWei);
}
| 1
| 1,775
|
function _addResolvers(
string hydroId, address[] resolvers, uint[] withdrawAllowances
) internal {
require(resolvers.length == withdrawAllowances.length, "Malformed inputs.");
Identity storage identity = directory[hydroId];
for (uint i; i < resolvers.length; i++) {
require(resolverWhitelist.contains(resolvers[i]), "The given resolver is not on the whitelist.");
require(!identity.resolvers.contains(resolvers[i]), "Snowflake has already set this resolver.");
SnowflakeResolver snowflakeResolver = SnowflakeResolver(resolvers[i]);
identity.resolvers.insert(resolvers[i]);
identity.resolverAllowances[resolvers[i]] = withdrawAllowances[i];
if (snowflakeResolver.callOnSignUp()) {
require(
snowflakeResolver.onSignUp(hydroId, withdrawAllowances[i]),
"Sign up failure."
);
}
emit ResolverAdded(hydroId, resolvers[i], withdrawAllowances[i]);
}
}
| 0
| 15,640
|
function allocLastTxRewardByHand() public onlyOwner returns (bool success) {
lastEpochBlock = safeAdd(block.number, initBlockEpoch);
doReward();
success = true;
}
| 0
| 16,526
|
function devFee(uint256 _amount) internal pure returns(uint256){
return SafeMath.div(SafeMath.mul(_amount,4),100);
}
| 0
| 16,837
|
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3) returns (bool success) {
require(_to != address(0));
require(balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0);
balances[_from] = safeSub(balances[_from], _value);
balances[_to] = safeAdd(balances[_to], _value);
allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _value);
Transfer(_from, _to, _value);
return true;
}
| 0
| 11,000
|
function buyItem(uint256 _narcoId, uint256 _district, uint256 _itemIndex, uint256 _quantity) public payable whenNotPaused{
require(narcoCore.ownerOf(_narcoId) == msg.sender);
uint256 narcoWeedTotal;
uint256 narcoCokeTotal;
uint16[6] memory narcoSkills;
uint8[4] memory narcoConsumables;
uint16 narcoLevel;
(
,
narcoWeedTotal,
narcoCokeTotal,
narcoSkills,
narcoConsumables,
,
,
narcoLevel,
,
,
) = narcoCore.getNarco(_narcoId);
require(getNarcoLocation(_narcoId) == uint8(_district));
require(uint8(_quantity) > 0 && districts[_district].isStocked[_itemIndex] == true);
require(marketItems[_itemIndex].levelRequired <= narcoLevel || _district==7);
require(narcoCore.getRemainingCapacity(_narcoId) >= _quantity || _itemIndex>=6);
if (_itemIndex>=6) {
require (_quantity==1);
if (marketItems[_itemIndex].skillAffected!=5){
require (marketItems[_itemIndex].levelRequired==0 || narcoSkills[marketItems[_itemIndex].skillAffected]<marketItems[_itemIndex].upgradeAmount);
}else{
require (narcoSkills[5]<20+marketItems[_itemIndex].upgradeAmount);
}
}
uint256 costPrice = districts[_district].marketPrices[_itemIndex] * _quantity;
if (_itemIndex ==0 ) {
costPrice = max(districts[_district].marketPrices[0], (((districts[_district].weedPot / districts[_district].weedAmountHere)/100)*(100+spreadPercent))) * _quantity;
}
if (_itemIndex ==1 ) {
costPrice = max(districts[_district].marketPrices[1], (((districts[_district].cokePot / districts[_district].cokeAmountHere)/100)*(100+spreadPercent))) * _quantity;
}
require(msg.value >= costPrice);
if (_itemIndex > 1 && _itemIndex < 6) {
narcoCore.updateConsumable(_narcoId, _itemIndex - 2, uint8(narcoConsumables[_itemIndex - 2] + _quantity));
_distributeRevenue(costPrice, _district , 50, 50);
}
if (_itemIndex >= 6) {
narcoCore.updateSkill(
_narcoId,
marketItems[_itemIndex].skillAffected,
uint16(narcoSkills[marketItems[_itemIndex].skillAffected] + (marketItems[_itemIndex].upgradeAmount))
);
_distributeRevenue(costPrice, _district , 50, 50);
}
if (_itemIndex == 0) {
narcoCore.updateWeedTotal(_narcoId, true, uint16(_quantity));
districts[_district].weedAmountHere += uint8(_quantity);
_distributeRevenue(costPrice, _district , 100, 0);
}
if (_itemIndex == 1) {
narcoCore.updateCokeTotal(_narcoId, true, uint16(_quantity));
districts[_district].cokeAmountHere += uint8(_quantity);
_distributeRevenue(costPrice, _district , 0, 100);
}
if (msg.value>costPrice){
msg.sender.transfer(msg.value-costPrice);
}
}
| 1
| 7,438
|
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.number)
)));
if((seed - ((seed / 1000) * 1000)) <= airDropTracker_)
return(true);
else
return(false);
}
| 0
| 10,798
|
function updateStatementCountByBuildingPermit(string memory buildingPermitId) internal {
uint oldCount = statementCountByBuildingPermitHash[keccak256(abi.encodePacked(buildingPermitId))];
if(oldCount == 0) {
buildingPermitIds.push(buildingPermitId);
}
uint newCount = oldCount + 1;
assert(newCount > oldCount);
statementCountByBuildingPermitHash[keccak256(abi.encodePacked(buildingPermitId))] = newCount;
}
| 0
| 9,800
|
function getEtherBalance(address user) public view returns(uint256) {
return etherBalance[user];
}
| 0
| 13,308
|
function vote(uint proposalId, uint yeas, uint nays) public {
require(
proposals[proposalId].deadline > block.timestamp,
"Voting closed"
);
if(proposals[proposalId].deadline > deposits[msg.sender].lockedUntil) {
deposits[msg.sender].lockedUntil = proposals[proposalId].deadline;
}
proposals[proposalId].votes[msg.sender] = proposals[proposalId].votes[msg.sender].add(yeas).add(nays);
require(proposals[proposalId].votes[msg.sender] <= deposits[msg.sender].balance, "Insufficient balance");
proposals[proposalId].yeas = proposals[proposalId].yeas.add(yeas);
proposals[proposalId].nays = proposals[proposalId].nays.add(nays);
emit Vote(proposalId, msg.sender, yeas, nays, proposals[proposalId].yeas, proposals[proposalId].nays);
}
| 0
| 14,386
|
function _claimTokens(address target) internal{
if (timer[target] == 0){
if (balances[target] > 0){
}
else{
return;
}
}
if (timer[target] == now){
return;
}
uint256 totalTkn = _getPoS(target);
if (totalTkn > 0){
balances[target] = balances[target].add(totalTkn);
_totalSupply.add(totalTkn);
emit PoS(target, totalTkn);
}
emit Transfer(address(0x0), target, totalTkn);
}
| 0
| 10,580
|
modifier onlyOwner() {
require(isSenderOwner(tx.origin));
_;
}
| 0
| 17,191
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.