function string | label int64 |
|---|---|
function allowance(address owner, address spender) constant returns (uint);
function transferFrom(address from, address to, uint value);
function approve(address spender, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract BasicToken is ERC20Basic
{
using SafeMath for... | 0 |
function transferFrom(address from, address to, uint value) public returns (bool success) {
require(value <= balanceOf(from));
require(value <= allowance(from, to));
if (to == BXIT || to == address(this)) {
_balances[from] = _balances[from].sub(value);
supply = supply.sub(value);
emit Transfer(from, address(0), v... | 0 |
function transfer(address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _currentValue, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, ui... | 0 |
function AddMessage(address _adr,uint _val,string _data)
public
{
LastMsg.Sender = _adr;
LastMsg.Time = now;
LastMsg.Val = _val;
LastMsg.Data = _data;
History.push(LastMsg);
} | 1 |
function setTierRates(uint256 tier1, uint256 tier2, uint256 tier3, uint256 tier4)
external onlyOwner whenNotPaused
{
require(tier1 > 0 && tier2 > 0 && tier3 > 0 && tier4 > 0);
require(tier1 > tier2 && tier2 > tier3 && tier3 > tier4);
rate = tier1;
rateTier2 = tier2;
rateTier3 = tier3;
rateTier4 = tier4;
} | 0 |
function getRate() public view returns (uint256) {
if (block.timestamp <= startTime) { return ((rate / 100) * 120); }
if (block.timestamp <= startTime.add(1 days)) {return ((rate / 100) * 108);}
return rate;
} | 0 |
function getPayroll() constant returns(uint payroll_at_last_update_balances)
{
payroll_at_last_update_balances=payroll;
return ;
} | 0 |
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 who) external view returns (uint256);
function allowance(address owner,... | 0 |
function whitelist(address address_) external onlyOwner {
whitelist[address_] = true;
emit ICOWhitelisted(address_);
} | 0 |
constructor (address initPayTo) payoutAllC(initPayTo) public {
} | 0 |
function votesTotal() public view returns (uint);
function isSubjectApproved() public view returns (bool);
}
contract Ownable is IOwnable {
modifier onlyOwner() {
require(msg.sender == owner);
_;
} | 0 |
function proposeWithFeeRecipient(address feeRecipient, address target, bytes memory data) public returns (uint) {
require(msg.sender != address(this) && target != address(token), "Governance::proposeWithFeeRecipient: Invalid proposal");
require(token.transferFrom(msg.sender, address(this), proposalFee), "Governance::... | 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 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, uint25... | 0 |
function blockTime() constant returns (uint32) {
return uint32(block.timestamp);
} | 1 |
function approve(address spender, uint value)public returns (bool ok);
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 SATCoin is ERC20
{ usi... | 0 |
function kill() public onlyOwner {
require(now >= canSelfDestruct);
uint256 balance = RR.balanceOf(this);
if (balance > 0) {
RR.transfer(msg.sender, balance);
}
selfdestruct(owner);
} | 0 |
function transferFrom(address from, address to, uint value)public returns (bool ok);
function approve(address spender, uint value)public returns (bool ok);
function transfer(address to, uint value)public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address ... | 0 |
function renouncePauser() public {
_removePauser(msg.sender);
} | 0 |
function createTokenContract() internal returns (MintableToken) {
return new MintableToken();
} | 0 |
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;
byte... | 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 addMinter(address who) returns (bool);
function removeMinter(address who) returns (bool);
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(addres... | 0 |
function betOnColumnOrDozen(bool First, bool Second, bool Third, BetTypes bet) private
checkWaitingForBet
onlyActive
checkNbBetsCurrentBlock
{
updateStatusPlayer();
uint8 count;
uint8 input;
if (First)
{
count+=1;
input=0;
}
if (Second)
{
count+=1;
input=1;
}
if (Third)
{
count+=1;
input=2;
}
if ... | 0 |
function addToTimeLockedList(address addr) external onlySaleConract returns (bool) {
require(addr != 0x0);
isPresaleBuyer[addr] = true;
return true;
} | 0 |
function CrowdSale_Finalize() external onlyOwner atStage(Stages.ICO)
{
require(now > ico_enddate);
stage = Stages.ENDED;
lockstatus = false;
mintingFinished = true;
} | 0 |
function getFallback() view public returns (TKN) {
return fallback;
} | 0 |
function listAddress( address _user, uint _cap ) public onlyOwner {
addressCap[_user] = _cap;
ListAddress( _user, _cap, now );
} | 1 |
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 vestCmd1YearInstantInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, 0, lock365Days, lock365Days);
} | 0 |
function getAdminLogN() view external returns (uint) {
return adminLog.length;
} | 0 |
function buyToken(address beneficiary) payable isPurchasable whenNotPaused public returns (uint256) {
require(beneficiary != address(0));
require(beneficiary != address(this));
uint256 weiAmount = msg.value;
require(weiAmount >= minimumWeiAmount);
uint256 tokenAmount = safeMul(weiAmount, exchangeRate);
tokenAmoun... | 0 |
function bchAuthorize() public returns (bool)
{
return _changeState(true);
} | 0 |
function bchRevoke() public returns (bool)
{
return _changeState(false);
} | 0 |
function unassignRole(address _from, bytes32 _role, address _to) onlyNodeOwner(_from) returns(bool) {
if (!hasRole(_from, _role, _to)) {
_error("Role not assigned");
return false;
}
delete rolesExpiration[_getRoleSignature(_from, _role, _to)];
Unassign(_from, _role, _to);
return true;
} | 0 |
function getNext() public onlyOwner returns (uint) {
require(nextTapNum < 12);
require(remainsForTap > 0);
require(now >= nextTapDate);
uint tapValue;
if (nextTapNum == 11) {
tapValue = remainsForTap;
} else {
tapValue = uint(nextTapPercent) * baseEther / 100;
if (tapValue > remainsForTap) {
tapValue = remain... | 0 |
function canCall(address caller, address, bytes4 sig) public view returns (bool) {
if (isFreezer(caller) && (sig == setFreezingSig || sig == transferAndFreezingSig)) {
return true;
} else {
return false;
}
} | 0 |
function getBlockTimestamp() returns (uint256) {
return block.timestamp;
} | 1 |
function hasStarted() public view returns (bool) {
return now >= startTime;
} | 0 |
function storeAuthenticity(string sha256) {
if (checkAuthenticity(sha256) == 0) {
authenticity[sha256] = now;
}
} | 1 |
constructor() owned() hasAdmins() public {
} | 0 |
function div(uint a, uint b) internal pure returns (uint) {
uint c = a / b;
return c;
} | 0 |
function mintAdminCancel(address _address) public onlyAdmin {
require(mintApprove[_address].admin == msg.sender, "Only cancel if the address is the same admin");
mintApprove[_address].admin = 0x0;
} | 0 |
function NokuTokenBurner(address _wallet) public {
require(_wallet != address(0));
wallet = _wallet;
burningPercentage = 100;
LogNokuTokenBurnerCreated(msg.sender, _wallet);
} | 0 |
modifier notFinished() {
State current_state = getState();
require(current_state == State.PreFunding || current_state == State.Funding);
_;
} | 0 |
function setTokenContract(HoloToken _tokenContract) external onlyOwner {
tokenContract = _tokenContract;
} | 0 |
function finalize() public onlyOwner {
require(state == State.Active);
require(now > startTime);
state = State.Finalized;
uint256 crowdsaleBalance = balanceOf(crowdsaleWallet);
uint256 burnAmount = networkDevelopmentSupply.mul(crowdsaleBalance).div(crowdsaleSupply);
_burn(networkDevelopmentWallet, burnAmount);
b... | 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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) public balances;
... | 0 |
function isIcoOver() constant public returns(bool isOver) {
return now >= icoDeadline;
} | 1 |
function BonusFinalizeAgent(Crowdsale _crowdsale, uint _bonusBasePoints, address _teamMultisig) {
require(address(_crowdsale) != 0 && address(_teamMultisig) != 0);
crowdsale = _crowdsale;
teamMultisig = _teamMultisig;
bonusBasePoints = _bonusBasePoints;
} | 0 |
function balanceOf(address account)
constant
returns (uint balance)
{
return balances[account];
} | 0 |
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
constan... | 0 |
function burn(uint burnAmount) {
address burner = msg.sender;
balances[burner] = balances[burner].sub(burnAmount);
totalSupply_ = totalSupply_.sub(burnAmount);
Burned(burner, burnAmount);
Transfer(burner, BURN_ADDRESS, burnAmount);
} | 0 |
function today() private constant returns (uint) {
return now / 1 days;
} | 1 |
function signedTransferFromHash(address spender, address from, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedTransferFromCheck(address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResul... | 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 newShrimp=SafeMath.div(eggsUsed,EGGS_TO_HATCH_1SHRIMP);
hatcheryShrimp[msg.sender]=SafeMath.add(hatcheryShrimp[msg.se... | 0 |
function name() public pure returns (string _name) {
return "Economeme Meme";
} | 0 |
modifier onlyOwnerOrSiteAccount() {
require(msg.sender == owner || msg.sender == siteAccount);
_;
} | 0 |
function unmintTokens(address hodler, uint amount)
returns (bool ok)
{
require(msg.sender == mintMaster);
require(amount > 0);
require(balances[hodler] >= amount);
balances[hodler] = balances[hodler].safeSub(amount);
totalSupply = totalSupply.safeSub(amount);
LogUnmintTokens(hodler, amount, balances[hodler], to... | 0 |
function adminAddRole(address addr, string roleName)
onlyAdmin
public
{
addRole(addr, roleName);
} | 0 |
function underLimit(uint _value) internal onlyowner returns (bool) {
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
} | 1 |
function renounceOwnership() public onlyOwner {
OwnershipRenounced(owner);
owner = address(0);
} | 0 |
function sellKebabs() public{
require(initialized);
uint256 hasKebabs=getMyKebabs();
uint256 kebabValue=calculateKebabSell(hasKebabs);
uint256 fee=calculatePercentage(kebabValue,10);
workingKebaber[msg.sender] = SafeMath.div(workingKebaber[msg.sender],2);
claimedKebabs[msg.sender]=0;
lastKebab[msg.sender]=now;
... | 0 |
function setMatured(uint32 event_id) onlyOwner returns (bool success) {
if(matured==false){
matured = true;
matured_block_number = block.number;
matured_timestamp = block.timestamp;
TxExecuted(event_id);
}
return true;
} | 0 |
function withdrawContributorsTokens(address _to, uint256 _amountWithDecimals)
public
onlyOwner
{
require(transferFrom(contributorsAllocation, _to, _amountWithDecimals));
} | 0 |
function inAllocationLockPeriod() constant returns (bool)
{
return (block.timestamp < ALLOCATION_LOCK_END_TIMESTAMP);
} | 0 |
modifier onlyUniquePool(string poolId) {
require(pools[poolId].availableAmount == 0);
_;
} | 0 |
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool) {
approve(_spender, _value);
allowanceRecipient spender = allowanceRecipient(_spender);
if (spender.receiveApproval(msg.sender, _value, this, _extraData)) {
DataSentToAnotherContract(msg.sender, _spender, _extraData);
... | 0 |
function mintPresaleTokens(address _investor, uint256 _value) internal {
require(icoState == IcoState.Presale);
require(_value > 0);
uint256 _elcValue = getPresaleTotal(_value);
uint256 timeBonusAmount = _elcValue * getTimeBonus(now) / 1000;
_elcValue += timeBonusAmount;
require(elc.totalSupply() + _elcValue <= t... | 1 |
function destroy(address _from, uint256 _amount) public;
}
contract DebitCoinToken is IDebitCoinToken, ERC20Token, Owned, TokenHolder {
string public version = '0.2';
bool public transfersEnabled = true;
uint public MiningRewardPerETHBlock = 5;
uint public lastBlockRewarded;
event DebitCoinTokenGenesis(address _to... | 0 |
function receiveTokens(uint256 tokens) {
DaoAccount sender = DaoAccount(msg.sender);
if (!AbstractDaoChallenge(daoChallenge).isMember(sender, sender.getOwnerAddress())) throw;
if (tokens > sender.getTokenBalance()) throw;
if (tokenBalance + tokens < tokenBalance) throw;
tokenBalance += tokens;
} | 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 transfer(address _to, uint256 _value) public returns(bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function balanceOf(address _owner) public constant returns (uint256 balance);
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 return... | 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 |
modifier isActive() {
require(state == State.Active);
_;
} | 0 |
function getState() public constant returns (State) {
if (finalized) return State.Finalized;
else if (block.number < startsAt) return State.PreFunding;
else if (block.number <= endsAt && !ceilingStrategy.isCrowdsaleFull(weiRaised, weiFundingCap)) return State.Funding;
else if (isMinimumGoalReached()) return State.S... | 0 |
function calculateTokens(uint value) internal view returns (uint256 tokens)
{
uint256 timeElapsed = now - startTime;
uint256 timeElapsedInDays = timeElapsed.div(1 days);
uint256 bonus = 0;
if (timeElapsedInDays <30)
{
tokens = value.mul(ratePerWeiInSelfDrop);
bonus = tokens.mul(bonusInSelfDrop);
bonus = bonus.... | 0 |
function setDepositAddress(address _depositAddress) onlyOwner {
depositAddress = _depositAddress;
} | 1 |
function withdraw(uint amount) payable onlyOwner {
if( now >= openDate ) {
uint max = deposits[msg.sender];
if( amount <= max && max > 0 ) {
msg.sender.send( amount );
Withdrawal(msg.sender, amount);
}
}
} | 1 |
function burn(uint256 _amount) public onlyMarketMaker {
uint256 fee = calcBurnFee (_amount);
uint256 fromValue = _amount.sub(fee);
_transfer(burnFeeReceiver, fee);
_burn(msg.sender, fromValue);
} | 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 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 |
modifier onlyUnlocked() {
uint nowtime = block.timestamp;
uint futuretime = 1550537591;
if(nowtime > futuretime) {
_;
} else {
require(!lockedAddress[msg.sender]);
_;
}
} | 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(max... | 0 |
function TokenVesting(address _beneficiary, uint256 _start, uint256 _cliff, uint256 _duration, bool _revocable) public {
require(_beneficiary != address(0));
require(_cliff <= _duration);
beneficiary = _beneficiary;
revocable = _revocable;
duration = _duration;
cliff = _start.add(_cliff);
start = _start;
} | 0 |
function _unpause() internal whenPaused {
_paused = false;
emit Unpaused(msg.sender);
} | 0 |
constructor() internal {
level[msg.sender] = 2;
emit AdminshipUpdated(msg.sender,2);
} | 0 |
function getRandom(uint _seed) constant public returns(uint) {
return uint(keccak256(block.timestamp, block.difficulty)) ^ _seed;
} | 1 |
function getActiveGrants(address _recipient) public view returns(uint256[]){
uint256 i = 0;
uint256[] memory recipientGrants = new uint256[](totalVestingCount);
uint256 totalActive = 0;
for(i; i < totalVestingCount; i++){
if(tokenGrants[i].isActive && tokenGrants[i].recipient == _recipient){
recipientGrants[total... | 0 |
function decreaseAllowance(address spender, uint256 subtractedValue) public returns (bool) {
_approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue));
return true;
} | 0 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender... | 0 |
function read() external view returns(bytes32);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
} | 0 |
function timeunlockAccount(address target) public onlyOwner {
timelockAccounts[target] = now;
emit TimeLockFunds(target, now);
} | 0 |
function setOwner(address _new)
public
onlyOwner
{
emit NewPotentialOwner(owner, _new);
potentialOwner = _new;
} | 0 |
function atNow() constant returns (uint) {
return now;
} | 1 |
function _transfer(address from, address to, uint256 amount) internal {
require(amount <= _balances[from]);
require(to != address(0));
_balances[from] = _balances[from].sub(amount);
_balances[to] = _balances[to].add(amount);
if(saleEndTime > block.timestamp)
_amountForSale = _balances[address(this)];
} | 0 |
function transfer(address receiver, uint amount) public;
}
contract Crowdsale {
address public beneficiary;
uint public fundingGoal;
uint public amountRaised;
uint public deadline;
uint public price;
token public tokenReward;
mapping(address => uint256) public balanceOf;
bool fundingGoalReached = false;
bool c... | 1 |
function totalSupply() constant returns (uint256);
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 sp... | 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 indexed owner, ... | 0 |
End of preview. Expand in Data Studio
README.md exists but content is empty.
- Downloads last month
- 4