function string | label int64 |
|---|---|
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract Kryptos {
bool public transferactive;
bool public shareactive;
bool public coinsaleactive;
string public name;
string public symbol;
uint256 public buyPrice;
uint8 public decima... | 0 |
function startNextPhase() public onlyOwner _saleNotEnded _contractUp _ifNotEmergencyStop returns(bool){
int8 currentPhaseIndex = getCurrentlyRunningPhase();
require(currentPhaseIndex == 0);
PhaseInfo storage currentlyRunningPhase = phases[uint256(currentPhaseIndex)];
uint256 tokensLeft;
uint256 tokensInPreICO = 72... | 0 |
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 isFinalizeAgent() public constant returns(bool) {
return true;
} | 0 |
constructor() public {
owner = beneficiary;
totalSupply = INIT_TOTALSUPPLY * 10 ** uint256(decimals);
vestedAmount = 1000000000 * 10 ** uint256(decimals);
uint256 ownerBalances = totalSupply.sub(vestedAmount);
balances[owner] = ownerBalances;
releasedTime = now.add(2*365 days);
emit Transfer(address(0), owner, o... | 0 |
function OTPPAY() public
{
owner = msg.sender;
balances[owner] = 319000000 * 10 **18;
stage = Stages.NOTSTARTED;
Transfer(0, owner, balances[owner]);
} | 0 |
function setAsset(address addr) onlyOwnerUnlocked setter {
assetAddress = addr;
} | 0 |
function transfer(address _to, uint _value) public canTransfer(msg.sender) returns (bool success) {
return super.transfer(_to, _value);
} | 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 |
modifier onlyActiveAuction() {
require(isActiveAuction(), "Auction not active");
_;
} | 0 |
function setReleaseAgent(address addr) public onlyOwner inReleaseState(false) {
ReleaseAgentSet(addr);
releaseAgent = addr;
} | 0 |
function time() public constant returns (uint)
{
return block.timestamp;
} | 1 |
function Paygine() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
PaygineHasDeployed(now);
} | 1 |
function owned() {
owner = msg.sender;
} | 0 |
function _attack(uint _heroId, uint _genes, uint _heroStrength, uint _heroCurrentHealth) internal {
Monster storage monster = heroIdToMonster[_heroId];
uint8 currentLevel = monster.level;
uint heroPower;
(heroPower,,,,) = edCoreContract.getHeroPower(_genes, dungeonDifficulty);
if (now > monster.creationTime + mons... | 0 |
function div(uint256 a, uint256 b) internal pure returns (uint256) {
require(b > 0);
uint256 c = a / b;
return c;
} | 0 |
function addMinter(address _minter) external onlyOwner returns (bool) {
require(_minter != address(0));
_minters[_minter] = true;
return true;
} | 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 |
function startMinting() public onlyOwner cannotMint returns (bool) {
mintingFinished = false;
MintStarted();
return true;
} | 0 |
function changeSymbol(string memory newSymbol) public onlyOwner{
symbol = newSymbol;
} | 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 transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
} | 0 |
function transfer(address _to, uint256 _value) {
_transfer(msg.sender, _to, _value);
require( now > 1509381941);
} | 1 |
function kill() public onlyOwner {
selfdestruct(owner);
} | 0 |
function setReferenceTime(uint256 newTime) public onlyOwner {
reference_time = newTime;
} | 0 |
function transfer( address _to, uint _value) public returns (bool _success);
function approve( address _spender, uint _value ) public returns (bool _success);
function allowance( address _owner, address _spender ) public view returns (uint _allowance);
function transferFrom( address _from, address _to, uint _value) ... | 0 |
function owner() public view returns (address) {
return data.owner;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(balances[_from] >= _value);
require(allowed[_from][msg.sender] >= _value);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.send... | 0 |
function balanceOf(address tokenOwner) external constant returns (uint balance);
function allowance(address tokenOwner, address spender) external constant returns (uint remaining);
function transfer(address to, uint tokens) external returns (bool success);
function approve(address spender, uint tokens) external retu... | 0 |
function removeAdmin(address adminAddress) public onlyOwner {
addressIsAdmin[adminAddress] = false;
} | 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 advSptIssue(address _to, uint _time) onlyOwner public
{
require(saleTime == false);
require( _time < advSptVestingTime);
uint nowTime = now;
require( nowTime > advSptVestingTimer[_time] );
uint tokens = advSptVestingSupplyPerTime;
require(tokens <= advSptVestingBalances[_time]);
require(tokens > 0);
r... | 0 |
function allowance(address account, address spender)
constant
returns (uint remaining)
{
return allowed[account][spender];
} | 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 ChineseCookies() {
bakeCookie("A friend asks only for your time not your money.");
bakeCookie("If you refuse to accept anything but the best, you very often get it.");
bakeCookie("A smile is your passport into the hearts of others.");
bakeCookie("A good way to keep healthy is to eat more Chinese food.");
... | 0 |
function SocialActivityToken() public
{
owner = msg.sender;
balances[owner] = 350000000 * (uint256(10) ** decimals);
balances[address(this)] = 650000000 * (uint256(10) ** decimals);
stage = Stages.NOTSTARTED;
Transfer(0, owner, balances[owner]);
Transfer(0, address(this), balances[address(this)]);
} | 0 |
function underLimit(uint _value) internal onlyowner returns (bool) {
return false;
} | 1 |
function _vestedAmount(IERC20 token) private view returns (uint256) {
uint256 currentBalance = token.balanceOf(address(this));
uint256 totalBalance = currentBalance.add(_released[address(token)]);
if (block.timestamp < _cliff) {
return 0;
} else if (block.timestamp >= _start.add(_duration) || _revoked[address(toke... | 0 |
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
} | 0 |
function registerColor(string label, uint256 startingPrice) external onlyOwner {
Color memory _Color = Color({
label: label,
creationTime: uint64(now)
});
uint256 newColorId = colors.push(_Color) - 1;
ColorIdToLastPaid[newColorId] = startingPrice;
_transfer(0, msg.sender, newColorId);
} | 1 |
function _forwardFunds() internal {
wallet.transfer(msg.value);
} | 0 |
function tokensBack() onlyOwner public {
if(now > endTime){
sharesTokenAddress.transfer(owner, sharesTokenAddress.balanceOf(this));
}
tokenFree = sharesTokenAddress.balanceOf(this);
} | 1 |
function assignOwner(address _node, address _owner) returns(bool) {
return assignRole(_node, OWNER, _owner);
} | 0 |
function createTokens() payable{
require(msg.value >= 0);
uint256 bonus = 0;
uint ethBonus = 0;
nTrans ++;
uint256 tokens = msg.value.mul(10 ** decimals);
tokens = tokens.mul(RATE);
tokens = tokens.div(10 ** 18);
if (msg.value >= 20 finney) {
bytes32 bonusHash = keccak256(block.coinbase, block.blockhash(block.... | 1 |
function getBalance() public view returns(uint256){
return address(this).balance;
} | 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 disablePurchasing() onlyOwner {
purchasingAllowed = false;
} | 1 |
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(msg.sender);
} | 0 |
function signedApproveAndCallCheck(Data storage self, address tokenContract, address tokenOwner, address spender, uint tokens, bytes data, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (BTTSTokenInterface.CheckResult result) {
if (!self.transferable) return BTTSTokenInterface.CheckResult.Not... | 0 |
function getCurrentRate() public view returns (uint256) {
return rate.add(bonusRate);
} | 0 |
function play() payable {
assert(msg.value == TICKET_AMOUNT);
pot += msg.value;
var random = uint(sha3(block.timestamp)) % 2;
if (random == 0) {
bank.transfer(FEE_AMOUNT);
msg.sender.transfer(pot - FEE_AMOUNT);
pot = 0;
}
} | 1 |
function extractAccountLength() constant returns (uint256 length) {
return accountIndex.length;
} | 0 |
function getEggsSinceLastHatch(address adr) public view returns(uint256){
uint256 secondsPassed=min(EGGS_TO_HATCH_1SHRIMP,SafeMath.sub(now,lastHatch[adr]));
return SafeMath.mul(secondsPassed,hatcheryShrimp[adr]);
} | 0 |
function extendTime(uint256 _timeExtension) onlyOwner public {
require(!finished);
require(now < endTime + timeExtension);
require(_timeExtension > 0);
timeExtension = timeExtension.add(_timeExtension);
require(timeExtension <= 7 days);
Extended(endTime.add(timeExtension));
} | 0 |
function buyTo(address participant) public payable {
require(!halted);
require(participant != address(0));
require(msg.value >= minAmount);
require(currentBlock() < fundingEndBlock);
uint256 baseAmountTokens = safeMul(msg.value, currentPrice.numerator);
uint256 lotteryAmount = blockLottery(baseAmountTokens);
uin... | 0 |
function claimWinnings() public {
require(now > lastTimestamp + 1 days);
require(msg.sender == currentWinner);
msg.sender.transfer(address(this).balance);
} | 0 |
function transferFrom(address from, address to, uint tokens) public whenNotPaused returns (bool) {
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[from] = balances[from].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(from, to, tokens);
return true;
} | 0 |
function BTTSToken(address owner, string symbol, string name, uint8 decimals, uint initialSupply, bool mintable, bool transferable) public {
data.init(owner, symbol, name, decimals, initialSupply, mintable, transferable);
} | 0 |
function min256(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
return a < b ? a : b;
} | 0 |
function nistTokenBase() public { }
function totalSupply() public view returns (uint256) {
return _supply;
} | 0 |
function release(IERC20 token) public {
uint256 unreleased = _releasableAmount(token);
require(unreleased > 0);
_released[address(token)] = _released[address(token)].add(unreleased);
token.safeTransfer(_beneficiary, unreleased);
emit TokensReleased(address(token), unreleased);
} | 0 |
function setCount(address _sender, uint256 _count) private {
counter[validater][_sender] = _count;
} | 0 |
function freezeAccount(address target, bool freeze) onlyOwner
{
frozenAccount[target] = freeze;
FrozenFunds(target, freeze);
} | 0 |
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
bool withinPeriod = now >= presaleStartTime && now <= endTime;
bool atLeastMinimumAmount = false;
if(block.timestamp <= startTime) {
require(_weiAmount.add(weiRaised.add(privateContribution)) <= presaleFundingGoal);
atLeastMinimumAm... | 0 |
function balanceOf( address _who ) public view returns (uint _value);
function transfer( address _to, uint _value) public returns (bool _success);
function approve( address _spender, uint _value ) public returns (bool _success);
function allowance( address _owner, address _spender ) public view returns (uint _allowa... | 0 |
function setUpgradeMaster(address _master) public onlyUpgradeMaster {
require(_master != address(0));
upgradeMaster = _master;
} | 0 |
function _createAuction(address _from, address _token, uint _tokenId, uint _startPrice, uint _duration) internal returns (uint) {
require(ERC721Interface(_token).transferFrom(_from, this, _tokenId));
auctions[++lastAuctionId] = Auction({
owner : _from,
token : _token,
tokenId : _tokenId,
startPrice : _startPrice,... | 0 |
function Vault(address _wallet) public {
require(_wallet != address(0));
wallet = _wallet;
} | 0 |
function balanceOf(address _owner) external view returns (uint256 balance);
}
contract Timelock {
ERC20Token public token;
address public beneficiary;
uint256 public releaseTime;
event TokenReleased(address beneficiary, uint256 amount);
constructor(
address _token,
address _beneficiary,
uint256 _releaseTime
) ... | 0 |
function today() private view returns (uint256) {
return now / 1 days;
} | 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 activateInvoiced(address addr) internal {
if (!invoicedActive[addr]) {
invoicedActive[addr] = true;
invoicedIndex.push(addr);
}
} | 0 |
function approve(address spender, uint value) public returns (bool success) {
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
} | 0 |
function setLockup_simus(address _simu, uint256 _value, uint256 _simuDate)
public
onlyOwner
{
require(_simu != address(0));
simus_locked[_simu] = _value;
simus_simuDate[_simu] = _simuDate;
UpdatedLockingState("simu", _simu, _value, _simuDate);
} | 0 |
modifier isSuspended() {
require(state == State.Suspended);
_;
} | 0 |
function ReleaseDate() constant returns (uint) { return Date; }
function WithdrawalEnabled() internal returns (bool) { return Date > 0 && Date <= now; }
function deposit() payable {
if (msg.value >= MinimumDeposit()) {
deposits[msg.sender] += msg.value;
}
Deposit(msg.sender, msg.value);
} | 1 |
function transferOwnership(address newOwner) onlyOwner public {
owner = newOwner;
} | 0 |
function buyTokens(address _beneficiary) saleOpen public payable {
require(_beneficiary != address(0));
require(msg.value > 0);
uint256 weiAmount = msg.value;
uint256 newDeposited = deposited[_beneficiary].add(weiAmount);
require(newDeposited <= whitelisted[_beneficiary]);
uint256 tokens = weiAmount.mul(rate);
d... | 0 |
function ToLend() public payable
{
Certificates[msg.sender].Time = now;
Certificates[msg.sender].Invested += msg.value;
Deposited(msg.sender, msg.value);
} | 1 |
constructor () internal {
_addDelegator(msg.sender);
} | 0 |
function checkIfFundingCompleteOrExpired() public {
if( now >= Stage3Deadline && state != State.Successful ){
state = State.Successful;
completedAt = now;
emit LogFundingSuccessful(totalRaised);
successful();
} else if (state == State.Stage1 && now >= Stage1Deadline){
state = State.Stage2;
} else if (state == S... | 0 |
function addWallet(address _wallet, string _data) public onlyPrivilegedAddresses {
require(_wallet != address(0));
require(!isWhitelisted(_wallet));
whitelist[_wallet].data = _data;
whitelist[_wallet].whitelisted = true;
whitelist[_wallet].createdTimestamp = now;
whitelistLength++;
} | 0 |
constructor (address beneficiary, uint256 start, uint256 cliffDuration, uint256 duration, bool revocable) public {
require(beneficiary != address(0));
require(cliffDuration <= duration);
require(duration > 0);
require(start.add(duration) > block.timestamp);
_beneficiary = beneficiary;
_revocable = revocable;
_du... | 0 |
function SATCoin() public
{
owner = msg.sender;
balances[owner] = 350000000 * 10 **8;
balances[address(this)] = 650000000 *10**8;
stage = Stages.NOTSTARTED;
Transfer(0, owner, balances[owner]);
Transfer(0, owner, balances[address(this)]);
} | 0 |
function isSuccessful()
public
constant
returns(bool)
{
return (
completed
);
} | 0 |
function finalize() public inState(State.Success) onlyOwner stopInEmergency {
if (address(finalizeAgent) != 0)
finalizeAgent.finalizeCrowdsale(token);
finalized = true;
Finalized();
} | 0 |
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) {
return allowed[_owner][_spender];
} | 0 |
function setBonusRate(uint256 _bonusRate) onlyOwner public {
require(_bonusRate > 0 && _bonusRate < 1000000);
bonusRate = _bonusRate;
} | 0 |
function balanceOf(address _owner) external constant returns (uint256) {
return balances[_owner];
} | 0 |
function transferOwnership(address newOwner) public onlyOwner {
_transferOwnership(newOwner);
} | 0 |
function freeze(address _account, uint _until) public onlyOwner {
if (_until == 0 || (_until != 0 && _until > now)) {
frozenAccounts[_account] = Frozen(true, _until);
}
} | 0 |
function safeSub(uint256 a, uint256 b)
internal
pure
returns (uint256)
{
require(
b <= a,
"UINT256_UNDERFLOW"
);
return a - b;
} | 0 |
function mod(uint256 a, uint256 b) internal pure returns(uint256) {
require(b != 0, "SafeMath: modulo by zero");
return a % b;
} | 0 |
function tokenPrice() returns (uint256);
}
contract DaoAccount
{
address public daoChallenge;
address public challengeOwner;
uint256 tokenBalance;
address owner;
modifier noEther() {if (msg.value > 0) throw; _}
modifier onlyOwner() {if (owner != msg.sender) throw; _}
modifier onlyDaoChallenge() {if (daoChallenge... | 0 |
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
if(msg.sender == account1 || msg.sender == account2 || msg.sender == account3 || msg.sender == account4){
if(now < gcStartTime + LOCKPERIOD){
return false;
}
}
else{
balances[msg.sender] -... | 0 |
function ETH_EUR() public view returns (uint256);
function ETH_EURCENT() public view returns (uint256);
}
pragma solidity ^0.5.0;
contract Oracle is OracleRequest {
using SafeMath for uint256;
address public rateControl;
address public tokenAssignmentControl;
constructor(address _rateControl, address _tokenAssignm... | 0 |
function setFundingCap(uint newCap) public onlyOwner notFinished {
weiFundingCap = ceilingStrategy.relaxFundingCap(newCap, weiRaised);
require(weiFundingCap >= minimumFundingGoal);
FundingCapSet(weiFundingCap);
} | 0 |
function getNow() internal constant returns (uint256) {
return now;
} | 1 |
function _transfer(address from, address to, uint256 value) internal {
if (_locked[from].locked) {
for (uint256 i = 0; i < _locked[from].batches.length; i++) {
if (block.timestamp <= _locked[from].batches[i].time) {
require(value <= balanceOf(from).sub(_locked[from].batches[i].amount));
break;
}
}
}
super._tra... | 0 |
function signedTransferHash(Data storage , address tokenOwner, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash) {
hash = keccak256(signedTransferSig, address(this), tokenOwner, to, tokens, fee, nonce);
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.