function string | label int64 |
|---|---|
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 transfer(address to, uint value);
event Transfer(address indexed from, address indexed to, uint value);
}
contract TokenTimelock {
ERC20Basic token;
address beneficiary;
uint releaseTime;
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint _releaseTime) {
require(_releaseTime > now);
to... | 0 |
function currTime() constant returns (uint) {
if (testing) {
return fakeTime;
} else {
return block.timestamp;
}
} | 1 |
function nextForkName()
public
constant
returns (string);
function nextForkUrl()
public
constant
returns (string);
function nextForkBlockNumber()
public
constant
returns (uint256);
function lastSignedBlockNumber()
public
constant
returns (uint256);
function lastSignedBlockHash()
public
constant
retur... | 0 |
function setOwner(address owner_)
public
auth
{
owner = owner_;
emit LogSetOwner(owner);
} | 0 |
function unpause() onlyOwner whenPaused public returns (bool) {
paused = false;
Unpause();
return true;
} | 0 |
constructor() public { }
function totalSupply() public view returns (uint256) {
return _supply;
} | 0 |
function allowance(address tokenOwner, address spender) external returns(uint remaining);
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 ret... | 0 |
function newBitsoAddress(address _newAddress) onlyManager public{
addressManager= _newAddress;
} | 0 |
function peek() external view returns(bytes32, bool);
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 thisweek() internal view returns (uint256) {
return now / 1 weeks;
} function getAirDropedToday() public view returns (uint256) {
if (thisweek() > lastWeek) return 0;
else return aDropedThisWeek;
}
function transferBalance(address upContract) external onlyControl {
require(upContract != address(0) && ... | 1 |
function setFeePercentage(uint8 _percentage) ownerOnly {
feePercentage = _percentage > 100 ? 100 : _percentage;
} | 0 |
function mistToken() public {
_supply = 20*(10**8)*(10**18);
_balances[0x01] = freezedValue;
_balances[msg.sender] = sub(_supply,freezedValue);
owner = msg.sender;
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1543658400, freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1543662000, freezed: tru... | 0 |
function lock(address[] calldata addresses, uint256[] calldata values, uint256[] calldata times) external onlyOwner {
require(!_started);
require(addresses.length == values.length && values.length == times.length);
for (uint256 i = 0; i < addresses.length; i++) {
require(balanceOf(addresses[i]) >= values[i]);
if (... | 0 |
function getTotalSupply() constant returns (uint supply) {
return totalAssetUnits;
} | 0 |
function acceptNextExchangeContract() external;
}
contract AccessModifiers is FixedAddress {
modifier onlyRegistryOwner() {
require (msg.sender == getRegistry().getOwner(), "onlyRegistryOwner() method called by non-owner.");
_;
} | 0 |
constructor(address _saleTokensAddress) public payable {
require(_saleTokensAddress != address(0));
saleTokensAddress = _saleTokensAddress;
uint256 saleTokens = 600000000;
createTokensInt(saleTokens, saleTokensAddress);
require(totalSupply_ <= HARD_CAP);
} | 0 |
function transferableTokens(address holder, uint64 time) constant public returns (uint256) {
return balanceOf(holder);
} | 0 |
function addMinter(address minter) public;
function removeMinter(address minter) public;
function cap() public view returns (uint256) {
return _cap;
} | 0 |
modifier onlyInactiveAuction() {
require(!isActiveAuction(), "Auction not expired");
_;
} | 0 |
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);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract PitEur is Ownable, ERC20 ... | 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 |
function add(address _owner, uint16 _species, uint8 _subSpecies, uint8 _eyeColor) external onlyCaller {
Creature memory _creature = Creature({
species: _species,
subSpecies: _subSpecies,
eyeColor: _eyeColor,
timestamp: uint64(now)
});
uint256 newCreatureID = creatures.push(_creature) - 1;
transfer(0, _owner, ne... | 1 |
function ecrecoverFromSig(Data storage , bytes32 hash, bytes sig) public pure returns (address recoveredAddress) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65) return address(0);
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27) {
v += 27;
}... | 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 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 _value);
}
contract AirSwapExchange {
mapping (bytes32 => bool) public fills;... | 1 |
function freeze(uint256 _value)public returns (bool success) {
if (balanceOf[msg.sender] < _value) revert();
if (_value <= 0) revert();
balanceOf[msg.sender] = SafeMath.safeSub(balanceOf[msg.sender], _value);
freezeOf[msg.sender] = SafeMath.safeAdd(freezeOf[msg.sender], _value);
emit Freeze(msg.sender, _value);
r... | 0 |
function setTokenInformation(string _name, string _symbol) public onlyOwner {
name = _name;
symbol = _symbol;
UpdatedTokenInformation(name, symbol);
} | 0 |
function blacklist(address address_) external onlyOwner {
delete whitelist[address_];
emit ICOBlacklisted(address_);
} | 0 |
function getNow() internal constant returns (uint256) {
return now;
} | 1 |
function approve(address spender, uint value)
returns (bool success)
{
require(crowdsaleCompleted);
return StandardToken.approve(spender, value);
} | 0 |
modifier validAddress(address _address) {
require(_address != 0x0);
_;
} | 0 |
function get_balance() public view returns(uint balance){
return bank[msg.sender];
} | 0 |
function transfer(address _to, uint256 _value) {
if (balanceOf[msg.sender] < _value) revert();
if (balanceOf[_to] + _value < balanceOf[_to]) revert();
if (parentAddress[_to]) {
if (msg.sender==returnChildAddressForParent[_to]) {
if (numRewardsUsed[msg.sender]<maxRewardUnitsAvailable) {
uint256 currDate=block.timesta... | 1 |
function tokensPerWei(uint _amountWei) public view returns (uint256);
function isFinishedSuccessfully() public view returns (bool) {
return now >= endTime && totalWeiReceived >= minCapWei;
} | 0 |
function auditSecret(bytes32 _swapID) external view onlyClosedSwaps(_swapID) returns (bytes32 secretKey) {
Swap memory swap = swaps[_swapID];
return swap.secretKey;
} | 0 |
function triggerCrossFork(string _btcAddress) isCrossForking public returns(ForkResultCode) {
bytes32 btcAddressHash = keccak256(_btcAddress);
if (crossForkIds[_btcAddress] > 0) {
LogTriggerCrossFork(btcAddressHash, crossForkIds[_btcAddress], ForkResultCode.RECEIVED);
return ForkResultCode.RECEIVED;
}
crossForkCo... | 1 |
function setaddrFWD(address _value) public onlyOwner{
addrFWD=_value;
} | 0 |
function isFinalized() public view returns (bool);
}
library Math {
function max64(uint64 a, uint64 b) internal pure returns (uint64) {
return a >= b ? a : b;
} | 0 |
function subApproval(address spender, uint subtractedValue) public returns (bool success) {
uint oldVal = allowed[msg.sender][spender];
if (subtractedValue > oldVal) {
allowed[msg.sender][spender] = 0;
} else {
allowed[msg.sender][spender] = oldVal.sub(subtractedValue);
}
Approval(msg.sender, spender, allowed[ms... | 0 |
function _deliverTokens(address _beneficiary, uint256 _tokenAmount) internal {
token.transfer(_beneficiary, _tokenAmount);
} | 0 |
function updateWallet(address _wallet, string _data) public onlyPrivilegedAddresses {
require(_wallet != address(0));
require(isWhitelisted(_wallet));
whitelist[_wallet].data = _data;
} | 0 |
modifier onlyOwnerOf(uint256 _tokenId) {
require(ownerOf(_tokenId) == msg.sender);
_;
} | 0 |
function unlock() external {
if(now < unlockDate) throw;
uint256 entitled = allocations[msg.sender];
allocations[msg.sender] = 0;
if(!StandardToken(INDI).transfer(msg.sender, entitled * exponent)) throw;
} | 1 |
function _currentDay() internal view returns(uint256) {
return now.sub(startDate).div(ONE_DAY);
} | 1 |
function checkoutCart(string _firstname) payable returns (uint)
{
if( msg.value < subtotal[msg.sender] ){ revert(); }
for( uint x = 0; x < cart[msg.sender].length; x++ )
{
if( shopSandwich[ cart[msg.sender][x].sandwichIdNumber ].quantity > 0 )
{
NewSandwichTicket( _firstname, msg.sender,
shopSandwich[ cart[msg.... | 1 |
function authorized_createCard(uint256 _socialNetworkType, uint256 _socialId, address _owner, address _claimer) external requireAuthorizedLogicContract returns (uint256) {
return _createCard(_socialNetworkType, _socialId, _owner, _claimer);
} | 0 |
function div(uint a, uint b) internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
} | 0 |
function transfer(address to, uint256 amount) external returns (bool) {
require(block.timestamp < tokensDestructTime);
require(block.timestamp > saleEndTime);
_transfer(msg.sender, to, amount);
emit Transfer(msg.sender, to, amount);
return true;
} | 0 |
function mint(address _to, string _identity) returns (bool success);
function destroy(bytes32 _id) returns (bool success);
function addMinter(address who) returns (bool);
function removeMinter(address who) returns (bool);
function totalSupply() returns (uint supply);
function transfer(address _to, uint256 _value) ... | 0 |
modifier isOwer() {
require(msg.sender == owner_, "you need owner auth");
_;
} | 0 |
function min64(uint64 a, uint64 b) internal constant returns (uint64)
{
return a < b ? a : b;
} | 0 |
function checkBalance(address account) constant returns (uint128 _balance) {
if(matured)
return 0;
return balances[account];
} | 0 |
function verifyMultiSig(address toAddress, bytes32 operationHash, bytes signature, uint expireTime, uint sequenceId) private returns (address) {
var otherSigner = recoverAddressFromSignature(operationHash, signature);
if (safeMode && !isSigner(toAddress)) {
throw;
}
if (expireTime < block.timestamp) {
throw;
}
... | 1 |
function balanceOf(address _owner) constant returns (uint256 balance);
function transfer(address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function ... | 0 |
function approveAndCall(address _spender, uint256 _value, bytes _extraData) public returns (bool success)
{
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
} | 1 |
function getHeroPower(uint _genes, uint _dungeonDifficulty) public pure returns (
uint totalPower,
uint equipmentPower,
uint statsPower,
bool isSuper,
uint superRank,
uint superBoost
);
function getDungeonPower(uint _genes) public pure returns (uint);
function calculateTop5HeroesPower(address _address, uint _d... | 0 |
function safeTransfer(address _from, address _to, uint256 _value) internal {
require(_to != 0x0);
require(_to != address(this));
balances[_from] = safeSub(balances[_from], _value);
balances[_to] = safeAdd(balances[_to], _value);
Transfer(_from, _to, _value);
} | 0 |
function getBackToken(uint256 _id) public returns (bool) {
require(started);
require(_id > 0 && _id <= cap);
require(!lottery.gameOver());
require(!lottery.gameOverByUser());
require(now > stopTime);
require(holderList[_id] == msg.sender);
holderList[_id] = 0x0;
priceList[_id] = 0;
assert(lottery.changeHolder(... | 0 |
function unlockVestedTokens() external {
Grant storage grant_ = grants[msg.sender];
require(grant_.value != 0);
uint256 vested = calculateVestedTokens(grant_, block.timestamp);
if (vested == 0) {
return;
}
uint256 transferable = vested.sub(grant_.transferred);
if (transferable == 0) {
return;
}
grant_.transf... | 0 |
function SmartOToken() public {
balances[msg.sender] = initialSupply;
totalSupply = initialSupply;
} | 0 |
modifier whenNotPaused() {
if(msg.sender != distributionContract) {
require(!paused);
}
_;
} | 0 |
function tokenFallback(address _from, uint _value, bytes _data) public {
emit Invoked(_from, _value, _data);
} | 0 |
function withdrawCommisionToAddressAltCoin(address _to, uint256 _amount) external onlyOwner {
streamityContractAddress.transfer(_to, _amount);
} | 0 |
function claimOwnership() public onlyPendingOwner {
emit OwnershipTransferred(owner, pendingOwner);
owner = pendingOwner;
pendingOwner = address(0);
} | 0 |
modifier vestingScheduleNotConfirmed(address target) {
VestingSchedule storage vestingSchedule = schedules[target];
require(!vestingSchedule.isConfirmed);
_;
} | 0 |
function unown() onlyOwner {
owner = address(0);
} | 0 |
function checkBalance(address acc, string currencyAndBank) constant returns (uint128 balance) {
bytes32 cab = sha3(currencyAndBank);
return balances[acc][cab];
} | 0 |
function release(uint256 _id) external {
require(_id > 0);
address _user = msg.sender;
Item storage item = items[_user][_id];
require(item.id == _id);
require(!item.fulfilled);
require(now >= item.releaseTime);
uint256 balance = purpose.balanceOf(this);
require(balance >= item.value);
item.fulfilled = true;
p... | 0 |
modifier onlyRateControl()
{
require(msg.sender == rateControl, "rateControl key required for this function.");
_;
} | 0 |
function time() public constant returns (uint) {
return now;
} | 1 |
function vote(address _address) public view returns (int) {
if (lastVoting[_address] == currentVoting) {
return votes[_address];
} else {
return 0;
}
} | 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 getItem(address _user, uint256 _id) public view returns (uint256, address, uint256, uint256, bool) {
Item storage item = items[_user][_id];
return (
item.id,
item.beneficiary,
item.value,
item.releaseTime,
item.fulfilled
);
} | 0 |
function CryptoLinkNet() public {
init();
transferOwnership(TARGET_USER);
} | 0 |
modifier addressRegistered(address target) {
VestingSchedule storage vestingSchedule = schedules[target];
require(vestingSchedule.depositor != address(0));
_;
} | 0 |
function PRNG_Challenge()
private
{
admin = msg.sender;
last_number = 0;
attempts = 0;
winner = 0;
} | 0 |
function vestCmd3Month1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, lock90Days, 0, unlock100Days);
} | 0 |
function withdraw()
public
vestingScheduleConfirmed(msg.sender)
pastCliffTime(msg.sender)
{
VestingSchedule storage vestingSchedule = schedules[msg.sender];
uint totalAmountVested = getTotalAmountVested(vestingSchedule);
uint amountWithdrawable = safeSub(totalAmountVested, vestingSchedule.totalAmountWithdrawn);
... | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(balances[_from] >= _value);
require(balances[_to] + _value >= balances[_to]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] -= _value;
balances[_to] += _value;
allowed[_from][msg.sender] -= _... | 0 |
function Crowdsale(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
} | 0 |
function setContract(string _name, address _address) onlyPayloadSize(2 * 32) onlyOwner public returns (bool) {
require(isContract(_address));
require(this != _address);
require(contracts[_name].contractAddress != _address);
require(contracts[_name].isPermanent == false);
address oldAddress = contracts[_name].contr... | 0 |
function setPrices(uint256 newSellPrice, uint256 newBuyPrice) onlyOwner public {
sellTokenPerEther = newSellPrice;
buyTokenPerEther = newBuyPrice;
} | 1 |
modifier whenNotPaused() {
require(now >= endDate);
_;
} | 1 |
modifier onlyMinter() {
require(isMinter(msg.sender), "MinterRole: caller does not have the Minter role.");
_;
} | 0 |
function setVendorWallet(address newVendorWallet) onlyOwner public returns (bool) {
require(newVendorWallet != 0x0);
vendorWallet = newVendorWallet;
return true;
} | 0 |
function upgrade(uint256 value) public {
UpgradeState state = getUpgradeState();
if(!(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading)) {
throw;
}
if (value == 0) throw;
balances[msg.sender] = balances[msg.sender].minus(value);
totalSupply = totalSupply.minus(value);
totalUpgraded = tota... | 0 |
function pause() public onlyOwner
{
paused = true;
emit EPause();
} | 0 |
function mint(address _to, uint256 _amount) onlyOwner canMint returns (bool) {
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
} | 0 |
function addDelegator(address minter) public;
function removeDelegator(address minter) public;
function renounceDelegator() public;
function _setFeeRate(uint16 _rate) internal{
_feeRate = _rate;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) whenNotPaused public returns (bool) {
super.transferFrom(_from, _to, _value);
return true;
} | 0 |
function setMaxParticipants(uint256 _newMax) onlyManager public{
currentPeople=_newMax;
carnitas[lastCarnita].maxPeople=currentPeople;
} | 0 |
function TimedCrowdsale(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
} | 0 |
function getBonus() constant returns (uint) {
assert(now > start);
assert(now < end);
uint week = (now - start) / period;
uint8 foundBonus = bonuses[week];
if (foundBonus != 0) {
return foundBonus;
} else {
return 5;
}
} | 0 |
function time() constant returns (uint) {
if(cTime > 0) {
return cTime;
}
return block.timestamp;
} | 1 |
function transfer(address _to, uint256 _value) stoppable public returns (bool) {
require(msg.data.length >= (2 * 32) + 4);
require(_value < c_totalSupply);
clearExpiredFreezing(msg.sender);
uint from_coins = validBalanceOf(msg.sender);
require(from_coins >= _value);
c_balances[msg.sender] = sub(c_balances[msg.sen... | 0 |
function setWallet(address[] _dest) public onlyOwner {
wallet_A = _dest[0];
wallet_B = _dest[1];
wallet_C = _dest[2];
} | 0 |
function BPESOToken() public payable {
startTime = now;
owner = msg.sender;
balances[owner] = _totalSupply;
} | 1 |
function buyEggs() public payable {
require(initialized);
uint256 eggsBought = calculateEggBuy(msg.value,SafeMath.sub(address(this).balance,msg.value));
eggsBought = SafeMath.sub(eggsBought, calculateDevFee(eggsBought));
ceoAddress.transfer(calculateDevFee(msg.value));
claimedEggs[msg.sender] = SafeMath.add(claime... | 0 |
function transfer(address _to, uint256 _value) returns (bool success);
function transfer(address _to, bytes32 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, bytes32 _value) returns (bool succe... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.