function string | label int64 |
|---|---|
function ownerSetFounderLock(address _address, uint256 _value, uint _round, uint256 _period) public onlyOwner{
require(_value <= unsetCoin);
setFounderLock( _address, _value, _round, _period);
unsetCoin = SafeMath.safeSub(unsetCoin, _value);
} | 0 |
function revokeAndPublish(address genesis, bytes32 key, bytes32 data, address newManager) public {
publish(genesis, key, data);
Revocation(genesis, manager[genesis], newManager, now);
manager[genesis] = newManager;
} | 0 |
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);
event Approval(
address indexed owner,
address indexed spender,
u... | 0 |
function signedTransferHash(address tokenOwner, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedTransferCheck(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedTra... | 0 |
function setApproved(address addr, uint256 amount) onlyOwnerUnlocked setter {
activateCurrency(addr);
approved[addr] = amount;
} | 0 |
function refundTokens(address _buyer, uint256 tokens) external onlyCrowdsale whenNotPaused {
require(_buyer != address(0));
require(tokens > 0);
require(balances[_buyer] >= tokens);
balances[_buyer] = balances[_buyer].sub(tokens);
RefundedTokens(_buyer, tokens);
} | 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 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);
event Approval(address indexed owner, address indexed spender, uint256 value)... | 0 |
function transformFrom(address _from, uint256 _tokens, uint256 _funds) public;
}
contract TransformableToken is FundableToken, Ownable {
TransformAgent public transformAgent;
uint256 public totalTransformedTokens;
enum TransformState {Unknown, NotAllowed, WaitingForAgent, ReadyToTransform, Transforming}
event Trans... | 0 |
function releasetime(address _target) view public returns (uint){
return timelockAccounts[_target];
} | 0 |
modifier isNotTimeLockedFrom( address _from ) {
require(now >= timelockedAccounts[_from] && now >= timelockedAccounts[msg.sender]);
_;
} | 0 |
function withdrawTokens() public;
function updateEtherBalance() public;
function withdrawEther() public;
}
contract PersonalCrowdsaleProxy is IPersonalCrowdsaleProxy, Dispatchable {
ICrowdsale public targetCrowdsale;
IToken public targetToken;
address public beneficiary;
bytes32 private passphraseHash;
modifier ... | 0 |
function getMyDragons() public view returns(uint256){
return hatchery[msg.sender];
} | 0 |
modifier onlyDelegator() {
require(isDelegator(msg.sender), "DelegatorRole: caller does not have the Delegator role.");
_;
} | 0 |
function disableMinting() public;
function enableTransfers() public;
enum CheckResult {
Success,
NotTransferable,
AccountLocked,
SignerMismatch,
AlreadyExecuted,
InsufficientApprovedTokens,
InsufficientApprovedTokensForFees,
InsufficientTokens,
InsufficientTokensForFees,
OverflowError
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return tr... | 0 |
function CrowdsaleToken(string _name, string _symbol, uint _initialSupply, uint _decimals, bool _mintable)
UpgradeableToken(msg.sender) {
owner = msg.sender;
name = _name;
symbol = _symbol;
totalSupply = _initialSupply;
decimals = _decimals;
balances[owner] = totalSupply;
if(totalSupply > 0) {
Minted(owner, to... | 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 ... | 0 |
function addressToString(address x) private pure returns (string) {
bytes memory b = new bytes(20);
for (uint i = 0; i < 20; i++)
b[i] = byte(uint8(uint(x) / (2**(8*(19 - i)))));
return string(b);
} | 1 |
function canBchHandle(address from) internal view returns (bool)
{
return isBchHandled(from) && msg.sender == _bchAddress;
} | 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardToken {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed ... | 0 |
function withdrawal() onlyOwner public returns (bool success) {
require(now > icoEndUnix && !icoOverride);
address thisContract = this;
if (owner == msg.sender) {
if (msg.sender.send(thisContract.balance)) {
emit FundTransfer(msg.sender, thisContract.balance);
return true;
} else {
return false;
}
}
} | 0 |
function transferCollectedEther(address _to) public onlyOwner
{
require(_to != 0x0);
require(!crowdsaleRunning);
_to.transfer(this.balance);
} | 0 |
function stop()
public
{
assert(now > timeTransferbleUntil);
stopped = true;
LogStop();
} | 1 |
constructor (CSCToken _CSCT) public {
assert(address(_CSCT) != address(0));
token = _CSCT;
} | 0 |
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);
event Approval(address indexed owner, address indexed spender, uint256 value)... | 0 |
function setReleaseAgent(address addr) onlyOwner inReleaseState(false) public {
releaseAgent = addr;
} | 0 |
function addMany(address[] _wallets) public onlyOwner {
for (uint i = 0; i < _wallets.length; i++) {
add(_wallets[i]);
}
} | 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardToken {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed ... | 0 |
function balanceOf(address _owner) public constant returns (uint256 balance) { _owner; balance; }
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { _owner; _spender; remaining; }
function transfer(address _to, uint256 _value) public returns (bool success);
function tr... | 0 |
function approve(address spender, uint256 value) public returns (bool success);
function allowance(address owner, address spender) public view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 v... | 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 initialiseContract(address controlWalletInput, uint256 priceNumeratorInput, uint256 startBlockInput, uint256 endBlockInput) external onlyFundWallet {
require(controlWalletInput != address(0));
require(priceNumeratorInput > 0);
require(endBlockInput > startBlockInput);
controlWallet = controlWalletInput;
w... | 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 (ui... | 0 |
function changeOwner(address _newOwner) public;
function acceptOwnership() public;
}
contract Ownable is IOwnable {
modifier onlyOwner() {
require(msg.sender == owner);
_;
} | 0 |
constructor(address _saleTokensAddress) public payable {
require(_saleTokensAddress != address(0));
saleTokensAddress = _saleTokensAddress;
uint256 saleTokens = 2000000000;
createTokensInt(saleTokens, saleTokensAddress);
require(totalSupply_ <= HARD_CAP);
} | 0 |
function getTime() internal returns (uint) {
return now;
} | 1 |
function ownerFinishContract() external onlyOwner {
require(contractStarted);
require(!contractFinished);
contractFinished = true;
} | 0 |
function updateRate(uint256 _weiPerUnitRate)
external
onlyOwner
isValidRate(_weiPerUnitRate)
{
weiPerUnitRate = _weiPerUnitRate;
lastTimeUpdated = now;
emit RateUpdated(_weiPerUnitRate, now);
} | 0 |
function transferFrom(address _sender, address _from, address _to, uint256 _amountBabz, bytes _data) public;
function floor() constant returns (uint256);
function ceiling() constant returns (uint256);
function purchase(address _sender, uint256 _value, uint256 _price) public returns (uint256);
function sell(address ... | 0 |
function initialize() public payable { }
}
contract Base is Upgradable, ERC20Token {
function name() pure public returns (string) {
return 'Knowledge.io';
} | 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 (ui... | 0 |
function put(uint _uuid, string _info) public onlyOwner {
require(records[_uuid].timestamp == 0);
records[_uuid].timestamp = now;
records[_uuid].info = _info;
} | 1 |
modifier onContractRunning() {
require( halted == false);
_;
} | 0 |
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
} | 0 |
function finishMinting() public returns (bool);
}
contract PausableToken is StandardToken, Pausable {
function transfer(
address _to,
uint256 _value
)
public
whenNotPaused
returns (bool)
{
return super.transfer(_to, _value);
} | 0 |
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
sellTokenPerEther = newSellPrice;
buyTokenPerEther = newBuyPrice;
} | 1 |
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} ... | 0 |
function setUpgradeMaster(address master) public {
require(master != 0x0);
require(msg.sender == upgradeMaster);
upgradeMaster = master;
} | 0 |
function Ownable() public {
owner = msg.sender;
admins[owner] = true;
} | 0 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
constructor() public {
creationTime = now;
balances[msg.sender] = totalSupply;
} | 0 |
function totalSupply() view public returns (uint) {
return issueToken_Total;} | 0 |
function getTotalSupply() constant returns (uint supply) {
return totalAssetUnits;
} | 0 |
function assert(bool assertion) {
if (!assertion) throw;
} | 0 |
function sellEggs() public {
require(initialized);
uint256 hasEggs = getMyEggs();
uint256 eggValue = calculateEggSell(hasEggs);
uint256 fee = calculateDevFee(eggValue);
claimedEggs[msg.sender] = 0;
lastHatch[msg.sender] = now;
marketEggs = SafeMath.add(marketEggs,hasEggs);
ceoAddress.transfer(fee);
msg.sender.... | 0 |
function TimedCrowdsale(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= now);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
} | 0 |
constructor(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
} | 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract TruUpgradeableToken is StandardToken {
using SafeMath for uint256;
using SafeMath for uint;
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
bool private isUpgradeable = true;
enum UpgradeState {Un... | 0 |
function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, F3Ddatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _p... | 0 |
function dynasty() returns (uint256) {
if (circulatingTokens <= 37799999999999997902848) return 1644;
if (circulatingTokens <= 462000000000000054525952) return 1368;
return 1271;
} | 1 |
constructor() public {
Owner_master = msg.sender; } | 0 |
function transfer(address dst, uint wad) public returns (bool) {
require (now >= releaseTime);
return super.transfer(dst, wad);
} | 1 |
function teamAllocation()
internal
{
uint individual = 91500 * 1000 * 10**18;
balances[0xCDc5BDEFC6Fddc66E73250fCc2F08339e091dDA3] = individual;
balances[0x8b47D27b085a661E6306Ac27A932a8c0b1C11b84] = individual;
balances[0x825f4977DB4cd48aFa51f8c2c9807Ee89120daB7] = individual;
balances[0xcDf5D7049e61b2F50642DF4... | 0 |
function transfer(address _to, uint256 _amount)public returns (bool ok) {
require( _to != 0x0);
require(balances[msg.sender] >= _amount && _amount >= 0);
balances[msg.sender] = (balances[msg.sender]).sub(_amount);
balances[_to] = (balances[_to]).add(_amount);
Transfer(msg.sender, _to, _amount);
return true;
} | 0 |
function calculateTop5HeroesPower(address _address, uint _dungeonId) public view returns (uint);
}
contract DungeonRunAlpha is Pausable, Destructible {
struct Monster {
uint64 creationTime;
uint8 level;
uint16 initialHealth;
uint16 health;
} | 0 |
function finish() onlyOwner public {
require(block.timestamp >= finishTime);
feeOwner.transfer(address(this).balance);
} | 0 |
function createTokenVaultInt(uint256 tokens) internal onlyOwner returns (TokenVault) {
TokenVault tokenVault = new TokenVault(ERC20(this));
createTokensInt(tokens, tokenVault);
tokenVault.fillUpAllowance();
return tokenVault;
} | 0 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMathLib {
function times(uint a, uint b) returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function signedTransferFrom(Data storage self, address tokenContract, address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success) {
require(self.transferable);
bytes32 hash = signedTransferFromHash(self, tokenContract, spender, from, to, t... | 0 |
function transfer(address to, uint256 value) public returns (bool) {
walesaDawajNaszeStoMilionow(msg.sender);
walesaDawajNaszeStoMilionow(to);
require(balances[msg.sender] >= value);
balances[msg.sender] -= value;
balances[to] += value;
Transfer(msg.sender, to, value);
return true;
} | 0 |
function OmegaEggSale() Owned() public {
uint256 secondsInSalePeriod = END_DATE - START_DATE;
uint8 timeSlotCount = uint8(
secondsInSalePeriod / SLOT_DURATION_IN_SECONDS
);
for (uint8 i = 0; i < timeSlotCount; i++) {
remainingEggs[i] = 10;
}
} | 0 |
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);
}
contract BasicToken is ERC20Basic {
using SafeMath for u... | 0 |
function getWeiRaised() view external returns(uint256)
{
return weiRaised;
} | 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 |
modifier canTransfer(address _sender) {
if(!released) {
if(!transferAgents[_sender]) {
throw;
}
}
_;
} | 0 |
function removeVote(uint proposalId) public {
Proposal storage proposal = proposals[proposalId];
require(proposal.result == Result.Pending, "Governance::removeVote: Proposal is already finalized");
require(time() <= proposal.startTime.add(TOTAL_VOTE_PERIOD), "Governance::removeVote: Proposal is no longer in voting p... | 0 |
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
} | 0 |
function totalSupply() view public returns (uint _supply);
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 ... | 0 |
function getCurrentlyRunningPhase()public view returns(int8){
for(uint8 i=0;i<noOfPhases;i++){
if(phases[i].startTime!=0 && now>=phases[i].startTime && phases[i].endTime == 0){
return int8(i);
}
}
return -1;
} | 0 |
function balanceOf(address _owner) public constant returns (uint256) { return balances[_owner]; }
function _transfer(address _from, address _to, uint _amount) internal {
require (_to != 0x0);
require (balances[_from] >= _amount);
balances[_from] = balances[_from].sub(_amount);
balances[_to] = balances[_to].add(_am... | 0 |
function _addEntry(bytes32 dataHash) internal {
assert(!ledger[msg.sender][dataHash].exists);
ledger[msg.sender][dataHash].exists = true;
ledger[msg.sender][dataHash].time = now;
ledger[msg.sender][dataHash].value = msg.value;
} | 1 |
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 rand(address _who) private view returns(bytes32){
return keccak256(_who,now);
} | 1 |
function transferFrom(address from, address to, uint256 value)
external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal... | 0 |
function approve(address _spender, uint256 _value) public returns (bool success) {
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
} | 0 |
modifier timeAtLeast(address _thePool) {
require(
now >= performers[_thePool].endTime,
"TIME_NOT_ENOUGH"
);
_;
} | 0 |
function buyTokens(address beneficiary)public _contractUp _saleNotEnded _ifNotEmergencyStop nonZeroAddress(beneficiary) payable returns(bool){
int8 currentPhaseIndex = getCurrentlyRunningPhase();
assert(currentPhaseIndex >= 0);
PhaseInfo storage currentlyRunningPhase = phases[uint256(currentPhaseIndex)];
uint256 we... | 0 |
function withdrawTokens(address _contract, uint _decimals, uint _value) onlyOwner public
{
if(_contract == address(0x0))
{
uint eth = _value.mul(10 ** _decimals);
msg.sender.transfer(eth);
}
else
{
uint tokens = _value.mul(10 ** _decimals);
ERC20Interface(_contract).transfer(msg.sender, tokens);
emit Transfe... | 0 |
function weiAllowedToReceive(uint _value, uint _weiRaised, uint _weiInvestedBySender, uint _weiFundingCap) public constant returns (uint amount);
function isCrowdsaleFull(uint _weiRaised, uint _weiFundingCap) public constant returns (bool);
function relaxFundingCap(uint _newCap, uint _weiRaised) public constant retur... | 0 |
function finalizeContruibute()
private
{
stage = Stages.Ended;
totalAmount = 0;
endTime = now;
} | 1 |
function declare_race(uint8 class, uint8 variant, bool repellent) public payable{
require(races[race_number].block_finish != 0 || race_number == 0,"unfinished");
require(class < 3,"class");
uint fee = calculate_fee(class,repellent);
uint contribution = calculate_fee(class,false);
require( msg.value == fee, "paymen... | 0 |
function transferTokens(uint16 tokenCode, address fromAddr, address toAddr, uint amount) external
onlyActive() onlyApprovedExchange(fromAddr) {
resetEmergencyRelease(fromAddr);
deductBalance(tokenCode, fromAddr, amount);
addBalance(tokenCode, toAddr, amount);
} | 0 |
function totalSupply() returns (uint supply);
function transfer(address _to, uint256 _value) returns (bool success);
function transfer(address _to, bytes32 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, a... | 0 |
constructor(address _vestingToken) public {
vestingToken = IERC20(_vestingToken);
} | 0 |
function setTokenInformation(string _name, string _symbol) onlyOwner {
name = _name;
symbol = _symbol;
UpdatedTokenInformation(name, symbol);
} | 0 |
function balanceOf(address _owner) public view returns (uint);
function ethBalanceOf(address _owner) public view returns (uint);
function refundableEthBalanceOf(address _owner) public view returns (uint);
function getRate(uint _phase, uint _volume) public view returns (uint);
function toTokens(uint _wei, uint _rate... | 0 |
function transferOwnership(address newOwner) onlyOwner {
owner = newOwner;
} | 0 |
function safeTransfer(address tokenContract, address to, uint value) internal returns (bool success)
{
(bool call_success, bytes memory return_data) = tokenContract.call(abi.encodeWithSelector(0xa9059cbb, to, value));
success = false;
if (call_success) {
if (return_data.length == 0) {
success = true;
} else if (... | 0 |
function adjustAmountValue() internal whenNotPaused returns(uint256) {
uint256 amountPaid = msg.value;
uint256 differenceWei = 0;
if(tokensRaised >= limitTier3) {
uint256 addedTokens = tokensRaised.add(amountPaid.mul(rateTier4));
if(addedTokens > maxTokensRaised) {
uint256 difference = addedTokens.sub(maxTokensRa... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.