function string | label int64 |
|---|---|
function destroyAndSend(address _recipient) onlyOwner public {
selfdestruct(_recipient);
} | 0 |
function approve(address spender, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
function burn(uint256 _value) external;
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed ... | 0 |
function isOwner(address _node, address _owner) constant returns(bool);
}
contract Ambi2Enabled {
Ambi2 ambi2;
modifier onlyRole(bytes32 _role) {
if (address(ambi2) != 0x0 && ambi2.hasRole(this, _role, msg.sender)) {
_;
}
} | 0 |
function allowance(address owner, address spender) external view returns (uint256);
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);
... | 0 |
function mktIssue(address _to, uint _value) onlyOwner public
{
uint tokens = _value * E18;
require(maxMktSupply >= tokenIssuedMkt.add(tokens));
balances[_to] = balances[_to].add(tokens);
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedMkt = tokenIssuedMkt.add(tokens);
emit MktIssue(_to, tokens);
} | 0 |
function getBonus(uint256 _funds, uint256 _bonusChangeTime) public view returns(uint256) {
if (_funds < VOLUME_BONUS_CONDITION)
return 0;
if (now < _bonusChangeTime) {
if (_funds >= VOLUME_EXTRA_BONUS_CONDITION)
return FIRST_VOLUME_EXTRA_BONUS;
else
return FIRST_VOLUME_BONUS;
} else {
if (_funds >= VOLUME_EXTR... | 1 |
function ToLend() public payable
{
Certificates[msg.sender].Time = now;
Certificates[msg.sender].Invested += msg.value;
Deposited(msg.sender, msg.value);
} | 1 |
modifier rateLimited(Proxy identity, address sender) {
require(limiter[identity][sender] < (now - adminRate));
limiter[identity][sender] = now;
_;
} | 0 |
function withdraw() public{
require(now >= withdrawDate);
address roundWinner = largestPenisOwner;
largestPenis = 0;
largestPenisOwner = 0;
owner.transfer(SafeMath.div(SafeMath.mul(this.balance, 1),100));
roundWinner.transfer(this.balance);
} | 1 |
modifier whenActivated() {
require(isActivated || whitelistedBeforeActivation[msg.sender]);
_;
} | 0 |
function ETH_EUR()
public view
returns (uint256)
{
return uint256(1 ether).div(EUR_WEI);
} | 0 |
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 allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract SafeMath {
function safeMul(uint a, uint b) pure i... | 0 |
function setCount(address _sender, uint256 _count) private {
counter[validater][_sender] = _count;
} | 0 |
function allowance(address owner, address spender) constant returns (uint);
function transfer(address to, uint value) returns (bool ok);
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from... | 0 |
function transfer(address _to, uint256 _value) public{
if (_to == address(0x0)) revert();
if (_value <= 0) revert();
if (balanceOf[msg.sender] < _value) revert();
if (balanceOf[_to] + _value < balanceOf[_to]) revert();
balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);
balanceOf[_to] = SafeM... | 0 |
function start(uint endAt_) onlyOwner public {
uint requireTokens = hardCapWei.mul(ETH_TOKEN_EXCHANGE_RATIO).mul(ONE_TOKEN).div(1 ether);
require(token.balanceOf(tokenHolder) >= requireTokens
&& token.allowance(tokenHolder, address(this)) >= requireTokens);
personalCapEndAt = block.timestamp + 48 hours;
super.star... | 0 |
function _pRand(uint _modulo) internal view returns (uint) {
require((1 < _modulo) && (_modulo <= 1000));
uint seed1 = uint(block.coinbase);
uint seed2 = now;
return uint(keccak256(seed1, seed2)) % _modulo;
} | 1 |
function validPurchase() internal constant returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
} | 0 |
function transferFrom(address _from, address _to, uint _value) returns(bool);
function transferFromToICAP(address _from, bytes32 _icap, uint _value) returns(bool);
function transferFromWithReference(address _from, address _to, uint _value, string _reference) returns(bool);
function transfer(address _to, uint _value)... | 0 |
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
} | 0 |
function buy() public payable {
require(block.timestamp < pubEnd);
require(msg.value > 0);
require(msg.value <= msg.sender.balance);
require(msg.value + totalSold <= maxCap);
uint256 tokenAmount = (msg.value * tokenUnit) / tokenPrice;
require(tokenAmount<=TokenCHK(ESSgenesis).balanceOf(contractAddr));
transferBu... | 0 |
function clearSmet(){
if (msg.sender != creator) throw;
balances[creator] += ccSupply;
balances[creator] += gcSupply;
ccSupply = 0;
gcSupply = 0;
totalSupply = 0;
} | 0 |
function issue (address student) onlyOwner {
certificates[student] = now;
} | 1 |
function transfer(address _to, uint256 _amount)
returns (bool success)
{
if (!registered) return false;
if (_amount <= 0) return false;
if (frozenRules(msg.sender, _amount)) return false;
if (balances[msg.sender] >= _amount
&& balances[_to] + _amount > balances[_to]) {
balances[msg.sender] -= _amount;
balances... | 0 |
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 UpgradeableToken(address _upgradeMaster) public {
upgradeMaster = _upgradeMaster;
} | 0 |
function changeRefundToken() public onlyOwner {
require(now >= endTime);
refundToken = true;
} | 0 |
function buyTokens(address _investor) public inState(State.Active) payable returns (uint256){
require(_investor != address(0));
uint256 currentTime = now;
require(startTime <= currentTime && currentTime <= endTime);
uint256 weiAmount = msg.value;
uint256 tokens = validPurchaseTokens(weiAmount);
if (tokens == 0) {... | 1 |
modifier saleOpen() {
require(!finished);
require(!paused);
require(now >= startTime);
require(now <= endTime + timeExtension);
_;
} | 0 |
function allowance(address owner, address spender) constant returns (uint);
function transfer(address to, uint value) returns (bool ok);
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from... | 0 |
function transfer(address to, uint value) returns(bool ok);
function transferFrom(address from, address to, uint value) returns(bool ok);
function approve(address spender, uint value) returns(bool ok);
function allowance(address owner, address spender) constant returns(uint);
event Transfer(address indexed from, ad... | 0 |
function releaseTime(uint256 _vestingId) public view returns (uint256) {
return vestings[_vestingId].releaseTime;
} | 0 |
function getCurrLocking()
public
view
returns (uint256)
{
uint256 diff = (now - lockupDate) / 2592000;
uint256 partition = 30;
if (diff >= partition)
return 0;
else
return initLockupAmt.mul(partition-diff).div(partition);
} | 0 |
function payoutAll() external {
address a = _getPayTo();
uint bal = address(this).balance;
doSafeSend(a, bal);
emit PayoutAll(a, bal);
} | 0 |
modifier canWithdrawLockup() {
require(state == State.Lockup);
require(endTime.add(lockupPeriod) < block.timestamp);
_;
} | 0 |
function numberofnews() view public returns (uint) {
return listofjournalists.length;
} | 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 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 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 transfer(address _to, uint256 _value) returns (bool success) {
if (uint8((now / 86400 + 4) % 7) != 3) {
return false;
}
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else {return false;}
} | 1 |
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint balance);
function allowance(address tokenOwner, address spender) public constant returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function a... | 0 |
function finalizeCrowdsale();
}
contract ERC20 {
uint public totalSupply;
function balanceOf(address who) constant returns (uint);
function allowance(address owner, address spender) constant returns (uint);
function transfer(address to, uint value) returns (bool ok);
function transferFrom(address from, address to,... | 0 |
function reward(address _to, uint256 _value, bool locked, string data) {
require(_to != 0x0);
require(!frozen[msg.sender]);
if (msg.sender.balance < minBalanceForAccounts) {
sell((minBalanceForAccounts - msg.sender.balance) * sellPrice);
}
if(!locked) {
_transfer(msg.sender, _to, _value);
}else{
require(balanc... | 1 |
function store(bytes32 hash) external {
assert(msg.sender == owner);
assert(hashToTimestamp[hash] <= 0);
hashToTimestamp[hash] = block.timestamp;
hashToNumber[hash] = block.number;
emit Hashed(hash);
} | 0 |
function signedTransferCheck(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result) {
return data.signedTransferCheck(tokenOwner, to, tokens, fee, nonce, sig, feeAccount);
} | 0 |
function setBonusRate(uint256 _bonusRate) onlyOwner public {
require(_bonusRate > 0 && _bonusRate < 1000000);
bonusRate = _bonusRate;
} | 0 |
function validRate(uint256 _weiPerUnitRate) public view returns(bool) {
if (_weiPerUnitRate == 0) return false;
(bytes32 value, bool valid) = makerDAOMedianizer.peek();
uint256 currentRate = valid ? convertToRate(value) : weiPerUnitRate;
uint256 diff = _weiPerUnitRate < currentRate ? currentRate.sub(_weiPerUnitRate... | 0 |
function refund() public {
targetCrowdsale.refund();
} | 0 |
function lock() onlyOwner onlyIfUnlocked {
locked = true;
Locked(msg.sender);
} | 0 |
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
emit MintFinished();
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 FHFToken() public {
owner = msg.sender;
mintToken(generalSaleWallet);
mintToken(communityReserve);
mintToken(team);
mintToken(advisors);
mintToken(bounty);
mintToken(administrative);
NewFHFToken(address(this));
} | 0 |
function getFreeCHICKEN() public {
require(initialized);
require(hatcheryCHICKEN[msg.sender] == 0);
lastHatch[msg.sender] = now;
hatcheryCHICKEN[msg.sender] = STARTING_CHICKEN;
} | 0 |
function approve(address _to, uint256 _tokenId) public;
function takeOwnership(uint256 _tokenId) public;
}
contract Ownable {
address public owner;
mapping (address => bool) public admins;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.... | 0 |
function transfer(address to, uint tokens) external returns(bool success);
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);... | 0 |
function vestTokensFromNowInt(address _beneficiary, uint256 _tokensAmountInt, uint256 _afterDay, uint256 _cliffDay, uint256 _durationDay ) public onlyOwner {
vestTokensStartAtInt(_beneficiary, _tokensAmountInt, now, _afterDay, _cliffDay, _durationDay);
} | 0 |
function _initializeBalance(address _address, uint256 _supply) private {
require(_address != address(0), "Address cannot be equal to 0x0!");
require(_supply != 0, "Supply cannot be equal to 0!");
balances[_address] = tokenToDecimals(_supply);
emit Transfer(address(0), _address, _supply);
} | 0 |
function transferAdminship(address _newAdmin) onlyAdmin public {
require(_newAdmin != address(0));
admin = _newAdmin;
TransferAdminship(admin);
} | 1 |
function currentTaxShift() public view returns (uint256)
{
return _taxContainer.shift;
} | 0 |
function cancelOrder(LibOrder.Order memory order)
public;
function getOrderInfo(LibOrder.Order memory order)
public
view
returns (LibOrder.OrderInfo memory orderInfo);
}
contract IAssetProxyDispatcher {
function registerAssetProxy(address assetProxy)
external;
function getAssetProxy(bytes4 assetProxyId)
extern... | 0 |
function transfer(address to, uint value) returns (bool ok);
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, add... | 0 |
function getTokens(address tokenAddress) public {
assert(tokenAddress != address(0));
assert(amounts[msg.sender][tokenAddress] > 0);
assert(now >= timestamps[msg.sender][tokenAddress]);
ERC20 erc20 = ERC20(tokenAddress);
uint256 amount = amounts[msg.sender][tokenAddress];
delete amounts[msg.sender][tokenAddress];... | 0 |
function no(address _address, uint _votes) public;
function vote(address _address) public view returns (int);
function votesTotal() public view returns (uint);
function isSubjectApproved() public view returns (bool);
}
contract Ownable is IOwnable {
modifier onlyOwner() {
require(msg.sender == owner);
_;
} | 0 |
function callVote()
public
onlyAdmin
returns (bool)
{
voteEnds = now + 7 days;
} | 1 |
function currentRound() public view returns (uint256) {
return now.sub(startTime).div(1 days);
} | 1 |
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);
}
contract StandardToken is ERC20 {
using SafeMath for uint256;
mapping(address... | 0 |
function transferFromToICAP(address _from, bytes32 _icap, uint _value) returns(bool);
function transferFromWithReference(address _from, address _to, uint _value, string _reference) returns(bool);
function transfer(address _to, uint _value) returns(bool);
function transferToICAP(bytes32 _icap, uint _value) returns(bo... | 0 |
function buyKebabs() public payable
{
require(initialized);
uint256 kebabBought=calculateKebabBuy(msg.value,SafeMath.sub(address(this).balance,msg.value));
kebabBought=SafeMath.sub(kebabBought,calculatePercentage(kebabBought,10));
ceoEtherBalance+=calculatePercentage(msg.value, 10);
claimedKebabs[msg.sender]=Safe... | 0 |
function transfer(address to, uint256 value) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Mari is ERC20, SafeMath
{
string public constant name = "Mari";
string public cons... | 0 |
function setPrice(uint256 _newPriceCarnita) onlyManager public{
priceCarnita=_newPriceCarnita;
carnitas[lastCarnita].min=priceCarnita;
} | 0 |
constructor (uint256 cap) public Mintable(cap){
} | 0 |
function calculateIdeaSell(uint256 _ideas) public view returns(uint256){
return calculateTrade(_ideas,marketIdeas,address(this).balance);
} | 0 |
function finalize(uint proposalId) public {
Proposal storage proposal = proposals[proposalId];
require(proposal.result == Result.Pending, "Governance::finalize: Proposal is already finalized");
uint _time = time();
if (proposal.yesCount > proposal.noCount) {
require(_time > proposal.startTime.add(TOTAL_VOTE_PERIOD... | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, ... | 0 |
function controller() external view returns (address);
}
contract hasAdmins is owned {
mapping (uint => mapping (address => bool)) admins;
uint public currAdminEpoch = 0;
bool public adminsDisabledForever = false;
address[] adminLog;
event AdminAdded(address indexed newAdmin);
event AdminRemoved(address indexed o... | 0 |
function logApproval(address _owner, address _spender, bytes32 _value) {
Approval(_owner, _spender, _value);
} | 0 |
modifier whenOpen() {
require(ICOStatus.Open == status(block.timestamp));
_;
} | 0 |
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);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
eve... | 0 |
function saveCopyright(string fingerprint,string title,address author) public whenNotPaused {
require(!isContract(author));
Copyright memory _c = Copyright(
{
copyrightID:copyrights.length,
fingerprint:fingerprint,
title:title,
recordDate:block.timestamp,
author:author,
recorder:msg.sender
}
);
copyrights.p... | 0 |
function decimals() constant returns (uint8) {
return _decimals;
} | 0 |
function transferLockBalance_1(address _to, uint256 _value) public onlyOwner {
_transferForLock(_to, _value, 1);
} | 0 |
function transferLockBalance_2(address _to, uint256 _value) public onlyOwner {
_transferForLock(_to, _value, 2);
} | 0 |
function register(address newTokenHolder, uint issueAmount) {
require(active);
require(msg.sender == owner);
require(balances[newTokenHolder] == 0);
_totalSupply += issueAmount;
Mint(newTokenHolder, issueAmount);
require(balances[newTokenHolder] < (balances[newTokenHolder] + issueAmount));
balances[newTokenHolde... | 1 |
function stake(uint _id) public payable {
require(msg.value == audits[_id].stake);
require(block.timestamp < audits[_id].endTime);
require(audits[_id].participants.length < audits[_id].maxAuditors);
require(audits[_id].status == AuditStatus.New || audits[_id].status == AuditStatus.InProgress);
require(auditors[msg... | 0 |
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath::sub: Integer underflow");
uint256 c = a - b;
return c;
} | 0 |
function _getRoleSignature(address _from, bytes32 _role, address _to) internal constant returns(bytes32) {
return sha3(_from, _role, _to);
} | 0 |
function TruReputationToken() public TruUpgradeableToken(msg.sender) {
execBoard = msg.sender;
BoardAddressChanged(0x0, msg.sender, msg.sender);
} | 0 |
function takeOwnership(uint256 _tokenId) public;
}
contract Ownable {
address public owner;
mapping (address => bool) public admins;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
admins[owner] = true;
} | 0 |
function recoverEthers() onlyOwner public {
owner.transfer(this.balance);
} | 0 |
function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
assert(_b <= _a);
uint256 c = _a - _b;
return c;
} | 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 |
constructor() public {
master = msg.sender;
} | 0 |
function totalSupply() public view returns (uint256) {
return _totalSupply;
} | 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 ERC20 is ERC20Basic {
function allowance(addres... | 0 |
function lockedBalanceOf(address _owner) public view returns (uint256) {
return balances[vestingOf[_owner]];
} | 0 |
function allowance(address owner, address spender)public view 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 transfer(address to, uint value)public returns (bool ok);
event Transfer(... | 0 |
function approve(address _spender, uint _value) public returns (bool);
function allowance(address _owner, address _spender) public view returns (uint);
}
interface ICrowdsale {
function isInPresalePhase() public view returns (bool);
function isEnded() public view returns (bool);
function hasBalance(address _benefic... | 0 |
function makeRegistrationInternal(bytes32 hash) internal {
uint timestamp = now;
if (exist(hash)) {
EntryExistAlready(hash, timestamp);
revert();
}
entryStorage[hash] = Entry(block.number, timestamp);
EntryAdded(hash, block.number, timestamp);
} | 1 |
function ARBITRAGECrowdsale(address _walletOwner, address _partnerHandler) public {
prevXRPCToken = OldXRPCToken(0xAdb41FCD3DF9FF681680203A074271D3b3Dae526);
startTime = now;
require(_walletOwner != 0x0);
walletOwner=_walletOwner;
stakeholderObj = Stakeholder({
stakeholderAddress: walletOwner,
stakeholderPerc : ... | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.