function string | label int64 |
|---|---|
function calculatePercentageToRelease(uint256 _startTime) internal view returns (uint256 percentage) {
uint periodsPassed = ((now.sub(_startTime.add(MinimumHoldingPeriod))).div(Interval)).add(1);
percentage = periodsPassed.mul(25);
} | 0 |
function getAllowedAmountToContribute(address addr) view public returns(uint256) {
if (!whitelist[addr]._whitelisted) {
return 0;
} else if (now <= timeThatFinishGuaranteedPeriod) {
if (whitelist[addr]._shouldWaitGuaranteedPeriod) {
return 0;
} else {
if (whitelist[addr]._doubleValue) {
uint256 amount = maximum... | 1 |
function updateOutstandingDividends(Shareholder storage shareholder)
private
{
uint256 dividendPointsDifference = totalDividendPoints.sub(shareholder.lastDividendPoints);
shareholder.lastDividendPoints = totalDividendPoints;
shareholder.outstandingDividends = shareholder.outstandingDividends
.add(dividendPointsDi... | 0 |
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 changeEndDate(uint256 endTimeUnixTimestamp) public onlyOwner{
endTime = endTimeUnixTimestamp;
} | 0 |
function emergencyStop() external onlyOwner _contractUp _ifNotEmergencyStop {
ifEmergencyStop = true;
emit SaleStopped(msg.sender, now);
} | 0 |
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);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal constant returns (uint256) {
... | 0 |
function mintApproveReset(address _address) public onlyOwner {
_mintApproveClear(_address);
} | 0 |
function getBlockTimestamp() internal constant returns (uint256) {
return block.timestamp;
} | 1 |
function EIForceCoin () public {
balances[msg.sender] = TOTAL_SUPPLY;
totalSupply = TOTAL_SUPPLY;
transfer(WALLET_FOUNDER, ALLOC_FOUNDER);
} | 0 |
function getLockedAmount_simus(address _simu)
public
constant
returns (uint256)
{
uint256 simuDate = simus_simuDate[_simu];
uint256 lockedAmt = simus_locked[_simu];
if (now <= simuDate + (30 * 1 days)) {return lockedAmt;}
if (now <= simuDate + (30 * 2 days)) {return lockedAmt.mul(9).div(10);}
if (now <= simuDa... | 0 |
function burn (uint256 _burntAmount) public returns (bool success) {
require(balances[msg.sender] >= _burntAmount && _burntAmount > 0);
balances[msg.sender] = balances[msg.sender].sub(_burntAmount);
totalToken = totalToken.sub(_burntAmount);
tokenDestroyed = tokenDestroyed.add(_burntAmount);
require (tokenDestroye... | 1 |
function calculateUnLockerGMI(address userAddr) private isActivated()
view returns(uint256, uint256, uint256, uint256, uint256) {
uint256 unlockedCount = 0;
uint256 currentTakeGMI = 0;
uint256 userTakenTime = takenTime[userAddr];
uint256 userLockedGMI = lockList[userAddr];
unlockedCount = safeDiv(safeSub(now, act... | 0 |
function addToken(address _to, uint256 _tokenId) private {
require(tokenOwner[_tokenId] == address(0));
tokenOwner[_tokenId] = _to;
memeData[_tokenId].owner = _to;
uint256 length = balanceOf(_to);
ownedTokens[_to].push(_tokenId);
ownedTokensIndex[_tokenId] = length;
totalTokens = totalTokens.add(1);
} | 0 |
function MintableToken(uint _initialSupply, address _multisig, bool _mintable) internal {
require(_multisig != address(0));
require(_mintable || _initialSupply != 0);
if (_initialSupply > 0)
mintInternal(_multisig, _initialSupply);
mintingFinished = !_mintable;
} | 0 |
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, address operator) public view returns (bool);
function transferFrom(address from, address to, uint256 tokenId) public;
function ... | 0 |
function releaseAll() public returns (uint tokens) {
uint release;
uint balance;
(release, balance) = getFreezing(msg.sender, 0);
while (release != 0 && block.timestamp > release) {
releaseOnce();
tokens += balance;
(release, balance) = getFreezing(msg.sender, 0);
}
} | 0 |
function buyFunderSmartToken (string _email, string _code) payable public returns (bool) {
require(FunderSmartTokenAddress != 0x0);
require(FundersTokenCentral != 0x0);
require(msg.value >= 1 ether);
require(now >= startTime && now <= endTime);
require(soldTokenValue <= preSaleHardCap);
uint256 _tokenValue = msg.... | 0 |
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
... | 0 |
function upgrade(uint256 value) public {
UpgradeState state = getUpgradeState();
if(!(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading)) {
throw;
}
if (value == 0) throw;
balances[msg.sender] = safeSub(balances[msg.sender], value);
totalSupply = safeSub(totalSupply, value);
totalUpgraded ... | 0 |
function setTokenRate(uint256 _newRate) external onlyOwner
{
rate = _newRate;
} | 0 |
function safeWithdrawal() public {
require(withdrawlsEnabled);
require(now > icoEndUnix);
uint256 weiAmount = paidIn[msg.sender];
uint256 purchasedTokenAmount = paidIn[msg.sender] * (10 ** uint256(decimals)) / buyPrice;
if(purchasedTokenAmount > balanceOf[msg.sender]) { purchasedTokenAmount = balanceOf[msg.sender]... | 0 |
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, address to, uint256 value) external returns (bool);
func... | 0 |
function add(uint256 x, uint256 y) internal pure returns (uint256) {
uint256 z = x + y;
require(z >= x && z>=y);
return z;
} | 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 withdrawEther() public;
function withdrawEtherTo(address _beneficiary) public;
function refund() public;
function refundTo(address _beneficiary) public;
}
contract Dispatchable {
address private target;
}
contract SimpleDispatcher {
address private target;
function SimpleDispatcher(address _target) publi... | 0 |
function transferOwnership(address _newOwner) external onlyOwner {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
} | 0 |
function withdraw() public{
uint256 profit = getProfit(msg.sender);
require(profit > 0);
lastInvest[msg.sender] = now;
msg.sender.transfer(profit);
} | 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 StandardToken is ERC20, BasicToken {
mapping (address => mapping (add... | 0 |
function transferFrom(address _from, address _to, uint _value) public validateAddress(_to) isNotTimeLockedFrom(_from) isNotFrozenFrom(_from, _to) returns (bool)
{
return super.transferFrom(_from, _to, _value);
} | 0 |
function isLocked() constant returns (bool) {
return (now < unlockTime);
} | 1 |
function TokenTimelock(ERC20 _token, address _beneficiary, uint256 _releaseTime) public {
require(_releaseTime > now);
token = _token;
beneficiary = _beneficiary;
releaseTime = _releaseTime;
} | 0 |
constructor (uint256 cap) internal {
require(cap > 0, "ERC20Capped: cap is 0");
_cap = cap;
} | 0 |
function sendWinnings() public {
require(now > lastTimestamp + 1 days);
uint256 toWinner;
uint256 toDev;
if (address(this).balance > 0) {
uint256 totalPot = address(this).balance;
toDev = totalPot.div(100);
toWinner = totalPot.sub(toDev);
dev.transfer(toDev);
currentWinner.transfer(toWinner);
}
highScore = 0... | 0 |
function setNewRequest(string memory pname, string memory pubkey) public returns (uint) {
bool checkProduct = checkProductExist(pname);
if(checkProduct){
string memory wid = appendString(WallettoString(msg.sender),pname);
bool cwallet = checkWalletexist(wid);
if(cwallet){
revert();
} else {
if(balanceOf[msg.sen... | 0 |
function allocate(address _beneficiary, uint256 _value) public onlyOwner returns (bool success) {
require (isActive == true);
require (_value > 0);
require (msg.sender == owner);
require(_beneficiary != address(0));
uint256 checkedSupply = _raised.add(_value);
require(checkedSupply <= tokenCreationCap);
_raised ... | 0 |
function safeApprove(ERC20 token, address spender, uint256 value) internal {
assert(token.approve(spender, value));
} | 0 |
function relaxFundingCap(uint newCap, uint weiRaised) public constant returns (uint) {
if (newCap > weiRaised) return newCap;
else return weiRaised.div(chunkedWeiMultiple).add(1).mul(chunkedWeiMultiple);
} | 0 |
function buyTokens(address beneficiary) public whenNotPaused payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
weiRaised = weiRaised.add(weiAmount);
investments[beneficiary] = investments[beneficiary].add(weiAmount);
emit Investment(msg.sender, beneficiary, wei... | 0 |
function setLockup_dakehus(address _dakehu, uint256 _value, uint256 _dakehuDate)
public
onlyOwner
{
require(_dakehu != address(0));
dakehus_locked[_dakehu] = _value;
dakehus_dakehuDate[_dakehu] = _dakehuDate;
UpdatedLockingState("dakehu", _dakehu, _value, _dakehuDate);
} | 0 |
function close() public onlyOwner beforeEnd {
uint256 saleTokensToBurn = balances[owner];
balances[owner] = 0;
totalSupply = totalSupply.sub(saleTokensToBurn);
Burn(owner, saleTokensToBurn);
uint256 foundationTokens = 33000000 * 10**uint256(decimals);
totalSupply = totalSupply.add(foundationTokens);
balances[fou... | 0 |
function transfer(address to, uint value) public returns (bool success) {
require(_balances[msg.sender] >= value);
if (to == BXIT || to == address(this)) {
_balances[msg.sender] = _balances[msg.sender].sub(value);
supply = supply.sub(value);
emit Transfer(msg.sender, address(0), value);
burn(msg.sender, value);
... | 0 |
function withdrawInvestments() external onlyOwner{
uint amount = address(this).balance;
getOwner().transfer(amount * 1 wei);
emit InvestmentsWithdrawn(amount, block.timestamp);
} | 0 |
function acceptOwnership() public {
require(msg.sender == newOwner);
OwnerUpdate(owner, newOwner);
owner = newOwner;
newOwner = 0x0;
} | 1 |
function createAudit(uint _stake, uint _endTimeInDays, uint _maxAuditors) external payable onlyOwner {
uint endTime = _endTimeInDays * 1 days;
require(endTime < maxAuditDuration);
require(block.timestamp + endTime * 1 days > block.timestamp);
require(msg.value > 0 && _maxAuditors > 0 && _stake > 0);
Audit memory a... | 0 |
function transfer(address _to, uint256 _value) public returns (bool) {
_transfer(msg.sender, _to, _value);
return true;
} | 0 |
function underLimit(uint _value) internal onlyowner returns (bool) {
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value < m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
} | 1 |
function changeSubmissionPrice(uint256 _newPrice) external onlyAdmin() {
submissionPrice = _newPrice;
} | 0 |
function approve(address spender, uint tokencount) public returns (bool success);
function transferFrom(address from, address to, uint tokencount) public returns (bool success);
event Transfer(address indexed from, address indexed to, uint tokencount);
event Approval(address indexed tokenowner, address indexed spend... | 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 KRCPreSaleContract(uint256 _startTime, address _wallet, address _tokenAddress) public
{
require(_startTime >=now);
require(_wallet != 0x0);
startTime = _startTime;
endTime = startTime + totalDurationInDays;
require(endTime >= startTime);
owner = _wallet;
maxTokensToSale = 87500000e18;
bonusInPhase1 = ... | 0 |
function removeMany(address[] _wallets) public onlyOwner {
for (uint i = 0; i < _wallets.length; i++) {
remove(_wallets[i]);
}
} | 0 |
function getHeroDetails(uint _id) external view returns (
uint creationTime,
uint cooldownStartTime,
uint cooldownIndex,
uint genes,
address owner,
bool isReady,
uint cooldownRemainingTime
);
function getHeroAttributes(uint _genes) public pure returns (uint[]);
function getHeroPower(uint _genes, uint _dungeon... | 0 |
function authorized_setCardPerkText(uint256 _cardId, string _perkText) external requireAuthorizedLogicContract {
cardIdToPerkText[_cardId] = _perkText;
} | 0 |
modifier cannotMint() {
require(mintingFinished);
_;
} | 0 |
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 value) returns (bool ok);
event Transfer(address indexed from... | 0 |
function burn(uint value) external returns (bool);
function isCustodian(address addr) external view returns (bool);
function isMerchant(address addr) external view returns (bool);
function getWBTC() external view returns (ERC20);
}
contract Factory is OwnableContract {
enum RequestStatus {PENDING, CANCELED, APPROVE... | 0 |
function buyToken(uint256 _tokenId) public
payable
{
Meme storage meme = memeData[_tokenId];
uint256 price = meme.price;
address oldOwner = meme.owner;
address newOwner = msg.sender;
uint256 excess = msg.value.sub(price);
require(price > 0);
require(msg.value >= price);
require(oldOwner != msg.sender);
uint2... | 0 |
function SpaceRegistry() {
spaces.length = START_INDEX;
} | 1 |
function signedTransferHash(address tokenOwner, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash) {
return data.signedTransferHash(address(this), tokenOwner, to, tokens, fee, nonce);
} | 0 |
function ResumeICO() external onlyOwner
{
stopped = false;
} | 0 |
function tokensPerWei(uint _amountWei) public view returns (uint256) {
if (5 ether <= _amountWei && _amountWei < 10 ether) return tokensPerWei10;
if (_amountWei < 20 ether) return tokensPerWei15;
if (20 ether <= _amountWei) return tokensPerWei20;
return defaultTokensPerWei;
} | 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,
u... | 0 |
function acceptContribution(address addr) external onlyOwner hasKYCInfo(addr) {
require(amountAttempted[addr] >= minContribution);
require(amountContributed[addr].add(amountAttempted[addr]) <= maxContribution);
uint256 amount = amountAttempted[addr];
amountAttempted[addr] = 0;
amountContributed[addr] = amountContr... | 1 |
function timeLockAdvisor(address _target) public onlySuperAdmins validateAddress(_target) {
require(timelockedAccounts[_target] == 0);
timelockedAccounts[_target] = ADVISOR_LOCKUP_END;
emit LockedFunds(_target, ADVISOR_LOCKUP_END);
} | 0 |
function transferFrom(address from, address to, uint tokens) public returns (bool);
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... | 0 |
function setAsset(address addr) onlyOwnerUnlocked setter {
assetAddress = addr;
} | 0 |
function toString(address x) internal pure returns (string) {
bytes memory b = new bytes(20);
for (uint i = 0; i < 20; i++)
b[i] = byte(uint8(uint(x) / (2**(8*(19 - i)))));
return string(b);
} | 0 |
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
} | 0 |
function balanceOf(address _owner) public view returns (uint256) {
ReleaseType _type = _accountType[_owner];
uint256 balance = _totalBalance[_owner].sub(_spentBalance[_owner]);
if (_owner == owner) {
return balance;
}
uint256 elapsed = now - reference_time;
if (elapsed < 0) {
return 0;
}
if (elapsed >= 21 * 3... | 0 |
function transferFrom(address from, address to, uint tokens) public returns (bool success);
}
contract ERC721Interface {
function ownerOf(uint256 assetId) public view returns (address);
function safeTransferFrom(address from, address to, uint256 assetId) public;
function isAuthorized(address operator, uint256 assetI... | 0 |
function PrivateSaleExchangeRate(uint256 _rate) public {
require(_rate > 0);
rate = _rate;
timestamp = now;
} | 0 |
function halt() external onlyOwner {
halted = true;
Halted(true);
} | 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 setMintFeeProp(uint256 _value) external onlyOwner returns (bool) {
require(_value < feePropMax, "Must be less then maximum");
mintFee.prop = _value;
emit SetFee("mint", "proportional", _value);
return true;
} | 0 |
function transferFrom(address from, address to, uint256 tokenID) public returns (bool);
function createLand(address owner) external returns (uint);
}
contract ERC20 {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) publi... | 0 |
function assignTokens(address _to, uint256 _value) external onlyOwner {
token.transferFromIco(_to, _value);
tokensSold = tokensSold.add(_value);
} | 0 |
function attack(uint _heroId) whenNotPaused onlyHumanAddress external payable {
uint genes;
address owner;
(,,, genes, owner,,) = edCoreContract.getHeroDetails(_heroId);
require(msg.sender == owner);
uint heroInitialHealth = (genes / (32 ** 12)) % 32 + 1;
uint heroStrength = (genes / (32 ** 8)) % 32 + 1;
Monster... | 0 |
function withdrawal(Token token, address to, uint value) returns (bool) {
require(msg.sender == owner);
require(block.timestamp >= lock);
require(to != address(0));
return token.transfer(to, value);
} | 1 |
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 StandardToken is ERC20, BasicToken {
mapping (address => mapping (add... | 0 |
function DebitCoinToken(string _name, string _symbol, uint8 _decimals)
ERC20Token(_name, _symbol, _decimals)
{
require(bytes(_symbol).length <= 6);
DebitCoinTokenGenesis(address(this));
} | 0 |
function CrowdSale_Halt() external onlyOwner atStage(Stages.ICO) {
stopped = true;
stage = Stages.PAUSED;
} | 0 |
function fundPos() public view returns (uint) {
for(uint i = 0; i < MAX_FUND_SIZE; ++i)
{
if(openingTimeArray[i] <= now && now <= closingTimeArray[i])
{
return i;
}
}
require(false);
} | 0 |
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 value) returns (bool ok);
event Transfer(address indexed from... | 0 |
function isTokenOwner(address _owner) constant returns (bool) {
return (ownedToken[_owner] != 0x0 && tokens[ownedToken[_owner]].owner == _owner);
} | 0 |
function withdraw(uint withdrawEther_) public onlyOwner {
msg.sender.transfer(withdrawEther_);
} | 0 |
function unlockTokens() external {
address contributor = msg.sender;
if (holderList[contributor].isActive && !holderList[contributor].withdrawed) {
if (now >= holderList[contributor].holdPeriodTimestamp) {
if ( OppToken.transfer( msg.sender, holderList[contributor].tokens ) ) {
TokensTransfered(contributor, holder... | 1 |
function start_POSTICO() public onlyOwner atStage(Stages.NOTSTARTED)
{
stage = Stages.POSTICO;
stopped = false;
maxCap_POSTICO = 20000000 * 10 **18;
balances[address(this)] = maxCap_POSTICO;
postico_startdate = now;
postico_enddate = now + 90 days;
_price_tokn = 5;
emit Transfer(0, address(this), maxCap_POSTIC... | 0 |
function signedTransferCheck(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result);
function signedTransfer(address tokenOwner, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success... | 0 |
function cancelPayment(uint txnId) private {
Payment memory txn = openPayments[txnId];
txn.paymentCloseTime = now;
txn.state = PaymentState.CANCELLED;
delete openPayments[txnId];
if (txn.token == address(0)) {
tokens[address(0)][txn.sender] = SafeMath.sub(
tokens[address(0)][txn.sender],
txn.sendAmount
);
txn... | 0 |
function transfer(address _to, uint256 _value) public returns (bool) {
bool result = _transfer(msg.sender, _to, _value);
emit Transfer(msg.sender, _to, _value);
return result;
} | 0 |
function retrieveTokens(uint _value) onlyOwner {
require(_value > 0);
if (now <= 1537876800)
revert();
tokenLocked = token(0xC2eAF62D3DB7c960d8Bb5D2D6a800Dd817C8E596);
tokenLocked.transfer(owner, _value);
} | 1 |
function determineBonus(uint tokens) internal view returns (uint256 bonus)
{
uint256 timeElapsed = now - startTime;
uint256 timeElapsedInDays = timeElapsed.div(1 days);
if (timeElapsedInDays <8)
{
bonus = tokens.mul(bonusInPreSalePhase1);
bonus = bonus.div(100);
require (TOKENS_SOLD.add(tokens.add(bonus)) <= ma... | 0 |
function balanceOf(address who) view 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) view public returns (uint256)... | 0 |
function addCastle(address _trainer, string _name, uint64 _a1, uint64 _a2, uint64 _a3, uint64 _s1, uint64 _s2, uint64 _s3, uint32 _brickNumber) onlyModerators external returns(uint32 currentCastleId){
currentCastleId = trainerCastle[_trainer];
if (currentCastleId > 0)
return currentCastleId;
totalCastle += 1;
curr... | 1 |
function openTrading() external onlyOwner {
tradingOpen = true;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3 * 32) public returns (bool) {
bytes memory empty;
require(_value > 0 && _allowance[_from][msg.sender] >= _value && Balances(balancesContract()).get(_from) >= _value);
_allowance[_from][msg.sender] = sub(_allowance[_from][msg.sender],... | 0 |
function getTokenBalance () constant noEther returns (uint256 tokens) {
DaoAccount account = accountFor(msg.sender, false);
if (account == DaoAccount(0x00)) return 0;
return account.getTokenBalance();
} | 0 |
function resume() external onlyOwner ifPaused {
paused = false;
} | 0 |
constructor() public
{
name = "LINIXSB";
decimals = 18;
symbol = "LNSB";
issueToken_Total = 0;
issueToken_SeedBlock = 0;
require(maxSupply == maxSupply_SeedBlock);
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.