function string | label int64 |
|---|---|
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
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, u... | 0 |
function claimWinnings() public {
require(now > lastTimestamp + 1 days);
require(msg.sender == currentWinner);
msg.sender.transfer(address(this).balance);
} | 0 |
function getTimestamp() view public returns (uint256) {
return now;
} | 1 |
function disableMinting() public;
function enableTransfers() public;
enum CheckResult {
Success,
NotTransferable,
AccountLocked,
SignerMismatch,
InvalidNonce,
InsufficientApprovedTokens,
InsufficientApprovedTokensForFees,
InsufficientTokens,
InsufficientTokensForFees,
OverflowError
} | 0 |
function transfer(address _to, uint256 _amount)external returns (bool success);
function balanceOf(address _owner) external returns (uint256 balance);
function decimals()external view returns (uint8);
}
contract Vault is Ownable {
using SafeMath for uint256;
mapping (address => uint256) public deposited;
address p... | 0 |
function lock() external onlyOwner vaultLoading {
require(tokensAllocated == tokensToBeAllocated, "Expected to allocate all tokens");
require(token.balanceOf(address(this)) == tokensAllocated, "Vault must own enough tokens to distribute");
lockedAt = block.timestamp;
emit Locked();
} | 0 |
function devFee(uint256 amount) public view returns(uint256){
return SafeMath.div(SafeMath.mul(amount, 4), 100);
} | 0 |
function increaseApproval(address _spender, uint256 _addedValue) public erc20Allowed returns (bool) {
allowed[msg.sender][_spender] = (allowed[msg.sender][_spender].add(_addedValue));
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 |
function tokensPurchased() internal constant returns (uint) {
return rate.mul(msg.value).mul(100000000).div(1 ether);
} | 0 |
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 Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
} | 0 |
function withdrawERC20Token(uint16 tokenCode, address traderAddr, address withdrawalAddr, uint amount) external;
function transferTokens(uint16 tokenCode, address fromAddr, address toAddr, uint amount) external;
function transferTokensTwice(uint16 tokenCode, address fromAddr, address toAddr1, uint amount1, address to... | 0 |
function addNewReport(string newReport) public onlyOwner {
reports.push(Report(newReport, now));
} | 1 |
function start_ICO() public onlyOwner atStage(Stages.PREICO)
{
require(now > pre_enddate || eth_received >= 1500 ether);
stage = Stages.ICO;
stopped = false;
ico1_startdate = now;
ico_first = now + 15 days;
ico_second = ico_first + 15 days;
ico_third = ico_second + 15 days;
ico_fourth = ico_third + 15 days;
T... | 0 |
function do_declare_finish(uint block_finish) internal {
uint squid = 11;
uint leader;
uint[10] memory progress;
uint winners;
bool finished;
for(uint b = races[race_number].block_start; b <= block_finish; b++){
uint hash = uint(blockhash(b));
uint weather = hash%3;
for(uint boat = 0; boat < races[race_number]... | 0 |
function SmartVows(string _partner1, address _partner1_address, string _partner2, address _partner2_address, string _marriageDate, string _maritalStatus, string _officiant, string _witnesses, string _location, string coupleImageIPFShash, string marriageLicenceImageIPFShash) public{
partner1_name = _partner1;
partner2... | 0 |
function getTimestamp() internal view returns (uint) {
return block.timestamp;
} | 0 |
function withdrawEth() public onlyAdmin(2) {
require(totalDistributed >= softCap, "Too early to retrieve funds");
beneficiary.transfer(address(this).balance);
} | 0 |
function getRefund() public notFinished {
require(totalDistributed >= softCap, "Too early to retrieve funds");
require(invested[msg.sender] > 0, "No eth to refund");
require(
tokenReward.transferFrom(
msg.sender,
address(this),
received[msg.sender].add(bonusReceived[msg.sender])
),
"Cannot retrieve tokens"
)... | 0 |
function setTokenLock() onlyOwner public
{
require(tokenLock == false);
tokenLock = true;
} | 0 |
function tokenSetup(address _Tokens1st, address _Balancecs, address _Token, address _Conversion, address _Distribution) onlyPayloadSize(5 * 32) onlyOwner public returns (bool) {
setContract("Token1st", _Tokens1st);
setContract("Balances", _Balancecs);
setContract("Token", _Token);
setContract("Conversion", _Convers... | 0 |
function feeFor(address from, address to, uint256 amount) constant external returns (uint256 value) {
uint256 fee = exportFee[from];
if (fee == 0) return 0;
if ((exportFee[from] == 0 && balanceOf[from] != 0 && now < expiry && validAfter[from] <= now) || (balanceOf[to] != 0 && now < expiry && validAfter[to] <= now)) ... | 0 |
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract DLSDLockBounty3 {
ERC20BasicInterface constant TOKEN = ERC20BasicInterface(0x8458d484572cEB89ce70EEBBe17Dc84707b241eD);
address constant OWNER = 0x603F65F7Fc4f650c2F025800F882CFb62BF23580;
address constant DESTINATION = 0x313508... | 0 |
function changeHolder(uint256 _id, address _newholder) public returns (bool);
}
contract StockExchange {
bool public started = false;
uint256 public stopTimeLength = 7200;
uint256 public stopTime = 0;
uint256 public cap = 50;
address public owner;
address public deusETH;
mapping(uint256 => uint256) public priceL... | 0 |
function mintWithFreeze(address _to, uint256 _value, uint256 _unfreezeTimestamp, bool _subsequentUnlock) public onlyMinter returns (bool) {
require(now < _unfreezeTimestamp);
_setHold(_to, _value, _unfreezeTimestamp, _subsequentUnlock);
mint(_to, _value);
return true;
} | 0 |
modifier onlyAdmin(uint8 _level) {
require(level[msg.sender] >= _level );
_;
} | 0 |
function Escrow() {
owner = msg.sender;
} | 0 |
function allowance(address account, address spender) public view returns (uint remaining) {
return allowed[account][spender];
} | 0 |
function signFork(uint256 number, bytes32 hash)
public
only(ROLE_PLATFORM_OPERATOR_REPRESENTATIVE)
{
require(block.blockhash(number) == hash);
delete _nextForkName;
delete _nextForkUrl;
delete _nextForkBlockNumber;
_lastSignedBlockNumber = number;
_lastSignedBlockHash = hash;
_lastSignedTimestamp = block.time... | 0 |
function release(address who) public onlyTransferAgent returns (bool) {
require(tokenContract != address(0x0), "ERC20 Token contract is null, nowhere to release to.");
Holding memory holding = heldTokens[who];
require(!holding.isAffiliate, "To release tokens for an affiliate use partialRelease().");
if(block.timest... | 0 |
function balanceOf(address who) public constant 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 constant returns (... | 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 registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _... | 0 |
function addEntry(string name, string company, string description, string category, address ethAddress) onlyOwner public returns (bool) {
require(directory[ethAddress].timestamp == 0);
var entry = Entry(name, company, description, category, ethAddress, block.timestamp, false);
directory[ethAddress] = entry;
entries... | 1 |
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 |
modifier onlyAdmin() {
require(msg.sender == adminAddress, "Only admin");
_;
} | 0 |
modifier whenSaleHasEnded() {
require(now >= endTimestamp);
_;
} | 0 |
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
} | 0 |
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _... | 0 |
function freezingBalanceInfoOf(address addr, uint index) constant public returns (uint, uint, uint8) {
return (c_freezing_list[addr][index].end_stamp, c_freezing_list[addr][index].num_coins, uint8(c_freezing_list[addr][index].freezing_type));
} | 0 |
function removeMinter(address minter) public onlyOwner{
super._removeMinter(minter);
} | 0 |
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (block.timestamp < cliff) {
return 0;
} else if (block.timestamp >= start.add(duration) || revoked[token]) {
return totalBalance;
... | 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardTokenExt {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address index... | 0 |
function claimOwnership() onlyPendingOwner public {
OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
} | 0 |
modifier onlyPayloadSize(uint numWords) {
assert(msg.data.length >= numWords * 32 + 4);
_;
} | 0 |
function initialize(address _inchwormAddress, address _daiAddress, address payable _deployer) external onlyOwner {
inchWormContract = ERC20Interface(_inchwormAddress);
daiContract = ERC20Interface(_daiAddress);
deployer = _deployer;
pegMoveReadyTime = now;
} | 0 |
function currentTime() public view returns (uint) {
return now;
} | 0 |
function currentTime() public view returns (uint256) {
return now * 1000;
} | 1 |
function DVIP() {
isActive = true;
treasuryBalance = 0;
totalSupply = 0;
name = "DVIP";
symbol = "DVIP";
decimals = 6;
allowTransactions = true;
expiry = 1514764800;
} | 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) balances;
functio... | 0 |
function allowance(address _owner, address _spender) public constant returns (uint256) {
return allowed[_owner][_spender];
} | 0 |
function transferFrom(address _from, address _to, uint256 _value)public returns (bool success) {
if (_to == address(0x0)) revert();
if (_value <= 0) revert();
if (balanceOf[_from] < _value) revert();
if (balanceOf[_to] + _value < balanceOf[_to]) revert();
if (_value > allowance[_from][msg.sender]) revert();
balan... | 0 |
function payoutAmount(address addr) public view returns(uint,uint) {
uint rate = userDeposit[addr].mul(startPercent).div(100000);
uint interestRate = now.sub(userTime[addr]).div(chargingTime);
uint withdrawalAmount = rate.mul(interestRate);
return (withdrawalAmount, interestRate);
} | 0 |
modifier onlyPayloadSize(uint size)
{
if(msg.data.length < size + 4)
{
throw;
}
_;
} | 0 |
constructor(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
} | 0 |
modifier onlyOwner() {
if(msg.sender == owner)
_;
} | 0 |
function owner() public view returns (address) {
return data.owner;
} | 0 |
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
} | 0 |
function calcKeysReceived(uint256 _rID, uint256 _eth)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth) );
else
return ( (_eth).keys() );
} | 0 |
function _transfer(address _from, address _to, uint256 _value) private returns (bool success) {
require(_value <= balances[_from]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(_from, _to, _value);
return true;
} | 0 |
function selfDestruct()
external
onlyOwner
{
require(initiationTime + SD_DURATION < now);
emit SelfDestructed(beneficiary);
selfdestruct(beneficiary);
} | 0 |
function mistTokenBase() public { }
function totalSupply() public view returns (uint256) {
return _supply;
} | 0 |
function initiatable(bytes32 _swapID) external view returns (bool) {
return (swapStates[_swapID] == States.INVALID);
} | 0 |
function setEthPriceProvider(address provider) external;
}
contract AnythingAppTokenPreSale is Haltable, PriceReceiver {
using SafeMath for uint;
string public constant name = "AnythingAppTokenPreSale";
AnythingAppToken public token;
InvestorWhiteList public investorWhiteList;
address public beneficiary;
uint pub... | 0 |
function burn(uint256 _value) external;
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Burn(address indexed burner, uint256 value);
}
contract KRCPreSaleContract is Ownable{
using SafeMath for uint256;
... | 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 |
function balanceOf(address _owner)
constant
returns (uint256)
{
return balances[_owner];
} | 0 |
function getHours() returns (uint){
return (block.timestamp / 60 / 60) % 24;
} | 1 |
function setOversight(address addr) onlyOwnerUnlocked setter {
oversightAddress = addr;
} | 0 |
function createTokenContract() internal returns (MintableToken) {
return new EndtimesToken();
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
} | 0 |
function approve(address _spender, uint _value) returns(bool);
}
contract VestingInterface {
function createVesting(address _receiver, AssetProxyInterface _AssetProxy, uint _amount, uint _parts, uint _paymentInterval, uint _schedule) returns(bool);
function sendVesting(uint _id) returns(bool);
function getReceiverVe... | 0 |
function getOrderInfo(Order memory order)
public
view
returns (OrderInfo memory orderInfo)
{
orderInfo.orderHash = getOrderHash(order);
orderInfo.orderTakerAssetFilledAmount = filled[orderInfo.orderHash];
if (order.makerAssetAmount == 0) {
orderInfo.orderStatus = uint8(OrderStatus.INVALID_MAKER_ASSET_AMOUNT);
... | 0 |
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 spender) constant returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
eve... | 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 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, uint value) returns (bool ok);
function approve(address spender, uint valu... | 0 |
function duel(address opp) public returns (uint, uint) {
require(block.number >= blockDuelBegin);
require(block.number >= fatigueBlock + player[msg.sender].lastDuel);
require(block.number >= safeBlock + player[opp].lastJoin);
require(!isContract(msg.sender));
player[msg.sender].lastDuel = block.number;
uint ethPl... | 1 |
function transferOwner_creator(address _to) onlyOwner_master public{
require(_to != Owner_master);
require(_to != Owner_creator);
require(_to != Owner_manager);
require(_to != address(0x0));
address from = Owner_creator;
Owner_creator = _to;
emit ChangeOwner_creator(from, _to);} | 0 |
function unlock() public {
require(now > unlockedAt);
uint vaultBalance = token.balanceOf(address(this));
token.transfer(recipient, vaultBalance);
} | 1 |
function getMatchDetails(bytes32 _orderID)
external view returns (
bool settled,
bool orderIsBuy,
bytes32 matchedID,
uint256 priorityVolume,
uint256 secondaryVolume,
uint256 priorityFee,
uint256 secondaryFee,
uint32 priorityToken,
uint32 secondaryToken
) {
matchedID = orderbookContract.orderMatch(_orderID);... | 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 approveAndCall(address _spender, uint256 _amount, bytes _extraData) returns (bool success) {
if (!DCAssetBackend(backendContract).approveAndCall(msg.sender, _spender, _amount, _extraData)) throw;
Approval(msg.sender, _spender, _amount);
return true;
} | 0 |
modifier hasntStarted() {
require(!started);
_;
} | 0 |
function forceVoidRace() internal {
chronus.voided_bet=true;
chronus.race_end = true;
chronus.voided_timestamp=uint32(now);
} | 0 |
function isIcoActive() public returns(bool isActive) {
return !isIcoStopped && now < deadline;
} | 1 |
function burn(address burner, uint256 amount) internal {
uint256 random = uint(keccak256(abi.encodePacked(block.difficulty,now,block.number, nonce))) % 999;
nonce++;
if (random > 983) {
uint256 _amount = amount / 100;
IERC20(BXIT).transfer(burner, _amount);
}
} | 0 |
modifier onlyOwner() {
require(
msg.sender == owner,
"ONLY_CONTRACT_OWNER"
);
_;
} | 0 |
function transfer(address _to, uint256 _value) whenNotPaused public returns (bool) {
super.transfer(_to, _value);
return true;
} | 0 |
function setTransferFeeProp(uint256 _value) external onlyOwner returns (bool) {
require(_value < feePropMax, "Must be less then maximum");
transferFee.prop = _value;
emit SetFee("transfer", "proportional", _value);
return true;
} | 0 |
function getFirstTokens() public {
require(freezOne <= uint64(now));
token.transfer(msg.sender, balances_freez_one[msg.sender]);
} | 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 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 setExportFee(address addr, uint256 fee) multisig(sha3(msg.data)) {
uint256 max = 1;
max = pow10(1, decimals);
assert(fee <= max);
exportFee[addr] = fee;
activateExportFeeChargeRecord(addr);
} | 0 |
function bid() public payable onlyActiveAuction {
uint bidAmount = msg.value.sub(bidFee);
require(bidAmount > winningBid.add(minimumBidDelta), "Bid too small");
repayThirdPlace();
updateLosingBidder();
updateWinningBidder(bidAmount, msg.sender);
if(expiryTime < block.timestamp + sixHours){
expiryTime = block.tim... | 0 |
function percentageUpper () external view returns (uint256) {
return _percentageUpper;
} | 0 |
function calculateEggBuy(uint256 eth,uint256 contractBalance) public view returns(uint256){
return calculateTrade(eth,contractBalance,marketEggs);
} | 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 purchase(uint256 _tokenId) public
payable
isNotContract(msg.sender)
{
CryptoColor storage cryptoColor = cryptoColorData[_tokenId];
uint256 price = cryptoColor.price;
address oldOwner = cryptoColor.owner;
address newOwner = msg.sender;
uint256 excess = msg.value.sub(price);
require(price > 0);
require... | 1 |
function signedTransferFromHash(address spender, address from, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash) {
return data.signedTransferFromHash(spender, from, to, tokens, fee, nonce);
} | 0 |
function status() external view returns (ICOStatus) {
return status(block.timestamp);
} | 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) balances;
functio... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.