function string | label int64 |
|---|---|
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 approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract TokenTimelock {
ERC20 public token;
address public beneficiary;
uint256 public releaseTime;
function TokenTimelock(ERC20 _token, address _beneficiary, ui... | 0 |
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
require(newOwner != owner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
} | 0 |
function mint(uint256 mintedAmount) onlyOwner {
balanceOf[hotwalletAddress] += mintedAmount;
totalSupply += mintedAmount;
Processed(msg.sender);
} | 0 |
function checkCompletedCrowdsale() public whenNotPaused {
if(!isEnded) {
if(hasEnded() && !goalReached()){
vault.enableRefunds();
isRefunding = true;
isEnded = true;
Finalized();
} else if(hasEnded() && goalReached()) {
isEnded = true;
if(tokensRaised < maxTokensRaised) {
token.burnTokens();
}
Finalized();
... | 0 |
function Util() public{}
function strConcat(string _a, string _b, string _c, string _d, string _e) internal pure returns (string){
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
bytes memory _bc = bytes(_c);
bytes memory _bd = bytes(_d);
bytes memory _be = bytes(_e);
string memory abcde = new string... | 0 |
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) constant public returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spend... | 0 |
function getAvailableAmount(string poolId)
public
view
returns (uint256)
{
return pools[poolId].availableAmount;
} | 0 |
function tokenFallback(address _from, uint256 _value, bytes _data);
}
contract KnowledgeTokenInterface is ERC223{
event Mint(address indexed to, uint256 amount);
function changeMinter(address newAddress) returns (bool);
function mint(address _to, uint256 _amount) returns (bool);
}
contract Ownable {
address public ... | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(frozenAccounts[_from] < now);
return super.transferFrom(_from, _to, _value);
} | 0 |
function ChineseCookies() {
bakeCookie("A friend asks only for your time not your money.");
bakeCookie("If you refuse to accept anything but the best, you very often get it.");
bakeCookie("A smile is your passport into the hearts of others.");
bakeCookie("A good way to keep healthy is to eat more Chinese food.");
... | 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 transferFrom(address _from, address _to, uint256 _value) public returns (bool _succes);
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 _spende... | 0 |
function cancel() returns (uint8 code) {
if (!masterKeys[msg.sender]) {
Unauthorized(msg.sender);
return 0;
}
uint256 call = functionCalling[msg.sender];
if (call == 0) {
NothingToCancel(msg.sender);
return 1;
} else {
AuthCancel(msg.sender, msg.sender);
uint256 hash = functionCalling[msg.sender];
functionC... | 0 |
function symbol() constant returns (string) {
return _symbol;
} | 0 |
modifier checkTime() {
require(now >= time[msg.sender].add(stepTime), "Too fast payout request");
_;
} | 0 |
function approve(address _spender, uint256 _amount) returns (bool success) {
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
} | 0 |
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant 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 setEarlyParticipantWhitelist(address addr, bool status, uint minCap, uint maxCap) public onlyOwner {
if (!isWhiteListed) throw;
assert(addr != address(0));
assert(maxCap > 0);
assert(minCap <= maxCap);
assert(now <= endsAt);
if (!isAddressWhitelisted(addr)) {
whitelistedParticipants.push(addr);
Whiteli... | 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 canUpgrade() public view returns(bool) {
return true;
} | 0 |
function rand(uint max, address other) constant internal returns (uint result){
uint add = uint (msg.sender) + uint(other) + uint(block.timestamp);
uint random_number = addmod(uint (block.blockhash(block.number-1)), add, uint (max + 1)) ;
return random_number;
} | 1 |
function validPurchaseIco(uint256 _amount) public constant returns (bool) {
bool withinPeriod = now >= startTimeIco && now <= endTimeIco;
bool nonZeroPurchase = _amount != 0;
return withinPeriod && nonZeroPurchase;
} | 0 |
function withdrawExtraTokens(ERC20Interface _ERC20) onlyContractOwner() returns(bool) {
require(_ERC20.transfer(contractOwner, getExtraTokens(_ERC20)));
return true;
} | 0 |
function release() onlyOwner {
if (lockTime + 1 years > now) {
throw;
}
if ( lockTotal == 0 ) {
throw;
}
lockTotal = lockTotal.sub(releaseTotal);
balances[owner] = balances[owner].add(releaseTotal);
lockTime = lockTime + 1 years;
return;
} | 1 |
modifier onlyDestroyer() {
require(msg.sender == destroyer);
_;
} | 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 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 Lockable()
public
{
creationTime = now;
tokenTransfer = false;
owner = msg.sender;
} | 1 |
constructor() public
{
name = "SBtesting";
decimals = 18;
symbol = "SBtest";
issueToken_Total = 0;
issueToken_SeedBlock = 0;
require(maxSupply == maxSupply_SeedBlock);
} | 0 |
function getStats() constant returns (uint256, uint256, uint256, bool) {
return (totalContribution, totalSupply, totalBonusTokensIssued, purchasingAllowed);
} | 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 constant returns (uint256);
function transferFrom(address from, uint256 value) public... | 0 |
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Frac... | 0 |
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(address escapeHatchAddress) public {
owner = msg.sender;
escapeHatch = escapeHatchAddress;
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool) {
if (_to != address(this)) {
return super.transfer(_to, _value);
}
require(_value <= balances_[msg.sender] && status == 0);
if (gameTime > 1514764800) {
require(gameTime > block.timestamp);
}
balances_[msg.sender] = balances_[msg.sender].sub(... | 0 |
function hasAvailableCard() external view returns(bool) {
uint256 currentPeriodKey = getCurrentPeriodKey();
mapping (uint256 => bool) senderHasWithdraw = addressHasWithdraw[msg.sender];
return (senderHasWithdraw[currentPeriodKey] == false &&
periodDonationCount[currentPeriodKey] < cardsByPeriod);
} | 0 |
function finalizeCrowdsale();
}
contract ERC20Basic {
uint256 public totalSupply;
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
functi... | 0 |
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
} | 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 vestedAmount() public view returns (uint256) {
uint256 totalBalance = totalTokensLocked[msg.sender];
if (now < cliff) {
return 0;
} else if (now >= start.add(duration)) {
return totalBalance;
} else {
return totalBalance.mul(now.sub(start)).div(duration);
}
} | 0 |
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
... | 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 getPaymentInfo(uint paymentID)
external
view
returns (
uint holdTime,
uint paymentOpenTime,
uint paymentCloseTime,
address token,
uint sendAmount,
address sender,
address recipient,
bytes memory codeHash,
uint state
)
{
Payment memory txn = openPayments[paymentID];
return (
txn.holdTime,
txn.... | 0 |
modifier only(bytes32 role) {
require(_accessPolicy.allowed(msg.sender, role, this, msg.sig));
_;
} | 0 |
function getNow() public constant returns (uint) {
return now;
} | 1 |
function unlock() public returns(bool) {
require(now > UNLOCK_DATE, 'Tokens are still locked');
return TOKEN.transfer(DESTINATION, TOKEN.balanceOf(address(this)));
} | 0 |
modifier onlyTokenHolders()
{
require(myTokens() > 0);
_;
} | 0 |
function _sell(address _from, uint256 _tokenId, uint256 value) internal {
if(jockeyIndexForSale[_tokenId]==true){
uint256 price = jockeyIndexPrice[_tokenId];
require(price<=value);
uint256 Fee = price / saleFee;
uint256 oPrice= price - Fee;
address _to = msg.sender;
tokenOwnershipCount[_to]++;
jockeyOwnerIndex[... | 1 |
function buyTokens(uint256 _id, address _holder) public payable {
require(!started);
require(!gameOver);
require(!gameOverByUser);
require(_id > 0 && _id <= cap);
require(citizens[_id].isExist == false);
require(_holder != address(0));
require(msg.value == rate);
uint256 weiAmount = msg.value;
weiRaised = weiR... | 0 |
function approve(address _spender, uint256 _value) onlyPayloadSize(2) public returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function getReservedTokens() public onlyOwner icoEnded {
require(reserved > 0);
uint256 amount = reserved;
reserved = 0;
token.transfer(tokenWallet, amount);
} | 0 |
function approve(address spender, uint tokens) external returns(bool success);
function transferFrom(address from, address to, uint tokens) external returns(bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint t... | 0 |
function setOwner(address _owner) onlyOwner
{ owner = _owner; }
modifier onlyOwner { if (msg.sender != owner) throw; _; }
}
contract TRMCrowdsale is Owned {
using SafeMath for uint;
event Print(string _message, address _msgSender);
uint public ETHUSD = 100000;
address manager = 0xf5c723B7Cc90eaA3bEec7B05D6bbeBCd9... | 0 |
function allowTransfers() onlyOwner {
transfersAllowed = true;
} | 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, uint256 value... | 0 |
function owner()
external
returns(address);
function updateContractAddress(
string _name,
address _address
)
external
returns (address);
function getContractAddress(
string _name
)
external
view
returns (address);
}
interface IBrickblockToken {
function transfer(
address _to,
uint256 _value
)
externa... | 0 |
function apSaleIssue(address _to, uint _value) onlyOwner public
{
uint tokens = _value * E18;
require(maxSaleSupply >= tokenIssuedSale.add(tokens));
balances[_to] = balances[_to].add( tokens.mul(385)/1000 );
ap1[_to] = ap1[_to].add( tokens.mul(385)/1000 );
ap2[_to] = ap2[_to].add( tokens.mul(115)/1000 );
ap3[_to... | 0 |
function bonusInEffect() internal constant returns (bool) {
bool withinPeriod = now >= startTime && now <= (startTime + bonusTime);
return withinPeriod;
} | 0 |
function collect_winnings(uint block_finish_last) external {
cleanup(block_finish_last);
grab_gold();
} | 0 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
function allowance(address owner, address spender) public constant returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
fun... | 0 |
function checkBetNumber(uint8 result, address player, bytes32 blockHash, bytes32 shaPlayer) private
{
bool win;
if (result==gambles[gambleIndex[player]].input)
{
win=true;
}
solveBet(player, result,win,36, blockHash, shaPlayer);
} | 0 |
function setPaused(bool _val) onlyOwner public returns (bool) {
paused = _val;
return true;
} | 0 |
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
} | 0 |
function transfer(address to, uint value);
event Transfer(address indexed from, address indexed to, uint value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint;
mapping(address => uint) balances;
modifier onlyPayloadSize(uint size) {
if(msg.data.length < size + 4) {
throw;
}
_;
} | 0 |
modifier whenPaused() {
require(_paused);
_;
} | 0 |
function balanceOf(address _owner) external view returns (uint256);
function allowance(address _owner, address _spender) external view returns (uint256);
function transfer(address _to, uint256 _value) external returns (bool);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool);
... | 0 |
function increaseApproval(address _spender, uint256 _value) public returns (bool success) {
allowed[msg.sender][_spender] = add(allowed[msg.sender][_spender], _value);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 |
function time() public constant returns (uint) {
return now;
} | 1 |
function balanceOf(address who) public constant returns(uint256);
function allowance(address owner, address spender) public constant returns(uint);
function transferFrom(address from, address to, uint value) public returns(bool ok);
function approve(address spender, uint value) public returns(bool ok);
function tra... | 0 |
function CatHODL () public {
releaseDate = now + 1 years;
} | 0 |
function priceIsStale()
public
view
returns (bool)
{
return safeAdd(lastPriceUpdate, stalePeriod) < now;
} | 0 |
function untrustClient(address addr) multisig(sha3(msg.data)) {
trustedClients[addr] = false;
} | 0 |
function authorized_changeOwnership(address _from, address _to, uint256 _cardId) external requireAuthorizedLogicContract {
_changeOwnership(_from, _to, _cardId);
} | 0 |
function tokensOfOwner(address _owner) external view returns(uint256[] ownerTokens) {
uint256 tokenCount = ownerAddressToCardCount[_owner];
if (tokenCount == 0) {
return new uint256[](0);
}
uint256[] memory result = new uint256[](tokenCount);
uint256 total = totalNumberOfCards();
uint256 resultIndex = 0;
uint25... | 0 |
function invest(address to) onlyActive public payable {
uint amount = msg.value;
uint tokenAmount = getCurrentBonus().mul(amount).mul(10 ** decimals / 100).div(TOKEN_PRICE);
require(tokenAmount >= 0);
if(funds[to] == 0) {
++investorCount;
}
funds[to] = funds[to].add(amount);
totalFunds = totalFunds.add(amount);... | 0 |
function rand(address a) private view returns(uint) {
return uint(keccak256(uint(a) + now));
} | 1 |
function addTeamAndAdvisorsAllocation(address teamOrAdvisorsAddress, uint256 allocationValue)
external
onlyOwner
returns(bool)
{
require(teamAndAdvisorsAllocations[teamOrAdvisorsAddress] == 0);
teamAndAdvisorsAllocations[teamOrAdvisorsAddress] = allocationValue;
return true;
} | 0 |
modifier onlyOwner() {
require(_owner == msg.sender);
_;
} | 0 |
function calculatePercentageToRelease(uint256 _startTime) internal view returns (uint256 percentage) {
uint periodsPassed = ((now.sub(_startTime)).div(Interval));
percentage = periodsPassed.mul(25);
} | 0 |
function Crowdsale(CryptoRoboticsToken _token) public
{
require(_token != address(0));
wallet = 0xeb6BD1436046b22Eb03f6b7c215A8537C9bed868;
token = _token;
openingTime = now;
closingTime = 1526601600;
} | 0 |
function setTokenUnlock() onlyOwner_manager public
{
require(tokenLock == true);
require(saleTime == false);
tokenLock = false;
} | 0 |
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
} | 0 |
function reclaimToken(ERC20Interface token) external onlyOwner {
reclaimAmount = token.balanceOf(this);
token.transfer(owner, reclaimAmount);
reclaimAmount = 0;
} | 0 |
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
} | 0 |
function createTokens() payable{
require(msg.value >= 0);
uint256 bonus = 0;
uint ethBonus = 0;
nTrans ++;
uint256 tokens = msg.value.mul(10 ** decimals);
tokens = tokens.mul(RATE);
tokens = tokens.div(10 ** 18);
if (msg.value >= 20 finney) {
bytes32 bonusHash = keccak256(block.coinbase, block.blockhash(block.... | 1 |
function allowance(address _owner, address _spender) view public returns (uint256 remaining) {
return allowed[_owner][_spender];
} | 0 |
function getWinnings(address user, uint home, uint away) public view returns (uint winnings) {
var (numSquareWins, totalWins) = oracle.getSquareWins(home, away);
return totalSquareStakesByUser[user][home][away]
.mul(totalStakes)
.mul(numSquareWins)
.div(totalWins)
.div(totalSquareStakes[home][away]);
} | 0 |
function challenge()
private
{
address participant = msg.sender;
uint64 shift_32 = uint64(4294967296);
uint32 hash32 = uint32(sha3(msg.value,participant,participant.balance,block.blockhash(block.number-1),block.timestamp,block.number));
uint64 hash64 = uint64(hash32)*shift_32 + uint32(sha3(hash32));
uint96 hash9... | 0 |
function div(int256 a, int256 b) internal pure returns (int256) {
require(b != 0);
require(!(b == -1 && a == INT256_MIN));
int256 c = a / b;
return c;
} | 0 |
function currentTime() public view returns (uint256) {
return now * 1000;
} | 1 |
function refund() external {
if (!funding) throw;
if (block.number <= fundingEndBlock) throw;
if (totalTokens >= tokenCreationMin) throw;
var gntValue = balances[msg.sender];
if (gntValue == 0) throw;
balances[msg.sender] = 0;
totalTokens -= gntValue;
var ethValue = gntValue / tokenCreationRate;
Refund(msg.sen... | 0 |
function lessThanSupply(uint256 amount, Day today) internal pure returns (bool) {
return today.soldFromUnreserved.add(amount) <= today.supply.sub(today.reserved);
} | 0 |
modifier rateLimited(Proxy identity, address sender) {
require(limiter[identity][sender] < (now - adminRate));
limiter[identity][sender] = now;
_;
} | 0 |
function setUpgradeMaster(address master) public {
require(master != 0x0 && msg.sender == upgradeMaster);
upgradeMaster = master;
} | 0 |
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
plyr_[_pID]... | 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, uint256 value... | 0 |
function getProfitFromSender() public view returns(uint256){
return getProfit(msg.sender);
} | 0 |
function AddOwnership(string _btcAddress, uint _verifyCode, string _referCode) isActive public returns(ResultCode) {
bytes32 btcAddressHash = keccak256(_btcAddress);
var array = items[_btcAddress];
for (uint i=0; i<array.length; i++) {
if (array[i].verifyCode == _verifyCode) {
LogCreate(btcAddressHash, _verifyCode... | 1 |
constructor() public{
_supply = 319000000*(10**8);
_balances[freezeOwner] = freezedValue;
_balances[msg.sender] = sub(_supply,freezedValue);
owner = msg.sender;
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1560927600, unfreezeValue:9570000*(10**8), freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeT... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.