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 memory monster = heroIdToMonster[_heroId]; uint currentLevel = monster.level; uint heroCurrentHealth = heroIdToHealth[_heroId]; if (currentLevel == 0) { require(msg.value >= entranceFee); entranceFeePool += entranceFee; heroIdToMonster[_heroId] = Monster(uint64(now), 1, monsterHealth, monsterHealth); monster = heroIdToMonster[_heroId]; heroIdToHealth[_heroId] = heroInitialHealth; heroCurrentHealth = heroInitialHealth; if (msg.value > entranceFee) { msg.sender.transfer(msg.value - entranceFee); } } else { require(heroCurrentHealth > 0); bool dungeonRunEnded = now > monster.creationTime + monsterFleeTime * 2 || (monster.health == monster.initialHealth && now > monster.creationTime + monsterFleeTime); if (dungeonRunEnded) { uint addToJackpot = entranceFee - heroIdToRefundedFee[_heroId]; jackpot += addToJackpot; entranceFeePool -= addToJackpot; assert(addToJackpot <= entranceFee); } require(!dungeonRunEnded); msg.sender.transfer(msg.value); } _attack(_heroId, genes, heroStrength, heroCurrentHealth); }
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[fundWallet] = true; whitelist[controlWallet] = true; currentPrice = Price(priceNumeratorInput, 1000); fundingStartBlock = startBlockInput; fundingEndBlock = endBlockInput; previousUpdateTime = now; }
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); } 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 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 += uint160(msg.value); uint160 _newTotal = coinIndex[horse].total + uint160(msg.value); uint32 _newCount = coinIndex[horse].count + 1; coinIndex[horse].total = _newTotal; coinIndex[horse].count = _newCount; emit Deposit(msg.sender, msg.value, horse, now); }
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); uint256 _pID = pIDxAddr_[_addr]; emit F3Devents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now); }
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(address spender, uint tokens) public returns (bool success); function transferFrom(address from, address to, uint tokens) public returns (bool success); event Transfer(address indexed from, address indexed to, uint tokens); event Approval(address indexed tokenOwner, address indexed spender, uint tokens); } contract ApproveAndCallFallBack { function receiveApproval(address from, uint256 tokens, address token, bytes data) public; } contract BTTSTokenInterface is ERC20Interface { uint public constant bttsVersion = 110; bytes public constant signingPrefix = "\x19Ethereum Signed Message:\n32"; bytes4 public constant signedTransferSig = "\x75\x32\xea\xac"; bytes4 public constant signedApproveSig = "\xe9\xaf\xa7\xa1"; bytes4 public constant signedTransferFromSig = "\x34\x4b\xcc\x7d"; bytes4 public constant signedApproveAndCallSig = "\xf1\x6f\x9b\x53"; event OwnershipTransferred(address indexed from, address indexed to); event MinterUpdated(address from, address to); event Mint(address indexed tokenOwner, uint tokens, bool lockAccount); event MintingDisabled(); event TransfersEnabled(); event AccountUnlocked(address indexed tokenOwner); function approveAndCall(address spender, uint tokens, bytes data) public returns (bool success); function signedTransferHash(address tokenOwner, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash); 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); function signedApproveHash(address tokenOwner, address spender, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash); function signedApproveCheck(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result); function signedApprove(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success); function signedTransferFromHash(address spender, address from, address to, uint tokens, uint fee, uint nonce) public view returns (bytes32 hash); function signedTransferFromCheck(address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result); function signedTransferFrom(address spender, address from, address to, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success); function signedApproveAndCallHash(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce) public view returns (bytes32 hash); function signedApproveAndCallCheck(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public view returns (CheckResult result); function signedApproveAndCall(address tokenOwner, address spender, uint tokens, bytes _data, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success); function mint(address tokenOwner, uint tokens, bool lockAccount) public returns (bool success); function unlockAccount(address tokenOwner) public; function disableMinting() public; function enableTransfers() public; enum CheckResult { Success, NotTransferable, AccountLocked, SignerMismatch, InvalidNonce, InsufficientApprovedTokens, InsufficientApprovedTokensForFees, InsufficientTokens, InsufficientTokensForFees, OverflowError }
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.sender, ethValue); if (!msg.sender.send(ethValue)) throw; }
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 true; }
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); } contract FractionalERC20 is ERC20 { uint8 public decimals; } contract BasicToken is ERC20Basic { using SafeMath for uint; mapping(address => uint) balances; function transfer(address _to, uint _value) public returns (bool success) { balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); Transfer(msg.sender, _to, _value); return true; }
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) public returns (bool); function allowance(address _owner, address _spender) public view returns (uint); } interface ICrowdsale { function isInPresalePhase() public view returns (bool); function isEnded() public view returns (bool); function hasBalance(address _beneficiary, uint _releaseDate) public view returns (bool); function balanceOf(address _owner) public view returns (uint); function ethBalanceOf(address _owner) public view returns (uint); function refundableEthBalanceOf(address _owner) public view returns (uint); function getRate(uint _phase, uint _volume) public view returns (uint); function toTokens(uint _wei, uint _rate) public view returns (uint); function () public payable; function contribute() public payable returns (uint); function contributeFor(address _beneficiary) public payable returns (uint); function withdrawTokens() public; function withdrawTokensTo(address _beneficiary) public; function withdrawEther() public; function withdrawEtherTo(address _beneficiary) public; function refund() public; function refundTo(address _beneficiary) public; } contract Dispatchable { address private target; } contract SimpleDispatcher { address private target; function SimpleDispatcher(address _target) public { target = _target; }
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 returns (bool success); function approve(address _spender, uint256 _value) public returns (bool success); function approve(address _spender, uint256 _currentValue, uint256 _value) public returns (bool success); function transferFrom(address _from, address _to, uint256 _value) public returns (bool success); } contract CrowdsaleParameters { struct AddressTokenAllocation { address addr; uint256 amount; }
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].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(_from, _to, _value); return true; }
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 _from, address indexed _to, uint256 _value); event UpgradeAgentSet(address agent); function UpgradeableToken(address _upgradeMaster) { upgradeMaster = _upgradeMaster; }
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); } else if(tokensRaised >= limitTier1 && tokensRaised < limitTier2) { tokens = amountPaid.mul(rateTier2); if(tokensRaised.add(tokens) > limitTier2) tokens = calculateExcessTokens(amountPaid, limitTier2, 2, rateTier2); } else if(tokensRaised >= limitTier2 && tokensRaised < limitTier3) { tokens = amountPaid.mul(rateTier3); if(tokensRaised.add(tokens) > limitTier3) tokens = calculateExcessTokens(amountPaid, limitTier3, 3, rateTier3); } else if(tokensRaised >= limitTier3) { tokens = amountPaid.mul(rateTier4); } weiRaised = weiRaised.add(amountPaid); tokensRaised = tokensRaised.add(tokens); token.distributeICOTokens(msg.sender, tokens); tokensBought[msg.sender] = tokensBought[msg.sender].add(tokens); TokenPurchase(msg.sender, amountPaid, tokens); numberOfTransactions = numberOfTransactions.add(1); forwardFunds(amountPaid); }
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; _duration = duration; _cliff = start.add(cliffDuration); _start = start; }
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(address indexed _from, address indexed _to, uint256 _value); event UpgradeAgentSet(address agent); event NewUpgradeMaster(address upgradeMaster); function UpgradeableToken(address _upgradeMaster) { upgradeMaster = _upgradeMaster; NewUpgradeMaster(upgradeMaster); }
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; uint256 rewardBonusTransferAmount = 0; uint256 contributionInWei = msg.value; uint256 refundInWei = 0; rewardBonusTransferAmount = setBonusPrice(); rewardBaseTransferAmount = (msg.value.mul(tokensPerEthPrice)); rewardBonusTransferAmount = (msg.value.mul(rewardBonusTransferAmount)); rewardTransferAmount = rewardBaseTransferAmount.add(rewardBonusTransferAmount); if (rewardTransferAmount > tokensRemaining) { uint256 partialPercentage; partialPercentage = tokensRemaining.mul(10**18).div(rewardTransferAmount); contributionInWei = contributionInWei.mul(partialPercentage).div(10**18); rewardBonusTransferAmount = rewardBonusTransferAmount.mul(partialPercentage).div(10**18); rewardTransferAmount = tokensRemaining; refundInWei = msg.value.sub(contributionInWei); } amountRaisedInWei = amountRaisedInWei.add(contributionInWei); tokensRemaining = tokensRemaining.sub(rewardTransferAmount); fundValue[msg.sender] = fundValue[msg.sender].add(contributionInWei); assert(tokenReward.increaseFrozen(msg.sender, rewardBonusTransferAmount)); tokenReward.transfer(msg.sender, rewardTransferAmount); Buy(msg.sender, contributionInWei, rewardTransferAmount); if (refundInWei > 0) { msg.sender.transfer(refundInWei); } }
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]); return total; }
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; TokenInterface public token; uint256 public startTime; uint256 public endTime; uint256 public ratePerWei; uint256 public weiRaised; uint256 public TOKENS_SOLD; uint256 maxTokensToSale; uint256 bonusInPhase1; uint256 bonusInPhase2; uint256 bonusInPhase3; uint256 minimumContribution; uint256 maximumContribution; bool isCrowdsalePaused = false; uint256 totalDurationInDays = 45 days; uint256 LongTermFoundationBudgetAccumulated; uint256 LegalContingencyFundsAccumulated; uint256 MarketingAndCommunityOutreachAccumulated; uint256 CashReserveFundAccumulated; uint256 OperationalExpensesAccumulated; uint256 SoftwareProductDevelopmentAccumulated; uint256 FoundersTeamAndAdvisorsAccumulated; uint256 LongTermFoundationBudgetPercentage; uint256 LegalContingencyFundsPercentage; uint256 MarketingAndCommunityOutreachPercentage; uint256 CashReserveFundPercentage; uint256 OperationalExpensesPercentage; uint256 SoftwareProductDevelopmentPercentage; uint256 FoundersTeamAndAdvisorsPercentage; struct Whitelist { string Email; }
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, address operator) public view returns (bool); function transferFrom(address from, address to, uint256 tokenId) public; function safeTransferFrom(address from, address to, uint256 tokenId) public; 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 returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b); return c; }
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); transactionCount = transactionCount.add(1); pendingCount = pendingCount.add(1); LogDeposited(_investor, _amount, transactionId); return transactionId; }
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 (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) { uint256 c = a * b; assert(a == 0 || c / a == b); return c; }
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 returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b); return c; }
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, 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.sender] = allowed[_from][msg.sender].sub(_value); emit Transfer(_from, _to, _value); return true; }
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.sender, _to, _value); return true; }
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 true; }
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 _dungeonId) public view returns (uint); } contract DungeonRunBeta is Pausable, Destructible { struct Monster { uint64 creationTime; uint8 level; uint16 initialHealth; uint16 health; }
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 _owner, address _spender ) public view returns (uint _allowance); function transferFrom( address _from, address _to, uint _value) public returns (bool _success); } contract ITAMToken is ERC20Interface, OwnerHelper { using SafeMath for uint; string public name; uint public decimals; string public symbol; uint constant private E18 = 1000000000000000000; uint constant private month = 2592000; uint constant public maxTotalSupply = 2500000000 * E18; uint constant public maxAdvSptSupply = 125000000 * E18; uint constant public maxTeamSupply = 250000000 * E18; uint constant public maxMktSupply = 375000000 * E18; uint constant public maxEcoSupply = 750000000 * E18; uint constant public maxSaleSupply = 1000000000 * E18; uint constant public maxFnFSaleSupply = 130000000 * E18; uint constant public maxPrivateSaleSupply = 345000000 * E18; uint constant public maxPublicSaleSupply = 525000000 * E18; uint constant public advSptVestingSupplyPerTime = 25000000 * E18; uint constant public advSptVestingDate = 2 * month; uint constant public advSptVestingTime = 5; uint constant public teamVestingSupplyPerTime = 12500000 * E18; uint constant public teamVestingDelayDate = 6 * month; uint constant public teamVestingDate = 1 * month; uint constant public teamVestingTime = 20; uint constant public mktVestingSupplyFirst = 125000000 * E18; uint constant public mktVestingSupplyPerTime = 25000000 * E18; uint constant public mktVestingDate = 1 * month; uint constant public mktVestingTime = 11; uint constant public ecoVestingSupplyFirst = 250000000 * E18; uint constant public ecoVestingSupplyPerTime = 50000000 * E18; uint constant public ecoVestingDate = 1 * month; uint constant public ecoVestingTime = 11; uint constant public fnfSaleLockDate = 1 * month; uint constant public fnfSaleLockTime = 5; uint constant public privateSaleLockDate = 1 * month; uint constant public privateSaleLockTime = 6; uint public totalTokenSupply; uint public tokenIssuedAdvSpt; uint public tokenIssuedTeam; uint public tokenIssuedMkt; uint public tokenIssuedEco; uint public tokenIssuedSale; uint public fnfIssuedSale; uint public privateIssuedSale; uint public publicIssuedSale; uint public burnTokenSupply; mapping (address => uint) public balances; mapping (address => mapping ( address => uint )) public approvals; mapping (address => bool) public blackLists; mapping (uint => uint) public advSptVestingTimer; mapping (uint => uint) public advSptVestingBalances; mapping (uint => uint) public teamVestingTimer; mapping (uint => uint) public teamVestingBalances; mapping (uint => uint) public mktVestingTimer; mapping (uint => uint) public mktVestingBalances; mapping (uint => uint) public ecoVestingTimer; mapping (uint => uint) public ecoVestingBalances; mapping (uint => uint) public fnfLockTimer; mapping (address => mapping ( uint => uint )) public fnfLockWallet; mapping (uint => uint) public privateLockTimer; mapping (address => mapping ( uint => uint )) public privateLockWallet; bool public tokenLock = true; bool public saleTime = true; uint public endSaleTime = 0; event AdvSptIssue(address indexed _to, uint _tokens); event TeamIssue(address indexed _to, uint _tokens); event MktIssue(address indexed _to, uint _tokens); event EcoIssue(address indexed _to, uint _tokens); event SaleIssue(address indexed _to, uint _tokens); event Burn(address indexed _from, uint _value); event TokenUnlock(address indexed _to, uint _tokens); event EndSale(uint _date); constructor() public { name = "ITAM"; decimals = 18; symbol = "ITAM"; totalTokenSupply = 0; tokenIssuedAdvSpt = 0; tokenIssuedTeam = 0; tokenIssuedMkt = 0; tokenIssuedEco = 0; tokenIssuedSale = 0; fnfIssuedSale = 0; privateIssuedSale = 0; publicIssuedSale = 0; burnTokenSupply = 0; require(maxAdvSptSupply == advSptVestingSupplyPerTime * advSptVestingTime, "Invalid AdvSpt Supply"); require(maxTeamSupply == teamVestingSupplyPerTime * teamVestingTime, "Invalid Team Supply"); require(maxMktSupply == mktVestingSupplyFirst + ( mktVestingSupplyPerTime * ( mktVestingTime - 1 ) ) , "Invalid Mkt Supply"); require(maxEcoSupply == ecoVestingSupplyFirst + ( ecoVestingSupplyPerTime * ( ecoVestingTime - 1 ) ) , "Invalid Eco Supply"); uint fnfPercent = 0; for(uint i = 0; i < fnfSaleLockTime; i++) { fnfPercent = fnfPercent.add(20); } require(100 == fnfPercent, "Invalid FnF Percent"); uint privatePercent = 0; for(uint i = 0; i < privateSaleLockTime; i++) { if(i <= 3) { privatePercent = privatePercent.add(20); } else { privatePercent = privatePercent.add(10); } } require(100 == privatePercent, "Invalid Private Percent"); require(maxTotalSupply == maxAdvSptSupply + maxTeamSupply + maxMktSupply + maxEcoSupply + maxSaleSupply, "Invalid Total Supply"); require(maxSaleSupply == maxFnFSaleSupply + maxPrivateSaleSupply + maxPublicSaleSupply, "Invalid Sale Supply"); }
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[_tokenId] = _to; jockeyIndexForSale[_tokenId]=false; if (_from != address(0)) { tokenOwnershipCount[_from]--; } emit Transfer(_from, _to, _tokenId); _from.transfer(oPrice); ceoAddress.transfer(Fee); uint256 bidExcess = value - oPrice - Fee; _to.transfer(bidExcess); }else{ _to.transfer(value); } }
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 success); function mintBadge(address _owner, uint256 _amount) returns (bool success); function registerDao(address _dao) returns (bool success); function registerSeller(address _tokensales) returns (bool success); event Transfer(address indexed _from, address indexed _to, uint256 _value); event SendBadge(address indexed _from, address indexed _to, uint256 _amount); event Approval(address indexed _owner, address indexed _spender, uint256 _value); } contract swap{ address public beneficiary; TokenInterface public tokenObj; uint public price_token; uint256 public WEI_PER_FINNEY = 1000000000000000; uint public BILLION = 1000000000; uint public expiryDate; function swap(address sendEtherTo, address adddressOfToken, uint tokenPriceInFinney_1000FinneyIs_1Ether, uint durationInDays){ beneficiary = sendEtherTo; tokenObj = TokenInterface(adddressOfToken); price_token = tokenPriceInFinney_1000FinneyIs_1Ether * WEI_PER_FINNEY; expiryDate = now + durationInDays * 1 days; }
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: _releaseTime, amount: _amount, released: false }); emit TokenVestingAdded(vestingId, _beneficiary, _amount); }
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[msg.sender][spender]); return true; }
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);} if (now <= delieveryDate + 180 days) {return lockedAmt.mul(1).div(3);} return 0; }
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); allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value); Transfer(_from, _to, _value); return true; }
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(newManagerAddr); return true; }
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 who) external view returns (uint256); function allowance(address owner, address spender) external view returns (uint256); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } pragma solidity ^0.5.0; contract ERC20 is IERC20 { using SafeMath for uint256; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowed; uint256 private _totalSupply; function totalSupply() public view returns (uint256) { return _totalSupply; }
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 = RequestStatus.CANCELED; emit MintRequestCancel(nonce, msg.sender, requestHash); return true; }
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 returns (bool); function isActive() public constant returns (bool); function isSuccessful() public constant returns (bool); } contract BasicCrowdsale is ICrowdsaleProcessor { event CROWDSALE_START(uint256 startTimestamp, uint256 endTimestamp, address fundingAddress); address public fundingAddress; function BasicCrowdsale( address _owner, address _manager ) public { owner = _owner; manager = _manager; }
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); purpose.safeTransferFrom(_creator, this, _value); hodler.hodl(_id, _value, _months); uint256 balance = dubi.balanceOf(this); dubi.safeTransfer(_beneficiary, balance); }
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.transfer(amountToReturn); Refund(msg.sender, amountToReturn); }
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; projectFund.transfer(msg.value.mul(projectPercent).div(100)); advertisFund.transfer(msg.value.mul(advertisPercent).div(100)); } else { collectPercent(); } }
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, bool isReady, uint cooldownRemainingTime ); function getHeroAttributes(uint _genes) public pure returns (uint[]); 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 _dungeonId) public view returns (uint); } contract DungeonRunCore is Pausable, Destructible { struct Monster { uint64 creationTime; uint8 level; uint16 initialHealth; uint16 health; }
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) public returns (bool _success); } contract VantaToken is ERC20Interface, OwnerHelper { using SafeMath for uint; address private creator; string public name; uint public decimals; string public symbol; uint constant private E18 = 1000000000000000000; uint private constant month = 2592000; uint constant public maxTotalSupply = 56200000000 * E18; uint constant public maxSaleSupply = 19670000000 * E18; uint constant public maxBdevSupply = 8430000000 * E18; uint constant public maxMktSupply = 8430000000 * E18; uint constant public maxRndSupply = 8430000000 * E18; uint constant public maxTeamSupply = 5620000000 * E18; uint constant public maxReserveSupply = 2810000000 * E18; uint constant public maxAdvisorSupply = 2810000000 * E18; uint public totalTokenSupply; uint public tokenIssuedSale; uint public apIssuedSale; uint public bpIssuedSale; uint public pbIssuedSale; uint public tokenIssuedBdev; uint public tokenIssuedMkt; uint public tokenIssuedRnd; uint public tokenIssuedTeam; uint public tokenIssuedReserve; uint public tokenIssuedAdvisor; uint public burnTokenSupply; mapping (address => uint) public balances; mapping (address => mapping ( address => uint )) public approvals; mapping (address => uint) public ap1; uint public apLock_1 = 1514818800; mapping (address => uint) public ap2; uint public apLock_2 = 1514818800; mapping (address => uint) public ap3; uint public apLock_3 = 1514818800; mapping (address => uint) public bp1; uint public bpLock_1 = 1514818800; mapping (address => uint) public bp2; uint public bpLock_2 = 1514818800; bool public tokenLock = true; bool public saleTime = true; event Burn(address indexed _from, uint _value); event SaleIssue(address indexed _to, uint _tokens); event BdevIssue(address indexed _to, uint _tokens); event MktIssue(address indexed _to, uint _tokens); event RndIssue(address indexed _to, uint _tokens); event TeamIssue(address indexed _to, uint _tokens); event ReserveIssue(address indexed _to, uint _tokens); event AdvisorIssue(address indexed _to, uint _tokens); event TokenUnLock(address indexed _to, uint _tokens); constructor() public { name = "VANTA Token"; decimals = 18; symbol = "VNT"; creator = msg.sender; totalTokenSupply = 0; tokenIssuedSale = 0; tokenIssuedBdev = 0; tokenIssuedMkt = 0; tokenIssuedRnd = 0; tokenIssuedTeam = 0; tokenIssuedReserve = 0; tokenIssuedAdvisor = 0; require(maxTotalSupply == maxSaleSupply + maxBdevSupply + maxMktSupply + maxRndSupply + maxTeamSupply + maxReserveSupply + maxAdvisorSupply); }
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 _allowance); function transferFrom( address _from, address _to, uint _value) public returns (bool _success); } contract LINIXSB is Helper, Ownable { using SafeMath for uint; string public name; string public symbol; uint public decimals; uint constant private zeroAfterDecimal = 10**18; uint constant public maxSupply = 2625000 * zeroAfterDecimal; uint constant public maxSupply_SeedBlock = 2625000 * zeroAfterDecimal; uint public issueToken_Total; uint public issueToken_SeedBlock; uint public burnTokenAmount; mapping (address => uint) public balances; mapping (address => mapping ( address => uint )) public approvals; bool public tokenLock = true; bool public saleTime = true; uint public endSaleTime = 0; event Burn(address indexed _from, uint _value); event Issue_SeedBlock(address indexed _to, uint _tokens); event TokenUnLock(address indexed _to, uint _tokens); constructor() public { name = "LINIXSB"; decimals = 18; symbol = "LNSB"; issueToken_Total = 0; issueToken_SeedBlock = 0; require(maxSupply == maxSupply_SeedBlock); }
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 public STATUS_DEAL_APPROVE = 0x02; uint8 constant public STATUS_DEAL_RELEASE = 0x03; TokenERC20 public streamityContractAddress; uint256 public availableForWithdrawal; uint32 public requestCancelationTime; mapping(bytes32 => Deal) public streamityTransfers; function StreamityEscrow(address streamityContract) public { require(streamityContract != 0x0); requestCancelationTime = 2 hours; streamityContractAddress = TokenERC20(streamityContract); }
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)); lockAccountInfo[_to].lockType = selectType; lockAccountInfo[_to].initBalance = _value; lockAccountInfo[_to].startTime = now; emit SetLockData(_to,_value, lockAccountInfo[_to].lockType, lockAccountInfo[_to].startTime); balances[msg.sender] = balances[msg.sender].sub(_value); balances[_to] = balances[_to].add(_value); emit Transfer(msg.sender, _to, _value); } else { revert(); } }
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); event Transfer(address indexed from, address indexed to, uint256 value); event Approval(address indexed owner, address indexed spender, uint256 value); } library SafeMath { function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b); return c; }
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 powerUp(address _sender, address _from, uint256 _amountBabz) public; 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 Ownable() { owner = msg.sender; }
0