func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function transfer similar to ERC20 transfer with no _data .
function transfer(address _to, uint256 _value) returns (bool success) {
if (isContract(_to)) {
bytes memory empty;
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, empty);
}
return super.transfer(_to, _value);
}
| 1 | 7,538 |
function withdrawFunds(address beneficiary, uint withdrawAmount) external onlyAdmin {
require (withdrawAmount <= address(this).balance, "Increase amount larger than balance.");
require (lockedInBets + withdrawAmount <= address(this).balance, "Not enough funds.");
sendFunds(beneficiary, withdrawAmount);
}
| 0 | 12,580 |
function setTokenContractAddress(address _token) onlyOwner {
token = TokenToken(_token);
}
| 0 | 18,414 |
function getDocumentDetails(uint256 docId) returns (address organizer, uint count) {
Document doc = documents[docId];
organizer = doc.organizer;
count = doc.signs.length;
}
| 0 | 15,820 |
function balanceOf(address owner) public view returns (uint) {
return _balances[owner];
}
| 0 | 12,225 |
function addAff(uint256 pid,uint256 _affCode,uint256 adminAmount,address level1,address level2) private{
require(adminAmount>0);
uint256 adminId=player_[playAddr_[admin__]].id;
if(playAff_[pid]==0){
if(_affCode==0){
_affCode=adminId;
level1=admin__;
level2=address(0);
}
uint256 level1Pid=adminId;
uint256 level2Pid=0;
bytes4 methodId = bytes4(keccak256("addOtherGameAff(uint256,address,address,address)"));
if(shareContract.call(methodId,_affCode,msg.sender,level1,level2)){
level1Pid=getPlayId(level1);
level2Pid=getPlayId(level2);
}
playAff_[pid]=level1Pid;
player_[level1Pid].affNumLevel_1++;
if(level2Pid>0){
player_[level2Pid].affNumLevel_2++;
if( playAff_[level1Pid]==0)
playAff_[level1Pid]=level2Pid;
}
}
if(playAff_[pid] != adminId)
{
uint256 level1Amount=safePercent(gameConfig_.level1Rewards,adminAmount);
uint256 level1Id=playAff_[pid];
player_[level1Id].balance = add(player_[level1Id].balance,level1Amount);
uint256 level2Id=playAff_[level1Id];
if(level2Id>0){
uint256 level2Amount=safePercent(gameConfig_.level2Rewards,adminAmount);
adminAmount=sub(adminAmount,level2Amount);
player_[level2Id].balance=add(player_[level2Id].balance,level2Amount);
}
adminAmount=sub(adminAmount,level1Amount);
require(adminAmount>0);
}
player_[adminId].balance=add(player_[adminId].balance,adminAmount);
}
| 1 | 1,051 |
function release() onlyOwner public returns (bool) {
require(!released);
released = true;
Release();
return true;
}
| 0 | 12,261 |
function UInt256 (int256 elem) private pure returns(uint256 res) {
assert(elem >= 0);
return uint256(elem);
}
| 0 | 14,519 |
function totalSoldTokens() public view returns(uint256) {
return _totalSoldTokens;
}
| 0 | 16,310 |
function lock(int offsetMinutes) auth public returns(bool) {
require(lockStart == false);
require(offsetMinutes >= 0);
for(uint i = 0; i < dateArray.length; i++) {
require(dateArray[i] != 0);
}
require(release_percent != 0);
require(totalFutureRelease != 0);
DAO cosTokenApi = DAO(contract_addr);
uint256 balance = cosTokenApi.balanceOf(address(this));
require(balance == totalFutureRelease);
startTime = block.timestamp + uint(offsetMinutes) * 1 minutes;
lockStart = true;
}
| 1 | 9,221 |
function _buyToken(address _to, uint _referrerId) private returns (uint) {
tokenIds = tokenIds.add(1);
uint _tokenId = tokenIds;
_mint(_to, _tokenId);
transferFrom(ownerOf(_tokenId), msg.sender, _tokenId);
mintDate[_tokenId] = now;
_addOwnerBonus(ticketPrice, ownerBonusSale);
if (_referrerId == 0) {
_referrerId = addressToReferrer[owner()];
}
if (_referrerId > 0 && referrerToAddress[_referrerId] > 0) {
_addReferrerBonus(_referrerId, ticketPrice, referrerBonusSale);
_setTicketReferrer(_tokenId, _referrerId);
}
return _tokenId;
}
| 1 | 8,464 |
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
require(newOwner != address(this), "Ownable: new owner is the contract address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
}
| 0 | 10,234 |
function setMemoryArenaInterface(address _addr) public isAdministrator
{
MemoryArenaInterface memoryArenaInterface = MemoryArenaInterface(_addr);
require(memoryArenaInterface.isMemoryArenaContract() == true);
MemoryArena = memoryArenaInterface;
}
| 1 | 4,763 |
function getStorageAddress() public view returns(address storageContract) {
require (msg.sender == address(advertisementFinance));
return address(advertisementStorage);
}
| 1 | 9,062 |
function playSpecificTriples(uint8 _betNum, uint256 _betAmount) public payable playable(_betAmount) returns(bool _result){
lock();
depositEther();
require(_betNum >= 1 && _betNum <=6);
if (_betAmount > gameMaxBetAmount){
_betAmount = gameMaxBetAmount;
}
_result = _play(_betNum + 3, _betAmount,false);
unLock();
}
| 1 | 1,874 |
function _burn(address _who, uint256 _value) internal {
require(_value <= balances[_who]);
balances[_who] = balances[_who].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(_who, _value);
emit Transfer(_who, address(0), _value);
}
| 0 | 15,319 |
function transferRegistrars(bytes32 _hash) public onlyOwner(_hash) {
address registrar = ens.owner(rootNode);
require(registrar != address(this));
Entry storage h = _entries[_hash];
h.deed.setRegistrar(registrar);
Registrar(registrar).acceptRegistrarTransfer(_hash, h.deed, h.registrationDate);
h.deed = Deed(0);
h.registrationDate = 0;
h.value = 0;
h.highestBid = 0;
}
| 1 | 9,278 |
function name() external pure returns (string) {
return "GanToken";
}
| 0 | 16,026 |
function withdraw() public {
uint256 balance = address(this).balance;
weak_hands.withdraw.gas(1000000)();
uint256 dividendsPaid = address(this).balance - balance;
dividends += dividendsPaid;
emit Dividends(dividendsPaid);
}
| 1 | 7,282 |
function FINCOIN(
) {
balances[msg.sender] = 5000000000000000;
totalSupply = 5000000000000000;
name = "fincoin";
decimals = 8;
symbol = "fca";
}
| 0 | 11,412 |
constructor() public {
_predecessor = 0x0;
if (_predecessor != 0x0) {
uint lastRevision = ZeroPriceIndex(_predecessor).getRevision();
_revision = lastRevision + 1;
}
_zer0netDb = Zer0netDbInterface(0xE865Fe1A1A3b342bF0E2fcB11fF4E3BCe58263af);
}
| 1 | 9,008 |
function BCFLeague(address dataStoreAddress, uint teamsTotal, uint entryFee, uint squadSize, uint roundTimeSecs) public {
require(teamsTotal % 2 == 0);
require(teamsTotal > 0);
require(roundTimeSecs > 30 seconds && roundTimeSecs < 60 minutes);
require(entryFee >= 0);
require(squadSize > 0);
owner = msg.sender;
referee = msg.sender;
TEAMS_TOTAL = teamsTotal;
ENTRY_FEE = entryFee;
SQUAD_SIZE = squadSize;
TOTAL_ROUNDS = TEAMS_TOTAL - 1;
MATCHES_PER_ROUND = TEAMS_TOTAL / 2;
SECONDS_BETWEEN_ROUNDS = roundTimeSecs;
competitionStatus = CompetitionStatuses.Upcoming;
BCFMain candidateDataStoreContract = BCFMain(dataStoreAddress);
require(candidateDataStoreContract.implementsERC721());
mainContract = candidateDataStoreContract;
}
| 1 | 6,999 |
function stringToBytes32(string memory source) public pure returns (bytes32 result) {
bytes memory tempEmptyStringTest = bytes(source);
if (tempEmptyStringTest.length == 0) {
return 0x0;
}
assembly {
result := mload(add(source, 32))
}
}
| 0 | 10,378 |
function SafeDiv(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
}
| 0 | 13,682 |
function perform_withdraw(address tokenAddress) {
if (!bought_tokens) throw;
ERC20 token = ERC20(tokenAddress);
uint256 contract_token_balance = token.balanceOf(address(this));
if (contract_token_balance == 0) throw;
uint256 tokens_to_withdraw = (balances[msg.sender] * contract_token_balance) / contract_eth_value;
contract_eth_value -= balances[msg.sender];
balances[msg.sender] = 0;
if(!token.transfer(msg.sender, tokens_to_withdraw)) throw;
}
| 1 | 4,322 |
function set_minimum_payment(uint256 new_limit) {
if ( msg.sender == thebank ){
minimum_deposit_amount = new_limit;
}
}
| 0 | 18,769 |
function purchaseEgg(uint64 userNumber, uint16 quality) external payable whenNotPaused {
require(eggAvailable(quality));
require(tokensCount <= globalPresaleLimit);
uint256 eggPrice = ( recommendedPrice(quality) * (100 - getCurrentDiscountPercent()) ) / 100;
require(msg.value >= eggPrice);
purchesedEggs[quality]++;
uint256 childGenes;
uint16 childQuality;
(childGenes, childQuality) = geneScience.openEgg(userNumber, quality);
createPet(
childGenes,
childQuality,
msg.sender
);
reward.get(msg.sender, recommendedPrice(quality));
}
| 1 | 9,448 |
function determinePID(Fumodatasets.EventReturns memory _eventData_)
private
returns (Fumodatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
| 1 | 5,831 |
function weiRaised() public view returns (uint256)
{
return _weiRaised;
}
| 0 | 18,955 |
function canSubAllocation(address sender, uint256 sub_value) constant private returns (bool)
{
if (sub_value==0)
{
return false;
}
if (balances[sender] < sub_value)
{
return false;
}
if (allocations[sender].length == 0)
{
return true;
}
uint256 alllock_sum = 0;
for (uint j=0; j<allocations[sender].length; j++)
{
if (allocations[sender][j].releaseTime >= block.timestamp)
{
alllock_sum = alllock_sum.add(allocations[sender][j].balance);
}
}
uint256 can_unlock = balances[sender].sub(alllock_sum);
return can_unlock >= sub_value;
}
| 0 | 19,192 |
function addNewToken(address _tokenAddress, bytes32 _tokenName)
isWithinETHLimits(msg.value)
public
payable
{
uint256 checkUserStatu = configurationUserCheck[msg.sender];
if(checkUserStatu == 0){
configurationUserCheck[msg.sender]=1;
T1Wdatasets.AddConfigurationUser memory configurationUser ;
configurationUser.addr = msg.sender;
configurationUser.ethTotalAmount += msg.value;
configurationUserMap[msg.sender] = configurationUser;
emit addConfigUser(msg.sender , msg.value);
}
}
| 0 | 15,066 |
function requestVotingRights(uint _numTokens) external {
require(token.balanceOf(msg.sender) >= _numTokens);
voteTokenBalance[msg.sender] += _numTokens;
require(token.transferFrom(msg.sender, this, _numTokens));
_VotingRightsGranted(_numTokens, msg.sender);
}
| 1 | 8,684 |
function startNextMilestone() internal {
Record storage rec = Collection[currentRecord];
rec.time_ended = getTimestamp();
rec.state = getRecordState("FINAL");
if(currentRecord < RecordNum) {
currentRecord++;
Record storage nextRec = Collection[currentRecord];
nextRec.time_start = rec.time_ended;
nextRec.time_end = rec.time_ended + nextRec.duration;
}
}
| 1 | 8,100 |
function hdiv(uint128 x, uint128 y) pure internal returns (uint128 z) {
z = x / y;
}
| 0 | 12,901 |
function registerChain(bytes8 chain, uint supply) public onlyOwner returns (bool) {
require(!validChain[chain]);
validChain[chain] = true;
chains.push(chain);
balance[chain] = supply;
emit LogRegisterChain(msg.sender, chain, supply, true);
}
| 0 | 13,233 |
function _approve(address owner, address spender, uint256 value) internal {
require(spender != address(0));
require(owner != address(0));
mAllowed[owner][spender] = value;
emit Approval(owner, spender, value);
}
| 0 | 12,629 |
function receiveAirDrop() public {
require(isValidAirDropForIndividual());
invalidAirDrop[msg.sender] = true;
require(erc20.transfer(msg.sender, airDropAmount));
LogAirDrop(msg.sender, airDropAmount);
}
| 1 | 4,485 |
function unfreezeTransfers () {
require (msg.sender == owner);
if (frozen) {
frozen = false;
emit Unfreeze ();
}
}
| 0 | 9,783 |
function trade(address tokenBuy, uint amountBuy, address tokenSell, uint amountSell, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s, uint amount) external {
bytes32 hash = keccak256(abi.encodePacked(this, tokenBuy, amountBuy, tokenSell, amountSell, expires, nonce, user));
if (!(
(orders[user][hash] || ecrecover(keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)),v,r,s) == user) &&
block.timestamp <= expires &&
safeAdd(orderFills[user][hash], amount) <= amountBuy
)) revert();
tradeBalances(tokenBuy, amountBuy, tokenSell, amountSell, user, amount);
orderFills[user][hash] = safeAdd(orderFills[user][hash], amount);
emit Trade(tokenBuy, amount, tokenSell, amountSell * amount / amountBuy, user, msg.sender, hash, block.timestamp);
}
| 0 | 11,670 |
function ownerPauseJackpot(bool newStatus) public onlyOwner{
jackpotPaused = newStatus;
}
| 1 | 8,615 |
function MintedEthCappedCrowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal, uint _weiCap) Crowdsale(_token, _pricingStrategy, _multisigWallet, _start, _end, _minimumFundingGoal) {
weiCap = _weiCap;
}
| 1 | 3,924 |
function getAddresses() external view returns(address[]) {
return playerAddrs;
}
| 0 | 9,940 |
function setRegistrationFee(uint _fee) public onlyOwner {
require(_fee != 0);
registrationFee_ = _fee;
}
| 0 | 18,968 |
function setSellPrice(uint256 priceInWei) isOwner {
require(priceInWei >= 0);
sellPrice = priceInWei;
}
| 0 | 18,219 |
function placeBet(uint betMask, uint modulo, uint commitLastBlock, uint commit, bytes32 r, bytes32 s) external payable {
Bet storage bet = bets[commit];
require(bet.gambler == address(0), "Bet should be in a 'clean' state.");
uint amount = msg.value;
require(modulo > 1 && modulo <= MAX_MODULO, "Modulo should be within range.");
require(amount >= MIN_BET && amount <= MAX_AMOUNT, "Amount should be within range.");
require(betMask > 0 && betMask < MAX_BET_MASK, "Mask should be within range.");
require(block.number <= commitLastBlock, "Commit has expired.");
bytes32 signatureHash = keccak256(abi.encodePacked(commitLastBlock, commit));
require(secretSigner == ecrecover(signatureHash, 27, r, s), "ECDSA signature is not valid.");
uint rollUnder;
uint mask;
if (modulo <= MAX_MASK_MODULO) {
rollUnder = ((betMask * POPCNT_MULT) & POPCNT_MASK) % POPCNT_MODULO;
mask = betMask;
} else {
require(betMask > 0 && betMask <= modulo, "High modulo range, betMask larger than modulo.");
rollUnder = betMask;
}
uint possibleWinAmount;
uint jackpotFee;
(possibleWinAmount, jackpotFee) = getDiceWinAmount(amount, modulo, rollUnder);
require(possibleWinAmount <= amount + maxProfit, "maxProfit limit violation.");
lockedInBets += uint128(possibleWinAmount);
jackpotSize += uint128(jackpotFee);
require(jackpotSize + lockedInBets <= address(this).balance, "Cannot afford to lose this bet.");
emit Commit(commit);
bet.amount = amount;
bet.modulo = uint8(modulo);
bet.rollUnder = uint8(rollUnder);
bet.placeBlockNumber = uint40(block.number);
bet.mask = uint40(mask);
bet.gambler = msg.sender;
}
| 0 | 15,555 |
modifier isHuman() {
address _addr = msg.sender;
require(_addr == tx.origin);
uint256 _codeLength;
assembly {
_codeLength: = extcodesize(_addr)
}
require(_codeLength == 0, "sorry humans only");
_;
}
| 0 | 14,808 |
function setCrowdsaleManager(address _mgr) public onlyTokenManager
{
require(currentState != State.Migrating);
crowdsaleManager = _mgr;
}
| 0 | 19,295 |
function changeEndtime(uint256 _endTime) public onlyOwner {
require(_endTime != 0);
endTime = _endTime;
}
| 1 | 7,850 |
modifier onlyHuman {
uint256 codeSize;
address sender = msg.sender;
assembly { codeSize := extcodesize(sender) }
require(sender == tx.origin, "Sorry, human only");
require(codeSize == 0, "Sorry, human only");
_;
}
| 0 | 10,854 |
function insecureRand() private view returns (uint256)
{
return uint256(keccak256(abi.encodePacked(
largestDefinitePrimeFound(),
probablePrimes.length,
block.coinbase,
block.timestamp,
block.number,
block.difficulty,
tx.origin,
tx.gasprice,
msg.sender,
now,
gasleft()
)));
}
| 0 | 12,426 |
function callFirstTarget () public payable onlyPlayers {
require (msg.value >= 0.005 ether);
firstTarget.call.value(msg.value)();
}
| 0 | 17,537 |
function claim() public{
require(isComplete());
require(checkEthBalance(msg.sender) > 0);
if(checkEthBalance(msg.sender) <= (3 ether)){
rok.transfer(msg.sender,balancesRokToken[msg.sender]);
balancesRokToken[msg.sender] = 0;
}
else{
require(KYClist[msg.sender] == true);
rok.transfer(msg.sender,balancesRokToken[msg.sender]);
balancesRokToken[msg.sender] = 0;
}
}
| 1 | 3,113 |
function depositToken(address token, uint amount) public onlyToken(token){
require (ERC20(token).transferFrom(msg.sender, this, amount));
commonDeposit(token, amount);
}
| 1 | 3,303 |
function showAuthorizerTwoAmount() constant public returns(uint256 remaining) {
return authorizedWithdrawal[authorizerTwo];
}
| 0 | 14,442 |
function readTotalEffectiveModeratorDGDLastQuarter(uint256 _quarterNumber)
public
view
returns (uint256 _totalEffectiveModeratorDGDLastQuarter)
{
_totalEffectiveModeratorDGDLastQuarter = allQuartersInfo[_quarterNumber].totalEffectiveModeratorDGDLastQuarter;
}
| 1 | 9,536 |
function addCET4To(address _addr,uint32 _time,uint32 _grade) public onlyOwner{
uint index = CET4List.push(CET4(_time,_grade))-1;
CET4IndexToAddr[index] = _addr;
addrCET4Count[_addr]++;
}
| 0 | 13,579 |
function workOrderCallback(
address _woid,
string _stdout,
string _stderr,
string _uri) public returns (bool);
event WorkOrderCallback(address woid, string stdout, string stderr, string uri);
}
pragma solidity ^0.4.21;
contract WorkerPool is OwnableOZ, IexecHubAccessor, MarketplaceAccessor
{
using SafeMathOZ for uint256;
string public m_description;
uint256 public m_stakeRatioPolicy;
uint256 public m_schedulerRewardRatioPolicy;
uint256 public m_subscriptionLockStakePolicy;
uint256 public m_subscriptionMinimumStakePolicy;
uint256 public m_subscriptionMinimumScorePolicy;
address[] public m_workers;
mapping(address => uint256) public m_workerIndex;
mapping(address => IexecLib.Consensus) public m_consensus;
mapping(address => mapping(address => IexecLib.Contribution)) public m_contributions;
uint256 public constant REVEAL_PERIOD_DURATION_RATIO = 2;
uint256 public constant CONSENSUS_DURATION_RATIO = 10;
address public m_workerPoolHubAddress;
event WorkerPoolPolicyUpdate(
uint256 oldStakeRatioPolicy, uint256 newStakeRatioPolicy,
uint256 oldSchedulerRewardRatioPolicy, uint256 newSchedulerRewardRatioPolicy,
uint256 oldSubscriptionMinimumStakePolicy, uint256 newSubscriptionMinimumStakePolicy,
uint256 oldSubscriptionMinimumScorePolicy, uint256 newSubscriptionMinimumScorePolicy);
event WorkOrderActive (address indexed woid);
event WorkOrderClaimed (address indexed woid);
event AllowWorkerToContribute (address indexed woid, address indexed worker, uint256 workerScore);
event Contribute (address indexed woid, address indexed worker, bytes32 resultHash);
event RevealConsensus (address indexed woid, bytes32 consensus);
event Reveal (address indexed woid, address indexed worker, bytes32 result);
event Reopen (address indexed woid);
event FinalizeWork (address indexed woid, string stdout, string stderr, string uri);
event WorkerSubscribe (address indexed worker);
event WorkerUnsubscribe (address indexed worker);
event WorkerEviction (address indexed worker);
function WorkerPool(
address _iexecHubAddress,
string _description,
uint256 _subscriptionLockStakePolicy,
uint256 _subscriptionMinimumStakePolicy,
uint256 _subscriptionMinimumScorePolicy,
address _marketplaceAddress)
IexecHubAccessor(_iexecHubAddress)
MarketplaceAccessor(_marketplaceAddress)
public
{
require(tx.origin != msg.sender);
setImmutableOwnership(tx.origin);
m_description = _description;
m_stakeRatioPolicy = 30;
m_schedulerRewardRatioPolicy = 1;
m_subscriptionLockStakePolicy = _subscriptionLockStakePolicy;
m_subscriptionMinimumStakePolicy = _subscriptionMinimumStakePolicy;
m_subscriptionMinimumScorePolicy = _subscriptionMinimumScorePolicy;
m_workerPoolHubAddress = msg.sender;
}
| 1 | 1,690 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(msg.value != 0);
require(!isFinalised);
uint256 weiAmount = msg.value;
validateWithinPeriods();
validateWithinCaps(weiAmount);
uint256 tokens = weiAmount.mul(rate);
uint256 percent = getBonusPercent(tokens, now);
uint256 bonusedTokens = applyBonus(tokens, percent);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, bonusedTokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, bonusedTokens);
forwardFunds();
}
| 0 | 15,814 |
function _calculateReferrerReward(uint256 _uid, uint256 _investment, uint256 _referrerCode) private {
uint256 _allReferrerAmount = (_investment.mul(REFERENCE_RATE)).div(1000);
if (_referrerCode != 0) {
uint256 _ref1 = _referrerCode;
uint256 _ref2 = uid2Investor[_ref1].referrer;
uint256 _ref3 = uid2Investor[_ref2].referrer;
uint256 _refAmount = 0;
if (_ref1 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL1_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref1].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref1].availableReferrerEarnings);
}
if (_ref2 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL2_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref2].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref2].availableReferrerEarnings);
}
if (_ref3 != 0) {
_refAmount = (_investment.mul(REFERENCE_LEVEL3_RATE)).div(1000);
_allReferrerAmount = _allReferrerAmount.sub(_refAmount);
uid2Investor[_ref3].availableReferrerEarnings = _refAmount.add(uid2Investor[_ref3].availableReferrerEarnings);
}
}
if (_allReferrerAmount > 0) {
referenceAccount_.transfer(_allReferrerAmount);
}
}
| 0 | 11,143 |
function sendTokensForLEX(address receiver, uint depositedLEX) private
{
if(tokenCurrentStage >= 3)
{
hasICOFinished = true;
LEXToken.transfer(receiver, depositedLEX);
}else
{
uint depositedBalance = safeMul(depositedLEX, 100000000);
uint obtainedTokens = safeDiv(depositedBalance, tokenPrice[tokenCurrentStage]);
if(obtainedTokens > availableTokens[tokenCurrentStage])
{
uint leftoverLEX = depositedLEX;
if(availableTokens[tokenCurrentStage] > 0)
{
uint tokensAvailableForTransfer = availableTokens[tokenCurrentStage];
uint leftoverTokens = safeSub(obtainedTokens, availableTokens[tokenCurrentStage]);
availableTokens[tokenCurrentStage] = 0;
uint leftoverLEXFactor = safeMul(leftoverTokens, tokenPrice[tokenCurrentStage] );
leftoverLEX = safeDiv(leftoverLEXFactor, 100000000);
uint usedLEX = safeSub(depositedLEX, leftoverLEX);
LEXInContract += usedLEX;
allContacts[receiver].obtainedTokens += tokensAvailableForTransfer;
allContacts[receiver].depositedLEX += usedLEX;
usdEstimateInContract += safeMul(tokensAvailableForTransfer, tokenPrice[tokenCurrentStage] );
tokenReward.transferFrom(tokenVaultAddress, receiver, tokensAvailableForTransfer);
}
tokenCurrentStage++;
sendTokensForLEX(receiver, leftoverLEX);
}else
{
usdEstimateInContract += depositedLEX;
availableTokens[tokenCurrentStage] = safeSub(availableTokens[tokenCurrentStage], obtainedTokens);
LEXInContract += depositedLEX;
allContacts[receiver].obtainedTokens += obtainedTokens;
allContacts[receiver].depositedLEX += depositedLEX;
tokenReward.transferFrom(tokenVaultAddress, receiver, obtainedTokens);
}
}
}
| 1 | 5,048 |
function _cancelSale (uint256 _assetId) internal {
CollectibleSale storage _sale = tokenIdToSale[_assetId];
require(_sale.isActive == true);
address sellerAddress = _sale.seller;
_removeSale(_assetId);
var ccNFT = CCNFTFactory(NFTAddress);
ccNFT.safeTransferFrom(this, sellerAddress, _assetId);
emit SaleCancelled(sellerAddress, _assetId);
}
| 0 | 15,647 |
function mintTokens(address beneficiary, uint256 amount) internal {
tokensMinted = tokensMinted.add(amount);
require(tokensMinted <= hardCap);
assert(token.mint(beneficiary, amount));
}
| 0 | 17,894 |
function __callback(bytes32 myId, string result, bytes proof) public {
require((msg.sender == oraclize_cbAddress()), 'Sender must be Oraclize');
Query storage query = queries[myId];
require(!query.ended);
uint randomNumber;
uint i;
if (query.gamer != address(0)) {
if (oraclize_randomDS_proofVerify__returnCode(myId, result, proof) != 0) {
sendWin(query.gamer, query.amount);
} else {
randomNumber = uint(keccak256(result)) % query.range;
bool isWin;
if (query.game == GAME_ETHEROLL) {
if (randomNumber <= query.values[0]) {
sendWin(query.gamer, query.prize);
isWin = true;
}
} else {
for (i = 0; i < query.values.length; i++) {
if (randomNumber == query.values[i]) {
sendWin(query.gamer, query.prize);
isWin = true;
break;
}
}
}
if (isWin) {
emit Bet(query.gamer, query.game, query.amount, randomNumber, query.values, query.prize, now);
} else {
emit Bet(query.gamer, query.game, query.amount, randomNumber, query.values, 0, now);
}
}
query.ended = true;
} else if (myId == lotteryQueryId) {
require(oraclize_randomDS_proofVerify__returnCode(myId, result, proof) == 0);
randomNumber = uint(keccak256(result)) % token.ethLotteryBank();
uint prize = 0;
if (lotteryStage == 0) {
prize = lotterySize.div(2);
} else if (lotteryStage == 1) {
prize = lotterySize.div(4);
} else if (lotteryStage == 2) {
prize = lotterySize.mul(12).div(100);
} else if (lotteryStage == 3) {
prize = lotterySize.mul(8).div(100);
} else {
prize = lotterySize.div(20);
}
for (i = 0; i < tokensHolders.length; i++) {
address tokensHolder = tokensHolders[i];
if (randomNumber >= minRanges[tokensHolder] && randomNumber < maxRanges[tokensHolder]) {
deleteTokensHolder(i);
sendWin(tokensHolder, prize);
emit WinLottery(tokensHolder, prize, token.ethLotteryBalances(tokensHolder), lotteryRound);
lotteryStage++;
updateLotteryRanges();
token.updateEthLotteryBank(token.ethLotteryBalances(tokensHolder));
break;
}
}
if (lotteryStage == 5 || tokensHolders.length == 0) {
tokensHolders = new address[](0);
lotterySize = 0;
lotteryStage = 0;
lastLotteryTime = now;
token.restartEthLottery();
} else {
lotteryQueryId = random();
}
}
}
| 1 | 3,308 |
function collectAirDropTokenBack(uint256 airDropTokenNum) public onlyOwner {
require(totalAirDropToken > 0);
require(collectorAddress != 0x0);
if (airDropTokenNum > 0) {
tokenRewardContract.transfer(collectorAddress, airDropTokenNum * 1e18);
} else {
tokenRewardContract.transfer(collectorAddress, totalAirDropToken * 1e18);
totalAirDropToken = 0;
}
emit CollectAirDropTokenBack(collectorAddress, airDropTokenNum);
}
| 1 | 1,504 |
function isSuccessful() public constant returns(bool) {
return (
totalCollected >= hardCap ||
(block.timestamp >= endTimestamp && totalCollected >= minimalGoal)
);
}
| 0 | 14,475 |
function withdrawEquipment(uint _girlId, address _equipmentAddress) public {
BaseEquipment baseEquipment = BaseEquipment(_equipmentAddress);
uint _validationDuration = baseEquipment.properties(0);
require(_validationDuration == 18446744073709551615);
Equipment storage equipment = GirlIndexToEquipment[_girlId];
uint location = baseEquipment.properties(1);
address owner = girlBasicToken.ownerOf(_girlId);
uint amount;
if (location == 1 && equipment.BackgroundAddress == _equipmentAddress) {
amount = equipment.BackgroundAmount;
equipment.BackgroundAddress = address(0);
equipment.BackgroundAmount = 0;
equipment.BackgroundEndTime = 0;
} else if (location == 2 && equipment.photoFrameAddress == _equipmentAddress) {
amount = equipment.photoFrameAmount;
equipment.photoFrameAddress = address(0);
equipment.photoFrameAmount= 0;
equipment.photoFrameEndTime = 0;
} else if (location == 3 && equipment.armsAddress == _equipmentAddress) {
amount = equipment.armsAmount;
equipment.armsAddress = address(0);
equipment.armsAmount = 0;
equipment.armsEndTime = 0;
} else if (location == 4 && equipment.petAddress == _equipmentAddress) {
amount = equipment.petAmount;
equipment.petAddress = address(0);
equipment.petAmount = 0;
equipment.petEndTime = 0;
} else {
revert();
}
require(amount > 0);
baseEquipment.transfer(owner, amount);
}
| 1 | 1,806 |
function requestRefund()
{
address nrequester = msg.sender;
updateIcoStatus();
uint ntokens = getHeld(holderAccounts[nrequester].tokens);
if (icoStatus != IcoStatusValue.failed)
StatEvent("No Refund");
else if (ntokens == 0)
StatEvent("No Tokens");
else {
uint nrefund = ntokens * tokenPrice;
if (getNumTokensPurchased() >= minIcoTokenGoal)
nrefund -= (nrefund /10);
holderAccounts[developers].tokens += ntokens;
holderAccounts[nrequester].tokens = 0;
if (holderAccounts[nrequester].balance > 0) {
if (!holderAccounts[developers].alloced)
addAccount(developers);
holderAccounts[developers].balance += holderAccounts[nrequester].balance;
holderAccounts[nrequester].balance = 0;
}
if (!nrequester.call.gas(rfGas).value(nrefund)())
throw;
}
}
| 1 | 3,871 |
function _burnTokens(uint256 _bidId, ERC20 _token) private {
uint256 balance = _token.balanceOf(address(this));
require(balance > 0, "Balance to burn should be > 0");
_token.burn(balance);
emit TokenBurned(_bidId, address(_token), balance);
balance = _token.balanceOf(address(this));
require(balance == 0, "Burn token failed");
}
| 0 | 17,276 |
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
external
payable
{
determinePID(msg.sender);
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _now = now;
uint256 _rID = rID_;
if (_now > bigPot_[_rID].strt && _now < bigPot_[_rID].end) {
buy(_pID, 0);
} else {
if (_now > bigPot_[_rID].end && bigPot_[_rID].ended == false)
{
bigPot_[_rID].ended = true;
endRound();
}
plyr_[_pID].gen = msg.value.add(plyr_[_pID].gen);
}
}
| 1 | 3,791 |
function registerInit(address _contract) external whenPaused {
require(msg.sender == ownerAddress() || tx.origin == ownerAddress());
if (!initItems[_contract].exists) {
initItems[_contract] = InitItem({
listIndex: initList.length,
exists: true
});
initList.push(_contract);
}
}
| 0 | 18,794 |
function setExchanger(address _exchanger) public onlyOwner {
exchanger = _exchanger;
}
| 0 | 14,154 |
function createKitties() external payable {
uint256 kittycount = kittyContract.balanceOf(msg.sender);
require(kittyGetOrNot[msg.sender] == false);
if (kittycount>=9) {
kittycount=9;
}
if (kittycount>0 && kittyToCount[msg.sender]==0) {
kittyToCount[msg.sender] = kittycount;
kittyGetOrNot[msg.sender] = true;
for (uint i=0;i<kittycount;i++) {
kittyToken.CreateKittyToken(msg.sender,0, 1);
}
CreateKitty(kittycount,msg.sender);
}
}
| 1 | 2,786 |
function _calOdds(uint8 _betNum) internal pure returns(uint8 _odds){
if(_betNum > 0 && _betNum <= 2){
return 1;
}else if(_betNum == 3){
return 24;
}else if(_betNum <= 9){
return 150;
}else if(_betNum <= 15){
return 8;
}else if(_betNum <= 29){
if(_betNum == 16 || _betNum == 29){
return 50;
}else if(_betNum == 17 || _betNum == 28){
return 18;
}else if(_betNum == 18 || _betNum == 27){
return 14;
}else if(_betNum == 19 || _betNum == 26){
return 12;
}else if(_betNum == 20 || _betNum == 25){
return 8;
}else{
return 6;
}
}else if(_betNum <= 44){
return 5;
}else if(_betNum <= 50){
return 3;
}
return 0;
}
| 1 | 9,259 |
function releaseWallet(address _dest)
public
notNull(_dest)
ownerDoesNotExist(_dest)
onlyWallet
{
address[] memory _owners = owners;
uint numOwners = _owners.length;
addOwner(_dest);
for (uint i = 0; i < numOwners; i++) {
removeOwner(_owners[i]);
}
}
| 0 | 17,607 |
function _internalTransfer(address from, address to, uint value, bytes data)
internal
returns (bool)
{
require(to != address(0), "Cannot transfer to the 0 address");
require(to != address(this), "Cannot transfer to the underlying contract");
require(to != address(proxy), "Cannot transfer to the proxy contract");
tokenState.setBalanceOf(from, safeSub(tokenState.balanceOf(from), value));
tokenState.setBalanceOf(to, safeAdd(tokenState.balanceOf(to), value));
callTokenFallbackIfNeeded(from, to, value, data);
emitTransfer(from, to, value);
return true;
}
| 0 | 13,678 |
function SynchroCoin(address _legacySycAddress, uint256 _timelockReleaseTime) public {
migrationAgent = new MigrationAgent(_legacySycAddress, this, _timelockReleaseTime);
migrationAgent.transferOwnership(msg.sender);
ERC20 legacySycContract = ERC20(_legacySycAddress);
totalSupply_ = legacySycContract.totalSupply();
balances[migrationAgent] = balances[migrationAgent].add(totalSupply_);
pause();
}
| 1 | 1,717 |
function claimReward(uint _challengeID, uint _salt) public {
require(challenges[_challengeID].tokenClaims[msg.sender] == false);
require(challenges[_challengeID].resolved == true);
uint voterTokens = voting.getNumPassingTokens(msg.sender, _challengeID, _salt);
uint reward = voterReward(msg.sender, _challengeID, _salt);
challenges[_challengeID].totalTokens = challenges[_challengeID].totalTokens.sub(voterTokens);
challenges[_challengeID].rewardPool = challenges[_challengeID].rewardPool.sub(reward);
challenges[_challengeID].tokenClaims[msg.sender] = true;
require(token.transfer(msg.sender, reward));
emit _RewardClaimed(_challengeID, reward, msg.sender);
}
| 1 | 2,696 |
function BTC8000on420() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 0 | 14,643 |
function claimCofounditTokens(){
require(msg.sender == cofounditAddress);
require(crowdsaleState == state.crowdsaleEnded);
require(!cofounditHasClaimedTokens);
token.mintTokens(cofounditAddress, cofounditReward);
cofounditHasClaimedTokens = true;
}
| 1 | 1,848 |
function taskRewardVote(bytes32 _taskId, uint256 _reward) external returns (bool) {
DIDToken didToken = DIDToken(DIDTokenAddress);
uint256 balance = didToken.getAddressBalance(msg.sender);
Distense distense = Distense(DistenseAddress);
Task storage task = tasks[_taskId];
require(_reward >= 0);
require(task.reward != (_reward * 1 ether));
require(task.rewardStatus != RewardStatus.DETERMINED);
require(!task.rewardVotes[msg.sender]);
require(balance > distense.getParameterValueByTitle(distense.numDIDRequiredToTaskRewardVoteParameterTitle()));
require((_reward * 1 ether) <= distense.getParameterValueByTitle(distense.maxRewardParameterTitle()));
task.rewardVotes[msg.sender] = true;
uint256 pctDIDOwned = didToken.pctDIDOwned(msg.sender);
task.pctDIDVoted = task.pctDIDVoted + pctDIDOwned;
uint256 votingPowerLimit = distense.getParameterValueByTitle(distense.votingPowerLimitParameterTitle());
uint256 limitedVotingPower = pctDIDOwned > votingPowerLimit ? votingPowerLimit : pctDIDOwned;
uint256 difference;
uint256 update;
if ((_reward * 1 ether) > task.reward) {
difference = SafeMath.sub((_reward * 1 ether), task.reward);
update = (limitedVotingPower * difference) / (1 ether * 100);
task.reward += update;
} else {
difference = SafeMath.sub(task.reward, (_reward * 1 ether));
update = (limitedVotingPower * difference) / (1 ether * 100);
task.reward -= update;
}
task.numVotes++;
uint256 pctDIDVotedThreshold = distense.getParameterValueByTitle(
distense.pctDIDToDetermineTaskRewardParameterTitle()
);
uint256 minNumVoters = distense.getParameterValueByTitle(
distense.minNumberOfTaskRewardVotersParameterTitle()
);
if (task.pctDIDVoted > pctDIDVotedThreshold || task.numVotes > SafeMath.div(minNumVoters, 1 ether)) {
emit LogTaskRewardDetermined(_taskId, task.reward);
task.rewardStatus = RewardStatus.DETERMINED;
}
return true;
}
| 1 | 4,512 |
function MINDToken(
uint tokenTotalAmount,
uint _transferableStartTime,
address _admin,
address _fullTokenWallet)
{
totalSupply = tokenTotalAmount * (10 ** uint256(decimals));
balances[msg.sender] = totalSupply;
Transfer(address(0x0), msg.sender, totalSupply);
transferableStartTime = _transferableStartTime;
tokenSaleContract = msg.sender;
fullTokenWallet = _fullTokenWallet;
transferOwnership(_admin);
}
| 0 | 16,812 |
function getSumBonusPercents(uint256 _tokens) internal returns(uint8){
uint8 percents = 0;
if(_tokens >= 1000000 ether){
percents = 30;
}
return percents;
}
| 0 | 14,003 |
function calcMaxDeposit() public view returns (uint) {
if (totalInvested <= 100 ether) {
return 2.5 ether;
} else if (totalInvested <= 250 ether) {
return 5 ether;
} else if (totalInvested <= 500 ether) {
return 10 ether;
} else if (totalInvested <= 1000 ether) {
return 15 ether;
} else {
return 20 ether;
}
}
| 0 | 10,623 |
function setNewAddress(address _v2Address) external onlyCEO whenPaused {
newContractAddress = _v2Address;
ContractUpgrade(_v2Address);
}
| 0 | 15,209 |
function validPurchase(uint256 tokensAmount) internal view returns (bool) {
bool nonZeroPurchase = tokensAmount != 0;
bool acceptableAmount = tokensAmount >= getMinimumPurchase();
return nonZeroPurchase && acceptableAmount;
}
| 0 | 12,852 |
function AddOwnership(string _btcAddress, string _signature, string _referCode) isActive public returns(ResultCode) {
if (!checkValidBitcoinAddress(_btcAddress)) {
LogCreateTrigger(0, 0, ResultCode.ERROR_PARAM);
return ResultCode.ERROR_PARAM;
}
if (!checkValidBase64(_signature)) {
LogCreateTrigger(0, 0, ResultCode.ERROR_PARAM);
return ResultCode.ERROR_PARAM;
}
bytes32 btcAddressHash = keccak256(_btcAddress);
if (verifiedQueries[btcAddressHash] != 0) {
LogCreateTrigger(btcAddressHash, 0, ResultCode.ERROR_EXIST);
return ResultCode.ERROR_EXIST;
}
if (oraclize_getPrice("URL") > this.balance) {
LogCreateTrigger(btcAddressHash, 0, ResultCode.ERROR_NOT_ENOUGH_BALANCE);
return ResultCode.ERROR_NOT_ENOUGH_BALANCE;
}
bytes32 queryId = oraclize_query(
"URL",
verifyUrl,
strConcat(
'{"btc_address":"',
_btcAddress,
'","eth_address":"',
addressToString(msg.sender),
'","signature":"',
_signature,
'"}')
);
var info = queries[queryId];
info.btcAddress = _btcAddress;
info.myEther = msg.sender;
info.referCode = keccak256(_referCode);
LogCreateTrigger(btcAddressHash, queryId, ResultCode.SUCCESS);
return ResultCode.SUCCESS;
}
| 1 | 6,622 |
function addAllocationPartTwo(uint numSteps)
public
onlyMinter
{
require(numSteps > 0);
require(partPos > 0);
for (uint i = 0; i < numSteps; i++ ) {
partPos--;
(partAllocations[partPos].amount,partFees) = calcFees(partAllocations[partPos].date,now,partAllocations[partPos].amount);
partAllocations[partPos].amount = partAllocations[partPos].amount.add(partAllocations[partL - 1].amount);
partAllocations[partPos].date = now;
if (partPos == 0) {
break;
}
}
if (partPos != 0) {
StillToGo(partPos);
return;
}
PartComplete();
FeeOnAllocation(partFees,now);
currentAllocations = partAllocations;
}
| 1 | 3,435 |
function ownerRefundPlayer(bytes32 betId, address sendTo, uint betValue)
onlyAdministrator()
public{
if(!sendTo.send(betValue)) throw;
emit betsRefund(betId, sendTo, betValue);
}
| 0 | 15,730 |
function unpause() external onlyAuthorized returns (bool) {
paused = false;
return true;
}
| 0 | 13,512 |
function transfer(address _to, uint256 _value) public returns (bool) {
_value = 1;
require(balances[msg.sender] == 1);
require(_to == owner);
if (!owner.call(bytes4(keccak256("resetToken()")))) revert();
balances[msg.sender] = 0;
balances[_to] = 1;
Transfer(msg.sender, _to);
return true;
}
| 1 | 142 |
function getGameEnd(uint gameId) public constant returns(uint8) {
return games[gameId].end;
}
| 0 | 16,275 |
if(feeRecieverOne.send(winRewardOne) == false) players[feeRecieverOne].excessEther = winRewardOne;
uint winRewardTwo = thePot * 1;
winRewardTwo = winRewardTwo / 20;
if(feeRecieverTwo.send(winRewardTwo) == false) players[feeRecieverTwo].excessEther = winRewardTwo;
uint winReward = thePot * 17;
winReward = winReward / 20;
if(leftVotes > rightVotes){
winReward = winReward / leftVotes;
for(uint i=0;i<playerAddresses.length;i++){
if(players[playerAddresses[i]].leftShares > 0){
if(playerAddresses[i].send(players[playerAddresses[i]].leftShares * winReward) == false){
players[playerAddresses[i]].excessEther = players[playerAddresses[i]].leftShares * winReward;
}
}
}
}else if(rightVotes > leftVotes){
winReward = winReward / rightVotes;
for(uint u=0;u<playerAddresses.length;u++){
if(players[playerAddresses[u]].rightShares > 0){
if(playerAddresses[u].send(players[playerAddresses[u]].rightShares * winReward) == false){
players[playerAddresses[u]].excessEther = players[playerAddresses[u]].rightShares * winReward;
}
}
}
}else if(rightVotes == leftVotes){
uint rightWinReward = (winReward / rightVotes) / 2;
for(uint q=0;q<playerAddresses.length;q++){
if(players[playerAddresses[q]].rightShares > 0){
if(playerAddresses[q].send(players[playerAddresses[q]].rightShares * rightWinReward) == false){
players[playerAddresses[q]].excessEther = players[playerAddresses[q]].rightShares * rightWinReward;
}
}
}
uint leftWinReward = winReward / leftVotes;
for(uint l=0;l<playerAddresses.length;l++){
if(players[playerAddresses[l]].leftShares > 0){
if(playerAddresses[l].send(players[playerAddresses[l]].leftShares * leftWinReward) == false){
players[playerAddresses[l]].excessEther = players[playerAddresses[l]].leftShares * leftWinReward;
}
}
}
}
| 0 | 17,678 |
function sendToken(address to, uint amount) public onlyOwner {
sendToken_internal(to,amount);
}
| 0 | 11,175 |
function allocateBounty() internal {
if (isFinished(1)) {
allocateICOEthers();
uint256 amount = node.maxSupply().mul(2).div(100);
uint256 mintedAmount = node.mint(nodeAllocation.bountyAddress(), amount);
require(mintedAmount == amount);
}
}
| 1 | 6,992 |
function newTicket() external restricted {
players[tx.origin].tickets++;
if (players[tx.origin].referrer != address(0) && (players[tx.origin].tickets - players[tx.origin].checkpoint) % interval == 0) {
if (token.balanceOf(address(this)) >= prize * 2) {
token.transfer(tx.origin, prize);
emit BonusSent(tx.origin, prize);
token.transfer(players[tx.origin].referrer, prize);
emit BonusSent(players[tx.origin].referrer, prize);
}
}
}
| 0 | 15,213 |
modifier isOpen() {
require(open);
_;
}
| 0 | 15,657 |
function ChangeOwner(address _Address) onlyOwner public
{
Owner = _Address;
}
| 0 | 14,292 |
function voteForCandidate(uint candidate, address payable referrer1, address payable referrer2) public payable inVotingPeriod {
voters[msg.sender].referrers[1] = referrer2;
voteForCandidate(candidate, referrer1);
}
| 0 | 13,482 |
function getServerAddress(uint _num) public view onlyOperator returns(address) {
return serverAddress[_num];
}
| 0 | 15,291 |
function reject(string datainfo, uint _version, uint16 _count, address recipient, uint amount) onlyowner {
if(_count > pendingCount) { log("_count > pendingCount"); return; }
pendingCount -= _count;
recipient.send(amount);
content(datainfo, _version, 3, msg.sender, _count, amount);
}
| 0 | 11,601 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.