function string | label int64 |
|---|---|
function refundTokens(address _buyer, uint256 tokens) external onlyCrowdsale whenNotPaused {
require(_buyer != address(0));
require(tokens > 0);
require(balances[_buyer] >= tokens);
balances[_buyer] = balances[_buyer].sub(tokens);
RefundedTokens(_buyer, tokens);
} | 0 |
function transferWithReference(address _to, uint _value, string _reference) returns(bool);
function totalSupply() constant returns(uint);
function approve(address _spender, uint _value) returns(bool);
}
contract VestingInterface {
function createVesting(address _receiver, AssetProxyInterface _AssetProxy, uint _amoun... | 0 |
function claimOwnerSupply() onlyOwner {
if (now < ownerTokensFreeDay) throw;
if (remainingOwner == 0) throw;
if (!remaindersSet) throw;
balanceOf[owner] = safeAdd(balanceOf[owner], remainingOwner);
remainingOwner = 0;
} | 1 |
function sub(uint a, uint b) internal pure returns (uint c) {
require(b <= a);
c = a - b;
} | 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 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 mint0(address _owner, uint256 _amount) onlyOwner {
accounts[_owner].balance = _amount.add(accounts[_owner].balance).toUINT112();
accounts[_owner].lastMintedTimestamp = uint32(block.timestamp);
Transfer(0, _owner, _amount);
} | 1 |
function setPaycarnita(uint256 _newPaycarnita) onlyManager public{
toPaycarnita=_newPaycarnita;
} | 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 getNumberOfAnswers(uint256 questionId)
public view
returns (uint256){
require (questionId < numberOfQuestions);
return (_supplyPerQ[questionId] - 1);
} | 0 |
function DividendManager(address token_address, address auth_address) public {
token = SingleTokenCoin(token_address);
set_new_admin(auth_address);
dividends_share = 50;
reinvestment_share = 50;
} | 1 |
function _updatePurchasingState(address _beneficiary, uint256 _weiAmount) internal {
} | 0 |
function approve(address _spender, uint256 _value) public onlyPayloadSize(2*32) returns (bool success) {
require(_value == 0 || allowanceUsed[msg.sender][_spender] == false);
allowed[msg.sender][_spender] = _value;
allowanceUsed[msg.sender][_spender] = false;
Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function transfer(address _to, uint _value)
public
canTransfer(msg.sender, _value)
returns (bool success)
{
return super.transfer(_to, _value);
} | 0 |
function getToken()
public
returns(address)
{
return address(crowdsaleToken);
} | 0 |
function relaxFundingCap(uint _newCap, uint _weiRaised) public constant returns (uint);
}
contract FixedCeiling is CeilingStrategy {
using SafeMath for uint;
uint public chunkedWeiMultiple;
uint public weiLimitPerAddress;
function FixedCeiling(uint multiple, uint limit) {
chunkedWeiMultiple = multiple;
weiLimitPe... | 0 |
function getBlockTimestamp() internal constant returns (uint256) {
return block.timestamp;
} | 1 |
function transferFrom(address _from, address _to, uint _value) returns(bool);
function transferFromToICAP(address _from, bytes32 _icap, uint _value) returns(bool);
function transferFromWithReference(address _from, address _to, uint _value, string _reference) returns(bool);
function transfer(address _to, uint _value)... | 0 |
function getDungeonDetails(uint _id) external view returns (
uint creationTime,
uint status,
uint difficulty,
uint capacity,
address owner,
bool isReady,
uint playerCount
);
function getDungeonFloorDetails(uint _id) external view returns (
uint floorNumber,
uint floorCreationTime,
uint rewards,
uint seedGe... | 0 |
function transferFrom(address from, address to, uint256 value) public returns (bool success);
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 indexe... | 0 |
function rand(address _who) private view returns(bytes32){
return keccak256(_who,now);
} | 1 |
function sale(uint256 _id, uint256 _price) public returns (bool) {
require(started);
require(_id > 0 && _id <= cap);
require(!lottery.gameOver());
require(!lottery.gameOverByUser());
require(now > stopTime);
require(lottery.getHolder(_id) == msg.sender);
priceList[_id] = _price;
holderList[_id] = msg.sender;
a... | 0 |
function isValidService(bytes32 _serviceName) public pure returns(bool isValid) {
return _serviceName != 0;
} | 0 |
function validatePendingRequest(Request memory request, bytes32 requestHash) internal pure {
require(request.status == RequestStatus.PENDING, "request is not pending");
require(requestHash == calcRequestHash(request), "given request hash does not match a pending request");
} | 0 |
function Vesting() payable {
creator = msg.sender;
} | 0 |
function burn(address account, uint256 value) public;
function _burn(address account, uint256 value) internal{
emit Burn(account, value);
} | 0 |
function addTeamMember(address wallet, uint256 tokenAmount) public onlyOwner returns (bool)
{
require(!_members[wallet].active, "Member already added");
uint256 firstTransfer;
uint256 eachMonthTransfer;
_alocatedWibxVestingTokens = _alocatedWibxVestingTokens.add(tokenAmount);
(firstTransfer, eachMonthTransfer) = ... | 0 |
constructor() public {
manager = msg.sender;
} | 0 |
function transfer(address _to, uint256 _amount)public returns (bool success) {
require( _to != 0x0);
require(balances[msg.sender] >= _amount && _amount >= 0);
balances[msg.sender] = (balances[msg.sender]).sub(_amount);
balances[_to] = (balances[_to]).add(_amount);
emit Transfer(msg.sender, _to, _amount);
return t... | 0 |
function decimals() public view returns (uint);
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);
}
contract... | 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 pow(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a ** b;
assert(c >= a);
return c;
} | 0 |
function exchange(address receiver) public payable {
uint256 amount = msg.value;
uint256 price = getRate();
uint256 numTokens = amount.mul(price);
bool isPreICO = (now <= preICO.date);
bool isICO = (now >= icoStarts.date && now <= icoEnds.date);
require(isPreICO || isICO);
require(numTokens > 500);
if (isPreICO... | 0 |
function checkBalance(address _owner) external view returns (uint256) {
return creatorBalances[_owner];
} | 0 |
function getCurrentDatetime() private constant returns (uint) {
return now;
} | 1 |
function buyTokens(address beneficiary) public whenNotPaused payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
if (weiAmount >= minWeiWhitelistInvestment) {
require(investorWhitelist[beneficiary]);
}
weiRaised = weiRaised.add(weiAmount);
investments[beneficia... | 0 |
function create() payable whenNotClosed whenNotPaused public returns (bool success) {
require(msg.value > 0);
require(now >= preIcoOpeningTime);
uint256 weiToParticipate = msg.value;
adjustPhaseBasedOnTime();
if (phase != Phases.AfterIco || weiToParticipate < (0.01 * 10**18)) {
Rates memory rates = getRates();
u... | 0 |
function transfer(address _to, uint256 _value) public validateAddress(_to) isNotTimeLocked(_to) isNotFrozen(_to) returns (bool)
{
return super.transfer(_to, _value);
} | 0 |
function setCrowdsaleAddress(address _crowdsale) external onlyOwner whenNotPaused {
require(crowdsale == address(0));
require(_crowdsale != address(0));
crowdsale = _crowdsale;
} | 0 |
function hodl(uint256 _id, uint256 _value, uint256 _months) external {
require(_id > 0);
require(_value > 0);
require(_months == 3 || _months == 6 || _months == 12);
address _user = msg.sender;
Item storage item = items[_user][_id];
require(item.id != _id);
uint256 _seconds = _months.mul(2628000);
uint256 _rele... | 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 addGame(address key, string description, string url) {
if (msg.value < REGISTRATION_COST) {
if (msg.value > 0) {
msg.sender.send(msg.value);
}
return;
}
distributeValue();
if (records[key].time == 0) {
records[key].time = now;
records[key].owner = msg.sender;
records[key].keysIndex = keys.length;
k... | 1 |
function totalSupply() public constant returns (uint) {
return data.totalSupply - data.balances[address(0)];
} | 0 |
function sha(uint128 wager) constant private returns(uint256)
{
return uint256(sha3(block.difficulty, block.coinbase, now, lastblockhashused, wager));
} | 1 |
modifier onlyApprovedExchangeBoth(address trader1, address trader2) {
require (msg.sender == ProxyAddress, "onlyApprovedExchange() called not by exchange proxy.");
require (getRegistry().contractApprovedBoth(trader1, trader2), "onlyApprovedExchangeBoth() requires approval of the latest contract code by both traders."... | 0 |
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a, "SafeMath::add: Integer overflow");
return c;
} | 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 calculateEggBuySimple(uint256 eth) public view returns(uint256){
return calculateEggBuy(eth, address(this).balance);
} | 0 |
function changeSubmissionPrice(uint256 _newPrice) external onlyAdmin() {
submissionPrice = _newPrice;
} | 0 |
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
} | 0 |
function approve(address _spender, uint256 _currentValue, uint256 _value) public onlyPayloadSize(3*32) returns (bool success) {
require(allowed[msg.sender][_spender] == _currentValue);
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function _transferFrom(address from, address to, uint256 tokenId) internal {
require(ownerOf(tokenId) == from);
require(to != address(0));
_clearApproval(tokenId);
_ownedTokensCount[from] = _ownedTokensCount[from].sub(1);
_ownedTokensCount[to] = _ownedTokensCount[to].add(1);
_tokenOwner[tokenId] = to;
emit Trans... | 0 |
function getCheckResultMessage(Data storage , BTTSTokenInterface.CheckResult result) public pure returns (string) {
if (result == BTTSTokenInterface.CheckResult.Success) {
return "Success";
} else if (result == BTTSTokenInterface.CheckResult.NotTransferable) {
return "Tokens not transferable yet";
} else if (resul... | 0 |
function getLockedAmount_dakehus(address _dakehu)
public
constant
returns (uint256)
{
uint256 dakehuDate = dakehus_dakehuDate[_dakehu];
uint256 lockedAmt = dakehus_locked[_dakehu];
if (now <= dakehuDate + (30 * 1 days)) {return lockedAmt;}
if (now <= dakehuDate + (30 * 2 days)) {return lockedAmt.mul(23).div(24)... | 0 |
function getCurrentBonus() public constant returns (uint){
if(totalSupply < 7000000 * (10 ** decimals))
return 180;
if(totalSupply < 14000000 * (10 ** decimals))
return 155;
return 140;
} | 0 |
function getMessage () constant returns (string retVal) {
return message;
} | 1 |
function transferFrom(address _from, address _to, uint256 _value) public canTransfer(_from) returns (bool success) {
return super.transferFrom(_from, _to, _value);
} | 0 |
function atNow() public constant returns (uint) {
return now;
} | 1 |
function safeSub(uint a, uint b) pure internal returns(uint) {
assert(b <= a);
return a - b;
} | 0 |
function mintLockedToken(address addr, uint256 tokens, uint256 _duration) public {
require(msg.sender == owner, "Lockable: only owner can lock token ");
require(_totalSupply.add(totalLocked()).add(tokens) <= cap(), "Lockable: locked tokens can not exceed total cap.");
require(_lock_list[addr] == false, "Lockable: th... | 0 |
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
} | 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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(addre... | 0 |
function decimals() public constant returns (uint8);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contract ERC223 is ERC20Interface {
function transfer(address to, uint value, bytes data) public returns (boo... | 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 newGame(uint _bet_amount, uint _durationh, uint _gwei) public payable{
if((stage == 3)&&(msg.sender == owner)){
for(uint i = 1; i<numTickets; i++){
tickets[i] = 0;
}
oraclize_setCustomGasPrice(_gwei * 1000000000 wei);
winningNumber = 0;
bet_amount = _bet_amount * 1 finney;
durationh = _durationh * 1 ho... | 1 |
function safeTransfer(address to, uint256 value) public {
require(!_isContract(to),"SafeTransfer: receiver is contract");
transfer(to,value);
} | 0 |
modifier not_upgraded() {
require(ptr == address(0), "upgrade pointer is non-zero");
_;
} | 0 |
function releaseTokensForce(bytes32 _hashDeal)
external onlyOwner
nonReentrant
returns(bool)
{
Deal storage deal = streamityTransfers[_hashDeal];
uint8 prevStatus = deal.status;
if (deal.status != STATUS_NO_DEAL) {
deal.status = STATUS_DEAL_RELEASE;
bool result = false;
if (deal.isAltCoin == false)
result = ... | 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 isWhitelisted(address funder) external view returns (bool) {
return knownFunders[funder].whitelisted;
} | 0 |
function release() public {
require(block.timestamp >= releaseTime);
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.safeTransfer(beneficiary, amount);
} | 0 |
function getCount(address _sender) public view returns (uint256) {
if (counter[validater][_sender] == 0) {
return 1;
}
return counter[validater][_sender];
} | 0 |
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
} | 0 |
function getLockTimestamp(string poolId)
public
view
returns (uint256)
{
return pools[poolId].lockTimestamp;
} | 0 |
function transfer(address _to, uint256 _value) returns (bool success) {
if (now < baseStartTime) revert();
if (balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else {
return fals... | 1 |
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 transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract StandardToken is... | 0 |
function LiteBoxToken(address _owner, string _name, string _symbol, uint _totalSupply, uint _decimals) UpgradeableToken(_owner) {
name = _name;
symbol = _symbol;
totalSupply = _totalSupply;
decimals = _decimals;
balances[_owner] = _totalSupply;
} | 0 |
function mint(address _to, uint256 _amount) public returns (bool) {
require(totalSupply_.add(_amount) <= cap);
return super.mint(_to, _amount);
} | 0 |
function fetch(address player)
private
{
Bet storage bet = bets[player];
require(bet.blocknumber < block.number);
bet.isOpen = false;
if(block.number - 256 > bet.blocknumber) {
emit Expiration(player, bet.amount);
return;
}
uint256 roll = (uint256(blockhash(bet.blocknumber)) % 100) + 1;
if(roll <= bet.chance... | 0 |
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
} | 0 |
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _v... | 0 |
function party() {
if (block.timestamp < partyTime) throw;
uint value = holders[msg.sender];
if (value == 0) throw;
holders[msg.sender] = 0;
msg.sender.transfer(value);
Party(msg.sender, value);
} | 1 |
function underLimit(uint _value) internal onlyowner returns (bool) {
return false;
} | 1 |
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 FlatPricing(uint _oneTokenInWei) {
oneTokenInWei = _oneTokenInWei;
} | 0 |
function transferAdminship(address _newAdmin) onlyAdmin public {
require(_newAdmin != address(0));
admin = _newAdmin;
TransferAdminship(admin);
} | 1 |
function balanceOf(address _owner) public view returns (uint256 balance) {
return super.balanceOf(_owner) + freezingBalance[_owner];
} | 0 |
function approve(address spender, uint tokens)
{
if (isAllocationLocked(spender))
{
throw;
}
else
{
super.approve(spender, tokens);
}
} | 0 |
function getLostAndFoundMaster() internal view returns (address);
function enableLostAndFound(address agent, uint tokens, EIP20Token token_contract) public {
require(msg.sender == getLostAndFoundMaster());
token_contract.approve(agent, tokens);
} | 0 |
modifier notThis(address _address) {
require(_address != address(this));
_;
} | 0 |
function calculateTokensTier(uint256 weiPaid, uint256 tierSelected)
internal constant returns(uint256 calculatedTokens)
{
require(weiPaid > 0);
require(tierSelected >= 1 && tierSelected <= 4);
if(tierSelected == 1)
calculatedTokens = weiPaid.mul(rate);
else if(tierSelected == 2)
calculatedTokens = weiPaid.mul(r... | 0 |
function Paygine() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
PaygineHasDeployed(now);
} | 1 |
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 setTransferAgent(address addr, bool state) public onlyOwner inReleaseState(false) {
TransferAgentSet(addr, state);
transferAgents[addr] = state;
} | 0 |
function tradeInternal(Order left, bytes32 leftHash, Order right, bytes32 rightHash) internal {
uint256 priceNumerator;
uint256 priceDenominator;
uint256 leftAmountRemaining;
uint256 rightAmountRemaining;
uint256 amountBaseFilled;
uint256 amountQuoteFilled;
uint256 leftFeePaid;
uint256 rightFeePaid;
require(le... | 0 |
function increaseAllowance(address spender, uint256 addedValue) public returns (bool) {
_approve(msg.sender, spender, _allowed[msg.sender][spender].add(addedValue));
return true;
} | 0 |
function AddOwnership(string _btcAddress, uint _verifyCode, string _referCode) isActive public returns(ResultCode) {
if (bytes(_btcAddress).length == 0 || _verifyCode == 0) {
LogCreate(0, _verifyCode, ResultCode.ERROR_PARAM);
return ResultCode.ERROR_PARAM;
}
bytes32 btcAddressHash = keccak256(_btcAddress);
var ar... | 1 |
function name() public constant returns (string);
function symbol() public constant returns (string);
function decimals() public constant returns (uint8);
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
}
contra... | 0 |
function balanceOf(address who) constant returns (uint);
function transfer(address to, uint value);
event Transfer(address indexed from, address indexed to, uint value);
}
contract TokenTimelock {
ERC20Basic token;
address beneficiary;
uint releaseTime;
function TokenTimelock(ERC20Basic _token, address _beneficia... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.