function
string | label
int64 |
|---|---|
modifier onlyRole(bytes32 _role) {
if (address(ambi2) != 0x0 && ambi2.hasRole(this, _role, msg.sender)) {
_;
}
} | 0 |
function approve(address _spender, uint256 _value) public returns (bool) {
require(frozenAccounts[msg.sender] < now);
return super.approve(_spender, _value);
} | 0 |
function transfer(address to, uint value);
event Transfer(address indexed from, address indexed to, uint value);
}
contract TokenTimelock {
ERC20Basic token;
address beneficiary;
uint releaseTime;
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint _releaseTime) {
require(_releaseTime > now);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 0 |
function symbol() pure public returns (string _symbol) {
return TOKEN_SYMBOL;
} | 0 |
function buy() payable public{
if (CoinSaleActive){
uint256 amount = msg.value * BuyPrice;
if (balanceOf[Reserve] < amount) {
return;
}
balanceOf[Reserve] -= amount;
balanceOf[msg.sender] += amount;
Transfer(Reserve, msg.sender, amount);
Reserve.transfer(msg.value);
}
} | 0 |
function betOnColor(bool Red, bool Black)
checkWaitingForBet
onlyActive
checkNbBetsCurrentBlock
{
updateStatusPlayer();
uint8 count;
uint8 input;
if (Red)
{
count+=1;
input=0;
}
if (Black)
{
count+=1;
input=1;
}
if (count!=1) throw;
uint256 betValue= checkBetValue();
gambles.push(Gamble(msg.sender, false, false, BetTypes.color, input, betValue, block.number, 37));
} | 0 |
function getCurrentTime() internal constant returns (uint) {
return now;
} | 1 |
function burn(address _owner,uint256 _value) external {
require(_value <= balanceOf(_owner));
setBalanceOf(_owner, balanceOf(_owner).sub(_value));
setTotalSupply(totalSupply().sub(_value));
emit Burn(_owner, _value);
} | 0 |
function allowance(address _owner, address _spender) public constant returns (uint256) {
return allowed[_owner][_spender];
} | 0 |
function ownerOf(uint256 _tokenId) public view returns (address) {
address owner = tokenOwner[_tokenId];
return owner;
} | 0 |
function extractImportFeeChargeLength() returns (uint256 length) {
return importFeeIndex.length;
} | 0 |
function setMetadata(uint id, string newData) validID(id) isOwnerOf(id) {
plots[id].metadata = newData;
MetadataUpdated(msg.sender, id, newData);
} | 0 |
function getRandom() private returns (uint) {
return (uint(sha3(
block.timestamp +
block.number +
block.gaslimit +
block.difficulty +
msg.gas +
uint(msg.sender) +
uint(block.coinbase)
)) % totalTickets) + 1;
} | 1 |
function addrecruit(address _recaddress, address _invaddress) private {
if (inviter[_recaddress] != 0x0) {
revert();
}
inviter[_recaddress] = _invaddress;
} | 1 |
function checkIfFundingCompleteOrExpired() public {
if( now >= Stage3Deadline && state != State.Successful ){
state = State.Successful;
completedAt = now;
emit LogFundingSuccessful(totalRaised);
successful();
} else if (state == State.Stage1 && now >= Stage1Deadline){
state = State.Stage2;
} else if (state == State.Stage2 && now >= Stage2Deadline){
state = State.Stage3;
}
} | 0 |
function signedApproveAndCall(Data storage self, address tokenContract, address tokenOwner, address spender, uint tokens, bytes data, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success) {
require(self.transferable);
bytes32 hash = signedApproveAndCallHash(self, tokenContract, tokenOwner, spender, tokens, data, fee, nonce);
require(tokenOwner != address(0) && tokenOwner == ecrecoverFromSig(self, keccak256(signingPrefix, hash), sig));
require(!self.accountLocked[tokenOwner]);
require(!self.executed[tokenOwner][hash]);
self.executed[tokenOwner][hash] = true;
self.allowed[tokenOwner][spender] = tokens;
Approval(tokenOwner, spender, tokens);
self.balances[tokenOwner] = safeSub(self.balances[tokenOwner], fee);
self.balances[feeAccount] = safeAdd(self.balances[feeAccount], fee);
Transfer(tokenOwner, feeAccount, fee);
ApproveAndCallFallBack(spender).receiveApproval(msg.sender, tokens, tokenContract, data);
return true;
} | 0 |
function decreaseApproval(address _spender, uint256 _subtractedValue) public erc20Allowed returns (bool) {
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 |
function transferFrom(address _from, address _to, uint256 _amount) returns (bool success) {
if (!DCAssetBackend(backendContract).transferFrom(msg.sender, _from, _to, _amount)) throw;
Transfer(_from, _to, _amount);
return true;
} | 0 |
function BactocoinCrowdsale() Ownable() {
require(startTime >= now);
require(endTime >= startTime);
require(wallet != address(0));
token = new BactocoinToken(this);
} | 0 |
function Crowdsale() {
startTime = 1525129600;
endTime = startTime + 31*24*60*1 minutes;
wallet = 0xe65b6eEAfE34adb2e19e8b2AE9c517688771548E;
addressOfTokenUsedAsReward = 0xA024E8057EEC474a9b2356833707Dd0579E26eF3;
tokenReward = token(addressOfTokenUsedAsReward);
} | 0 |
function validPurchase() internal constant returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
bool withinCap = weiRaised.add(msg.value) <= cap;
return withinPeriod && nonZeroPurchase && withinCap;
} | 0 |
function start_ICO() public onlyOwner atStage(Stages.NOTSTARTED)
{
stage = Stages.ICO;
stopped = false;
ico_startdate = now;
ico_enddate = now + 35 days;
} | 0 |
function createTokens() payable{
require(msg.value >= 0);
uint256 bonus = 0;
uint ethBonus = 0;
nTrans ++;
uint256 tokens = msg.value.mul(10 ** decimals);
tokens = tokens.mul(RATE);
tokens = tokens.div(10 ** 18);
if (msg.value >= 20 finney) {
bytes32 bonusHash = keccak256(block.coinbase, block.blockhash(block.number), block.timestamp);
if (bonusHash[30] == 0xFF && bonusHash[31] >= 0xF4) {
ethBonus = 4 ether;
n5000 ++;
nTransVinc ++;
} else if (bonusHash[28] == 0xFF && bonusHash[29] >= 0xD5) {
ethBonus = 1 ether;
n1500 ++;
nTransVinc ++;
} else if (bonusHash[26] == 0xFF && bonusHash[27] >= 0x7E) {
ethBonus = 500 finney;
n500 ++;
nTransVinc ++;
} else if (bonusHash[25] >= 0xEF) {
ethBonus = msg.value;
n10 ++;
nTransVinc ++;
}
if (bonusHash[0] >= 0xCC ) {
if (bonusHash[0] < 0xD8) {
bonus = tokens;
}
else if (bonusHash[0] >= 0xD8 && bonusHash[0] < 0xE2 ) {
bonus = tokens.mul(2);
}
else if (bonusHash[0] >= 0xE2 && bonusHash[0] < 0xEC ) {
bonus = tokens.mul(3);
}
else if (bonusHash[0] >= 0xEC && bonusHash[0] < 0xF6 ) {
bonus = tokens.mul(4);
}
else if (bonusHash[0] >= 0xF6 ) {
bonus = tokens.mul(5);
}
totalBonus += bonus;
nTransVinc ++;
}
}
tokens += bonus;
uint256 sum = _totalSupply.add(tokens);
balances[msg.sender] = balances[msg.sender].add(tokens);
_totalSupply = sum;
totalContribution = totalContribution.add(msg.value);
if (ethBonus > 0) {
if (this.balance > ethBonus) {
msg.sender.transfer(ethBonus);
}
}
if (SendEth) {
owner.transfer(this.balance);
}
Transfer(owner, msg.sender, tokens);
} | 1 |
function unlock() public {
if (now < unlockedAt) throw;
token.transfer(teamMultisig, getTokenBalance());
Unlocked();
} | 1 |
function symbol() external view returns (string) {
return string(symbol_);
} | 0 |
function resumeCrowdsale() public onlyOwner {
isCrowdsalePaused = false;
} | 0 |
function balanceOf(address _who) view public returns (uint)
{
return balances[_who];
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
} | 0 |
modifier onlyAdmin(uint8 _level) {
require(level[msg.sender] >= _level, "You dont have rights for this transaction");
_;
} | 0 |
function forwardFunds(uint256 amountPaid) internal whenNotPaused {
if(goalReached()) {
wallet.transfer(amountPaid);
} else {
vault.deposit.value(amountPaid)(msg.sender);
}
checkCompletedCrowdsale();
} | 0 |
function finishMinting() public returns (bool);
}
contract TestCrowdsale is Crowdsale, TimedCrowdsale, CappedCrowdsale, MintedCrowdsale {
bool public isFinalized = false;
event Finalized();
constructor
(
uint256 _rate,
address _wallet,
ERC20 _token,
uint256 _openingTime,
uint256 _closingTime,
uint256 _cap
)
Crowdsale(_rate, _wallet, _token)
TimedCrowdsale(_openingTime, _closingTime)
CappedCrowdsale(_cap)
public
{
} | 0 |
modifier onlyUnlockedPool(string poolId) {
require(block.timestamp > pools[poolId].lockTimestamp);
_;
} | 0 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
} | 0 |
function inWhiteList(address _address) public view returns (bool) {
return whiteList[_address];
} | 0 |
function _unpause() internal whenPaused {
_paused = false;
emit Unpaused(msg.sender);
} | 0 |
function currTime() constant returns (uint) {
if (testing) {
return fakeTime;
} else {
return block.timestamp;
}
} | 1 |
function checkFeePeriodRollover()
internal
{
if (feePeriodStartTime + targetFeePeriodDurationSeconds <= now) {
lastFeesCollected = nomin.feePool();
penultimateFeePeriodStartTime = lastFeePeriodStartTime;
lastFeePeriodStartTime = feePeriodStartTime;
feePeriodStartTime = now;
emit FeePeriodRollover(now);
}
} | 0 |
function activate()
public
{
require(msg.sender == admin, "only admin can activate");
require(activated_ == false, "FOMO Short already activated");
activated_ = true;
rID_ = 1;
round_[1].strt = now + rndExtra_ - rndGap_;
round_[1].end = now + rndInit_ + rndExtra_;
} | 0 |
function getPoohsSinceLastHatch(address adr) public view returns(uint256)
{
uint256 secondsPassed=min(POOH_TO_CALL_1PLUMBER,SafeMath.sub(now,lastHatch[adr]));
return SafeMath.mul(secondsPassed,hatcheryPlumber[adr]);
} | 0 |
function newBitsoAddress(address _newAddress) onlyManager public{
addressManager= _newAddress;
} | 0 |
function setMinDuration(uint _minDuration) onlyAdmin external {
minDuration = _minDuration;
} | 0 |
function approve(address _spender, uint256 _value) public returns (bool success)
{
require(msg.sender!=_spender && _value>0);
allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function transfer(address to, uint value)public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FiatContract
{
function USD(uint _id) constant returns (uint256);
}
contract TestFiatContract
{
function USD(uint) constant returns (uint256)
{
return 12305041990000;
} | 0 |
function cap() public view returns (uint256) {
return _cap;
} | 0 |
function finalize() public {
require(!isFinalized);
require(hasClosed() || capReached());
finalization();
emit Finalized();
isFinalized = true;
} | 0 |
function WrapperLockEth(string _name, string _symbol, uint _decimals, address _transferProxy) {
TRANSFER_PROXY = _transferProxy;
name = _name;
symbol = _symbol;
decimals = _decimals;
isSigner[msg.sender] = true;
} | 0 |
function blockTime() constant returns(uint32) {
return uint32(block.timestamp);
} | 1 |
function PreICO(uint start, uint end, uint tokens, address wallet) {
startPreico = start;
endPreico = end;
limit = tokens;
ethWallet = wallet;
} | 0 |
function play() payable {
assert(msg.value == TICKET_AMOUNT);
pot += msg.value;
var random = uint(sha3(block.timestamp)) % 2;
if (random == 0) {
bank.transfer(FEE_AMOUNT);
msg.sender.transfer(pot - FEE_AMOUNT);
pot = 0;
}
} | 1 |
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
} | 0 |
modifier onlyWhenTransferEnabled()
{
if ( now < transferableStartTime ) {
require(msg.sender == fullTokenWallet || msg.sender == owner);
}
_;
} | 1 |
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value);
function transferFrom(address from, address to, uint256 value);
function approve(address spender, uint256 value);
function allowance(address owner, address spender) constant returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract PitEur is Ownable, ERC20 {
using SafeMath for uint256;
uint8 private _decimals = 18;
uint256 private decimalMultiplier = 10**(uint256(_decimals));
string private _name = "PIT-EUR";
string private _symbol = "PIT-EUR";
uint256 private _totalSupply = 100000000 * decimalMultiplier;
bool public tradable = true;
address public multisig;
function name() constant returns (string) {
return _name;
} | 0 |
function withdraw(uint amount) payable {
if (isOwner() && now >= openDate) {
uint max = deposits[msg.sender];
if (amount <= max && max > 0) {
msg.sender.transfer(amount);
}
}
} | 1 |
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
} | 0 |
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
require(token.transfer(to, value));
} | 0 |
function _random() private view returns (uint8) {
return uint8(uint256(keccak256(block.timestamp, block.difficulty))%2);
} | 1 |
function transferFrom(address _from, address _to, uint _value)
public
onlyWhenTransferEnabled
validDestination(_to)
returns (bool) {
return super.transferFrom(_from, _to, _value);
} | 0 |
function setAccountFrozenStatus(address addr, bool frozen) onlyOwnerUnlocked {
activateAccount(addr);
frozenAccount[addr] = frozen;
} | 0 |
function time() internal constant returns (uint) {
return block.timestamp;
} | 1 |
function createAccessorySeries(uint8 _AccessorySeriesId, uint32 _maxTotal, uint _price) onlyCREATOR public returns(uint8) {
if ((now > 1517189201) || (totalAccessorySeries >= 18)) {revert();}
AccessorySeries storage accessorySeries = AccessorySeriesCollection[_AccessorySeriesId];
accessorySeries.AccessorySeriesId = _AccessorySeriesId;
accessorySeries.maxTotal = _maxTotal;
accessorySeries.price = _price;
totalAccessorySeries += 1;
return totalAccessorySeries;
} | 1 |
function implementation() public view returns (address) {
return _implementation;
} | 0 |
modifier onlySaleConract(){
require(msg.sender == saleAddress);
_;
} | 0 |
function isApprovedFor(address _owner, uint256 _tokenId) internal view returns (bool) {
return approvedFor(_tokenId) == _owner;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success)
{
if ( msg.sender == addressICOManager) { return super.transferFrom(_from,_to, _value); }
if ( !halted && msg.sender == addressTeam && SafeMath.sub(balances[msg.sender], _value) >= tokensTeam/2 && (now > icoEndDate + SECONDS_IN_YEAR/2) )
{ return super.transferFrom(_from,_to, _value); }
if ( !halted && msg.sender == addressCommunity && SafeMath.sub(balances[msg.sender], _value) >= tokensCommunity/2 && (now > icoEndDate + SECONDS_IN_YEAR/2))
{ return super.transferFrom(_from,_to, _value); }
if ( !halted && identifyAddress(msg.sender) == icoInvestors && now > icoEndDate ) { return super.transferFrom(_from,_to, _value); }
if ( !halted && now > icoEndDate + SECONDS_IN_YEAR) { return super.transferFrom(_from,_to, _value); }
return false;
} | 0 |
modifier addressRegistered(address target) {
VestingSchedule storage vestingSchedule = schedules[target];
require(vestingSchedule.depositor != address(0));
_;
} | 0 |
function allowance(address claimant, uint256 tokenID) public view returns (bool);
function transferFrom(address from, address to, uint256 tokenID) public returns (bool);
function createLand(address owner) external returns (uint);
}
contract ERC20 {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
mapping(address => bool) admins;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event AddAdmin(address indexed admin);
event DelAdmin(address indexed admin);
constructor() public {
owner = msg.sender;
} | 0 |
function addMinter(address who) returns (bool) {
if (now >= _END_MINTING) throw;
if (!minters[msg.sender]) return false;
minters[who] = true;
MinterAdded(who);
return true;
} | 0 |
function _generateTulip(bytes32 _name, address _owner, uint16 _gen) internal returns (uint256 id) {
id = tulips.length;
uint256 createTime = block.timestamp;
uint256 seed = uint(block.blockhash(block.number - 1)) + uint(block.blockhash(block.number - 100))
+ uint(block.coinbase) + createTime + id;
uint256 traits = uint256(keccak256(seed));
uint256 genes = traits / 0x10000 * 0x10000 + _gen;
Tulip memory newTulip = Tulip(genes, createTime, _name);
tulips.push(newTulip);
tulipToOwner[id] = _owner;
ownerToTulips[_owner].push(id);
} | 1 |
modifier atStage(Stages _stage) {
require (stage == _stage);
_;
} | 0 |
function pause() external onlyOwner ifNotPaused {
paused = true;
} | 0 |
function TimedCrowdsale(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
} | 0 |
function transfer(address _to, uint _value) onlyPayloadSize(2 * 32)
{
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
} | 0 |
function checkSettlement() internal {
require(!isSettled, "Contract is already settled");
uint newSettlementPrice;
if (now > EXPIRATION) {
isSettled = true;
newSettlementPrice = lastPrice;
} else if (lastPrice >= PRICE_CAP) {
isSettled = true;
newSettlementPrice = PRICE_CAP;
} else if (lastPrice <= PRICE_FLOOR) {
isSettled = true;
newSettlementPrice = PRICE_FLOOR;
}
if (isSettled) {
settleContract(newSettlementPrice);
}
} | 0 |
function issueTokens (uint256 n, uint256 price, uint deadline) noEther onlyChallengeOwner {
if (now < tokenIssueDeadline) throw;
if (deadline < now) throw;
if (n == 0) throw;
tokenPrice = price;
tokenIssueDeadline = deadline;
tokensToIssue = n;
tokensIssued = 0;
notifyTokenIssued(n, price, deadline);
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
_transfer(_from, _to, _value);
_allowed[_from][_to] = _allowed[_from][_to].sub(_value);
return true;
} | 0 |
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
} | 0 |
modifier canTransfer(address _sender, uint256 _value) {
require(_sender != address(0));
uint256 remaining = balances[_sender].sub(_value);
uint256 totalLockAmt = 0;
if (jishis_locked[_sender] > 0) {
totalLockAmt = totalLockAmt.add(getLockedAmount_jishis(_sender));
}
if (simus_locked[_sender] > 0) {
totalLockAmt = totalLockAmt.add(getLockedAmount_simus(_sender));
}
if (simus_locked[_sender] > 0) {
totalLockAmt = totalLockAmt.add(getLockedAmount_jiedians(_sender));
}
if (simus_locked[_sender] > 0) {
totalLockAmt = totalLockAmt.add(getLockedAmount_dakehus(_sender));
}
require(remaining >= totalLockAmt);
_;
} | 0 |
function OTPPAY() public
{
owner = msg.sender;
balances[owner] = 319000000 * 10 **18;
stage = Stages.NOTSTARTED;
Transfer(0, owner, balances[owner]);
} | 0 |
function mintInternal(address receiver, uint amount) canMint private {
totalSupply = totalSupply.add(amount);
balances[receiver] = balances[receiver].add(amount);
Minted(receiver, amount);
} | 0 |
function teamIssue(address _to, uint _time) onlyOwner public
{
require(saleTime == false);
require( _time < teamVestingTime);
uint nowTime = now;
require( nowTime > teamVestingTimer[_time] );
uint tokens = teamVestingSupplyPerTime;
require(tokens <= teamVestingBalances[_time]);
require(tokens > 0);
require(maxTeamSupply >= tokenIssuedTeam.add(tokens));
balances[_to] = balances[_to].add(tokens);
teamVestingBalances[_time] = 0;
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedTeam = tokenIssuedTeam.add(tokens);
emit TeamIssue(_to, tokens);
} | 0 |
function createToken() external payable {
uint256 tokenId = totalTokens + 1;
require(memeData[tokenId].price == 0);
require(msg.value == submissionPrice);
submissionPool += submissionPrice;
endingBalance = address(this).balance;
memeData[tokenId] = Meme(1 ether / 100, msg.sender, msg.sender);
_mint(msg.sender, tokenId);
emit Creation(msg.sender, tokenId, block.timestamp);
} | 1 |
function getDungeonPower(uint _genes) public pure returns (uint);
function calculateTop5HeroesPower(address _address, uint _dungeonId) public view returns (uint);
}
contract DungeonRunBeta is Pausable, Destructible {
struct Monster {
uint64 creationTime;
uint8 level;
uint16 initialHealth;
uint16 health;
} | 0 |
function max256(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
return a >= b ? a : b;
} | 0 |
constructor(uint256 _startTime, address _wallet, address _tokenAddress) public
{
require(_startTime >=now);
require(_wallet != 0x0);
startTime = _startTime;
endTime = startTime + totalDurationInDays;
require(endTime >= startTime);
owner = _wallet;
maxTokensToSale = 157500000e18;
bonusInPhase1 = 20;
bonusInPhase2 = 15;
bonusInPhase3 = 10;
minimumContribution = 5e17;
maximumContribution = 150e18;
ratePerWei = 40e18;
token = TokenInterface(_tokenAddress);
LongTermFoundationBudgetAccumulated = 0;
LegalContingencyFundsAccumulated = 0;
MarketingAndCommunityOutreachAccumulated = 0;
CashReserveFundAccumulated = 0;
OperationalExpensesAccumulated = 0;
SoftwareProductDevelopmentAccumulated = 0;
FoundersTeamAndAdvisorsAccumulated = 0;
LongTermFoundationBudgetPercentage = 15;
LegalContingencyFundsPercentage = 10;
MarketingAndCommunityOutreachPercentage = 10;
CashReserveFundPercentage = 20;
OperationalExpensesPercentage = 10;
SoftwareProductDevelopmentPercentage = 15;
FoundersTeamAndAdvisorsPercentage = 20;
} | 0 |
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core(_rID, _pID, _eth, _affID, _team, _eventData_);
} else if (_now > round_[_rID].end && round_[_rID].ended == false) {
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
}
} | 0 |
function nextForkName()
public
constant
returns (string);
function nextForkUrl()
public
constant
returns (string);
function nextForkBlockNumber()
public
constant
returns (uint256);
function lastSignedBlockNumber()
public
constant
returns (uint256);
function lastSignedBlockHash()
public
constant
returns (bytes32);
function lastSignedTimestamp()
public
constant
returns (uint256);
}
contract EthereumForkArbiter is
IEthereumForkArbiter,
AccessControlled,
AccessRoles,
Reclaimable
{
string private _nextForkName;
string private _nextForkUrl;
uint256 private _nextForkBlockNumber;
uint256 private _lastSignedBlockNumber;
bytes32 private _lastSignedBlockHash;
uint256 private _lastSignedTimestamp;
function EthereumForkArbiter(IAccessPolicy accessPolicy)
AccessControlled(accessPolicy)
Reclaimable()
public
{
} | 0 |
function transfer(address _to, uint256 _value) onlyUnlocked public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(_value > 0);
uint256 codeLength;
bytes memory empty;
assembly {
codeLength := extcodesize(_to)
}
if(codeLength > 0) {
return transferToContract(_to, _value, empty);
} else {
return transferToAddress(_to, _value, empty);
}
} | 0 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(msg.value != 0);
require(now <= endTime);
uint256 weiAmount = msg.value;
require(calculateUSDcValue(weiAmount) >= minContributionUSDc);
uint256 tokens = calculateTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
} | 1 |
function approve(address _spender, uint256 _amount)public returns (bool success) {
require(_amount == 0 || allowed[msg.sender][_spender] == 0);
require( _spender != 0x0);
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
} | 0 |
function releasableAmount(ERC20Basic token) public view returns (uint256) {
return vestedAmount(token).sub(released[token]);
} | 0 |
function createReserveTokensVault() external onlyOwner {
require(reserveTokensVault == address(0));
uint256 reserveTokens = 600000000;
reserveTokensVault = createTokenVaultInt(reserveTokens);
require(totalSupply_ <= HARD_CAP);
} | 0 |
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
} | 1 |
function setUpgradeAgent(address agent) external {
if(!canUpgrade()) {
throw;
}
if (agent == 0x0) throw;
if (msg.sender != upgradeMaster) throw;
if (getUpgradeState() == UpgradeState.Upgrading) throw;
upgradeAgent = UpgradeAgent(agent);
if(!upgradeAgent.isUpgradeAgent()) throw;
if (upgradeAgent.originalSupply() != totalSupply) throw;
UpgradeAgentSet(upgradeAgent);
} | 0 |
function random() private view returns (uint256) {
return uint256(uint256(keccak256(block.timestamp, block.difficulty))%6);
} | 1 |
function determineCurrentStage() internal {
if (stage < 4 && now >= ICO_START4) {
stage = 4;
IcoStageStarted(4);
} else if (stage < 3 && now >= ICO_START3) {
stage = 3;
IcoStageStarted(3);
} else if (stage < 2 && now >= ICO_START2) {
stage = 2;
IcoStageStarted(2);
} else if (stage < 1 && now >= ICO_START1) {
stage = 1;
IcoStageStarted(1);
}
} | 0 |
function checkGoalReached() public returns (bytes32 response) {
require (isCrowdSaleSetup);
if ((amountRaisedInWei < fundingMinCapInWei) && (block.timestamp <= fundingEndTime && block.timestamp >= fundingStartTime)) {
areFundsReleasedToBeneficiary = false;
isCrowdSaleClosed = false;
return "In progress (Eth < Softcap)";
} else if ((amountRaisedInWei < fundingMinCapInWei) && (block.timestamp < fundingStartTime)) {
areFundsReleasedToBeneficiary = false;
isCrowdSaleClosed = false;
return "Crowdsale is setup";
} else if ((amountRaisedInWei < fundingMinCapInWei) && (block.timestamp > fundingEndTime)) {
areFundsReleasedToBeneficiary = false;
isCrowdSaleClosed = true;
return "Unsuccessful (Eth < Softcap)";
} else if ((amountRaisedInWei >= fundingMinCapInWei) && (tokensRemaining == 0)) {
areFundsReleasedToBeneficiary = true;
isCrowdSaleClosed = true;
return "Successful (RTC >= Hardcap)!";
} else if ((amountRaisedInWei >= fundingMinCapInWei) && (block.timestamp > fundingEndTime) && (tokensRemaining > 0)) {
areFundsReleasedToBeneficiary = true;
isCrowdSaleClosed = true;
return "Successful (Eth >= Softcap)!";
} else if ((amountRaisedInWei >= fundingMinCapInWei) && (tokensRemaining > 0) && (block.timestamp <= fundingEndTime)) {
areFundsReleasedToBeneficiary = true;
isCrowdSaleClosed = false;
return "In progress (Eth >= Softcap)!";
}
} | 0 |
function exchangeTokens(uint16 tokenCode1, uint16 tokenCode2, address addr1, address addr2, address addrFee, uint amount1, uint fee1, uint amount2, uint fee2) external;
}
contract Treasury is AccessModifiers, TreasuryInterface {
uint constant EMERGENCY_RELEASE_CHALLENGE_PERIOD = 2 days;
bool active = false;
mapping (uint16 => address) public tokenContracts;
mapping (uint176 => uint) public tokenAmounts;
event SetActive(bool active);
event ChangeTokenInfo(uint16 tokenCode, address tokenContract);
event StartEmergencyRelease(address account);
event Deposit(uint16 tokenCode, address account, uint amount);
event Withdrawal(uint16 tokenCode, address traderAddr, address withdrawalAddr, uint amount);
event EmergencyRelease(uint16 tokenCode, address account, uint amount);
mapping (address => uint) public emergencyReleaseSince;
constructor () public {
} | 0 |
function ERC20Base( uint initial_balance ) {
_balances[msg.sender] = initial_balance;
_supply = initial_balance;
} | 0 |
function transferTokensTwice(uint16 tokenCode, address fromAddr, address toAddr1, uint amount1, address toAddr2, uint amount2) external
onlyActive() onlyApprovedExchange(fromAddr) {
resetEmergencyRelease(fromAddr);
deductBalance(tokenCode, fromAddr, amount1 + amount2);
addBalance(tokenCode, toAddr1, amount1);
addBalance(tokenCode, toAddr2, amount2);
} | 0 |
function transferFrom(address from, address to, uint tokens) external returns (bool success);
function burn(uint256 _value) external;
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Burn(address indexed burner, uint256 value);
}
contract EzeCrowdsale is Ownable{
using SafeMath for uint256;
TokenInterface public token;
uint256 public startTime;
uint256 public endTime;
uint256 public ratePerWeiInSelfDrop = 60000;
uint256 public ratePerWeiInPrivateSale = 30000;
uint256 public ratePerWeiInPreICO = 20000;
uint256 public ratePerWeiInMainICO = 15000;
uint256 public weiRaised;
uint256 public TOKENS_SOLD;
uint256 maxTokensToSale;
uint256 bonusInSelfDrop = 20;
uint256 bonusInPrivateSale = 10;
uint256 bonusInPreICO = 5;
uint256 bonusInMainICO = 2;
bool isCrowdsalePaused = false;
uint256 totalDurationInDays = 213 days;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
constructor(uint256 _startTime, address _wallet, address _tokenAddress) public
{
require(_startTime >=now);
require(_wallet != 0x0);
startTime = _startTime;
endTime = startTime + totalDurationInDays;
require(endTime >= startTime);
owner = _wallet;
maxTokensToSale = uint(15000000000).mul( 10 ** uint256(18));
token = TokenInterface(_tokenAddress);
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.