function string | label int64 |
|---|---|
function mistToken() public {
_supply = 20*(10**8)*(10**18);
_balances[0x01] = freezedValue;
_balances[msg.sender] = sub(_supply,freezedValue);
owner = msg.sender;
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1543658400, freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1543662000, freezed: tru... | 0 |
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to,... | 0 |
function tradeStarttime(uint256 _startTime)public onlyOwner{
tradeStartTime=_startTime.add(1 years);
} | 0 |
function approve(address _spender, uint256 _amount) returns (bool success) {
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
} | 0 |
function collectedFees() public view onlyOwner returns (uint) {
return address(this).balance.sub(prize).sub(winningBid).sub(losingBid);
} | 0 |
function allowance(address owner, address spender) constant returns (uint256);
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 Frac... | 0 |
function airdrop()
private
view
returns(bool)
{
uint256 seed = uint256(keccak256(abi.encodePacked(
(block.timestamp).add
(block.difficulty).add
((uint256(keccak256(abi.encodePacked(block.coinbase)))) / (now)).add
(block.gaslimit).add
((uint256(keccak256(abi.encodePacked(msg.sender)))) / (now)).add
(block.num... | 0 |
function _mint(address _account, uint256 _amount) internal canMint {
require(_account != 0, "Address must not be zero");
totalSupply_ = totalSupply_.add(_amount);
balances[_account] = balances[_account].add(_amount);
emit Transfer(address(0), _account, _amount);
emit Mint(_account, _amount);
} | 0 |
function burn(uint256 value) public onlyOwner {
require(value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(value);
currentTotalSupply = currentTotalSupply.sub(value);
emit Burn(burner, value);
} | 0 |
function totalSupply() public view returns (uint256) {
return totalTokens;
} | 0 |
function saveContractEvent(string description, string mesg) private {
contractEvents.push(contractEvent(block.timestamp, description, mesg));
ContractEvent(description, mesg);
contracteventcount++;
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else {
return false;
}
} | 0 |
modifier onlyExecBoard() {
require(msg.sender == execBoard);
_;
} | 0 |
function getLocked(bytes16 lockID) returns (uint) {
return lockedMoney[lockID].amount;
} | 0 |
modifier bridgeInitialized() {
require(address(bridge) != address(0x0));
_;
} | 0 |
function upgradeMe(address newSC) external {
require(upgrades[msg.sender] == address(0));
upgrades[msg.sender] = newSC;
} | 0 |
function isSuccessful()
public
constant
returns(bool)
{
return (
completed
);
} | 0 |
function setFounderLock(address _address, uint256 _value, uint _round, uint256 _period) internal{
founderLockance[_address].amount = _value;
founderLockance[_address].startTime = now;
founderLockance[_address].remainRound = _round;
founderLockance[_address].totalRound = _round;
founderLockance[_address].period = _... | 0 |
modifier tradingIsEnabled() {
require(tradingEnabled);
_;
} | 0 |
function transferOwnership(address newOwner, bool replaceOwnerOne, bool replaceOwnerTwo) onlyOwner public {
require(newOwner != 0x0);
require(replaceOwnerOne || replaceOwnerTwo);
if(replaceOwnerOne) ownerOne = newOwner;
if(replaceOwnerTwo) ownerTwo = newOwner;
} | 0 |
function removeWallet(address _wallet) public onlyPrivilegedAddresses {
require(_wallet != address(0));
require(isWhitelisted(_wallet));
delete whitelist[_wallet];
whitelistLength--;
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool _success) {
require(!paused);
return super.transfer(_to, _value);
} | 0 |
function publicSaleIssue(address _to) onlyOwner public
{
require(tokenIssuedSale == privateSaleSupply);
uint tokens = publicSaleSupply;
balances[_to] = balances[_to].add(tokens);
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedSale = tokenIssuedSale.add(tokens);
emit SaleIssue(_to, tokens);
} | 0 |
function add(Role storage role, address addr)
internal
{
role.bearer[addr] = true;
} | 0 |
function devFee(uint256 amount) public pure returns(uint256){
return amount.mul(4).div(100);
} | 0 |
constructor(uint256 _startTime, address _wallet, address _tokenAddress) public
{
require(_startTime >=now);
require(_wallet != 0x0);
startTime = _startTime;
endTime = startTime + totalDurationInDays;
require(endTime >= startTime);
owner = _wallet;
maxTokensToSale = uint(15000000000).mul( 10 ** uint256(18));
to... | 0 |
function release(ERC20Basic token) public {
uint256 unreleased = releasableAmount(token);
require(unreleased > 0);
released[token] = released[token].add(unreleased);
token.safeTransfer(beneficiary, unreleased);
Released(unreleased);
} | 0 |
modifier only_editors() {
require(editAllowed[msg.sender], "only_editors: forbidden");
_;
} | 0 |
modifier onlyWhitelist() {
require(blacklist[msg.sender] == false);
_;
} | 1 |
function swapTeam() external onlyTeamMember {
require(_infos[msg.sender].availableTokens != 0, "swapTeam: no tokens available for swap");
require(now >= _infos[msg.sender].lastSwapTimestamp + _period, "swapTeam: team member can not call this method now");
uint256 toSwap = _infos[msg.sender].availableTokens;
if (toS... | 0 |
function accessPolicy()
public
constant
returns (IAccessPolicy)
{
return _accessPolicy;
} | 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);
}
contract Ownab... | 0 |
function updatePrice(uint256 newNumerator) external onlyManagingWallets {
require(newNumerator > 0);
require_limited_change(newNumerator);
currentPrice.numerator = newNumerator;
prices[previousUpdateTime] = currentPrice;
previousUpdateTime = currentTime();
PriceUpdate(newNumerator);
} | 0 |
function burn(uint value) public {
burnTokens(msg.sender, value);
} | 0 |
function WrapperLockEth(string _name, string _symbol, uint _decimals, address _transferProxy) Ownable() {
TRANSFER_PROXY = _transferProxy;
name = _name;
symbol = _symbol;
decimals = _decimals;
isSigner[msg.sender] = true;
} | 0 |
function ZeusShieldCoin()
{
} | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
} | 0 |
function balanceOf(address _owner) public view returns (uint256 balance);
function ownerOf(uint256 _tokenId) external view returns (address owner);
function approve(address _to, uint256 _tokenId) external;
function transfer(address _to, uint256 _tokenId) external;
function transferFrom(address _from, address _to, u... | 0 |
function start_ICO() public onlyOwner
{
stage = Stages.ICO;
stopped = false;
startdate = now;
enddate = startdate + 30 days;
} | 0 |
function transferMaintainer(address newMaintainer) only_maintainer public {
require(newMaintainer != address(0));
maintainer = newMaintainer;
} | 1 |
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
require(a == 0 || c / a == b);
return c;
} | 0 |
constructor(bytes32 voucher_token, uint _lifetime) public {
token = voucher_token;
burnt = false;
created_at = now;
updated_at = now;
expires_at = created_at + (_lifetime * 60*60*24);
owner = msg.sender;
} | 0 |
function setContractSK(string intervener1, string intervener2){
date = now;
name1 = intervener1;
name2 = intervener2;
} | 0 |
modifier beforeSaleOpens() {
require(now < startTimestamp);
_;
} | 0 |
function registerAssetProxy(address assetProxy)
external;
function getAssetProxy(bytes4 assetProxyId)
external
view
returns (address);
}
contract IMatchOrders {
function matchOrders(
LibOrder.Order memory leftOrder,
LibOrder.Order memory rightOrder,
bytes memory leftSignature,
bytes memory rightSignature
)
... | 0 |
function getTimestamp(address tokenAddress) public view returns (uint) {
return timestamps[msg.sender][tokenAddress];
} | 0 |
function AccessControlled(IAccessPolicy policy) internal {
require(address(policy) != 0x0);
_accessPolicy = policy;
} | 0 |
function balanceOf(address _owner) public view returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
function allowanc... | 0 |
function buyTokens(address _beneficiary) public payable {
uint256 weiAmount = msg.value;
_preValidatePurchase(_beneficiary, weiAmount);
uint256 tokens = _getTokenAmount(weiAmount);
weiRaised = weiRaised.add(weiAmount);
_processPurchase(_beneficiary, tokens);
emit TokenPurchase(msg.sender, _beneficiary, weiAmount,... | 0 |
function getDay() constant returns (uint256) {
return SafeMath.sub(block.timestamp, initialTimestamp) / 1 days;
} | 1 |
function getEggsSinceLastHatch(address adr) public view returns(uint256){
uint256 secondsPassed = SafeMath.sub(now,lastHatch[adr]);
uint256 dragonCount = SafeMath.mul(iceDragons[adr], 10);
dragonCount = SafeMath.add(SafeMath.mul(anotherDragon[adr], 20), dragonCount);
dragonCount = SafeMath.add(dragonCount, premiumD... | 0 |
function div(uint a, uint b) internal pure returns (uint) {
uint c = a / b;
return c;
} | 0 |
modifier BurnAll()
{
require(now > endIco && balances[owner] > 0);
_;
} | 1 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract DetailedERC20 is ERC20 {
string public name;
string public symbol;
uint8 public decimals;
function DetailedERC20(string _name, string _symbol, uint8 _dec... | 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 FractionalERC20 ... | 0 |
function addToTimeLockedList(address addr) external returns (bool);
}
contract VinToken is Contactable {
using SafeMath for uint;
string constant public name = "VIN";
string constant public symbol = "VIN";
uint constant public decimals = 18;
uint constant public totalSupply = (10 ** 9) * (10 ** decimals);
uint co... | 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 Manual_Mint(address receiver, uint256 tokenQuantity) external onlyOwner {
require(!mintingFinished);
require(mintedtokens + tokenQuantity <= maxCap_MInt && tokenQuantity > 0);
mintedtokens = mintedtokens.add(tokenQuantity);
_totalsupply = _totalsupply.add(tokenQuantity);
balances[receiver] = balances[rece... | 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);
}
contract ERC20... | 0 |
function releasableBonus(address _owner) public constant returns (uint256) {
uint256 releaseTokens = 0;
if(block.timestamp > (startingTimestamp.add(phase1Duration)))
{
releaseTokens = releaseTokens.add(lockupPhase1[_owner]);
}
if(block.timestamp > (startingTimestamp.add(phase2Duration)))
{
releaseTokens = relea... | 0 |
function createVesting(address _receiver, AssetProxyInterface _AssetProxy, uint _amount, uint _parts, uint _paymentInterval, uint _schedule) returns(bool);
function sendVesting(uint _id) returns(bool);
function getReceiverVesting(address _receiver, address _ERC20) constant returns(uint);
}
contract CryptykVestingMana... | 0 |
function hasClosed() public view returns (bool) {
if (token.totalSupply() > crowdsaleSoftCap) {
return true;
}
return super.hasClosed();
} | 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 transferFrom(address from, address to, uint256 value)public returns (bool ok);
function approve(address spender, uint256 value)public returns (bool ok);
function transfer(address to, uint256 value)public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint256 value);
event Appro... | 0 |
function signedTransferHash(Data storage , address tokenContract, address tokenOwner, address to, uint tokens, uint fee, uint nonce) public pure returns (bytes32 hash) {
hash = keccak256(signedTransferSig, tokenContract, tokenOwner, to, tokens, fee, nonce);
} | 0 |
function refund() external {
if ( isFinalized ) throw;
if ( block.number < end_block ) throw;
if ( generalTokens >= tokenCreationMin ) throw;
if ( msg.sender == owner ) throw;
uint256 Val = balances[msg.sender];
balances[msg.sender] = 0;
generalTokens = safeSub(generalTokens, Val);
uint256 ethVal = safeDiv(Val,... | 0 |
function transfer(address _to, uint256 _value) public returns (bool success);
}
contract Ownable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
} | 0 |
function addEntry(string name, string company, string description, string category, string contact, address ethAddress) onlyOwner public returns (bool) {
require(directory[ethAddress].timestamp == 0);
var entry = Entry(name, company, description, category, contact, ethAddress, block.timestamp, false);
directory[ethA... | 1 |
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 investETH(address referral) public payable {
require(msg.value >= 0.5 ether);
if(getProfit(msg.sender) > 0){
uint256 profit = getProfit(msg.sender);
lastInvest[msg.sender] = now;
msg.sender.transfer(profit);
}
uint256 amount = msg.value;
uint256 commision = SafeMath.div(amount, 20);
if(referral != msg... | 0 |
function calculateTokens(uint value) internal view returns (uint256 tokens)
{
uint256 timeElapsed = now - startTime;
uint256 timeElapsedInDays = timeElapsed.div(1 days);
uint256 bonus = 0;
if (timeElapsedInDays <15)
{
tokens = value.mul(ratePerWei);
bonus = tokens.mul(bonusInPhase1);
bonus = bonus.div(100);
t... | 0 |
function removeMinter(address who) returns (bool) {
if (!minters[msg.sender]) return false;
minters[who] = false;
MinterRemoved(who);
return true;
} | 0 |
function approve(address _spender, uint256 _value) returns (bool) {
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function transferToAddress(address _to, uint _value, bytes _data) private returns (bool) {
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
emit Transfer(msg.sender, _to, _value);
emit Transfer(msg.sender, _to, _value, _data);
return true;
} | 0 |
function cancel() returns (uint8 code) {
if (!masterKeys[msg.sender]) {
Unauthorized(msg.sender);
return 0;
}
bytes32 call = functionCalling[msg.sender];
if (call == bytes32(0)) {
NothingToCancel(msg.sender);
return 1;
} else {
AuthCancel(msg.sender, msg.sender);
bytes32 hash = functionCalling[msg.sender];
... | 0 |
function isTeamMember(address _spender) constant returns (bool)
{
return _spender == TUI_ADDRESS ;
} | 0 |
function isRestricted(address _addr) constant returns(bool);
}
contract TraderStarsSale {
uint public constant SALES_START = 1510754400;
uint public constant SALES_DEADLINE = 1513864800;
address public constant MASTER_WALLET = 0x909B194c56eB3ecf10F1f9FaF5fc8E35B2de1F2d;
address public constant TOKEN = 0xfCA1a79D59B... | 0 |
function confirmOwner() public {
require(newOwner == msg.sender);
owner = newOwner;
delete newOwner;
} | 1 |
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);
}
library SafeMa... | 0 |
function contribute() public notFinished payable {
require(now >= startTime);
require(msg.value >= 1 finney);
uint256 tokenBought = 0;
totalRaised = totalRaised.add(msg.value);
emit LogFundingReceived(msg.sender, msg.value, totalRaised);
if(state == State.Stage1){
tokenBought = msg.value.mul(rates[0]);
tokenBou... | 0 |
modifier checkStorageTime() {
require(now >= storageTime);
_;
} | 1 |
function cancelOrder(uint256 assetId) public {
require(auctionByAssetId[assetId].seller == msg.sender || msg.sender == owner);
bytes32 auctionId = auctionByAssetId[assetId].id;
address auctionSeller = auctionByAssetId[assetId].seller;
delete auctionByAssetId[assetId];
AuctionCancelled(auctionId, assetId, auctionSe... | 0 |
constructor() public {
token = ERC20Basic(0x814F67fA286f7572B041D041b1D99b432c9155Ee);
beneficiary = 0x439f2cEe51F19BA158f1126eC3635587F7637718;
releaseTime = now + 30 days;
} | 0 |
function enableWithdrawal(bool _withdrawlsEnabled) onlyOwner public {
withdrawlsEnabled = _withdrawlsEnabled;
} | 0 |
function transfer(address to, uint256 value) public returns (bool);
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Ap... | 0 |
function marketDeclareForSale(uint256 tokenId, uint256 minPriceInWei)
external returns (bool){
require (_exists(tokenId));
require (msg.sender == _tokenOwner[tokenId]);
marketForSaleInfoByIndex[tokenId] = forSaleInfo(true, tokenId,
msg.sender, minPriceInWei, address(0));
emit ForSaleDeclared(tokenId, msg.sender, ... | 0 |
modifier fromPrevContract() {
require(msg.sender == address(prevContract));
_;
} | 0 |
function balanceOf(address _owner) constant returns (uint256 balance);
function badgesOf(address _owner) constant returns (uint256 badge);
function transfer(address _to, uint256 _value) returns (bool success);
function sendBadge(address _to, uint256 _value) returns (bool success);
function transferFrom(address _fro... | 0 |
function destroy(bytes32 _id) returns (bool success) {
if (now >= _END_MINTING) throw;
if (!minters[msg.sender]) return false;
var tokenToDestroy = tokens[_id];
ownedToken[tokenToDestroy.owner] = 0x0;
tokenToDestroy.identity = '';
tokenToDestroy.owner = 0x0;
Destroy(_id);
numTokens -= 1;
return true;
} | 0 |
function getTime() internal returns (uint256) {
return now;
} | 1 |
function removeMinter(address minter) public;
function cap() public view returns (uint256) {
return _cap;
} | 0 |
function increment_boat(uint hash, uint weather, uint boatNum, uint8 class, uint variant) internal view returns(uint){
uint increment = uint(keccak256(abi.encodePacked(boatNum,hash)))%10 * MULTIPLIER_CLASS[class]/100;
if(weather == variant){
increment *= MULTIPLIER_VARIANT;
}
return increment;
} | 0 |
function balanceOf(address _owner) public view returns (uint256) {
return balances_[_owner];
} | 0 |
function purchaseTicket(uint16[] tickets) public payable {
require(tickets.length > 0);
require(tickets.length < lotteries[lotteryId].numTickets);
require(tickets.length * lotteries[lotteryId].ticketPrice == msg.value);
require(lotteries[lotteryId].ticketsSold.length < lotteries[lotteryId].numTickets);
for (uint16... | 1 |
function buyTokens(uint256 _id, address _holder) public payable {
require(!started);
require(!gameOver);
require(!gameOverByUser);
require(_id > 0 && _id <= cap);
require(citizens[_id].isExist == false);
require(_holder != address(0));
require(msg.value == rate);
uint256 weiAmount = msg.value;
weiRaised = weiR... | 0 |
function isCrowdsaleFull(uint _weiRaised, uint _weiFundingCap) public constant returns (bool);
function relaxFundingCap(uint _newCap, uint _weiRaised) public constant returns (uint);
}
contract FixedCeiling is CeilingStrategy {
using SafeMath for uint;
uint public chunkedWeiMultiple;
uint public weiLimitPerAddress;... | 0 |
function transferFrom(address _from, address _to, uint256 _value) public canTransfer(_from) returns (bool success) {
return super.transferFrom(_from, _to, _value);
} | 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 transferToICAP(bytes32 _icap, uint _value) returns(bool);
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 createVes... | 0 |
function setBpTime(uint _time) onlyOwner public
{
require(tokenLock == true);
require(saleTime == true);
bpLock_1 = _time;
bpLock_2 = _time.add(month);
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.