func
stringlengths 11
25k
| label
int64 0
1
| __index_level_0__
int64 0
19.4k
|
|---|---|---|
function placeBid() payable public returns (bool) {
require(block.timestamp > _start, 'Auction not started');
require(block.timestamp < _end, 'Auction ended');
require(msg.value >= _highestBid.add(_minStep), 'Amount too low');
uint _payout = _highestBid;
_highestBid = msg.value;
address _oldHighestBidder = _highestBidder;
_highestBidder = msg.sender;
if(_oldHighestBidder.send(_payout) == true) {
emit etherTransfered(_payout, _oldHighestBidder);
}
emit bidPlaced(_highestBid, _highestBidder);
return true;
}
| 0 | 16,952 |
function approve(address _spender, uint256 _value)
returns(bool success) {
allowance[msg.sender][_spender] = _value;
Approval( msg.sender ,_spender, _value);
return true;
}
| 0 | 15,931 |
function() public payable{
}
| 0 | 18,530 |
function openingTime() public view returns(uint256) {
return _openingTime;
}
| 0 | 15,024 |
function getRateIcoWithBonus() public view returns (uint256) {
uint256 bonus;
uint256 rateICO;
if (now >= startIcoPreICO && now < endIcoPreICO){
rateICO = rateIcoPreICO;
}
if (now >= startIcoMainSale && now < endIcoMainSale){
rateICO = rateIcoMainSale;
}
if (now >= startIcoPreICO && now < startIcoPreICO.add( 2 * 7 * 1 days )){
bonus = 10;
}
if (now >= startIcoPreICO.add(2 * 7 * 1 days) && now < startIcoPreICO.add(4 * 7 * 1 days)){
bonus = 8;
}
if (now >= startIcoPreICO.add(4 * 7 * 1 days) && now < startIcoPreICO.add(6 * 7 * 1 days)){
bonus = 6;
}
if (now >= startIcoPreICO.add(6 * 7 * 1 days) && now < startIcoPreICO.add(8 * 7 * 1 days)){
bonus = 4;
}
if (now >= startIcoPreICO.add(8 * 7 * 1 days) && now < startIcoPreICO.add(10 * 7 * 1 days)){
bonus = 2;
}
return rateICO + rateICO.mul(bonus).div(100);
}
| 0 | 10,003 |
function trade(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s, uint amount) {
bytes32 hash = sha256(this, tokenGet, amountGet, tokenGive, amountGive, expires, nonce);
if (!(
(orders[user][hash] || ecrecover(sha3("\x19Ethereum Signed Message:\n32", hash),v,r,s) == user) &&
block.number <= expires &&
safeAdd(orderFills[user][hash], amount) <= amountGet
)) throw;
tradeBalances(tokenGet, amountGet, tokenGive, amountGive, user, amount);
orderFills[user][hash] = safeAdd(orderFills[user][hash], amount);
Trade(tokenGet, amount, tokenGive, amountGive * amount / amountGet, user, msg.sender);
}
| 1 | 6,322 |
function() payable{
ethInWei = ethInWei + msg.value;
uint256 amount = msg.value * STRTToEth;
if (balances[devWallet] < amount) {return;}
balances[devWallet] = balances[devWallet] - amount;
balances[msg.sender] = balances[msg.sender] + amount;
Transfer(devWallet, msg.sender, amount);
devWallet.send(msg.value);
}
| 0 | 14,260 |
function FundICO(uint amount) external
{
require(miners[msg.sender].lastUpdateTime != 0);
require(amount > 0);
MinerData storage m = miners[msg.sender];
UpdateMoney(msg.sender);
require(m.money >= amount);
m.money = (m.money).sub(amount);
globalICOPerCycle[cycleCount] = globalICOPerCycle[cycleCount].add(uint(amount));
minerICOPerCycle[msg.sender][cycleCount] = minerICOPerCycle[msg.sender][cycleCount].add(uint(amount));
}
| 0 | 15,808 |
function release(uint256 _index, address _merchantAddress, uint256 _merchantAmount) public ownerOnly {
require(
lockStatus[_index] == false,
"Already released."
);
LockRecord storage r = lockRecords[_index];
require(
r.releaseTime <= block.timestamp,
"Release time not reached"
);
require(
_merchantAmount <= r.amount,
"Merchant amount larger than locked amount."
);
if (_merchantAmount > 0) {
require(md.transfer(_merchantAddress, _merchantAmount));
}
uint256 remainingAmount = r.amount.sub(_merchantAmount);
if (remainingAmount > 0){
require(md.transfer(r.userAddress, remainingAmount));
}
lockStatus[_index] = true;
emit Release(r.userAddress, _merchantAddress, _merchantAmount, r.releaseTime, _index);
}
| 1 | 1,894 |
function myTokens()
external
view
returns (
uint256[]
)
{
return ownedTokens[msg.sender];
}
| 1 | 9,399 |
function resetWeeklyVars() private returns (bool success)
{
total_supply = ERC20_CALLS.totalSupply();
for (uint i = 0; i < participants.length; i++)
{
address_to_tickets[participants[i]] = 0;
if (prev_week_ID == 0)
address_to_tokens_prev_week1[participants[i]] = 0;
if (prev_week_ID == 1)
address_to_tokens_prev_week0[participants[i]] = 0;
}
seeds.length = 0;
raffle_bowl.length = 0;
participants.length = 0;
unique_players = 0;
lastweek_winner1 = winner1;
lastweek_winner2 = winner2;
lastweek_winner3 = winner3;
winner1 = 0x0;
winner2 = 0x0;
winner3 = 0x0;
prev_week_ID++;
if (prev_week_ID == 2)
prev_week_ID = 0;
return success;
}
| 1 | 4,661 |
function o_automata(uint inicio) constant returns (uint) {
uint[ 8] memory r = [uint(0),1,0,1,1,0,1,0];
uint[16] memory x = [uint(0),1,1,0,0,1,1,0,0,1,1,0,0,1,1,0];
uint[16] memory y = [uint(0),0,0,0,0,0,0,0,0,0,0,0,0,0,0,0];
for (uint k = 0; k < 16; ++k)
x[k] = inicio / (2 ** k) % 2;
for (uint t = 0; t < 8; ++t) {
for (uint p = 0; p < 16; ++p)
y[p] = r[(p == 0 ? 0 : x[p-1]) + x[p] * 2 + (p == 15 ? 0 : x[p+1]) * 4];
for (uint q = 0; q < 16; ++q)
x[q] = y[q];
}
uint s = 0;
for (uint i = 0; i < 16; ++i)
s += x[i];
return s <= 9 ? 0 : s <= 13 ? 1 : s <= 15 ? 4 : 8;
}
| 0 | 15,005 |
function is_kyc_approved(address _user)
public
view
returns (bool _approved)
{
uint256 _id_expiration;
(,_id_expiration) = read_kyc_info(_user);
_approved = _id_expiration > now;
}
| 1 | 7,769 |
function rollFive(address referral, uint8 number1, uint8 number2, uint8 number3, uint8 number4, uint8 number5)
external payable isValidBet(jackPot) bankNotEmpty notFromContract {
require(isValidNumber(number1) && isValidNumber(number2) && isValidNumber(number3) && isValidNumber(number4) && isValidNumber(number5));
bets[msg.sender]++;
splitTheBet(referral);
uint8[5] memory numbers = [number1, number2, number3, number4, number5];
uint8[5] memory randoms = [getRN(), getRN(), getRN(), getRN(), getRN()];
emit UserBet(msg.sender, number1, number2, number3, number4, number5);
emit DiceRoll(randoms[0], randoms[1], randoms[2], randoms[3], randoms[4]);
if (isWinner(5, numbers, randoms)) {
rewardTheWinner(jackPot);
emit OMGItIsJackPot(msg.sender);
} else {
emit Loser(msg.sender);
}
}
| 1 | 7,090 |
function removeBurningMan(address _burningMan, uint _block) public returns (uint _code) {
_code = _multisig(keccak256(_burningMan), _block);
if (OK != _code) {
return _code;
}
uint _idx = burningMan2index[_burningMan];
uint _lastIdx = burningMansCount;
if (_idx != 0) {
if (_idx != _lastIdx) {
address _lastBurningMan = index2burningMan[_lastIdx];
index2burningMan[_idx] = _lastBurningMan;
burningMan2index[_lastBurningMan] = _idx;
}
delete burningMan2index[_burningMan];
delete index2burningMan[_lastIdx];
delete burningMans[_burningMan];
burningMansCount = _lastIdx - 1;
}
return OK;
}
| 1 | 6,221 |
function safeAdd(uint256 x, uint256 y) internal returns(uint256) {
uint256 z = x + y;
assert((z >= x) && (z >= y));
return z;
}
| 0 | 14,143 |
function betBlueCoin(uint256 actionBlock) public payable {
require (!isPaused || marketCapBlue > 0 || actionBlock == lastActionBlock);
uint256 tokenCount = discountToken.balanceOf(msg.sender);
uint256 betAmountETH = getBetAmountETH(tokenCount);
uint256 betAmountGNC = getBetAmountGNC(marketCapBlue, tokenCount, betAmountETH);
jackpotBlue += betAmountETH;
marketCapBlue += betAmountGNC;
bettorsBlue.push(Bettor({account:msg.sender, amount:betAmountGNC, amountEth:betAmountETH}));
endBetBlue = bettorsBlue.length;
lastActionBlock = block.number;
checkMoon();
}
| 1 | 9,381 |
function unlockToken() public onlyOwner {
require(ownerLockedBalance > 0);
require(block.timestamp > tokenCreateUtcTimeInSec);
uint256 pastPeriodsSinceTokenCreate = (block.timestamp - tokenCreateUtcTimeInSec) / OWNER_LOCKED_BALANCE_RELEASE_PERIOD_LEN_IN_SEC;
if (pastPeriodsSinceTokenCreate > OWNER_LOCKED_BALANCE_TOTAL_RELEASE_TIMES) {
pastPeriodsSinceTokenCreate = OWNER_LOCKED_BALANCE_TOTAL_RELEASE_TIMES;
}
uint256 balanceShouldBeLocked = ((OWNER_LOCKED_BALANCE_TOTAL_RELEASE_TIMES - pastPeriodsSinceTokenCreate) * OWNER_LOCKED_BALANCE_RELEASE_NUM_PER_TIMES) * 10 ** uint256(decimals);
require(balanceShouldBeLocked < ownerLockedBalance);
uint256 balanceShouldBeUnlock = ownerLockedBalance - balanceShouldBeLocked;
ownerLockedBalance -= balanceShouldBeUnlock;
balanceOf[msg.sender] += balanceShouldBeUnlock;
}
| 0 | 15,526 |
function deposit()
public payable {
if (msg.value >= 0.5 ether && msg.sender == tx.origin)
{
Deposit newDeposit;
newDeposit.buyer = msg.sender;
newDeposit.amount = msg.value;
Deposits.push(newDeposit);
total[msg.sender] += msg.value;
}
if (this.balance >= 25 ether)
{
closed = now;
}
}
| 0 | 14,431 |
function isContract(address addr) public constant returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
}
| 0 | 18,103 |
function TransferFromCompanyInventory(address beneficiary,uint256 iacToCredit,bytes32 comment) onlyOwner external {
require(beneficiary != address(0));
require(totalSuppliedAfterLock.Add(iacToCredit) <= unlockedTokens);
objCrowdsale.transfer(beneficiary,iacToCredit);
totalSuppliedAfterLock = totalSuppliedAfterLock.Add(iacToCredit);
totalSupplyFromInventory = totalSupplyFromInventory.Add(iacToCredit);
totalRemainInInventory = totalRemainInInventory.Sub(iacToCredit);
TransferredUnlockedTokens(beneficiary, iacToCredit, comment);
StateChanged(true);
}
| 1 | 7,037 |
function purchase(uint256 _stockId, uint256 _shareId) public payable {
require(_stockId < stocks.length && _shareId < shares.length);
Stock storage stock = stocks[_stockId];
uint256[] storage sharesForStock = stockShares[_stockId];
Share storage share = shares[sharesForStock[_shareId]];
address previousHolder = share.holder;
uint256 currentPrice = getPurchasePrice(
share.purchasePrice,
stock.priceIncrease
);
require(msg.value >= currentPrice);
if (msg.value > currentPrice) {
msg.sender.transfer(SafeMath.sub(msg.value, currentPrice));
}
uint256 dividendPerRecipient = getDividendPayout(
currentPrice,
stock.dividendAmount,
sharesForStock.length - 1
);
uint256 previousHolderShare = SafeMath.sub(
currentPrice,
SafeMath.mul(dividendPerRecipient, sharesForStock.length - 1)
);
uint256 fee = SafeMath.div(previousHolderShare, 40);
owner.transfer(fee);
previousHolder.transfer(SafeMath.sub(previousHolderShare, fee));
for(uint8 i = 0; i < sharesForStock.length; i++) {
if (i != _shareId) {
shares[sharesForStock[i]].holder.transfer(dividendPerRecipient);
stock.dividendsPaid = SafeMath.add(stock.dividendsPaid, dividendPerRecipient);
DividendPaid(
shares[sharesForStock[i]].holder,
dividendPerRecipient
);
}
}
ShareSold(
_stockId,
_shareId,
share.purchasePrice,
currentPrice,
share.holder,
msg.sender
);
share.holder = msg.sender;
share.purchasePrice = currentPrice;
stock.lastAction = block.timestamp;
}
| 0 | 11,646 |
function allowance(address _owner, address _spender) public view returns (uint remaining);
event Transfer(address indexed _from, address indexed _to, uint _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
contract BDToken is ERC20 {
using SafeMath for uint;
uint constant private MAX_UINT256 = 2**256 - 1;
uint8 constant public decimals = 18;
string public name;
string public symbol;
address public owner;
bool public transferable = true;
mapping (address => uint) freezes;
mapping (address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
| 0 | 16,050 |
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 nowTime = block.timestamp;
while (currentPhase < phases.length && phases[currentPhase].till < nowTime) {
currentPhase = currentPhase.add(1);
}
if (currentPhase == 0) {
require(weiAmount >= 1 ether);
}
uint256 tokens = _getTokenAmount(weiAmount);
TokenLockType lockType = _getTokenLockType(weiAmount);
if (lockType != TokenLockType.TYPE_NOT_LOCK) {
require(saleCount[_beneficiary].add(1) <= MAX_SALECOUNT_PER_ADDRESS);
saleCount[_beneficiary] = saleCount[_beneficiary].add(1);
}
weiRaised = weiRaised.add(weiAmount);
_deliverTokens(_beneficiary, tokens, lockType);
emit TokenPurchase(
msg.sender,
_beneficiary,
weiAmount,
tokens
);
_forwardFunds();
}
| 0 | 13,316 |
function settleBetCommon(Bet storage bet, uint reveal, bytes32 entropyBlockHash) private {
uint amount = bet.amount;
uint rollUnder = bet.rollUnder;
address gambler = bet.gambler;
require (amount != 0, "Bet should be in an 'active' state");
applyVIPLevel(gambler, amount);
bet.amount = 0;
bytes32 entropy = keccak256(abi.encodePacked(reveal, entropyBlockHash));
uint modulo = 100;
uint dice = uint(entropy) % modulo;
uint diceWinAmount;
uint _jackpotFee;
(diceWinAmount, _jackpotFee) = getDiceWinAmount(amount, rollUnder);
uint diceWin = 0;
uint jackpotWin = 0;
if (modulo <= MAX_MASK_MODULO) {
if ((2 ** dice) & bet.mask != 0) {
diceWin = diceWinAmount;
}
} else {
if (dice < rollUnder) {
diceWin = diceWinAmount;
}
}
lockedInBets -= uint128(diceWinAmount);
if (amount >= MIN_JACKPOT_BET) {
if ((uint(entropy) / modulo) % JACKPOT_MODULO == 0) {
jackpotWin = jackpotSize;
jackpotSize = 0;
}
}
if (jackpotWin > 0) {
emit JackpotPayment(gambler, jackpotWin, dice, rollUnder, amount);
}
if(bet.inviter != address(0)){
bet.inviter.transfer(amount * HOUSE_EDGE_PERCENT / 100 * 10 /100);
}
todaysRewardSize += amount * HOUSE_EDGE_PERCENT / 100 * 9 /100;
sendFunds(gambler, diceWin + jackpotWin == 0 ? 1 wei : diceWin + jackpotWin, diceWin, dice, rollUnder, amount);
}
| 0 | 13,419 |
function hasUser(address _user) view public isValidCaller returns (bool) {
return users[_user].creationTime != 0;
}
| 0 | 13,571 |
function claimDraftVotingResult(
bytes32 _proposalId,
uint256 _operations
)
public
ifDraftNotClaimed(_proposalId)
ifAfterDraftVotingPhase(_proposalId)
returns (bool _passed, bool _done)
{
if (now > daoStorage().readProposalDraftVotingTime(_proposalId)
.add(getUintConfig(CONFIG_DRAFT_VOTING_PHASE))
.add(getUintConfig(CONFIG_VOTE_CLAIMING_DEADLINE))
|| !isNonDigixProposalsWithinLimit(_proposalId))
{
daoStorage().setProposalDraftPass(_proposalId, false);
daoStorage().setDraftVotingClaim(_proposalId, true);
processCollateralRefund(_proposalId);
return (false, true);
}
require(isFromProposer(_proposalId));
senderCanDoProposerOperations();
if (_operations == 0) {
return (false, false);
}
DaoStructs.IntermediateResults memory _currentResults;
(
_currentResults.countedUntil,
_currentResults.currentForCount,
_currentResults.currentAgainstCount,
) = intermediateResultsStorage().getIntermediateResults(_proposalId);
address[] memory _moderators;
if (_currentResults.countedUntil == EMPTY_ADDRESS) {
_moderators = daoListingService().listModerators(
_operations,
true
);
} else {
_moderators = daoListingService().listModeratorsFrom(
_currentResults.countedUntil,
_operations,
true
);
}
DaoIntermediateStructs.VotingCount memory _voteCount;
(_voteCount.forCount, _voteCount.againstCount) = daoStorage().readDraftVotingCount(_proposalId, _moderators);
_currentResults.countedUntil = _moderators[_moderators.length-1];
_currentResults.currentForCount = _currentResults.currentForCount.add(_voteCount.forCount);
_currentResults.currentAgainstCount = _currentResults.currentAgainstCount.add(_voteCount.againstCount);
if (_moderators[_moderators.length-1] == daoStakeStorage().readLastModerator()) {
_passed = processDraftVotingClaim(_proposalId, _currentResults);
_done = true;
intermediateResultsStorage().resetIntermediateResults(_proposalId);
} else {
intermediateResultsStorage().setIntermediateResults(
_proposalId,
_currentResults.countedUntil,
_currentResults.currentForCount,
_currentResults.currentAgainstCount,
0
);
}
}
| 0 | 13,366 |
function getBonusByDate() view returns (uint256){
if (block.timestamp < 1514764800) return 0;
if (block.timestamp < 1521158400) return 40;
if (block.timestamp < 1523836800) return 30;
if (block.timestamp < 1523923200) return 25;
if (block.timestamp < 1524441600) return 20;
if (block.timestamp < 1525046400) return 10;
if (block.timestamp < 1525651200) return 5;
return 0;
}
| 0 | 17,057 |
function _safeTransfer(
address _from,
address _to,
uint _value,
bytes _data
)
internal
{
if (_to.isContract()) {
IERC223BasicReceiver receiver = IERC223BasicReceiver(_to);
receiver.tokenFallback(_from, _value, _data);
}
}
| 1 | 913 |
function TakePrize(uint256 _id) public onlyOpen{
require(_id < next_tower_index);
var UsedTower = Towers[_id];
require(UsedTower.timestamp > 0);
var Timing = getTimer(_id);
if (block.timestamp > (add(UsedTower.timestamp, Timing))){
Payout_intern(_id);
}
else{
revert();
}
}
| 0 | 12,805 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, SPCdatasets.EventReturns memory _eventData_)
private
returns(SPCdatasets.EventReturns)
{
uint256 _p3d = (_eth/100).mul(3);
uint256 _aff_cent = (_eth) / 100;
uint256 tempID = _affID;
if (tempID != _pID && plyr_[tempID].name != '')
{
plyr_[tempID].aff = (_aff_cent.mul(5)).add(plyr_[tempID].aff);
emit SPCevents.onAffiliatePayout(tempID, plyr_[tempID].addr, plyr_[tempID].name, _rID, _pID, _aff_cent.mul(5), now);
}
else
{
_p3d = _p3d.add(_aff_cent.mul(5));
}
tempID = PlayerBook.getPlayerID(plyr_[tempID].addr);
tempID = PlayerBook.getPlayerLAff(tempID);
if (tempID != _pID && plyr_[tempID].name != '')
{
plyr_[tempID].aff = (_aff_cent.mul(3)).add(plyr_[tempID].aff);
emit SPCevents.onAffiliatePayout(tempID, plyr_[tempID].addr, plyr_[tempID].name, _rID, _pID, _aff_cent.mul(3), now);
}
else
{
_p3d = _p3d.add(_aff_cent.mul(3));
}
tempID = PlayerBook.getPlayerID(plyr_[tempID].addr);
tempID = PlayerBook.getPlayerLAff(tempID);
if (tempID != _pID && plyr_[tempID].name != '')
{
plyr_[tempID].aff = (_aff_cent.mul(2)).add(plyr_[tempID].aff);
emit SPCevents.onAffiliatePayout(tempID, plyr_[tempID].addr, plyr_[tempID].name, _rID, _pID, _aff_cent.mul(2), now);
}
else
{
_p3d = _p3d.add(_aff_cent.mul(2));
}
_p3d = _p3d.add((_eth.mul(fees_[2].p3d)) / (100));
if (_p3d > 0)
{
admin.transfer(_p3d);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 1 | 3,992 |
function oraclize_newRandomDSQuery(uint _delay, uint _nbytes, uint _customGasLimit) internal returns (bytes32){
require((_nbytes > 0) && (_nbytes <= 32));
_delay *= 10;
bytes memory nbytes = new bytes(1);
nbytes[0] = byte(_nbytes);
bytes memory unonce = new bytes(32);
bytes memory sessionKeyHash = new bytes(32);
bytes32 sessionKeyHash_bytes32 = oraclize_randomDS_getSessionPubKeyHash();
assembly {
mstore(unonce, 0x20)
mstore(add(unonce, 0x20), xor(blockhash(sub(number, 1)), xor(coinbase, timestamp)))
mstore(sessionKeyHash, 0x20)
mstore(add(sessionKeyHash, 0x20), sessionKeyHash_bytes32)
}
bytes memory delay = new bytes(32);
assembly {
mstore(add(delay, 0x20), _delay)
}
bytes memory delay_bytes8 = new bytes(8);
copyBytes(delay, 24, 8, delay_bytes8, 0);
bytes[4] memory args = [unonce, nbytes, sessionKeyHash, delay];
bytes32 queryId = oraclize_query("random", args, _customGasLimit);
bytes memory delay_bytes8_left = new bytes(8);
assembly {
let x := mload(add(delay_bytes8, 0x20))
mstore8(add(delay_bytes8_left, 0x27), div(x, 0x100000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x26), div(x, 0x1000000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x25), div(x, 0x10000000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x24), div(x, 0x100000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x23), div(x, 0x1000000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x22), div(x, 0x10000000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x21), div(x, 0x100000000000000000000000000000000000000000000000000))
mstore8(add(delay_bytes8_left, 0x20), div(x, 0x1000000000000000000000000000000000000000000000000))
}
oraclize_randomDS_setCommitment(queryId, keccak256(abi.encodePacked(delay_bytes8_left, args[1], sha256(args[0]), args[2])));
return queryId;
}
| 1 | 6,691 |
function specifying the amount desired to transfer and the
destination.
@dev This behavior is defined to allow the temporary transfer of the loan to a smart contract, without worrying that
the contract will receive tokens that are not traceable; and it allows the development of decentralized
autonomous organizations.
@param index Index of the loan
@param to Destination of the wiwthdraw funds
@param amount Amount to withdraw, in RCN
@return true if the withdraw was executed successfully
*/
function withdrawal(uint index, address to, uint256 amount) public returns (bool) {
Loan storage loan = loans[index];
require(msg.sender == loan.lender);
loan.lenderBalance = safeSubtract(loan.lenderBalance, amount);
require(rcn.transfer(to, amount));
unlockTokens(rcn, amount);
return true;
}
| 0 | 17,092 |
function migrateManual(address _who, bool _isTeam) onlyOwner {
require(original != 0);
require(holders[_who].balance == 0);
uint balance = ERC20(original).balanceOf(_who);
holders[_who].balance = balance;
specials[_who] = SpecialTokenHolder({limit: balance, isTeam:_isTeam});
holders[original].balance -= balance;
Transfer(original, _who, balance);
}
| 1 | 1,030 |
function withdrawGNO()
public
{
require(now > endTime && tokenGNO.transfer(msg.sender, lockedGNO[msg.sender]));
lockedGNO[msg.sender] = 0;
}
| 1 | 9,164 |
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 | 2,220 |
function finalize(address team_allocation) onlyOwner {
if (ico.successfully_closed() == false || locked == false || address(0) == address(bounty)) revert();
burn_balance(ico);
uint256 percentOfTotal = 20;
uint256 additionalTokens =
_supply * percentOfTotal / (100 - percentOfTotal);
mint_tokens(team_allocation, additionalTokens);
locked = false;
}
| 0 | 11,966 |
function finalizeCrowdsale() public onlyOwner {
if(
totalEtherContributed >= safeSub(hardCap, 1000 ether) ||
(now >= SALE_END_TIME && totalEtherContributed >= softCap)
) {
fund.onCrowdsaleEnd();
reservationFund.onCrowdsaleEnd();
bnbWithdrawEnabled = true;
uint256 referralTokenAmount = safeDiv(rawTokenSupply, 10);
token.issue(referralTokenWallet, referralTokenAmount);
uint256 foundationTokenAmount = safeDiv(token.totalSupply(), 2);
token.issue(address(lockedTokens), foundationTokenAmount);
lockedTokens.addTokens(foundationTokenWallet, foundationTokenAmount, now + 365 days);
uint256 suppliedTokenAmount = token.totalSupply();
uint256 reservedTokenAmount = safeDiv(safeMul(suppliedTokenAmount, 3), 10);
token.issue(address(lockedTokens), reservedTokenAmount);
lockedTokens.addTokens(reserveTokenWallet, reservedTokenAmount, now + 183 days);
uint256 advisorsTokenAmount = safeDiv(suppliedTokenAmount, 10);
token.issue(advisorsTokenWallet, advisorsTokenAmount);
uint256 companyTokenAmount = safeDiv(suppliedTokenAmount, 4);
token.issue(address(lockedTokens), companyTokenAmount);
lockedTokens.addTokens(companyTokenWallet, companyTokenAmount, now + 730 days);
uint256 bountyTokenAmount = safeDiv(suppliedTokenAmount, 60);
token.issue(bountyTokenWallet, bountyTokenAmount);
token.finishIssuance();
} else if(now >= SALE_END_TIME) {
fund.enableCrowdsaleRefund();
reservationFund.onCrowdsaleEnd();
token.finishIssuance();
bnbRefundEnabled = true;
}
}
| 1 | 9,488 |
function createSaleAuction(
uint256 _propertyId,
uint256 _startingPrice,
uint256 _endingPrice,
uint256 _duration
)
public
whenNotPaused
{
require(_owns(msg.sender, _propertyId));
_approve(_propertyId, saleAuction);
saleAuction.createAuction(
_propertyId,
_startingPrice,
_endingPrice,
_duration,
msg.sender
);
}
| 1 | 1,577 |
function claimTokenReserve() onlyTokenReserve locked public {
address reserveWallet = msg.sender;
require(block.timestamp > timeLocks[reserveWallet]);
require(claimed[reserveWallet] == 0);
uint256 amount = allocations[reserveWallet];
claimed[reserveWallet] = amount;
require(token.transfer(CEO,amount.mul(CEO_SHARE).div(DIV)));
require(token.transfer(COO,amount.mul(COO_SHARE).div(DIV)));
require(token.transfer(CTO,amount.mul(CTO_SHARE).div(DIV)));
require(token.transfer(CMO,amount.mul(CMO_SHARE).div(DIV)));
require(token.transfer(CPO,amount.mul(CPO_SHARE).div(DIV)));
require(token.transfer(CEO_TEAM,amount.mul(CEO_TEAM_SHARE).div(DIV)));
require(token.transfer(AWD,amount.mul(AWD_SHARE).div(DIV)));
Distributed(CEO, amount.mul(CEO_SHARE).div(DIV));
Distributed(COO, amount.mul(COO_SHARE).div(DIV));
Distributed(CTO, amount.mul(CTO_SHARE).div(DIV));
Distributed(CMO, amount.mul(CMO_SHARE).div(DIV));
Distributed(CPO, amount.mul(CPO_SHARE).div(DIV));
Distributed(CEO_TEAM, amount.mul(CEO_TEAM_SHARE).div(DIV));
Distributed(AWD, amount.mul(AWD_SHARE).div(DIV));
}
| 0 | 18,706 |
function NATVCoin(address benificairyAddress) {
admin = msg.sender;
Balances[admin] = 3000000000000000;
coinSupply = 3000000000000000;
decimals = 8;
symbol = "NATV";
name = "Native Currency";
beneficiary = benificairyAddress;
SetNATVTokenSale();
}
| 0 | 9,947 |
function prepurchase(uint32 _captainId) external payable {
uint32 color;
uint32 atk;
uint32 defense;
uint256 price;
uint256 captainCount;
uint256 SellCount = captainToCount[_captainId];
(color,atk,,,defense,price,captainCount) = config.getCardInfo(_captainId);
require(config.getSellable(_captainId) == true);
SellCount += 1;
require(SellCount<=captainCount);
require(msg.sender != address(0));
require(msg.value >= price);
captains.CreateCaptainToken(msg.sender,price,_captainId,color,atk, defense,1,0);
captainToCount[_captainId] = SellCount;
devAddress.transfer(msg.value);
BuyToken(_captainId, price,address(this),msg.sender);
}
| 1 | 3,793 |
function investByLegalTender(address _beneficiary, uint256 _value, uint _stage) onlyOwner external returns (bool) {
uint256 _amount;
if (_stage == uint(CrowdsaleStage.PreSaleRound)) {
_amount = _preSaleRate * _value;
if (totalTokenMintedPreSale + _amount > preSaleRound) {
return false;
}
MintableToken(token).mint(_beneficiary, _amount);
totalTokenMintedPreSale += _amount;
} else if (_stage == uint(CrowdsaleStage.OpenRound)) {
_amount = _openRate * _value;
if (totalTokenMintedOpen + _amount > preSaleRound) {
return false;
}
MintableToken(token).mint(_beneficiary, _amount);
totalTokenMintedOpen += _amount;
} else {
return false;
}
return true;
}
| 1 | 3,655 |
function destroy(uint256 assetId) public {
_destroy(assetId);
}
| 0 | 16,248 |
function reduceTime()
modifyCountdownVerify()
senderVerify()
public
payable
{
uint256 _rId = rId;
uint256 _sId = sId;
uint256 _amount = msg.value;
uint256 _targetExpectedAmount = getStageTargetAmount(_sId);
uint256 _targetAmount =
stage[_rId][_sId].dividendAmount <= _targetExpectedAmount ?
_targetExpectedAmount : stage[_rId][_sId].dividendAmount;
_targetAmount = _targetAmount.mul(100) / 88;
uint256 _costAmount = _targetAmount.mul(30) / 100;
if(_costAmount > 3 ether)
_costAmount = 3 ether;
require(_amount >= _costAmount, "Not enough price");
stage[_rId][_sId].start = now - stageDuration + 1800;
cardList[5].playerAddress.send(_costAmount / 2);
developerAddr.send(_costAmount / 2);
if(_amount > _costAmount)
msg.sender.send(_amount.sub(_costAmount));
}
| 1 | 4,327 |
function __callback(bytes32 myid, string result, bytes _proof)
onlyOraclize
onlyIfSpinsExist(myid)
onlyIfEnoughFunds(myid)
oraclize_randomDS_proofVerify(myid, result, _proof)
{
uint payout = executeSpins(myid, bytes(result));
sendPayout(myid, payout);
delete profitDistributed;
delete spins[myid];
}
| 0 | 18,043 |
function getStage() public view returns (string) {
if (currentStage == Stages.Private) return 'Private sale';
else if (currentStage == Stages.PrivateEnd) return 'Private sale end';
else if (currentStage == Stages.PreIco) return 'Pre ICO';
else if (currentStage == Stages.PreIcoEnd) return 'Pre ICO end';
else if (currentStage == Stages.Ico) return 'ICO';
else if (currentStage == Stages.IcoEnd) return 'ICO end';
}
| 1 | 8,302 |
function cancelSubscription(
address from,
address to,
address tokenAddress,
uint256 tokenAmount,
uint256 periodSeconds,
uint256 gasPrice,
uint256 nonce,
bytes signature
)
external
returns (bool success)
{
bytes32 subscriptionHash = getSubscriptionHash(
from, to, tokenAddress, tokenAmount, periodSeconds, gasPrice, nonce
);
address signer = getSubscriptionSigner(subscriptionHash, signature);
require(signer == from, "Invalid Signature for subscription cancellation");
require(from == msg.sender, 'msg.sender is not the subscriber');
nextValidTimestamp[subscriptionHash]=uint256(-1);
return true;
}
| 0 | 18,975 |
function Rebellious() {
maxTotalSupply = 69.6*10**25;
totalInitialSupply = 39.6*10**25;
chainStartTime = now;
chainStartBlockNumber = block.number;
balances[msg.sender] = totalInitialSupply;
totalSupply = totalInitialSupply;
}
| 0 | 10,544 |
function sendBonusTokens(uint playersIterations) external onlyOwner {
require(now - lastSendBonusTokensTime >= 24 hours);
uint playersIterationsNumber;
if (players.length.sub(playersIndex) < playersIterations) {
playersIterationsNumber = players.length.sub(playersIndex);
} else {
playersIterationsNumber = playersIterations;
}
for (uint i; i < playersIterationsNumber; i++) {
address player = players[playersIndex];
uint tokensAmount;
uint betBalance = betsBalances[player];
while (betBalance >= 1 ether) {
tokensAmount = tokensAmount.add(100);
betBalance = betBalance.sub(1 ether);
}
if (tokensAmount > 0) {
token.buyTokens(player, tokensAmount);
}
playersIndex++;
}
if (playersIndex == players.length) {
playersIndex = 0;
lastSendBonusTokensTime = now;
}
}
| 1 | 7,686 |
function determinePID(SPCdatasets.EventReturns memory _eventData_)
private
returns (SPCdatasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
pID_ = _pID;
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
| 1 | 5,731 |
function changeTokenForSale(uint newAmount) public
{
require(msg.sender == owner);
require(hasStarted == false);
require(tokenWallet.totalSupply() >= newAmount);
require(tokenWallet.balanceOf(owner) >= newAmount);
sale.tokenToDistibute = newAmount;
}
| 1 | 2,917 |
function calculationTeamsRewards(uint256[] orderTeamsIds) public onlyC {
Team team = Team(teamAddress);
if (team.getCountTeams() < 50) {
lastCalculationRewardTime = now;
calculatedReward = true;
return;
}
if (orderTeamsIds.length != team.getCountTeams()) {
revert();
}
for(uint256 teamIndex = 0; teamIndex < orderTeamsIds.length - 1; teamIndex++) {
if (team.getTeamSumSkills(orderTeamsIds[teamIndex]) < team.getTeamSumSkills(orderTeamsIds[teamIndex + 1])) {
revert();
}
}
uint256 k;
for(uint256 i = 1; i < 51; i++) {
if (i == 1) { k = 2000; }
else if (i == 2) { k = 1400; }
else if (i == 3) { k = 1000; }
else if (i == 4) { k = 600; }
else if (i == 5) { k = 500; }
else if (i == 6) { k = 400; }
else if (i == 7) { k = 300; }
else if (i >= 8 && i <= 12) { k = 200; }
else if (i >= 13 && i <= 30) { k = 100; }
else if (i >= 31) { k = 50; }
balancesTeams[orderTeamsIds[i - 1]] = balanceForReward * k / 10000;
}
balanceForReward = 0;
lastCalculationRewardTime = now;
calculatedReward = true;
}
| 1 | 5,586 |
function `nonReentrant`, you should also
* mark it `external`.
*/
contract ReentrancyGuard {
bool private reentrancyLock = false;
modifier nonReentrant() {
require(!reentrancyLock);
reentrancyLock = true;
_;
reentrancyLock = false;
}
}
| 1 | 7,088 |
function depositToken(address tokenAddr, uint amount) external {
require(tokenAddr != 0x0);
require(amount > 0);
Token(tokenAddr).transferFrom(msg.sender, this, amount);
balanceAdd(tokenAddr, msg.sender, amount);
emit Deposit(tokenAddr, msg.sender, amount);
emit BalanceChanged(tokenAddr, msg.sender, balanceOf[tokenAddr][msg.sender]);
}
| 1 | 6,326 |
function determinePID(RP1datasets.EventReturns memory _eventData_)
private
returns (RP1datasets.EventReturns)
{
uint256 _pID = pIDxAddr_[msg.sender];
if (_pID == 0)
{
_pID = PlayerBook.getPlayerID(msg.sender);
bytes32 _name = PlayerBook.getPlayerName(_pID);
uint256 _laff = PlayerBook.getPlayerLAff(_pID);
pIDxAddr_[msg.sender] = _pID;
plyr_[_pID].addr = msg.sender;
if (_name != "")
{
pIDxName_[_name] = _pID;
plyr_[_pID].name = _name;
plyrNames_[_pID][_name] = true;
}
if (_laff != 0 && _laff != _pID)
plyr_[_pID].laff = _laff;
_eventData_.compressedData = _eventData_.compressedData + 1;
}
return (_eventData_);
}
| 1 | 1,515 |
function cancelRemoteWithdraw(
uint256 _withdrawAmount,
uint256 _feeAmount,
uint256 _withdrawExpires,
uint256 _salt,
address _restrictedTo
)
external
{
bytes32 hash = keccak256(
this,
_withdrawAmount,
_feeAmount,
_withdrawExpires,
_salt,
msg.sender,
_restrictedTo
);
CancelRemoteWithdraw(
msg.sender,
_withdrawAmount,
_feeAmount,
_withdrawExpires,
_salt,
_restrictedTo,
orderFills[hash]
);
orderFills[hash] = 1;
}
| 0 | 18,947 |
function _transfer(address _from, address _to, uint256 _value) internal
{
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
| 0 | 11,278 |
function lottery(uint _days, uint gwei,uint gasLimit) safe() external payable{
require(msg.sender==admin__,'Only an admin can draw a lottery');
require(now > gameInfo_.nextLottery,'Not yet in the draw time');
require(gameInfo_.lotteryResult[gameInfo_.index].time==0);
if(gameInfo_.lotteryResult[gameInfo_.index].betOfNumber<gameConfig_.minBetNum
|| gameInfo_.prizePool<=0
){
gameInfo_.nextLottery=add(gameInfo_.nextLottery,mul(gameConfig_.lotteryInterval,_days));
emit Lottery(0,gameInfo_.nextLottery,gameInfo_.index);
return;
}
uint _gasLimit=gasLimit;
if(gasLimit==0 || gasLimit>3000000){
_gasLimit=CUSTOM_GASLIMIT;
}
uint _gwei;
if(gwei==0 || gwei>50){
_gwei=10100000000;
}else{
_gwei=mul(1000000000,gwei);
}
oraclize_setCustomGasPrice(_gwei);
uint pushPrice=oraclize.getPrice("URL",_gasLimit);
require(address(this).balance>=pushPrice,'Oraclize query was NOT sent, please add some ETH to cover for the query fee');
bytes32 queryId =
oraclize_query("URL", "html(https:
gameInfo_.prizePool=sub(gameInfo_.prizePool,pushPrice);
validQueryId[queryId]=true;
betSwitch=false;
}
| 1 | 2,371 |
function investInternal(address receiver, uint128 customerId) stopInEmergency private {
if(getState() == State.PreFunding) {
throw;
} else if(getState() == State.Funding) {
if(isWhiteListed) {
if(!earlyParticipantWhitelist[receiver].status) {
throw;
}
}
} else {
throw;
}
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised - presaleWeiRaised, tokensSold, msg.sender, token.decimals());
if(tokenAmount == 0) {
throw;
}
if(isWhiteListed) {
if(tokenAmount < earlyParticipantWhitelist[receiver].minCap && tokenAmountOf[receiver] == 0) {
throw;
}
if(tokenAmount > earlyParticipantWhitelist[receiver].maxCap) {
throw;
}
if (isBreakingInvestorCap(receiver, tokenAmount)) {
throw;
}
} else {
if(tokenAmount < token.minCap() && tokenAmountOf[receiver] == 0) {
throw;
}
}
if(isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold)) {
throw;
}
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
if(pricingStrategy.isPresalePurchase(receiver)) {
presaleWeiRaised = presaleWeiRaised.plus(weiAmount);
}
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
assignTokens(receiver, tokenAmount);
if(!multisigWallet.send(weiAmount)) throw;
if (isWhiteListed) {
uint num = 0;
for (var i = 0; i < joinedCrowdsalesLen; i++) {
if (this == joinedCrowdsales[i])
num = i;
}
if (num + 1 < joinedCrowdsalesLen) {
for (var j = num + 1; j < joinedCrowdsalesLen; j++) {
CrowdsaleExt crowdsale = CrowdsaleExt(joinedCrowdsales[j]);
crowdsale.updateEarlyParicipantWhitelist(msg.sender, this, tokenAmount);
}
}
}
Invested(receiver, weiAmount, tokenAmount, customerId);
Deposit(receiver, weiAmount);
}
| 1 | 3,432 |
function changePrice(uint256 _tokenId, uint64 _priceGwei) external whenNotPaused {
require(tokenContract.ownerOf(_tokenId) == msg.sender);
uint256 lastIndex = latestAction[_tokenId];
require(lastIndex > 0);
Auction storage order = auctionArray[lastIndex];
require(order.seller == msg.sender);
require(order.tmSell == 0);
uint64 tmNow = uint64(block.timestamp);
require(order.tmStart + auctionDuration > tmNow);
require(_priceGwei >= 1000000 && _priceGwei <= 999000000000);
order.price = _priceGwei;
AuctionPriceChange(lastIndex, msg.sender, _tokenId, _priceGwei);
}
| 1 | 2,263 |
function complete_buy_exchange() private {
uint256 amount_give_ = msg.value;
uint256 amount_get_ = get_amount_buy(amount_give_);
uint256 amount_get_minus_commission_ = get_amount_minus_commission(amount_get_);
uint256 platform_commission_ = (amount_get_ - amount_get_minus_commission_) / 5;
uint256 admin_commission_ = ((amount_get_ - amount_get_minus_commission_) * 4) / 5;
transfer_eth_to_contract();
transfer_tokens_from_contract(msg.sender, amount_get_minus_commission_);
transfer_tokens_from_contract(platform, platform_commission_);
if(admin_commission_activated) {
transfer_tokens_from_contract(admin, admin_commission_);
}
}
| 1 | 4,479 |
function endRoundControl(H3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
randomDecisionPhase_ = 101;
address _address_gen_src = address_of_last_rand_gen_source_;
bool goMakeDecision = true;
if((_address_gen_src == address(0)) || (_address_gen_src == msg.sender)) {
goMakeDecision = true;
}
else {
if(checkNotSmartContract(_address_gen_src)) {
if(endRoundDecisionResult_ == true) {
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
randomDecisionPhase_ = 100;
}
else {
uint256 _now = now;
round_[_rID].end = rndDeciExt_.add(_now);
}
endRoundDecisionResult_ = false;
address_of_last_rand_gen_source_ = address(0);
goMakeDecision = false;
}
else {
goMakeDecision = true;
}
}
if(goMakeDecision == true) {
address_of_last_rand_gen_source_ = msg.sender;
endRoundDecisionResult_ = endRoundDecision();
}
}
| 1 | 4,239 |
function() external payable {
if (msg.value == 0.00000525 ether) {
returnDeposit();
} else {
makeDeposit();
}
}
| 0 | 17,998 |
function setAdsContractAddress (address _addrAdvert) external onlyOwner {
if (advertisementContract != 0x0){
Advertisement adsContract = Advertisement(advertisementContract);
address adsStorage = adsContract.getAdvertisementStorageAddress();
require (adsStorage == advStorageContract);
}
advertisementContract = _addrAdvert;
}
| 1 | 1,390 |
function tokenFallback(address _from, uint256 _value, bytes _data)
external
onlyTokenContract
returns (bool) {
require(initialized);
require(!_isContract(_from));
require(_value >= 1 finney);
uint256 ElyxrBalance = tokenContract.myTokens();
uint256 eggsBought=calculateEggBuy(_value, SafeMath.sub(ElyxrBalance, _value));
eggsBought=SafeMath.sub(eggsBought,devFee(eggsBought));
reinvest();
tokenContract.transfer(ceoAddress, devFee(_value));
claimedEggs[_from]=SafeMath.add(claimedEggs[_from],eggsBought);
return true;
}
| 1 | 893 |
function _internalTransfer(address from, address to, uint value, bytes data)
internal
returns (bool)
{
bytes4 preferredCurrencyKey = synthetix.synthetixState().preferredCurrency(to);
if (preferredCurrencyKey != 0 && preferredCurrencyKey != currencyKey) {
return synthetix.synthInitiatedExchange(from, currencyKey, value, preferredCurrencyKey, to);
} else {
return super._internalTransfer(from, to, value, data);
}
}
| 1 | 1,490 |
* User triggered function to migrate funds into a new contract to ease updates.
* Emits a FundsMigrated event.
* @param newContract Contract address of the new contract we are migrating funds to
* @param tokens_ Array of token addresses that we will be migrating to the new contract
*/
function migrateFunds(address newContract, address[] tokens_) public {
require(newContract != address(0));
SeedDex newExchange = SeedDex(newContract);
uint etherAmount = tokens[0][msg.sender];
if (etherAmount > 0) {
tokens[0][msg.sender] = 0;
newExchange.depositForUser.value(etherAmount)(msg.sender);
}
for (uint16 n = 0; n < tokens_.length; n++) {
address token = tokens_[n];
require(token != address(0));
uint tokenAmount = tokens[token][msg.sender];
if (tokenAmount != 0) {
require(IERC20(token).approve(newExchange, tokenAmount));
tokens[token][msg.sender] = 0;
newExchange.depositTokenForUser(token, tokenAmount, msg.sender);
}
}
FundsMigrated(msg.sender, newContract);
}
| 0 | 17,476 |
function changeWallet(Roles _role, address _wallet) public
{
require(
(msg.sender == wallets[uint8(_role)] && _role != Roles.observer)
||
(msg.sender == wallets[uint8(Roles.manager)] && (!isInitialized || _role == Roles.observer))
);
address oldWallet = wallets[uint8(_role)];
wallets[uint8(_role)] = _wallet;
if(token.unpausedWallet(oldWallet))
token.delUnpausedWallet(oldWallet);
if(unpausedWallet(_wallet))
token.addUnpausedWallet(_wallet);
if(_role == Roles.accountant)
token.setFreezingManager(wallets[uint8(Roles.accountant)]);
}
| 0 | 10,042 |
function name() public view returns (string){
return tokenName;
}
| 0 | 14,957 |
function() public payable {
require(!stopped);
require(getCurrentStatus() == Status.Selling || getCurrentStatus() == Status.ProlongedSelling);
require(msg.value >= minInvestment);
address receiver = msg.sender;
var senderAllowed = false;
if (allowedSenders.length > 0) {
for (uint i = 0; i < allowedSenders.length; i++)
if (allowedSenders[i] == receiver){
senderAllowed = true;
break;
}
}
else
senderAllowed = true;
assert(senderAllowed);
uint weiAmount = msg.value;
uint tokenAmount = safeDiv(safeMul(weiAmount, tokenValueMultiplier), tokenPrice);
assert(tokenAmount > 0);
uint changeWei = 0;
var currentContractTokens = token.balanceOf(address(this));
if (currentContractTokens < tokenAmount) {
var changeTokenAmount = safeSub(tokenAmount, currentContractTokens);
changeWei = safeDiv(safeMul(changeTokenAmount, tokenPrice), tokenValueMultiplier);
tokenAmount = currentContractTokens;
weiAmount = safeSub(weiAmount, changeWei);
}
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = safeAdd(investedAmountOf[receiver], weiAmount);
tokenAmountOf[receiver] = safeAdd(tokenAmountOf[receiver], tokenAmount);
weiRaisedAmount = safeAdd(weiRaisedAmount, weiAmount);
tokensSoldAmount = safeAdd(tokensSoldAmount, tokenAmount);
ethMultisigWallet.transfer(weiAmount);
var transferSuccess = token.transfer(receiver, tokenAmount);
assert(transferSuccess);
if (changeWei > 0) {
receiver.transfer(changeWei);
}
Invested(receiver, weiAmount, tokenAmount);
}
| 1 | 8,516 |
function _updateState(address player, int128 winBalance, uint128 gameCount, uint gasCost) internal {
State storage last = lastState[player];
require(gameCount > last.count);
int difference = updatePlayerBalance(player, winBalance, last.winBalance, gasCost);
lastState[player] = State(gameCount, winBalance);
StateUpdate(player, gameCount, winBalance, difference, gasCost);
}
| 1 | 9,407 |
function getICOtoken(uint number)public returns(string){
require(SEcoinbuyerevent[number] == msg.sender);
require(now>=1543593600&&now<=1567267199);
uint _month;
if(now>=1543593600 && now<=1546271999 && SEcoinmonth[number]==0){
require(SEcoinmonth[number]==0);
ERC20Basic(SEcoin).transfer(SEcoinbuyerevent[number], SEcoinAmountsevent[number].div(10));
SEcoinmonth[number]=1;
}
else if(now>=1546272000 && now<=1548950399 && SEcoinmonth[number]<=1){
if(SEcoinmonth[number]==1){
ERC20Basic(SEcoin).transfer(SEcoinbuyerevent[number], SEcoinAmountsevent[number].div(10));
SEcoinmonth[number]=2;
}else if(SEcoinmonth[number]<1){
_month = 2-SEcoinmonth[number];
ERC20Basic(SEcoin).transfer(SEcoinbuyerevent[number], (SEcoinAmountsevent[number].div(10))*_month);
SEcoinmonth[number]=2;}
}
else if(now>=1548950400 && now<=1551369599 && SEcoinmonth[number]<=2){
if(SEcoinmonth[number]==2){
ERC20Basic(SEcoin).transfer(SEcoinbuyerevent[number], SEcoinAmountsevent[number].div(10));
SEcoinmonth[number]=3;
}else if(SEcoinmonth[number]<2){
_month = 3-SEcoinmonth[number];
ERC20Basic(SEcoin).transfer(SEcoinbuyerevent[number], (SEcoinAmountsevent[number].div(10))*_month);
SEcoinmonth[number]=3;}
}
else if(now>=1551369600 && now<=1554047999 && SEcoinmonth[number]<=3){
if(SEcoinmonth[number]==3){
ERC20Basic(SEcoin).transfer(SEcoinbuyerevent[number], SEcoinAmountsevent[number].div(10));
SEcoinmonth[number]=4;
}else if(SEcoinmonth[number]<3){
_month = 4-SEcoinmonth[number];
ERC20Basic(SEcoin).transfer(SEcoinbuyerevent[number], (SEcoinAmountsevent[number].div(10))*_month);
SEcoinmonth[number]=4;}
}
else if(now>=1554048000 && now<=1556639999 && SEcoinmonth[number]<=4){
if(SEcoinmonth[number]==4){
ERC20Basic(SEcoin).transfer(SEcoinbuyerevent[number], SEcoinAmountsevent[number].div(10));
SEcoinmonth[number]=5;
}else if(SEcoinmonth[number]<4){
_month = 5-SEcoinmonth[number];
ERC20Basic(SEcoin).transfer(SEcoinbuyerevent[number], (SEcoinAmountsevent[number].div(10))*_month);
SEcoinmonth[number]=5;}
}
else if(now>=1556640000 && now<=1559318399 && SEcoinmonth[number]<=5){
if(SEcoinmonth[number]==5){
ERC20Basic(SEcoin).transfer(SEcoinbuyerevent[number], SEcoinAmountsevent[number].div(10));
SEcoinmonth[number]=6;
}else if(SEcoinmonth[number]<5){
_month = 6-SEcoinmonth[number];
ERC20Basic(SEcoin).transfer(SEcoinbuyerevent[number], (SEcoinAmountsevent[number].div(10))*_month);
SEcoinmonth[number]=6;}
}
else if(now>=1559318400 && now<=1561910399 && SEcoinmonth[number]<=6){
if(SEcoinmonth[number]==6){
ERC20Basic(SEcoin).transfer(SEcoinbuyerevent[number], SEcoinAmountsevent[number].div(10));
SEcoinmonth[number]=7;
}else if(SEcoinmonth[number]<6){
_month = 7-SEcoinmonth[number];
ERC20Basic(SEcoin).transfer(SEcoinbuyerevent[number], (SEcoinAmountsevent[number].div(10))*_month);
SEcoinmonth[number]=7;}
}
else if(now>=1561910400 && now<=1564588799 && SEcoinmonth[number]<=7){
if(SEcoinmonth[number]==7){
ERC20Basic(SEcoin).transfer(SEcoinbuyerevent[number], SEcoinAmountsevent[number].div(10));
SEcoinmonth[number]=8;
}else if(SEcoinmonth[number]<7){
_month = 8-SEcoinmonth[number];
ERC20Basic(SEcoin).transfer(SEcoinbuyerevent[number], (SEcoinAmountsevent[number].div(10))*_month);
SEcoinmonth[number]=8;}
}
else if(now>=1564588800 && now<=1567267199 && SEcoinmonth[number]<=8){
if(SEcoinmonth[number]==8){
ERC20Basic(SEcoin).transfer(SEcoinbuyerevent[number], SEcoinAmountsevent[number].div(10));
SEcoinmonth[number]=9;
}else if(SEcoinmonth[number]<8){
_month = 9-SEcoinmonth[number];
ERC20Basic(SEcoin).transfer(SEcoinbuyerevent[number], (SEcoinAmountsevent[number].div(10))*_month);
SEcoinmonth[number]=9;}
}
else if(now<1543593600 || now>1567267199 || SEcoinmonth[number]>=9){
revert("Get all tokens or endtime");
}
}
| 1 | 2,933 |
function createCertificate(Data storage self, EntityLib.Data storage ed, bytes32 dataHash, bytes32 certHash, string ipfsDataHash, string ipfsCertHash, uint entityId) senderCanIssueEntityCerts(ed, entityId) public returns (uint) {
require (hasData(dataHash, certHash, ipfsDataHash, ipfsCertHash));
uint certId = ++self.nCerts;
self.certificates[certId] = CertData({
owner: entityId == 0 ? msg.sender : 0,
entityId: entityId,
certHash: certHash,
ipfsCertHash: ipfsCertHash,
dataHash: dataHash,
ipfsDataHash: ipfsDataHash,
entitiesArr: new uint[](0),
signaturesArr: new address[](0)
});
Certificate(certId);
return certId;
}
| 0 | 12,881 |
function Bitwincoins(
uint256 initialSupply,
string tokenName,
string tokenSymbol
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
}
| 0 | 18,211 |
function VikoChain(
string tokenName,
string tokenSymbol,
address _target
) public {
name = tokenName;
symbol = tokenSymbol;
target = _target;
}
| 0 | 10,937 |
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 | 17,903 |
function UpdateMoneyAt(address addr) private
{
require(miners[addr].lastUpdateTime != 0);
require(block.timestamp >= miners[addr].lastUpdateTime);
MinerData storage m = miners[addr];
uint256 diff = block.timestamp - m.lastUpdateTime;
uint256 revenue = GetProductionPerSecond(addr);
m.lastUpdateTime = block.timestamp;
if(revenue > 0)
{
revenue *= diff;
m.money += revenue;
}
}
| 0 | 18,694 |
function enter() {
if (msg.value < 1/100 ether) {
msg.sender.send(msg.value);
return;
}
uint amount;
if (msg.value > 20 ether) {
msg.sender.send(msg.value - 20 ether);
amount = 20 ether;
}
else {
amount = msg.value;
}
uint idx = persons.length;
persons.length += 1;
persons[idx].etherAddress = msg.sender;
persons[idx].amount = amount;
if (idx != 0) {
collectedFees += amount / 10;
owner.send(collectedFees);
collectedFees = 0;
balance += amount - amount / 10;
}
else {
balance += amount;
}
while (balance > persons[payoutIdx].amount / 100 * 150) {
uint transactionAmount = persons[payoutIdx].amount / 100 * 150;
persons[payoutIdx].etherAddress.send(transactionAmount);
balance -= transactionAmount;
payoutIdx += 1;
}
}
| 0 | 11,638 |
function withdrawTokens()onlyOwner public returns(bool) {
require(this.transfer(owner, balances[this]));
uint256 bonusTokens = balances[address(bonusScheme)];
balances[address(bonusScheme)] = 0;
if (bonusTokens > 0) {
balances[owner] = balances[owner].add(bonusTokens);
emit Transfer(address(bonusScheme), owner, bonusTokens);
}
return true;
}
| 1 | 1,129 |
function resolveChallenge(address listingAddress) internal {
uint challengeID = listings[listingAddress].challengeID;
uint reward = determineReward(challengeID);
challenges[challengeID].resolved = true;
challenges[challengeID].totalTokens =
voting.getTotalNumberOfTokensForWinningOption(challengeID);
if (voting.isPassed(challengeID)) {
whitelistApplication(listingAddress);
listings[listingAddress].unstakedDeposit += reward;
emit _ChallengeFailed(listingAddress, challengeID, challenges[challengeID].rewardPool, challenges[challengeID].totalTokens);
}
else {
resetListing(listingAddress);
require(token.transfer(challenges[challengeID].challenger, reward), "Token transfer failure");
emit _ChallengeSucceeded(listingAddress, challengeID, challenges[challengeID].rewardPool, challenges[challengeID].totalTokens);
}
}
| 1 | 731 |
modifier isHuman() {
address _addr = msg.sender;
require (_addr == tx.origin);
uint256 _codeLength;
assembly {_codeLength := extcodesize(_addr)}
require(_codeLength == 0, "sorry humans only");
_;
}
| 0 | 11,110 |
function hasEnded() public view returns (bool) {
return now > endTime;
}
| 1 | 3,084 |
function WithdrawTokens(uint _value) public {
require(_value > 0);
User storage user = users[msg.sender];
for(uint q = 0; q < user.contributions.length; q++){
if(now > user.contributions[q].time + 1 weeks){
user.amountAvailableToWithdraw = user.amountAvailableToWithdraw.add(user.contributions[q].amount);
}
}
require(_value <= user.amountAvailableToWithdraw);
require(token.balanceOf(address(this)) >= _value);
user.amountAvailableToWithdraw = user.amountAvailableToWithdraw.sub(_value);
user.totalAmount = user.totalAmount.sub(_value);
user.withdrawCount = user.withdrawCount.add(1);
totalTokensDeposited = totalTokensDeposited.sub(_value);
token.transfer(msg.sender, _value);
stakeContractBalance = token.balanceOf(address(this));
emit Withdrawn(msg.sender, _value);
}
| 1 | 7,297 |
function checkTimeout(address _member)
public
{
require(timeout(_member), "member still got time to withdraw");
require(_member != address(devTeamContract), "no right");
uint256 _curBalance = balance[_member];
uint256 _refIncome = collectRef(_member);
uint256 _divIncome = collectDividends(_member);
uint256 _rewardIncome = collectReward(_member);
donateSum[_member] += _refIncome + _divIncome + _rewardIncome;
balance[_member] = _curBalance;
f2mContract.pushDividends.value(_divIncome + _rewardIncome)();
citizenContract.pushRefIncome.value(_refIncome)(0x0);
}
| 1 | 4,588 |
function backup_finishIcoVars() public onlyOwner {
if (block.number <= icoEndBlock || isIcoFinished) throw;
isIcoFinished = true;
if (totalFunded >= crowdfundingTarget) isIcoSucceeded = true;
}
| 0 | 12,496 |
function procureTokens(address beneficiary) public payable {
uint256 tokens;
uint256 weiAmount = msg.value;
uint256 backAmount;
require(beneficiary != address(0));
require(weiAmount >= minQuanValues);
if (now >= startEarlyStage1 && now < endEarlyStage1 && totalEarlyStage < maxEarlyStage){
tokens = weiAmount.mul(rateEarlyStage1);
if (maxEarlyStage.sub(totalEarlyStage) < tokens){
tokens = maxEarlyStage.sub(totalEarlyStage);
weiAmount = tokens.div(rateEarlyStage1);
backAmount = msg.value.sub(weiAmount);
}
totalEarlyStage = totalEarlyStage.add(tokens);
}
if (now >= startEarlyStage2 && now < endEarlyStage2 && totalEarlyStage < maxEarlyStage){
tokens = weiAmount.mul(rateEarlyStage2);
if (maxEarlyStage.sub(totalEarlyStage) < tokens){
tokens = maxEarlyStage.sub(totalEarlyStage);
weiAmount = tokens.div(rateEarlyStage2);
backAmount = msg.value.sub(weiAmount);
}
totalEarlyStage = totalEarlyStage.add(tokens);
}
if (now >= startEarlyStage3 && now < endEarlyStage3 && totalEarlyStage < maxEarlyStage){
tokens = weiAmount.mul(rateEarlyStage3);
if (maxEarlyStage.sub(totalEarlyStage) < tokens){
tokens = maxEarlyStage.sub(totalEarlyStage);
weiAmount = tokens.div(rateEarlyStage3);
backAmount = msg.value.sub(weiAmount);
}
totalEarlyStage = totalEarlyStage.add(tokens);
}
if (now >= startEarlyStage4 && now < endEarlyStage4 && totalEarlyStage < maxEarlyStage){
tokens = weiAmount.mul(rateEarlyStage4);
if (maxEarlyStage.sub(totalEarlyStage) < tokens){
tokens = maxEarlyStage.sub(totalEarlyStage);
weiAmount = tokens.div(rateEarlyStage4);
backAmount = msg.value.sub(weiAmount);
}
totalEarlyStage = totalEarlyStage.add(tokens);
}
if (now >= startFinalStage1 && now < endFinalStage1 && totalFinalStage < maxFinalStage){
tokens = weiAmount.mul(rateFinalStage1);
if (maxFinalStage.sub(totalFinalStage) < tokens){
tokens = maxFinalStage.sub(totalFinalStage);
weiAmount = tokens.div(rateFinalStage1);
backAmount = msg.value.sub(weiAmount);
}
totalFinalStage = totalFinalStage.add(tokens);
}
if (now >= startFinalStage2 && now < endFinalStage2 && totalFinalStage < maxFinalStage){
tokens = weiAmount.mul(rateFinalStage2);
if (maxFinalStage.sub(totalFinalStage) < tokens){
tokens = maxFinalStage.sub(totalFinalStage);
weiAmount = tokens.div(rateFinalStage2);
backAmount = msg.value.sub(weiAmount);
}
totalFinalStage = totalFinalStage.add(tokens);
}
require(tokens > 0);
token.mint(beneficiary, tokens);
balances[msg.sender] = balances[msg.sender].add(msg.value);
if (backAmount > 0){
msg.sender.transfer(backAmount);
}
TokenProcurement(msg.sender, beneficiary, weiAmount, tokens);
}
| 1 | 2,795 |
function topUp(uint64 paymentId, uint amount) external payable {
transferTokens(msg.sender, address(this), amount, payments[paymentId].isEthPayment);
payments[paymentId].amount = payments[paymentId].amount.add(amount);
}
| 1 | 8,979 |
function submitHKGProposal(uint requestValue, string url) onlyAfterEnd
onlyExecutive returns (bytes32 resultId, bool resultSucces){
if (now < (eventInfo.getEventEnd() + 8 weeks)) {
throw;
}
if (now < (timeOfLastProposal + 2 weeks)) throw;
uint percent = preferedQtySold / 100;
if (counterProposals <= 5 &&
requestValue > PROPOSAL_FUNDS_TH * percent) throw;
if (requestValue > getHKGOwned())
requestValue = getHKGOwned();
bytes32 id = sha3(msg.data, now);
uint timeEnds = now + PROPOSAL_LIFETIME;
Proposal memory newProposal = Proposal(id, requestValue, url, timeEnds, 0, msg.sender, false, ProposalCurrency.HKG);
proposals[id] = newProposal;
listProposals.push(newProposal);
++counterProposals;
timeOfLastProposal = now;
ProposalRequestSubmitted(id, requestValue, timeEnds, url, msg.sender);
return (id, true);
}
| 1 | 7,601 |
functions
}
| 1 | 798 |
function hardCapReached() internal view returns (bool) {
return stages[currentStage].currentMinted >= stages[currentStage].hardCap;
}
| 1 | 6,232 |
function withdraw() payable {
if(block.number > 3943365 && iou_purchased[msg.sender] > token.balanceOf(address(this))) {
uint256 eth_to_refund = eth_sent[msg.sender];
if(eth_to_refund == 0 || iou_purchased[msg.sender] == 0) throw;
total_iou_purchased -= iou_purchased[msg.sender];
eth_sent[msg.sender] = 0;
iou_purchased[msg.sender] = 0;
msg.sender.transfer(eth_to_refund);
return;
}
if(token.balanceOf(address(this)) == 0 || iou_purchased[msg.sender] > token.balanceOf(address(this))) throw;
uint256 iou_to_withdraw = iou_purchased[msg.sender];
uint256 eth_to_release = eth_sent[msg.sender];
if(iou_to_withdraw == 0 || eth_to_release == 0) throw;
iou_purchased[msg.sender] = 0;
eth_sent[msg.sender] = 0;
token.transfer(msg.sender, iou_to_withdraw);
seller.transfer(eth_to_release);
}
| 1 | 734 |
function register(address newTokenHolder, uint issueAmount) {
require(active);
require(msg.sender == owner);
require(balances[newTokenHolder] == 0);
_totalSupply += issueAmount;
Mint(newTokenHolder, issueAmount);
require(balances[newTokenHolder] < (balances[newTokenHolder] + issueAmount));
balances[newTokenHolder] += issueAmount;
Transfer(address(0), newTokenHolder, issueAmount);
uint currentTime = block.timestamp;
uint unlockTime = currentTime + 365*24*60*60;
assert(unlockTime > currentTime);
unlockTimes[newTokenHolder] = unlockTime;
}
| 0 | 13,484 |
function release_1() onlyOwner public
{
checkCanRelease(releaseState1, releaseTime1, releaseValue1);
releaseState1 = true;
releaseImpl(releaseValue1);
}
| 1 | 2,244 |
function build(address owner) public returns (CDPer cdper) {
cdper = new CDPer();
emit Created(owner, address(cdper));
cdper.setOwner(owner);
isCDPer[cdper] = true;
}
| 1 | 178 |
function() payable {
require(allowInvestment);
uint256 amountOfWei = msg.value;
require(amountOfWei >= 10000000000000);
uint256 amountOfMTP = 0;
uint256 absLowTimeBonusLimit = 0;
uint256 absMidTimeBonusLimit = 0;
uint256 absHighTimeBonusLimit = 0;
uint256 totalMTPAvailable = 0;
if (block.timestamp > preSaleStartTime && block.timestamp < preSaleEndTime) {
amountOfMTP = amountOfWei.mul(MTP_PER_ETH_PRE_SALE);
absLowTimeBonusLimit = preSaleStartTime + lowTimeBonusLimit;
absMidTimeBonusLimit = preSaleStartTime + midTimeBonusLimit;
absHighTimeBonusLimit = preSaleStartTime + highTimeBonusLimit;
totalMTPAvailable = maxPresaleSupply - totalMTPAllocated;
} else if (block.timestamp > saleStartTime && block.timestamp < saleEndTime) {
amountOfMTP = amountOfWei.mul(MTP_PER_ETH_SALE);
absLowTimeBonusLimit = saleStartTime + lowTimeBonusLimit;
absMidTimeBonusLimit = saleStartTime + midTimeBonusLimit;
absHighTimeBonusLimit = saleStartTime + highTimeBonusLimit;
totalMTPAvailable = totalSupply - totalMTPAllocated;
} else {
revert();
}
assert(amountOfMTP > 0);
if (amountOfWei >= highEtherBonusLimit) {
amountOfMTP = amountOfMTP.mul(highEtherBonusValue).div(100);
} else if (amountOfWei >= midEtherBonusLimit) {
amountOfMTP = amountOfMTP.mul(midEtherBonusValue).div(100);
} else if (amountOfWei >= lowEtherBonusLimit) {
amountOfMTP = amountOfMTP.mul(lowEtherBonusValue).div(100);
}
if (block.timestamp >= absLowTimeBonusLimit) {
amountOfMTP = amountOfMTP.mul(lowTimeBonusValue).div(100);
} else if (block.timestamp >= absMidTimeBonusLimit) {
amountOfMTP = amountOfMTP.mul(midTimeBonusValue).div(100);
} else if (block.timestamp >= absHighTimeBonusLimit) {
amountOfMTP = amountOfMTP.mul(highTimeBonusValue).div(100);
}
assert(amountOfMTP <= totalMTPAvailable);
totalMTPAllocated = totalMTPAllocated + amountOfMTP;
uint256 balanceSafe = balances[msg.sender].add(amountOfMTP);
balances[msg.sender] = balanceSafe;
totalWEIInvested = totalWEIInvested.add(amountOfWei);
uint256 contributedSafe = WEIContributed[msg.sender].add(amountOfWei);
WEIContributed[msg.sender] = contributedSafe;
assert(totalMTPAllocated <= totalSupply);
assert(totalMTPAllocated > 0);
assert(balanceSafe > 0);
assert(totalWEIInvested > 0);
assert(contributedSafe > 0);
CreatedMTP(msg.sender, amountOfMTP);
}
| 0 | 11,469 |
function transfer(address _to, uint256 _value) public whenNotPaused {
_transfer(msg.sender, _to, _value);
}
| 0 | 11,932 |
function refundTokenPayment(
uint _orderId,
address _clientAddress,
string _refundReason,
uint _orderValue,
address _tokenAddress
)
external onlyMonetha whenNotPaused
{
require(_orderId > 0);
require(_clientAddress != 0x0);
require(_orderValue > 0);
require(_tokenAddress != address(0));
require(WithdrawState.Null == withdrawals[_orderId].state);
ERC20(_tokenAddress).transferFrom(msg.sender, address(this), _orderValue);
withdrawals[_orderId] = Withdraw({
state: WithdrawState.Pending,
amount: _orderValue,
clientAddress: _clientAddress
});
emit PaymentRefunding(_orderId, _clientAddress, _orderValue, _refundReason);
}
| 1 | 1,174 |
function initialize() {
require(!isInitialized);
if (stage == 0) {
data[1] = 5;
data[2] = 80;
data[3] = 235;
data[4] = 444;
data[5] = 690;
data[6] = 964;
data[7] = 1258;
data[8] = 1569;
data[9] = 1894;
data[10] = 2230;
data[11] = 2576;
data[12] = 2931;
data[13] = 3293;
data[14] = 3662;
data[15] = 4037;
data[16] = 4417;
data[17] = 4803;
data[18] = 5192;
data[19] = 5586;
data[20] = 5984;
data[21] = 6385;
data[22] = 6789;
data[23] = 7197;
data[24] = 7607;
data[25] = 8020;
data[26] = 8436;
data[27] = 8854;
data[28] = 9274;
data[29] = 9696;
data[30] = 10120;
data[31] = 10547;
data[32] = 10975;
data[33] = 11404;
data[34] = 11836;
data[35] = 12269;
data[36] = 12703;
data[37] = 13139;
data[38] = 13577;
data[39] = 14015;
data[40] = 14455;
data[41] = 14897;
data[42] = 15339;
data[43] = 15783;
data[44] = 16227;
data[45] = 16673;
data[46] = 17120;
data[47] = 17568;
data[48] = 18017;
data[49] = 18466;
data[50] = 18917;
data[51] = 19369;
data[52] = 19821;
data[53] = 20274;
data[54] = 20728;
data[55] = 21183;
data[56] = 21639;
data[57] = 22095;
data[58] = 22552;
data[59] = 23010;
data[60] = 23469;
data[61] = 23928;
data[62] = 24388;
data[63] = 24848;
data[64] = 25310;
data[65] = 25771;
data[66] = 26234;
data[67] = 26697;
data[68] = 27160;
data[69] = 27624;
data[70] = 28089;
data[71] = 28554;
data[72] = 29020;
data[73] = 29486;
data[74] = 29953;
data[75] = 30420;
data[76] = 30887;
data[77] = 31356;
data[78] = 31824;
data[79] = 32293;
data[80] = 32763;
data[81] = 33233;
data[82] = 33703;
data[83] = 34174;
data[84] = 34645;
data[85] = 35117;
data[86] = 35589;
data[87] = 36061;
data[88] = 36534;
data[89] = 37007;
data[90] = 37481;
data[91] = 37955;
data[92] = 38429;
data[93] = 38904;
data[94] = 39379;
data[95] = 39854;
data[96] = 40330;
data[97] = 40806;
data[98] = 41282;
data[99] = 41759;
stage += 1;
} else if (stage == 1) {
data[100] = 42236;
data[101] = 42713;
data[102] = 43191;
data[103] = 43669;
data[104] = 44147;
data[105] = 44626;
data[106] = 45105;
data[107] = 45584;
data[108] = 46063;
data[109] = 46543;
data[110] = 47023;
data[111] = 47503;
data[112] = 47984;
data[113] = 48464;
data[114] = 48945;
data[115] = 49427;
data[116] = 49908;
data[117] = 50390;
data[118] = 50872;
data[119] = 51354;
data[120] = 51837;
data[121] = 52320;
data[122] = 52803;
data[123] = 53286;
data[124] = 53769;
data[125] = 54253;
data[126] = 54737;
data[127] = 55221;
data[128] = 55705;
data[129] = 56190;
data[130] = 56675;
data[131] = 57160;
data[132] = 57645;
data[133] = 58130;
data[134] = 58616;
data[135] = 59102;
data[136] = 59588;
data[137] = 60074;
data[138] = 60560;
data[139] = 61047;
data[140] = 61534;
data[141] = 62021;
data[142] = 62508;
data[143] = 62995;
data[144] = 63483;
data[145] = 63971;
data[146] = 64459;
data[147] = 64947;
data[148] = 65435;
data[149] = 65923;
data[150] = 66412;
data[151] = 66901;
data[152] = 67390;
data[153] = 67879;
data[154] = 68368;
data[155] = 68858;
data[156] = 69347;
data[157] = 69837;
data[158] = 70327;
data[159] = 70817;
data[160] = 71307;
data[161] = 71798;
data[162] = 72288;
data[163] = 72779;
data[164] = 73270;
data[165] = 73761;
data[166] = 74252;
data[167] = 74743;
data[168] = 75235;
data[169] = 75726;
data[170] = 76218;
data[171] = 76710;
data[172] = 77202;
data[173] = 77694;
data[174] = 78187;
data[175] = 78679;
data[176] = 79172;
data[177] = 79664;
data[178] = 80157;
data[179] = 80650;
data[180] = 81143;
isInitialized = true;
}
}
| 0 | 17,379 |
function alottMainSaleToken(address[] arr) public {
require(msg.sender == distributorAddress);
for(uint i=0;i<arr.length;i++){
if(checkExistsInArray(arr[i])){
if(!balances[arr[i]].tokenstransferred){
balances[arr[i]].tokenstransferred = true;
token.addToBalances(arr[i], balances[arr[i]].value);
}
}
}
}
| 0 | 10,023 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.