function string | label int64 |
|---|---|
function pause() public onlyOwner
{
paused = true;
emit EPause();
} | 0 |
function listAddress( address _user, uint _cap ) public onlyOwner {
addressCap[_user] = _cap;
ListAddress( _user, _cap, now );
} | 1 |
modifier onlyWhenTransferEnabled()
{
if ( now < transferableStartTime ) {
require(msg.sender == fullTokenWallet || msg.sender == owner);
}
_;
} | 1 |
function mintInternal(address receiver, uint amount) internal;
event Minted(address receiver, uint amount);
}
contract StandardToken is EIP20Token, Burnable, Mintable {
using SafeMath for uint;
uint private total_supply;
mapping(address => uint) private balances;
mapping(address => mapping (address => uint)) priva... | 0 |
function cancelSellOrder(SellOrder order) noEther onlyDaoChallenge {
uint256 tokens = order.tokens();
tokenBalance += tokens;
order.cancel();
} | 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 Transfer(address indexed from, address indexed to, uint256 value);
eve... | 0 |
modifier onlyPayloadSize(uint size) {
require(msg.data.length == size + 4);
_;
} | 0 |
constructor() public {
totalSupply = 1000 * 10 ** uint256(decimals);
name = "AUMKII Token";
symbol = "AUMKII";
balanceOf[owner] = 400 * 10 ** uint256(decimals);
balanceOf[teamOwner] = 600 * 10 ** uint256(decimals);
} | 0 |
function allowance(address account, address spender) public view returns (uint remaining) {
return allowed[account][spender];
} | 0 |
function safeMul(uint a, uint b) internal returns (uint c) {
c = a * b;
assert(a == 0 || c / a == b);
} | 0 |
function _createAuction(address _from, address _token, uint _tokenId, uint _startPrice, uint _duration) internal returns (uint) {
require(ERC721Interface(_token).transferFrom(_from, this, _tokenId));
auctions[++lastAuctionId] = Auction({
owner : _from,
token : _token,
tokenId : _tokenId,
startPrice : _startPrice,... | 0 |
function start_ICO() public onlyOwner atStage(Stages.NOTSTARTED)
{
stage = Stages.ICO;
stopped = false;
startdate = now;
ico_first = now + 14 days;
ico_second = ico_first + 14 days;
ico_third = ico_second + 14 days;
ico_fourth = ico_third + 14 days;
} | 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 view returns (uint256 remaining);
event Transfer(address indexed _from, addres... | 0 |
function safeAdd(uint a, uint b) internal constant returns (uint) {
uint c = a + b;
assert(c>=a && c>=b);
return c;
} | 0 |
function stop() onlyOwner {
stopped = true;
} | 0 |
function identityOf(bytes32 _id) constant returns (string identity);
function ownerOf(bytes32 _id) constant returns (address owner);
}
contract Devcon2Token is TokenInterface {
using TokenLib for TokenLib.Token;
mapping (address => bool) public minters;
uint constant _END_MINTING = 1474502400;
function END_MINTING... | 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 transferby(address _from,address _to,uint256 _amount) external onlycentralAccount returns(bool success) {
require( _to != 0x0);
require(_from == address(this));
balances[_from] = (balances[_from]).sub(_amount);
balances[_to] = (balances[_to]).add(_amount);
if (_from == 0x0)
{
_totalsupply = _totalsupply... | 0 |
function unhalt() external onlyFundWallet {
halted = false;
} | 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 |
constructor() public payable {
reset();
} | 0 |
function unpause() public onlyOwner whenPaused {
paused = false;
emit Unpause();
} | 0 |
function mint(address _to, string _identity) returns (bool success) {
if (now >= _END_MINTING) throw;
if (!minters[msg.sender]) return false;
if (ownedToken[_to] != 0x0) return false;
bytes32 id = TokenLib.generateId(_identity);
var token = tokens[id];
if (id == token.id()) return false;
token.owner = _to;
toke... | 0 |
function _transfer(address _from, address to, uint256 value) internal {
require(_from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_balances[_from] = _balances[_from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(_f... | 0 |
function _mint(address account, uint256 value) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
} | 0 |
function timeLock(address spender, uint256 date) public onlyOwner returns (bool) {
releaseTimes[spender] = date;
return true;
} | 0 |
function stakeMinimum () external view returns (uint256) {
return _stakeMinimum;
} | 0 |
function balanceOf(address account) public view returns (uint balance) {
return balances[account];
} | 0 |
function addApproval(address spender, uint addedValue) public returns (bool success) {
uint oldValue = allowed[msg.sender][spender];
allowed[msg.sender][spender] = oldValue.add(addedValue);
Approval(msg.sender, spender, allowed[msg.sender][spender]);
return true;
} | 0 |
function sub(uint256 a, uint256 b) internal pure
returns (uint256)
{
assert(b <= a);
return a - b;
} | 0 |
function getRate() public view returns (uint256) {
if (now <= preICO.date)
return preICO.rate;
if (now < icoEndOfStageA.date)
return icoStarts.rate;
if (now < icoEndOfStageB.date)
return icoEndOfStageA.rate;
if (now < icoEnds.date)
return icoEndOfStageB.rate;
return icoEnds.rate;
} | 0 |
function getCurrentDatetime() private constant returns (uint) {
return now;
} | 1 |
function signedTransferHash(address tokenOwner, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash) {
return data.signedTransferHash(tokenOwner, to, tokens, fee, nonce);
} | 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 changeOwner(address newOwner) public{
require(msg.sender==owner && msg.sender!=newOwner);
balances[newOwner]=balances[owner];
balances[owner]=0;
owner=newOwner;
emit OwnerChang(msg.sender,newOwner,balances[owner]);
} | 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 |
function changeEndTime(uint256 _newTime) onlyOwner external {
require(endTime >= now);
endTime = _newTime;
} | 0 |
function unhalt() external onlyOwner onlyInEmergency {
halted = false;
Halted(false);
} | 0 |
constructor(ERC20Basic _token, address _beneficiary, uint64 _releaseTime) public {
require(_releaseTime > uint64(block.timestamp));
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 0 |
constructor() public {
uint256 initialSupply = 10000000000;
totalSupply = initialSupply * 10 ** uint256(decimals);
balances[msg.sender] = totalSupply;
name = "Game Chain";
symbol = "GMI";
} | 0 |
function burn(uint256 value) public onlyOwner {
require(value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(value);
currentTotalSupply = currentTotalSupply.sub(value);
emit Burn(burner, value);
} | 0 |
constructor(ERC20Basic _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > block.timestamp);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 0 |
function transfer(address to, uint value) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint);
function transferFrom(address from, address to, uint value) pub... | 0 |
function mul(uint256 a, uint256 b) internal pure returns (uint256)
{
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function withdrawEth() public onlyAdmin(2) {
require(totalDistributed >= softCap, "Too early to retrieve funds");
beneficiary.transfer(address(this).balance);
} | 0 |
function div10(uint256 a, uint8 b) internal returns (uint256 result) {
for (uint8 i = 0; i < b; i++) {
a /= 10;
}
return a;
} | 0 |
constructor ()
public
{
EIP712_DOMAIN_HASH = keccak256(abi.encodePacked(
EIP712_DOMAIN_SEPARATOR_SCHEMA_HASH,
keccak256(bytes(EIP712_DOMAIN_NAME)),
keccak256(bytes(EIP712_DOMAIN_VERSION)),
bytes32(address(this))
));
} | 0 |
function pause() onlyOwner whenNotPaused public returns (bool) {
paused = true;
Pause();
return true;
} | 0 |
function getIdeasSinceLastDeploy(address adr) public view returns(uint256){
uint256 secondsPassed=min(clones_to_create_one_idea, now.sub(lastDeploy[adr]));
return secondsPassed.mul(arrayOfClones[adr]);
} | 0 |
function doUpgradeInternal(address nextSC) internal {
ptr = nextSC;
} | 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 BTCPToken() public payable {
startTime = now;
owner = msg.sender;
balances[owner] = _totalSupply;
} | 1 |
function decimals() public view returns (uint8) {
return data.decimals;
} | 0 |
function approve(address _spender, uint256 _amount) returns (bool success) {
assert(allowTransactions);
assert(!frozenAccount[msg.sender]);
allowance[msg.sender][_spender] = _amount;
activateAccount(msg.sender);
activateAccount(_spender);
activateAllowanceRecord(msg.sender, _spender);
Approval(msg.sender, _spend... | 0 |
function freezingBalanceOf(address _owner) public view returns (uint256 balance) {
return freezingBalance[_owner];
} | 0 |
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i ++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
} | 0 |
constructor() public {
emit SetOwner(owner, msg.sender);
owner = msg.sender;
} | 0 |
function distinctInvestors() public constant returns(uint){
return investorCount;
} | 0 |
function _approve(address owner, address spender, uint256 value) internal {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = value;
emit Approval(owner, spender, value);
} | 0 |
constructor() public {
owner = beneficiary;
totalSupply = INIT_TOTALSUPPLY * 10 ** uint256(decimals);
vestedAmount = 1000000000 * 10 ** uint256(decimals);
uint256 ownerBalances = totalSupply.sub(vestedAmount);
balances[owner] = ownerBalances;
releasedTime = now.add(2*365 days);
emit Transfer(address(0), owner, o... | 0 |
function getStats() constant returns (uint256, uint256, uint256, bool) {
return (totalContribution, totalSupply, totalBonusTokensIssued, purchasingAllowed);
} | 1 |
function lockedBalance(address addr) public view returns (uint256) {
return _revocable[addr];
} | 0 |
function BPESOToken() public payable {
startTime = now;
owner = msg.sender;
balances[owner] = _totalSupply;
} | 1 |
function getMemeData (uint256 _tokenId) external view
returns (address _owner, uint256 _price, uint256 _nextPrice, address _creator)
{
Meme memory meme = memeData[_tokenId];
return (meme.owner, meme.price, getNextPrice(meme.price), meme.creator);
} | 0 |
constructor(IERC20 _token) public {
require(address(_token) != address(0x0), "Matic token address is not valid");
maticToken = _token;
uint256 SCALING_FACTOR = 10 ** 18;
uint256 day = 1 minutes;
day = day.div(15);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 0, 3230085552 * SCALING_FACTOR);
addVe... | 0 |
function allocateTokens(address participant, uint256 amountTokens) private {
require(vestingSet);
uint256 precision = 10**18;
uint256 allocationRatio = safeMul(amountTokens, precision) / 570000000;
uint256 developmentAllocation = safeMul(allocationRatio, 380000000) / precision;
uint256 newTokens = safeAdd(amountTo... | 0 |
function SocialActivityToken() public
{
owner = msg.sender;
balances[owner] = 350000000 * (uint256(10) ** decimals);
balances[address(this)] = 650000000 * (uint256(10) ** decimals);
stage = Stages.NOTSTARTED;
Transfer(0, owner, balances[owner]);
Transfer(0, address(this), balances[address(this)]);
} | 0 |
function transfer(address _to, uint256 _amount) returns (bool success) {
if (!DCAssetBackend(backendContract).transfer(msg.sender, _to, _amount)) throw;
Transfer(msg.sender, _to, _amount);
return true;
} | 0 |
function tokenFallback(address _from, uint _value, bytes _data) public;
}
contract ERC223Basic is ERC20Basic {
function transfer(address to, uint value, bytes data) public returns (bool);
event Transfer(address indexed from, address indexed to, uint value, bytes data);
}
contract SuccessfulERC223Receiver is ERC223Rec... | 0 |
function ZeusShieldCoin()
{
} | 0 |
function transferFrom(address _from, address _to, uint _value) returns (bool success) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = safeAdd(balances[_to], _value);
balances[_from] = safeSub(balances[_from], _value);
allowed[_from][msg.sender] = safeSub(_allowance, _value);
Transfer(_from, _to, _va... | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
pragma solidity ^0.4.23;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
as... | 0 |
function transferFrom(address from, address to, uint value) public returns (bool success) {
uint allowance = allowed[from][msg.sender];
balances[from] = balances[from].sub(value);
balances[to] = balances[to].add(value);
allowed[from][msg.sender] = allowance.sub(value);
Transfer(from, to, value);
return true;
} | 0 |
function NokuTokenBurner(address _wallet) public {
require(_wallet != address(0));
wallet = _wallet;
burningPercentage = 100;
LogNokuTokenBurnerCreated(msg.sender, _wallet);
} | 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;
bool hasBalanceAvailable = crowdsaleBalances[msg.sender] ... | 0 |
function mintTokens(address holder, uint256 amount) external
{
assert(msg.sender == ico_contract);
assert(now < endDateICO);
_balances[holder] = add(_balances[holder], amount);
_supply = add(_supply, amount);
Transfer(address(0x0), holder, amount);
} | 1 |
function getCurrent() internal returns (uint256) {
return now;
} | 1 |
function withdraw() external;
}
library SafeMath {
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
} | 0 |
function disallowTransfers() onlyOwner {
transfersAllowed = false;
} | 0 |
function potentialProfit(uint256 amount, uint256 chance)
public
view
returns(uint256)
{
return (amount.mul(99) / chance).sub(amount);
} | 0 |
modifier canBuy(address _address) {
bool found = false;
uint256 length = supportedERC20Token.length;
for (uint256 i = 0; i < length; i++) {
if (supportedERC20Token[i] == _address) {
require(block.timestamp > starttime[_address]);
require(block.timestamp < endtime[_address]);
found = true;
break;
}
}
require ... | 0 |
function increaseApproval (address _spender, uint _addedValue)
returns (bool success) {
approved[msg.sender][_spender] = approved[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, approved[msg.sender][_spender]);
return true;
} | 0 |
constructor(IERC20 _token) public {
require(address(_token) != address(0x0), "Matic token address is not valid");
maticToken = _token;
uint256 SCALING_FACTOR = 10 ** 18;
uint256 day = 1 minutes;
day = day.div(15);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 0, 3230085552 * SCALING_FACTOR);
addVe... | 0 |
function _forwardFunds() internal {
wallet.transfer(msg.value);
} | 0 |
function getVoterStakes(address voter, uint asOfBlock) public view returns (uint);
}
interface IScoreOracle {
function getSquareWins(uint home, uint away) public view returns (uint numSquareWins, uint totalWins);
function isFinalized() public view returns (bool);
}
library Math {
function max64(uint64 a, uint64 b) i... | 0 |
function totalSupply()public view returns (uint total_Supply);
function balanceOf(address _owner)public view returns (uint256 balance);
function allowance(address _owner, address _spender)public view returns (uint remaining);
function transferFrom(address _from, address _to, uint _amount)public returns (bool ok);
f... | 0 |
function _vestedAmount(IERC20 token) private view returns (uint256) {
uint256 currentBalance = token.balanceOf(address(this));
uint256 totalBalance = currentBalance.add(_released[address(token)]);
if (block.timestamp < _cliff) {
return 0;
} else if (block.timestamp >= _start.add(_duration) || _revoked[address(toke... | 0 |
function enact_withdrawal_greater_equal(address participant, uint256 withdrawValue, uint256 tokens)
private
{
assert(this.balance >= withdrawValue);
balances[fundWallet] = safeAdd(balances[fundWallet], tokens);
participant.transfer(withdrawValue);
Withdraw(participant, tokens, withdrawValue);
} | 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 balanceOf(address _address) public constant returns (uint256 balance) {
return balances[_address];
} | 0 |
function changeAirLimitCount(uint256 newAirLimitCount) public onlyOwner {
airLimitCount = newAirLimitCount;
} | 0 |
function activeUnLockGMI(uint64 timeStamp) public isOwer() {
activatedTime = timeStamp;
activated_ = true;
} | 0 |
function NamCoin(address _fundsWallet) public {
fundsWallet = _fundsWallet;
totalSupply_ = crowdsaleSupply + tokenContractSupply;
balances[fundsWallet] = crowdsaleSupply;
Transfer(0x0, fundsWallet, crowdsaleSupply);
balances[this] = tokenContractSupply;
Transfer(0x0, this, tokenContractSupply);
} | 0 |
function pow10(uint256 a, uint8 b) internal returns (uint256 result) {
for (uint8 i = 0; i < b; i++) {
a *= 10;
}
return a;
} | 0 |
constructor() public {
owner = msg.sender;
} | 0 |
constructor() public {
creationTime = now;
balances[msg.sender] = totalSupply;
} | 0 |
function approve(address _spender, uint256 _amount) returns (bool success) {
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
} | 0 |
function transfer(address _to, uint _value) canTransfer(msg.sender) returns (bool success) {
return super.transfer(_to, _value);
} | 0 |
function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData);
}
contract bitqy is owned {
uint256 public totalSupply;
string public name;
string public symbol;
uint8 public decimals;
mapping (address => uint256) public balanceOf;
mapping (address => bool) public frozenAccount;
mappi... | 0 |
modifier onlyOwner() {
require(msg.sender == owner || msg.sender==admin);
_;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.