function string | label int64 |
|---|---|
function transferFrom( address from, address to, uint value) returns (bool ok) {
if( _balances[from] < value ) {
throw;
}
if( _approvals[from][msg.sender] < value ) {
throw;
}
if( !safeToAdd(_balances[to], value) ) {
throw;
}
_approvals[from][msg.sender] -= value;
_balances[from] -= value;
_balances[to] += ... | 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 logShiftAndBookAward() internal {
uint256 shiftAward;
if ((phase == Phases.PreIcoA) || (phase == Phases.PreIcoB)) {
shiftAward = PRE_OPENING_AWARD;
} else if (phase == Phases.MainIco) {
shiftAward = ICO_OPENING_AWARD;
} else {
shiftAward = ICO_CLOSING_AWARD;
returnAllowedTime = uint64(now + RETURN_WEI_... | 0 |
modifier pastCliffTime(address target) {
VestingSchedule storage vestingSchedule = schedules[target];
require(block.timestamp > vestingSchedule.cliffTimeInSec);
_;
} | 0 |
function min64(uint64 a, uint64 b) internal pure returns (uint64) {
return a < b ? a : b;
} | 0 |
function revoke(address wlCandidate) public onlyOwner {
whitelist[wlCandidate] = false;
emit Revoked(wlCandidate, now);
} | 0 |
function upgradeFrom(address _tokenHolder, uint256 _amount) external;
}
contract UpgradeableToken is ProsperMintableToken {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade... | 0 |
function transferable() public view returns (bool) {
return data.transferable;
} | 0 |
function addInvestment(address _from, uint256 _value) internal {
investments[_from] = investments[_from].add(_value);
} | 0 |
function isEthereumBased(address _tokenAddress) private pure returns (bool) {
return (_tokenAddress != address(0x0));
} | 0 |
function releasableAmount() public view returns (uint256) {
return vestedAmount().sub(releasedTokens[msg.sender]);
} | 0 |
function startDealForUser(bytes32 _hashDeal, address _seller, address _buyer, uint256 _commission, uint256 _value, bool isAltCoin)
private returns(bytes32)
{
Deal storage userDeals = streamityTransfers[_hashDeal];
userDeals.seller = _seller;
userDeals.buyer = _buyer;
userDeals.value = _value;
userDeals.commissio... | 0 |
function audit(bytes32 _swapID) external view returns (uint256 timelock, uint256 value, address to, address from, bytes32 secretLock) {
Swap memory swap = swaps[_swapID];
return (swap.timelock, swap.value, swap.withdrawTrader, swap.ethTrader, swap.secretLock);
} | 0 |
modifier onlyIco() {
require(msg.sender == addressIco);
_;
} | 0 |
function hasEnded() external view returns (bool) {
return now > endTime;
} | 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 motionConfirming(uint motionID)
public
view
returns (bool)
{
uint startTime = motionStartTime[motionID];
return startTime + votingPeriod <= now &&
now < startTime + votingPeriod + confirmationPeriod;
} | 0 |
function reserveIssue(address _to, uint _value) onlyOwner public
{
uint tokens = _value * E18;
require(maxReserveSupply >= tokenIssuedReserve.add(tokens));
balances[_to] = balances[_to].add(tokens);
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedReserve = tokenIssuedReserve.add(tokens);
emit Reserve... | 0 |
function checkBetLowhigh(uint8 result) private
{
bool win;
if (result!=0 && ( (result<19 && gambles[gambleIndex[msg.sender]].input==0)
|| (result>18 && gambles[gambleIndex[msg.sender]].input==1)
) )
{
win=true;
}
solveBet(msg.sender,result,win,2);
} | 0 |
constructor() public {
creationTime = now;
} | 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 receiveApproval(address from, uint256 tokens, address token, bytes data) public;
}
contract BTTSTokenInterface is ERC20Interface {
uint public constant bttsVersion = 100;
bytes public constant signingPrefix = "\x19Ethereum Signed Message:\n32";
bytes4 public constant signedTransferSig = "\x75\x32\xea\xac";
... | 0 |
function releaseVestedTokens(address _adr) public changesToVestingFreezed(_adr) {
VestingSchedule storage vestingSchedule = vestingMap[_adr];
require(vestingSchedule.amount.minus(vestingSchedule.amountReleased) > 0);
uint256 totalTime = block.timestamp - vestingSchedule.startAt;
uint256 totalSteps = totalTime / ves... | 0 |
function yes(address _address, uint _votes) public;
function no(address _address, uint _votes) public;
function vote(address _address) public view returns (int);
function votesTotal() public view returns (uint);
function isSubjectApproved() public view returns (bool);
}
contract Ownable is IOwnable {
modifier only... | 0 |
function pause() public onlyOwner whenNotPaused {
_paused = true;
emit Paused(msg.sender);
} | 0 |
function deposit(bytes32 _password) public payable {
require(msg.value > commissionFee);
uint256 rand = _rand();
bytes32 pass = sha3(_password, rand);
randToAddress[msg.sender] = rand;
password[pass].from = msg.sender;
password[pass].amount = password[pass].amount.add(msg.value);
_updateSeed();
emit LogDeposit(... | 0 |
function transfer(address to, uint256 value) 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) returns (bool) {
balances[msg.... | 0 |
function strConcat(string _a, string _b, string _c) internal pure returns (string) {
return strConcat(_a, _b, _c, "", "");
} | 0 |
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 SafeMath {
function safeMul(uint a, uint b) internal returns (uint) {
uint c = a * b;
assert(... | 0 |
function add_referral(address referral, string promo, uint256 amount) external returns(address partner, uint256 p_partner, uint256 p_referral){
bytes32 promo_code = stringTobytes32(promo);
p_partner = 0;
p_referral = 0;
partner = address(0x0);
if(partnersPromo[promo_code] != address(0x0) && partnersPromo[promo_cod... | 1 |
function freezeTo(address _to, uint _amount, uint64 _until) public {
require(_to != address(0));
require(_amount <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
bytes32 currentKey = toKey(_to, _until);
freezings[currentKey] = freezings[currentKey].add(_amount);
freezingBalance[... | 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 claimTokens(address _token) external onlyFundWallet {
require(_token != address(0));
Token token = Token(_token);
uint256 balance = token.balanceOf(this);
token.transfer(fundWallet, balance);
} | 0 |
function date_check() private returns(bool check_newyears){
is_leap_year();
if((_year <= now) && (now <= (_year + 1209600))){
return true;
}
else{
return false;
}
} | 0 |
function storeAuthenticity(string sha256) {
if (checkAuthenticity(sha256) == 0) {
authenticity[sha256] = now;
}
} | 1 |
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool success);
function transferFrom(address from, address to, uint256 value) public returns (bool success);
function approve(address spen... | 0 |
function mul(uint256 a, uint256 b) pure internal returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function getTimeLeft()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now < round_[_rID].end)
if (_now > round_[_rID].strt + rndGap_)
return( (round_[_rID].end).sub(_now) );
else
return( (round_[_rID].strt + rndGap_).sub(_now) );
else
return(0);
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public validateAddress(_to) isNotTimeLockedFrom(_from, _to) isNotFrozenFrom(_from, _to) returns (bool)
{
return super.transferFrom(_from, _to, _value);
} | 0 |
function approve(address spender, uint256 value) public returns (bool success);
function allowance(address owner, address spender) public view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 v... | 0 |
function investETH(address referral) public payable {
require(msg.value >= 0.1 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 HubiiCrowdsale(address _teamMultisig, uint _start, uint _end) Crowdsale(_teamMultisig, _start, _end, hubii_minimum_funding) public {
PricingStrategy p_strategy = new FlatPricing(token_in_wei);
CeilingStrategy c_strategy = new FixedCeiling(chunked_multiple, limit_per_address);
FinalizeAgent f_agent = new Bon... | 0 |
constructor() public {
owner = msg.sender;
emit OwnerChanged(address(0), owner);
} | 0 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
} | 0 |
function remoteAllowanceOnMyAddress () public view
returns(uint256 allowance) {
allowance = _remoteToken.allowance(msg.sender, address(this));
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) {
require (_value > 0);
require(_to != address(0));
require(_from != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_... | 0 |
function start_PREICO() external onlyOwner atStage(Stages.NOTSTARTED)
{
stage = Stages.PREICO;
stopped = false;
_price_tokn = 70;
balances[address(this)] =10000000 * 10 ** 18 ;
preico_startdate = now;
preico_enddate = now + 7 days;
emit Transfer(0, address(this), balances[address(this)]);
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.send... | 0 |
function WithdrawETH(uint _amount) {
if (beneficiary != msg.sender) throw;
coldWallet.transfer(_amount);
} | 0 |
function balanceOf(address who) constant public 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 constant returns (... | 0 |
function sellPoohs() public{
require(initialized);
uint256 hasPoohs=getMyPoohs();
uint256 poohValue=calculatePoohSell(hasPoohs);
uint256 fee=devFee(poohValue);
hatcheryPlumber[msg.sender] = SafeMath.div(hatcheryPlumber[msg.sender],2);
claimedPoohs[msg.sender]=0;
lastHatch[msg.sender]=now;
marketPoohs=SafeMath.a... | 0 |
function notarize(string sha256) {
bytes memory b_hash = bytes(sha256);
if ( b_hash.length == 64 ){
if ( proofs[sha256] == 0 ){
proofs[sha256] = block.timestamp;
}
}
} | 1 |
function TokenTimelock(ERC20Basic _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > now);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 0 |
function setUpgradeAgent(address agent) external {
require(canUpgrade());
require(agent != 0x0);
require(msg.sender == upgradeMaster);
require(getUpgradeState() != UpgradeState.Upgrading);
upgradeAgent = UpgradeAgent(agent);
require(upgradeAgent.isUpgradeAgent());
require(upgradeAgent.originalSupply() == totalSu... | 0 |
function balanceOf(address who) constant returns (uint);
function allowance(address owner, address spender) constant returns (uint);
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 valu... | 0 |
function externalTokensRecovery(ERC20Basic _address) onlyAdmin(2) public{
require(state == State.Successful);
uint256 remainder = _address.balanceOf(this);
_address.transfer(msg.sender,remainder);
} | 0 |
function transferFrom(address _from, address _to, uint _value) public returns (bool)
{
require(isTransferable(_from) == true);
require(isTransferable(_to) == true);
require(balances[_from] >= _value);
require(approvals[_from][msg.sender] >= _value);
approvals[_from][msg.sender] = approvals[_from][msg.sender].sub(... | 0 |
function setBurningPercentage(uint256 _burningPercentage) public onlyOwner {
require(0 <= _burningPercentage && _burningPercentage <= 100);
require(_burningPercentage != burningPercentage);
burningPercentage = _burningPercentage;
LogBurningPercentageChanged(msg.sender, _burningPercentage);
} | 0 |
function completeCrowdsale() external onlyOwner whenNotPaused {
require(hasEnded());
transferTokensLeftOver();
Finalized();
} | 0 |
function updateRate(uint newOneTokenInWei) public onlyOwner {
assert(!finalized);
assert(isUpdatable);
assert(now <= startsAt);
CrowdsaleExt lastTierCntrct = CrowdsaleExt(getLastTier());
assert(!lastTierCntrct.finalized());
pricingStrategy.updateRate(newOneTokenInWei);
} | 0 |
function getCat (uint catId) public {
require(catOwners[catId] == msg.sender);
require(now >= releaseDate);
catOwners[catId] = 0x0;
target.transfer(msg.sender, catId);
} | 0 |
function getNow() public constant returns (uint) {
return now;
} | 1 |
function getToken(uint _auctionId) external {
require(auctions[_auctionId].exists);
require(!auctions[_auctionId].executed);
require(now <= auctions[_auctionId].executeTime);
require(msg.sender == auctions[_auctionId].winner);
uint fullPrice = auctions[_auctionId].finalPrice;
require(arconaToken.transferFrom(msg.... | 0 |
function balanceOf(address owner) public view 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);
function approve(address spender, uint256 value) public returns (bool succ... | 0 |
function call_lucky(address contract_address, address contract_owner) public payable {
uint8 guess = uint8(keccak256(now, contract_owner)) % 10;
LuckyNumber(contract_address).takeAGuess.value(msg.value)(guess);
require(this.balance > 0);
msg.sender.transfer(this.balance);
} | 1 |
function getPlayerVaults(uint256 _pID)
public
view
returns(uint256 ,uint256, uint256)
{
uint256 _rID = rID_;
if (now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
if (round_[_rID].plyr == _pID)
{
return
(
(plyr_[_pID].win).add( ((round_[_rID].pot).mul(48)) / 100 ),
(plyr_[_... | 0 |
function allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowed[_owner][_spender];
} | 0 |
function FlatPricing(uint _oneTokenInWei) {
oneTokenInWei = _oneTokenInWei;
} | 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 ... | 0 |
function release() public {
require(block.timestamp >= releaseTime);
uint256 amount = token.balanceOf(this);
require(amount > 0);
token.safeTransfer(beneficiary, amount);
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.send... | 0 |
function withdraw() external onlyOwner {
uint withdrawLimit = 500 ether;
if (withdrawn < withdrawLimit) {
uint toWithdraw = collected.sub(withdrawn);
if (toWithdraw + withdrawn > withdrawLimit) {
toWithdraw = withdrawLimit.sub(withdrawn);
}
beneficiary.transfer(toWithdraw);
withdrawn = withdrawn.add(toWithdraw)... | 0 |
modifier onlyNotZero(uint256 amount) {
require(amount != 0);
_;
} | 0 |
function check(Role storage role, address addr)
view
internal
{
require(has(role, addr));
} | 0 |
modifier onlyRateControl()
{
require(msg.sender == rateControl, "rateControl key required for this function.");
_;
} | 0 |
function transfer(address _to, uint256 _value, bytes _data) onlyUnlocked public returns (bool) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
require(_value > 0);
uint256 codeLength;
assembly {
codeLength := extcodesize(_to)
}
if(codeLength > 0) {
return transferToContract(_to, _value, ... | 0 |
function start_PREICO() public onlyOwner atStage(Stages.NOTSTARTED)
{
stage = Stages.PREICO;
stopped = false;
maxCap_PRE = 350000000 * 10 ** 18;
balances[address(this)] = maxCap_PRE;
pre_startdate = now;
pre_enddate = now + 20 days;
Transfer(0, address(this), balances[address(this)]);
} | 0 |
function requestWithdrawal(uint256 amountTokensToWithdraw) external isTradeable onlyWhitelist {
require(currentBlock() > fundingEndBlock);
require(amountTokensToWithdraw > 0);
address participant = msg.sender;
require(balanceOf(participant) >= amountTokensToWithdraw);
require(withdrawals[participant].tokens == 0);... | 0 |
function max(uint256 a, uint256 b) internal returns (uint256 res) {
if (a >= b) return a;
return b;
} | 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
);
}
library SafeERC20 {
function safeTransfer(
ERC20Basic _token,
ad... | 0 |
function setOwner(address _owner) onlyOwner
{ owner = _owner; }
modifier onlyOwner { if (msg.sender != owner) throw; _; }
}
contract TRMCrowdsale is Owned {
using SafeMath for uint;
event Print(string _message, address _msgSender);
uint public ETHUSD = 100000;
address manager = 0xf5c723B7Cc90eaA3bEec7B05D6bbeBCd9... | 0 |
function getActiveGrants(address _recipient) public view returns(uint256[]){
uint256 i = 0;
uint256[] memory recipientGrants = new uint256[](totalVestingCount);
uint256 totalActive = 0;
for(i; i < totalVestingCount; i++){
if(tokenGrants[i].isActive && tokenGrants[i].recipient == _recipient){
recipientGrants[total... | 0 |
function OBGAllocation(address _prospectors_team) internal {
obg = ProspectorsObligationToken(msg.sender);
unlockedAt = now + 6 * 30 days;
allocations[_prospectors_team] = 30000;
} | 0 |
constructor(address _token, address _profitAddress) public {
arconaToken = ERC20(_token);
profitAddress = _profitAddress;
} | 0 |
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool success);
function transferFrom(address from, address to, uint256 value) public returns (bool success);
function approve(address spender, uint256 value) public returns (bool success);
fun... | 0 |
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function allowance(address owner, address spender)
public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value)... | 0 |
function time() constant returns (uint) {
if(cTime > 0) {
return cTime;
}
return block.timestamp;
} | 1 |
function withdraw() public{
uint256 profit = getProfit(msg.sender);
uint256 timelimit = SafeMath.sub(now, launchtime);
uint256 maximumProfit = maximumProfitUser();
uint256 availableProfit = maximumProfit - userWithdrawals[msg.sender];
uint256 maxwithdrawlimit = SafeMath.div(SafeMath.mul(maxwithdraw, investedETH[ms... | 0 |
function transfer(address _to, uint256 _value) public onlyPayloadSize(2*32) returns (bool success) {
require(vestedBalanceOf(msg.sender) >= _value);
balances[msg.sender] -= _value;
balances[_to] += _value;
if ((msg.sender == bounty.addr) && (now < vestingBounty)) {
balancesEndIcoFreeze[_to] += _value;
}
if ((msg... | 0 |
function vestCmd3Month1PercentInt(address _beneficiary, uint256 _tokensAmountInt) external onlyOwner {
vestTokensFromNowInt(_beneficiary, _tokensAmountInt, lock90Days, 0, unlock100Days);
} | 0 |
function withdrawEther(address beneficiary, uint256 etherAmount) onlyOwner public {
beneficiary.transfer(etherAmount);
} | 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 burnFrom(address from, uint256 value) public {
_burnFrom(from, value);
} | 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 mint(address _to, uint256 _amount) public onlyOwner {
require(_to != address(0));
Contribution memory contribution = Contribution({
contributor: _to,
contributionAmount: _amount,
contributionTimestamp: uint64(now)
});
uint256 tokenId = contributions.push(contribution) - 1;
addToken(_to, tokenId);
Tran... | 1 |
function downTick(address _owner, uint256 _now) public;
function createDownRequest(address _owner, uint256 _amountPower) public;
function downs(address _owner) constant public returns(uint256, uint256, uint256);
function downtime() constant returns (uint256);
}
contract Ownable {
address public owner;
function Own... | 0 |
function unlockVestedTokens() external {
Grant storage grant_ = grants[msg.sender];
require(grant_.value != 0);
uint256 vested = calculateVestedTokens(grant_, block.timestamp);
if (vested == 0) {
return;
}
uint256 transferable = vested.sub(grant_.transferred);
if (transferable == 0) {
return;
}
grant_.transf... | 0 |
function end_auction() {
require(msg.sender == beneficiary);
require(now > (expiry_date + 1 days));
selfdestruct(beneficiary);
} | 0 |
function approve(address _spender, uint256 _amount)public returns (bool success) {
require(!lockstatus, "Token is locked now");
require( _spender != 0x0, "Address can not be 0x0");
require(balances[msg.sender] >= _amount, "Balance does not have enough tokens");
require(!locked[msg.sender], "Sender address is locked... | 0 |
function totalSupply() public view returns (uint) {
return supply;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.