func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function deployTokenContract(uint _start_date) public{
address _token;
require(_start_date % 86400 == 0);
require(long_tokens[_start_date] == address(0) && short_tokens[_start_date] == address(0));
_token = new DRCT_Token();
token_dates[_token] = _start_date;
long_tokens[_start_date] = _token;
token_type[_token]=2;
_token = new DRCT_Token();
token_type[_token]=1;
short_tokens[_start_date] = _token;
token_dates[_token] = _start_date;
startDates.push(_start_date);
}
| 1 | 7,175 |
function increaseSupply(uint value, address to) public onlyOwner returns (bool) {
totalSupply_ = totalSupply_.add(value);
balances[to] = balances[to].add(value);
emit Transfer(address(0), to, value);
return true;
}
| 0 | 14,995 |
function removeTrustedContractAddress(address addr) auth public returns (bool) {
trustedContractAddresses[addr] = false;
RemoveTrustedContractAddress(msg.sender, addr);
return true;
}
| 0 | 11,413 |
function release(ERC20MiniMe token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
require(token.transfer(beneficiary, unreleased));
Released(unreleased);
}
| 1 | 3,882 |
function startNewRound() public payable {
require(!upgraded, "This contract has been upgraded!");
if(rounds.length > 0) {
require(rounds[latestRoundID].finalized, "Previous round not finalized");
require(rounds[latestRoundID].softDeadline < now, "Previous round still running");
}
uint _rID = rounds.length++;
MobiusRound storage rnd = rounds[_rID];
latestRoundID = _rID;
rnd.lastInvestor = msg.sender;
rnd.price = STARTING_SHARE_PRICE;
rnd.hardDeadline = now + HARD_DEADLINE_DURATION;
rnd.softDeadline = now + SOFT_DEADLINE_DURATION;
rnd.jackpot = jackpotSeed;
jackpotSeed = 0;
_purchase(rnd, msg.value, address(0x0));
emit RoundStarted(_rID, rnd.hardDeadline);
}
| 1 | 6,055 |
function settleBetCommon(Bet storage bet, bytes20 reveal1, bytes20 reveal2, bytes32 entropyBlockHash) private {
uint amount = bet.amount;
uint modulo = bet.modulo;
uint rollUnder = bet.rollUnder;
address gambler = bet.gambler;
require(amount != 0, "Bet should be in an 'active' state");
bet.amount = 0;
bytes32 entropy = keccak256(abi.encodePacked(reveal1, entropyBlockHash, reveal2));
uint dice = uint(entropy) % modulo;
uint diceWinAmount;
uint _jackpotFee;
(diceWinAmount, _jackpotFee) = getDiceWinAmount(amount, modulo, rollUnder);
uint diceWin = 0;
uint jackpotWin = 0;
if ((modulo != 100) && (modulo <= MAX_MASK_MODULO * 6)) {
if ((2 ** dice) & bet.mask != 0) {
diceWin = diceWinAmount;
}
} else {
if (dice < rollUnder) {
diceWin = diceWinAmount;
}
}
lockedInBets -= uint128(diceWinAmount);
if (amount >= MIN_JACKPOT_BET) {
uint jackpotRng = (uint(entropy) / modulo) % JACKPOT_MODULO;
if (jackpotRng == 0) {
jackpotWin = jackpotSize;
jackpotSize = 0;
}
}
if (jackpotWin > 0) {
emit JackpotPayment(gambler, jackpotWin);
}
sendFunds(gambler, diceWin + jackpotWin == 0 ? 1 wei : diceWin + jackpotWin, diceWin);
}
| 0 | 11,115 |
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());
}
if (randomGenerateMethod == 1){
uint maxRange = 100;
userDieResult[myid] = uint(sha3(result)) % maxRange + 1;
}
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 | 8,135 |
function setDungeonPreparationTime(uint _newDungeonPreparationTime) onlyOwner external {
dungeonPreparationTime = _newDungeonPreparationTime;
}
| 0 | 9,802 |
function()
isActivated()
isHuman()
isWithinLimits(msg.value)
public
payable
{
F3Ddatasets.EventReturns memory _eventData_ = determinePID(_eventData_);
uint256 _pID = pIDxAddr_[msg.sender];
plyr_[_pID].gen = plyr_[_pID].gen.add(msg.value);
}
| 1 | 7,605 |
function () payable
{
require(!crowdsaleClosed);
require(tokensLeft >= amount / price);
uint amount = msg.value;
balanceOf[msg.sender] += amount;
amountRaised += amount;
tokenReward.transfer(msg.sender, amount / price);
FundTransfer(msg.sender, amount, true);
tokensLeft = tokenReward.getBalanceOf(address(this));
if (tokensLeft == 0)
{
crowdsaleClosed = true;
}
}
| 1 | 3,875 |
function revoke(ERC20Basic token) public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(unreleasedHolder, refund);
emit Revoked();
}
| 0 | 14,145 |
function emitTokenStateUpdated(address newTokenState) internal {
proxy._emit(abi.encode(newTokenState), 1, TOKENSTATEUPDATED_SIG, 0, 0, 0);
}
| 1 | 2,789 |
function mintMulti(address[] _investors, uint256[] _amounts) public onlyModule(STO_KEY, true) returns (bool success) {
require(_investors.length == _amounts.length, "Mis-match in the length of the arrays");
for (uint256 i = 0; i < _investors.length; i++) {
mint(_investors[i], _amounts[i]);
}
return true;
}
| 1 | 9,136 |
function getType(uint id) public view returns (string, uint, uint, uint, uint, uint) {
return (types[id].name, types[id].currentPrice, types[id].basePrice, types[id].sales, types[id].id, types[id].maxPower);
}
| 0 | 18,389 |
function transfer(address _to, uint256 _amount) public notTimeLocked stopInEmergency returns (bool success) {
if (balances[msg.sender] < _amount) {
error('transfer: the amount to transfer is higher than your token balance');
return false;
}
if(!SCComplianceService.validate(msg.sender, _to, _amount)) {
error('transfer: not allowed by the compliance service');
return false;
}
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
| 1 | 1,857 |
function() public payable {
revert();
}
| 0 | 18,179 |
modifier onlyMiningContract() {
require(msg.sender == miningContract);
_;
}
| 1 | 4,108 |
function bid(uint256 _tokenId)
external
payable
{
address seller = tokenIdToAuction[_tokenId].seller;
uint256 price = _bid(_tokenId, msg.value);
_transfer(msg.sender, _tokenId);
if (seller == address(nonFungibleContract) || seller == owner) {
for (uint256 i = 0; i < 5; i++) {
if (lastGen0SalePrices[i] == 0) {
lastGen0SalePrices[i] = 175 finney;
}
}
lastGen0SalePrices[gen0SaleCount % 5] = price;
gen0SaleCount++;
}
}
| 1 | 5,213 |
function deploy() public onlyOwner {
token = new Token();
preITO = new PreITO();
preITO.setWallet(0x89C92383bCF3EecD5180aBd055Bf319ceFD2D516);
preITO.setStart(1531612800);
preITO.setPeriod(48);
preITO.setPrice(1080000000000000000000);
preITO.setMinInvestedLimit(100000000000000000);
preITO.setSoftcap(1000000000000000000000);
preITO.setHardcap(4000000000000000000000);
preITO.setToken(token);
preITO.setDirectMintAgent(0xF3D57FC2903Cbdfe1e1d33bE38Ad0A0753E72406);
token.setSaleAgent(preITO);
ito = new ITO();
ito.setWallet(0xb13a4803bcC374B8BbCaf625cdD0a3Ac85CdC0DA);
ito.setStart(1535760000);
ito.addMilestone(7, 15);
ito.addMilestone(7, 13);
ito.addMilestone(7, 11);
ito.addMilestone(7, 9);
ito.addMilestone(7, 7);
ito.addMilestone(7, 5);
ito.addMilestone(7, 3);
ito.setPrice(900000000000000000000);
ito.setMinInvestedLimit(100000000000000000);
ito.setHardcap(32777000000000000000000);
ito.addWallet(0xA5A5cf5325AeDA4aB32b9b0E0E8fa91aBDb64DdC, 10);
ito.setToken(token);
ito.setDirectMintAgent(0xF3D57FC2903Cbdfe1e1d33bE38Ad0A0753E72406);
preITO.setNextSaleAgent(ito);
address manager = 0xd8Fe93097F0Ef354fEfee2e77458eeCc19D8D704;
token.transferOwnership(manager);
preITO.transferOwnership(manager);
ito.transferOwnership(manager);
}
| 1 | 8,281 |
function executeOrder() public onlyOwnerOrPartner {
require(now <= toTime && status == StatusChoices.REPAYMENT_WAITING);
if (loanTokenName.stringCompare(TOKEN_ETH)) {
require(ethAmount[maker] >= repaymentSum && address(this).balance >= repaymentSum);
lastRepaymentSum = address(this).balance;
taker.transfer(repaymentSum);
} else {
require(ERC20(token20).balanceOf(address(this)) >= repaymentSum);
lastRepaymentSum = ERC20(token20).balanceOf(address(this));
require(safeErc20Transfer(taker, repaymentSum));
}
PledgeContract(owner)._conclude();
status = StatusChoices.REPAYMENT_ALL;
emit ExecuteOrder(maker, lastRepaymentSum);
}
| 1 | 3,255 |
function pay(uint256 percentage) public {
percentage = percentage <= vestingAmount ? percentage : vestingAmount;
uint256 balance = token.balanceOf(this);
var (period, amount) = calculate(getBlockTime() , balance , percentage);
require(period > 0);
require(vestings[period].status == false);
require(vestings[period].wallet == address(0));
require(amount > 0);
vestings[period].period = period;
vestings[period].status = true;
vestings[period].wallet = wallet;
vestings[period].amount = amount;
vestings[period].timestamp = getBlockTime();
bytes memory empty;
token.transfer(wallet, amount, empty);
Payouts(period, vestings[period].status, vestings[period].wallet, vestings[period].amount, vestings[period].timestamp);
}
| 1 | 7,323 |
function accrueAdvisorsTokens(address to, uint256 amount) public onlyOwner {
require(now > ICO_End);
uint256 tokenBalance = _token.balanceOf(address(this));
require(tokenBalance >= _accruedTokensAmount.add(amount));
_accruedTokensAmount = _accruedTokensAmount.add(amount);
sixMonthsFreezingAccrual[to] = sixMonthsFreezingAccrual[to].add(amount);
emit Accrual(to, amount, _sixMonths, 0, 0);
}
| 1 | 2,690 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(block.timestamp >= 1545102693);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
| 0 | 14,501 |
function init(address _eos, address _cnt, address _bgb, address _vpe, address _gvpe, address _nrb) public {
require(!initialized);
EOS_address = _eos;
CNT_address = _cnt;
BGB_address = _bgb;
VPE_address = _vpe;
GVPE_address = _gvpe;
NRB_address = _nrb;
PRE_SALE_Token(CNT_address).init(address(this));
PRE_SALE_Token(BGB_address).init(address(this));
PRE_SALE_Token(VPE_address).init(address(this));
PRE_SALE_Token(GVPE_address).init(address(this));
initialized = true;
}
| 1 | 7,389 |
function activateDividends(address account1, address account2) internal {
activateDividends(account1);
activateDividends(account2);
}
| 1 | 4,627 |
modifier onlyAllowedMultivests(address _addresss) {
require(allowedMultivests[_addresss] == true);
_;
}
| 0 | 16,840 |
modifier dataCenterAPI() {
if((address(DAR) == 0) || (getCodeSize(address(DAR)) == 0))
setNetwork(networkID_auto);
if(address(dataCenter) != DAR.getAddress())
dataCenter = DataCenterInterface(DAR.getAddress());
_;
}
| 1 | 1,319 |
function getDepositDetails(
address depositor,
bytes4[] memory terms
) public view returns (bytes4[] memory, uint256[] memory, uint256[] memory, uint256[] memory)
{
Deposit[][] memory depositListByTerms = new Deposit[][](terms.length);
uint256 totalDepositCount = 0;
for (uint256 i = 0; i < terms.length; i++) {
bytes4 term = terms[i];
TermDepositInfo storage info = _termDeposits[term];
require(info.duration > 0, "should be a valid term");
Deposit[] memory deposits = info.deposits[depositor];
depositListByTerms[i] = deposits;
totalDepositCount = totalDepositCount.add(deposits.length);
}
bytes4[] memory depositTerms = new bytes4[](totalDepositCount);
uint256[] memory amounts = new uint256[](totalDepositCount);
uint256[] memory depositTs = new uint256[](totalDepositCount);
uint256[] memory withdrawTs = new uint256[](totalDepositCount);
uint256 retIndex = 0;
for (uint256 i = 0; i < depositListByTerms.length; i++) {
Deposit[] memory deposits = depositListByTerms[i];
for (uint256 j = 0; j < deposits.length; j++) {
depositTerms[retIndex] = terms[i];
Deposit memory d = deposits[j];
amounts[retIndex] = d.amount;
depositTs[retIndex] = d.depositAt;
withdrawTs[retIndex] = d.withdrawAt;
retIndex += 1;
}
}
assert(retIndex == totalDepositCount);
return (depositTerms, amounts, depositTs, withdrawTs);
}
| 0 | 17,414 |
function explodePhoenix(uint256 _phoenixId) whenNotPaused public {
Phoenix phoenix = phoenixes[_phoenixId];
require(msg.sender == phoenix.currentOwner);
require(PHOENIX_POOL > 0);
require(now >= phoenix.nextExplosionTime);
uint256 payout = phoenix.explosivePower.mul(PHOENIX_POOL).div(EXPLOSION_DENOMINATOR);
PHOENIX_POOL = PHOENIX_POOL.sub(payout);
if (phoenix.price >= PRICE_CUTOFF) {
phoenix.price = phoenix.price.mul(HIGHER_PRICE_RESET_PERCENTAGE).div(100);
} else {
phoenix.price = phoenix.price.mul(LOWER_PRICE_RESET_PERCENTAGE).div(100);
if (phoenix.price < BASE_PRICE) {
phoenix.price = BASE_PRICE;
}
}
phoenix.previousOwner = msg.sender;
phoenix.nextExplosionTime = now + (phoenix.cooldown * 1 minutes);
sendFunds(msg.sender,payout);
PhoenixExploded(_phoenixId, msg.sender, payout, phoenix.price, phoenix.nextExplosionTime);
}
| 0 | 19,342 |
function cancelBid(address bidder, bytes32 seal) {
Deed bid = sealedBids[bidder][seal];
if (address(bid) == 0
|| now < bid.creationDate() + initialAuctionPeriod
|| bid.owner() > 0) throw;
bid.setOwner(msg.sender);
bid.closeDeed(5);
sealedBids[bidder][seal] = Deed(0);
BidRevealed(seal, bidder, 0, 5);
}
| 1 | 5,162 |
function __callback(bytes32 myid, string result, bytes proof) public {
require (msg.sender == oraclize_cbAddress());
require (!chronus.race_end);
bytes32 coin_pointer;
chronus.race_start = true;
chronus.betting_open = false;
bettingControllerInstance.remoteBettingClose();
coin_pointer = oraclizeIndex[myid];
if (myid == coinIndex[coin_pointer].preOraclizeId) {
if (coinIndex[coin_pointer].pre > 0) {
} else if (now >= chronus.starting_time+chronus.betting_duration+ 30 minutes) {
forceVoidRace();
} else {
coinIndex[coin_pointer].pre = stringToUintNormalize(result);
emit newPriceTicker(coinIndex[coin_pointer].pre);
}
} else if (myid == coinIndex[coin_pointer].postOraclizeId){
if (coinIndex[coin_pointer].pre > 0 ){
if (coinIndex[coin_pointer].post > 0) {
} else if (now >= chronus.starting_time+chronus.race_duration+ 30 minutes) {
forceVoidRace();
} else {
coinIndex[coin_pointer].post = stringToUintNormalize(result);
coinIndex[coin_pointer].price_check = true;
emit newPriceTicker(coinIndex[coin_pointer].post);
if (coinIndex[horses.ETH].price_check && coinIndex[horses.BTC].price_check && coinIndex[horses.LTC].price_check) {
reward();
}
}
} else {
forceVoidRace();
}
}
}
| 1 | 7,226 |
function periodAt(uint _blockTimestamp) constant returns(uint) {
if (startBlockTimestamp > _blockTimestamp)
return 0;
uint p = ((_blockTimestamp - startBlockTimestamp) / intervalSecs) + 1;
if (p > periods)
p = periods;
return p;
}
| 0 | 16,066 |
function updateClosingTime(uint256 _closingTime) external onlyManagement {
require(_closingTime > preSaleCloseTime, "A closing time must be after the pre-sale close time");
closingTime = _closingTime;
}
| 0 | 12,192 |
function buy(string _index, address buyer) onlyOwner returns (bool) {
require(token != 0x0);
bytes32 _bindex = ConvertStringByte.stringToBytes32(_index);
uint256 fee = coin.fee();
require(storehouse[_bindex].amount > 0);
Bullion bullion = storehouse[_bindex];
uint256 tokenPrice = convert2PlatinumToken(bullion.amount);
uint256 tokenPriceFee = tokenPrice.add(fee);
bool transfered = coin.transferFrom(buyer, coin.owner(), tokenPriceFee);
require(transfered);
bool reduced = coin.reduce(tokenPrice);
require(reduced);
for (uint256 index = 0; index < storehouseIndex.length; index++) {
Bullion _bullion = storehouse[storehouseIndex[index]];
if (_bullion.index.toSlice().equals(_index.toSlice())) {
delete storehouseIndex[index];
}
}
delete storehouse[_bindex];
Buy(_index, buyer, fee, tokenPrice);
return true;
}
| 1 | 1,135 |
function () payable public {
contribution(msg.value);
uint256 amountToGive = 0;
uint256 price = buyPrice;
if (totalBought < 10000) {
price -= price * 15 / 100;
} else if (totalBought < 50000) {
price -= price / 10;
} else if (totalBought < 100000) {
price -= price / 20;
} else if (totalBought < 200000) {
price -= price / 100;
}
amountToGive += msg.value / price;
buy(amountToGive);
}
| 1 | 4,529 |
function setNFTContractInfo(string newHostName, string newName, string newSymbol) onlyByWeTrustManager external {
hostname = newHostName;
nftName = newName;
nftSymbol = newSymbol;
}
| 0 | 11,667 |
function closeBet() external {
require(!isBetClosed);
(leftPts, rightPts, confirmations) = dataCenterGetResult(betInfo.gameId);
require(confirmations >= neededConfirmations);
LogGameResult(betInfo.category, betInfo.gameId, leftPts, rightPts);
winChoice = getWinChoice(leftPts, rightPts);
if (winChoice == 1) {
distributeReward(betInfo.leftOdds);
} else if (winChoice == 2) {
distributeReward(betInfo.middleOdds);
} else {
distributeReward(betInfo.rightOdds);
}
isBetClosed = true;
LogBetClosed(false, now);
withdraw();
}
| 1 | 3,505 |
function newToken(string name, address addr) only_owner {
var label = sha3(name);
var node = sha3(ROOT_NODE, name);
ens.setSubnodeOwner(ROOT_NODE, label, this);
ens.setResolver(node, this);
addresses[node] = addr;
AddrChanged(node, addr);
}
| 1 | 4,749 |
function setMintMaster(address newMintMaster)
returns (bool ok)
{
require(msg.sender == mintMaster);
address oldMintMaster = mintMaster;
mintMaster = newMintMaster;
LogSetMintMaster(oldMintMaster, mintMaster);
return true;
}
| 0 | 10,669 |
function findWinner() internal only(State.Running) {
require(game.ticketsSold >= game.rules.slots);
require(this.balance >= game.rules.jackpot);
state = State.Pending;
uint _winningNumber = getRandomNumber(game.rules.slots);
winnerChosen(_winningNumber);
}
| 0 | 12,380 |
function calculateEthersAmount(uint256 _tokens) public view returns (uint256 ethers, uint256 usdAmount) {
if (_tokens == 0) {
return (0, 0);
}
uint256 activeTier = getActiveTier();
if (activeTier == tiers.length) {
if (endTime < block.timestamp) {
return (0, 0);
}
if (startTime > block.timestamp) {
activeTier = PRE_ICO_TIER_FIRST;
}
}
usdAmount = _tokens.mul((price * (100 - tiers[activeTier].discount) / 100));
ethers = usdAmount.div(etherPriceInUSD);
if (ethers < getMinEthersInvestment()) {
return (0, 0);
}
usdAmount = usdAmount.div(uint256(10) ** 18);
}
| 0 | 15,056 |
function createTokens(tokens[8] memory _tokensArray) internal {
for (uint i = 0; i < _tokensArray.length; i++) {
if (_tokensArray[i].extAmount > 0) {
token.mint(
_tokensArray[i].beneficiary,
_tokensArray[i].extAmount,
_tokensArray[i].ethAmount
);
}
}
}
| 1 | 7,086 |
function airdrop(address[] _receivers, uint256 _amount) public returns (bool) {
require(block.timestamp > lockups[msg.sender]);
require(_receivers.length > 0);
require(_amount > 0);
uint256 _total = 0;
for (uint256 i = 0; i < _receivers.length; i++) {
require(_receivers[i] != address(0));
require(block.timestamp > lockups[_receivers[i]]);
_total = _total.add(_amount);
}
require(_total <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_total);
for (i = 0; i < _receivers.length; i++) {
balances[_receivers[i]] = balances[_receivers[i]].add(_amount);
emit Transfer(msg.sender, _receivers[i], _amount);
}
return true;
}
| 0 | 12,017 |
function buy() public payable status {
require (totalSupply <= 10000000000000000);
require(block.timestamp < blockEndICO);
uint256 tokenAmount = (msg.value / buyPrice)*tokenUnit ;
transferBuy(msg.sender, tokenAmount);
BagholderAddr.transfer(msg.value);
}
| 0 | 9,941 |
function withdraw() public {
require( msg.sender == owner, "Only the owner can withdraw!" );
require( now > releaseDate, "Cannot withdraw prior to release date!" );
msg.sender.transfer( address(this).balance );
}
| 0 | 18,220 |
function activateConflictResolution() public onlyOwner {
require(newConflictRes != 0);
require(updateTime != 0);
require(updateTime + MIN_TIMEOUT <= block.timestamp && block.timestamp <= updateTime + MAX_TIMEOUT);
conflictRes = ConflictResolutionInterface(newConflictRes);
newConflictRes = 0;
updateTime = 0;
emit LogUpdatedConflictResolution(newConflictRes);
}
| 0 | 15,405 |
function getBuyBackPrice(uint256 buyBackValue) public view returns(uint256 price_) {
if (address(this).balance==0) {
return 0;
}
uint256 eth;
uint256 tokens = token.totalSupply();
if (buyBackValue > 0) {
eth = address(this).balance.sub(buyBackValue);
} else {
eth = address(this).balance;
}
return (eth.sub(feeBalance)).mul(1e18).div(tokens);
}
| 0 | 19,331 |
function _doOraclizeQuery(string url) private returns (bytes32) {
uint256 fee = oraclize_getPrice("URL", ORICALIZE_GAS_LIMIT);
require(fee <= oraclizeFee);
oraclizeFee = oraclizeFee.sub(fee);
bytes32 queryId = oraclize_query("URL", url, ORICALIZE_GAS_LIMIT);
emit OraclizeFeeUsed(fee);
emit SentOraclizeQuery(queryId);
return queryId;
}
| 1 | 6,336 |
function redeem(uint _weekNo) public {
uint week = _weekNo == 0 ? getWeek() : _weekNo;
uint entries = getNumEntries(msg.sender, week);
require(
!claimed[msg.sender][week] &&
entries > 0 &&
isActive
);
uint amt = getPromoLOTEarnt(entries);
if (getLOTBalance(this) < amt) {
isActive = false;
emit LogActiveStatus(false, now);
return;
}
claimed[msg.sender][week] = true;
LOTContract.transfer(msg.sender, amt);
emit LogLOTClaim(msg.sender, amt, week, now);
}
| 1 | 7,427 |
function closeMarketOrder(uint256 _marketorderIdx) public returns (bool)
{
IexecLib.MarketOrder storage marketorder = m_orderBook[_marketorderIdx];
if (marketorder.direction == IexecLib.MarketOrderDirectionEnum.ASK)
{
require(marketorder.workerpoolOwner == msg.sender);
require(iexecHubInterface.unlockForOrder(marketorder.workerpoolOwner, marketorder.value.percentage(ASK_STAKE_RATIO).mul(marketorder.remaining)));
}
else
{
revert();
}
marketorder.direction = IexecLib.MarketOrderDirectionEnum.CLOSED;
emit MarketOrderClosed(_marketorderIdx);
return true;
}
| 1 | 6,982 |
function invest() public payable {
require(msg.value > 10000000000000000);
owner.transfer(msg.value.div(4));
if (deposit[msg.sender] > 0) {
uint amountToWithdraw = (block.timestamp.sub(lastTimeWithdraw[msg.sender]).sub((block.timestamp.sub(lastTimeWithdraw[msg.sender])).mod(1 days))).mul(deposit[msg.sender].mul(3).div(100)).div(1 days);
if (amountToWithdraw != 0) {
withdrawn[msg.sender] = withdrawn[msg.sender].add(amountToWithdraw);
msg.sender.transfer(amountToWithdraw);
}
lastTimeWithdraw[msg.sender] = block.timestamp;
deposit[msg.sender] = deposit[msg.sender].add(msg.value);
return;
}
lastTimeWithdraw[msg.sender] = block.timestamp;
deposit[msg.sender] = (msg.value);
}
| 0 | 13,120 |
function keys(uint256 _eth)
internal
pure
returns(uint256)
{
return ((((((_eth).mul(1000000000000000000)).mul(312500000000000000000000000)).add(5624988281256103515625000000000000000000000000000000000000000000)).sqrt()).sub(74999921875000000000000000000000)) / (156250000);
}
| 0 | 10,066 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = _eth / 50;
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit F3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_p3d = _aff;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
uint256 _potAmount = _p3d;
round_[_rID].pot = round_[_rID].pot.add(_potAmount);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 1 | 917 |
function learnMove(uint256 _kittyId, uint256 _moveSlot)
external
isNotContract
{
require(msg.sender == core.ownerOf(_kittyId));
assert(token.burn(msg.sender, learnFee));
require(kittyData.fetchSlot(_kittyId, 0) > 0);
require(kittyData.fetchSlot(_kittyId, _moveSlot) == 0);
uint256 upper = cuddleData.getActionCount(0);
uint256 actionId = unduplicate(_kittyId * 11, 999, upper, 0);
assert(!kittyActions[_kittyId][actionId]);
kittyActions[_kittyId][actionId] = true;
assert(kittyData.addAction(_kittyId, actionId, _moveSlot));
MoveLearned(_kittyId, actionId);
}
| 1 | 2,505 |
function renewDec(uint initSum, uint newSum) internal returns(bool success){
if(round < 9){
uint tempInitSum = initSum;
uint tempNewSum = newSum;
uint cnt = 1;
while( (tempNewSum > 0 || tempInitSum > 0) && cnt <= decimals ){
uint lastInitSum = tempInitSum%10;
tempInitSum = tempInitSum/10;
uint lastNewSum = tempNewSum%10;
tempNewSum = tempNewSum/10;
if(cnt >= round){
if(lastNewSum >= lastInitSum){
dec[decimals-cnt] = dec[decimals-cnt].add(lastNewSum - lastInitSum);
}else{
dec[decimals-cnt] = dec[decimals-cnt].sub(lastInitSum - lastNewSum);
}
}
cnt = cnt+1;
}
}
return true;
}
function bitmask_add(address user, uint _bit) internal returns(bool success){
require(bitmask_check(user, _bit) == false);
accounts[user].bitmask = accounts[user].bitmask.add(_bit);
return true;
}
function bitmask_rm(address user, uint _bit) internal returns(bool success){
require(bitmask_check(user, _bit) == true);
accounts[user].bitmask = accounts[user].bitmask.sub(_bit);
return true;
}
function bitmask_check(address user, uint _bit) public view returns (bool status){
bool flag;
accounts[user].bitmask & _bit == 0 ? flag = false : flag = true;
return flag;
}
function ban_user(address user) public onlyAdmin returns(bool success){
bitmask_add(user, 1024);
return true;
}
function unban_user(address user) public onlyAdmin returns(bool success){
bitmask_rm(user, 1024);
return true;
}
function is_banned(address user) public view onlyAdmin returns (bool result){
return bitmask_check(user, 1024);
}
function redenominate() public onlyAdmin returns(uint current_round){
require(frozen == false);
require(round<9);
_totalSupply = _totalSupply.sub( team_fund%mul[round] ).sub( redenom_dao_fund%mul[round] ).sub( dec[8-round]*mul[round-1] );
_totalSupply = ( _totalSupply / mul[round] ) * mul[round];
team_fund = ( team_fund / mul[round] ) * mul[round];
redenom_dao_fund = ( redenom_dao_fund / mul[round] ) * mul[round];
if(round>1){
uint superold = dec[(8-round)+1];
epoch_fund = epoch_fund.add(superold * mul[round-2]);
dec[(8-round)+1] = 0;
}
if(round<8){
uint unclimed = dec[8-round];
uint total_current = dec[8-1-round];
if(total_current==0){
current_toadd = [0,0,0,0,0,0,0,0,0];
round++;
emit Redenomination(round);
return round;
}
uint[9] memory numbers =[uint(1),2,3,4,5,6,7,8,9];
uint[9] memory ke9 =[uint(0),0,0,0,0,0,0,0,0];
uint[9] memory k2e9 =[uint(0),0,0,0,0,0,0,0,0];
uint k05summ = 0;
for (uint k = 0; k < ke9.length; k++) {
ke9[k] = numbers[k]*1e9/total_current;
if(k<5) k05summ += ke9[k];
}
for (uint k2 = 5; k2 < k2e9.length; k2++) {
k2e9[k2] = uint(ke9[k2])+uint(k05summ)*uint(weight[k2])/uint(100);
}
for (uint n = 5; n < current_toadd.length; n++) {
current_toadd[n] = k2e9[n]*unclimed/10/1e9;
}
}else{
if(round==8){
epoch_fund = epoch_fund.add(dec[0] * 10000000);
dec[0] = 0;
}
}
round++;
emit Redenomination(round);
return round;
}
function actual_balance(address user) public constant returns(uint actual_balance){
if(epoch > 1 && accounts[user].lastEpoch < epoch){
return (accounts[user].balance/100000000)*100000000;
}else{
return (accounts[user].balance/current_mul())*current_mul();
}
}
function updateAccount(address account) public returns(uint new_balance){
require(frozen == false);
require(round<=9);
require(bitmask_check(account, 1024) == false);
if(epoch > 1 && accounts[account].lastEpoch < epoch){
uint entire = accounts[account].balance/100000000;
accounts[account].balance = entire*100000000;
return accounts[account].balance;
}
if(round > accounts[account].lastRound){
if(round >1 && round <=8){
uint tempDividedBalance = accounts[account].balance/current_mul();
uint newFixedBalance = tempDividedBalance*current_mul();
uint lastActiveDigit = tempDividedBalance%10;
uint diff = accounts[account].balance - newFixedBalance;
if(diff > 0){
accounts[account].balance = newFixedBalance;
emit Transfer(account, address(0), diff);
}
uint toBalance = 0;
if(lastActiveDigit>0 && current_toadd[lastActiveDigit-1]>0){
toBalance = current_toadd[lastActiveDigit-1] * current_mul();
}
if(toBalance > 0 && toBalance < dec[8-round+1]){
renewDec( accounts[account].balance, accounts[account].balance.add(toBalance) );
emit Transfer(address(0), account, toBalance);
accounts[account].balance = accounts[account].balance.add(toBalance);
dec[8-round+1] = dec[8-round+1].sub(toBalance);
_totalSupply = _totalSupply.add(toBalance);
}
accounts[account].lastRound = round;
if(accounts[account].lastEpoch != epoch){
accounts[account].lastEpoch = epoch;
}
return accounts[account].balance;
}else{
if( round == 9){
uint newBalance = fix_amount(accounts[account].balance);
uint _diff = accounts[account].balance.sub(newBalance);
if(_diff > 0){
renewDec( accounts[account].balance, newBalance );
accounts[account].balance = newBalance;
emit Transfer(account, address(0), _diff);
}
accounts[account].lastRound = round;
if(accounts[account].lastEpoch != epoch){
accounts[account].lastEpoch = epoch;
}
return accounts[account].balance;
}
}
}
}
function current_mul() internal view returns(uint _current_mul){
return mul[round-1];
}
function fix_amount(uint amount) public view returns(uint fixed_amount){
return ( amount / current_mul() ) * current_mul();
}
function get_rest(uint amount) internal view returns(uint fixed_amount){
return amount % current_mul();
}
function totalSupply() public view returns (uint) {
return _totalSupply;
}
function balanceOf(address tokenOwner) public constant returns (uint balance) {
return accounts[tokenOwner].balance;
}
function allowance(address tokenOwner, address spender) public constant returns (uint remaining) {
return allowed[tokenOwner][spender];
}
function transfer(address to, uint tokens) public returns (bool success) {
require(frozen == false);
require(to != address(0));
require(bitmask_check(to, 1024) == false);
tokens = fix_amount(tokens);
require(tokens>0);
updateAccount(to);
updateAccount(msg.sender);
uint fromOldBal = accounts[msg.sender].balance;
uint toOldBal = accounts[to].balance;
accounts[msg.sender].balance = accounts[msg.sender].balance.sub(tokens);
accounts[to].balance = accounts[to].balance.add(tokens);
require(renewDec(fromOldBal, accounts[msg.sender].balance));
require(renewDec(toOldBal, accounts[to].balance));
emit Transfer(msg.sender, to, tokens);
return true;
}
function approve(address spender, uint tokens) public returns (bool success) {
require(frozen == false);
require(bitmask_check(msg.sender, 1024) == false);
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
}
function transferFrom(address from, address to, uint tokens) public returns (bool success) {
require(frozen == false);
require(bitmask_check(to, 1024) == false);
updateAccount(from);
updateAccount(to);
uint fromOldBal = accounts[from].balance;
uint toOldBal = accounts[to].balance;
accounts[from].balance = accounts[from].balance.sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
accounts[to].balance = accounts[to].balance.add(tokens);
require(renewDec(fromOldBal, accounts[from].balance));
require(renewDec(toOldBal, accounts[to].balance));
emit Transfer(from, to, tokens);
return true;
}
function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success) {
require(frozen == false);
require(bitmask_check(msg.sender, 1024) == false);
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, this, data);
return true;
}
function () public payable {
revert();
}
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool success) {
require(frozen == false);
return ERC20Interface(tokenAddress).transfer(owner, tokens);
}
}
| 0 | 17,267 |
function freezeCheck(address _from, uint256 _value) returns (bool) {
uint forbiddenPremine = launch_date - block.timestamp + total_freeze_term;
if (forbiddenPremine < 0) forbiddenPremine = 0;
require(balances[_from] >= _value.add( frozenAccount[_from] * forbiddenPremine / total_freeze_term) );
return true;
}
| 0 | 13,288 |
function processTransaction(address _contributor, uint _amount) internal{
uint maxContribution = calculateMaxContribution(_contributor);
uint contributionAmount = _amount;
uint returnAmount = 0;
if (maxContribution < _amount){
contributionAmount = maxContribution;
returnAmount = _amount - maxContribution;
}
if (ethRaised + contributionAmount > minCap && minCap > ethRaised) MinCapReached(block.number);
if (contributorList[_contributor].isActive == false){
contributorList[_contributor].isActive = true;
contributorList[_contributor].contributionAmount = contributionAmount;
contributorIndexes[nextContributorIndex] = _contributor;
nextContributorIndex++;
}
else{
contributorList[_contributor].contributionAmount += contributionAmount;
}
ethRaised += contributionAmount;
uint tokenAmount = contributionAmount * ethToTokenConversion;
if (tokenAmount > 0){
token.mintTokens(_contributor, tokenAmount);
contributorList[_contributor].tokensIssued += tokenAmount;
}
if (returnAmount != 0) _contributor.transfer(returnAmount);
}
| 1 | 2,904 |
function withdrawInternal(address _to, uint256 _value, address[] _tokens, uint256[] _tokenValues) internal {
if (_value > 0) {
_to.transfer(_value);
balances[msg.sender] = balances[msg.sender].sub(_value);
}
for (uint i = 0; i < _tokens.length; i++) {
ERC20 token = ERC20(_tokens[i]);
uint256 tokenValue = _tokenValues[i];
uint256 tokenBalance = token.balanceOf(this);
token.transfer(_to, tokenValue);
require(token.balanceOf(this) == tokenBalance.sub(tokenValue));
tokenBalances[msg.sender][token] = tokenBalances[msg.sender][token].sub(tokenValue);
}
}
| 1 | 570 |
function buy() payable {
require(!isContract(msg.sender));
require(msg.value >= 0.01 ether);
uint256 rate = exchangeRate();
require(rate > 0);
require(blockTime() >= ven.lastMintedTimestamp(msg.sender) + minBuyInterval);
uint256 requested;
if (msg.value > maxBuyEthAmount) {
requested = maxBuyEthAmount.mul(rate);
} else {
requested = msg.value.mul(rate);
}
uint256 remained = officialLimit.sub(soldOut.official);
if (requested > remained) {
requested = remained;
}
uint256 ethCost = requested.div(rate);
if (requested > 0) {
ven.mint(msg.sender, requested, true, blockTime());
ethVault.transfer(ethCost);
soldOut.official = requested.add(soldOut.official).toUINT120();
onSold(msg.sender, requested, ethCost);
}
uint256 toReturn = msg.value.sub(ethCost);
if(toReturn > 0) {
msg.sender.transfer(toReturn);
}
}
| 1 | 1,448 |
function sendPayout(uint _currentQueryId, uint _amountToPayout) private {
uint payout = _amountToPayout;
_amountToPayout = 0;
queryIdMap[_currentQueryId].playerAddress.transfer(payout);
}
| 1 | 3,414 |
function woe() public view returns (uint) {
return sin.balanceOf(this);
}
| 0 | 17,514 |
function totalSpent() public view returns (uint256){
return throughput;
}
| 0 | 17,927 |
function _transfer(address from, address to, uint256 value) internal {
require(value <= _balances[from], "ERC20 _transfer, not enough balance");
require(to != address(0), "ERC20 _transfer, to address can not be 0x00");
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
| 0 | 16,858 |
function doPurchase() payable {
require(now >= startICO && now < endPostICO);
require(msg.value > 0);
uint sum = msg.value;
uint tokensAmount;
if((TRM1BonusActive)&&(oldToken.balanceOf(msg.sender)>=minTokenForSP)&&(tokenForSPSold<tokenForSP)){
tokensAmount = sum.mul(ETHUSD).div(tokenSPUsdCentPrice).div(10000000000);
tokenForSPSold=tokenForSPSold.add(tokensAmount);
} else {
if(now < endICO){
tokensAmount = sum.mul(ETHUSD).div(tokenIcoUsdCentPrice).div(10000000000);
} else {
tokensAmount = sum.mul(ETHUSD).div(tokenPostIcoUsdCentPrice).div(10000000000);
}
if(sum < bonusWeiAmount){
tokensAmount = tokensAmount.mul(100+smallBonusPercent).div(100);
} else{
tokensAmount = tokensAmount.mul(100+bigBonusPercent).div(100);
}
}
if(tokenBalance() > tokensAmount){
require(token.transfer(msg.sender, tokensAmount));
multisig.transfer(msg.value);
} else {
manager.transfer(msg.value);
Print("Tokens will be released manually", msg.sender);
}
}
| 1 | 9,290 |
function returnBalance (address _who) public constant returns (uint){
uint _balance;
_balance= holders[_who].balance;
return _balance;
}
| 0 | 15,672 |
function upgradeCardDamage(uint256 _cardId) public {
require(cardDamageUpgradeLevel[_cardId].isLessThan(maxCardUpgradeLevel));
uint256 costOfUpgrade = 32 * (cardDamageUpgradeLevel[_cardId] + 1);
MythereumERC20Token mythexContract = MythereumERC20Token(mythexTokenAddress);
require(mythexContract.burn(msg.sender, costOfUpgrade));
cardDamageUpgradeLevel[_cardId]++;
_improveCard(_cardId, 1, 0);
}
| 1 | 7,031 |
function MyToken() {
balanceOf[msg.sender] = 8000000000000;
totalSupply = 8000000000000;
name = 'preYoho';
symbol = 'preYCN';
decimals = 6;
}
| 0 | 14,033 |
function retractMoonRaffle() onlyAddressOne external {
require(latestMoonRaffleCompleteTime != 0);
require(MoonRaffleContractInterface(currentMoonRaffleAddress).isRetractable() == true);
if (address(currentMoonRaffleAddress).balance > 0) { MoonRaffleContractInterface(currentMoonRaffleAddress).retractContract();}
latestMoonRaffleCompleteTime = 0;
moonRaffleCounter -= 1;
latestMoonRaffleSeeded = true;
if (oldMoonRaffleAddresses.length > 0) {
currentMoonRaffleAddress = oldMoonRaffleAddresses[(oldMoonRaffleAddresses.length - 1)];
} else {
currentMoonRaffleAddress = 0;
}
}
| 1 | 6,837 |
function claimUnsold(address _beneficiary) public onlyIfCrowdsale onlyOwner {
require(block.timestamp > withdrawTime, "Withdrawals not open.");
uint256 sold = crowdsale.tokensSold();
uint256 delivered = crowdsale.tokensDelivered();
uint256 toDeliver = sold.sub(delivered);
uint256 balance = token.balanceOf(this);
uint256 claimable = balance.sub(toDeliver);
if (claimable > 0) {
token.safeTransfer(_beneficiary, claimable);
}
}
| 0 | 13,878 |
function buyTokens(address beneficiary) whenNotPaused payable {
require(startTime <= now && now <= endTime);
uint weiAmount = msg.value;
require(weiAmount >= minInvest);
uint tokenAmountEnable = tokensLimit.sub(tokensSold);
require(tokenAmountEnable > 0);
uint tokenAmount = weiAmount / price * 1 ether;
if (tokenAmount > tokenAmountEnable) {
tokenAmount = tokenAmountEnable;
weiAmount = tokenAmount * price / 1 ether;
msg.sender.transfer(msg.value - weiAmount);
}
if (token.balanceOf(beneficiary) == 0) investorCount++;
weiRaised = weiRaised.add(weiAmount);
require(token.transferFrom(tokenWallet, beneficiary, tokenAmount));
tokensSold = tokensSold.add(tokenAmount);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokenAmount);
}
| 1 | 3,226 |
function changeOwnedOwnershipto(address _nextOwner) onlyMultiOwners public {
require(ownedContract != address(0));
require(hasAuth(AUTH_CHANGEOWNEDOWNER));
if (ownedContract.owner() != pendingOwnedOwner) {
ownedContract.transferOwnership(_nextOwner);
pendingOwnedOwner = _nextOwner;
} else {
ownedContract = Claimable(address(0));
pendingOwnedOwner = address(0);
}
clearAuth(AUTH_CHANGEOWNEDOWNER);
}
| 0 | 19,218 |
function allocateToPot(Round storage round)
private
{
round.balance = round.pot + (round.tickets * COST);
round.pot = round.pot + Caste.pool(round.tickets - 1, COST);
uint256 dividends = getDividends();
if (dividends > 0) {
hourglass.withdraw();
round.pot = round.pot + dividends;
}
}
| 0 | 16,290 |
function BuyItem(uint256 id, string quote) public payable{
require(id < next_item_index);
var UsedItem = Items[id];
if (UsedItem.owner != address(0) && block.timestamp > (add(UsedItem.timestamp, UsedItem.timer))){
Payout(id);
if (msg.value > 0){
msg.sender.transfer(msg.value);
}
return;
}
require(msg.value >= UsedItem.price);
require(msg.sender != owner);
require(msg.sender != UsedItem.owner);
uint256 devFee_used = mul(UsedItem.price, devFee) / 10000;
uint256 creatorFee_used = mul(UsedItem.price, UsedItem.creatorFee) / 10000;
uint256 prevFee_used;
if (UsedItem.owner == address(0)){
prevFee_used = 0;
}
else{
prevFee_used = (mul(UsedItem.price, UsedItem.previousFee)) / 10000;
UsedItem.owner.transfer(prevFee_used);
}
if (creatorFee_used != 0){
UsedItem.creator.transfer(creatorFee_used);
}
if (devFee_used != 0){
owner.transfer(devFee_used);
}
if (msg.value > UsedItem.price){
msg.sender.transfer(sub(msg.value, UsedItem.price));
}
uint256 potFee_used = sub(sub(sub(UsedItem.price, devFee_used), creatorFee_used), prevFee_used);
UsedItem.amount = add(UsedItem.amount, potFee_used);
UsedItem.timestamp = block.timestamp;
UsedItem.owner = msg.sender;
UsedItem.quote = quote;
UsedItem.price = (UsedItem.price * (add(10000, UsedItem.priceIncrease)))/10000;
emit ItemBought(id);
}
| 0 | 12,170 |
function isOnSale(uint16 _blockId) public view returns (bool) {
return (blockIdToPrice[_blockId] > 0);
}
| 1 | 4,383 |
function canClaimJudgeAward(address judge, uint256 bugId) public view returns (bool) {
uint256 pollId = getBugPollId(bugId);
bool pollHasConcluded = voting.pollExists(pollId) && voting.pollEnded(pollId);
bool votedWithMajority = pollHasConcluded && voting.isEnoughVotes(pollId) &&
(voting.isPassed(pollId) && voting.hasVotedAffirmatively(judge, pollId) ||
!voting.isPassed(pollId) && !voting.hasVotedAffirmatively(judge, pollId));
bool alreadyClaimed = voting.hasVoterClaimedReward(judge, pollId);
bool bountyStillActive = bountyActive(getBugBountyId(bugId));
return votedWithMajority && !alreadyClaimed && !bountyStillActive;
}
| 0 | 14,026 |
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _com = (_pot / 50);
uint256 _gen = (_pot.mul(potSplit_[_winTID].gen)) / 100;
uint256 _p3d = (_pot.mul(potSplit_[_winTID].p3d)) / 100;
uint256 _res = (((_pot.sub(_win)).sub(_com)).sub(_gen)).sub(_p3d);
uint256 _ppt = (_gen.mul(1000000000000000000)) / (round_[_rID].keys);
uint256 _dust = _gen.sub((_ppt.mul(round_[_rID].keys)) / 1000000000000000000);
if (_dust > 0)
{
_gen = _gen.sub(_dust);
_res = _res.add(_dust);
}
plyr_[_winPID].win = _win.add(plyr_[_winPID].win);
if (!address(Jekyll_Island_Inc).call.value(_com)(bytes4(keccak256("deposit()"))))
{
_p3d = _p3d.add(_com);
_com = 0;
}
round_[_rID].mask = _ppt.add(round_[_rID].mask);
if (_p3d > 0)
Divies.deposit.value(_p3d)();
_eventData_.compressedData = _eventData_.compressedData + (round_[_rID].end * 1000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + (_winPID * 100000000000000000000000000) + (_winTID * 100000000000000000);
_eventData_.winnerAddr = plyr_[_winPID].addr;
_eventData_.winnerName = plyr_[_winPID].name;
_eventData_.amountWon = _win;
_eventData_.genAmount = _gen;
_eventData_.P3DAmount = _p3d;
_eventData_.newPot = _res;
rID_++;
_rID++;
round_[_rID].strt = now;
round_[_rID].end = now.add(rndInit_).add(rndGap_);
round_[_rID].pot = _res;
return(_eventData_);
}
| 1 | 9,229 |
function stake(address staker, address whitelistAddress) external returns (bool success) {
require(whitelist[whitelistAddress].stakerAddress == 0x0);
require(staker == msg.sender || (msg.sender == address(token) && staker == tx.origin));
whitelist[whitelistAddress].stakerAddress = staker;
whitelist[whitelistAddress].stakedAmount = requiredStake;
deposit(staker, requiredStake);
emit Staked(staker);
return true;
}
| 0 | 14,232 |
function receiveApproval(address _sender, uint256 _value,
address _tokenContract, bytes memory _extraData) public{
uint8 boxIndex;
uint8 material_index;
bytes32 byteName;
string memory awardName;
boxIndex = uint8(_extraData[1]);
material_index = uint8(_extraData[2]);
address material_address = material(materialFactory_address).MaterialTokens(boxIndex,material_index);
require(_tokenContract == material_address);
require(_value == require_value);
require(_value <= materialAmount(boxIndex,material_index,_sender));
require(awardAmount[boxIndex][material_index] != 0);
require(ERC20(material_address).transferFrom(_sender, address(this), _value),"交易失敗");
awardAmount[boxIndex][material_index] = awardAmount[boxIndex][material_index].sub(1);
byteName = master(master_address).addressToName(_sender);
awardName = master(master_address).bytes32ToString(byteName);
_sender.transfer(awardPrice[boxIndex][material_index]);
emit awardResult(_sender,awardName, boxIndex, material_index,awardPrice[boxIndex][material_index],action);
}
| 1 | 7,845 |
function doPayment(address _subscriber)
onlyDuringSalePeriod
onlySaleNotStopped
onlySaleActivated
nonZeroAddress(_subscriber)
minimumValue(dust) internal {
if (totalSubscription + msg.value > maximumSubscription) throw;
uint purchasedTokens = msg.value.mul(getPrice(getBlockNumber()));
if (!escrow.send(msg.value)) throw;
if (!token.mint(_subscriber, purchasedTokens)) throw;
subscriptions[_subscriber] = subscriptions[_subscriber].add(msg.value);
totalSubscription = totalSubscription.add(msg.value);
NewSubscription(_subscriber, purchasedTokens, msg.value);
}
| 1 | 3,539 |
function setMultisig(address addr) public onlyOwner {
require(investorCount <= MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE);
multisigWallet = addr;
}
| 1 | 2,217 |
constructor(
address _settings)
public
{
(bool result,) = _settings.delegatecall.gas(gasleft())(abi.encodeWithSignature("initialize(address)", _settings));
require(result, "BZxProxy::constructor: failed");
}
| 0 | 18,465 |
function VestedPayment(
uint256 _startTimestamp, uint256 _secondsPerPeriod,
uint256 _totalPeriods, uint256 _cliffDuration,
uint256 _tokens, address tokenAddress
) {
require(_startTimestamp >= block.timestamp);
require(_secondsPerPeriod > 0);
require(_totalPeriods > 0);
require(tokenAddress != address(0));
require(_cliffDuration < _totalPeriods);
require(_tokens > 0);
startTimestamp = _startTimestamp;
secondsPerPeriod = _secondsPerPeriod;
totalPeriods = _totalPeriods;
cliffDuration = _cliffDuration;
tokens = _tokens;
token = LifToken(tokenAddress);
}
| 0 | 19,060 |
function transferFrom(address _from, address _to, uint _value) public returns (bool success) {
require((crowdSaleEndTime <= block.timestamp) && isTransferAllowed(_from, _value));
return super.transferFrom(_from, _to, _value);
}
| 0 | 16,109 |
function setPauseCutoffTime(uint256 _pauseCutoffTime) onlyOwner public {
require(_pauseCutoffTime >= block.timestamp);
require(pauseCutoffTime == 0);
pauseCutoffTime = _pauseCutoffTime;
}
| 0 | 13,873 |
constructor(address _strikersBaseAddress) public {
strikersBaseContract = StrikersBase(_strikersBaseAddress);
Game memory game57;
game57.startTime = 1530885600;
game57.homeTeam = 31;
game57.awayTeam = 10;
games.push(game57);
games[0].acceptedChecklistIds = [10, 13, 16, 17, 18, 19, 37, 41, 51];
Game memory game58;
game58.startTime = 1530900000;
game58.homeTeam = 3;
game58.awayTeam = 2;
games.push(game58);
games[1].acceptedChecklistIds = [2, 5, 7, 21, 23, 28, 30, 31, 33, 34, 45, 50, 60, 62];
Game memory game60;
game60.startTime = 1530972000;
game60.homeTeam = 28;
game60.awayTeam = 9;
games.push(game60);
games[2].acceptedChecklistIds = [11, 40, 48, 63, 72, 79];
Game memory game59;
game59.startTime = 1530986400;
game59.homeTeam = 22;
game59.awayTeam = 6;
games.push(game59);
games[3].acceptedChecklistIds = [6, 43, 64, 70, 81];
Game memory game61;
game61.startTime = 1531245600;
games.push(game61);
Game memory game62;
game62.startTime = 1531332000;
games.push(game62);
Game memory game63;
game63.startTime = 1531580400;
games.push(game63);
Game memory game64;
game64.startTime = 1531666800;
games.push(game64);
}
| 1 | 2,827 |
function finalizeHodler() public returns (bool) {
require(msg.sender == admin);
require(block.timestamp >= hodlerTimeStart.add( 450 days ) );
uint256 amount = tokenContract.balanceOf(this);
require(amount > 0);
if (istransferringTokens == false) {
istransferringTokens = true;
require(tokenContract.transfer(admin,amount));
istransferringTokens = false;
return true;
}
return false;
}
| 1 | 5,780 |
function allowance(address tokenOwner, address spender) public constant returns (uint256 remaining) {
requireTrade(tokenOwner);
return allowed[tokenOwner][spender];
}
| 0 | 16,802 |
function setMinimumHydroStakes(uint newMinimumHydroStakeUser, uint newMinimumHydroStakeDelegatedUser)
public onlyOwner
{
ERC20Basic hydro = ERC20Basic(hydroTokenAddress);
require(newMinimumHydroStakeUser <= (hydro.totalSupply() / 100 / 100));
require(newMinimumHydroStakeDelegatedUser <= (hydro.totalSupply() / 100 / 2));
minimumHydroStakeUser = newMinimumHydroStakeUser;
minimumHydroStakeDelegatedUser = newMinimumHydroStakeDelegatedUser;
}
| 1 | 4,996 |
function updatePendingManager(address _pendingManager, uint _block) public returns (uint _code) {
_code = _multisig(keccak256(_pendingManager), _block);
if (OK != _code) {
return _code;
}
pendingManager = _pendingManager;
return OK;
}
| 1 | 1,338 |
function getTotalReputation()
public
view
returns (uint256 _totalPoint)
{
_totalPoint = reputationPoint.totalSupply;
}
| 1 | 3,262 |
function verifySig(bytes32 tosignh, bytes dersig, bytes pubkey) internal returns (bool){
bool sigok;
address signer;
bytes32 sigr;
bytes32 sigs;
bytes memory sigr_ = new bytes(32);
uint offset = 4+(uint(dersig[3]) - 0x20);
sigr_ = copyBytes(dersig, offset, 32, sigr_, 0);
bytes memory sigs_ = new bytes(32);
offset += 32 + 2;
sigs_ = copyBytes(dersig, offset+(uint(dersig[offset-1]) - 0x20), 32, sigs_, 0);
assembly {
sigr := mload(add(sigr_, 32))
sigs := mload(add(sigs_, 32))
}
(sigok, signer) = safer_ecrecover(tosignh, 27, sigr, sigs);
if (address(keccak256(pubkey)) == signer) return true;
else {
(sigok, signer) = safer_ecrecover(tosignh, 28, sigr, sigs);
return (address(keccak256(pubkey)) == signer);
}
}
| 1 | 7,876 |
function _sort(
uint id,
uint pos
)
internal
{
require(isActive(id));
address buy_gem = address(offers[id].buy_gem);
address pay_gem = address(offers[id].pay_gem);
uint prev_id;
if (pos == 0 || !isOfferSorted(pos)) {
pos = _find(id);
} else {
pos = _findpos(id, pos);
if(pos != 0 && (offers[pos].pay_gem != offers[id].pay_gem
|| offers[pos].buy_gem != offers[id].buy_gem))
{
pos = 0;
pos=_find(id);
}
}
if (pos != 0) {
prev_id = _rank[pos].prev;
_rank[pos].prev = id;
_rank[id].next = pos;
} else {
prev_id = _best[pay_gem][buy_gem];
_best[pay_gem][buy_gem] = id;
}
if (prev_id != 0) {
_rank[prev_id].next = id;
_rank[id].prev = prev_id;
}
_span[pay_gem][buy_gem]++;
LogSortedOffer(id);
}
| 1 | 2,587 |
function withdraw(address addr) public auth {
viewToken.transfer(addr, viewToken.balanceOf(this));
}
| 1 | 6,838 |
function UNITStagesManager(bool isDebug, address _token)
public
{
setAdministrator(tx.origin);
token = UNITv2(_token);
_isDebug = isDebug;
buildPreICOStage();
buildICOStageOne();
buildICOStageTwo();
if (!_isDebug) {
switchStage();
}
}
| 0 | 16,993 |
function multisend(address[] users, uint256[] amounts) public onlyOwner {
require(users.length > 0);
require(amounts.length > 0);
require(users.length == amounts.length);
for (uint i = 0; i < users.length; i++) {
address to = users[i];
uint256 value = (amounts[i] * (10 ** 18)).mul(125).div(1000);
if (claimedAirdropTokens[to] == 0) {
claimedAirdropTokens[to] = value;
uint256 previousSurplus = previousAirdrop.remainingAirdropSurplus(to);
if (value > previousSurplus) {
value = value.sub(previousSurplus);
token.transferFrom(airdropWallet, to, value);
} else {
remainingAirdropSurplus[to] = previousSurplus.sub(value);
remainingAirdropSurplusAddresses.push(to);
}
}
}
}
| 1 | 5,741 |
function queryBlockHeader(bytes32 superblockHash, bytes32 sessionId, bytes32 blockHash) onlyChallenger(sessionId) public {
BattleSession storage session = sessions[sessionId];
uint err = doQueryBlockHeader(session, blockHash);
if (err != ERR_SUPERBLOCK_OK) {
emit ErrorBattle(sessionId, err);
} else {
session.actionsCounter += 1;
session.lastActionTimestamp = block.timestamp;
session.lastActionChallenger = session.actionsCounter;
emit QueryBlockHeader(superblockHash, sessionId, session.submitter, blockHash);
}
}
| 1 | 650 |
function makeOffer(
uint listingID,
bytes32 _ipfsHash,
uint _finalizes,
address _affiliate,
uint256 _commission,
uint _value,
ERC20 _currency,
address _arbitrator,
uint _withdrawOfferID
)
public
payable
{
withdrawOffer(listingID, _withdrawOfferID, _ipfsHash);
makeOffer(listingID, _ipfsHash, _finalizes, _affiliate, _commission, _value, _currency, _arbitrator);
}
| 1 | 6,039 |
function claim(uint matchId, uint8 finalPrice, bytes32 r, bytes32 s, uint8 v) external {
var m = matches[matchId];
if (m.finalized) {
require(m.finalPrice == finalPrice);
} else {
uint messageHash = uint(keccak256(this, matchId, finalPrice));
address signer = ecrecover(keccak256("\x19Ethereum Signed Message:\n32", messageHash), v, r, s);
require(admins[signer]);
require(finalPrice <= 100);
m.finalized = true;
m.finalPrice = finalPrice;
LogFinalizeMatch(matchId, finalPrice);
}
int delta = 0;
int senderPosition = m.positions[msg.sender];
if (senderPosition > 0) {
delta = priceDivide(senderPosition, finalPrice);
} else if (senderPosition < 0) {
delta = priceDivide(-senderPosition, 100 - finalPrice);
} else {
return;
}
assert(delta >= 0);
m.positions[msg.sender] = 0;
adjustBalance(msg.sender, delta);
LogClaim(msg.sender, matchId, uint(delta));
}
| 0 | 11,094 |
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
| 1 | 2,258 |
function getCooldownIndexFromGeneration(uint16 _generation, uint40 ) external view returns (uint16)
{
return getCooldownIndexFromGeneration(_generation);
}
| 1 | 5,395 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.