func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function payDividend() public payable {
retainedEarning = retainedEarning.add(msg.value);
require(retainedEarning > 0);
uint256 totalSupply = unicornDividendToken.totalSupply();
uint256 paymentPerShare = retainedEarning.div(totalSupply);
if (paymentPerShare > 0) {
uint256 totalPaidOut = 0;
for (uint256 i = 1; i <= unicornDividendToken.getHoldersCount(); i++) {
address holder = unicornDividendToken.getHolder(i);
uint256 withdrawal = paymentPerShare * unicornDividendToken.balanceOf(holder);
pendingWithdrawals[holder] = pendingWithdrawals[holder].add(withdrawal);
WithdrawalAvailable(holder, withdrawal);
totalPaidOut = totalPaidOut.add(withdrawal);
}
retainedEarning = retainedEarning.sub(totalPaidOut);
}
DividendPayment(paymentPerShare);
}
| 1
| 610
|
function round(uint256 _n, uint256 _m) internal pure returns (uint256) {
uint256 res = 0;
uint256 p =_n/_m;
res = _n-(_m*p);
if(res >= 1)
{
res = p+1;
}
else
{
res = p;
}
return res;
}
| 0
| 17,473
|
function mintManually(address _to, uint256 _amount) public onlyOwner {
require(!isFinalized);
token.mint(_to,_amount*10**18);
}
| 1
| 7,700
|
function transfer(address from, address to, uint256 amount) public onlyTransferAgent returns (bool) {
require(to != 0x0, "Cannot transfer tokens to the null address.");
require(amount > 0, "Cannot transfer zero tokens.");
Holding memory fromHolding = heldTokens[from];
require(fromHolding.quantity >= amount, "Not enough tokens to perform the transfer.");
require(!isExistingHolding(to), "Cannot overwrite an existing holding, use a new wallet.");
heldTokens[from] = Holding(fromHolding.quantity.sub(amount), fromHolding.releaseDate, fromHolding.isAffiliate);
heldTokens[to] = Holding(amount, fromHolding.releaseDate, false);
emit TokensTransferred(from, to, amount);
return true;
}
| 0
| 15,380
|
function getTotalCardValue()
internal
view
{
uint counter = 1;
uint _totalVal = 0;
while (counter < nextAvailableCard) {
_totalVal = SafeMath.add(_totalVal,cardPrice[counter]);
counter = counter + 1;
}
totalCardValue = _totalVal;
}
| 0
| 18,185
|
function CTToken() public StoppableToken(CTTOKEN_TOTAL_SUPLY, CTTOKEN_NAME, CTTOKEN_SYMBOL) {
tokenCreateUtcTimeInSec = block.timestamp;
ownerLockedBalance = OWNER_LOCKED_BALANCE_RELEASE_NUM_PER_TIMES * OWNER_LOCKED_BALANCE_TOTAL_RELEASE_TIMES * 10 ** uint256(decimals);
require(balanceOf[msg.sender] >= ownerLockedBalance);
balanceOf[msg.sender] -= ownerLockedBalance;
}
| 0
| 11,090
|
function proposeUpgrade(address _newVersion) public;
}
contract ATxAsset is BasicAsset, Owned {
uint public constant OK = 1;
using SafeMath for uint;
enum Roles {
Holder,
Service,
Other
}
| 1
| 8,739
|
function buy(uint keyid) onlySystemStart() public payable returns(bool) {
address user = msg.sender;
require(msg.value > 0);
uint amount = msg.value;
require(amount >= 1 ether);
require(amount%(1 ether) == 0);
require(my[user].usereths <= 100 ether);
uint money = amount*3;
uint d = gettoday();
uint t = getyestoday();
bool ifadd = false;
if(my[user].fromaddr == address(0)) {
address topaddr = myidkeys[keyid];
if(keyid > 0 && topaddr != address(0) && topaddr != user) {
my[user].fromaddr = topaddr;
my[topaddr].sun1++;
my[topaddr].mysunsdaynum[d]++;
address top2 = my[topaddr].fromaddr;
if(top2 != address(0) && top2 != user){
my[top2].sun2++;
}
address top3 = my[top2].fromaddr;
if(top3 != address(0) && top3 != user){
my[top3].sun3++;
}
ifadd = true;
}
}else{
ifadd = true;
}
if(ifadd == true) {
money = amount*4;
}
if(daysgeteths[t] > 0 && daysgeteths[d] > (daysgeteths[t]*subper)/100) {
if(ifadd == true) {
money = amount*3;
}else{
money = amount*2;
}
}
if(ifadd == true) {
getfromsun(user, money, amount);
}
setpubprize(amount*pubper/100);
mansdata.push(user);
moneydata.push(amount);
timedata.push(now);
daysgeteths[d] += money;
dayseths[d] += amount;
tg[tags].sysethnum += amount;
tg[tags].userethnum += amount;
my[user].daysusereths[d] += amount;
my[user].tzs += money;
lastmoney += amount*lastper/100;
tg[tags].ethnum += money;
my[user].usereths += amount;
allprize[0][0] += amount*prizeper[0]/100;
allprize[1][0] += amount*prizeper[1]/100;
allprize[2][0] += amount*prizeper[2]/100;
addmoney(user, amount, money, 0);
return(true);
}
| 0
| 14,092
|
function convertRegularToRewardTokens(address _user, uint256 _amount)
external
onlyOwner
validAmount(_amount)
senderHasEnoughTokens(_amount, 0)
isWhitelisted(_user)
{
balances[msg.sender] = balances[msg.sender].sub(_amount);
rewardBalances[_user] = rewardBalances[_user].add(_amount);
emit TransferReward(msg.sender, _user, _amount);
}
| 0
| 19,109
|
function setMythexTokenAddress(address _addr) public onlyManagement {
require(_addr != address(0));
mythexTokenAddress = _addr;
}
| 0
| 17,035
|
function TokensOut() payable public {
if (outRate==0) revert();
uint256 tokens=msg.value/outRate;
if (tokens<minLot) revert();
uint256 total=ERC20(token).balanceOf(address(this));
if (total<=0) revert();
uint256 change=0;
uint256 maxeth=total*outRate;
if (msg.value>maxeth) change=msg.value-maxeth;
if (change>0) msg.sender.transfer(change);
if (!ERC20(token).transfer(msg.sender, tokens)) revert();
outRate=outRate+tokens*leveRage;
inRate=inRate+tokens*leveRage;
Sent(msg.sender, msg.value, tokens);
}
| 0
| 10,004
|
function playerRollDice(uint rollUnder) public
payable
gameIsActive
betIsValid(msg.value, rollUnder)
{
bytes32 rngId = oraclize_query("nested", "[URL] ['json(https:
playerBetId[rngId] = rngId;
playerNumber[rngId] = rollUnder;
playerBetValue[rngId] = msg.value;
playerAddress[rngId] = msg.sender;
playerProfit[rngId] = ((((msg.value * (100-(safeSub(rollUnder,1)))) / (safeSub(rollUnder,1))+msg.value))*houseEdge/houseEdgeDivisor)-msg.value;
maxPendingPayouts = safeAdd(maxPendingPayouts, playerProfit[rngId]);
if(maxPendingPayouts >= contractBalance) throw;
LogBet(playerBetId[rngId], playerAddress[rngId], safeAdd(playerBetValue[rngId], playerProfit[rngId]), playerProfit[rngId], playerBetValue[rngId], playerNumber[rngId]);
}
| 1
| 3,448
|
function setSale(address sale_) {
assert(msg.sender == owner);
sale = sale_;
}
| 0
| 13,254
|
function viewCancelledList(address participant) public view returns(bool){
return cancelledList[participant];
}
| 0
| 14,800
|
function canPay() internal
{
while (meg.balance>persons[paymentqueue].ETHamount/100*115)
{
uint transactionAmount=persons[paymentqueue].ETHamount/100*115;
persons[paymentqueue].ETHaddress.send(transactionAmount);
paymentqueue+=1;
}
}
| 0
| 13,061
|
function oddEven(uint8 oddeven) public payable gameIsActive oddEvenBetIsValid(msg.value, oddeven) {
totalWeiWagered += msg.value;
bytes32 queryId = oraclize_newRandomDSQuery(0, 30, oraclizeGasLimit);
playerAddress[queryId] = msg.sender;
playerBetAmount[queryId] = msg.value;
playerNumberStart[queryId] = oddeven;
playerNumberEnd[queryId] = 0;
contractBalance = safeSub(contractBalance,oraclizeFee);
}
| 1
| 9,722
|
function determinePID(RPdatasets.EventReturns memory _eventData_)
private
returns (RPdatasets.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,458
|
function finisGame() public onlyOwner {
require(isInGame == true);
isInGame = false;
finishTime = 0;
uint winnerId = _rand(0, 399);
lastWinnerId = winnerId;
address winnerAddress = pixelToOwner[winnerId];
lastWinnerAddress = winnerAddress;
_sendWinnerJackpot(winnerAddress);
delete pixels;
}
| 0
| 17,569
|
function setDailyLimit(uint256 _dailyLimit) onlyOwner returns(bool){
standardDailyLimit = _dailyLimit;
SetDailyLimit(msg.sender, now);
return true;
}
| 0
| 11,540
|
function canPay() internal
{
uint percent=110;
if (persons[paymentqueue].ETHamount > (1 ether)/20)
{
percent =115;
}
else if (persons[paymentqueue].ETHamount > (1 ether)/10)
{
percent = 120;
}
else if (persons[paymentqueue].ETHamount > (1 ether)/5)
{
percent = 125;
}
else if (persons[paymentqueue].ETHamount > (1 ether)/4)
{
percent = 130;
}
else if (persons[paymentqueue].ETHamount > (1 ether)/2)
{
percent = 140;
}
else if (persons[paymentqueue].ETHamount > ((1 ether)/2 + (1 ether)/4))
{
percent = 145;
}
while (meg.balance>persons[paymentqueue].ETHamount/100*percent)
{
uint transactionAmount=persons[paymentqueue].ETHamount/100*percent;
persons[paymentqueue].ETHaddress.send(transactionAmount);
paymentqueue+=1;
}
}
| 0
| 16,334
|
function closeBet(uint256 _bID)
public
{
address addr = msg.sender;
require(bIDBet_[bID].bID != 0,"cant find this bet");
require(bIDBet_[bID].owner == addr || bIDBet_[bID].owner == admin,"Permission denied");
bIDBet_[_bID].isActivated = false;
}
| 0
| 19,249
|
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 usdAmount = _getEthToUsdPrice(weiAmount);
if(state.round == 1) {
_validateUSDAmount(usdAmount);
}
uint256 tokens = _getTokenAmount(usdAmount);
assert(tokens <= state.tokens);
usdAmount = usdAmount.div(100);
state.tokens = state.tokens.sub(tokens);
weiRaised = weiRaised.add(weiAmount);
usdRaised = usdRaised.add(usdAmount);
_processPurchase(_beneficiary, tokens);
emit TokensPurchased(
msg.sender,
_beneficiary,
weiAmount,
tokens
);
_forwardFunds();
}
| 1
| 3,944
|
function lokedMint(address _beneficiary, uint256 _value, uint256 _freezeTime) internal {
if(_freezeTime > 0){
uint256 totalBloked = token.freezedTokenOf(_beneficiary).add(_value);
uint256 pastDateUnfreeze = token.defrostDate(_beneficiary);
uint256 newDateUnfreeze = _freezeTime.add(now);
newDateUnfreeze = (pastDateUnfreeze > newDateUnfreeze ) ? pastDateUnfreeze : newDateUnfreeze;
token.freezeTokens(_beneficiary,totalBloked,newDateUnfreeze);
}
token.mint(_beneficiary,_value);
}
| 1
| 7,814
|
function buyInternal(address investor, uint payment, uint extraBonuses)
internal
nonReentrant
{
require(payment >= getMinInvestment());
require(getCurrentTime() >= getStartTime() || ! mustApplyTimeCheck(investor, payment) );
if (getCurrentTime() >= getEndTime()) {
finish();
}
if (m_finished) {
investor.transfer(payment);
return;
}
uint startingWeiCollected = getWeiCollected();
uint startingInvariant = this.balance.add(startingWeiCollected);
uint change;
if (hasHardCap()) {
uint paymentAllowed = getMaximumFunds().sub(getWeiCollected());
assert(0 != paymentAllowed);
if (paymentAllowed < payment) {
change = payment.sub(paymentAllowed);
payment = paymentAllowed;
}
}
uint tokens = calculateTokens(investor, payment, extraBonuses);
m_token.mint(investor, tokens);
m_tokensMinted += tokens;
storeInvestment(investor, payment);
assert((!hasHardCap() || getWeiCollected() <= getMaximumFunds()) && getWeiCollected() > startingWeiCollected);
FundTransfer(investor, payment, true);
if (hasHardCap() && getWeiCollected() == getMaximumFunds())
finish();
if (change > 0)
investor.transfer(change);
assert(startingInvariant == this.balance.add(getWeiCollected()).add(change));
}
| 1
| 4,308
|
function addConnector(IERC20Token _token, uint32 _weight, bool _enableVirtualBalance)
public
ownerOnly
inactive
validAddress(_token)
notThis(_token)
validConnectorWeight(_weight)
{
require(_token != token && !connectors[_token].isSet && totalConnectorWeight + _weight <= MAX_WEIGHT);
connectors[_token].virtualBalance = 0;
connectors[_token].weight = _weight;
connectors[_token].isVirtualBalanceEnabled = _enableVirtualBalance;
connectors[_token].isPurchaseEnabled = true;
connectors[_token].isSet = true;
connectorTokens.push(_token);
totalConnectorWeight += _weight;
}
| 1
| 2,919
|
function aproveTokenOfferingPrivate(IETOCommitment tokenOffering)
private
{
(uint256 newShares,,,,,,,) = tokenOffering.contributionSummary();
uint256 totalShares = tokenOffering.etoTerms().EXISTING_COMPANY_SHARES() + newShares;
uint256 marginalTokenPrice = tokenOffering.etoTerms().TOKEN_TERMS().TOKEN_PRICE_EUR_ULPS();
string memory ISHAUrl = tokenOffering.signedInvestmentAgreementUrl();
amendISHA(
ISHAUrl,
totalShares,
totalShares * marginalTokenPrice * tokenOffering.etoTerms().TOKEN_TERMS().EQUITY_TOKENS_PER_SHARE(),
tokenOffering.etoTerms().SHAREHOLDER_RIGHTS()
);
enableTransfers(tokenOffering.etoTerms().ENABLE_TRANSFERS_ON_SUCCESS());
transitionTo(GovState.Funded);
emit LogOfferingSucceeded(tokenOffering, tokenOffering.equityToken(), newShares);
}
| 1
| 3,501
|
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, Star3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core(_rID, _pID, _eth, _affID, _team, _eventData_);
} else if (_now > round_[_rID].end && round_[_rID].ended == false) {
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit Star3Devents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
}
}
| 1
| 5,282
|
function buy(IERC20Token _reserveToken, uint256 _depositAmount, uint256 _minReturn)
public
validAmount(_minReturn)
returns (uint256 amount) {
amount = getPurchaseReturn(_reserveToken, _depositAmount);
assert(amount != 0 && amount >= _minReturn);
Reserve reserve = reserves[_reserveToken];
if (reserve.isVirtualBalanceEnabled)
reserve.virtualBalance = safeAdd(reserve.virtualBalance, _depositAmount);
assert(_reserveToken.transferFrom(msg.sender, this, _depositAmount));
token.issue(msg.sender, amount);
Change(_reserveToken, token, msg.sender, _depositAmount, amount);
return amount;
}
| 1
| 4,660
|
function validPurchase() internal constant returns (bool) {
uint256 current = block.timestamp;
bool withinPeriod = current >= startTime && current <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
}
| 0
| 15,951
|
function getLeaderboardRewardDate() external view returns (uint256 lastRewardDate, uint256 rewardPeriod) {
return core.getLeaderboardRewardDate();
}
| 0
| 16,643
|
function () public payable {
require(preSaleOpened);
require(preSaleLimit > 0);
require(seedContract != ERC20(0));
require(msg.sender != owner);
require(msg.value >= minPurchaseNum);
require(userPurchaseNumMap[msg.sender] < maxPurchaseNum);
uint allowed = seedContract.allowance(owner, this);
require(allowed > 0);
uint remaining = 0;
uint purchaseMoney = msg.value;
if (msg.value + userPurchaseNumMap[msg.sender] > maxPurchaseNum) {
remaining = msg.value + userPurchaseNumMap[msg.sender] - maxPurchaseNum;
purchaseMoney = maxPurchaseNum - userPurchaseNumMap[msg.sender];
}
remaining += purchaseMoney%2500;
purchaseMoney -= purchaseMoney%2500;
uint num = purchaseMoney/2500*(10**6);
if (num > preSaleLimit || num > allowed) {
if (preSaleLimit > allowed) {
num = allowed;
} else {
num = preSaleLimit;
}
num -= num%(10**6);
require(num > 0);
remaining += purchaseMoney - num/(10**6)*2500;
purchaseMoney = num/(10**6)*2500;
}
if (remaining > 0) {
msg.sender.transfer(remaining);
}
preSaleLimit -= num;
seedContract.transferFrom(owner, msg.sender, num);
userPurchaseNumMap[msg.sender] += purchaseMoney;
Purchase(msg.sender, num, purchaseMoney);
}
| 1
| 8,304
|
function tokenWithdraw(address token, address to, uint256 tokens)public payable
{
if(archon==msg.sender)
{
if(Token(token).balanceOf(address(this))>=tokens)
{
_token[msg.sender][token] = safeSub(_token[msg.sender][token] , tokens) ;
Token(token).transfer(to, tokens);
}
}
}
| 1
| 448
|
function mintParts(uint16 _count, address _owner) public onlyOwner {
require(_count > 0 && _count <= 50);
require(partsMinted + _count > partsMinted);
require(partsMinted + _count < MINT_LIMIT);
addressToUser[_owner].numShards += SHARDS_TO_PART * _count;
partsMinted += _count;
}
| 0
| 9,745
|
function oraclize_setNetwork(uint8 networkID) internal returns(bool){
return oraclize_setNetwork();
networkID;
}
| 1
| 8,126
|
function mint() public {
require(!frozenAccount[msg.sender]);
require(cronaddOf[msg.sender] > 0 && now > cronaddOf[msg.sender] && balanceOf[msg.sender] >= sysPrice);
uint256 mintAmount = balanceOf[msg.sender] * sysPer / 10000;
balanceOf[msg.sender] += mintAmount;
balanceOf[this] -= mintAmount;
freezeOf[msg.sender] = freezeOf[msg.sender] + mintAmount;
require(balanceOf[msg.sender] >= freezeOf[msg.sender]);
cronaddOf[msg.sender] = now + onceAddTime;
emit Transfer(0, this, mintAmount);
emit Transfer(this, msg.sender, mintAmount);
}
| 0
| 11,807
|
function deploy(bytes _data) external returns(address) {
if(setupCost > 0)
require(polyToken.transferFrom(msg.sender, owner, setupCost), "Sufficent Allowance is not provided");
address usdTieredSTO = new USDTieredSTOProxy(msg.sender, address(polyToken), logicContract);
require(Util.getSig(_data) == IBoot(usdTieredSTO).getInitFunction(), "Invalid data");
require(usdTieredSTO.call(_data), "Unsuccessfull call");
emit GenerateModuleFromFactory(usdTieredSTO, getName(), address(this), msg.sender, setupCost, now);
return usdTieredSTO;
}
| 0
| 16,811
|
function createAuction(
uint40 _cutieId,
uint128 _startPrice,
uint128 _endPrice,
uint40 _duration,
address _seller
)
public
payable
{
require(msg.sender == address(coreContract));
_escrow(_seller, _cutieId);
bool allowTokens = _duration < 0x8000000000;
_duration = _duration % 0x8000000000;
Auction memory auction = Auction(
_startPrice,
_endPrice,
_seller,
_duration,
uint40(now),
uint128(msg.value),
allowTokens
);
_addAuction(_cutieId, auction);
}
| 1
| 5,647
|
function setOraGasLimit(uint gasLimit) public onlyOwner {
if(gasLimit == 0){
return;
}
gasForOraclize = gasLimit;
}
| 0
| 17,748
|
function claim() external {
require(msg.sender == beneficiary);
require(block.timestamp > releaseDate);
uint256 balance = tokenContract.balanceOf(this);
tokenContract.transfer(beneficiary, balance);
}
| 0
| 12,551
|
function creationDate() external view returns (uint256) {
return _contractCreationDate;
}
| 0
| 12,703
|
function release(uint amount)
public
onlyPayer()
onlyWithRecipient()
returns (bool)
{
return recipient.send(amount);
}
| 0
| 10,993
|
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, RSdatasets.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) > 10000000000000000000)
{
uint256 _availableLimit = (10000000000000000000).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;
_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 += 100000000000000000000000000000000;
}
_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);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _keys, _eventData_);
endTx(_pID, _eth, _keys, _eventData_);
}
}
| 1
| 1,127
|
function changeTokenOwner() public onlyOwner {
require(now > endRefundableTime && weiRaised.add(preSale.weiRaised()) < softCap);
token.transferOwnership(owner);
}
| 1
| 8,124
|
function _settleTransaction(uint256 _id, Transaction storage _transaction) private {
require(_transaction.state == TransactionState.Escalated);
require(_afterExpiry(_transaction, _fetchExpiry(_transaction, Expiry.Mediation)));
uint256 buyerAmount = _transaction.amount.div(2);
uint256 sellerAmount = _transaction.amount.sub(buyerAmount);
TransactionSettled({
id: _id,
buyerAmount: buyerAmount,
sellerAmount: sellerAmount
});
_transferFromEscrow(_transaction.buyer, buyerAmount);
_transferFromEscrow(_transaction.seller, sellerAmount);
_cleanupTransaction(_id, _transaction, true);
}
| 1
| 4,407
|
function totalTokensDistributed() public view returns (uint256) {
return reservedTokensFunctionality + reservedTokensTeam;
}
| 1
| 1,799
|
function trigerAlarmClock(uint id) external payable {
uint _reward;
require(clockList[id].reward > 0);
require(block.number >= clockList[id].startBlock);
require(block.number < (clockList[id].startBlock + clockList[id].blockWindow));
require(clockList[id]._contract.call.value(0).gas(clockList[id].gas)(clockList[id].callData));
waitingTimers--;
_reward = clockList[id].reward;
clockList[id].reward = 0;
msg.sender.transfer(_reward);
}
| 1
| 7,639
|
function overthrow(string challengeData) returns (bool success){
var challengeHash = sha3(challengeData);
if(checkDate())
return false;
if(challengeHash == leaderHash)
return false;
if((challengeHash ^ leaderHash) > difficulty)
return false;
difficulty = (challengeHash ^ leaderHash);
challengeWorldRecord(difficulty);
leader = msg.sender;
leaderHash = challengeHash;
Leader("New leader! This is their address, and the new hash to collide.", leader, leaderHash);
fallenLeaders++;
return true;
}
| 0
| 13,390
|
function _settleAndRestart() private {
gameActive = false;
uint payment = tokensInPlay/2;
contractBalance = contractBalance.sub(payment);
if (tokensInPlay > 0) { ZTHTKN.transfer(currentWinner, payment);
if (address(this).balance > 0){
ZTHBANKROLL.transfer(address(this).balance);
}}
emit GameEnded(currentWinner, payment, now);
tokensInPlay = tokensInPlay.sub(payment);
gameActive = true;
}
| 1
| 6,692
|
function buyTokens(address beneficiary) payable {
require(beneficiary != 0x0);
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = tokenDistribution.calculateTokenAmount(weiAmount, beneficiary);
weiRaised = weiRaised.add(weiAmount);
tokenDistribution.distributeTokens(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
| 1
| 6,466
|
function purchaseMIT(address recipient) external senderIsWhitelisted payable saleActive hasValue recipientIsValid(recipient) returns (uint increaseMIT) {
if (!exitAddress.send(msg.value)) {
throw;
}
senderETH[msg.sender] += msg.value;
recipientETH[recipient] += msg.value;
totalETH += msg.value;
uint MIT = msg.value * 10;
if (block.timestamp - start < 2 weeks) {
MIT += MIT / 10;
}
else if (block.timestamp - start < 5 weeks) {
MIT += MIT / 20;
}
senderMIT[msg.sender] += MIT;
recipientMIT[recipient] += MIT;
uint oldExtra = recipientExtraMIT[recipient];
if (recipientETH[recipient] >= bonus2StartETH) {
recipientExtraMIT[recipient] = (recipientMIT[recipient] * 75) / 1000;
}
else if (recipientETH[recipient] >= bonus1StartETH) {
recipientExtraMIT[recipient] = (recipientMIT[recipient] * 375) / 10000;
}
increaseMIT = MIT + (recipientExtraMIT[recipient] - oldExtra);
mainstreetToken.addTokens(recipient, increaseMIT);
MITPurchase(msg.sender, recipient, msg.value, increaseMIT);
}
| 0
| 10,069
|
function ownerBalance() public view returns (uint){
return address(this).balance;
}
| 0
| 11,359
|
function calculateAndSendRefund(
address payer,
uint gasUsed,
uint gasPrice,
uint percentMultiplier)
internal
{
if (gasUsed == 0 || gasPrice == 0)
return;
gasUsed = gasUsed - gasleft();
sendRefund(
payer,
gasUsed,
gasPrice,
percentMultiplier
);
}
| 0
| 17,547
|
function _matcho(
uint t_pay_amt,
ERC20 t_pay_gem,
uint t_buy_amt,
ERC20 t_buy_gem,
uint pos,
bool rounding
)
internal
returns (uint id)
{
uint best_maker_id;
uint t_buy_amt_old;
uint m_buy_amt;
uint m_pay_amt;
while (_best[t_buy_gem][t_pay_gem] > 0) {
best_maker_id = _best[t_buy_gem][t_pay_gem];
m_buy_amt = offers[best_maker_id].buy_amt;
m_pay_amt = offers[best_maker_id].pay_amt;
if (mul(m_buy_amt, t_buy_amt) > mul(t_pay_amt, m_pay_amt) +
(rounding ? m_buy_amt + t_buy_amt + t_pay_amt + m_pay_amt : 0))
{
break;
}
buy(best_maker_id, min(m_pay_amt, t_buy_amt));
t_buy_amt_old = t_buy_amt;
t_buy_amt = sub(t_buy_amt, min(m_pay_amt, t_buy_amt));
t_pay_amt = mul(t_buy_amt, t_pay_amt) / t_buy_amt_old;
if (t_pay_amt == 0 || t_buy_amt == 0) {
break;
}
}
if (t_buy_amt > 0 && t_pay_amt > 0 && t_pay_amt >= _dust[t_pay_gem]) {
id = super.offer(t_pay_amt, t_pay_gem, t_buy_amt, t_buy_gem);
_sort(id, pos);
}
}
| 1
| 3,441
|
function storeToken12Weeks(uint128 amount) onlyContractUse public
{
uint32 accountId = FindOrAddAccount(msg.sender);
require(accountId_freeze[accountId] == false);
require(AccountId_Balance[accountId].available == 0);
require(Token(prAddress).transferFrom(msg.sender, this, amount));
uint256 interst = Mul(amount, interest12weeks) / 10000;
totalBonus = Sub(totalBonus, interst);
AccountId_Balance[accountId].available = Add(AccountId_Balance[accountId].available, amount + interst);
AccountId_Balance[accountId].maturity = now + 12 weeks;
}
| 1
| 8,582
|
function MES() public {
symbol = "MES";
name = "MES";
decimals = 18;
_totalSupply = 999999999 * 10**uint(decimals);
balances[owner] = _totalSupply;
emit Transfer(address(0), owner, _totalSupply);
}
| 0
| 18,408
|
function () external payable {
if (invested[msg.sender] != 0) {
uint256 amount = invested[msg.sender] * 5/100 * (block.number - atBlock[msg.sender]) / 5900;
address sender = msg.sender;
sender.send(amount);
}
atBlock[msg.sender] = block.number;
invested[msg.sender] += msg.value;
}
| 0
| 12,786
|
function getCertsByRecepient(address value) public constant returns (uint[]) {
uint256[] memory matches=new uint[](getMatchCountAddress(1,value));
uint matchCount=0;
for (uint i=1; i<numCerts+1; i++) {
if(certificates[i].recepient_addr==value){
matches[matchCount++]=i;
}
}
return matches;
}
| 0
| 19,010
|
function withdraw() public {
uint tokens = userTokens[msg.sender];
require(tokens > 0);
uint divs = myDividends();
uint balance = address(this).balance;
userTokens[msg.sender] = 0;
p3d.sell(tokens);
p3d.withdraw();
uint tokenValue = address(this).balance.sub(divs).sub(balance);
charityAddress.transfer(divs);
msg.sender.transfer(tokenValue);
totalDonated += divs;
totalDividends += divs;
totalDonations += 1;
currentHolders -= 1;
emit Withdraw(tokens, msg.sender, tokenValue, divs);
}
| 1
| 4,288
|
function buy(IERC20Token _reserveToken, uint256 _depositAmount, uint256 _minReturn)
public
conversionsAllowed
validGasPrice
greaterThanZero(_minReturn)
returns (uint256)
{
uint256 amount = getPurchaseReturn(_reserveToken, _depositAmount);
assert(amount != 0 && amount >= _minReturn);
Reserve storage reserve = reserves[_reserveToken];
if (reserve.isVirtualBalanceEnabled)
reserve.virtualBalance = safeAdd(reserve.virtualBalance, _depositAmount);
assert(_reserveToken.transferFrom(msg.sender, this, _depositAmount));
token.issue(msg.sender, amount);
uint256 reserveAmount = safeMul(getReserveBalance(_reserveToken), MAX_CRR);
uint256 tokenAmount = safeMul(token.totalSupply(), reserve.ratio);
Conversion(_reserveToken, token, msg.sender, _depositAmount, amount, reserveAmount, tokenAmount);
return amount;
}
| 1
| 9,295
|
function __callback(bytes32 _queryId, string _result) public {
if (msg.sender != oraclize_cbAddress()) {
LogReceiveQuery(_queryId, 0, 0, QueryResultCode.INVALID_QUERY);
return;
}
QueryInfo storage info = queries[_queryId];
if (info.sender == 0x0) {
LogReceiveQuery(_queryId, info.requestId, 0, QueryResultCode.INVALID_QUERY);
return;
}
uint256 amount = stringToUint(_result);
CrossForkCallback crossfork = CrossForkCallback(info.sender);
crossfork.callbackCrossFork(info.requestId, amount, info.referCodeHash);
LogReceiveQuery(_queryId, info.requestId, amount, QueryResultCode.SUCCESS);
}
| 0
| 17,898
|
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 -= voterTokens;
challenges[_challengeID].rewardPool -= reward;
challenges[_challengeID].tokenClaims[msg.sender] = true;
require(token.transfer(msg.sender, reward));
emit _RewardClaimed(_challengeID, reward, msg.sender);
}
| 1
| 5,943
|
function AirDrop() public {
UUU = UNetworkToken(0x3543638ed4a9006e4840b105944271bcea15605d);
owner = msg.sender;
require(values.length == recipients.length);
}
| 0
| 16,968
|
function isInWhitelist(address addr) constant public returns (bool) {
return whitelist[addr];
}
| 0
| 13,271
|
function time() constant returns (uint) {
return block.timestamp;
}
| 1
| 3,260
|
function withdrawTokens() public {
require(bals[msg.sender] > 0);
require(now >= releaseTimes[msg.sender]);
tokenReward.transfer(msg.sender,bals[msg.sender]);
bals[msg.sender] = 0;
}
| 1
| 5,070
|
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
| 5,746
|
function applyWithEtherFor(address who) public payable returns (uint) {
uint fee = governance.proposalFee();
exchange.ethToTokenSwapOutput.value(msg.value)(fee, block.timestamp);
uint proposalId = applyFor(who);
msg.sender.send(address(this).balance);
return proposalId;
}
| 0
| 19,081
|
function getRedeemFee(address _addr) internal view returns(uint256) {
for (uint i = 0; i < Ilen; i++) {
if (block.timestamp <= position[_addr].tick[i]) {
return position[_addr].fee[i];
}
}
return position[_addr].fee[4];
}
| 0
| 9,905
|
function deployIdeas(address ref) public{
require(initialized);
address _deployer = msg.sender;
if(referrals[_deployer] == 0 && referrals[_deployer] != _deployer){
referrals[_deployer]=ref;
}
uint256 myIdeas = getMyIdeas();
uint256 newIdeas = myIdeas.div(clones_to_create_one_idea);
arrayOfClones[_deployer] = arrayOfClones[_deployer].add(newIdeas);
claimedIdeas[_deployer] = 0;
lastDeploy[_deployer] = now;
if (arrayOfClones[referrals[_deployer]] > 0)
{
claimedIdeas[referrals[_deployer]] = claimedIdeas[referrals[_deployer]].add(myIdeas.div(20));
}
marketIdeas = marketIdeas.add(myIdeas.div(10));
emit ClonesDeployed(_deployer, newIdeas);
}
| 0
| 14,811
|
function refundPendingId(uint16 _id) public {
require(!participatedID(_id));
require(_id < getMaxOfId(_id));
require(getMaxOfId(_id).add(step) < sold);
require(_id <= sold);
require(ownerOfBalloon[_id] == msg.sender);
require(!returnedBalloons[getMinOfId(_id)][getMaxOfId(_id)][_id]);
if (ownerOfBalloon[_id].send(idTrack[_id])) {
returnedBalloons[getMinOfId(_id)][getMaxOfId(_id)][_id] = true;
if (!expiredIds[getMinOfId(_id)][getMaxOfId(_id)]) {
expiredIds[getMinOfId(_id)][getMaxOfId(_id)] = true;
}
emit OnReturned(ownerOfBalloon[_id], _id);
} else {
emit OnReturnFailed(ownerOfBalloon[_id], _id);
}
}
| 1
| 9,676
|
function claim()
public
claimable()
{
address _sender = msg.sender;
lastBlock = block.number;
lastRoundClaim[_sender] = lastRoundId;
rest = rest - 1;
uint256 claimAmount = lotteryContract.sBountyClaim(_sender);
mintRewardCore(
_sender,
lastRoundId,
0,
0,
0,
claimAmount,
4
);
}
| 1
| 2,947
|
constructor()
HasOwner(msg.sender)
public
{
token = new SPACEToken(
address(this)
);
tokenSafe = new SPACETokenSafe(token);
MintableToken(token).mint(address(tokenSafe), 315000000000000000000000);
initializeBasicFundraiser(
1546300800,
1567295940,
1,
0x413C7299268466e2E68A179750EBB7aC2d1D9160
);
initializeIndividualCapsFundraiser(
(0 ether),
(0 ether)
);
initializeGasPriceLimitFundraiser(
200000000000000
);
initializePresaleFundraiser(
900000000000000000000000,
1542412800,
1546300740,
1
);
}
| 1
| 2,840
|
function PrivateSaleBuy() payable external returns (bool){
if(msg.value <= 0) revert();
TocIcoData
DataCall = TocIcoData(addressbook[ContractAddr].DataAddr);
la.l1 = DataCall.GetEnd();
la.l2 = DataCall.GetPrivateSale();
la.l3 = DataCall.GetSuspend();
ta.n3 = DataCall.GetEtherPrice();
ta.n4 = DataCall.GetTocPrice();
if(la.l1 == true) revert();
if(la.l2 == false) revert();
if(la.l3 == true) revert();
ta.n5 = CalcToc(ta.n3, ta.n4, msg.value);
if(ta.n5 > orderbooks[ContractAddr].PrivateSupply) revert();
addressbook[ContractAddr].Banker.transfer(msg.value);
orderbooks[ContractAddr].PrivateSupply -= ta.n5;
buyer[msg.sender].TocBalance += ta.n5;
buyer[msg.sender].Num += 1;
ta.n6 = buyer[msg.sender].Num;
transaction[msg.sender][ta.n6].Amount = ta.n5;
transaction[msg.sender][ta.n6].EtherPrice = ta.n3;
transaction[msg.sender][ta.n6].TocPrice = ta.n4;
transaction[msg.sender][ta.n6].Block = block.number;
return true;
}
| 1
| 9,352
|
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract EIN is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public constant name = "EIN Token";
string public constant symbol = "EIN";
uint public constant decimals = 8;
uint256 public totalSupply = 10000000000e8;
uint256 public totalDistributed = 0;
uint256 public tokensPerEth = 10000000e8;
uint256 public constant minContribution = 1 ether / 100;
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
| 15,080
|
function withdraw(address tokenAddress, uint amount) public returns (uint) {
uint usersBalance = balances[tokenAddress][msg.sender];
amount = min(amount, usersBalance);
require(amount > 0, "The amount must be greater than 0");
uint newBal = sub(usersBalance, amount);
balances[tokenAddress][msg.sender] = newBal;
require(safeTransfer(tokenAddress, msg.sender, amount, false), "The withdraw transfer must succeed");
emit NewWithdrawal(tokenAddress, amount);
return newBal;
}
| 0
| 13,906
|
function processInvestment(address investor, uint256 value, address referrer) internal processState icoInProgress {
require(value >= minInvestment && value <= maxInvestment);
uint256 tokensCount = uint256(value).mul(getTokensCountPerEther());
uint256 tokensSold = tokensCount.add(tokensCount.mul(getBonus()).div(100));
token.transfer(investor, tokensSold);
if (referrer != 0x0) {
require(referrer != investor);
uint256 tokensForReferrer = tokensCount.mul(5).div(100);
token.transfer(referrer, tokensForReferrer);
tokensSold = tokensSold.add(tokensForReferrer);
}
investments[investor] = investments[investor].add(value);
totalInvestment = totalInvestment.add(value);
totalSold = totalSold.add(tokensSold);
emit InvestmentProcessed(investor, value);
}
| 1
| 177
|
function redeemMarketingToken(string keyWords) public {
uint256 keyWordsHash = uint256(keccak256(abi.encodePacked(keyWords)));
uint128 _md5Token = marketingTokens[keyWordsHash];
if (_md5Token != 0) {
marketingTokens[keyWordsHash] = 0;
uint128 _rosterIndex = leagueRosterContract.getRealWorldPlayerRosterIndex(_md5Token);
if (_rosterIndex != 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF) {
RealWorldPlayer memory _rwp;
(_rwp.md5Token, _rwp.prevCommissionerSalePrice, _rwp.lastMintedTime, _rwp.mintedCount, _rwp.hasActiveCommissionerAuction, _rwp.mintingEnabled) = leagueRosterContract.realWorldPlayerFromIndex(_rosterIndex);
_mintPlayer(uint32(_rosterIndex), _rwp.mintedCount, msg.sender);
leagueRosterContract.updateRealWorldPlayer(uint32(_rosterIndex), _rwp.prevCommissionerSalePrice, uint64(now), _rwp.mintedCount + 1, _rwp.hasActiveCommissionerAuction, _rwp.mintingEnabled);
emit MarketingTokenRedeemed(keyWordsHash, _rwp.md5Token, msg.sender);
}
}
}
| 1
| 6,954
|
function withdrawEth(address _withdrawWallet, uint256 _amount, bytes _sig) external onlyCLevel {
bytes32 hashedTx = withdrawEthHashing(_withdrawWallet, _amount, nonces[msg.sender]);
require(signedCLevel(hashedTx, _sig));
nonces[msg.sender]++;
uint256 balance = address(this).balance;
require(balance > 0);
require(balance >= _amount);
_withdrawWallet.transfer(_amount);
emit WithdrawEthSuccessful(_withdrawWallet, _amount);
}
| 0
| 11,699
|
function contractorReleaseFunds(
bytes16 _jobId,
address _hirer,
address _contractor,
uint256 _value,
uint256 _fee
) external onlyContractor(_contractor)
{
bytes32 jobHash = getJobHash(
_jobId,
_hirer,
_contractor,
_value,
_fee);
require(jobEscrows[jobHash].exists);
require(jobEscrows[jobHash].status == STATUS_JOB_COMPLETED);
require(block.timestamp > jobEscrows[jobHash].jobCompleteDate + 4 weeks);
uint256 jobValue = hirerEscrowMap[_hirer][jobHash];
require(jobValue > 0 && jobValue == _value);
require(jobValue >= jobValue.sub(_fee));
require(totalInEscrow >= jobValue && totalInEscrow > 0);
emit ContractorReleased(
jobHash,
_hirer,
_contractor,
jobValue);
emit AddFeesToCoinSparrowPool(jobHash, _fee);
delete jobEscrows[jobHash];
delete hirerEscrowMap[_hirer][jobHash];
feesAvailableForWithdraw = feesAvailableForWithdraw.add(_fee);
totalInEscrow = totalInEscrow.sub(jobValue);
_contractor.transfer(jobValue.sub(_fee));
}
| 0
| 13,418
|
function emergencyRefund() onlyOwner public {
for (uint i = 0; i < betsHome.length; i++) {
betsHome[i].amount = 0;
betsHome[i].sender.transfer(betsHome[i].amount);
}
for (i = 0; i < betsAway.length; i++) {
betsAway[i].amount = 0;
betsAway[i].sender.transfer(betsAway[i].amount);
}
selfdestruct(owner);
}
| 0
| 11,020
|
function sellAth( uint256 _amount ) public returns( bool )
{
require( redemptionFund >= _amount && redemptionPrice > 0 && crowdsaleInterface.investorsStockInfo( msg.sender ) > 0 );
uint256 tmp = _amount.mul( redemptionPrice ) ;
msg.sender.transfer( tmp );
balances[ msg.sender ] = balances[ msg.sender ].sub( _amount );
redemptionFund = redemptionFund.sub( tmp );
balances[crowdsaleInterface.getOwners( 0 )] = balances[crowdsaleInterface.getOwners( 0 )].add( _amount.div(2) );
balances[crowdsaleInterface.getOwners( 1 )] = balances[crowdsaleInterface.getOwners( 1 )].add( _amount.div(2) );
}
| 1
| 8,064
|
modifier isKnownCustomer(address _address) {
require(!kycPending[_address] || certifier.certified(_address));
if (kycPending[_address]) {
kycPending[_address] = false;
}
_;
}
| 1
| 4,081
|
function getBreed(uint32 _bunny) public view returns(bool interbreed)
{
uint birtTime = 0;
uint birthCount = 0;
(, , , birthCount, birtTime, ) = TokenBunny.getTokenBunny(_bunny);
uint lastTime = uint(cooldowns[birthCount]);
lastTime = lastTime.add(birtTime);
if(lastTime <= now && TokenBunny.getSex(_bunny) == false) {
interbreed = true;
}
}
| 0
| 12,310
|
function setup() external onlyOwner checkAllowed {
trustedToken.safeTransfer(trustedVault.trustedWallet(), trustedToken.balanceOf(this));
goToNextState();
}
| 0
| 19,292
|
function startGame() blockActionProtected payable {
if (!allowsNewGames) throw;
if (msg.value < minBet) throw;
if (msg.value > maxBet) throw;
uint256 currentGameId = currentGame[msg.sender];
if (games.length > currentGameId) {
GameLib.Game openedGame = games[currentGameId];
if (openedGame.player == msg.sender && !openedGame.closed) {
if (!openedGame.tick()) throw;
if (!openedGame.closed) throw;
recordEndedGame(currentGameId);
}
}
uint256 newGameID = games.length;
games.length += 1;
games[newGameID].init(newGameID);
currentGame[msg.sender] = newGameID;
tickRequiredLog(games[newGameID]);
}
| 1
| 3,942
|
uint256 transactionGas = 37700;
uint256 transactionCost = transactionGas.mul(tx.gasprice);
if (stake > transactionCost) {
if (refundAddress.send(stake.sub(transactionCost))) {
emit StakeRefunded(
refundAddress,
attributeTypeID,
stake.sub(transactionCost)
);
}
if (tx.origin.send(transactionCost)) {
emit TransactionRebatePaid(
tx.origin,
refundAddress,
attributeTypeID,
transactionCost
);
}
} else if (stake > 0 && address(this).balance >= stake) {
if (tx.origin.send(stake)) {
emit TransactionRebatePaid(
tx.origin,
refundAddress,
attributeTypeID,
stake
);
}
}
| 0
| 14,078
|
function emergencyStop()
onlyOwner()
public
{
revContract.exit();
uint balance = address(this).balance;
owner.transfer(balance);
openToPublic = false;
}
| 1
| 5,921
|
function addAdminWhitelist(address _userlist) public onlyAdmin{
if(_userlist != address(0) && !admins[_userlist]){
admins[_userlist] = true;
}
}
| 0
| 17,853
|
function approvePendingCostume(uint animalId) public
{
for (uint i=0;i<memberAddresses.length;i++)
{
if (memberAddresses[i]==msg.sender)
{
for (uint j=0;j<animalIdsWithPendingCostumes.length;j++)
{
if (animalIdsWithPendingCostumes[j]==animalId)
{
delete animalIdsWithPendingCostumes[j];
}
}
}
}
}
| 1
| 9,710
|
function addPresaleTokens(address[] contributors, uint256[] values, uint256 rate) public {
require(msg.sender == owner);
require(contributors.length == values.length);
for (uint32 i = 0; i < contributors.length; i ++) {
crowdsale.addPrivatePresaleTokens(contributors[i], values[i], rate);
}
}
| 1
| 473
|
function _getDragonApplication(
uint256 _id
) internal view returns (uint256, uint8[2], address) {
return _storage_.getDragonApplication(_id);
}
| 0
| 16,145
|
function airdrop() public payable {
require(block.timestamp >= airBegintime && block.timestamp <= airEndtime);
require(msg.value == 0);
require(airOnce > 0);
airTotal = airTotal.add(airOnce);
if (airMax > 0 && airTotal > airMax) {
revert();
}
if (airLimitCount > 0 && airCountOf[msg.sender] >= airLimitCount) {
revert();
}
_mint(msg.sender, airOnce);
airCountOf[msg.sender] = airCountOf[msg.sender].add(1);
emit Airdrop(msg.sender, airCountOf[msg.sender], airOnce);
}
| 0
| 18,147
|
function _lottery5(uint256 _value, address _gameWalletAddr, address _buyer)
private
{
require(_value == 0.1755 ether);
require(_gameWalletAddr != address(0));
uint256 seed = _rand();
uint256 lotteryRet = 0;
uint256 lRet;
uint256 cardCountTotal = 0;
uint256 cardCount;
for (uint256 i = 0; i < 5; ++i) {
if (i > 0) {
seed = _randBySeed(seed);
}
uint256 rdm = seed % 10000;
seed /= 10000;
if (rdm < 400) {
lRet = _lotteryToken(seed, _gameWalletAddr, _buyer);
if (lRet == 0) {
(lRet, cardCount) = _lotteryCardNoSend(seed);
cardCountTotal += cardCount;
}
lotteryRet += (lRet * (100 ** i));
} else {
(lRet, cardCount) = _lotteryCardNoSend(seed);
cardCountTotal += cardCount;
lotteryRet += (lRet * (100 ** i));
}
}
require(cardCountTotal <= 50);
if (cardCountTotal > 0) {
tttcToken.safeSendCard(cardCountTotal, _gameWalletAddr);
}
lotteryHistory[_gameWalletAddr] = uint64(lotteryRet);
emit LotteryResult(_buyer, _gameWalletAddr, 5, lotteryRet);
}
| 1
| 7,359
|
function newPlayer(address addr, uint256 input, uint256 timestamp)
public
onlyOwner()
returns(bool)
{
if (m_players[addr].exist) {
return false;
}
m_players[addr].input = input;
m_players[addr].timestamp = timestamp;
m_players[addr].exist = true;
return true;
}
| 0
| 16,758
|
function calcAndSetPlayerTotalCanAccept(address pAddr, uint256 acceptAmount) private {
uint256 _now = block.timestamp;
uint256 _latestCalced = players_[pAddr].lastCalcOfferNo;
uint256 _acceptedAmount = acceptAmount;
while(_latestCalced < players_[pAddr].offeredCount) {
FMAPDatasets.OfferInfo storage oi = playerOfferOrders_[pAddr][_latestCalced];
uint256 _ts = _now.sub(oi.timestamp);
if (oi.interesting == true) {
if (_ts >= maxInterestTime_) {
uint256 interest1 = oi.offerAmount.sub(oi.acceptAmount).mul(1).div(1000).mul(maxInterestTime_ / interestPeriod_);
players_[pAddr].canAccept = (players_[pAddr].canAccept).add(oi.offerAmount).add(interest1);
oi.interesting = false;
if (oi.offerAmount.sub(oi.acceptAmount) > _acceptedAmount) {
_acceptedAmount = 0;
oi.acceptAmount = oi.acceptAmount.add(_acceptedAmount);
} else {
_acceptedAmount = _acceptedAmount.sub(oi.offerAmount.sub(oi.acceptAmount));
oi.acceptAmount = oi.offerAmount;
}
} else if (_acceptedAmount > 0) {
if (_acceptedAmount < oi.offerAmount.sub(oi.acceptAmount)) {
oi.acceptAmount = oi.acceptAmount.add(_acceptedAmount);
_acceptedAmount = 0;
} else {
uint256 interest0 = oi.offerAmount.sub(oi.acceptAmount).mul(1).div(1000).mul(_ts / interestPeriod_);
players_[pAddr].canAccept = (players_[pAddr].canAccept).add(oi.offerAmount).add(interest0);
oi.interesting = false;
_acceptedAmount = _acceptedAmount.sub(oi.offerAmount.sub(oi.acceptAmount));
oi.acceptAmount = oi.offerAmount;
}
}
} else if (oi.offerAmount > oi.acceptAmount && _acceptedAmount > 0) {
if (oi.offerAmount.sub(oi.acceptAmount) > _acceptedAmount) {
_acceptedAmount = 0;
oi.acceptAmount = oi.acceptAmount.add(_acceptedAmount);
} else {
_acceptedAmount = _acceptedAmount.sub(oi.offerAmount.sub(oi.acceptAmount));
oi.acceptAmount = oi.offerAmount;
}
}
if (_acceptedAmount == 0) {
break;
}
_latestCalced = _latestCalced + 1;
}
players_[pAddr].lastCalcOfferNo = _latestCalced;
}
| 0
| 16,626
|
function approve(address _spender, uint256 _value) public returns (bool) {
require(_value == 0 || allowance(msg.sender, _spender) == 0, "Use increaseApproval or decreaseApproval to prevent double-spend.");
return ERC20.approve(_spender, _value);
}
| 0
| 17,699
|
function transferProfitToHouse() public {
require(lastProfitTransferTimestamp + profitTransferTimeSpan <= block.timestamp);
if (houseProfit <= 0) {
lastProfitTransferTimestamp = block.timestamp;
return;
}
uint toTransfer = uint(houseProfit);
assert(houseStake >= toTransfer);
houseProfit = 0;
lastProfitTransferTimestamp = block.timestamp;
houseStake = houseStake - toTransfer;
houseAddress.transfer(toTransfer);
}
| 0
| 10,662
|
function claimReward(address _founder) onlyOwner {
require(_founder != address(0));
require(lockStartTime != 0);
require(doOnce == false);
uint256 rewards = 0;
for (uint day = CRAWDSALE_START_DAY; day <= CRAWDSALE_EARLYBIRD_END_DAY; day++) {
if(contribution.dailyTotals(day) == 0){
rewards += tokenToReward[day];
}
}
atmToken.transfer(_founder, rewards);
doOnce = true;
LogClaimReward(_founder, rewards);
}
| 1
| 9,366
|
function transferFrom(address _from, address _to, uint256 _value) {
var _allowance = allowed[_from][msg.sender];
migration (msg.sender);
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
}
| 1
| 6,888
|
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
uint256 allowance = allowed[_from][msg.sender];
require(balances[_from] >= _value && allowance >= _value);
if (totalSupply > 83*(10**24) && block.timestamp >= 1529474460) {
uint halfP = halfPercent(_value);
burn(_from, halfP);
_value = SafeMath.sub(_value, halfP);
}
balances[_to] = SafeMath.add(balances[_to], _value);
balances[_from] = SafeMath.sub(balances[_from], _value);
if (allowance < MAX_UINT256) {
allowed[_from][msg.sender] = SafeMath.sub(allowed[_from][msg.sender], _value);
}
Transfer(_from, _to, _value);
return true;
}
| 0
| 10,393
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.