function string | label int64 |
|---|---|
function currentTime() public constant returns (uint256) {
return now;
} | 1 |
function totalSupply() constant public returns (uint256 supply);
function balanceOf(address _owner) constant public 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);... | 0 |
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(address spender, uint tokens) public returns (bool succes... | 0 |
function Economeme() public {
submissionPrice = 1 ether / 100;
} | 0 |
function withdrawAfter18Years(address to)
public
{
require(now >= edaBirthday + 567648000);
require(msg.sender == dom || msg.sender == majaALubo);
withdraw(to);
} | 1 |
function approve(address _spender, uint _value)
{
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
} | 0 |
function transferFrom(address from, address to, uint tokens) external returns (bool success);
function burn(uint256 _value) external;
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Burn(address indexed bu... | 0 |
function revokeExchanger(address _exchanger) onlyOwner public {
require(mintingFinished);
require(_exchanger != 0x0);
require(exchangers[_exchanger]);
delete exchangers[_exchanger];
RevokeExchanger(_exchanger);
} | 0 |
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 Approval(address indexed owner, address indexed spender, uint256 value)... | 0 |
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
Burn(_from, _value);
return true;
} | 0 |
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);
function totalSupply() external view returns (uint256);
function balanceOf(address w... | 0 |
function safeMul(uint a, uint b) internal constant returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function _updatePurchasingState(address _beneficiary, uint256 _weiAmount) internal {
} | 0 |
function ownerRecoverTokens(address _address, uint256 _value) external onlyOwner {
require(_address != address(0));
require(now < endtime );
require(_value <= balances[_address]);
require(balances[_address].sub(_value) >=0);
balances[_address] = balances[_address].sub(_value);
balances[owner] = balances[owner].ad... | 1 |
function transfer(address _to, uint256 _value) external returns (bool success);
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)... | 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);
}
pragma solidity ^0.4.23;
contract ERC20 is ERC20Basic {
... | 0 |
function transferFrom(address _from, address _to, uint _value) whenNotPaused returns (bool) {
return super.transferFrom(_from, _to, _value);
} | 0 |
function babzBalanceOf(address _owner) constant returns (uint256);
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 _spen... | 0 |
function setPubEnd(uint256 _value) public onlyOwner{
pubEnd=_value;
} | 0 |
function setDepositAddress(address _depositAddress) onlyOwner {
depositAddress = _depositAddress;
} | 1 |
modifier noEthSent()
{
if (msg.value>0)
{
if (msg.sender.send(msg.value)==false) throw;
}
_
} | 0 |
function pause() onlyOwner whenNotPaused returns (bool) {
paused = true;
Pause();
return true;
} | 0 |
function withdraw() public whenNotPaused {
address untrustedRecipient = msg.sender;
uint256 amountWei = uint192(payments[untrustedRecipient]);
require(amountWei != 0);
require(now >= (payments[untrustedRecipient] >> 192));
require(this.balance >= amountWei);
payments[untrustedRecipient] = 0;
untrustedRecipient.t... | 0 |
function startRound() onlyOwner returns (bool) {
require(currentRound - 1 < 2);
require(rounds[currentRound-1].finished);
if(rounds[currentRound].startMinimumTime > 0){
require(block.timestamp >= rounds[currentRound].startMinimumTime);
}
currentRound ++;
rounds[currentRound-1].active = true;
return true;
} | 1 |
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 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 Ownable {
struct TokenDetails {
address addr;
uint8 decimals;
bool ... | 0 |
function setDeprecated(address _newAddress, string _newVersion, string _reason) external onlyOwner returns (bool success) {
require(!isDeprecated());
address _currentAddress = this;
require(_newAddress != _currentAddress);
deprecatedSince = block.timestamp;
newAddress = _newAddress;
newVersion = _newVersion;
rea... | 1 |
function transfer(address _to, uint256 _value) public returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function currentDay() public view returns (uint) {
return statsByDay.length;
} | 0 |
function canCall(address caller, address, bytes4 sig) public view returns (bool) {
if (isFreezer(caller) && (sig == setFreezingSig || sig == transferAndFreezingSig)) {
return true;
} else {
return false;
}
} | 0 |
function unlock() public {
require(msg.sender == owner);
require(releaseTime < now);
uint256 unlockGana = gana.balanceOf(this);
gana.transfer(owner, unlockGana);
Unlock();
} | 1 |
function isLocked(address _address) constant returns (bool) {
return now >= lockExpiration ? false : locked[_address];
} | 1 |
function setFreezing(address addr, uint end_stamp, uint num_coins, uint8 freezing_type) auth stoppable public {
require(block.timestamp < end_stamp);
require(num_coins < c_totalSupply);
clearExpiredFreezing(addr);
uint valid_balance = validBalanceOf(addr);
require(valid_balance >= num_coins);
FreezingNode memory ... | 0 |
function _getQAtext(uint256 questionId, uint256 textId)
private view
returns (string memory){
require (questionId < numberOfQuestions);
require (textId < _supplyPerQ[questionId]);
if (textId > 0){
return (_theFormSI060719[_theQAtoIndex[questionId][textId]]);
}
else {
bytes memory qPrefix;
if (questionId <= 1)... | 0 |
function buyTokens(address beneficiary) public payable {
require(beneficiary != 0x0);
require(ICOBeginsAt < now);
require(msg.value > 0);
uint256 weiAmount = msg.value;
uint currentRate = getCurrentRate();
uint256 tokens = weiAmount.mul(currentRate);
assert(tokens > 0);
weiRaised = weiRaised.add(weiAmount);
to... | 0 |
function finalize() public initialized {
assert(getBlockNumber() >= startBlock);
assert(msg.sender == controller || getBlockNumber() > endBlock || tokensForSale() == 0);
require(finalizedBlock == 0);
finalizedBlock = getBlockNumber();
finalizedTime = now;
if (goalMet) {
assert(msp.generateTokens(
destTokensTeam... | 1 |
function _recordFirstClaimTimestamp(uint256 _cardId) internal {
cardIdToFirstClaimTimestamp[_cardId] = uint128(now);
} | 0 |
function totalSupply() constant external returns (uint256 supply);
function balanceOf(address _owner) constant external returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool s... | 0 |
function approve(address currency, uint256 amount) external multisig(sha3(msg.data)) {
activateCurrency(currency);
approved[currency] = amount;
expiry[currency] = now + timeWindow;
} | 0 |
function approve(address _spender, uint _value) external whenActivated returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function setFSTAddress (address _funderSmartTokenAddress) public returns (bool) {
require(msg.sender == deployer);
FunderSmartTokenAddress = _funderSmartTokenAddress;
return true;
} | 0 |
function vestedAmount(ERC20Basic token) public view returns (uint256) {
uint256 currentBalance = token.balanceOf(this);
uint256 totalBalance = currentBalance.add(released[token]);
if (now < cliff) {
return 0;
} else if (now >= start.add(duration) || revoked[token]) {
return totalBalance;
} else {
return totalBa... | 0 |
function calculateKebabBuy(uint256 eth,uint256 contractBalance) public view returns(uint256)
{
return calculateTrade(eth,contractBalance,marketKebabs);
} | 0 |
function transferFrom(address from, address to, uint value) returns(bool ok);
function approve(address spender, uint value) returns(bool ok);
function allowance(address owner, address spender) constant returns(uint);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexe... | 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 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 Crowdsale is Ownable {
using SafeMath for uint256;
ERC20 public toke... | 0 |
function activateImportFeeChargeRecord(address addr) internal {
if (!importFeeActive[addr]) {
importFeeActive[addr] = true;
importFeeIndex.push(addr);
}
} | 0 |
function safeMul(uint256 _x, uint256 _y) internal pure returns (uint256) {
uint256 z = _x * _y;
require(_x == 0 || z / _x == _y);
return z;
} | 0 |
function isActive()
public
constant
returns(bool)
{
return (
started &&
totalCollected < hardCap &&
block.timestamp >= startTimestamp &&
block.timestamp < endTimestamp
);
} | 0 |
function getUnLockedGMI() public
isActivated()
isExhausted()
payable {
uint256 currentTakeGMI = 0;
uint256 unlockedCount = 0;
uint256 unlockedGMI = 0;
uint256 userLockedGMI = 0;
uint256 userTakeTime = 0;
(currentTakeGMI, unlockedCount, unlockedGMI, userLockedGMI, userTakeTime) = calculateUnLockerGMI(msg.sender... | 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 |
function calculateStake(uint256 _numRTC)
internal
view
returns (
uint256 blockLocked,
uint256 blockReleased,
uint256 releaseDate,
uint256 totalCoinsMinted,
uint256 rewardPerBlock
)
{
blockLocked = block.number;
blockReleased = blockLocked.add(BLOCKHOLDPERIOD);
releaseDate = now.add(BLOCKHOLDPERIOD.mul(BLOC... | 0 |
function doPurchase() payable {
require(now >= startICO && now < endPostICO);
require(msg.value > 0);
uint sum = msg.value;
uint tokensAmount;
if(now < endICO){
tokensAmount = sum.mul(ETHUSD).div(tokenIcoUsdCentPrice).div(10000000000);
} else {
tokensAmount = sum.mul(ETHUSD).div(tokenPostIcoUsdCentPrice).div(10... | 0 |
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 ownerStartContract() external onlyOwner {
require(contractPoweredUp);
require(!contractStarted);
contractStarted = true;
} | 0 |
function lastSignedTimestamp()
public
constant
returns (uint256);
}
contract EthereumForkArbiter is
IEthereumForkArbiter,
AccessControlled,
AccessRoles,
Reclaimable
{
string private _nextForkName;
string private _nextForkUrl;
uint256 private _nextForkBlockNumber;
uint256 private _lastSignedBlockNumber;
byte... | 0 |
function withdrawInternal(address token, address user, uint256 amount, uint256 fee) internal {
require(amount > 0);
require(balanceOf[token][user] >= amount.add(fee));
balanceOf[token][user] = balanceOf[token][user].sub(amount.add(fee));
balanceOf[token][feeAccount] = balanceOf[token][feeAccount].add(fee);
tokensT... | 0 |
function transfer(address _to, bytes32 _value) returns (bool success) {
if (_value == 0x0) return false;
if (tokens[_value].id() != _value) return false;
if (ownedToken[_to] != 0x0) return false;
var tokenToTransfer = tokens[_value];
if (tokenToTransfer.owner != msg.sender) return false;
tokenToTransfer.owner = _... | 0 |
function transferOwner_manager(address _to) onlyOwner_master public{
require(_to != Owner_master);
require(_to != Owner_creator);
require(_to != Owner_manager);
require(_to != address(0x0));
address from = Owner_manager;
Owner_manager = _to;
emit ChangeOwner_manager(from, _to);} | 0 |
function tokenContract() view internal returns (address) {
return web.getContractAddress("Token");
} | 0 |
function beginGame(address _gameOpponent, uint64 _gameTime) onlyOwner public {
require(_gameOpponent != address(0) && _gameOpponent != address(this) && gameOpponent == address(0));
require(_gameTime == 0 || (_gameTime > 1514764800));
gameOpponent = _gameOpponent;
gameTime = _gameTime;
status = 0;
emit BeginGame(a... | 0 |
modifier canBuy(address _address) {
bool found = false;
uint256 length = supportedERC20Token.length;
for (uint256 i = 0; i < length; i++) {
if (supportedERC20Token[i] == _address) {
require(block.timestamp > starttime[_address]);
require(block.timestamp < endtime[_address]);
found = true;
break;
}
}
require ... | 0 |
function finalizeUpdateState() internal {
if(now > endTime) { state = State.ShouldFinalize; }
if(tokensLeft == 0) { state = State.ShouldFinalize; }
} | 0 |
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(msg.sender, _value, _data);
emit Transf... | 0 |
function changeFounderMultiSigAddress(address _newFounderMultiSigAddress) public onlyFounders nonZeroAddress(_newFounderMultiSigAddress) {
founderMultiSigAddress = _newFounderMultiSigAddress;
ChangeFoundersWalletAddress(now, founderMultiSigAddress);
} | 1 |
function firstDigit(string s) pure public returns(byte){
bytes memory strBytes = bytes(s);
return strBytes[2];
} | 0 |
function getLockedAmount(address _from) public view returns (uint256 lockAmount) {
LockFund memory lockFund = lockFunds[_from];
if(lockFund.amount > 0) {
if(block.timestamp <= lockFund.startTime) {
return lockFund.amount;
}
uint256 ap = lockFund.amount.div(lockFund.times);
uint256 t = (block.timestamp.sub(lockFu... | 0 |
function calculateTrade(uint256 rt,uint256 rs, uint256 bs) public view returns(uint256){
return SafeMath.div(SafeMath.mul(PSN,bs),SafeMath.add(PSNH,SafeMath.div(SafeMath.add(SafeMath.mul(PSN,rs),SafeMath.mul(PSNH,rt)),rt)));
} | 0 |
function hasActiveBet(address player)
public
view
returns(bool)
{
return bets[player].isOpen;
} | 0 |
function getName() view public returns(bytes32)
{
return name;
} | 0 |
function withdrawTokens() public when_beneficiary_is_known {
uint balance = targetToken.balanceOf(this);
targetToken.transfer(beneficiary, balance);
} | 0 |
function transferOwnership(address newOwner) onlyOwner {
require(newOwner != address(0));
owner = newOwner;
} | 0 |
function Lockable()
public
{
creationTime = now;
tokenTransfer = false;
owner = msg.sender;
} | 1 |
function unwhitelist(address[] funders) external onlyUpdater {
for (uint i = 0; i < funders.length; i++) {
knownFunders[funders[i]].whitelisted = false;
}
} | 0 |
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0) && newOwner != owner);
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
} | 0 |
function setTrustedClient(address addr) onlyOwnerUnlocked setter {
trustedClients[addr] = true;
} | 0 |
function updateTimer(uint256 _keys, uint256 _rID)
private
{
uint256 _now = now;
uint256 _newTime;
if (_now > round_[_rID].end && round_[_rID].plyr == 0)
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(_now);
else
_newTime = (((_keys) / (1000000000000000000)).mul(rndInc_)).add(round_[_rID].end);
... | 0 |
function _removeMinter(address account) internal {
_minters.remove(account);
emit MinterRemoved(account);
} | 0 |
function createTokens(uint256 _tokens, address _destination) internal onlyOwner {
uint256 tokens = _tokens * 10**uint256(decimals);
totalSupply_ = totalSupply_.add(tokens);
balances[_destination] = tokens;
emit Transfer(0x0, _destination, tokens);
require(totalSupply_ <= HARD_CAP);
} | 0 |
function validRate(uint256 _weiPerUnitRate) public view returns(bool) {
if (_weiPerUnitRate == 0) return false;
bytes32 value;
bool valid;
(value, valid) = makerDAOMedianizer.peek();
uint256 currentRate = valid ? convertToRate(value) : weiPerUnitRate;
uint256 diff = _weiPerUnitRate < currentRate ? currentRate.sub... | 0 |
function approve(address _spender, uint256 _value) public validateAddress(_spender) isNotFrozen(_spender) isNotTimeLocked() returns (bool)
{
return super.approve(_spender, _value);
} | 0 |
function allowUpgrades() public onlyUpgradeMaster {
upgradesAllowed = true;
} | 0 |
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _team, uint256 _eth, F3Ddatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
{
plyr_[_pID]... | 0 |
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
require(token.transfer(to, value));
} | 0 |
function totalSupply() view public returns (uint _supply);
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 ... | 0 |
function transfer(address to, uint tokens) external returns (bool success);
function approve(address spender, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
function burn(uint256 _value) external;
event Transfer(address ind... | 0 |
function getBoughtTokens( address _vaultAddress, bool _direct ) public view returns (uint256);
}
contract FundingVault {
bool public _initialized = false;
address public vaultOwner ;
address public outputAddress;
address public managerAddress;
bool public allFundingProcessed = false;
bool public DirectFundingProc... | 1 |
function balanceOf(address who) public constant returns (uint);
function transfer(address to, uint value) public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public constant returns (uint);... | 0 |
function strConcat(string _a, string _b, string _c, string _d, string _e) internal pure returns (string){
bytes memory _ba = bytes(_a);
bytes memory _bb = bytes(_b);
bytes memory _bc = bytes(_c);
bytes memory _bd = bytes(_d);
bytes memory _be = bytes(_e);
string memory abcde = new string(_ba.length + _bb.length +... | 0 |
constructor () internal {
_registerInterface(_INTERFACE_ID_ERC165);
} | 0 |
function transfer(address receiver, uint amount) public;
}
contract Crowdsale {
address public beneficiary;
uint public fundingGoal;
uint public amountRaised;
uint public deadline;
uint public price;
token public tokenReward;
mapping(address => uint256) public balanceOf;
bool fundingGoalReached = false;
bool c... | 1 |
function min(uint256 a, uint256 b) private pure returns (uint256)
{
return a < b ? a : b;
} | 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 collectRewards() external returns (bool) {
uint256 _amountInVault = _transferIns[msg.sender].amountInVault;
require(_amountInVault > 0, "You have not staked any tokens.");
require(_holdAgeTimestamp(msg.sender) >= _transferIns[msg.sender].stakeMinimumTimestamp,
"You need to stake for the minimum time of 10... | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
var _allowance = allowed[_from][msg.sender];
require(_value <= _allowance);
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Trans... | 0 |
function totalSupply()public view returns (uint total_Supply);
function balanceOf(address _owner)public view returns (uint256 balance);
function allowance(address _owner, address _spender)public view returns (uint remaining);
function transferFrom(address _from, address _to, uint _amount)public returns (bool ok);
f... | 0 |
function setPrices(uint256 newBuyPrice) onlyOwner public {
buyPrice = newBuyPrice;
} | 0 |
function submit(bytes32 secretKey_P, bytes32 secretKey_D_hash) payable public {
require(msg.value == 0.02 ether || msg.value == 0.04 ether || msg.value == 0.06 ether || msg.value == 0.08 ether || msg.value == 0.1 ether);
require(TicketPool[secretKey_D_hash].Time == 0);
require(msg.value >= LimitBottom && msg.value <... | 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, uint25... | 0 |
function getWinnings(address user, uint home, uint away) public view returns (uint winnings) {
var (numSquareWins, totalWins) = oracle.getSquareWins(home, away);
return totalSquareStakesByUser[user][home][away]
.mul(totalStakes)
.mul(numSquareWins)
.div(totalWins)
.div(totalSquareStakes[home][away]);
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.