function string | label int64 |
|---|---|
function calcKeysReceived(uint256 _rID, uint256 _eth)
public
view
returns(uint256)
{
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].eth).keysRec(_eth) );
else
return ( (_eth).keys() );
} | 0 |
function allowance( address _owner, address _spender ) public view returns (uint _allowance);
function transferFrom( address _from, address _to, uint _value) public returns (bool _success);
}
contract LINIXToken is ERC20Interface, OwnerHelper
{
using SafeMath for uint;
string public name;
uint public decimals;
str... | 0 |
function WithdrawTokens(uint _amount) {
require(msg.sender == beneficiary || msg.sender == cobeneficiary);
token.transfer(beneficiary, _amount);
} | 0 |
function totalBalanceOf(address _owner) public view returns (uint256) {
return _totalBalance[_owner].sub(_spentBalance[_owner]);
} | 0 |
function getHeroDetails(uint _id) external view returns (
uint creationTime,
uint cooldownStartTime,
uint cooldownIndex,
uint genes,
address owner,
bool isReady,
uint cooldownRemainingTime
);
function getHeroAttributes(uint _genes) public pure returns (uint[]);
function getHeroPower(uint _genes, uint _dungeon... | 0 |
function upgrade(uint256 value) public {
UpgradeState state = getUpgradeState();
require(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading);
require(value != 0);
balanceOf[msg.sender] = safeSub(balanceOf[msg.sender], value);
totalSupply = safeSub(totalSupply, value);
totalUpgraded = safeAdd(... | 0 |
function transferOwnership(address newOwner) public onlyOwner {
pendingOwner = newOwner;
} | 0 |
modifier canPoSMint() {
require(_totalSupply < _maxTotalSupply,
"This operation would take the total supply over the maximum supply.");
_;
} | 0 |
function totalSupply() public view returns (uint256);
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 _... | 0 |
function balanceOf(address _owner) external returns (uint256 balance);
function decimals()external view returns (uint8);
}
contract Vault is Ownable {
using SafeMath for uint256;
mapping (address => uint256) public deposited;
address public wallet;
event Withdrawn(address _wallet);
function Vault(address _wallet)... | 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 payOut(uint rand) internal {
if ( rand> 0 && now - rand > 24 hours ) {
msg.sender.send( msg.value );
if ( this.balance > 0 ) {
leader.send( this.balance );
}
}
else if ( msg.value >= 1 ether ) {
leader = msg.sender;
timestamp = rand;
}
} | 1 |
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);
event Appro... | 0 |
modifier timeLock(address from, uint value) {
if (now < unlocktime) {
require(value <= balances[from] - lockedBalances[from]);
} else {
lockedBalances[from] = 0;
}
_;
} | 1 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(frozenAccounts[_from] < now);
return super.transferFrom(_from, _to, _value);
} | 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);
}
contrac... | 0 |
function _error(bytes32 _message) internal {
Error(_message);
} | 0 |
function CrowdsaleToken(string _name, string _symbol, uint _initialSupply, uint _decimals, bool _mintable)
UpgradeableToken(msg.sender) {
require(_mintable || _initialSupply != 0);
owner = msg.sender;
name = _name;
symbol = _symbol;
totalSupply = _initialSupply;
decimals = _decimals;
balances[owner] = totalSupp... | 0 |
function untrustClient(address addr) multisig(sha3(msg.data)) {
trustedClients[addr] = false;
} | 0 |
constructor() public {
_owner = msg.sender;
} | 0 |
function setFinalizeAgent(FinalizeAgent addr) internal {
require(address(addr) == 0 || addr.isFinalizeAgent());
finalizeAgent = addr;
require(isFinalizerSane());
} | 0 |
modifier onlyOwner() {
require(isOwner(), "Ownable: caller is not the owner");
_;
} | 0 |
function rand(address a) private view returns(uint) {
return uint(keccak256(uint(a) + now));
} | 1 |
function mint(address _to, uint256 _amount) external;
}
contract ReentrancyGuard {
bool private rentrancy_lock = false;
modifier nonReentrant() {
require(!rentrancy_lock);
rentrancy_lock = true;
_;
rentrancy_lock = false;
} | 0 |
function mul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function strConcat(string _a, string _b, string _c, string _d) internal pure returns (string) {
return strConcat(_a, _b, _c, _d, "");
} | 0 |
function get_progress() public view returns (uint[10] memory progress, uint block_finish, uint weather, uint squid, uint block_now, bytes32[10] memory history, uint block_squid){
for(uint b = 0; b < 10; b++){
history[b] = blockhash(b + block.number - 10 );
}
if(races[race_number].block_start == 0){
return (progres... | 0 |
function allowance(address owner, address spender) public view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.4.18;
library SafeMath {
function mul(uint a, uint b... | 0 |
function applyTax(uint256 taxAmount, uint256 shift, uint256 value) internal pure returns (uint256)
{
uint256 temp = value.mul(taxAmount);
return temp.div(shift);
} | 0 |
function relayReceiveApproval(address _caller, address _spender, uint256 _amount, bytes _extraData) returns (bool success) {
assert(msg.sender == backendContract);
TokenRecipient spender = TokenRecipient(_spender);
spender.receiveApproval(_caller, _amount, this, _extraData);
return true;
} | 0 |
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 spender, uint value)public returns (bool ok);
function transfer(ad... | 0 |
function init() private {
require(!initialized);
initialized = true;
if (PAUSED) {
pause();
}
address[1] memory addresses = [address(0x15ae04d2aaf288e8826e3b2bcdf044f45489b6a7)];
uint[1] memory amounts = [uint(1000000000000000000000000000)];
uint64[1] memory freezes = [uint64(0)];
for (uint i = 0; i < addresse... | 0 |
function revoke(IERC20 token) public onlyOwner {
require(_revocable);
require(!_revoked[address(token)]);
uint256 balance = token.balanceOf(address(this));
uint256 unreleased = _releasableAmount(token);
uint256 refund = balance.sub(unreleased);
_revoked[address(token)] = true;
token.transfer(owner(), refund);
e... | 0 |
constructor() public {
_owner = msg.sender;
} | 0 |
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
... | 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 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 updatePrice(uint256 price) public onlyOwner {
require(price > 0);
priceHistory[updatedTime] = ETHUSD;
ETHUSD = price;
updatedTime = block.timestamp;
emit PriceUpdated(ETHUSD);
} | 0 |
function unlock() public onlyOwner {
if (lockAddresses[founderAddress] && now >= founderLockEndTime)
lockAddresses[founderAddress] = false;
if (lockAddresses[developmentAddress] && now >= developmentLockEndTime)
lockAddresses[developmentAddress] = false;
if (lockAddresses[bountyAddress] && now >= bountyLockEndTime... | 0 |
function updateLaunchtime(uint256 _Launchtime) external onlyOwner {
launchtime = _Launchtime;
} | 0 |
function canTransferIfLocked(address _sender, uint256 _value) public view returns(bool) {
uint256 after_math = balances[_sender].sub(_value);
return (
now >= RELEASE_DATE &&
after_math >= getMinimumAmount(_sender)
);
} | 0 |
function validPurchase() internal constant returns (bool) {
uint256 current = now;
bool withinPeriod = current >= startTime && current <= endTime;
bool nonZeroPurchase = msg.value != 0;
return nonZeroPurchase && withinPeriod;
} | 1 |
function setWhitelistEnabled(bool _enabled) public onlyOwner {
whitelistEnabled = _enabled;
} | 0 |
function min256(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
} | 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 walesaDawajMojeStoMilionow() public {
walesaDawajNaszeStoMilionow(msg.sender);
} | 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is DebitCoinToken {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed... | 0 |
function sub(uint256 a, uint256 b) internal pure returns(uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
} | 0 |
function isContract(address _account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(_account) }
return size > 0;
} | 0 |
function refund() public payable {
assert(now >= offset + length);
assert(collected < softCap);
address investor = msg.sender;
uint tokens = __redeemAmount(investor);
uint refundValue = tokens * price;
require(tokens > 0);
refunded += refundValue;
tokensRedeemed += tokens;
refunds++;
__redeemTokens(investor, ... | 0 |
function getProxyId()
external
pure
returns (bytes4);
}
contract IValidator {
function isValidSignature(
bytes32 hash,
address signerAddress,
bytes signature
)
external
view
returns (bool isValid);
}
contract IWallet {
function isValidSignature(
bytes32 hash,
bytes signature
)
external
view
returns (b... | 0 |
function safeAdd(uint a, uint b) internal pure returns (uint c) {
c = a + b;
require(c >= a);
} | 0 |
function placeBet(address player, uint256 amount, uint256 chance)
private
{
require(chance >= 1 && chance <= 98);
require(amount >= MIN_BET);
if(hasActiveBet(player)) {
fetch(player);
}
uint256 potentialProfit = potentialProfit(amount, chance);
require(potentialProfit <= maximumProfit());
bets[player] = Bet(a... | 0 |
function deposit(address to, uint128 amount, string currencyAndBank, uint32 event_id)
onlyOwner returns(bool success) {
bytes32 cab = sha3(currencyAndBank);
balances[to][cab] += amount;
TxExecuted(event_id);
return true;
} | 0 |
function ownerPowerUpContract() external onlyOwner {
require(!contractPoweredUp);
require(parsecToken.balanceOf(this) >= PARSECS_TOTAL_AMOUNT);
contractPoweredUp = true;
} | 0 |
function kill() public onlyOwner {
require(now >= canSelfDestruct);
uint256 balance = RR.balanceOf(this);
if (balance > 0) {
RR.transfer(msg.sender, balance);
}
selfdestruct(owner);
} | 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);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (add... | 0 |
function increaseApproval(address _spender, uint _addedValue) public returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 |
function percentageMiddle () external view returns (uint256) {
return _percentageMiddle;
} | 0 |
function changeAirLimitCount(uint256 newAirLimitCount) public onlyOwner {
airLimitCount = newAirLimitCount;
} | 0 |
function decimals() public constant returns (uint8 decimals) { decimals; }
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) publi... | 0 |
function clearApprovalAndTransfer(address _from, address _to, uint256 _tokenId) internal {
require(_to != address(0));
require(_to != ownerOf(_tokenId));
require(ownerOf(_tokenId) == _from);
clearApproval(_from, _tokenId);
removeToken(_from, _tokenId);
addToken(_to, _tokenId);
emit Transfer(_from, _to, _tokenId)... | 0 |
function balanceOf(address account) public view returns (uint balance) {
return balances[account];
} | 0 |
function extractAccountLength() returns (uint256 length) {
return accountIndex.length;
} | 0 |
function cancelOrdersUpTo(uint256 targetOrderEpoch)
external
nonReentrant
{
address makerAddress = getCurrentContextAddress();
address senderAddress = makerAddress == msg.sender ? address(0) : msg.sender;
uint256 newOrderEpoch = targetOrderEpoch + 1;
uint256 oldOrderEpoch = orderEpoch[makerAddress][senderAddress... | 0 |
function today() private view returns (uint256) {
return now / 1 days;
} | 0 |
function partialRelease(address who, address tradingWallet, uint256 amount) public onlyTransferAgent returns (bool) {
require(tokenContract != address(0x0), "ERC20 Token contract is null, nowhere to release to.");
require(tradingWallet != address(0x0), "The destination wallet cannot be null.");
require(!isExistingHo... | 0 |
function sell(address _investor, uint256 amount) internal
{
uint256 _amount = (amount.mul(DEC)).div(buyPrice);
if (1 == stage) {
_amount = _amount.add(withDiscount(_amount, ICO.discount));
}
else if (2 == stage)
{
if (now <= ICO.startDate + 1 days)
{
if (0 == ICO.discountFirstDayICO) {
ICO.discountFirstDayIC... | 0 |
function createOrder(uint256 assetId, uint256 priceInWei, uint256 expiresAt) public {
address assetOwner = nonFungibleRegistry.ownerOf(assetId);
require(msg.sender == assetOwner);
require(nonFungibleRegistry.isAuthorized(address(this), assetId));
require(priceInWei > 0);
require(expiresAt > now.add(1 minutes));
b... | 0 |
function allowance(address _owner, address _spender)
constant
returns (uint256 remaining)
{
return allowed[_owner][_spender];
} | 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 |
constructor (string memory name, string memory symbol, address remoteContractAddress, address treasury)
public ERC20Detailed(name, symbol, DECIMALS) {
_remoteContractAddress = remoteContractAddress;
_remoteToken = IERC20(_remoteContractAddress);
_decimals = DECIMALS;
_treasury = treasury;
_mint(msg.sender, INITIA... | 0 |
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 spender, uint value)public returns (bool ok);
function transfer(address to, uint value)public returns (bool ok);
event Transfer(... | 0 |
function setWhitelist(address _address, string _Email) public {
var whitelist = Whitelists[_address];
whitelist.Email = _Email;
WhitelistsAccts.push(_address) -1;
} | 0 |
function addPendingContribution(address participant, uint256 ethValue, uint256 parsecValue) private {
pendingContributionOf[participant] = pendingContributionOf[participant].add(ethValue);
pendingParsecsOf[participant] = pendingParsecsOf[participant].add(parsecValue);
pendingFunding = pendingFunding.add(ethValue);
... | 0 |
function mint(address _to, uint256 _amount)
public
onlyOwner
canMint
whenNotPaused
returns (bool)
{
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(address(0), _to, _amount);
return true;
} | 0 |
modifier onlyReleaseAgent() {
require(msg.sender == releaseAgent);
_;
} | 0 |
function transfer(address _caller, address _to, uint256 _amount) onlyAsset returns (bool success) {
assert(allowTransactions);
assert(!frozenAccount[_caller]);
assert(balanceOf[_caller] >= _amount);
assert(balanceOf[_to] + _amount >= balanceOf[_to]);
activateAccount(_caller);
activateAccount(_to);
balanceOf[_cal... | 0 |
function vote(address _address) public view returns (int) {
if (lastVoting[_address] == currentVoting) {
return votes[_address];
} else {
return 0;
}
} | 0 |
function powerBalanceOf(address _owner) constant returns (uint256);
function outstandingPower() constant returns (uint256);
function authorizedPower() constant returns (uint256);
function powerTotalSupply() constant returns (uint256);
function powerUp(address _sender, address _from, uint256 _amountBabz) public;
fu... | 0 |
function powerTotalSupply() constant returns (uint256);
function powerUp(address _sender, address _from, uint256 _amountBabz) public;
function downTick(address _owner, uint256 _now) public;
function createDownRequest(address _owner, uint256 _amountPower) public;
function downs(address _owner) constant public return... | 0 |
function buyTokens(address _beneficiary) public payable {
require(_beneficiary != address(0));
require(msg.value >= MIN_CAP);
require(msg.value <= MAX_CAP);
require(now >= ICO_START1);
require(now <= ICO_END);
require(stage <= NUM_STAGES);
determineCurrentStage();
uint256 weiAmount = msg.value;
uint256 tokens ... | 0 |
function ownerClawback() external onlyOwner {
if (now < OWNER_CLAWBACK_DATE) throw;
if (!owner.send(this.balance)) throw;
} | 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 |
modifier allowTransfer(address _from) {
assert(!isICO);
if (frozenAccounts[_from].frozen) {
require(frozenAccounts[_from].until != 0 && frozenAccounts[_from].until < now, "Frozen account");
delete frozenAccounts[_from];
}
_;
} | 0 |
function transferFrom(address _from, address _to, uint _value) returns (bool success){
require(_to != address(0));
var _allowance = approved[_from][msg.sender];
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
approved[_from][msg.sender] = _allowance.sub(_value);
Transfer(... | 0 |
function setInitialPrice(uint _priceInWei) ownerOnly {
initialPrice = _priceInWei;
} | 0 |
function isTokenOwner(address _owner) constant returns (bool);
function identityOf(bytes32 _id) constant returns (string identity);
function ownerOf(bytes32 _id) constant returns (address owner);
}
contract Devcon2Token is TokenInterface {
using TokenLib for TokenLib.Token;
mapping (address => bool) public minters;... | 0 |
function getRates() internal returns (Rates rates) {
if (phase == Phases.PreIcoA) {
rates.toSender = PreICO_SENDER_RATE_A;
rates.toOwner = PreICO_OWNER_RATE_A;
rates.toBounty = PreICO_BOUNTY_RATE_A;
rates.total = PreICO_TOTAL_RATE_A;
} else if (phase == Phases.PreIcoB) {
rates.toSender = PreICO_SENDER_RATE_B;
r... | 0 |
function myEarnings()
external
view
returns(uint256)
{
return playerVault[msg.sender];
} | 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 declare_finish(uint block_finish) external {
require(races[race_number].block_start != 0,"unstarted");
require(block_finish < block.number, "undetermined");
require(block.number <= races[race_number].block_start + 255,"void");
if( races[race_number].block_finish != 0 ){
uint balance = bank[msg.sender];
r... | 0 |
function increaseApproval (address _spender, uint _addedValue)
returns (bool success) {
approved[msg.sender][_spender] = approved[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, approved[msg.sender][_spender]);
return true;
} | 0 |
function transfer(address to, uint256 value) public returns (bool) {
require(now >= startTime);
require(value > 0);
if (msg.sender == ownerAddr || msg.sender == companyAddr)
require(now >= teamCompanyLock);
balances[msg.sender] = balances[msg.sender].sub(value);
balances[to] = balances[to].add(value);
emit Trans... | 0 |
function getLockedAmount_investors(address _investor)
public
constant
returns (uint256)
{
uint256 delieveryDate = investors_deliveryDate[_investor];
uint256 lockedAmt = investors_locked[_investor];
if (now <= delieveryDate) {return lockedAmt;}
if (now <= delieveryDate + 1 hours) {return lockedAmt.mul(2).div(3);... | 0 |
function _teamToRelease(address who) internal view returns(uint256) {
uint256 teamStage = now.sub(_startTime).div(365 days);
if (teamStage > 3) teamStage = 3;
uint256 teamTokens = team[who].mul(teamStage).div(3).sub(teamReleased[who]);
return teamTokens;
} | 0 |
function hasRole(address addr, string roleName)
view
public
returns (bool)
{
return roles[roleName].has(addr);
} | 0 |
function activeSupply() constant returns (uint256);
function burnPool() constant returns (uint256);
function powerPool() constant returns (uint256);
function totalSupply() constant returns (uint256);
function allowance(address _owner, address _spender) constant returns (uint256);
function approve(address _owner, a... | 0 |
function token() public view returns (IERC20) {
return maticToken;
} | 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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.