function string | label int64 |
|---|---|
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 C20(address controlWalletInput, uint256 priceNumeratorInput, uint256 startBlockInput, uint256 endBlockInput) {
require(controlWalletInput != address(0));
require(priceNumeratorInput > 0);
require(endBlockInput > startBlockInput);
fundWallet = msg.sender;
controlWallet = controlWalletInput;
whitelist[fund... | 0 |
function getNextPrice(bytes32) external view returns (uint) {
return commBallotPriceWei;
} | 0 |
function tokenFallback(address _from, uint _value, bytes _data) public {
emit Invoked(_from, _value, _data);
} | 0 |
function getUnit() external view returns(string);
function getRate() external view returns(uint256);
function getLastTimeUpdated() external view returns(uint256);
}
pragma solidity 0.4.24;
interface ReadableI {
function peek() external view returns(bytes32, bool);
function read() external view returns(bytes32);
}
l... | 0 |
function calculateTop5HeroesPower(address _address, uint _dungeonId) public view returns (uint);
}
contract DungeonRunCore is Pausable, Destructible {
struct Monster {
uint64 creationTime;
uint8 level;
uint16 initialHealth;
uint16 health;
} | 0 |
function changeCommissionFee(uint256 _fee) public onlyOwner {
commissionFee = _fee;
emit LogChangeCommissionFee(_fee);
} | 0 |
function TransferTokens(address _to, uint _amount) {
require(msg.sender == beneficiary || msg.sender == cobeneficiary);
token.transfer(_to, _amount);
} | 0 |
function newRCAI(bytes32 info_concealed, bytes32 client_full, bytes32 address_full, address declared_for, uint status) public {
emit RCAI(info_concealed, client_full, address_full, msg.sender, declared_for, status, block.timestamp, block.number);
} | 0 |
function transfer(address _to, uint256 _amount) returns (bool success) {
if (!DCAssetBackend(backendContract).transfer(msg.sender, _to, _amount)) throw;
Transfer(msg.sender, _to, _amount);
return true;
} | 0 |
function transferEthFromContract(address _to, uint256 amount) public onlyOwner
{
_to.transfer(amount);
} | 0 |
function placeBet(bytes32 horse) external duringBetting payable {
require(msg.value >= 0.01 ether);
if (voterIndex[msg.sender].total_bet==0) {
total_bettors+=1;
}
uint _newAmount = voterIndex[msg.sender].bets[horse] + msg.value;
voterIndex[msg.sender].bets[horse] = _newAmount;
voterIndex[msg.sender].total_bet +=... | 0 |
function validate(address currency, uint256 amount) external onlyHotWallet returns (bool) {
assert(approved[currency] >= amount);
approved[currency] -= amount;
return true;
} | 0 |
function isAuthorized(address logger) returns (bool) {
return authorizedLoggers[logger];
} | 1 |
function balanceOf(address accountAddr) public constant returns (uint256 balance) {
return balances[accountAddr];
} | 0 |
function disallowTransfersTo(address _owner) onlyOwner {
allowedTransfersTo[_owner] = false;
} | 0 |
function registerNameXID(string _nameString, uint256 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all... | 0 |
function _forwardFunds() internal {
wallet.transfer(msg.value);
} | 0 |
function changeMintingAddress(address newAddress) onlyOwner returns (bool success) {
minter_address = newAddress;
return true;
} | 0 |
function Play() public payable protect protect_mining {
require(msg.value <= getMaxBet());
if (now % magic != 0) {
msg.sender.transfer(msg.value + msg.value/magic);
}
last_blocknumber = block.number;
} | 1 |
function extractAccountAllowanceRecordLength(address addr) constant returns (uint256 len) {
return allowanceIndex[addr].length;
} | 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 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
} | 0 |
function claimBeer() payable {
require(msg.value == .015 ether);
balances[msg.sender] += 1;
totalSupply += 1;
require(totalSupply <= maxSupply);
RECIPIENT.transfer(msg.value);
Transfer(address(0), msg.sender, 1);
LogBeerBought(now, msg.sender);
} | 1 |
function totalSupply() public view returns (uint);
function balanceOf(address tokenOwner) public view returns (uint balance);
function allowance(address tokenOwner, address spender) public view returns (uint remaining);
function transfer(address to, uint tokens) public returns (bool success);
function approve(addre... | 0 |
function max256(uint a, uint b) internal constant returns (uint) {
return a >= b ? a : b;
} | 0 |
function transfer(address _to, uint256 _value) public {
_transfer(msg.sender, _to, _value);
} | 0 |
function unlock() external {
require(REB != address(0));
assert(now >= unlockedAt);
if (tokensCreated == 0) {
tokensCreated = REB.balanceOf(this);
}
uint256 transferAllocation = lockedAllocations[msg.sender];
lockedAllocations[msg.sender] = 0;
require(REB.transfer(msg.sender, transferAllocation));
} | 0 |
function refund() external {
if (!funding) throw;
if (block.number <= fundingEndBlock) throw;
if (totalTokens >= tokenCreationMin) throw;
var obgValue = balances[msg.sender];
if (obgValue == 0) throw;
balances[msg.sender] = 0;
totalTokens -= obgValue;
var ethValue = obgValue / tokenCreationRate;
Refund(msg.sen... | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return ... | 0 |
function allowance(address owner, address spender) public constant returns (uint);
function transferFrom(address from, address to, uint value) public returns (bool ok);
function approve(address spender, uint value) public returns (bool ok);
event Approval(address indexed owner, address indexed spender, uint value);
... | 0 |
function safeSub(uint a, uint b) pure internal returns (uint) {
assert(b <= a);
return a - b;
} | 0 |
function boughtToday(address beneficiary) external view returns (uint) {
return statsByDay[currentDay()-1].fuelBoughtByAddress[beneficiary];
} | 0 |
function totalSupply() public view returns (uint);
function balanceOf(address _owner) public view returns (uint);
function transfer(address _to, uint _value) public returns (bool);
function transferFrom(address _from, address _to, uint _value) public returns (bool);
function approve(address _spender, uint _value) p... | 0 |
function balanceOf(address _address) public constant returns (uint256 balance);
function vestedBalanceOf(address _address) public constant returns (uint256 balance);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
function transfer(address _to, uint256 _value) public... | 0 |
function transferFrom(address _from, address _to, uint _value) public returns (bool)
{
require(isTransferable() == true);
require(balances[_from] >= _value);
require(approvals[_from][msg.sender] >= _value);
approvals[_from][msg.sender] = approvals[_from][msg.sender].sub(_value);
balances[_from] = balances[_from].... | 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 |
modifier canTrade() {
require(tradable);
_;
} | 0 |
function buyTokens() public payable whenNotPaused {
require(validPurchase());
uint256 tokens = 0;
uint256 amountPaid = calculateExcessBalance();
if(tokensRaised < limitTier1) {
tokens = amountPaid.mul(rate);
if(tokensRaised.add(tokens) > limitTier1)
tokens = calculateExcessTokens(amountPaid, limitTier1, 1, rate)... | 0 |
constructor (address beneficiary, uint256 start, uint256 cliffDuration, uint256 duration, bool revocable) public {
require(beneficiary != address(0));
require(cliffDuration <= duration);
require(duration > 0);
require(start.add(duration) > block.timestamp);
_beneficiary = beneficiary;
_revocable = revocable;
_du... | 0 |
function upgradeFrom(address _tokenHolder, uint256 _amount) external;
}
contract UpgradeableToken is StandardToken {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(addres... | 0 |
function BuyRTCtokens() public payable {
require(!(msg.value == 0)
&& (isCrowdSaleSetup)
&& (now >= fundingStartTime)
&& (now <= fundingEndTime)
&& (tokensRemaining > 0));
if (now <= p1_start) {
assert(isWhitelisted(msg.sender));
}
uint256 rewardTransferAmount = 0;
uint256 rewardBaseTransferAmount = 0;
uint2... | 0 |
function earningsOf(address _addr) public constant returns (uint256) {
uint256 total = 0;
uint256 interest = vault.contributionsOf(_addr).mul(833).div(10000);
for (uint8 i = 0; i < payoutDates.length; i++) {
if (now < payoutDates[i]) {
break;
}
total = total.add(interest);
}
total = total.sub(withdrawals[_addr... | 1 |
function burn(uint256 _value) external;
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Burn(address indexed burner, uint256 value);
}
contract KRCICOContract is Ownable{
using SafeMath for uint256;
Toke... | 0 |
function kill() {
if (msg.sender == owner)
selfdestruct(owner);
} | 0 |
function SicBo (address drawer_) public {
Drawer = drawer_;
} | 0 |
function ownerOf(uint256 tokenId) public view returns (address owner);
function approve(address to, uint256 tokenId) public;
function getApproved(uint256 tokenId) public view returns (address operator);
function setApprovalForAll(address operator, bool _approved) public;
function isApprovedForAll(address owner, add... | 0 |
function addTransaction(address _investor, uint256 _amount) internal returns (uint256) {
uint256 transactionId = transactionCount;
transactions[transactionId] = Deposit({
amount: _amount,
beneficiary: _investor,
time: uint64(now),
cleared : false
});
addressTransactions[_investor].push(transactionId);
transact... | 1 |
function TimedCrowdsale(uint256 _openingTime, uint256 _closingTime) public {
require(_openingTime >= block.timestamp);
require(_closingTime >= _openingTime);
openingTime = _openingTime;
closingTime = _closingTime;
} | 0 |
function transfer(address to, uint256 value) returns (bool);
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) returns ... | 0 |
function setUpgradeAgent(address agent) external {
require(agent != 0x0 && msg.sender == upgradeMaster);
assert(canUpgrade());
upgradeAgent = UpgradeAgent(agent);
assert(upgradeAgent.isUpgradeAgent());
assert(upgradeAgent.originalSupply() == totalSupply);
UpgradeAgentSet(upgradeAgent);
} | 0 |
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}
contract IERC721Receiver {
function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
public returns (bytes4);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure ret... | 0 |
function burnToken(uint _value) onlyOwner public
{
uint tokens = _value * E18;
require(balances[msg.sender] >= tokens);
balances[msg.sender] = balances[msg.sender].sub(tokens);
burnTokenSupply = burnTokenSupply.add(tokens);
totalTokenSupply = totalTokenSupply.sub(tokens);
emit Burn(msg.sender, tokens);
} | 0 |
modifier inState(State state) {
require(getState() == state);
_;
} | 0 |
function claimOwnerSupply() onlyOwner {
if (now < ownerTokensFreeDay) throw;
if (remainingOwner == 0) throw;
if (!remaindersSet) throw;
balanceOf[owner] = safeAdd(balanceOf[owner], remainingOwner);
remainingOwner = 0;
} | 1 |
modifier checkAuthorizedUser() {
require(msg.sender == owner || msg.sender == depositor || msg.sender == beneficiary, "Only authorized users may call this function.");
_;
} | 0 |
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 (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, ... | 0 |
function div(uint a, uint b) internal pure returns (uint c) {
require(b > 0);
c = a / b;
} | 0 |
function withdrawal(address _wallet) external onlyOwner whenSaleHasEnded {
require(_wallet != address(0));
_wallet.transfer(this.balance);
token.transferOwnership(msg.sender);
} | 0 |
function transfer(address _to, uint _value) public returns (bool success) {
require(_to != address(0));
require(now >= endOfFreeze || msg.sender == owner);
require(balances[msg.sender] >= _value);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.send... | 0 |
function transferFrom(address _from, address _to, uint256 _value) returns (bool) {
uint256 _allowance = allowed[_from][msg.sender];
balances[_from] = balances[_from].sub(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(_from, _to, _value);
return tr... | 0 |
function getHeroPower(uint _genes, uint _dungeonDifficulty) public pure returns (
uint totalPower,
uint equipmentPower,
uint statsPower,
bool isSuper,
uint superRank,
uint superBoost
);
function getDungeonPower(uint _genes) public pure returns (uint);
function calculateTop5HeroesPower(address _address, uint _d... | 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 setPrices(uint256 newBuyPrice) public {
if (msg.sender == Owner) {BuyPrice = newBuyPrice;}
} | 0 |
function _sell(address _from, uint256 _tokenId, uint256 value) internal {
if(jockeyIndexForSale[_tokenId]==true){
uint256 price = jockeyIndexPrice[_tokenId];
require(price<=value);
uint256 Fee = price / saleFee;
uint256 oPrice= price - Fee;
address _to = msg.sender;
tokenOwnershipCount[_to]++;
jockeyOwnerIndex[... | 1 |
function transferAnyERC20Token(address tokenAddress, uint tokens) public returns (bool success) {
return data.transferAnyERC20Token(tokenAddress, tokens);
} | 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);
function mint(address _owner, uint256 _amount) returns (bool ... | 0 |
function addVesting(address _beneficiary, uint256 _releaseTime, uint256 _amount) public onlyOwner {
require(_beneficiary != address(0x0), INVALID_BENEFICIARY);
tokensToVest = tokensToVest.add(_amount);
vestingId = vestingId.add(1);
vestings[vestingId] = Vesting({
beneficiary: _beneficiary,
releaseTime: _releaseTi... | 0 |
function claimFreeDragon() public{
require(initialized);
require(hatchery[msg.sender] == 0);
lastHatch[msg.sender] = now;
hatchery[msg.sender] = 300;
} | 0 |
function nameFor(address addr) constant returns (bytes32 name) {
return Trust(trustAddress).nameFor(addr);
} | 0 |
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
} | 0 |
function subApproval(address spender, uint subtractedValue) public returns (bool success) {
uint oldVal = allowed[msg.sender][spender];
if (subtractedValue > oldVal) {
allowed[msg.sender][spender] = 0;
} else {
allowed[msg.sender][spender] = oldVal.sub(subtractedValue);
}
Approval(msg.sender, spender, allowed[ms... | 0 |
function getLockedAmount_investors(address _investor)
public
constant
returns (uint256)
{
uint256 delieveryDate = investors_deliveryDate[_investor];
uint256 lockedAmt = investors_locked[_investor];
if (now <= delieveryDate) {return lockedAmt;}
if (now <= delieveryDate + 90 days) {return lockedAmt.mul(2).div(3);... | 0 |
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3) 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);
allo... | 0 |
function updateRoleManager(address newManagerAddr)
inUpdateWindow()
public
returns (bool) {
require(roleManager.passedContract(newManagerAddr));
roleManagerAddress = newManagerAddr;
roleManager = IMultiSigManager(roleManagerAddress);
require(roleManager.moderator() != address(0));
emit UpdateRoleManager(newMana... | 0 |
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address w... | 0 |
function cancelMintRequest(bytes32 requestHash) external onlyMerchant returns (bool) {
uint nonce;
Request memory request;
(nonce, request) = getPendingMintRequest(requestHash);
require(msg.sender == request.requester, "cancel sender is different than pending request initiator");
mintRequests[nonce].status = Reque... | 0 |
function releaseTokens() public onlyManager() hasntStopped() whenCrowdsaleSuccessful();
function stop() public onlyManager() hasntStopped();
function start(uint256 _startTimestamp, uint256 _endTimestamp, address _fundingAddress)
public onlyManager() hasntStarted() hasntStopped();
function isFailed() public constant... | 0 |
function yes(address _address, uint _votes) public onlyOwner {
require(inProgress());
require(lastVoting[_address] < currentVoting);
require(_votes > 0);
lastVoting[_address] = currentVoting;
votes[_address] = int(_votes);
votesYes = safeAdd(votesYes, _votes);
emit Vote(_address, int(_votes));
} | 0 |
constructor ()
public
{
owner = msg.sender;
} | 0 |
function allowance(address _owner, address _spender)public view returns (uint256 remaining) {
return allowed[_owner][_spender];
} | 0 |
function extractAccountLength() constant returns (uint256 length) {
return accountIndex.length;
} | 0 |
function hodl(address _beneficiary, uint256 _id, uint256 _value, uint256 _months) external {
require(_beneficiary != address(0));
require(_id > 0);
address _creator = msg.sender;
Item storage item = items[_creator][_id];
require(item.id != _id);
items[_creator][_id] = Item(_id, _creator, _beneficiary, false);
pu... | 0 |
function isUpgradeAgent() public pure returns (bool) {
return true;
} | 0 |
function refund() external {
require((now > saleStopTimestamp) && (totalCollected < CrowdsaleParameters.minimumICOCap * 1e18));
require(investmentRecords[msg.sender] > 0);
var amountToReturn = investmentRecords[msg.sender];
require(this.balance >= amountToReturn);
investmentRecords[msg.sender] = 0;
msg.sender.tra... | 0 |
function _mint(address account, uint256 value) internal {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply = _totalSupply.add(value);
_balances[account] = _balances[account].add(value);
emit Transfer(address(0), account, value);
} | 0 |
function makeDeposit() private {
if (msg.value > 0) {
if (userDeposit[msg.sender] == 0) {
countOfInvestors += 1;
}
if (userDeposit[msg.sender] > 0 && now > userTime[msg.sender].add(chargingTime)) {
collectPercent();
}
userDeposit[msg.sender] = userDeposit[msg.sender].add(msg.value);
userTime[msg.sender] = now;... | 0 |
function withdrawEther() public;
}
contract PersonalCrowdsaleProxy is IPersonalCrowdsaleProxy, Dispatchable {
ICrowdsale public targetCrowdsale;
IToken public targetToken;
address public beneficiary;
bytes32 private passphraseHash;
modifier when_beneficiary_is_known() {
require(beneficiary != address(0));
_;
} | 0 |
function getTime() internal returns (uint256) {
return now;
} | 1 |
function getDungeonFloorDetails(uint _id) external view returns (
uint floorNumber,
uint floorCreationTime,
uint rewards,
uint seedGenes,
uint floorGenes
);
function getHeroDetails(uint _id) external view returns (
uint creationTime,
uint cooldownStartTime,
uint cooldownIndex,
uint genes,
address owner,
bo... | 0 |
function transfer( address _to, uint _value) public returns (bool _success);
function approve( address _spender, uint _value ) public returns (bool _success);
function allowance( address _owner, address _spender ) public view returns (uint _allowance);
function transferFrom( address _from, address _to, uint _value) ... | 0 |
function balanceOf( address _who ) public view returns (uint _value);
function transfer( address _to, uint _value) public returns (bool _success);
function approve( address _spender, uint _value ) public returns (bool _success);
function allowance( address _owner, address _spender ) public view returns (uint _allowa... | 0 |
function getUserBalance(address _address) view public returns (uint256) {
uint percent = getPhasePercent();
uint256 differentTime = now.sub(time[_address]).div(1 hours);
uint256 differentPercent = deposit[_address].mul(percent).div(100);
uint256 payout = differentPercent.mul(differentTime).div(24);
return payout;
... | 0 |
function get_balance() public view returns(uint balance){
return bank[msg.sender];
} | 0 |
function approve(address _spender, uint _value) public returns (bool success);
}
contract StreamityEscrow is Ownable, ReentrancyGuard {
using SafeMath for uint256;
using ECRecovery for bytes32;
uint8 constant public STATUS_NO_DEAL = 0x0;
uint8 constant public STATUS_DEAL_WAIT_CONFIRMATION = 0x01;
uint8 constant pu... | 0 |
modifier whenNotPaused() {
require(!paused);
_;
} | 0 |
function _transferForLock(address _to, uint256 _value, uint256 selectType) internal {
require(selectType >= 1);
require(selectType <= LOCK_TYPE_MAX);
if ((lockAccountInfo[_to].lockType == 0) &&
(lockAccountInfo[_to].initBalance == 0)) {
require(_value <= balances[msg.sender]);
require(_to != address(0));
lockAcc... | 0 |
function allowance(address owner, address spender) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
... | 0 |
function ownerClawbackCredits() external onlyOwner {
require(totalFunding < PRESALE_MINIMUM_FUNDING);
require(now >= OWNER_CLAWBACK_DATE);
require(!creditsClawbacked);
creditsClawbacked = true;
parsecToken.transfer(owner, parsecToken.balanceOf(this));
} | 0 |
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b, "SafeMath::mul: Integer overflow");
return c;
} | 0 |
function sell(address _from, uint256 _price, uint256 _amountBabz);
function powerBalanceOf(address _owner) constant returns (uint256);
function outstandingPower() constant returns (uint256);
function authorizedPower() constant returns (uint256);
function powerTotalSupply() constant returns (uint256);
function powe... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.