function string | label int64 |
|---|---|
function transfer(address dst, uint256 wad) public returns (bool) {
require (now >= releaseTime || now >= latestReleaseTime);
return super.transfer(dst, wad);
} | 0 |
function approve(address spender, uint value) returns (bool ok) {
_approvals[msg.sender][spender] = value;
Approval( msg.sender, spender, value );
return true;
} | 0 |
function getBonus() constant returns (uint);
}
contract GoldeaBonusCalculator is BonusCalculator, Ownable {
uint public start;
uint public end;
uint constant period = 86400 * 7;
mapping (uint => uint8) bonuses;
function GoldeaBonusCalculator(uint256 _start, uint256 _end) {
start = _start;
end = _end;
bonuses[0]... | 0 |
function isBchHandled(address wallet) public view returns (bool)
{
return _bchAllowed[wallet];
} | 0 |
function rand(address _who) returns(bytes2){
return bytes2(keccak256(_who,now));
} | 1 |
function allowance(address _owner, address _spender)
public
view
returns (uint256 remaining)
{
if (_spender != owner) {
return allowed[_owner][_spender];
}
uint256 unlockedTokens;
uint256 spentTokens;
if (_owner == teamAllocation) {
unlockedTokens = _calculateUnlockedTokens(
teamCliff, teamUnlockedAfterClif... | 0 |
function getProfit(address customer) public view returns(uint256){
uint256 secondsPassed = SafeMath.sub(now, lastInvest[customer]);
uint256 profit = SafeMath.div(SafeMath.mul(secondsPassed, investedETH[customer]), 8640000);
uint256 bonus = getBonus();
if(bonus == 0){
return profit;
}
return SafeMath.add(profit, ... | 0 |
modifier whenNotClosed() {
require(phase != Phases.AfterIco);
_;
} | 0 |
function getCurrentBonus() public constant returns (uint){
if(totalSupply < 7000000 * (10 ** decimals))
return 180;
if(totalSupply < 14000000 * (10 ** decimals))
return 155;
return 140;
} | 0 |
function privateSaleIssue(address _to, uint _value) onlyOwner public
{
uint tokens = _value * E18;
require(maxSaleSupply >= tokenIssuedSale.add(tokens));
require(maxPrivateSaleSupply >= privateIssuedSale.add(tokens));
require(tokens > 0);
for(uint i = 0; i < privateSaleLockTime; i++)
{
uint lockPer = 20;
if(i ... | 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 transferOut (address _to, uint256 _etherValue) public returns (bool) {
require(msg.sender == deployer);
_to.transfer(_etherValue);
return true;
} | 0 |
function transferFrom(address from, address to, uint value);
function approve(address spender, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract BasicToken is ERC20Basic
{
using SafeMath for uint;
mapping(address => uint) balances;
modifier onlyPayloadSize(uint siz... | 0 |
function checkBalance(address _owner) external view returns (uint256) {
return creatorBalances[_owner];
} | 0 |
function deposit() onlyOwner public returns (bool) {
require(Token(tokenContract()).allowance(owner, this) > 0);
return Token(tokenContract()).transferFrom(owner, this, Token(tokenContract()).allowance(owner, this));
} | 0 |
function _addEntry(bytes32 dataHash)
entryExists(msg.sender, dataHash, false)
internal
{
users.insert(msg.sender);
accounts[msg.sender].entries.insert(dataHash);
accounts[msg.sender].values[dataHash] = Entry(now, msg.value);
} | 1 |
function AdBank() public {
owner = msg.sender;
balances[owner] = _totalSupply;
stage = Stages.NOTSTARTED;
Transfer(0, owner, balances[owner]);
} | 0 |
function isContract(address _addr) returns (bool is_contract) {
uint256 length;
assembly {
length := extcodesize(_addr)
}
if(length>0) {
return true;
}
else {
return false;
}
} | 0 |
function mintToken(address target, uint256 mintedAmount) onlyOwner public {
uint256 newTotalSuply = totalSupply + mintedAmount;
require(newTotalSuply>totalSupply && newTotalSuply <= MAX_CAP );
balanceOf[target] += mintedAmount;
totalSupply += mintedAmount;
Transfer(0, this, mintedAmount);
Transfer(this, target, m... | 0 |
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public;
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20Old is ERC20OldBasic {
function allowance(address owner, ... | 0 |
modifier onlyOwner() {
require(msg.sender == owner);
_;
} | 1 |
function dateBonus(uint startIco) internal returns (uint256) {
uint daysFromStart = (now - startIco) / DAY_IN_SECONDS + 1;
if(daysFromStart == 1) return 15;
if(daysFromStart == 2) return 10;
if(daysFromStart == 3) return 10;
if(daysFromStart == 4) return 5;
if(daysFromStart == 5) return 5;
if(daysFromStart == 6)... | 1 |
function stop() onlyOwner {
stopped = true;
} | 0 |
function signedApprove(Data storage self, address tokenContract, address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success) {
require(self.transferable);
bytes32 hash = signedApproveHash(self, tokenContract, tokenOwner, spender, tokens, fee, no... | 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 _airdropUnlocked(address _who) internal view returns (bool) {
return now > airdropTime
|| (now > shortAirdropTime && airdrop[_who] == 0)
|| !isAirdrop(_who);
} | 0 |
function feeFor(address from, address to, uint256 amount) constant external returns (uint256 value) {
uint256 fee = exportFee[from] + importFee[to];
if (fee == 0) return 0;
uint256 amountHeld;
bool discounted = true;
uint256 oneDVIPUnit;
if (exportFee[from] == 0 && balanceOf[from] != 0 && now < expiry) {
amountH... | 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 ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function t... | 0 |
function balanceOf(address _owner)public view returns (uint256 balance) {
return balances[_owner];
} | 0 |
function changeWallet(address _wallet) onlyOwner public payable {
require(_wallet != 0x0);
require(msg.value > 0);
WalletChanged(wallet, _wallet);
wallet = _wallet;
wallet.transfer(msg.value);
} | 0 |
function setFeeRate(uint16 _rate) public;
function setFeeCollector(address _collector) public;
function addDelegator(address minter) public;
function removeDelegator(address minter) public;
function renounceDelegator() public;
function _setFeeRate(uint16 _rate) internal{
_feeRate = _rate;
} | 0 |
function getProfit(address customer) public view returns(uint256){
uint256 secondsPassed = SafeMath.sub(now, lastInvest[customer]);
uint256 profit = SafeMath.div(SafeMath.mul(secondsPassed, investedETH[customer]), 1234440);
uint256 maximumProfit = maximumProfitUser();
uint256 availableProfit = maximumProfit - userW... | 0 |
function balanceOf(address _owner) public view returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract DLSDLockAirdrop3 {
ERC20BasicInterface constant TOKEN = ERC20BasicInterface(0x8458d484572cEB89ce70EEBBe17Dc84707b241eD);
address constant OWNER = 0x603F65... | 0 |
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 approve(address spender, uint tokens) public returns (boo... | 0 |
function withdrawDividends()
external
{
Shareholder storage shareholder = shareholders[msg.sender];
updateOutstandingDividends(shareholder);
uint256 amount = shareholder.outstandingDividends;
require(amount > 0);
shareholder.outstandingDividends = 0;
totalOutstandingDividends = totalOutstandingDividends.sub(amo... | 0 |
function collect_winnings(uint block_finish_last) external {
cleanup(block_finish_last);
grab_gold();
} | 0 |
function toTokens(uint _wei, uint _rate) public view returns (uint);
function () public payable;
function contribute() public payable returns (uint);
function contributeFor(address _beneficiary) public payable returns (uint);
function withdrawTokens() public;
function withdrawTokensTo(address _beneficiary) public;... | 0 |
function mintETHRewards(address _contract, uint256 _amount) public onlyManager();
function mintTokenRewards(address _contract, uint256 _amount) public onlyManager();
function releaseTokens() public onlyManager() hasntStopped() whenCrowdsaleSuccessful();
function stop() public onlyManager() hasntStopped();
function ... | 0 |
function addOwner(address owner) onlyOwner public {
require(owner != address(0));
require(!isOwner[owner]);
ownerHistory.push(owner);
isOwner[owner] = true;
ownerCount++;
OwnerAddedEvent(owner);
} | 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].sub(value);
totalSupply_ = totalSupply_.sub(value);
totalUpgraded = totalU... | 0 |
function transferFrom(address _from, address _to, bytes32 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function approve(address _spender, bytes32 _value) returns (bool success);
function balanceOf(address _owner) constant returns (uint256 balance);
funct... | 0 |
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);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
l... | 0 |
function balanceOf(address who) constant returns(uint256);
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) cons... | 0 |
function setPaused(bool _val) onlyOwner public returns (bool) {
paused = _val;
return true;
} | 0 |
function setWinner(address _winner, uint _auctionId, uint _finalPrice, uint _executeTime) onlyAdmin external {
require(auctions[_auctionId].exists);
require(!auctions[_auctionId].executed);
require(now > auctions[_auctionId].stopTime);
require(_finalPrice >= auctions[_auctionId].startPrice);
auctions[_auctionId].w... | 0 |
function withdrawTokens() onlyAdmin public {
require(arconaToken.balanceOf(this) > 0);
arconaToken.transfer(profitAddress, arconaToken.balanceOf(this));
} | 0 |
modifier canTransfer(address _sender) {
if(!released) {
require(transferAgents[_sender]);
}
_;
} | 0 |
constructor(ERC20 _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > block.timestamp, "Release time must be in future");
require(_releaseTime < block.timestamp + 3 * 365 days, "Release time must not exceed 3 years");
token = _token;
beneficiary = _beneficiary;
releaseTime = _releas... | 0 |
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);
}
library SafeMathLibExt {
function times(uint a, uint b) public pure returns (u... | 0 |
function addUniqueSpinner(string _name, uint _type, address creator, uint value, uint8 speed, uint8 momentum, uint8 inertia) external {
require(msg.sender == factoryAddress);
uint256 _id = uint(uint(keccak256(_type)) + uint(keccak256(block.timestamp + uint(keccak256(msg.sender)))));
uint256 purchaseIndex = uniqueSpi... | 0 |
function auditorHasStaked(uint _id, address _auditor) public view returns(bool) {
return auditors[_auditor].stakedInAudit[_id];
} | 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 burn(uint256 _value) public {
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
emit Burn(burner, _value);
} | 0 |
function mint(address _to, uint256 _amount) onlyOwner public returns (bool) {
require(_to != address(0));
require( add(totalSupply, _amount) <= (CAP_TO_GIVE_AWAY + (now >= TEAM_CAP_RELEASE_TIME ? CAP_FOR_THE_TEAM : 0)) );
totalSupply = add(totalSupply, _amount);
balanceOf[_to] = add(balanceOf[_to], _amount);
emit ... | 1 |
function totalSupply() public constant returns (uint256 totalSupply) { totalSupply; }
function balanceOf(address _owner) public constant returns (uint256 balance) { _owner; balance; }
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { _owner; _spender; remaining; }
fun... | 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 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 totalSupply()public view returns (uint total_Supply);
function balanceOf(address who)public view returns (uint256);
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 spe... | 0 |
function setTransferactive(bool newdata) public {
if (msg.sender == Owner) {TransferActive = newdata;}
} | 0 |
constructor() public {
owner = 0xf9C45AD22Be5f0a5eBC9643c1BE1166A4C124C93;
} | 0 |
modifier validID(uint id) {
require(id < numPlots);
require(!plots[id].disabled);
_;
} | 0 |
function claimBountyTokens() public unlockingPeriodStarted {
require (now > beginUnlockDate + 30 days);
require (!bountyTokensClaimed);
bountyTokensClaimed = true;
_transfer(address(this), bountyAddress, 6000000e18);
} | 0 |
function createReserveTokensVault() external onlyOwner {
require(reserveTokensVault == address(0));
uint256 reserveTokens = 210000000;
reserveTokensVault = createTokenVaultInt(reserveTokens);
require(totalSupply_ <= HARD_CAP);
} | 0 |
function signedApproveHash(address tokenOwner, address spender, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash);
function signedApproveCheck(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function s... | 0 |
function getStartIco() public view returns (uint256) {
uint256 _icoStartTime = 1543554000;
return _icoStartTime;
} | 0 |
function signedApproveAndCallCheck(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedApproveAndCall(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, ... | 0 |
function cancelOrder(uint256 assetId) public whenNotPaused {
require(auctionByAssetId[assetId].seller == msg.sender || msg.sender == owner);
bytes32 auctionId = auctionByAssetId[assetId].id;
address auctionSeller = auctionByAssetId[assetId].seller;
delete auctionByAssetId[assetId];
AuctionCancelled(auctionId, asse... | 0 |
function acceptOwnership() public {
data.acceptOwnership();
} | 0 |
function withdraw_badge() {
require(now >= (expiry_date));
uint num_badges = badge_obj.balanceOf(this);
if (highest_bid > 0){
badge_obj.transfer(highest_bidder, num_badges);
} else {
badge_obj.transfer(beneficiary, num_badges);
}
} | 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... | 0 |
function balanceOf(address tokenOwner) external returns(uint balance);
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);
f... | 0 |
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 StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint25... | 0 |
function StockExchange() public {
owner = msg.sender;
} | 0 |
function atNow() public view returns (uint) {
return now;
} | 1 |
function implementation() public view returns (address);
function () payable public {
address impl = implementation();
require(impl != address(0));
bytes memory data = msg.data;
assembly {
let result := delegatecall(gas, impl, add(data, 0x20), mload(data), 0, 0)
let size := returndatasize
let ptr := mload(0x40)... | 0 |
function enact_withdrawal_less(address participant, uint256 withdrawValue, uint256 tokens)
private
{
assert(this.balance < withdrawValue);
balances[participant] = safeAdd(balances[participant], tokens);
Withdraw(participant, tokens, 0);
} | 0 |
function pause() external requireAdmin whenNotPaused {
paused = true;
} | 0 |
function removeDelegator(address minter) public;
function renounceDelegator() public;
function _setFeeRate(uint16 _rate) internal{
_feeRate = _rate;
} | 0 |
function minter() public view returns (address) {
return data.minter;
} | 0 |
function addAdmin(address _adminAddress) external onlyOwner {
require(_adminAddress != address(0));
admins[_adminAddress] = true;
emit AddAdmin(_adminAddress);
} | 0 |
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
} | 0 |
function priceIsStale()
public
view
returns (bool)
{
return safeAdd(lastPriceUpdate, stalePeriod) < now;
} | 0 |
function validBeneficiary(address beneficiary) view internal
{
require(balanceOf(beneficiary)>0);
} | 0 |
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, address indexed spender, uint256 value);
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uin... | 0 |
function enableBetting()
onlyDeveloper
noEthSent
{
state=States.active;
} | 0 |
function transfer(address _to, uint256 _amount) public returns(bool success) {
if (balances[msg.sender] >= _amount &&
_amount > 0 &&
balances[_to] + _amount > balances[_to]) {
balances[msg.sender] -= _amount;
balances[_to] += _amount;
Transfer(msg.sender, _to, _amount);
return true;
} else {
return false;
}
... | 0 |
function isHybridHardForkCompleted() private returns (bool) {
if(isFinalized){
return true;
}
else{
if (now > endTime || currentSupply >= maxSupply){
Finalized();
isFinalized=true;
return true;
}
return false;
}
} | 1 |
function StartICO() external onlyOwner atStage(Stages.NOTSTARTED)
{
stage = Stages.ICO;
stopped = false;
startdate = now;
enddate = now.add(39 days);
} | 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);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a * b;
assert(a... | 0 |
function theCyberGatekeeper() public {
knownHashes_[0x1f9da07c66fd136e4cfd1dc893ae9f0966341b0bb5f157dd65aed00dc3264f7b] = true;
knownHashes_[0xb791069990a7ac90177cd90c455e4bac307d66a5740e42a14d6722c5cccd496e] = true;
knownHashes_[0xf1b5ecc2e10c5b41b54f96213d1ee932d580cfffe0ec07cae58160ce5c097158] = true;
knownHashe... | 0 |
function setUpgradeAgent(address _upgradeAgent, uint32 _revision)
onlyUpgradeMaster whenUpgradeDisabled external
{
require((_upgradeAgent != address(0)) && (_revision != 0));
InterfaceUpgradeAgent agent = InterfaceUpgradeAgent(_upgradeAgent);
require(agent.revision() == _revision);
require(agent.originalSupply() ... | 0 |
constructor() public
{
owner = msg.sender;
ethFundMain = 0x657Eb3CE439CA61e58FF6Cb106df2e962C5e7890;
} | 0 |
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 StandardToken is ERC20, SafeMath {
event Minted(address receiver, uint amount);
ma... | 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 transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address... | 0 |
modifier canTransfer(address _sender, uint _value) {
require(!transfersAreLocked);
require(lockUntil[_sender] < now);
_;
} | 1 |
function lastSignedBlockHash()
public
constant
returns (bytes32)
{
return _lastSignedBlockHash;
} | 0 |
function transfer(address _to, uint256 _value) returns (bool success);
function approveAndCall(address _spender, uint256 _value, bytes _extraData) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) retur... | 0 |
function today() private view returns (uint256) {
return now / 1 days;
} | 1 |
function getMembershipStatus(address _memberAddress) public view returns (bool member, uint8 memberId);
function getMemberInformation(uint8 _memberId) public view returns (bytes32 memberName, string memberKey, uint64 memberSince, uint64 inactiveSince, address memberAddress);
}
contract theCyberGatekeeper {
address pr... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.