function string | label int64 |
|---|---|
function transfer(address to, uint value) public returns (bool success) {
balances[msg.sender] = balances[msg.sender].sub(value);
balances[to] = balances[to].add(value);
Transfer(msg.sender, to, value);
return true;
} | 0 |
function underLimit(uint _value) internal onlyowner returns (bool) {
return true;
} | 1 |
function randomGen() constant returns (uint randomNumber) {
return block.timestamp;
} | 1 |
function transferFrom(address from, address to, uint256 value) public returns (bool);
function burn() public;
}
contract MonedaICO {
using SafeMath for uint256;
struct DateRate {
uint256 date;
uint256 rate;
} | 0 |
function voteAllowTransactions(bool allow) multisig(sha3(msg.data)) {
assert(allow != allowTransactions);
allowTransactions = allow;
} | 0 |
function ecoIssue(address _to) onlyOwner public
{
require(saleTime == false);
require(tokenIssuedEco == 0);
uint tokens = maxEcoSupply;
balances[_to] = balances[_to].add(tokens);
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedEco = tokenIssuedEco.add(tokens);
emit EcoIssue(_to, tokens);
} | 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 changeDates(uint256 _startTime, uint256 _endTime)
external onlyOwner beforeStarting
{
if (_startTime > 0 && _endTime > 0) {
require(_startTime < _endTime);
}
if (_startTime > 0) {
startTime = _startTime;
}
if (_endTime > 0) {
endTime = _endTime;
}
} | 0 |
function TokenVesting(address _beneficiary, uint256 _start, uint256 _cliff, uint256 _duration, bool _revocable) public {
require(_beneficiary != address(0));
require(_cliff <= _duration);
beneficiary = _beneficiary;
revocable = _revocable;
duration = _duration;
cliff = _start.add(_cliff);
start = _start;
} | 0 |
function purchase(uint256 _tokenId) public
payable
isNotContract(msg.sender)
{
Burrito storage burrito = burritoData[_tokenId];
uint256 price = burrito.price;
address oldOwner = burrito.owner;
address newOwner = msg.sender;
uint256 excess = msg.value.sub(price);
require(price > 0);
require(msg.value >= price)... | 1 |
function approve(address _spender, uint256 _value) returns (bool success)
{
if ((frozenAccount[msg.sender]) || (frozenAccount[_spender]))
{
return false;
}
else
{
allowance[msg.sender][_spender] = _value;
bitqyRecipient spender = bitqyRecipient(_spender);
return true;
}
} | 0 |
modifier isIssetRecepient(){
require(balances[msg.sender] > 0, "Please send something");
_;
} | 0 |
function finalizeCrowdsale(CrowdsaleToken token) public;
}
contract GenericCrowdsale is Haltable {
using SafeMath for uint;
CrowdsaleToken public token;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokens... | 0 |
function disableTransfers(bool _disable) public;
function issue(address _to, uint256 _amount) public;
function destroy(address _from, uint256 _amount) public;
}
contract DebitCoinToken is IDebitCoinToken, ERC20Token, Owned, TokenHolder {
string public version = '0.2';
bool public transfersEnabled = true;
uint publ... | 0 |
function claim(uint amount) stopInEmergency {
require (now > timeLock);
address investor = msg.sender;
if(amount == 0) {
throw;
}
if(getClaimLeft(investor) < amount) {
throw;
}
if(claimed[investor] == 0) {
claimCount++;
}
claimed[investor] = claimed[investor].add(amount);
totalClaimed = totalClaimed.add(am... | 0 |
function vestToAdvisors (address who, uint256 amount) public onlyOwner {
require(who != address(0));
_tokensForTeamAndAdvisors = _tokensForTeamAndAdvisors.sub(amount);
advisors[who] = advisors[who].add(amount);
emit VestedToAdvisors(who, amount);
} | 0 |
function decreaseApproval(address _spender, uint _subtractedValue) public returns (bool) {
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
emit Approval(msg.sender, _spe... | 0 |
function setEndsAt(uint time) onlyOwner {
if(now > time) {
throw;
}
endsAt = time;
EndsAtChanged(endsAt);
} | 0 |
function KRCPreSaleContract(uint256 _startTime, address _wallet, address _tokenAddress) public
{
require(_startTime >=now);
require(_wallet != 0x0);
startTime = _startTime;
endTime = startTime + totalDurationInDays;
require(endTime >= startTime);
owner = _wallet;
maxTokensToSale = 87500000e18;
bonusInPhase1 = ... | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns... | 0 |
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
} | 0 |
function verifyDeal(bytes32 _hashDeal, bytes _sign) private view {
require(_hashDeal.recover(_sign) == owner);
require(streamityTransfers[_hashDeal].status == STATUS_NO_DEAL);
} | 0 |
function approve(address _spender, uint _value) public returns (bool success) {
require (_value == 0 || allowed[msg.sender][_spender] == 0);
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function approveDeal(bytes32 _hashDeal)
external
onlyOwner
nonReentrant
returns(bool)
{
Deal storage deal = streamityTransfers[_hashDeal];
if (deal.status == STATUS_DEAL_WAIT_CONFIRMATION) {
deal.status = STATUS_DEAL_APPROVE;
emit ApproveDealEvent(_hashDeal, deal.seller, deal.buyer);
return true;
}
return f... | 0 |
function makeRandomResult(uint256 guessType, uint256 period, uint256 seed, uint256 maxNumber) onlyMaster
public returns (bool) {
require(guessType > 0);
require(period > 0);
require(seed >= 0);
require(maxNumber > 0);
require(results[guessType][period] <= 0);
require(maxNumber <= 1000000);
uint256 random = (uin... | 0 |
function transferOwnership(Data storage self, address newOwner) public {
require(msg.sender == self.owner);
self.newOwner = newOwner;
} | 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 transfer(address to, uint256 tokenID) public returns (bool);
function approve(address to, uint256 tokenID) public returns (bool);
function takeOwnership(uint256 tokenID) public;
function totalSupply() public view returns (uint);
function owns(address owner, uint256 tokenID) public view returns (bool);
fun... | 0 |
function moderator() external returns(address);
}
contract Managed {
IMultiSigManager roleManager;
address public roleManagerAddress;
address public operator;
uint public lastOperationTime;
uint public operationCoolDown;
uint constant BP_DENOMINATOR = 10000;
event UpdateRoleManager(address newManagerAddress);
e... | 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 b) in... | 0 |
function setTierRates(uint256 tier1, uint256 tier2, uint256 tier3, uint256 tier4)
external onlyOwner whenNotPaused beforeStarting
{
require(tier1 > 0 && tier2 > 0 && tier3 > 0 && tier4 > 0);
require(tier1 > tier2 && tier2 > tier3 && tier3 > tier4);
rate = tier1;
rateTier2 = tier2;
rateTier3 = tier3;
rateTier4 =... | 0 |
function Squares(IScoreOracle _oracle, address _developer) public {
oracle = _oracle;
developer = _developer;
} | 0 |
function setAttributes(bytes ipfsHash) {
ipfsAttributeLookup[msg.sender] = ipfsHash;
AttributesSet(msg.sender, now);
} | 1 |
function passedContract(address) external returns (bool);
function moderator() external returns(address);
}
contract Managed {
IMultiSigManager roleManager;
address public roleManagerAddress;
address public operator;
uint public lastOperationTime;
uint public operationCoolDown;
uint constant BP_DENOMINATOR = 100... | 0 |
function mint(address participant, uint256 amountTokens) private {
require(vestingSet);
uint256 precision = 10**18;
uint256 allocationRatio = safeMul(amountTokens, precision) / safeMul(570000000, precision);
uint256 developmentAllocation = safeMul(allocationRatio, safeMul(380000000, precision)) / precision;
uint25... | 0 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
... | 0 |
function addBalance(address participant, uint256 value) private {
balanceOf[participant] = balanceOf[participant].add(value);
totalFunding = totalFunding.add(value);
LogParticipation(participant, value, now);
} | 0 |
function TemplateCrowdsale(MintableToken _token) public
Crowdsale(START_TIME > now ? START_TIME : now, 1546297140, 1500 * TOKEN_DECIMAL_MULTIPLIER, 0x8F988d90C96282402b47b01D7EADE079eA6eBe36)
CappedCrowdsale(20000000000000000000000)
RefundableCrowdsale(1000000000000000000000)
{
token = _token;
} | 0 |
function setFlatFee(uint256 _flatFee) public onlyOwner {
require(_flatFee != 0);
require(_flatFee != flatFee);
flatFee = _flatFee;
LogFlatFeeChanged(msg.sender, _flatFee);
} | 0 |
function hasSaleBeginTimeCome() public view returns(bool) {
return (block.timestamp > saleBeginTime);
} | 0 |
modifier whenClosed() {
require(phase == Phases.AfterIco);
_;
} | 0 |
function getToken() public returns(address);
function mintETHRewards(address _contract, uint256 _amount) public onlyManager();
function mintTokenRewards(address _contract, uint256 _amount) public onlyManager();
function releaseTokens() public onlyManager() hasntStopped() whenCrowdsaleSuccessful();
function stop() p... | 0 |
function transfer(address _to, uint256 _value) public returns (bool)
{
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(now > _tradeableDate || _to == POOL || msg.sender == POOL);
if (_to == CONVERT_ADDRESS)
{
address burner = msg.sender;
balances[burner] = balances[burner].sub(_valu... | 1 |
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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256)... | 0 |
function safeApprove(address spender, uint256 value) public {
require(value != 0, "SafeTransfer: approve from non-zero to non-zero allowance");
require(!_isContract(spender),"SafeTransfer: spender is contract");
approve(spender, value);
} | 0 |
constructor () public payable {
dev = msg.sender;
highScore = 0;
currentWinner = msg.sender;
lastTimestamp = now;
randomContract = new Random();
} | 0 |
function DCAsset(address _backendContract) {
backendContract = _backendContract;
} | 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 withdrawRequest(ERC20 token, uint256 amount) external returns(uint256) {
uint256 index = withdrawals.length;
withdrawals.push(Withdrawal(msg.sender, address(token), amount, now, false));
Requested(token, msg.sender, amount, index);
return index;
} | 0 |
function setPrice(uint id, bool forSale, uint newPrice) validID(id) isOwnerOf(id) {
plots[id].price = newPrice;
plots[id].forSale = forSale;
PriceChanged(msg.sender, id, newPrice);
} | 0 |
function getBurnRequestsLength() external view returns (uint length) {
return burnRequests.length;
} | 0 |
function approve(address _spender, uint256 _value) public returns (bool success);
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, ... | 0 |
function authorized_recordStashedPayout(uint256 _cardId) external payable requireAuthorizedLogicContract {
cardIdToStashedPayout[_cardId] += msg.value;
totalStashedPayouts += msg.value;
} | 0 |
function purchase(uint256 _tokenId) public
payable
isNotContract(msg.sender)
{
require(!paused);
Token storage token = tokens[_tokenId];
uint256 price = token.price;
address oldOwner = token.owner;
require(price > 0);
require(msg.value >= price);
require(oldOwner != msg.sender);
uint256 priceDelta = price.su... | 1 |
function owned()
{
owner = msg.sender;
} | 0 |
function freezeAccount(address target, bool freeze) public onlyOwner {
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
} | 0 |
function remoteAllowance (address owner, address spender) external view returns (uint256) {
return _remoteToken.allowance(owner, spender);
} | 0 |
function stopCrowdsale() public onlyOwner
{
crowdsaleRunning = false;
} | 0 |
function getMyChicken() public view returns(uint256){
return hatcheryCHICKEN[msg.sender];
} | 0 |
modifier onlyBountyAgent() {
if(!bountyAgents[msg.sender]) {
throw;
}
_;
} | 0 |
function addHash(bytes32 rootHash) external onlyOwner {
require(_hashes[rootHash] == 0, "addHash: this hash was already deployed");
_hashes[rootHash] = block.timestamp;
emit HashAdded(rootHash);
} | 0 |
function transfer(address to, uint tokencount) public returns (bool success);
function approve(address spender, uint tokencount) public returns (bool success);
function transferFrom(address from, address to, uint tokencount) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint... | 0 |
function getMinimumAmount(address _addr) constant public returns (uint256) {
if(blocked_amounts[_addr] == 0x0)
return 0x0;
if(purchase_dates[_addr] > now){
return blocked_amounts[_addr];
}
uint256 alpha = uint256(now).sub(purchase_dates[_addr]);
uint256 beta = release_dates[_addr].sub(purchase_dates[_addr]);
ui... | 0 |
modifier onlyValid(address _address) {
require(_address != address(0));
_;
} | 0 |
function TUINETWORK()
{
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = totalSupply;
balances[msg.sender] -= TUI_ALLOCATION;
balances[TUI_ADDRESS] = TUI_ALLOCATION;
} | 0 |
function tokenFallback(address _from, uint256 _value, bytes _data);
}
contract KnowledgeTokenInterface is ERC223{
event Mint(address indexed to, uint256 amount);
function changeMinter(address newAddress) returns (bool);
function mint(address _to, uint256 _amount) returns (bool);
}
contract Ownable {
address public ... | 0 |
function burn (uint256 _burntAmount) public returns (bool success) {
require(balances[msg.sender] >= _burntAmount && _burntAmount > 0);
balances[msg.sender] = balances[msg.sender].sub(_burntAmount);
totalToken = totalToken.sub(_burntAmount);
tokenDestroyed = tokenDestroyed.add(_burntAmount);
require (tokenDestroye... | 1 |
function transferTokens(address _to, uint256 _amount) private returns(bool success) {
if (balances[address(this)] >= _amount &&
_amount > 0 &&
balances[_to] + _amount > balances[_to]) {
balances[address(this)] -= _amount;
balances[_to] += _amount;
Transfer(address(this), _to, _amount);
return true;
} else {
re... | 0 |
function issue_Vesting_RND(address _to, uint _time) onlyOwner_creator public
{
require(saleTime == false);
require(vestingReleaseRound_RND >= _time);
uint time = now;
require( ( ( endSaleTime + (_time * vestingReleaseTime_RND) ) < time ) && ( vestingRelease_RND[_time] > 0 ) );
uint tokens = vestingRelease_RND[_ti... | 0 |
function determineCurrentStage() internal {
if (stage < 4 && now >= ICO_START4) {
stage = 4;
emit IcoStageStarted(4);
} else if (stage < 3 && now >= ICO_START3) {
stage = 3;
emit IcoStageStarted(3);
} else if (stage < 2 && now >= ICO_START2) {
stage = 2;
emit IcoStageStarted(2);
} else if (stage < 1 && now >=... | 0 |
function stillAllowedReadable() view public returns (uint256) {
uint256 _1 = allowedSince() - withdrawn;
return _1 / 1000000000000000000;
} | 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 |
function setMintFeeReceiver(address _address) public onlyOwner returns (bool) {
mintFeeReceiver = _address;
return true;
} | 0 |
modifier whenNotPaused() {
if(msg.sender != distributionContract) {
require(!paused);
}
_;
} | 0 |
function claimLeftTokens() onlyOwner public {
require(hasEnded());
require(!finished);
uint256 balance = token.balanceOf(this);
token.transfer(owner, balance);
finished = true;
Finish();
} | 0 |
function rand() internal constant returns (uint32 res){
return uint32(block.number^now)%uint32(carnitas[lastCarnita].participants.length);
} | 0 |
function _transfer(address _from, address _to, uint _amount) internal {
require (_to != 0x0);
require (balances[_from] >= _amount);
balances[_from] = balances[_from].sub(_amount);
balances[_to] = balances[_to].add(_amount);
Transfer(_from, _to, _amount);
} | 0 |
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 returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokens);
e... | 0 |
modifier canTransfer(address _sender) {
if(!released) {
if(!transferAgents[_sender]) {
revert();
}
}
else {
if(now < lock_addresses[_sender]) {
revert();
}
}
_;
} | 1 |
function calculateTokens(uint value) internal view returns (uint256 tokens)
{
uint256 timeElapsed = now - startTime;
uint256 timeElapsedInDays = timeElapsed.div(1 days);
uint256 bonus = 0;
if (timeElapsedInDays <30)
{
tokens = value.mul(ratePerWeiInSelfDrop);
bonus = tokens.mul(bonusInSelfDrop);
bonus = bonus.... | 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 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 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 has(Role storage role, address addr)
view
internal
returns (bool)
{
return role.bearer[addr];
} | 0 |
modifier beforeStarting() {
require(now < startTime);
_;
} | 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 strConcat(string _a, string _b) internal pure returns (string) {
return strConcat(_a, _b, "", "", "");
} | 0 |
function reserveFor(address investor, uint256 weiAmount) managerOnly {
require(!investors[investor] && hasFreePlaces());
if(reservedInvestors[investor] == 0) {
knownReserved++;
}
reservedInvestors[investor] += reserveTokens(weiAmount);
ReserveKnown(true, investor, weiAmount, reservedInvestors[investor]);
} | 0 |
function cancel() returns (uint8 status) {
assert(trustAddress != address(0x0));
uint8 code = Trust(trustAddress).authCancel(msg.sender);
if (code == 0) Unauthorized(msg.sender);
else if (code == 1) NothingToCancel(msg.sender);
else if (code == 2) AuthCancel(msg.sender, msg.sender);
return code;
} | 0 |
function buy()
public
payable
{
address _customerAddress = msg.sender;
uint256 _eth = msg.value;
if(now>=jpTimer){
uint256 jpwinnings = ethJackpot/2;
ethJackpot = 0;
ethBank[leader] = ethBank[leader].add(jpwinnings);
jpRound += 1;
}
uint256 _tokens = _eth.mul(1e18)/buyingPrice();
uint256 fee = _eth/buyInFe... | 0 |
function resumeTokenTransferFromAddress(address investor) external onlyOwner {
locked[investor] = false;
} | 0 |
function transfer(address _to, uint256 _value) public whenMintingFinished returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function transfer(address _to, uint256 _amount) public returns(bool success) {
if (_to == 0x0) revert();
if (balances[msg.sender] < _amount) revert();
if (safeAdd(balances[_to], _amount) < balances[_to]) revert();
balances[msg.sender] = safeSub(balances[msg.sender], _amount);
balances[_to] = safeAdd(balances[_to],... | 0 |
function play()
public
payable
validBet
onlyPlayer
{
require(tickets[msg.sender].block_number == 0);
require(ticketIndex.length < 200);
tickets[msg.sender].is_winner = false;
tickets[msg.sender].is_active = true;
tickets[msg.sender].block_number = block.number;
tickets[msg.sender].block_time = block.timestam... | 1 |
function transferFrom(address from, address to, uint256 value) public whenNotPaused returns (bool) {
require(value > 0, "transferFrom: value is must be greater than zero.");
require(balanceOf(from) >= value, "transferFrom: balance of from address is not enough");
require(_allowances[from][msg.sender] >= value, "tran... | 0 |
constructor(uint end, address initialPledge) public {
endDate = end;
pledgeLoyalty(initialPledge);
} | 0 |
function UpgradeableToken(address master) internal {
setUpgradeMaster(master);
} | 0 |
function award(bytes32 secretKey_D) public {
require(Drawer == msg.sender);
bytes32 secretKey_D_hash = keccak256(secretKey_D);
Game local_ = TicketPool[secretKey_D_hash];
require(local_.Time != 0 && !local_.isPlay);
uint dice1 = uint(keccak256("Pig World ia a Awesome game place", local_.SecretKey_P, secretKey_D)) ... | 0 |
function withdrawTeam(address _to) public onlyManager() {
require(now > nextWithdrawDayTeam);
require(withdrawedTeamCounter < 48);
balances[_to] = balances[_to].add(teamReservation / 48);
withdrawedTeamCounter += 1;
nextWithdrawDayTeam += 30 days;
totalSupply = totalSupply.add(teamReservation / 48);
emit Transfe... | 0 |
function getTimeLeft()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt + rndGap_)
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].strt + rndGap_).sub(_now) );
else
return(0);
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.