function string | label int64 |
|---|---|
function legal() constant returns (string content)
{
content = "bitqy, the in-app token for bitqyck\n\nbitqy is a cryptocurrency token for the marketplace platform bitqyck and the general market as it is accepted by businesses and consumers globally. bitqy will be allocated by the directors of bitqyck, Inc. Once allo... | 0 |
function hatchEggs(address ref) public {
require(initialized);
if(referrals[msg.sender] == 0 && referrals[msg.sender] != msg.sender){
referrals[msg.sender] = ref;
}
uint256 eggsUsed = getMyEggs();
uint256 newDragons = SafeMath.div(eggsUsed, EGGS_TO_HATCH_1DRAGON);
hatchery[msg.sender] = SafeMath.add(hatchery[msg... | 0 |
function underLimit(uint256 _value) internal returns (bool) {
if (today() > lastDay_[msg.sender]) {
spentToday_[msg.sender] = 0;
lastDay_[msg.sender] = today();
}
if (spentToday_[msg.sender] + _value >= spentToday_[msg.sender] && spentToday_[msg.sender] + _value <= dailyLimit_) {
spentToday_[msg.sender] += _value... | 0 |
function setTradable(bool _newTradableState) onlyOwner public {
tradable = _newTradableState;
} | 0 |
function invest() public;
function refund() public;
function updateTokenBalance() public;
function withdrawTokens() public;
function updateEtherBalance() public;
function withdrawEther() public;
}
contract PersonalCrowdsaleProxy is IPersonalCrowdsaleProxy, Dispatchable {
ICrowdsale public targetCrowdsale;
IToken... | 0 |
function setIssuer(address _issuer, uint32 event_id) onlyOwner returns (bool success) {
if(matured==false && issuer==address(0)){
issuer = _issuer;
balances[_issuer] = totalAssetUnits;
TxExecuted(event_id);
return true;
}
return false;
} | 0 |
modifier multisig (bytes32 hash) {
if (!masterKeys[msg.sender]) {
Unauthorized(msg.sender);
} else if (functionCalling[msg.sender] == 0) {
if (functionCalls[hash] == 0x0) {
functionCalls[hash] = msg.sender;
functionCalling[msg.sender] = hash;
AuthInit(msg.sender);
} else {
AuthComplete(functionCalls[hash], msg... | 0 |
function balanceOf(address _owner) public constant returns (uint256) {
return balances[_owner];
} | 0 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(isCrowdsalePaused == false);
require(validPurchase());
require(TOKENS_SOLD<maxTokensToSale);
uint256 weiAmount = msg.value;
uint256 tokens = calculateTokens(weiAmount);
weiRaised = weiRaised.add(msg.value);
token.trans... | 0 |
function disableWhitelist() public onlyOwner {
whitelistEnabled = false;
} | 0 |
function allowance(address owner, address spender) public constant 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 va... | 0 |
function add_referral(address referral, string promo, uint256 amount) external returns(address partner, uint256 p_partner, uint256 p_referral){
p_partner = 0;
p_referral = 0;
partner = address(0x0);
if (msg.sender == contractPreICO || msg.sender == contractICO){
if(partnersPromo[promo] != address(0x0) && partnersP... | 1 |
function transfer(address caller, address _to, uint256 _amount) onlyAsset returns (bool success) {
assert(allowTransactions);
assert(balanceOf[caller] >= _amount);
assert(balanceOf[_to] + _amount >= balanceOf[_to]);
assert(!frozenAccount[caller]);
assert(!frozenAccount[_to]);
balanceOf[caller] -= _amount;
uint25... | 0 |
function buyTokens() public payable whenNotPaused {
require(validPurchase());
uint256 tokens = 0;
uint256 amountPaid = adjustAmountValue();
if (tokensRaised < limitTier1) {
tokens = amountPaid.mul(rate);
if (tokensRaised.add(tokens) > limitTier1) {
tokens = adjustTokenTierValue(amountPaid, limitTier1, 1, rate);
... | 0 |
function endRound(F3Ddatasets.EventReturns memory _eventData_)
private
returns (F3Ddatasets.EventReturns)
{
uint256 _rID = rID_;
uint256 _winPID = round_[_rID].plyr;
uint256 _winTID = round_[_rID].team;
uint256 _pot = round_[_rID].pot;
uint256 _win = (_pot.mul(48)) / 100;
uint256 _com = (_pot / 50);
uint256 _... | 0 |
function withdrawUser(uint256 index) external {
require((withdrawals[index].createdAt.add(delay)) < now);
require(withdrawals[index].executed == false);
require(withdrawals[index].user == msg.sender);
withdrawals[index].executed = true;
withdrawInternal(withdrawals[index].token, withdrawals[index].user, withdrawal... | 0 |
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
} | 0 |
function balanceOf(address owner) public view returns (uint256 balance);
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 succ... | 0 |
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 (bool success);
function transferFrom(address from, address to, uint tokens) public... | 0 |
constructor(IERC20 _token) public {
require(address(_token) != address(0x0), "Matic token address is not valid");
maticToken = _token;
uint256 SCALING_FACTOR = 10 ** 18;
uint256 day = 1 minutes;
day = day.div(15);
addVesting(0x9fB29AAc15b9A4B7F17c3385939b007540f4d791, now + 0, 3230085552 * SCALING_FACTOR);
addVe... | 0 |
function forwardFunds() internal {
teamWallet.transfer(msg.value);
} | 0 |
function updatePromoter1(address _address) external onlyOwner {
require(_address != address(0x0));
promoter1 = _address;
} | 0 |
function setAddressOfERC20Token(address _addressOfERC20Token) onlyOwner {
addressOfERC20Token = _addressOfERC20Token;
token = ERC20(addressOfERC20Token);
} | 0 |
function create() payable whenNotClosed whenNotPaused public returns (bool success) {
require(msg.value > 0);
require(now >= preIcoOpeningTime);
Phases oldPhase = phase;
uint256 weiToParticipate = msg.value;
uint256 overpaidWei;
adjustPhaseBasedOnTime();
if (phase != Phases.AfterIco) {
Rates memory rates = getR... | 0 |
function allowance(address owner, address spender) constant returns (uint);
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... | 0 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
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 transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
} | 0 |
function totalSupply() public view returns (uint);
function owns(address owner, uint256 tokenID) public view returns (bool);
function allowance(address claimant, uint256 tokenID) public view returns (bool);
function transferFrom(address from, address to, uint256 tokenID) public returns (bool);
function createLand(a... | 0 |
function ETH_EURCENT()
public view
returns (uint256)
{
return uint256(100 ether).div(EUR_WEI);
} | 0 |
function setBeneficiary(address _beneficiary, bytes32 _passphrase) public when_beneficiary_is_unknown {
require(keccak256(_passphrase) == passphraseHash);
beneficiary = _beneficiary;
} | 0 |
function withdrawBountyTokens(address _to, uint256 _amountWithDecimals)
public
onlyOwner
{
require(transferFrom(bountyAllocation, _to, _amountWithDecimals));
} | 0 |
function checkBalance(address account) constant returns (uint128 _balance) {
if(matured)
return 0;
return balances[account];
} | 0 |
function CrowdSale_Resume() external onlyOwner atStage(Stages.PAUSED)
{
stopped = false;
stage = Stages.ICO;
} | 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 burnToken(uint _value) onlyOwner_manager public
{
uint tokens = _value * zeroAfterDecimal;
require(balances[msg.sender] >= tokens);
balances[msg.sender] = balances[msg.sender].sub(tokens);
burnTokenAmount = burnTokenAmount.add(tokens);
issueToken_Total = issueToken_Total.sub(tokens);
emit Burn(msg.sende... | 0 |
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
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, ... | 0 |
function updatePromoter2(address _address) external onlyOwner {
require(_address != address(0x0));
promoter2 = _address;
} | 0 |
contract SubToken { function SubTokenCreate ( uint256 _initialSupply, uint8 decimalUnits, string _name, string _symbol, address _tokenowner )
returns (address){} } | 0 |
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) returns (bool success);
function () {
throw;
} | 0 |
function withdrawEther() external onlyOwner {
owner.transfer(ownerBalance);
ownerBalance = 0;
} | 1 |
function updateIcoEnding(uint256 _endTimestamp) public onlyOwner {
endTimestamp = _endTimestamp;
} | 0 |
function upgrade(uint value) public {
UpgradeState state = getUpgradeState();
require(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading);
require(value != 0);
upgradeAgent.upgradeFrom(msg.sender, value);
burnTokens(msg.sender, value);
totalUpgraded = totalUpgraded.add(value);
Upgrade(msg.se... | 0 |
constructor () internal{
_feeRate = 10;
_feeCollector = msg.sender;
} | 0 |
function balanceOf(address owner) public view returns (uint256) {
require(owner != address(0));
return _ownedTokensCount[owner];
} | 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 |
constructor() public payable {
reset();
} | 0 |
function createProxyAddressFor(address _beneficiary) public returns (address) {
address proxy = new CrowdsaleProxy(_beneficiary, targetCrowdsale);
ProxyCreated(proxy, _beneficiary);
return proxy;
} | 0 |
function burn () external {
uint256 amount = burnable();
require(amount > 0);
lastBurn = now;
assert(purpose.supplyBurn(amount));
} | 0 |
modifier multisig (bytes32 hash) {
assert(trustAddress != address(0x0));
address current = Trust(trustAddress).functionCalls(hash);
uint8 code = Trust(trustAddress).authCall(msg.sender, hash);
if (code == 0) Unauthorized(msg.sender);
else if (code == 1) AuthInit(msg.sender);
else if (code == 2) {
AuthComplete(cu... | 0 |
function claimTokens() external {
require( holdings[msg.sender].isValue );
require( vestingStarted );
uint personalVestingStart =
(holdings[msg.sender].isFounder) ? (vestingStart.add(FOUNDERS_HOLDING)) : (vestingStart);
require( now > personalVestingStart );
uint periodsPassed = now.sub(personalVestingStart).div(... | 0 |
function burn(uint256 _amount) public {
burnInternal(msg.sender, _amount);
} | 0 |
function hasClosed() public view returns (bool) {
return block.timestamp > closingTime;
} | 0 |
function orderMatch(bytes32 _orderID) external view returns (bytes32);
function orderTrader(bytes32 _orderID) external view returns (address);
function orderState(bytes32 _orderID) external view returns (OrderState);
function orderConfirmer(bytes32 _orderID) external view returns (address);
}
contract RenExTokens is... | 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);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return ... | 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 FractionalERC20 is ERC20 {
uint public decimals;
}
contract Crowdsale is Haltable {... | 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 HarukaTest01 is IERC20 {
event OwnershipTransferred(address indexed pr... | 0 |
function approveCrowdsale(address _crowdsaleAddress) external onlyOwner {
uint uintDecimals = decimals;
uint exponent = 10**uintDecimals;
uint amount = generalSaleWallet.amount * exponent;
allowed[generalSaleWallet.addr][_crowdsaleAddress] = amount;
Approval(generalSaleWallet.addr, _crowdsaleAddress, amount);
} | 0 |
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
return a - b;
} | 0 |
modifier onlyPayloadSize(uint size) {
require(!(msg.data.length < size + 4));
_;
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool success)
{
if ( msg.sender == addressICOManager) { return super.transfer(_to, _value); }
if ( !halted && msg.sender == addressTeam && SafeMath.sub(balances[msg.sender], _value) >= tokensTeam/2 && (now > icoEndDate + SECONDS_IN_YEAR/2) )
{ return su... | 0 |
function withdraw() external {
address participant = msg.sender;
uint256 tokens = withdrawals[participant].tokens;
require(tokens > 0);
uint256 requestTime = withdrawals[participant].time;
Price price = prices[requestTime];
require(price.numerator > 0);
uint256 withdrawValue = tokens / price.numerator;
withdraw... | 0 |
function createTokens() payable external is_not_dust {
if (isFinalized) throw;
if (block.number < start_block) throw;
if (block.number > end_block) throw;
if (msg.value == 0) throw;
if (tx.gasprice > 0.021 szabo && fairsale_protection) throw;
if (msg.value > 0.04 ether && fairsale_protection) throw;
uint256 toke... | 0 |
function time() public constant returns (uint) {
return now;
} | 1 |
function increasePrize() public payable onlyActiveAuction {
require(msg.value >= tenthEth, "Must increase by at least 0.1ETH");
prize = prize.add(msg.value);
lastDonor = msg.sender;
} | 0 |
function isWithinContributionRange() internal constant returns (bool)
{
uint timePassed = now.sub(startTime);
timePassed = timePassed.div(1 days);
if (timePassed<15)
require(msg.value>=minimumContributionPresalePhase1);
else if (timePassed>=15 && timePassed<31)
require(msg.value>=minimumContributionPresalePhase2... | 0 |
function setCrowdsaleCompleted() {
require(msg.sender == crowdsaleContract);
require(crowdsaleCompleted == false);
crowdsaleCompleted = true;
} | 0 |
function getRunDetails(uint _heroId) external view returns (
uint _heroPower,
uint _heroStrength,
uint _heroInitialHealth,
uint _heroHealth,
uint _monsterCreationTime,
uint _monsterLevel,
uint _monsterInitialHealth,
uint _monsterHealth,
uint _gameState
) {
uint genes;
address owner;
(,,, genes, owner,,) = ... | 0 |
function isFinishedSuccessfully() public view returns (bool) {
return now >= endTime && totalWeiReceived >= minCapWei;
} | 0 |
function releaseTokensForce(bytes32 _hashDeal)
external onlyOwner
nonReentrant
returns(bool)
{
Deal storage deal = streamityTransfers[_hashDeal];
uint8 prevStatus = deal.status;
if (deal.status != STATUS_NO_DEAL) {
deal.status = STATUS_DEAL_RELEASE;
bool result = false;
if (deal.isAltCoin == false)
result = ... | 0 |
function currentTime() private constant returns(uint256 _currentTime) {
return now;
} | 0 |
function bakeCookie(string wish) {
var cookiesCount = cookies[msg.sender].push(wish);
if (cookiesCount == 1) {
bakers.push(msg.sender);
}
} | 0 |
function bid()
public
payable
atStage(Stages.AuctionStarted)
{
require(msg.value > 0);
assert(bids[msg.sender] + msg.value >= msg.value);
uint missingFunds = missingFundsToEndAuction();
require(msg.value <= missingFunds);
bids[msg.sender] += msg.value;
receivedWei += msg.value;
walletAddress.transfer(msg.val... | 0 |
function withdraw() onlyOwner external {
require(now >= END_DATE);
owner.transfer(this.balance);
} | 0 |
function unlock() external {
require(RR != address(0));
assert(now >= unlockedAt);
if (tokensCreated == 0) {
tokensCreated = RR.balanceOf(this);
}
uint256 transferAllocation = lockedAllocations[msg.sender];
lockedAllocations[msg.sender] = 0;
require(RR.transfer(msg.sender, transferAllocation));
} | 0 |
function blockTime() constant returns (uint) {
return block.timestamp;
} | 1 |
function transfer(address _to, uint256 _value) public returns (bool) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function pow10(uint256 a, uint8 b) internal returns (uint256 result) {
for (uint8 i = 0; i < b; i++) {
a *= 10;
}
return a;
} | 0 |
function setCoinPrice(uint256 newPriceInWei) public returns(uint256 oldPriceInWei){
require(msg.sender==owner);
uint256 _old=coinPriceInWei;
coinPriceInWei=newPriceInWei;
return _old;
} | 0 |
function addOwner(Proxy identity, address newOwner) public onlyOlderOwner(identity) rateLimited(identity) {
require(!isOwner(identity, newOwner));
owners[identity][newOwner] = now - userTimeLock;
LogOwnerAdded(identity, newOwner, msg.sender);
} | 0 |
function end_ICO() external onlyOwner atStage(Stages.ICO)
{
require(now > ico_enddate);
stage = Stages.ENDED;
icoRunningStatus = false;
uint256 x = balances[address(this)];
balances[owner] = (balances[owner]).add( balances[address(this)]);
balances[address(this)] = 0;
emit Transfer(address(this), owner , x);
} | 0 |
function updateOperator() public inUpdateWindow() returns (bool) {
address updater = msg.sender;
operator = roleManager.provideAddress(updater, 0);
emit UpdateOperator(updater, operator);
return true;
} | 0 |
function vestedBalanceOf(address _address) public constant returns (uint256 balance) {
if (now < vestingBounty) {
return balances[_address] - balances2yearFreeze[_address] - balancesEndIcoFreeze[_address];
}
if (now < vestingTeam) {
return balances[_address] - balances2yearFreeze[_address];
} else {
return balan... | 0 |
function getHistoricPrice(uint256 time) public view returns (uint256) {
return priceHistory[time];
} | 0 |
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) view internal {
require(now >= fundingStartTime);
require(now < fundingEndTime);
require(_beneficiary != address(0));
require(_weiAmount != 0);
} | 0 |
function transferFrom(address from, address to, uint tokens) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ApproveAndCallFallBack {
function receiveApproval(address fro... | 0 |
function SaviorToken(uint64 _preIcoOpeningTime) payable {
require(_preIcoOpeningTime > now);
preIcoOpeningTime = _preIcoOpeningTime;
icoOpeningTime = preIcoOpeningTime + PRE_ICO_DURATION;
closingTime = icoOpeningTime + ICO_DURATION;
} | 0 |
function remoteTransferFrom (address from, address to, uint256 value) external onlyOwner returns (bool) {
return _remoteTransferFrom(from, to, value);
} | 0 |
function getOrderHash(address[3] orderAddresses, uint[4] orderValues)
public
constant
returns (bytes32)
{
return keccak256(
address(this),
orderAddresses[0],
orderAddresses[1],
orderAddresses[2],
orderValues[0],
orderValues[1],
orderValues[2],
orderValues[3]
);
} | 1 |
function currentTime() internal constant returns (uint _currentTime) {
return now;
} | 1 |
function withdrawToken(address beneficiary, address _token) onlyOwner public {
ERC20 token = ERC20(_token);
uint256 amount = token.balanceOf(this);
require(amount>0);
token.transfer(beneficiary, amount);
} | 0 |
function MiningRigFarmer() public{
ceoAddress=msg.sender;
} | 0 |
function resumeMintToken() external onlyOwner {
require(stopped, "Minting is running");
stopped = false;
} | 0 |
function payoutAmount() public view returns(uint256) {
uint256 percent = percentRate();
uint256 different = now.sub(time[msg.sender]).div(stepTime);
uint256 rate = balance[msg.sender].mul(percent).div(1000);
uint256 withdrawalAmount = rate.mul(different).div(24).sub(percentWithdraw[msg.sender]);
return withdrawalA... | 0 |
constructor() public {
emit SetOwner(owner, msg.sender);
owner = msg.sender;
} | 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 - 300 > block.timestamp);
}
balances_[msg.sender] = balances_[msg.sender... | 0 |
function changeStatus(uint8 _status) onlyOwner public {
require(status != _status);
status = _status;
emit ChangeStatus(address(this), _status);
} | 0 |
function setTransferAgent(address addr, bool state) public onlyOwner inReleaseState(false) {
TransferAgentSet(addr, state);
transferAgents[addr] = state;
} | 0 |
function DGDb_Auction(address beneficiary_address, address badge_address, uint duration_in_days){
beneficiary = beneficiary_address;
badge_obj = Badge(badge_address);
expiry_date = now + duration_in_days * 1 days;
} | 0 |
function _releasableAmount(address token) private view returns (uint256) {
return _vestedAmount(token).sub(_released[token]);
} | 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 constant returns (uint256);
function transferFrom(address from, address to, uint256 v... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.