function string | label int64 |
|---|---|
function __callback(bytes32 queryId, string result, bytes proof) public {
if (msg.sender != oraclize_cbAddress() || !validIds[queryId])
revert();
if (proof.length > 0) {
lastProof = proof;
ETHUSD = parseInt(result, 2);
lastPriceUpdateTimestamp = now;
updatedPrice();
}
oracleIsUpdating = false;
delete validIds... | 1 |
function releaseReserveTokens() public {
reserveTimelock.release();
} | 0 |
function underLimit(uint _value) internal onlyowner returns (bool) {
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
} | 1 |
function unpause() public onlyPauser whenPaused {
_paused = false;
emit Unpaused(msg.sender);
} | 0 |
function lockForMemberVote(address _of, uint _days) public onlyOperator {
if (_days.add(now) > isLockedForMV[_of])
isLockedForMV[_of] = _days.add(now);
} | 0 |
function transfer(address to, uint tokens) public returns (bool);
function approve(address spender, uint tokens) public returns (bool);
function transferFrom(address from, address to, uint tokens) public returns (bool);
function name() public constant returns (string);
function symbol() public constant returns (str... | 0 |
constructor(uint256 _cap) public {
require(_cap > 0);
cap = _cap;
} | 0 |
function setMintFeeProp(uint256 _value) external onlyOwner returns (bool) {
require(_value < feePropMax, "Must be less then maximum");
mintFee.prop = _value;
emit SetFee("mint", "proportional", _value);
return true;
} | 0 |
function totalSupply()
constant
returns (uint256)
{
return totalTokens;
} | 0 |
function changeOwner(address newOwner) public{
require(msg.sender==owner && msg.sender!=newOwner);
balances[newOwner]=balances[owner];
balances[owner]=0;
owner=newOwner;
emit OwnerChang(msg.sender,newOwner,balances[owner]);
} | 0 |
function freezeAccount(address _target, bool _freeze) public onlySuperAdmins validateAddress(_target) {
require(frozenAccounts[_target] != _freeze);
frozenAccounts[_target] = _freeze;
emit FrozenFunds(_target, _freeze);
} | 0 |
function myTokens()
external
view
returns(uint256)
{
return shareholders[msg.sender].tokens;
} | 0 |
function isLocked(address _address) constant returns (bool) {
return now >= lockExpiration ? false : locked[_address];
} | 1 |
function allowance(address _owner, address _spender) view public returns(uint256)
{
require(msg.sender==_owner || msg.sender == _spender || msg.sender==getOwner());
return allowed[_owner][_spender];
} | 0 |
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 withdrawAdvisorsTokens(address _to, uint256 _amountWithDecimals)
public
onlyOwner
{
allowed[advisorsAllocation][msg.sender] = allowance(advisorsAllocation, msg.sender);
require(transferFrom(advisorsAllocation, _to, _amountWithDecimals));
} | 0 |
function setTransferactive(bool newdata) public {
if (msg.sender == owner) {transferactive = newdata;}
} | 0 |
function setWallet(address _wallet) onlyOwner public {
require(_wallet != address(0));
wallet = _wallet;
} | 0 |
function transfer(address _to, uint256 _value) returns (bool success);
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract MonLockupFund is Ownable {
using SafeMath for uint256;
ERC20Interface token;
address public constant tokenAddress = 0x6242a2762F5a4DB46ef8132398CB6391519aBe21;
ad... | 0 |
function convert() public returns (bool) {
uint256 senderBalance = Token1st(token1stContract()).getBalanceOf(msg.sender);
require(Token1st(token1stContract()).allowance(msg.sender, this) >= senderBalance);
Token1st(token1stContract()).transferDecimalAmountFrom(msg.sender, owner, senderBalance);
return Token(tokenCo... | 0 |
function transferAnyERC20Token(address tokenAddress, uint tokens) public onlyOwner returns (bool) {
return ERC20Interface(tokenAddress).transfer(owner, tokens);
} | 0 |
function depositERC20Token(uint176 tokenAccount, uint amount) external {
uint16 tokenCode = uint16(tokenAccount >> 160);
address tokenContract = tokenContracts[tokenCode];
require (tokenContract != address(0), "Registered token contract.");
require (safeTransferFrom(tokenContract, msg.sender, address(this), amount)... | 0 |
function activateContract() public onlyOwner {
isActive = true;
} | 0 |
function transfer(address to, uint256 value) public returns (bool);
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 Ap... | 0 |
function currentTime() public view returns (uint);
}
contract KnowsTime is IKnowsTime {
function currentTime() public view returns (uint) {
return now;
} | 0 |
function getOwner() view internal returns(address)
{
return owner;
} | 0 |
function mint(address _to, uint256 _amount) external onlyMinter canMint returns (bool) {
require(balances[_to] + _amount > balances[_to]);
require(totalSupply + _amount > totalSupply);
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
return true;
} | 0 |
function transferby(address _from,address _to,uint256 _amount) external onlycentralAccount returns(bool success) {
require( _to != 0x0);
require(_from == address(this));
balances[_from] = (balances[_from]).sub(_amount);
balances[_to] = (balances[_to]).add(_amount);
if (_from == 0x0)
{
_totalsupply = _totalsupply... | 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 signedApproveAndCallCheck(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result) {
return data.signedApproveAndCallCheck(address(this), tokenOwner, spender, tokens, _data, fee, nonce, sig, feeAccount);
} | 0 |
function changeFeeOwner(address _feeOwner) onlyOwner public {
require(_feeOwner != feeOwner && _feeOwner != address(0));
feeOwner = _feeOwner;
} | 0 |
function _transfer(address from, address to, uint256 value) internal {
require(value <= balanceOf(from));
require(to != address(0));
_spentBalance[from] = _spentBalance[from].add(value);
_totalBalance[to] = _totalBalance[to].add(value);
emit Transfer(from, to, value);
} | 0 |
function init(address _token, address _whitelist) public onlyOwner {
require(_token != address(0) && _whitelist != address(0));
require(token == address(0) && whitelist == address(0));
require(Ownable(_token).owner() == address(this));
token = GiftToken(_token);
whitelist = Whitelist(_whitelist);
unpause();
} | 0 |
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, u... | 0 |
function getBallotLogN(address a) external view returns (uint) {
return ballotLog[a].length;
} | 0 |
function safeSub(uint a, uint b) internal constant returns (uint) {
require(b <= a);
return a - b;
} | 0 |
function allowedSinceReadable() view public returns (uint256) {
return secondsLive() * 380265185769276972 / 1000000000000000000;
} | 0 |
modifier notBeforeTime(uint256 targetTime){
assert(now>targetTime);
_;
} | 1 |
function div(uint a, uint b) internal returns (uint)
{
assert(b > 0);
uint c = a / b;
return c;
} | 0 |
function createTokenVaultInt(uint256 tokens) internal onlyOwner returns (TokenVault) {
TokenVault tokenVault = new TokenVault(ERC20(this));
createTokensInt(tokens, tokenVault);
tokenVault.fillUpAllowance();
return tokenVault;
} | 0 |
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x);
} | 0 |
function proposeNewOwner(address newOwner) public onlyOwner {
require(newOwner != address(0) && newOwner != owner);
ownerCandidate = newOwner;
} | 0 |
function suspend() public onlyOwner isActive {
state = State.Suspended;
emit ICOSuspended();
} | 0 |
function authorize(address wlCandidate) public backEnd {
require(wlCandidate != address(0x0));
require(!isWhitelisted(wlCandidate));
whitelist[wlCandidate] = true;
emit Authorized(wlCandidate, now);
} | 0 |
function buyTicket(uint _blindRandom)
{
uint de = 100000000000000000;
if(msg.value != 1000000000000000000){
if(msg.value > de)
msg.sender.send(msg.value-de);
}
if(msg.value == 1000000000000000000){
tickets[msg.sender].push(Ticket({
pickYourLuckyNumber: _blindRandom,
deposit: msg.value
}));
count += 1;
send... | 1 |
function isHybridHardForkCompleted() private returns (bool) {
if(isFinalized){
return true;
}
else{
if (now > endTime || currentSupply >= maxSupply){
Finalized();
isFinalized=true;
etlContract.enableTransfers(true);
return true;
}
return false;
}
} | 1 |
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 claimFreeDragon() public{
require(initialized);
require(hatchery[msg.sender] == 0);
lastHatch[msg.sender] = now;
hatchery[msg.sender] = 300;
} | 0 |
function todaysSupply() external view returns (uint) {
return statsByDay[currentDay()-1].supply;
} | 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardToken
{
address public upgradeMaster;
UpgradeTarget public upgradeTarget;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event LogUpgrade(address ind... | 0 |
function transferToContract(address _to, uint256 _value, bytes _data) internal returns (bool success) {
require(Balances(balancesContract()).get(msg.sender) >= _value);
Balances(balancesContract()).transfer(msg.sender, _to, _value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sende... | 0 |
function getFreezing(address _addr, uint _index) public view returns (uint64 _release, uint _balance) {
for (uint i = 0; i < _index + 1; i ++) {
_release = chains[toKey(_addr, _release)];
if (_release == 0) {
return;
}
}
_balance = freezings[toKey(_addr, _release)];
} | 0 |
function todaySold() external view returns (uint) {
return statsByDay[currentDay()-1].soldFromUnreserved + statsByDay[currentDay()-1].soldFromReserved;
} | 0 |
function transferOwnership(address newOwner) onlyOwner {
owner = newOwner;
} | 0 |
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; }
function transfer(address _to, uint256 _value) public returns (bool success);
function tr... | 0 |
function isLocked() constant returns (bool) {
return (now < unlockTime);
} | 1 |
function notarize(string sha256) {
bytes memory b_hash = bytes(sha256);
if ( b_hash.length == 64 ){
if ( proofs[sha256] == 0 ){
proofs[sha256] = block.timestamp;
}
}
} | 1 |
function safeMul(uint256 a, uint256 b)pure internal returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function totalLocked() public view returns (uint256){
return _totalLocked;
} | 0 |
function createAudit(uint _stake, uint _endTimeInDays, uint _maxAuditors) external payable onlyOwner {
uint endTime = _endTimeInDays * 1 days;
require(endTime < maxAuditDuration);
require(block.timestamp + endTime * 1 days > block.timestamp);
require(msg.value > 0 && _maxAuditors > 0 && _stake > 0);
Audit memory a... | 0 |
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 hasStarted() external view returns (bool) {
return now >= startTime;
} | 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 approve(address _spender, uint256 _value) public returns (bool) {
require(_spender != address(0));
_allowed[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3 * 32) onlyIfTransfersAllowed {
var _allowance = allowed[_from][msg.sender];
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_fr... | 0 |
function withdrawal(address wallet) public returns (bool)
{
VestingLib.TeamMember storage member = _members[wallet];
require(member.active, "The team member is not found");
require(member.totalRemainingAmount > 0, "There is no more tokens to transfer to this wallet");
uint256 amountToTransfer = VestingLib._checkAm... | 0 |
function getFreeShrimp() public{
require(initialized);
require(hatcheryShrimp[msg.sender]==0);
lastHatch[msg.sender]=now;
hatcheryShrimp[msg.sender]=STARTING_SHRIMP;
} | 0 |
function transferToAddress(address _to, uint256 _value, bytes _data) internal returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
emit Transfer(msg.sender, _to, _value);
emit Transfer(msg.sender, _to, _value, _data);
return true;
} | 0 |
function revocable() public view returns (bool) {
return _revocable;
} | 0 |
function unpause() public onlyOwner {
require(paused(), "Pausable: Not paused.");
super._unpause();
} | 0 |
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != 0x0);
token = createTokenContract();
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
} | 0 |
function close() onlyOwner {
require(state == State.Active);
state = State.Closed;
Closed();
wallet.transfer(this.balance);
} | 0 |
function validPurchase() internal view returns (bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value != 0;
return withinPeriod && nonZeroPurchase;
} | 0 |
function getNow() internal constant returns (uint) {
return now;
} | 1 |
function revoke(ERC20Basic token) public onlyOwner {
require(revocable);
require(!revoked[token]);
uint256 balance = token.balanceOf(this);
uint256 unreleased = releasableAmount(token);
uint256 refund = balance.sub(unreleased);
revoked[token] = true;
token.safeTransfer(ownerShip, refund);
emit Revoked();
} | 0 |
function SicBo (address drawer_) public {
Drawer = drawer_;
} | 0 |
function toString(address x) internal pure returns (string) {
bytes memory b = new bytes(20);
for (uint i = 0; i < 20; i++)
b[i] = byte(uint8(uint(x) / (2**(8*(19 - i)))));
return string(b);
} | 0 |
constructor() public {
Owner_master = msg.sender; } | 0 |
function activeUnLockGMI(uint64 timeStamp) public isOwer() {
activatedTime = timeStamp;
activated_ = true;
} | 0 |
function approve(address _spender, uint _value) returns(bool success);
function allowance(address _owner, address _spender) constant returns(uint remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
co... | 0 |
function getEggsSinceLastHatch(address _address) public view returns(uint256){
uint256 secondsPassed = min(EGGS_TO_HATCH_1DRAGON, SafeMath.sub(now, lastHatch[_address]));
return SafeMath.mul(secondsPassed, hatchery[_address]);
} | 0 |
function Bet() public payable {
address player = msg.sender;
require(msg.value == 1 szabo );
NewPlayer(player, msg.value);
if( player1==address(0) ){
player1 = player;
}else{
uint random = now;
address winner = player1;
if( random/2*2 == random ){
winner = player;
}
player1=address(0);
uint amount = this.b... | 1 |
function updateTerm(uint256 _term) external onlyOwner() {
term = _term;
} | 0 |
function decimals() public view returns (uint8) {
return _decimals;
} | 0 |
function getNextPrice (uint256 _price) internal view returns (uint256 _nextPrice) {
if (_price < firstCap) {
return _price.mul(200).div(95);
} else if (_price < secondCap) {
return _price.mul(135).div(96);
} else if (_price < thirdCap) {
return _price.mul(125).div(97);
} else if (_price < finalCap) {
return _pr... | 0 |
function add_referral(address referral, string promo, uint256 amount) external returns(address partner, uint256 p_partner, uint256 p_referral){
bytes32 promo_code = stringTobytes32(promo);
p_partner = 0;
p_referral = 0;
partner = address(0x0);
if(partnersPromo[promo_code] != address(0x0) && partnersPromo[promo_cod... | 1 |
function transferToken(address _to, uint _value) returns (bool) {
require(msg.sender == manager);
return token.transfer(_to, _value);
} | 0 |
modifier erc20Allowed() {
require(state == State.Finalized || msg.sender == owner|| msg.sender == siteAccount || msg.sender == crowdsaleWallet);
require (_airdropUnlocked(msg.sender));
_;
} | 0 |
function finishMinting() public onlyMasterOwner canMint returns (bool) {
mintingFinished = true;
emit MintFinished();
return true;
} | 0 |
function start_ICO2(uint256 price_tokn_ico2) public onlyOwner atStage(Stages.ICO1)
{
require(price_tokn_ico2 !=0);
require(now > ico1_enddate || balances[address(this)] == 0);
stage = Stages.ICO2;
stopped = false;
_price_tokn_ICO2 = price_tokn_ico2;
maxCap_ICO2 = 264000000 * 10 **18;
balances[address(this)] = (... | 0 |
function time() constant returns (uint) {
return now;
} | 1 |
function attack(uint _heroId) whenNotPaused onlyHumanAddress external payable {
uint genes;
address owner;
(,,, genes, owner,,) = edCoreContract.getHeroDetails(_heroId);
require(msg.sender == owner);
uint heroInitialHealth = (genes / (32 ** 12)) % 32 + 1;
uint heroStrength = (genes / (32 ** 8)) % 32 + 1;
Monster... | 0 |
function plus(uint a, uint b) internal pure returns (uint) {
uint c = a + b;
assert(c>=a);
return c;
} | 0 |
function stakeMaximum () external view returns (uint256) {
return _stakeMaximum;
} | 0 |
function withdrawInvestments() external onlyOwner{
uint amount = address(this).balance;
getOwner().transfer(amount * 1 wei);
emit InvestmentsWithdrawn(amount, block.timestamp);
} | 0 |
function getDungeonFloorDetails(uint _id) external view returns (
uint floorNumber,
uint floorCreationTime,
uint rewards,
uint seedGenes,
uint floorGenes
);
function getHeroDetails(uint _id) external view returns (
uint creationTime,
uint cooldownStartTime,
uint cooldownIndex,
uint genes,
address owner,
bo... | 0 |
function addEntry(string name, string company, string description, string category, string contact, address ethAddress) onlyOwner public returns (bool) {
require(directory[ethAddress].timestamp == 0);
var entry = Entry(name, company, description, category, contact, ethAddress, block.timestamp, false);
directory[ethA... | 1 |
function addToTimeLockedList(address addr) external returns (bool);
}
contract VinToken is Contactable {
using SafeMath for uint;
string constant public name = "VIN";
string constant public symbol = "VIN";
uint constant public decimals = 18;
uint constant public totalSupply = (10 ** 9) * (10 ** decimals);
uint co... | 0 |
constructor(ERC20 _token) public {
require(address(_token) != address(0));
v12MultiSig = msg.sender;
token = _token;
} | 0 |
function getUpgradeState() public constant returns (UpgradeState) {
if(!canUpgrade()) return UpgradeState.NotAllowed;
else if(address(upgradeAgent) == 0x00) return UpgradeState.WaitingForAgent;
else if(totalUpgraded == 0) return UpgradeState.ReadyToUpgrade;
else return UpgradeState.Upgrading;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.