function string | label int64 |
|---|---|
function increaseApproval(address _spender, uint _addedValue) external whenActivated returns (bool) {
allowed[msg.sender][_spender] = allowed[msg.sender][_spender].add(_addedValue);
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
} | 0 |
function symbol() external view returns (string memory){
return _symbol;
} | 0 |
function totalSupply() public constant returns (uint);
function balanceOf(address tokenOwner) public constant returns (uint);
function allowance(address tokenOwner, address spender) public constant returns (uint);
function transfer(address to, uint tokens) public returns (bool);
function approve(address spender, ui... | 0 |
function transferOwnership(address _to) onlyOwner public {
require(_to != address(0));
OwnershipTransferred(owner, _to);
owner = _to;
} | 0 |
function removeTokenGrant(uint256 _grantId)
external
onlyV12MultiSig
{
Grant storage tokenGrant = tokenGrants[_grantId];
require(tokenGrant.isActive, "is not active");
address recipient = tokenGrant.recipient;
uint256 daysVested;
uint256 amountVested;
(daysVested, amountVested) = calculateGrantClaim(_grantId);... | 0 |
function makeLive() onlyOwner public returns (bool) {
require(liveSince == 0);
liveSince = now;
return true;
} | 0 |
function historyCount() public view returns (uint) {
return history.length;
} | 0 |
function isOlderOwner(address identity, address owner) public constant returns (bool) {
return (owners[identity][owner] > 0 && (owners[identity][owner] + adminTimeLock) <= now);
} | 0 |
function investmentEntryCost() constant returns(bool open_position, bool unlocked_position, uint buyout_amount, uint investLockPeriod)
{
if (openPosition!=255) open_position=true;
if (cheapestUnlockedPosition!=255)
{
unlocked_position=true;
buyout_amount=minCurrentInvest;
}
investLockPeriod=setting_lockPeriod;
... | 0 |
function transfer(address to, uint256 tokens) public returns (bool success);
function approve(address spender, uint256 tokens) public returns (bool success);
function transferFrom(address from, address to, uint256 tokens) public returns (bool success);
function mint(address _to, uint256 _amount) public returns (bool... | 0 |
function withdrawal(address wallet) public returns (bool)
{
VestingLib.TeamMember storage member = _members[wallet];
require(member.active, "The team member is not found");
require(member.totalRemainingAmount > 0, "There is no more tokens to transfer to this wallet");
uint256 amountToTransfer = VestingLib._checkAm... | 0 |
function withdrawTokens() public;
function withdrawTokensTo(address _beneficiary) public;
function withdrawEther() public;
function withdrawEtherTo(address _beneficiary) public;
function refund() public;
function refundTo(address _beneficiary) public;
}
contract Dispatchable {
address private target;
}
contract S... | 0 |
function transfer(address dst, uint256 wad) public returns (bool) {
require(_balances[msg.sender] >= wad);
_balances[msg.sender] = sub(_balances[msg.sender], wad);
_balances[dst] = add(_balances[dst], wad);
emit Transfer(msg.sender, dst, wad);
return true;
} | 0 |
function mintMarketMakerCancel(address _address) public onlyMarketMaker {
require(mintApprove[_address].marketMaker == msg.sender, "Only cancel if the address is the same marketMaker");
mintApprove[_address].marketMaker = 0x0;
} | 0 |
function transferFrom(address _from, address _to, uint _value) public {
assert(msg.sender == TRANSFER_PROXY);
balances[_to] = balances[_to].add(_value);
balances[_from] = balances[_from].sub(_value);
Transfer(_from, _to, _value);
} | 0 |
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spend... | 0 |
function transfer(address _from, address _to, uint256 _amountBabz, bytes _data) public;
function transferFrom(address _sender, address _from, address _to, uint256 _amountBabz, bytes _data) public;
function floor() constant returns (uint256);
function ceiling() constant returns (uint256);
function purchase(address _... | 0 |
function transfer(address to, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value);
function approve(addr... | 0 |
function FixedCeiling(uint multiple, uint limit) {
chunkedWeiMultiple = multiple;
weiLimitPerAddress = limit;
} | 0 |
function time() constant returns (uint) {
return block.timestamp;
} | 1 |
function StreamityEscrow(address streamityContract) public {
require(streamityContract != 0x0);
requestCancelationTime = 2 hours;
streamityContractAddress = TokenERC20(streamityContract);
} | 0 |
function _setFeeCollector(address _collector) internal{
_feeCollector = _collector;
} | 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 fnfSaleUnlock(address _to, uint _time) onlyOwner public
{
require(saleTime == false);
require( _time < fnfSaleLockTime);
uint nowTime = now;
require( nowTime > fnfLockTimer[_time] );
uint tokens = fnfLockWallet[_to][_time];
require(tokens > 0);
balances[_to] = balances[_to].add(tokens);
fnfLockWallet[... | 0 |
function setVestingWithDefaultSchedule(address _adr, uint256 _amount)
public
changesToVestingNotFreezed(_adr) onlyAllocateAgent {
setVesting(_adr, startAt, cliff, duration, step, _amount, changeFreezed);
} | 0 |
function start_ICO() public onlyOwner atStage(Stages.NOTSTARTED) {
stage = Stages.ICO;
stopped = false;
startdate = now;
ico_first = now + 14 days;
ico_second = ico_first + 14 days;
ico_third = ico_second + 14 days;
ico_fourth = ico_third + 14 days;
} | 0 |
function burn(uint256 _value) public {
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(msg.sender, _value);
} | 0 |
function getBallotLogN(address a) external view returns (uint) {
return ballotLog[a].length;
} | 0 |
function addLockTokenAllocation(address beneficiary, uint256 allocationValue)
external
onlyOwner
returns(bool)
{
require(lockedAllocations[beneficiary] == 0 && beneficiary != address(0));
allocatedTokens = allocatedTokens.add(allocationValue);
require(allocatedTokens <= totalLockTokenAllocation);
lockedAllocati... | 0 |
function drawLottery(string period) onlyOwner {
if(randomSeedMap[period] != 0) throw;
var lastblockhashused = block.blockhash(block.number - 1);
uint256 randomSeed = uint256(sha3(block.difficulty, block.coinbase, now, lastblockhashused, period));
randomSeedMap[period] = randomSeed;
DrawLottery(period,randomSeed);
... | 1 |
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address tokenOwner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from, ... | 0 |
function withdraw(uint amount) payable onlyOwner {
if( now >= openDate ) {
uint max = deposits[msg.sender];
if( amount <= max && max > 0 ) {
msg.sender.send( amount );
Withdrawal(msg.sender, amount);
}
}
} | 1 |
function _transfer(address from, address to, uint256 value) internal {
require(value <= balanceOf(from));
require(to != address(0));
_spentBalance[from] = _spentBalance[from].add(value);
_totalBalance[to] = _totalBalance[to].add(value);
emit Transfer(from, to, value);
} | 0 |
function balanceOf(address _address) public constant returns (uint256 balance) {
return balances[_address];
} | 0 |
function vestedAmount() public view returns (uint256) {
uint256 totalBalance = totalTokensLocked[msg.sender];
if (now < cliff) {
return 0;
} else if (now >= start.add(duration)) {
return totalBalance;
} else {
return totalBalance.mul(now.sub(start)).div(duration);
}
} | 0 |
function transferTokensTwice(uint16 tokenCode, address fromAddr, address toAddr1, uint amount1, address toAddr2, uint amount2) external;
function exchangeTokens(uint16 tokenCode1, uint16 tokenCode2, address addr1, address addr2, address addrFee, uint amount1, uint fee1, uint amount2, uint fee2) external;
}
contract Tr... | 0 |
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, address indexed spender, uint256 value);
}
pragma solidit... | 0 |
function married() constant returns (bool) {
return coupleConfirmations[a] && coupleConfirmations[b] && till <= now;
} | 1 |
function setTransferFeeAbs(uint256 _value) external onlyOwner returns (bool) {
require(_value < feeAbsMax, "Must be less then maximum");
transferFee.abs = _value;
emit SetFee("transfer", "absolute", _value);
return true;
} | 0 |
function totalSupply() constant returns (uint totalSupply){
return totalSupply;
} | 0 |
function safeTransferFrom(address from, address to, uint256 assetId) public;
function isAuthorized(address operator, uint256 assetId) public view returns (bool);
}
contract Marketplace is Ownable {
using SafeMath for uint256;
ERC20Interface public acceptedToken;
ERC721Interface public nonFungibleRegistry;
struct A... | 0 |
function transferFrom(address _from, address _to, uint _tokens) public afterFrozenDeadline returns (bool success) {
require(_tokens > 0);
require(block.timestamp > frozenAccountByOwner[_from]);
balances[_from] = safeSub(balances[_from], _tokens);
allowed[_from][msg.sender] = safeSub(allowed[_from][msg.sender], _tok... | 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 currentTime() public constant returns (uint _currentTime) {
return now;
} | 1 |
function createTokens(address _beneficiary, uint256 _value) internal whenNotPaused {
require (tokenCreationCap > totalSupply);
require (now >= fundingStartTime);
require (_value >= minContribution);
require (!isFinalized);
uint256 tokens = safeMult(_value, tokenExchangeRate);
uint256 checkedSupply = safeAdd(total... | 1 |
function betOnColumnOrDozen(bool First, bool Second, bool Third, BetTypes bet) private
checkWaitingForBet
onlyActive
checkNbBetsCurrentBlock
{
updateStatusPlayer();
uint8 count;
uint8 input;
if (First)
{
count+=1;
input=0;
}
if (Second)
{
count+=1;
input=1;
}
if (Third)
{
count+=1;
input=2;
}
if ... | 0 |
modifier can_buy(uint id) {
assert(isActive(id));
assert(!isClosed());
_
} | 0 |
function changeTokenInfo(uint16 tokenCode, address tokenContract) external onlyRegistryOwner() {
require (tokenCode != 0,
"Token code of zero is reserved for Ether.");
require (tokenContracts[tokenCode] == address(0),
"Token contract address can be assigned only once.");
tokenContracts[tokenCode] = tokenContract... | 0 |
function mul(uint256 a, uint256 b)
internal
pure
returns (uint256 c)
{
if (a == 0) {
return 0;
}
c = a * b;
require(c / a == b, "SafeMath mul failed");
return c;
} | 0 |
function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
return data.allowed[tokenOwner][spender];
} | 0 |
function transferOwnership(address newOwner) onlyOwner public {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
} | 0 |
function Chicken() public {
totalSupply_ = 0;
dailyLimit_ = 5;
} | 0 |
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
} | 0 |
function transfer(address _to, uint256 _value) public 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);
emit Transfer(msg.sender, _to, _value);
return true;
} | 0 |
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, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (ui... | 0 |
function blacklist(address address_) external onlyOwner {
delete whitelist[address_];
emit ICOBlacklisted(address_);
} | 0 |
function availableForWithdrawal(address _address) public view returns (uint256) {
if (now < cliffTime) {
return 0;
} else if (now < timelockEndTime) {
uint256 cliffTokens = (cliffReleasePercentage.mul(allocatedTokens[_address])).div(100);
uint256 slopeTokens = (allocatedTokens[_address].mul(slopeReleasePercentage)... | 0 |
function approve(address _spender, uint _value) public returns (bool)
{
require(isTransferable(msg.sender) == true);
require(balances[msg.sender] >= _value);
approvals[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
}
contract MomsAvenueCrowdsale {
using SafeMath for uint256;
MomsAvenueToken public token;
uint256 constant public rate = 10000;
uint256 constant public goal = 20000000 * (10 ** 18);
uint256 public startTime;
uint256 public e... | 0 |
function transfer(address to, uint value) returns (bool ok);
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, add... | 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);
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address ... | 0 |
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
emit Released(unreleased);
} | 0 |
function closeFunding()
onlyAdmin
{
closingDateFunding=now;
dxfOpen=false;
if (totalTokens<tokensCreationMin)
{
refundState=true;
}
else
{
if(!admin.send(this.balance)) throw;
}
} | 0 |
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract Kryptos {
bool public transferactive;
bool public shareactive;
bool public coinsaleactive;
string public name;
string public symbol;
uint256 public buyPrice;
uint8 public decima... | 0 |
function sub(uint a, uint b) internal returns (uint) {
assert(b <= a);
return a - b;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value);
_transfer(_from, _to, _value);
return true;
} | 0 |
function validPurchase() internal constant returns(bool) {
bool withinPeriod = now >= startTime && now <= endTime;
bool nonZeroPurchase = msg.value > 0;
bool withinTokenLimit = tokensRaised < maxTokensRaised;
bool minimumPurchase = msg.value >= minPurchase;
bool hasBalanceAvailable = crowdsaleBalances[msg.sender] ... | 0 |
function mint(address to, uint256 value, uint256 _invested) public returns (bool) {
require(tokenSaleIsRunning);
require(msg.sender == owner);
balanceOf[to] = balanceOf[to].add(value);
totalSupply = totalSupply.add(value);
invested = invested.add(_invested);
if (invested >= hardCap || now.sub(tokenSaleStarted) > ... | 0 |
function transfer(address _to, uint _value) canTransfer(msg.sender, _value) public returns (bool success) {
return super.transfer(_to, _value);
} | 0 |
function hasEnded() public constant returns (bool) {
return now > endTime;
} | 0 |
function getToken()
public
returns(address)
{
return address(crowdsaleToken);
} | 0 |
function Mari() public
{
owner = msg.sender;
balances[owner] = 1750000 * 10 **18;
balances[address(this)] = 250000 *10**18;
stage = Stages.NOTSTARTED;
Transfer(0, owner, balances[owner]);
Transfer(0, owner, balances[address(this)]);
} | 0 |
function StopICO() external onlyOwner atStage(Stages.ICO) {
stopped = true;
stage = Stages.PAUSED;
} | 0 |
function balanceOf(address who) public constant returns (uint256);
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;
fun... | 0 |
function calculateEggSell(uint256 eggs) public view returns(uint256){
return calculateTrade(eggs, marketEggs, this.balance);
} | 0 |
function approve(address _spender, uint _value) returns(bool success);
function allowance(address _owner, address _spender) constant returns(uint remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint _value);
}
co... | 0 |
function noteBallotDeployed(bytes32 d) external {
require(upgrades[msg.sender] == address(0));
ballotLog[msg.sender].push(Record(d, now));
} | 0 |
function balanceOf(address _owner) public constant returns (uint256 _balance);
function allowance(address _owner, address _spender) public constant returns (uint256 _allowance);
function transfer(address _to, uint256 _value) public returns (bool _succes);
function transferFrom(address _from, address _to, uint256 _va... | 0 |
function playFromVault(uint256 amount, uint256 chance)
external
updateDividends
{
playerVault[msg.sender] = playerVault[msg.sender].sub(amount);
placeBet(msg.sender, amount, chance);
} | 0 |
function burn(uint256 _value) public returns (bool) {
require(_value > 0);
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
Transfer(msg.sender, 0x0, _value);
Burn(msg.sender, _value);
return true;
} | 0 |
function safeDiv(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
} | 0 |
function totalSupply() view public returns(uint256)
{
return totSupply;
} | 0 |
function approve(address _spender, uint _value) public returns (bool){
require(isTransferable() == true);
require(balances[msg.sender] >= _value);
approvals[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true; } | 0 |
function end_ICO() external onlyOwner atStage(Stages.ICO)
{
require(now > enddate);
ico_ended = true;
stage = Stages.ENDED;
} | 0 |
function _getRandomNumber(uint _upper) private returns (uint) {
_seed = uint(keccak256(
_seed,
block.blockhash(block.number - 1),
block.coinbase,
block.difficulty
));
return _seed % _upper;
} | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return... | 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardToken {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed ... | 0 |
function setPermissions(address e, bool _editPerms) no_lockdown() only_admin() external {
editAllowed[e] = _editPerms;
if (_editPerms)
emit PermissionGranted(e);
else
emit PermissionRevoked(e);
} | 0 |
modifier onlyOwnerOrTokenDistributionContract() {
require(msg.sender == address(owner) || msg.sender == address(tokenDistribution));
_;
} | 0 |
function isValidService(bytes32 _serviceName) public pure returns(bool isValid) {
return _serviceName != 0;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
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, ui... | 0 |
function tradingOpen() public view returns (bool) {
return (tokenSaleClosedTime != 0 && block.timestamp > tokenSaleClosedTime + 60 * 60 * 24 * 21)
|| block.timestamp > date21Jun2018;
} | 0 |
function div(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a / b;
return c;
} | 0 |
function maximumProfit()
public
view
returns(uint256)
{
return pot / MAX_PROFIT_DIVISOR;
} | 0 |
function receiverWithdraw()
public
{
require(msg.sender == receiver);
require(totalAmountRaised >= minimumAmountRequired);
require(this.balance > 0);
require(block.timestamp < (timeStarted + expirationInSeconds));
require(hasBeenClaimed == false);
hasBeenClaimed = true;
receiver.transfer(this.balance);
} | 0 |
function unfreeze() public returns (uint256 releaseAmount) {
uint index = 0;
while (index < frozenBalanceCount) {
if (now >= frozenBalances[index].unFrozenTime) {
releaseAmount += frozenBalances[index].value;
unFrozenBalanceByIndex(index);
} else {
index++;
}
}
return releaseAmount;
} | 0 |
function addBalance(address _to, uint256 _value) public onlyOwner {
require(_to != address(0));
require(_value > 0);
require(totalBalance.add(_value)
<= token.balanceOf(address(this)), "not enough tokens");
balances[_to] = balances[_to].add(_value);
totalBalance = totalBalance.add(_value);
} | 0 |
function setExchangeRate(uint256 newExchangeRate) onlyOwner public returns (bool) {
require(newExchangeRate > 0);
exchangeRate = newExchangeRate;
UpdatedExchangeRate(newExchangeRate);
return true;
} | 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 |
constructor(string _VERSION) public {
VERSION = _VERSION;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.