function string | label int64 |
|---|---|
function startNextPhase() public onlyOwner _saleNotEnded _contractUp _ifNotEmergencyStop returns(bool){
int8 currentPhaseIndex = getCurrentlyRunningPhase();
require(currentPhaseIndex == 0);
PhaseInfo storage currentlyRunningPhase = phases[uint256(currentPhaseIndex)];
uint256 tokensLeft;
uint256 tokensInPreICO = 72... | 0 |
function setEndsAt(uint time) public onlyOwner {
assert(!finalized);
assert(isUpdatable);
assert(now <= time);
assert(startsAt <= time);
assert(now <= endsAt);
CrowdsaleExt lastTierCntrct = CrowdsaleExt(getLastTier());
if (lastTierCntrct.finalized()) throw;
uint8 tierPosition = getTierPosition(this);
for (uint... | 0 |
function setClosingTime(uint256 _closingTime) onlyOwner public {
require(_closingTime >= block.timestamp);
require(_closingTime >= openingTime);
closingTime = _closingTime;
} | 0 |
function withdrawContributorsTokens(address _to, uint256 _amountWithDecimals)
public
onlyOwner
{
require(transferFrom(contributorsAllocation, _to, _amountWithDecimals));
} | 0 |
function setMinimumWeiAmount(uint256 newMinimumWeiAmount) onlyOwner public returns (bool) {
require(newMinimumWeiAmount > 0);
minimumWeiAmount = newMinimumWeiAmount;
return true;
} | 0 |
function getLostAndFoundMaster() internal view returns(address) {
return lost_and_found_master;
} | 0 |
function nameFor(address addr) returns (bytes32 name) {
return nameRegistry[addr];
} | 0 |
modifier withGasPriceLimit(uint256 _gasPriceLimit) {
require(tx.gasprice <= _gasPriceLimit, "gas price too high");
_;
} | 0 |
function close() onlyOwner {
require(state == State.Active);
state = State.Closed;
Closed();
wallet.transfer(this.balance);
} | 0 |
function setTime(uint _time) public onlyOwner{
current_time = _time;
} | 0 |
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
}
library SafeMath {
function sub(uint256 a, u... | 0 |
modifier updateDividends()
{
if(now - lastDividendsFetched > DIVIDEND_FETCH_TIME && totalSupply > 0) {
fetchDividendsFromP3X();
}
_;
} | 0 |
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet, address _token) public {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != address(0));
token = ERC20(_token);
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wal... | 0 |
function addOwnerFromRecovery(address sender, Proxy identity, address newOwner) public
onlyAuthorized
onlyRecovery(identity, sender)
rateLimited(identity, sender)
{
require(!isOwner(identity, newOwner));
owners[identity][newOwner] = now;
LogOwnerAdded(identity, newOwner, sender);
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, ad... | 0 |
function totalSupply()public view returns (uint total_Supply);
function balanceOf(address who)public view returns (uint256);
function allowance(address owner, address spender)public view returns (uint);
function transferFrom(address from, address to, uint value)public returns (bool ok);
function approve(address spe... | 0 |
function setUpgradeMaster(address new_master) private {
require(new_master != 0x0);
upgradeMaster = new_master;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transferFrom(_from, _to, _value);
} | 0 |
function approve(address _spender, uint256 _value) external returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
} | 1 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 valu... | 0 |
function signedTransferCheck(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedTransfer(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success... | 0 |
function sellEggs() public{
require(initialized);
uint256 hasEggs=getMyEggs();
uint256 eggValue=calculateEggSell(hasEggs);
uint256 fee=devFee(eggValue);
claimedEggs[msg.sender]=0;
lastHatch[msg.sender]=now;
marketEggs=SafeMath.add(marketEggs,hasEggs);
ceoAddress.transfer(fee);
msg.sender.transfer(SafeMath.sub(... | 0 |
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FractionalERC20 is ERC20 {
uint public decimals;
}
contract Crowdsale is Haltable {
using Safe... | 0 |
function getRunDetails(uint _heroId) external view returns (
uint _heroPower,
uint _heroStrength,
uint _heroInitialHealth,
uint _heroHealth,
uint _monsterCreationTime,
uint _monsterLevel,
uint _monsterInitialHealth,
uint _monsterHealth,
uint _gameState
) {
uint genes;
address owner;
(,,, genes, owner,,) = ... | 0 |
function signedApproveAndCallCheck(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result) {
return data.signedApproveAndCallCheck(tokenOwner, spender, tokens, _data, fee, nonce, sig, feeAccount);
} | 0 |
function marketWithdrawBid(uint256 tokenId) external returns(bool){
require (_exists(tokenId));
require (_tokenOwner[tokenId] != msg.sender);
bidInfo storage existingBid = marketBidInfoByIndex[tokenId];
require (existingBid.hasBid);
require (existingBid.bidder == msg.sender);
uint256 amount = existingBid.value;
... | 0 |
constructor (string memory name, string memory symbol, uint8 decimals, uint256 supply, address treasury, uint256 initialUnlocked, uint256 monthlyUnlocked) public
ERC20Detailed(name, symbol, decimals)
{
_mint(treasury, supply);
require(initialUnlocked <= totalSupply(), "initialUnlocked too large");
require(monthlyU... | 0 |
function mint(address to, uint256 value) public onlyMinter returns (bool) {
_mint(to, value);
emit Mint(msg.sender, to, value);
return true;
} | 0 |
function payAltCoin(bytes32 _tradeID, address _seller, address _buyer, uint256 _value, uint256 _commission, bytes _sign)
external
{
bytes32 _hashDeal = keccak256(_tradeID, _seller, _buyer, _value, _commission);
verifyDeal(_hashDeal, _sign);
bool result = streamityContractAddress.transferFrom(msg.sender, address(th... | 0 |
function updateTokensPerEthOnce(uint _newValue) public onlyOwner canBeCalledOnce("updateTokensPerEth") {
defaultTokensPerWei = _newValue;
recalcBonuses();
} | 0 |
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[... | 0 |
function balanceOf(address tokenowner) public constant returns (uint);
function allowance(address tokenowner, address spender) public constant returns (uint);
function transfer(address to, uint tokencount) public returns (bool success);
function approve(address spender, uint tokencount) public returns (bool success)... | 0 |
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);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256)... | 0 |
function finalize() public inState(State.Success) onlyOwner stopInEmergency {
finalizeAgent.finalizeCrowdsale(token);
finalized = true;
Finalized();
} | 0 |
function _getTokenAmount(uint256 _weiAmount)
internal view returns (uint256)
{
return _weiAmount.mul(rate);
} | 0 |
function buyTokens() public payable whenNotPaused {
require(validPurchase());
uint256 tokens = 0;
uint256 amountPaid = calculateExcessBalance();
if(tokensRaised < limitTier1) {
tokens = amountPaid.mul(rate);
if(tokensRaised.add(tokens) > limitTier1)
tokens = calculateExcessTokens(amountPaid, limitTier1, 1, rate)... | 0 |
function normalizeShiftAmount(uint256 shift) internal pure returns (uint256)
{
require(shift >= 0 && shift <= 2, "You can't set more than 2 decimal places");
uint256 value = 100;
return value.mul(10 ** shift);
} | 0 |
function changeOwner(address newOwner) onlyOwner public {
require(newOwner != address(0));
require(newOwner != owner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
} | 0 |
function init(Data storage self, address owner, string symbol, string name, uint8 decimals, uint initialSupply, bool mintable, bool transferable) public {
require(!self.initialised);
self.initialised = true;
self.owner = owner;
self.symbol = symbol;
self.name = name;
self.decimals = decimals;
if (initialSupply >... | 0 |
function transform() public {
TransformState state = getTransformState();
require(state == TransformState.ReadyToTransform || state == TransformState.Transforming);
uint tokens = balances[msg.sender];
uint investments = funds[msg.sender];
require(tokens > 0);
balances[msg.sender] = 0;
funds[msg.sender] = 0;
tot... | 0 |
modifier onlyBefore() {
if (now > icoEndtime) {
revert();
}
_;
} | 1 |
function GStarToken() public {
owner = msg.sender;
totalSupply_ = INITIAL_SUPPLY;
balances[owner] = INITIAL_SUPPLY;
currentTotalSupply = INITIAL_SUPPLY;
emit Transfer(address(0), owner, INITIAL_SUPPLY);
} | 0 |
function tokenFallback(address from, uint256 value, bytes) public {
require(msg.sender == auctusTokenAddress);
escrowedTokens = escrowedTokens.add(value);
emit Escrow(from, value);
} | 1 |
function Destructible() public payable { }
function destroy() onlyOwner public {
selfdestruct(owner);
} | 0 |
function getBonus() public view returns(uint256){
uint256 invested = getInvested();
if(invested >= 0.5 ether && 4 ether >= invested){
return 0;
}else if(invested >= 4.01 ether && 7 ether >= invested){
return 20;
}else if(invested >= 7.01 ether && 10 ether >= invested){
return 40;
}else if(invested >= 10.01 ethe... | 0 |
function attack(uint _heroId) whenNotPaused onlyHumanAddress external payable {
uint genes;
address owner;
(,,, genes, owner,,) = edCoreContract.getHeroDetails(_heroId);
require(msg.sender == owner);
uint heroInitialHealth = (genes / (32 ** 12)) % 32 + 1;
uint heroStrength = (genes / (32 ** 8)) % 32 + 1;
Monster... | 0 |
function increaseAllowance(address spender, uint addedValue) public whenNotPaused returns (bool success) {
return super.increaseAllowance(spender, addedValue);
} | 0 |
modifier onlyPayloadSize(uint numwords) {
assert(msg.data.length >= numwords * 32 + 4);
_;
} | 0 |
function startEmergencyRelease() external {
emergencyReleaseSince[msg.sender] = block.timestamp + EMERGENCY_RELEASE_CHALLENGE_PERIOD;
emit StartEmergencyRelease(msg.sender);
} | 0 |
function timelockAccount(address target, uint releasetime) public onlyOwner {
uint r_time;
r_time = now + (releasetime * 1 days);
timelockAccounts[target] = r_time;
emit TimeLockFunds(target, r_time);
} | 0 |
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender)
external view returns (uint256);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexe... | 0 |
function BioCoin(address _owner) UpgradeableToken(_owner) {
name = "BioCoin";
symbol = "BIOCOIN";
totalSupply = 1000000000000000000000000000;
decimals = 18;
balances[_owner] = totalSupply;
} | 0 |
function pause() onlyOwner whenNotPaused public returns (bool) {
paused = true;
emit Pause();
return true;
} | 0 |
function balanceOf(address who) constant returns(uint256);
function transfer(address to, uint value) returns(bool ok);
function transferFrom(address from, address to, uint value) returns(bool ok);
function approve(address spender, uint value) returns(bool ok);
function allowance(address owner, address spender) cons... | 0 |
function approve(address _spender, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function () {
throw;
} | 0 |
function symbol() constant returns (string) {
return _symbol;
} | 0 |
function isSane(CrowdsaleToken token) public constant returns (bool) {
return token.mintAgents(address(this)) && token.releaseAgent() == address(this);
} | 0 |
constructor(ERC20Interface _addressOfTokenUsedAsReward) public {
tokenReward = _addressOfTokenUsedAsReward;
owner = 0x7a3a57c620fA468b304b5d1826CDcDe28E2b2b98;
beneficiary = 0x8605409D35f707714A83410BE9C8025dcefa9faC;
emit LogFundingInitialized(owner);
} | 0 |
function totalSupply() external constant returns (uint);
function balanceOf(address tokenOwner) external constant returns (uint balance);
function allowance(address tokenOwner, address spender) external constant returns (uint remaining);
function transfer(address to, uint tokens) external returns (bool success);
fu... | 0 |
function isContract(address _addr) view internal returns (bool) {
uint256 length;
if (_addr == address(0x0)) return false;
assembly {
length := extcodesize(_addr)
}
if(length > 0) {
return true;
} else {
return false;
}
} | 0 |
function approve(address _spender, uint256 _value) public returns (bool success);
}
contract ERC20Token is IERC20Token, SafeMath {
string public standard = 'Token 0.1';
string public name = 'DEBIT Coin Token';
string public symbol = 'DBC';
uint8 public decimals = 8;
uint256 public totalSupply = 0;
mapping (addres... | 0 |
function emergencyRestart() external onlyOwner _contractUp {
require(ifEmergencyStop);
ifEmergencyStop = false;
emit SaleRestarted(msg.sender, now);
} | 0 |
function mul(uint256 _a, uint256 _b) internal pure returns (uint256) {
if (_a == 0) {
return 0;
}
uint256 c = _a * _b;
assert(c / _a == _b);
return c;
} | 0 |
function reclaimToken(ERC20Basic _token) external onlyOwner {
uint256 balance = _token.balanceOf(this);
_token.safeTransfer(owner, balance);
} | 0 |
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _com = (_pot / 50);
uint256 _... | 0 |
function balanceOf(address who) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
}
library SafeMath {
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <=... | 0 |
modifier isNotTimeLockedFrom( address _from ) {
require( now >= timelockedAccounts[_from] && now >= timelockedAccounts[msg.sender]);
_;
} | 0 |
function allowance(address _owner, address _spender) constant returns (uint256 remaining){
return approved[_owner][_spender];
} | 0 |
function transferFrom(address _from, address _to, uint _value) canTransfer(_from, _value) public returns (bool success) {
require(_from != address(0));
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][m... | 0 |
function receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract BTTSTokenInterface is ERC20Interface {
uint public constant bttsVersion = 110;
bytes public constant signingPrefix = "\x19Ethereum Signed Message:\n32";
bytes4 public constant signedTransferSig = "\x75\x32\xea\xac";
... | 0 |
function mintBadge(address _owner, uint256 _amount) returns (bool success);
function registerDao(address _dao) returns (bool success);
function registerSeller(address _tokensales) returns (bool success);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event SendBadge(address indexed _fro... | 0 |
function canPegBeDecreased() external view returns(bool) {
return (daiContract.balanceOf(address(this)) <= address(this).balance.mul(etherPeg).div(50) && (now > pegMoveReadyTime));
} | 0 |
function approve(address _spender, uint256 _value) public returns (bool);
function allowance(address _owner, address _spender) public view returns (uint256);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}... | 0 |
function setAssetProxy(AssetProxyInterface _assetProxy) onlyRole('admin') returns(bool) {
require(address(assetProxy) == 0x0);
require(address(vesting) != 0x0);
assetProxy = _assetProxy;
assetProxy.approve(vesting, ((2 ** 256) - 1));
return true;
} | 0 |
function setTokenCountFromPreIco(uint256 value) public;
}
contract Crowdsale is Ownable {
using SafeMath for uint256;
CryptoRoboticsToken public token;
ICOContract ico;
address public wallet;
uint256 public weiRaised;
uint256 public openingTime;
uint256 public closingTime;
bool public isFinalized = false;
uint... | 0 |
function time() public view returns (uint) {
return block.timestamp;
} | 0 |
function createTokenContract() internal returns (MintableToken) {
return new BlockbidMintableToken();
} | 0 |
function decimals()external view returns (uint8);
}
contract Vault is Ownable {
using SafeMath for uint256;
mapping (address => uint256) public deposited;
address public wallet;
event Withdrawn(address _wallet);
function Vault(address _wallet) public {
require(_wallet != address(0));
wallet = _wallet;
} | 0 |
function changeFounderMultiSigAddress(address _newFounderMultiSigAddress) onlyFounders nonZeroAddress(_newFounderMultiSigAddress) {
founderMultiSigAddress = _newFounderMultiSigAddress;
ChangeFoundersWalletAddress(now, founderMultiSigAddress);
} | 1 |
function sellEggs() public{
require(initialized);
uint256 hasEggs = getMyEggs();
uint256 eggValue = calculateEggSell(hasEggs);
uint256 fee = devFee(eggValue);
claimedEggs[msg.sender] = 0;
lastHatch[msg.sender] = now;
marketEggs = SafeMath.add(marketEggs, hasEggs);
ceoAddress.transfer(fee);
msg.sender.transfer(... | 0 |
modifier onlyPauser() {
require(isPauser(msg.sender));
_;
} | 0 |
constructor() public {
manager = msg.sender;
nextWithdrawDayFoundation = now;
nextWithdrawDayCommunity = now;
nextWithdrawDayTeam = now;
} | 0 |
function validPurchase() internal constant returns(bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value > 0;
bool withinTokenLimit = tokensRaised < maxTokensRaised;
bool minimumPurchase = msg.value >= minPurchase;
return withinPeriod && nonZeroPurchase && withinTokenLimi... | 0 |
function approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
} | 0 |
constructor() public {
lock = now;
emit SetLock(0, now);
} | 0 |
modifier onlyOwnerOf(uint256 _tokenId) {
require(ownerOf(_tokenId) == msg.sender);
_;
} | 0 |
function add(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
} | 0 |
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all... | 0 |
function buy() public payable {
require(!requireCustomerId);
investInternal(msg.sender, 0);
} | 0 |
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FractionalERC20 is ERC20 {
uint public decimals;
}
contract Crowdsale is Haltable {
uint public MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE = 5;
using SafeMathLib for... | 0 |
function endSale() onlyManager public
{
require(saleTime == true);
saleTime = false;
uint time = now;
endSaleTime = time;
for(uint i = 1; i <= teamVestingTime; i++)
{
teamVestingTimeAtSupply[i] = teamVestingTimeAtSupply[i].add(teamVestingSupplyPerTime);
}
for(uint i = 1; i <= advisorVestingTime; i++)
{
advi... | 0 |
function bonuscalpre() private returns (uint256 cp)
{
uint bon = 8;
bonusCalculationFactor = (block.timestamp.sub(pre_startdate)).div(604800);
if(bonusCalculationFactor == 0)
{
bon = 8;
}
else{
bon -= bonusCalculationFactor* 8;
}
return bon;
} | 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);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (add... | 0 |
function isCrowdsale() public pure returns (bool) {
return true;
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool) {
bytes memory empty;
return transfer(_to, _value, empty);
} | 0 |
function relayReceiveApproval(address _caller, address _spender, uint256 _amount, bytes _extraData) returns (bool success);
}
contract TokenBase is Owned {
bytes32 public standard = 'Token 0.1';
bytes32 public name;
bytes32 public symbol;
uint256 public totalSupply;
bool public allowTransactions;
event Approval(a... | 0 |
function finishMinting() public onlyMasterOwner canMint returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
} | 0 |
function approve(address _spender, uint256 _value) public returns (bool _succes);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is ERC20, SafeMath {
mapping (address => uint256) pu... | 0 |
function transfer(address _to, uint256 _value) public erc20Allowed returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(_airdropUnlocked(_to));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to... | 0 |
constructor() public {
daysOnline = block.timestamp;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.