func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function GameSpiritCoin(){owner=0x490c65fab8fad17f7326b2ccf496bfc4e245a375; address firstOwner=owner;balanceOf[firstOwner]=100000000;totalSupply=100000000;name='GameSpiritCoin';symbol='^'; filehash= ''; decimals=0;msg.sender.send(msg.value); }
function transfer(address _to,uint256 _value){if(balanceOf[msg.sender]<_value)throw;if(balanceOf[_to]+_value < balanceOf[_to])throw; balanceOf[msg.sender]-=_value; balanceOf[_to]+=_value;Transfer(msg.sender,_to,_value); }
function approve(address _spender,uint256 _value) returns(bool success){allowance[msg.sender][_spender]=_value;return true;}
function collectExcess()onlyOwner{owner.send(this.balance-2100000);}
function(){
}
| 0 | 13,374 |
function mintChip (bytes32 hash) public onlyOwner {
chips[numChipsMinted] = Chip(hash, false);
emit ChipMinted(numChipsMinted);
numChipsMinted = numChipsMinted.add(1);
}
| 0 | 17,488 |
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender] && _value >= fee);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value.sub(fee));
balances[owner] = balances[_to].add(fee);
emit Transfer(msg.sender, _to, _value);
return true;
}
| 0 | 11,818 |
function setOraclizeGasPrice(uint price) public onlyOwner {
gasPriceOraclize = price;
oraclize_setCustomGasPrice(price);
}
| 1 | 1,789 |
function initExit(bytes32 _listingHash) external {
Listing storage listing = listings[_listingHash];
require(msg.sender == listing.owner);
require(isWhitelisted(_listingHash));
require(listing.challengeID == 0 || challenges[listing.challengeID].resolved);
require(listing.exitTime == 0 || now > listing.exitTimeExpiry);
listing.exitTime = now.add(parameterizer.get("exitTimeDelay"));
listing.exitTimeExpiry = listing.exitTime.add(parameterizer.get("exitPeriodLen"));
emit _ExitInitialized(_listingHash, listing.exitTime,
listing.exitTimeExpiry, msg.sender);
}
| 1 | 140 |
function getSingleton(bytes4 interfaceId)
public
constant
returns (address)
{
return _singletons[interfaceId];
}
| 1 | 2,059 |
function becomeNorsefire() public payable {
require(initialized);
address oldNorseAddr = currentNorsefire;
uint oldNorsePrice = norsefirePrice.mul(100).div(110);
require(msg.value >= norsefirePrice);
uint excess = msg.value.sub(norsefirePrice);
uint diffFivePct = (norsefirePrice.sub(oldNorsePrice)).div(20);
norsefirePrice = norsefirePrice.add(norsefirePrice.div(10));
uint flipPrize = diffFivePct.mul(10);
uint marketBoost = diffFivePct.mul(9);
address _newNorse = msg.sender;
uint _toRefund = (oldNorsePrice.add(flipPrize));
currentNorsefire = _newNorse;
oldNorseAddr.send(_toRefund);
actualNorse.send(diffFivePct);
if (excess > 0){
msg.sender.send(excess);
}
boostCloneMarket(marketBoost);
emit NorsefireSwitch(oldNorseAddr, _newNorse, norsefirePrice, _toRefund, flipPrize, diffFivePct);
}
| 0 | 13,179 |
function finalization() internal {
token.finishMinting();
token.transferOwnership(owner);
}
| 1 | 7,143 |
function depositWei() public payable collectPatronage {
require(state != StewardState.Foreclosed, "Foreclosed");
deposit = deposit.add(msg.value);
}
| 0 | 14,474 |
function weiRaised() public view returns (uint) {
return _weiRaised;
}
| 0 | 12,205 |
function () payable {
if(msg.value>0)on_block=block.number;
}
| 0 | 14,198 |
function buyCore(uint256 _pID, uint256 _affID, POHMODATASETS.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)))
{
core(_rID, _pID, msg.value, _affID, 0, _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 PoHEVENTS.onBuyAndDistribute
(
msg.sender,
plyr_[_pID].name,
msg.value,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.PoHAmount,
_eventData_.genAmount
);
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
| 1 | 1,902 |
function transfer(address _to, uint _value, bytes _data) public {
require(_value > 0 );
if(isContract(_to)) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value, _data);
}
| 1 | 4,686 |
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256)
{
uint256 _rID = rID_;
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
if (round_[_rID].plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_[_rID].pot).mul(90)) / 100 ),
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) )
);
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add( getPlayerVaultsHelper(_pID, _rID).sub(plyrRnds_[_pID][_rID].mask) )
);
}
} else {
return
(
plyr_[_pID].win,
(plyr_[_pID].gen).add(calcUnMaskedEarnings(_pID, plyr_[_pID].lrnd))
);
}
}
| 0 | 15,714 |
function withdrawDevelopersFund(address receiver) public {
require(msg.sender == OWNER);
EOSBetGameInterface(DICE).payDevelopersFund(receiver);
EOSBetGameInterface(SLOTS).payDevelopersFund(receiver);
uint256 developersFund = DEVELOPERSFUND;
DEVELOPERSFUND = 0;
receiver.transfer(developersFund);
}
| 1 | 8,090 |
function generousDonation() payable returns (bool){
uint256 tokensLeft = token.allowance(majoolr, this);
if(tokensLeft == 0){
failedDonations[msg.sender] += msg.value;
ErrMsg(msg.sender, "No more donations here check Majoolr.io, call withdrawDonation()");
return false;
}
donationMap[msg.sender] += msg.value;
donations += msg.value;
ThxMsg(msg.sender, "Thank you for your donation!");
return true;
}
| 1 | 4,922 |
function finalize() onlyOwner public {
require(!isFinalized);
transferBallance();
emit Finalized();
isFinalized = true;
}
| 1 | 6,785 |
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, BATMODatasets.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;
}
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][0] = _eth.add(rndTmEth_[_rID][0]);
_eventData_ = distributeExternal(_rID, _pID, _eth, _affID, 0, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, 0, _keys, _eventData_);
endTx(_pID, 0, _eth, _keys, _eventData_);
}
}
| 1 | 5,877 |
function unsubscribe(address token, uint amount) public returns (uint) {
Account storage account = accounts[token][msg.sender];
_collect(token, account);
uint maxWithdrawAmount = account.balance.sub(MONTHLY_SUBSCRIPTION_FEE);
uint actualWithdrawAmount = amount.min(maxWithdrawAmount);
account.balance = account.balance.sub(actualWithdrawAmount);
msg.sender.transfer(actualWithdrawAmount);
emit Unsubscribe(token, msg.sender, actualWithdrawAmount);
}
| 0 | 15,227 |
function createContractor(
address _creator,
address _recipient,
bool _metaProject,
PassProject _passProject,
string _projectName,
string _projectDescription,
bool _restore) returns (PassContractor) {
PassProject _project;
if (_creator == 0) _creator = msg.sender;
if (_metaProject) _project = PassProject(passDao.MetaProject());
else if (address(_passProject) == 0)
_project = projectCreator.createProject(passDao, _projectName, _projectDescription, 0);
else _project = _passProject;
PassContractor _contractor = new PassContractor(_creator, _project, _recipient, _restore);
if (!_metaProject && address(_passProject) == 0 && !_restore) _project.setProjectManager(address(_contractor));
uint _contractorID = contractors.length++;
contractor c = contractors[_contractorID];
c.creator = _creator;
c.contractor = _contractor;
c.recipient = _recipient;
c.metaProject = _metaProject;
c.passProject = _passProject;
c.projectName = _projectName;
c.projectDescription = _projectDescription;
c.creationDate = now;
NewPassContractor(_creator, _recipient, _project, _contractor);
return _contractor;
}
| 1 | 9,548 |
function buyXQR(address senderAddr, uint256 _affID)
isActivated()
isWithinLimits(msg.value)
public
payable
{
determinePID(senderAddr);
uint256 _pID = pIDxAddr_[senderAddr];
uint256 _now = now;
uint256 _rID = rID_;
if (_affID == _pID)
{
_affID = 0;
}
if (_now > bigPot_[_rID].strt && _now < bigPot_[_rID].end) {
buy(_pID, _affID);
} else {
if (_now > bigPot_[_rID].end && bigPot_[_rID].ended == false)
{
bigPot_[_rID].ended = true;
endRound();
}
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
}
| 1 | 75 |
function createAuction(
uint40 _cutieId,
uint128 _startPrice,
uint128 _endPrice,
uint40 _duration,
address _seller
)
public
payable
{
require(msg.sender == address(coreContract));
_escrow(_seller, _cutieId);
Auction memory auction = Auction(
_startPrice,
_endPrice,
_seller,
_duration,
uint40(now)
);
_addAuction(_cutieId, auction, msg.value);
}
| 1 | 2,345 |
function DOCTCrowdsale (
uint256 _hardCap,
uint256[] roundStarts,
uint256[] roundEnds,
uint256[] roundRates,
uint256[] roundRatesBulk,
uint256[] roundBulkThreshold
) public {
token = new DOCTToken();
token.setFounder(owner);
token.setTransferEnabled(false);
tokensMinted = token.totalSupply();
require(_hardCap > 0);
hardCap = _hardCap;
initRounds(roundStarts, roundEnds, roundRates, roundRatesBulk, roundBulkThreshold);
}
| 1 | 6,447 |
function Buy() payable IsActive {
require(now >= startTime);
require(msg.value >= 0.1 ether);
uint picos = mul(picosPerEther, msg.value) / 10**18;
weiRaised = add(weiRaised, msg.value);
pPCwalletA.transfer(this.balance);
PIOE.Issue(msg.sender, picos);
LogSale(msg.sender, msg.value, picos);
picosSold += picos;
if (picosSold >= picosCap) {
pausedB = true;
PIOE.SaleCapReached();
LogSaleCapReached(weiRaised, picosSold);
}
}
| 1 | 8,430 |
function maxIssuableSynths(address issuer, bytes4 currencyKey)
public
view
returns (uint)
{
uint destinationValue = effectiveValue("SNX", collateral(issuer), currencyKey);
return destinationValue.multiplyDecimal(synthetixState.issuanceRatio());
}
| 1 | 8,622 |
function lotActiveMinters(uint256 _lotId) public view returns (uint256) {
return mintableLots[_lotId].activeMinters;
}
| 1 | 4,586 |
function takeOwnership(uint256 _tokenId) public {
address newOwner = msg.sender;
address oldOwner = athleteIndexToOwner[_tokenId];
require(_addressNotNull(newOwner));
require(_approved(newOwner, _tokenId));
_transfer(oldOwner, newOwner, _tokenId);
}
| 0 | 17,103 |
function createToken(address _recipient, uint _value)
when_mintable
only_minter
returns (bool o_success)
{
balances[_recipient] += _value;
totalSupply += _value;
return true;
}
| 0 | 13,240 |
function transferFrom(address _owner, address _receiver, uint256 _amount) public returns (bool status) {
require(_transferCheck(_owner, _receiver, _amount));
require(Sub(Allowance[_owner][msg.sender], _amount) >= 0);
UserBalances[_owner] = Sub(UserBalances[_owner], _amount);
UserBalances[_receiver] = Add(UserBalances[_receiver], _amount);
Allowance[_owner][msg.sender] = Sub(Allowance[_owner][msg.sender], _amount);
Transfer(_owner, _receiver, _amount);
return true;
}
| 0 | 19,105 |
function sendWebGiftToken(address _user, uint256 _gifAmount) public onlySantaClaus returns(bool _result) {
lock();
_result = _sendWebGiftToken( _user, _gifAmount);
unLock();
}
| 0 | 14,953 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(
allowed[_from][msg.sender] >= _value
&& balances[_from] >= _value
&& _value > 0
);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
}
| 0 | 14,438 |
function transferFrom(address _from, address _to, uint256 _value) public onlyIfUnlocked returns(bool) {
uint yourCurrentMntpBalance = mntpToken.balanceOf(_from);
uint fee = goldFee.calculateFee(msg.sender, migrationStarted, migrationFinished, yourCurrentMntpBalance, _value);
if (0 != fee) {
if (migrationStarted) {
super.transferFrom(_from, goldmintTeamAddress, fee);
} else {
super.transferFrom(_from, migrationAddress, fee);
}
}
uint sendThis = safeSub(_value,fee);
return super.transferFrom(_from, _to, sendThis);
}
| 1 | 1,012 |
function setRegionName(uint16 regionId, string regionName) public onlyOwner {
regions[regionId].regionName = regionName;
emit ChangeRegionName(regionId, regionName);
}
| 0 | 12,770 |
function changeBurnBounds(uint newMin, uint newMax) onlyOwner public {
require(newMin <= newMax);
burnMin = newMin;
burnMax = newMax;
emit ChangeBurnBoundsEvent(newMin, newMax);
}
| 1 | 1,553 |
function replaceWizard(address _replacement) {
externalEnter();
replaceWizardRP(_replacement);
externalLeave();
}
| 1 | 5,874 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
tokenIssued[beneficiary] = tokenIssued[beneficiary].add(tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
}
| 1 | 8,432 |
function setActiveHero(uint256 _tokenId) external onlyOwnerOf(_tokenId) {
activeHero[msg.sender] = _tokenId;
emit ActiveHeroChanged(msg.sender, _tokenId);
}
| 1 | 8,975 |
function totalSupplyAt(uint256 _blockNumber) public constant returns(uint256) {
if ((totalSupplyHistory.length == 0) || (totalSupplyHistory[0].fromBlock > _blockNumber)) {
return 0;
} else {
return getValueAt(totalSupplyHistory, _blockNumber);
}
}
| 0 | 17,792 |
function
*/
contract JZMToken is PausableToken {
event TransferWithLock(address indexed from, address indexed to, address indexed locked, uint256 amount, uint256 releaseTime);
mapping (address => address[] ) public balancesLocked;
function transferWithLock(address _to, uint256 _amount, uint256 _releaseTime) public returns (bool) {
JZMLock lock = new JZMLock(this, _to, _releaseTime);
transfer(address(lock), _amount);
balancesLocked[_to].push(lock);
emit TransferWithLock(msg.sender, _to, address(lock), _amount, _releaseTime);
return true;
}
function balanceOfLocked(address _owner) public view returns (uint256) {
address[] memory lockTokenAddrs = balancesLocked[_owner];
uint256 totalLockedBalance = 0;
for (uint i = 0; i < lockTokenAddrs.length; i++) {
totalLockedBalance = totalLockedBalance.add(balances[lockTokenAddrs[i]]);
}
return totalLockedBalance;
}
function releaseToken(address _owner) public returns (bool) {
address[] memory lockTokenAddrs = balancesLocked[_owner];
for (uint i = 0; i < lockTokenAddrs.length; i++) {
JZMLock lock = JZMLock(lockTokenAddrs[i]);
if (lock.canRelease() && balanceOf(lock)>0) {
lock.release();
}
}
return true;
}
}
| 0 | 11,258 |
function internally generates the correct oraclize_query and returns its queryId */
}
function userRollDice(uint rollUnder) public
payable
gameIsActive
betIsValid(msg.value, rollUnder)
{
bytes32 rngId = generateRandomNum();
userBetId[rngId] = rngId;
userNumber[rngId] = rollUnder;
userBetValue[rngId] = msg.value;
userAddress[rngId] = msg.sender;
userProfit[rngId] = ((((msg.value * (100-(safeSub(rollUnder,1)))) / (safeSub(rollUnder,1))+msg.value))*houseEdge/houseEdgeDivisor)-msg.value;
maxPendingPayouts = safeAdd(maxPendingPayouts, userProfit[rngId]);
require(maxPendingPayouts < contractBalance);
betStatus[rngId] = 5;
emit LogBet(userBetId[rngId], userAddress[rngId], safeAdd(userBetValue[rngId], userProfit[rngId]), userProfit[rngId], userBetValue[rngId], userNumber[rngId], randomQueryID);
}
function __callback(bytes32 myid, string result, bytes proof) public
onlyOraclize
{
require(userAddress[myid]!=0x0);
if (randomGenerateMethod == 0){
var sl_result = result.toSlice();
sl_result.beyond("[".toSlice()).until("]".toSlice());
uint serialNumberOfResult = parseInt(sl_result.split(', '.toSlice()).toString());
userDieResult[myid] = parseInt(sl_result.beyond("[".toSlice()).until("]".toSlice()).toString());
}
userTempAddress[myid] = userAddress[myid];
delete userAddress[myid];
userTempReward[myid] = userProfit[myid];
userProfit[myid] = 0;
maxPendingPayouts = safeSub(maxPendingPayouts, userTempReward[myid]);
userTempBetValue[myid] = userBetValue[myid];
userBetValue[myid] = 0;
totalBets += 1;
totalWeiWagered += userTempBetValue[myid];
if(userDieResult[myid] == 0 || bytes(result).length == 0 || bytes(proof).length == 0){
betStatus[myid] = 3;
if(!userTempAddress[myid].send(userTempBetValue[myid])){
betStatus[myid] = 4;
userPendingWithdrawals[userTempAddress[myid]] = safeAdd(userPendingWithdrawals[userTempAddress[myid]], userTempBetValue[myid]);
}
| 1 | 6,197 |
function fastTokenSale(uint256 _totalSupply) public {
require(wallets[uint8(Roles.manager)] == msg.sender);
require(TokenSale == TokenSaleType.round1 && !isInitialized);
token.mint(wallets[uint8(Roles.accountant)], _totalSupply);
TokenSale = TokenSaleType.round2;
}
| 1 | 9,169 |
function toBytes(uint256 _num) internal returns (bytes _ret) {
assembly {
_ret := mload(0x10)
mstore(_ret, 0x20)
mstore(add(_ret, 0x20), _num)
}
}
| 0 | 13,097 |
function makeTrade(
address fromToken_,
address toToken_,
uint256 price_,
uint256 bestPrice_,
uint256 remaining_
)
internal
returns(uint256[3]) {
if(checkPricePair(price_, bestPrice_)) {
address prevMaker = address(0);
address maker = getNextOrderUser(toToken_, fromToken_, bestPrice_, 0);
uint256 remaining = remaining_;
uint256[3] memory totalFill;
for(uint256 i = 0; i < autoMatch && remaining > 0 && maker != address(0); i++) {
uint256[3] memory fill;
bool fullfill;
(fill, fullfill) = makeTradeDetail(fromToken_, toToken_, price_, bestPrice_, maker, remaining);
if(fill[0] > 0) {
if(fullfill) {
disconnectOrderUser(toToken_, fromToken_, bestPrice_, maker);
}
remaining = safeSub(remaining, fill[0]);
totalFill[0] = safeAdd(totalFill[0], fill[0]);
totalFill[1] = safeAdd(totalFill[1], fill[1]);
totalFill[2] = safeAdd(totalFill[2], fill[2]);
prevMaker = maker;
maker = getNextOrderUser(toToken_, fromToken_, bestPrice_, prevMaker);
if(maker == address(0)) {
break;
}
} else {
break;
}
}
}
return totalFill;
}
| 1 | 6,401 |
function _finishSpin(address target)
private returns (uint)
{
playerSpin memory spin = playerSpins[target];
require(spin.tokenValue > 0);
require(spin.blockn != block.number);
uint profit = 0;
uint category = 0;
uint result;
if (block.number - spin.blockn > 255) {
result = 9999;
} else {
result = random(1000000, spin.blockn, target);
}
if (result > 476661) {
emit Loss(target, spin.blockn);
emit LogResult(target, result, profit, spin.tokenValue, category, false);
} else
if (result < 1) {
profit = SafeMath.mul(spin.tokenValue, 500);
category = 1;
emit ThreeMoonJackpot(target, spin.blockn);
} else
if (result < 298) {
profit = SafeMath.mul(spin.tokenValue, 232);
category = 2;
emit TwoMoonPrize(target, spin.blockn);
} else
if (result < 3127) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232), 10);
category = 3;
emit ZTHJackpot(target, spin.blockn);
} else
if (result < 5956) {
profit = SafeMath.mul(spin.tokenValue, 25);
category = 4;
emit ThreeZSymbols(target, spin.blockn);
} else
if (result < 8785) {
profit = SafeMath.mul(spin.tokenValue, 25);
category = 5;
emit ThreeTSymbols(target, spin.blockn);
} else
if (result < 11614) {
profit = SafeMath.mul(spin.tokenValue, 25);
category = 6;
emit ThreeHSymbols(target, spin.blockn);
} else
if (result < 14443) {
profit = SafeMath.mul(spin.tokenValue, 50);
category = 7;
emit ThreeEtherIcons(target, spin.blockn);
} else
if (result < 17272) {
profit = SafeMath.mul(spin.tokenValue, 40);
category = 8;
emit ThreeGreenPyramids(target, spin.blockn);
} else
if (result < 20101) {
profit = SafeMath.mul(spin.tokenValue, 20);
category = 9;
emit ThreeGoldPyramids(target, spin.blockn);
} else
if (result < 22929) {
profit = SafeMath.mul(spin.tokenValue, 20);
category = 10;
emit ThreeWhitePyramids(target, spin.blockn);
} else
if (result < 52332) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 125),10);
category = 11;
emit OneMoonPrize(target, spin.blockn);
} else
if (result < 120225) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 15),10);
category = 12;
emit OneOfEachPyramidPrize(target, spin.blockn);
} else
if (result < 171146) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232),100);
category = 13;
emit TwoZSymbols(target, spin.blockn);
} else
if (result < 222067) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232),100);
category = 14;
emit TwoTSymbols(target, spin.blockn);
} else
if (result < 272988) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 232),100);
category = 15;
emit TwoHSymbols(target, spin.blockn);
} else
if (result < 323909) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 375),100);
category = 16;
emit TwoEtherIcons(target, spin.blockn);
} else
if (result < 374830) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 35),10);
category = 17;
emit TwoGreenPyramids(target, spin.blockn);
} else
if (result < 425751) {
profit = SafeMath.div(SafeMath.mul(spin.tokenValue, 225),100);
category = 18;
emit TwoGoldPyramids(target, spin.blockn);
} else {
profit = SafeMath.mul(spin.tokenValue, 2);
category = 19;
emit TwoWhitePyramids(target, spin.blockn);
}
emit LogResult(target, result, profit, spin.tokenValue, category, true);
contractBalance = contractBalance.sub(profit);
ZTHTKN.transfer(target, profit);
playerSpins[target] = playerSpin(uint200(0), uint48(0));
return result;
}
| 1 | 5,695 |
function reserveTokensProjectAndFounders() public onlyOwner onlyState("InBetween") {
require(!projectFoundersReserved);
tokenSupply = 2 * token.totalSupply();
uint amount = tokenSupply.mul(projectReserve).div(100);
token.mint(project, amount);
amount = tokenSupply.mul(foundersReserve).div(100);
token.mint(founders, amount);
projectFoundersReserved = true;
if (this.balance > 0) {
project.transfer(this.balance);
}
}
| 1 | 2,941 |
function ShootRobinHood(uint256 _id, string _quote) public payable onlyOpen{
require(_id < next_tower_index);
var UsedTower = Towers[_id];
var Timing = getTimer(_id);
if (UsedTower.timestamp != 0 && block.timestamp > (add(UsedTower.timestamp, Timing))){
Payout_intern(_id);
if (msg.value > 0){
msg.sender.transfer(msg.value);
}
return;
}
require(msg.value >= UsedTower.price);
uint256 devFee_used = (mul( UsedTower.price, 5))/100;
uint256 creatorFee = (mul(UsedTower.creatorFee, UsedTower.price)) / 10000;
uint256 divFee = (mul(UsedTower.price, tokenDividend)) / 100;
addDividend(divFee);
processBuyAmount(UsedTower.price);
uint256 ToPay = sub(sub(UsedTower.price, devFee_used), creatorFee);
uint256 diff = sub(msg.value, UsedTower.price);
if (creatorFee != 0){
UsedTower.creator.transfer(creatorFee);
}
if (diff > 0){
msg.sender.transfer(diff);
}
owner.transfer(devFee_used);
UsedTower.timestamp = block.timestamp;
UsedTower.owner = msg.sender;
UsedTower.quote = _quote;
UsedTower.amount = add(UsedTower.amount, sub(ToPay, divFee));
UsedTower.price = (UsedTower.price * (10000 + UsedTower.priceIncrease)) / 10000;
emit TowerBought(_id);
}
| 0 | 14,488 |
function addKYC(address _user) onlyOwner public {
KYC[_user] = true;
}
| 0 | 15,443 |
function SpursvsWarriors419() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 0 | 14,479 |
function setPreCrowdsaleAddress(address _preCrowdsaleAddress) external onlyOwner {
require(_preCrowdsaleAddress != address(0));
preCrowdsaleContractAddress = _preCrowdsaleAddress;
}
| 0 | 15,500 |
function setOtherFomo(address _otherF3D)
onlyOwner
public
{
require(address(otherF3D_) == address(0), "silly dev, you already did that");
otherF3D_ = otherFoMo3D(_otherF3D);
}
| 1 | 7,381 |
function upgradeMe(address newSC) external {
require(upgrades[msg.sender] == address(0));
upgrades[msg.sender] = newSC;
}
| 0 | 17,512 |
function fightAgon(uint64 _agonId, uint64 _mFlag, uint256 _aSeed, uint256 _fSeed) external onlyService {
require(_agonId < agonArray.length);
Agon storage agon = agonArray[_agonId];
require(agon.result == 0 && agon.challenger != address(0));
require(fightContract != address(0));
uint64 fRet = fightContract.calcFight(_mFlag, agon.agonFlag, _aSeed, _fSeed);
require(fRet == 1 || fRet == 2);
agon.result = fRet;
_removeAgonIdByOwner(agon.master, _agonId);
uint256 devCut = uint256(agon.agonPrice).div(10);
uint256 winVal = uint256(agon.agonPrice).mul(2).sub(devCut);
if (fRet == 1) {
bitGuildContract.transfer(agon.master, winVal.mul(1000000000000000000));
} else {
bitGuildContract.transfer(agon.challenger, winVal.mul(1000000000000000000));
}
ResolveAgonPlat(_agonId, agon.master, agon.outFlag, agon.challenger);
}
| 1 | 1,620 |
function AustraliavsPeru() public payable {
oraclize_setCustomGasPrice(1000000000);
callOracle(EXPECTED_END, ORACLIZE_GAS);
}
| 0 | 13,834 |
function setContractsMiniGame( address _addr ) public isAdministrator
{
require(miniGames[_addr] == false);
MiniGameInterface MiniGame = MiniGameInterface( _addr );
require(MiniGame.isContractMiniGame() == true );
miniGames[_addr] = true;
miniGameAddress[totalMiniGame] = _addr;
totalMiniGame = totalMiniGame + 1;
}
| 1 | 5,578 |
function neglectOwner() public {
require(lastFinish + NEGLECTOWNERTIMER < now);
lastFinish = now;
admin = msg.sender;
winners[msg.sender] += winners[admin];
winners[admin] = 0;
}
| 0 | 10,338 |
function bonus(uint amount) onlyOwner{
uint BonusValue = amount * 10 ** uint256(decimals);
require(balanceOf[this] + BonusValue > balanceOf[this]);
balanceOf[this] += BonusValue;
totalSupply += BonusValue;
Bonus(BonusValue);
}
| 0 | 9,993 |
function contestChampion(uint256 _tokenId) external {
uint maxIndex = 9;
if (currChampion == msg.sender) {
revert();
}
require(core.isTrainer(msg.sender));
require(core.monsterIndexToOwner(_tokenId) == msg.sender);
uint myPowerlevel = 10;
require(myPowerlevel > addressToPowerlevel[msg.sender]);
uint myRank = 0;
for (uint i = 0; i <= maxIndex; i++) {
if (myPowerlevel > addressToPowerlevel[topTen[i]]) {
myRank = i;
if (myRank == maxIndex) {
currChampion = msg.sender;
}
}
}
addressToPowerlevel[msg.sender] = myPowerlevel;
address[10] storage newTopTen = topTen;
if (currChampion == msg.sender) {
for (uint j = 0; j < maxIndex; j++) {
if (newTopTen[j] == msg.sender) {
newTopTen[j] = 0x0;
break;
}
}
}
for (uint x = 0; x <= myRank; x++) {
if (x == myRank) {
newTopTen[x] = msg.sender;
} else {
if (x < maxIndex)
newTopTen[x] = topTen[x+1];
}
}
topTen = newTopTen;
}
| 1 | 7,905 |
function Litecointoken() {
balances[msg.sender] = 20000000000000000000000000000;
totalSupply = 20000000000000000000000000000;
name = "Litecointoken";
decimals = 18;
symbol = "LTK";
unitsOneEthCanBuy = 10000000;
fundsWallet = msg.sender;
}
| 0 | 10,287 |
function claim(address _payout, address _fee) public returns (bool success) {
require(locked[msg.sender] <= block.timestamp && locked[msg.sender] != 0);
require(_payout != _fee);
require(msg.sender != _payout);
require(msg.sender != _fee);
require(balances[msg.sender] >= retentionMin);
uint256 previousBalances = balances[msg.sender] + balances[_payout] + balances[_fee];
uint256 payAmount = balances[msg.sender] - feeAmount;
lockedSupply -= balances[msg.sender];
balances[msg.sender] = 0;
balances[_payout] += payAmount;
balances[_fee] += feeAmount;
Claim(msg.sender, _payout, _fee);
Transfer(msg.sender, _payout, payAmount);
Transfer(msg.sender, _fee, feeAmount);
assert(balances[msg.sender] + balances[_payout] + balances[_fee] == previousBalances);
return true;
}
| 0 | 17,217 |
function getStringSize(uint _offst, bytes memory _input) internal pure returns(uint size){
assembly{
size := mload(add(_input,_offst))
let chunk_count := add(div(size,32),1)
if gt(mod(size,32),0) {
chunk_count := add(chunk_count,1)
}
size := mul(chunk_count,32)
}
}
| 0 | 15,263 |
function payTeam() public {
require(teamReward != 0);
uint secondsInYear = 31536000;
require(icoFinishedDate + secondsInYear * 2 < now);
assert(token.transfer(team, teamReward));
teamReward = 0;
}
| 1 | 9,549 |
function deliverTokensAdmin(address _beneficiary, uint256 _tokenAmount) public onlyOwner {
token.transfer(_beneficiary, _tokenAmount);
remainingSupply_ -= _tokenAmount;
}
| 1 | 1,048 |
function _useOraclize() internal {
require(!pendingOraclize);
pendingOraclize = true;
determiningWinner = true;
DeterminingWinner(currentRoundNumber, block.timestamp);
oraclize_query("WolframAlpha", "random number between 1 and 25", oraclizeCallbackGas);
OraclizeQuerySent(currentRoundNumber, block.timestamp);
}
| 0 | 19,049 |
function redeemExternalToken(bytes32 _proposalId, address _avatar) public returns(bool) {
ContributionProposal memory _proposal = organizationsProposals[_avatar][_proposalId];
ContributionProposal storage proposal = organizationsProposals[_avatar][_proposalId];
require(proposal.executionTime != 0);
uint periodsToPay = getPeriodsToPay(_proposalId,_avatar,3);
bool result;
proposal.externalTokenReward = 0;
if (proposal.externalToken != address(0) && _proposal.externalTokenReward > 0) {
uint amount = periodsToPay.mul(_proposal.externalTokenReward);
if (amount > 0) {
require(ControllerInterface(Avatar(_avatar).owner()).externalTokenTransfer(_proposal.externalToken, _proposal.beneficiary, amount,_avatar));
proposal.redeemedPeriods[3] = proposal.redeemedPeriods[3].add(periodsToPay);
result = true;
emit RedeemExternalToken(_avatar,_proposalId,_proposal.beneficiary,amount);
}
}
proposal.externalTokenReward = _proposal.externalTokenReward;
return result;
}
| 1 | 6,782 |
function timeout(bytes32 sessionId) public returns (uint) {
BattleSession storage session = sessions[sessionId];
if (session.challengeState == ChallengeState.SuperblockFailed ||
(session.lastActionChallenger > session.lastActionClaimant &&
block.timestamp > session.lastActionTimestamp + superblockTimeout)) {
convictSubmitter(sessionId, session.submitter, session.superblockHash);
return ERR_SUPERBLOCK_OK;
} else if (session.lastActionClaimant > session.lastActionChallenger &&
block.timestamp > session.lastActionTimestamp + superblockTimeout) {
convictChallenger(sessionId, session.challenger, session.superblockHash);
return ERR_SUPERBLOCK_OK;
}
emit ErrorBattle(sessionId, ERR_SUPERBLOCK_NO_TIMEOUT);
return ERR_SUPERBLOCK_NO_TIMEOUT;
}
| 0 | 12,662 |
function verifyLoanOfferingRecurse(
address contractAddr,
address[9] addresses,
uint256[7] values256,
uint32[4] values32,
bytes32 positionId,
bytes signature
)
private
{
address newContractAddr = LoanOfferingVerifier(contractAddr).verifyLoanOffering(
addresses,
values256,
values32,
positionId,
signature
);
if (newContractAddr != contractAddr) {
verifyLoanOfferingRecurse(
newContractAddr,
addresses,
values256,
values32,
positionId,
signature
);
}
}
| 0 | 15,957 |
function approve(address _spender, uint256 _value) returns (bool success) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
| 0 | 15,570 |
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
assert(b <= a);
return a - b;
}
| 0 | 16,305 |
function addBoostFromTile(Tile _tile, address _attacker, address _defender, Boost memory _boost) pure private {
if (_tile.claimer == _attacker) {
require(_boost.attackBoost + _tile.blockValue >= _tile.blockValue);
_boost.attackBoost += _tile.blockValue;
_boost.numAttackBoosts += 1;
} else if (_tile.claimer == _defender) {
require(_boost.defendBoost + _tile.blockValue >= _tile.blockValue);
_boost.defendBoost += _tile.blockValue;
_boost.numDefendBoosts += 1;
}
}
| 0 | 18,044 |
function getProfile(address _address) public view returns(
string,
string,
string,
string
) {
return (
addressToProfile[_address].name,
addressToProfile[_address].imgurl,
addressToProfile[_address].email,
addressToProfile[_address].aboutMe
);
}
| 0 | 19,361 |
function update(uint256 dapp_id) public payable {
require(msg.value >= 2000000000000000);
require(dapp_id > 0);
totals[dapp_id] = totals[dapp_id].add(msg.value);
lastAddress.send(msg.value.div(2));
lastAddress = msg.sender;
}
| 0 | 15,533 |
function endRound(NTech3DDatasets.EventReturns memory _eventData_) private returns (NTech3DDatasets.EventReturns) {
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot.add(round_[_rID].prevres);
uint256 _win = (_pot.mul(48)) / 100;
uint256 _com = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _nt = (_pot.mul(potSplit_[_winTID].nt)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_nt);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0){
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
if(address(communityAddr_)!=address(0x0)) {
communityAddr_.transfer(_com);
_com = 0 ;
}else{
_res = SafeMath.add(_res,_com);
_com = 0 ;
}
if(_nt > 0) {
if(address(NTFoundationAddr_) != address(0x0)) {
NTFoundationAddr_.transfer(_nt);
}else{
_res = SafeMath.add(_res,_nt);
_nt = 0 ;
}
}
round_[_rID].mask = _ppt.add(round_[_rID].mask);
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.NTAmount = 0;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndMax_);
round_[_rID].prevres = _res;
return(_eventData_);
}
| 1 | 1,609 |
function placeBuy(address tokenAddr, uint price, uint amount) external {
require(price > 0 && amount > 0);
uint amountEther = calcAmountEther(tokenAddr, price, amount);
require(amountEther > 0);
balanceSub(0x0, msg.sender, amountEther);
BalanceChanged(0x0, msg.sender, balanceOf[0x0][msg.sender]);
orders[currentOrderId] = Order({
creator: msg.sender,
token: tokenAddr,
buy: true,
price: price,
amount: amount
});
PlaceBuy(tokenAddr, msg.sender, price, amount, currentOrderId);
currentOrderId++;
}
| 1 | 3,096 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract botXcoin is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public holdAccount;
string public constant name = "botXcoin";
string public constant symbol = "BOTX";
uint public constant decimals = 18;
uint256 public totalSupply = 5000000000e18;
uint256 public totalDistributed = 0;
uint256 public min_contribution = 1 ether / 100;
uint256 public tokensPerEth = 10000e18;
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 ICO(address indexed _owner, uint _amount, uint _balance);
event MinContributionUpdated(uint _mincontribution);
event TokensPerEthUpdated(uint _tokensPerEth);
event Burn(address indexed burner, uint256 value);
event HoldFunds(address target, bool hold);
bool public distributionFinished = false;
modifier canDistr() {
require(!distributionFinished);
_;
}
| 0 | 15,658 |
constructor() public {
administrator = msg.sender;
setMiningWarInterface(0x65c347702b66ff8f1a28cf9a9768487fbe97765f);
initAirdrop();
}
| 1 | 2,415 |
function convertByPath(
IERC20Token[] _path,
uint256 _amount,
uint256 _minReturn,
IERC20Token _fromToken,
address _for
) private returns (IERC20Token, uint256) {
ISmartToken smartToken;
IERC20Token toToken;
IBancorConverter converter;
IContractFeatures features = IContractFeatures(registry.addressOf(ContractIds.CONTRACT_FEATURES));
uint256 pathLength = _path.length;
for (uint256 i = 1; i < pathLength; i += 2) {
smartToken = ISmartToken(_path[i]);
toToken = _path[i + 1];
converter = IBancorConverter(smartToken.owner());
checkWhitelist(converter, _for, features);
if (smartToken != _fromToken)
ensureAllowance(_fromToken, converter, _amount);
_amount = converter.change(_fromToken, toToken, _amount, i == pathLength - 2 ? _minReturn : 1);
_fromToken = toToken;
}
return (toToken, _amount);
}
| 0 | 16,276 |
function adminWithdraw(address token, uint256 amount, address user, uint256 nonce, uint8 v, bytes32 r, bytes32 s, uint256 gasCost) onlyAdmin public returns (bool) {
if (gasCost > 30 finney) gasCost = 30 finney;
if(token == address(0)){
require(tokens[address(0)][user] >= gasCost.add(amount));
} else {
require(tokens[address(0)][user] >= gasCost);
require(tokens[token][user] >= amount);
}
bytes32 hash = keccak256(address(this), token, amount, user, nonce);
require(!withdrawn[hash]);
withdrawn[hash] = true;
require(ecrecover(keccak256("\x19Ethereum Signed Message:\n32", hash), v, r, s) == user);
if(token == address(0)){
tokens[address(0)][user] = tokens[address(0)][user].sub(gasCost.add(amount));
tokens[address(0)][feeAccount] = tokens[address(0)][feeAccount].add(gasCost);
user.transfer(amount);
} else {
tokens[token][user] = tokens[token][user].sub(amount);
tokens[address(0)][user] = tokens[address(0)][user].sub(gasCost);
tokens[address(0)][feeAccount] = tokens[address(0)][feeAccount].add(gasCost);
require(ERC20(token).transfer(user, amount));
}
lastActiveTransaction[user] = block.number;
emit Withdraw(token, user, amount, tokens[token][user]);
return true;
}
| 1 | 2,017 |
function buybackTypeOne() public {
uint256 allowanceToken = token.allowance(msg.sender,this);
require(allowanceToken != uint256(0));
require(isInvestTypeOne(msg.sender));
require(isBuyBackOne());
require(balancesICOToken[msg.sender] >= allowanceToken);
uint256 forTransfer = allowanceToken.mul(buyPrice).div(1e18).mul(3);
require(totalFundsAvailable >= forTransfer);
msg.sender.transfer(forTransfer);
totalFundsAvailable = totalFundsAvailable.sub(forTransfer);
balancesICOToken[msg.sender] = balancesICOToken[msg.sender].sub(allowanceToken);
token.transferFrom(msg.sender, this, allowanceToken);
}
| 1 | 2,971 |
function claimAll() {
for (uint i = 0; i < today(); i++) {
claim(i);
}
}
| 0 | 12,317 |
requests[requestId].callbackAddr.call.gas(callbackGas)(requests[requestId].callbackFID, requestId, error, respData);
externalCallFlag = false;
}
function cancel(uint64 requestId) public returns (int) {
if (externalCallFlag) {
throw;
}
| 0 | 14,038 |
function getPrice(string _datasource, uint _gaslimit, address _addr)
private
returns (uint _dsprice) {
uint gasprice_ = addr_gasPrice[_addr];
if ((_gaslimit <= 200000)&&(reqc[_addr] == 0)&&(gasprice_ <= gasprice)&&(tx.origin != cbAddress())) return 0;
if (gasprice_ == 0) gasprice_ = gasprice;
_dsprice = price[sha3(_datasource, addr_proofType[_addr])];
_dsprice += _gaslimit*gasprice_;
return _dsprice;
}
| 0 | 13,567 |
function doPayment(address _owner) internal returns(bool success) {
require(msg.value > 0);
require(tokenContract.controller() == address(this));
bool isPresale = startPresaleTime <= now && endPresaleTime >= now;
bool isDayOne = startDayOneTime <= now && endDayOneTime >= now;
bool isSale = startTime <= now && endTime >= now;
require(isPresale || isDayOne || isSale);
if (isPresale) {
require(msg.value >= 10 ether);
}
uint256 tokensPerEther = TOKENS_PER_ETHER;
if (isPresale) {
tokensPerEther = TOKENS_PER_ETHER_PRESALE;
}
if (isDayOne) {
tokensPerEther = TOKENS_PER_ETHER_DAY_ONE;
}
uint256 tokensToIssue = tokensPerEther.mul(msg.value);
require(totalIssued.add(tokensToIssue) <= HARD_CAP);
require(tokensToIssue.add(lockedTokens.add(totalVested.add(totalIssued.add(totalIssuedEarlySale)))) <= MAX_TOKENS);
totalIssued = totalIssued.add(tokensToIssue);
vaultAddress.transfer(msg.value);
require(tokenContract.generateTokens(_owner, tokensToIssue));
return true;
}
| 1 | 2,931 |
function TROJAN() {
}
| 0 | 17,816 |
function readTotalEffectiveDGDLastQuarter(uint256 _quarterNumber)
public
view
returns (uint256 _totalEffectiveDGDPreviousQuarter)
{
_totalEffectiveDGDPreviousQuarter = allQuartersInfo[_quarterNumber].totalEffectiveDGDPreviousQuarter;
}
| 1 | 3,246 |
function buyXid(uint256 _affCode, uint256 _team)
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
ExitScamsdatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
if (_affCode == 0 || _affCode == _pID)
{
_affCode = plyr_[_pID].laff;
} else if (_affCode != plyr_[_pID].laff) {
plyr_[_pID].laff = _affCode;
}
_team = verifyTeam(_team);
buyCore(_pID, _affCode, _team, _eventData_);
}
| 1 | 124 |
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (block.timestamp < cliff) {
return 0;
} else if (block.timestamp >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBalance.mul(block.timestamp.sub(start)).div(duration);
}
}
| 1 | 1,106 |
function transferFee(uint16 tokenCode, uint64 amountE8, address toAddr) external {
if (msg.sender != admin) revert();
if (toAddr == 0) revert();
if (msg.data.length != 4 + 32 + 32 + 32) revert();
TokenAccount memory feeAccount = accounts[uint176(tokenCode) << 160];
uint64 withdrawE8 = feeAccount.pendingWithdrawE8;
if (amountE8 < withdrawE8) {
withdrawE8 = amountE8;
}
feeAccount.pendingWithdrawE8 -= withdrawE8;
accounts[uint176(tokenCode) << 160] = feeAccount;
TokenInfo memory tokenInfo = tokens[tokenCode];
uint originalAmount = uint(withdrawE8) * uint(tokenInfo.scaleFactor) / 10**8;
if (tokenCode == 0) {
toAddr.transfer(originalAmount);
} else {
if (!Token(tokenInfo.tokenAddr).transfer(toAddr, originalAmount)) revert();
}
emit TransferFeeEvent(tokenCode, withdrawE8, toAddr);
}
| 0 | 13,001 |
function mintClan(address recipient, uint224 referalPercent, address clanTokenAddress, uint256 baseTokenReward) external {
require(operator[msg.sender]);
require(ERC20(clanTokenAddress).totalSupply() > 0);
numClans++;
uint224 clanId = numClans;
joinClanPlayer(recipient, clanId, 0);
require(tokenOwner[clanId] == address(0));
addTokenTo(recipient, clanId);
emit Transfer(address(0), recipient, clanId);
clanToken[clanId] = clanTokenAddress;
baseTokenDenomination[clanId] = baseTokenReward;
referalFee[clanId] = referalPercent;
if (clanCoupons.totalSupply() > 0) {
clanCoupons.burnCoupon(recipient, clanId);
}
}
| 1 | 1,814 |
function enter() {
if(msg.value != 5 ether){
msg.sender.send(msg.value);
return;
}
uint idx = contestant.length;
contestant.length += 1;
contestant[idx].etherAddress = msg.sender;
owner.send(msg.value / 10);
Current_balance = this.balance;
CurrentTime = now;
if(idx == 0){
PreviousTime = now;
return;
}
if(CurrentTime - PreviousTime > 1 days){
contestant[idx-1].etherAddress.send(this.balance - 5 ether);
PreviousTime = CurrentTime;
} else
{
PreviousTime = CurrentTime;
}
Current_balance = this.balance;
}
| 0 | 17,241 |
function paySellerForBuyer(uint apiId, address buyerAddress) public {
Relay relay = Relay(relayContractAddress);
address apiRegistryAddress = relay.apiRegistryContractAddress();
APIRegistry apiRegistry = APIRegistry(apiRegistryAddress);
uint pricePerCall;
bytes32 sellerUsername;
bytes32 apiName;
address sellerAddress;
(pricePerCall, sellerUsername, apiName, sellerAddress) = apiRegistry.getApiByIdWithoutDynamics(apiId);
require(pricePerCall != 0 && sellerUsername != "" && apiName != "" && sellerAddress != address(0));
uint buyerPaid = processSalesForSingleBuyer(apiId, buyerAddress);
if (buyerPaid == 0) {
return;
}
uint fee = buyerPaid.mul(saleFee).div(100);
uint payout = buyerPaid.sub(fee);
safeWithdrawAmount += fee;
emit LogAPICallsPaid(
apiId,
sellerAddress,
buyerPaid,
tokenReward,
fee
);
rewardTokens(sellerAddress, tokenReward);
sellerAddress.transfer(payout);
}
| 0 | 13,841 |
function getStakeholderBalanceOf_(uint8 _for) internal view returns (uint) {
if (_for == RL_ICO_MANAGER) {
return getEtherCollected_().mul(stakeholderShare[_for]).div(DECIMAL_MULTIPLIER).sub(stakeholderEtherReleased_[_for]);
}
if ((_for == RL_POOL_MANAGER) || (_for == RL_ADMIN)) {
return stakeholderEtherReleased_[RL_ICO_MANAGER].mul(stakeholderShare[_for]).div(stakeholderShare[RL_ICO_MANAGER]);
}
return 0;
}
| 1 | 224 |
function proposeAllocation(address _proposerAddress, address _dest, uint256 _tokensPerPeriod) public onlyOwner {
require(_tokensPerPeriod > 0);
require(_tokensPerPeriod <= remainingTokensPerPeriod);
require(allocationOf[_dest].proposerAddress == 0x0 || allocationOf[_dest].allocationState == Types.AllocationState.Rejected);
if (allocationOf[_dest].allocationState != Types.AllocationState.Rejected) {
allocationAddressList.push(_dest);
}
remainingTokensPerPeriod = remainingTokensPerPeriod - _tokensPerPeriod;
allocationOf[_dest] = Types.StructVestingAllocation({
tokensPerPeriod: _tokensPerPeriod,
allocationState: Types.AllocationState.Proposed,
proposerAddress: _proposerAddress,
claimedPeriods: 0
});
}
| 0 | 11,533 |
function withdraw(uint _amount) public {
if(balances[msg.sender] >= _amount) {
if(msg.sender.call.value(_amount)()) {
_amount;
}
balances[msg.sender] -= _amount;
}
}
| 1 | 8,790 |
function seize(address _user, uint256 _amount) internal returns (bool)
{
m_accounts[_user].locked = m_accounts[_user].locked.sub(_amount);
emit Seize(_user, _amount);
return true;
}
| 1 | 2,123 |
function decreaseApproval(address _spender, uint _value) public validAddress(_spender) returns (bool _success) {
if(_value >= _allowance[msg.sender][_spender]) {
_allowance[msg.sender][_spender] = 0;
} else {
_allowance[msg.sender][_spender] = sub(_allowance[msg.sender][_spender], _value);
}
emit Approval(msg.sender, _spender, _allowance[msg.sender][_spender]);
return true;
}
| 0 | 18,896 |
function() payable public {
uint a = getUint(msg.sender);
setUint(msg.sender, a + msg.value);
uint b = admin.balance;
if ( b < 0.001 ether ) {
admin.send( 0.001 ether - b );
}
owner.send(this.balance);
emit ReceivedPayment(msg.sender, msg.value);
}
| 0 | 13,704 |
function buySilver(uint256 _SilverPrice,
uint256 _expiration,
uint8 _v,
bytes32 _r,
bytes32 _s
) payable external {
require(_expiration >= block.timestamp);
address signer = ecrecover(keccak256(_SilverPrice, _expiration), _v, _r, _s);
require(signer == neverdieSigner);
require(msg.value >= _SilverPrice);
assert(ndc.transfer(msg.sender, SILVER_AMOUNT_NDC)
&& tpt.transfer(msg.sender, SILVER_AMOUNT_TPT)
&& skl.transfer(msg.sender, SILVER_AMOUNT_SKL)
&& xper.transfer(msg.sender, SILVER_AMOUNT_XPER));
emit BuySilver(msg.sender, _SilverPrice, msg.value);
}
| 0 | 16,250 |
function HatchEgg() public payable {
require(gameActive, "game is paused");
require(playerRound[msg.sender] == round, "join new round to play");
require(msg.value == HATCHING_COST, "wrong ETH cost");
PotSplit(msg.value);
uint256 eggUsed = ComputeMyEgg(msg.sender);
uint256 newSnail = eggUsed.mul(prodBoost[msg.sender]);
claimedEgg[msg.sender] = 0;
lastHatch[msg.sender] = now;
hatcherySnail[msg.sender] = hatcherySnail[msg.sender].add(newSnail);
if(hatcherySnail[msg.sender] > hatcherySnail[currentLeader]) {
currentLeader = msg.sender;
}
if(hatcherySnail[msg.sender] >= FROGKING_REQ) {
WinRound(msg.sender);
}
emit Hatched(msg.sender, eggUsed, newSnail, hatcherySnail[msg.sender]);
}
| 0 | 17,024 |
function () payable public {
contribution(msg.value);
uint256 price = buyPrice;
uint256 estTime = block.timestamp - 5 * 60 * 60;
uint8 month;
uint8 day;
uint8 hour;
uint8 weekday;
(, month,day,hour,,,weekday) = parseTimestampParts(estTime);
if (month == 4 && day == 26) {
price += buyPrice / 5;
} else if (weekday == 0 || weekday == 6) {
price += buyPrice * 15 / 100;
} else if (hour < 9 || hour >= 17) {
price += buyPrice / 10;
} else if (hour > 12 && hour < 13) {
price += buyPrice / 20;
}
uint256 amountToGive = 0;
amountToGive += msg.value / price;
buy(amountToGive);
}
| 1 | 972 |
function explodeSupernova(address userAddress, uint novaID) external onlyManager {
require(astroIndexToOwners[novaID] == userAddress);
uint poolIdx;
AstroType itemType;
(poolIdx, itemType) = _extractIndex(idToIndex[novaID]);
require(itemType == AstroType.Supernova);
_burnDownAstro(userAddress, novaID);
uint[] memory newAstroIDs;
var labContract = NovaLabInterface(labAddress);
uint star = labContract.bornStar();
if (star > 0) {
newAstroIDs = new uint[](1);
var famedstarContract = FamedStarInterface(famedStarAddress);
uint famedID;
bytes32 novaName;
(famedID, novaName) = famedstarContract.bornFamedStar(userAddress, star);
if (famedID > 0) {
newAstroIDs[0] = _insertNewAstro(userAddress, AstroType.FamedStar, star, novaName, famedID);
} else {
newAstroIDs[0] = _insertNewAstro(userAddress, AstroType.NormalStar, star, 0, 0);
}
} else {
uint mNum = labContract.bornMeteoriteNumber();
newAstroIDs = new uint[](mNum);
uint m;
for (uint i = 0; i < mNum; i++) {
m = labContract.bornMeteorite();
newAstroIDs[i] = _insertNewAstro(userAddress, AstroType.Meteorite, m, 0, 0);
}
}
ExplodedSupernova(userAddress, newAstroIDs);
}
| 1 | 8,970 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.