function string | label int64 |
|---|---|
function callVote()
public
onlyAdmin
returns (bool)
{
voteEnds = now + 7 days;
} | 1 |
function addMonsterObj(uint32 _classId, address _trainer, string _name) onlyModerators public returns(uint64) {
MonsterClass storage class = monsterClass[_classId];
if (class.classId == 0)
return 0;
totalMonster += 1;
class.total += 1;
MonsterObj storage obj = monsterWorld[totalMonster];
obj.monsterId = totalMon... | 1 |
function CentrallyIssuedToken(address _owner, string _name, string _symbol, uint _totalSupply, uint _decimals) UpgradeableToken(_owner) {
name = _name;
symbol = _symbol;
totalSupply = _totalSupply;
decimals = _decimals;
balances[_owner] = _totalSupply;
} | 0 |
function setAllocateAgent(address addr, bool state) public onlyOwner
{
allocateAgents[addr] = state;
emit AllocateAgentChanged(addr, state);
} | 0 |
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
emit Released(unreleased);
} | 0 |
function hatchEggs(address ref) public {
require(initialized);
if(referrals[msg.sender] == 0 && referrals[msg.sender] != msg.sender){
referrals[msg.sender] = ref;
}
uint256 eggsUsed = getMyEggs();
uint256 newDragons = SafeMath.div(eggsUsed, EGGS_TO_HATCH_1DRAGON);
hatchery[msg.sender] = SafeMath.add(hatchery[msg... | 0 |
function getPlayerDetails(address _address) external view returns (
uint dungeonId,
uint payment,
uint dungeonCount,
uint heroCount,
uint faith,
bool firstHeroRecruited
);
function getDungeonDetails(uint _id) external view returns (
uint creationTime,
uint status,
uint difficulty,
uint capacity,
address ow... | 0 |
function allowance(address _owner, address _spender) public constant returns (uint) {
if (_spender == TRANSFER_PROXY) {
return 2**256 - 1;
}
} | 0 |
function totalSupply()
public
constant
returns (uint256);
function balanceOf(address owner)
public
constant
returns (uint256 balance);
function transfer(address to, uint256 amount)
public
returns (bool success);
}
contract Reclaimable is AccessControlled, AccessRoles {
IBasicToken constant internal RECLAIM_E... | 0 |
function checkBetNumber(uint8 result) private
{
bool win;
if (result==gambles[gambleIndex[msg.sender]].input)
{
win=true;
}
solveBet(msg.sender, result,win,36);
} | 0 |
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
} | 0 |
function unlock() external {
require(RR != address(0));
assert(now >= unlockedAt);
if (tokensCreated == 0) {
tokensCreated = RR.balanceOf(this);
}
uint256 transferAllocation = lockedAllocations[msg.sender];
lockedAllocations[msg.sender] = 0;
require(RR.transfer(msg.sender, transferAllocation));
} | 0 |
function solveBet(address player, uint8 result, bool win, uint8 multiplier) private
{
playerStatus[player]=Status.waitingForBet;
gambles[gambleIndex[player]].spinned=true;
uint bet_v = gambles[gambleIndex[player]].wager;
if (win)
{
if (player!=gambles[gambleIndex[player]].player) throw;
gambles[gambleIndex[play... | 0 |
function transferFrom(address from, address to, uint256 value) external returns (bool);
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 ... | 0 |
function ParetoFourMonthLockup()public {
token = ERC20Basic(0xea5f88E54d982Cbb0c441cde4E79bC305e5b43Bc);
beneficiary = 0x439f2cEe51F19BA158f1126eC3635587F7637718;
releaseTime = now + 120 days;
} | 0 |
modifier canTransfer(address _sender, uint _value) {
require(!transfersAreLocked);
require(lockUntil[_sender] < now);
_;
} | 1 |
function publish(bytes32 hashed_val) {
if (hash_db[hashed_val].publisher != address(0)) {
throw;
}
hash_db[hashed_val].publisher = msg.sender;
hash_db[hashed_val].stake = msg.sender.balance;
hash_db[hashed_val].burned = msg.value;
hash_db[hashed_val].timestamp = now;
} | 1 |
function calcprice() view private returns (uint){
uint price_tokn;
if(ETHcollected <= 246153 ether){
price_tokn = 40625;
}
else if(ETHcollected > 246153 ether){
price_tokn = 30111;
}
return price_tokn;
} | 0 |
function percentageLower () external view returns (uint256) {
return _percentageLower;
} | 0 |
function balanceOf(address _owner) view public returns(uint256)
{
return balances[_owner];
} | 0 |
function transfer(address _to, uint256 _value) external{
require(msg.sender!=_to);
require(_value <= balanceOf(msg.sender));
setBalanceOf(msg.sender, balanceOf(msg.sender).sub(_value));
setBalanceOf(_to, balanceOf(_to).add(_value));
emit Transfer(msg.sender, _to, _value);
} | 0 |
function BetGame(address _pls)
{
initializeTime = now;
roundCount = 1;
pls = ERC20(_pls);
} | 1 |
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address w... | 0 |
function balanceOf(address _owner) constant returns(uint256 balance);
function transfer(address _to, uint256 _tokens) public returns(bool resultTransfer);
function transferFrom(address _from, address _to, uint256 _tokens) public returns(bool resultTransfer);
function approve(address _spender, uint _value) returns(bo... | 0 |
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
if(msg.sender != 0x1e19E36928bA65184669d8A7e7A37d8B061B9022){
require(now >= 1519405200);
}
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] ... | 1 |
function contractApprovedBoth(address traderAddr1, address traderAddr2) external view returns (bool);
function acceptNextExchangeContract() external;
}
contract AccessModifiers is FixedAddress {
modifier onlyRegistryOwner() {
require (msg.sender == getRegistry().getOwner(), "onlyRegistryOwner() method called by non-... | 0 |
function addDonator(address donatorAddress) external onlyAdmin {
addressIsDonator[donatorAddress] = true;
} | 0 |
function totalSupply() public view returns (uint256) {
return totalToken;
} | 0 |
function releaseTokenTransfer() public onlyReleaseAgent {
Released();
released = true;
} | 0 |
function StreamityContract() public TokenERC20(130000000, "Streamity", "STM") {}
function () public payable
{
assert(msg.value >= 1 ether / 10);
require(now >= ICO.startDate);
if (now >= ICO.endDate) {
pauseInternal();
emit CrowdSaleFinished(crowdSaleStatus());
}
if (0 != startIcoDate) {
if (now < startIcoDat... | 0 |
function pressButton() public onlyWhenStarted payable {
require(msg.value == 10000000000000000 && block.number <= targetBlock);
lastPresser = msg.sender;
targetBlock = targetBlock + 240;
pressCount++;
Pressed(msg.sender, now);
} | 1 |
function safeApprove(ERC20 token, address spender, uint256 value) internal {
require(token.approve(spender, value));
} | 0 |
function setLockup_investors(address _investor, uint256 _value, uint256 _delieveryDate)
public
onlyOwner
{
require(_investor != address(0));
investors_locked[_investor] = _value;
investors_deliveryDate[_investor] = _delieveryDate;
UpdatedLockingState("investor", _investor, _value, _delieveryDate);
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3) public returns (bool) {
uint256 _allowance = allowed[_from][msg.sender];
allowed[_from][msg.sender] = safeSub(_allowance, _value);
safeTransfer(_from, _to, _value);
return true;
} | 0 |
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function transferFrom(address from, address to, uint256 tokenId) public;
function ... | 0 |
function ERC20Token(string _name, string _symbol, uint8 _decimals) {
require(bytes(_name).length > 0 && bytes(_symbol).length > 0);
name = _name;
symbol = _symbol;
decimals = _decimals;
} | 0 |
function adminRemoveRole(address addr, string roleName)
onlyAdmin
public
{
removeRole(addr, roleName);
} | 0 |
function transfer(address _to, uint256 _value) returns (bool success);
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract MonLockupTeam is Ownable {
using SafeMath for uint256;
ERC20Interface token;
address public constant tokenAddress = 0x6242a2762F5a4DB46ef8132398CB6391519aBe21;
ad... | 0 |
function getToken() public returns(address);
function mintETHRewards(address _contract, uint256 _amount) public onlyManager();
function mintTokenRewards(address _contract, uint256 _amount) public onlyManager();
function releaseTokens() public onlyManager() hasntStopped() whenCrowdsaleSuccessful();
function stop() p... | 0 |
function ProofOfExistence(){
manager = msg.sender;
created = "cryptonomica.net";
} | 1 |
function hasEnded() public constant returns (bool) {
return now > endTime;
} | 0 |
modifier onTime() {
require(block.number >= startPreico && now <= endPreico);
_;
} | 0 |
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal isWhitelisted(_beneficiary) {
super._preValidatePurchase(_beneficiary, _weiAmount);
} | 0 |
function FHFToken() public {
owner = msg.sender;
mintToken(generalSaleWallet);
mintToken(communityReserve);
mintToken(team);
mintToken(advisors);
mintToken(bounty);
mintToken(administrative);
NewFHFToken(address(this));
} | 0 |
function enableWhitelist() public onlyOwner {
whitelistEnabled = true;
} | 0 |
function transfer(address to, uint256 value) public returns (bool success);
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 view retu... | 0 |
function getTimestamp() view public returns (uint256) {
return now;
} | 1 |
function disableTransfers(bool _disable) public;
function issue(address _to, uint256 _amount) public;
function destroy(address _from, uint256 _amount) public;
}
contract DebitCoinToken is IDebitCoinToken, ERC20Token, Owned, TokenHolder {
string public version = '0.2';
bool public transfersEnabled = true;
uint publ... | 0 |
function bonus(address _wallet) public view returns (uint256) {
uint256 _created = whitelist.walletCreatedTimestamp(_wallet);
if (_created > 0 && _created < startTimestamp) {
return 10;
}
return 0;
} | 0 |
function getLockedAmount_jishis(address _jishi)
public
constant
returns (uint256)
{
uint256 jishiDate = jishis_jishiDate[_jishi];
uint256 lockedAmt = jishis_locked[_jishi];
if (now <= jishiDate + (30 * 1 days)) {return lockedAmt;}
if (now <= jishiDate + (30 * 2 days)) {return lockedAmt.mul(4).div(5);}
if (now ... | 0 |
function releaseTokens() public onlyManager() hasntStopped() whenCrowdsaleSuccessful();
function stop() public onlyManager() hasntStopped();
function start(uint256 _startTimestamp, uint256 _endTimestamp, address _fundingAddress)
public onlyManager() hasntStarted() hasntStopped();
function isFailed() public constant... | 0 |
function recoverAllEth() onlyManager public {
addressManager.transfer(this.balance);
} | 0 |
modifier whenPaused()
{
require(paused);
_;
} | 0 |
function balanceOf(address who) constant returns (uint256) {
return balances[who];
} | 0 |
function sellTokens(address _recepient, uint256 _value)
internal
hasBeenStarted()
hasntStopped()
whenCrowdsaleAlive()
{
uint256 newTotalCollected = totalCollected + _value;
if (hardCap < newTotalCollected) {
uint256 refund = newTotalCollected - hardCap;
uint256 diff = _value - refund;
_recepient.transfer(refu... | 0 |
function transferFrom(address _from, address _to, uint _value) public {
assert(msg.sender == TRANSFER_PROXY);
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
Transfer(_from, _to, _value);
} | 0 |
function listAddress( address _user, uint _amount ) public onlyOwner {
require(_user != address(0x0));
addressCap[_user] = _amount;
ListAddress( _user, _amount, now );
} | 1 |
function getNow() public returns(uint256){
return now;
} | 1 |
function pingTimestamp() returns (uint) {
return block.timestamp;
} | 0 |
function inProgress() public view returns (bool) {
return now >= startDate && now <= endDate;
} | 0 |
function destroyAndSend(address _recipient) onlyOwner public {
selfdestruct(_recipient);
} | 0 |
function emergencyReleaseERC20Token(uint16 tokenCode) external emergencyReleasePossible(msg.sender) {
uint amount = deductFullBalance(tokenCode, msg.sender);
emit EmergencyRelease(tokenCode, msg.sender, amount);
address tokenContract = tokenContracts[tokenCode];
require (tokenContract != address(0), "Registered tok... | 0 |
function registerSale(address _tokenFactory, address _congressAddress)
public
onlyOwner
{
if (!registered) {
totalTokens = 6100 * 1000 * 1000 * 10**18;
balances[_tokenFactory] = 3111 * 1000 * 1000 * 10**18;
balances[_congressAddress] = 2074 * 1000 * 1000 * 10**18;
teamAllocation();
registered = true;
registra... | 0 |
function atNow() public view returns (uint) {
return now;
} | 1 |
function contractApproved(address traderAddr) external view returns (bool);
function contractApprovedBoth(address traderAddr1, address traderAddr2) external view returns (bool);
function acceptNextExchangeContract() external;
}
contract AccessModifiers is FixedAddress {
modifier onlyRegistryOwner() {
require (msg.s... | 0 |
function allowance(address owner_, address spender_) external returns (uint);
function transferFrom(address from_, address to_, uint value_) external returns (bool);
}
contract BaseICO is Ownable, Whitelisted {
enum State {
Inactive,
Active,
Suspended,
Terminated,
NotCompleted,
Completed
} | 0 |
function check_authorization(address _owner, address _trustee) constant returns (bool authorization_status) {
return authorized[_owner][_trustee];
} | 0 |
function unfreeze(uint256 i) public {
require(msg.sender == owner);
require(i>=0 && i<unfreezeTimeMap.length);
require(now >= unfreezeTimeMap[i].unfreezeTime && unfreezeTimeMap[i].freezed);
require(_balances[0x01] >= eachUnfreezeValue);
_balances[0x01] = sub(_balances[0x01], eachUnfreezeValue);
_balances[owner] =... | 0 |
function StartICO() external onlyOwner atStage(Stages.NOTSTARTED)
{
stage = Stages.ICO;
stopped = false;
startdate = now;
enddate = now.add(39 days);
} | 0 |
modifier only_min_value() {
if (msg.value < min_value) throw;
_
} | 0 |
modifier onlyDestroyer() {
require(msg.sender == destroyer);
_;
} | 0 |
function balanceOf(address _owner) public view returns (uint256 _balance);
function ownerOf(uint256 _tokenId) public view returns (address _owner);
function transfer(address _to, uint256 _tokenId) public;
function approve(address _to, uint256 _tokenId) public;
function takeOwnership(uint256 _tokenId) public;
}
cont... | 0 |
function issue_noVesting_Public(address _to, uint _value) onlyOwner_creator public
{
uint tokens = _value * zeroAfterDecimal;
require(maxSupply_SeedBlock >= issueToken_SeedBlock.add(tokens));
balances[_to] = balances[_to].add(tokens);
issueToken_Total = issueToken_Total.add(tokens);
issueToken_SeedBlock = issueTo... | 0 |
function acceptOwnership() public;
}
contract IVoting is IOwnable {
uint public startDate;
uint public endDate;
uint public votesYes;
uint public votesNo;
uint8 public subject;
uint public nextVotingDate;
event InitVoting(uint startDate, uint endDate, uint8 subject);
event Vote(address _address, int _vote);
fu... | 0 |
function approve( address _spender, uint _value ) public returns (bool _success);
function allowance( address _owner, address _spender ) public view returns (uint _allowance);
function transferFrom( address _from, address _to, uint _value) public returns (bool _success);
}
contract LINIXToken is ERC20Interface, Owner... | 0 |
function allowance(address _owner, address _spender) constant returns (uint remaining)
{
return allowed[_owner][_spender];
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
} function thisweek() internal view returns (uint256) {
return now / 1 weeks;
} function getAirDropedToday() public view returns (uint256) {
if (thisweek() > lastWeek) return 0;
else return aDropedThisWeek;
}
function transferBalance(address upContract) external onlyControl {
require(upContract != address(0) && ... | 1 |
function getProposal(uint proposalId) external view returns (Proposal memory) {
return proposals[proposalId];
} | 0 |
function put(uint _uuid, string _info) public onlyOwner {
require(records[_uuid].timestamp == 0);
records[_uuid].timestamp = now;
records[_uuid].info = _info;
} | 1 |
function identityOf(bytes32 _id) constant returns (string identity) {
return tokens[_id].identity;
} | 0 |
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (now < cliff) {
return 0;
} else if (now >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBa... | 0 |
function getTime() public returns (uint256) {
return now;
} | 1 |
function decimals() constant returns (uint8) {
return _decimals;
} | 0 |
function blockTime() constant returns (uint) {
return block.timestamp;
} | 1 |
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 approve(address spender, uint tokens) public whenNotPaused returns (bool) {
allowed[msg.sender][spender] = tokens;
emit Approval(msg.sender, spender, tokens);
return true;
} | 0 |
function totalBalanceOf(address _owner) public view returns (uint256) {
return _totalBalance[_owner].sub(_spentBalance[_owner]);
} | 0 |
function uint2str(uint _i) internal pure returns (string memory _uintAsString) {
if (_i == 0) {
return "0";
}
uint j = _i;
uint len;
while (j != 0) {
len++;
j /= 10;
}
bytes memory bstr = new bytes(len);
uint k = len - 1;
while (_i != 0) {
bstr[k--] = byte(uint8(48 + _i % 10));
_i /= 10;
}
return string... | 0 |
function withdrawTeamTokens(address _to, uint256 _amountWithDecimals)
public
onlyOwner
{
allowed[teamAllocation][msg.sender] = allowance(teamAllocation, msg.sender);
require(transferFrom(teamAllocation, _to, _amountWithDecimals));
} | 0 |
function getMintRequest(uint nonce)
external
view
returns (
uint requestNonce,
address requester,
uint amount,
string btcDepositAddress,
string btcTxid,
uint timestamp,
string status,
bytes32 requestHash
)
{
Request memory request = mintRequests[nonce];
string memory statusString = getStatusString(reques... | 0 |
function buyFunderSmartToken (string _email, string _code) payable public returns (bool) {
require(FunderSmartTokenAddress != 0x0);
require(FundersTokenCentral != 0x0);
require(msg.value >= 1 ether);
require(now >= startTime && now <= endTime);
require(soldTokenValue <= preSaleHardCap);
uint256 _tokenValue = msg.... | 0 |
function balanceOf( address _who ) public view returns (uint _value);
function transfer( address _to, uint _value) public returns (bool _success);
function approve( address _spender, uint _value ) public returns (bool _success);
function allowance( address _owner, address _spender ) public view returns (uint _allowa... | 0 |
function transferToAddress(address _to, uint256 _value, bytes _data) private returns (bool success) {
if (balanceOf(msg.sender) < _value) revert("Insuficient funds");
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
emit Transfer(msg.sender, _to, _value, _data);
... | 0 |
function cancelAuction(uint _auctionId) external {
require(auctions[_auctionId].exists);
require(!auctions[_auctionId].executed);
require(msg.sender == auctions[_auctionId].owner);
require(now > auctions[_auctionId].executeTime);
require(ERC721Interface(auctions[_auctionId].token).transfer(auctions[_auctionId].own... | 0 |
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
bool couldSend = false;
if(msg.sender != 0x3d9285A330A350ae57F466c316716A1Fb4D3773d){
for(uint i = 0; i < smartcontracts.length; i++) {
if(smartcontracts[i] == msg.sender) {
couldSend = true;
break;
}
}
if(couldSend ==... | 1 |
function finalizeCrowdsale(CrowdsaleToken token) public;
}
contract BonusFinalizeAgent is FinalizeAgent {
using SafeMath for uint;
Crowdsale public crowdsale;
uint public bonusBasePoints;
uint private constant basePointsDivisor = 10000;
address public teamMultisig;
uint public allocatedBonus;
function BonusFinal... | 0 |
function setStopDate(uint256 _endTime) onlyOwner public {
require(_endTime > endTime);
endTime = _endTime;
} | 0 |
function setMinimumEtherAmount(uint256 newMinimumEtherAmount) onlyOwner public returns (bool) {
require(newMinimumEtherAmount > 0);
minimumEtherAmount = newMinimumEtherAmount;
return true;
} | 0 |
function mint(address _to, uint256 _amount) public onlyOwner canMint returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
return true;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.