Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
TokenTracker
Latest 1 internal transaction
Advanced mode:
Parent Transaction Hash | Block | From | To | |||
---|---|---|---|---|---|---|
10604814 | 1493 days ago | Contract Creation | 0 ETH |
Loading...
Loading
Similar Match Source Code This contract matches the deployed Bytecode of the Source Code for Contract 0xdDE11648...f6AF32Ae7 The constructor portion of the code might be different and could alter the actual behaviour of the contract
Contract Name:
SmartToken
Compiler Version
v0.4.26+commit.4563c3fc
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2020-07-11 */ // File: contracts/token/interfaces/IERC20Token.sol pragma solidity 0.4.26; /* ERC20 Standard Token interface */ contract IERC20Token { // these functions aren't abstract since the compiler emits automatically generated getter functions as external function name() public view returns (string) {this;} function symbol() public view returns (string) {this;} function decimals() public view returns (uint8) {this;} function totalSupply() public view returns (uint256) {this;} function balanceOf(address _owner) public view returns (uint256) {_owner; this;} function allowance(address _owner, address _spender) public view returns (uint256) {_owner; _spender; this;} function transfer(address _to, uint256 _value) public returns (bool success); function transferFrom(address _from, address _to, uint256 _value) public returns (bool success); function approve(address _spender, uint256 _value) public returns (bool success); } // File: contracts/utility/Utils.sol pragma solidity 0.4.26; /** * @dev Utilities & Common Modifiers */ contract Utils { // verifies that a value is greater than zero modifier greaterThanZero(uint256 _value) { _greaterThanZero(_value); _; } // error message binary size optimization function _greaterThanZero(uint256 _value) internal pure { require(_value > 0, "ERR_ZERO_VALUE"); } // validates an address - currently only checks that it isn't null modifier validAddress(address _address) { _validAddress(_address); _; } // error message binary size optimization function _validAddress(address _address) internal pure { require(_address != address(0), "ERR_INVALID_ADDRESS"); } // verifies that the address is different than this contract address modifier notThis(address _address) { _notThis(_address); _; } // error message binary size optimization function _notThis(address _address) internal view { require(_address != address(this), "ERR_ADDRESS_IS_SELF"); } } // File: contracts/utility/SafeMath.sol pragma solidity 0.4.26; /** * @dev Library for basic math operations with overflow/underflow protection */ library SafeMath { /** * @dev returns the sum of _x and _y, reverts if the calculation overflows * * @param _x value 1 * @param _y value 2 * * @return sum */ function add(uint256 _x, uint256 _y) internal pure returns (uint256) { uint256 z = _x + _y; require(z >= _x, "ERR_OVERFLOW"); return z; } /** * @dev returns the difference of _x minus _y, reverts if the calculation underflows * * @param _x minuend * @param _y subtrahend * * @return difference */ function sub(uint256 _x, uint256 _y) internal pure returns (uint256) { require(_x >= _y, "ERR_UNDERFLOW"); return _x - _y; } /** * @dev returns the product of multiplying _x by _y, reverts if the calculation overflows * * @param _x factor 1 * @param _y factor 2 * * @return product */ function mul(uint256 _x, uint256 _y) internal pure returns (uint256) { // gas optimization if (_x == 0) return 0; uint256 z = _x * _y; require(z / _x == _y, "ERR_OVERFLOW"); return z; } /** * @dev Integer division of two numbers truncating the quotient, reverts on division by zero. * * @param _x dividend * @param _y divisor * * @return quotient */ function div(uint256 _x, uint256 _y) internal pure returns (uint256) { require(_y > 0, "ERR_DIVIDE_BY_ZERO"); uint256 c = _x / _y; return c; } } // File: contracts/token/ERC20Token.sol pragma solidity 0.4.26; /** * @dev ERC20 Standard Token implementation */ contract ERC20Token is IERC20Token, Utils { using SafeMath for uint256; string public name; string public symbol; uint8 public decimals; uint256 public totalSupply; mapping (address => uint256) public balanceOf; mapping (address => mapping (address => uint256)) public allowance; /** * @dev triggered when tokens are transferred between wallets * * @param _from source address * @param _to target address * @param _value transfer amount */ event Transfer(address indexed _from, address indexed _to, uint256 _value); /** * @dev triggered when a wallet allows another wallet to transfer tokens from on its behalf * * @param _owner wallet that approves the allowance * @param _spender wallet that receives the allowance * @param _value allowance amount */ event Approval(address indexed _owner, address indexed _spender, uint256 _value); /** * @dev initializes a new ERC20Token instance * * @param _name token name * @param _symbol token symbol * @param _decimals decimal points, for display purposes * @param _totalSupply total supply of token units */ constructor(string _name, string _symbol, uint8 _decimals, uint256 _totalSupply) public { // validate input require(bytes(_name).length > 0, "ERR_INVALID_NAME"); require(bytes(_symbol).length > 0, "ERR_INVALID_SYMBOL"); name = _name; symbol = _symbol; decimals = _decimals; totalSupply = _totalSupply; balanceOf[msg.sender] = _totalSupply; } /** * @dev transfers tokens to a given address * throws on any error rather then return a false flag to minimize user errors * * @param _to target address * @param _value transfer amount * * @return true if the transfer was successful, false if it wasn't */ function transfer(address _to, uint256 _value) public validAddress(_to) returns (bool success) { balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value); balanceOf[_to] = balanceOf[_to].add(_value); emit Transfer(msg.sender, _to, _value); return true; } /** * @dev transfers tokens to a given address on behalf of another address * throws on any error rather then return a false flag to minimize user errors * * @param _from source address * @param _to target address * @param _value transfer amount * * @return true if the transfer was successful, false if it wasn't */ function transferFrom(address _from, address _to, uint256 _value) public validAddress(_from) validAddress(_to) returns (bool success) { allowance[_from][msg.sender] = allowance[_from][msg.sender].sub(_value); balanceOf[_from] = balanceOf[_from].sub(_value); balanceOf[_to] = balanceOf[_to].add(_value); emit Transfer(_from, _to, _value); return true; } /** * @dev allows another account/contract to transfers tokens on behalf of the caller * throws on any error rather then return a false flag to minimize user errors * * also, to minimize the risk of the approve/transferFrom attack vector * (see https://docs.google.com/document/d/1YLPtQxZu1UAvO9cZ1O2RPXBbT0mooh4DYKjA_jp-RLM/), approve has to be called twice * in 2 separate transactions - once to change the allowance to 0 and secondly to change it to the new allowance value * * @param _spender approved address * @param _value allowance amount * * @return true if the approval was successful, false if it wasn't */ function approve(address _spender, uint256 _value) public validAddress(_spender) returns (bool success) { // if the allowance isn't 0, it can only be updated to 0 to prevent an allowance change immediately after withdrawal require(_value == 0 || allowance[msg.sender][_spender] == 0, "ERR_INVALID_AMOUNT"); allowance[msg.sender][_spender] = _value; emit Approval(msg.sender, _spender, _value); return true; } } // File: contracts/utility/interfaces/IOwned.sol pragma solidity 0.4.26; /* Owned contract interface */ contract IOwned { // this function isn't abstract since the compiler emits automatically generated getter functions as external function owner() public view returns (address) {this;} function transferOwnership(address _newOwner) public; function acceptOwnership() public; } // File: contracts/utility/interfaces/ITokenHolder.sol pragma solidity 0.4.26; /* Token Holder interface */ contract ITokenHolder is IOwned { function withdrawTokens(IERC20Token _token, address _to, uint256 _amount) public; } // File: contracts/converter/interfaces/IConverterAnchor.sol pragma solidity 0.4.26; /* Converter Anchor interface */ contract IConverterAnchor is IOwned, ITokenHolder { } // File: contracts/token/interfaces/ISmartToken.sol pragma solidity 0.4.26; /* Smart Token interface */ contract ISmartToken is IConverterAnchor, IERC20Token { function disableTransfers(bool _disable) public; function issue(address _to, uint256 _amount) public; function destroy(address _from, uint256 _amount) public; } // File: contracts/utility/Owned.sol pragma solidity 0.4.26; /** * @dev Provides support and utilities for contract ownership */ contract Owned is IOwned { address public owner; address public newOwner; /** * @dev triggered when the owner is updated * * @param _prevOwner previous owner * @param _newOwner new owner */ event OwnerUpdate(address indexed _prevOwner, address indexed _newOwner); /** * @dev initializes a new Owned instance */ constructor() public { owner = msg.sender; } // allows execution by the owner only modifier ownerOnly { _ownerOnly(); _; } // error message binary size optimization function _ownerOnly() internal view { require(msg.sender == owner, "ERR_ACCESS_DENIED"); } /** * @dev allows transferring the contract ownership * the new owner still needs to accept the transfer * can only be called by the contract owner * * @param _newOwner new contract owner */ function transferOwnership(address _newOwner) public ownerOnly { require(_newOwner != owner, "ERR_SAME_OWNER"); newOwner = _newOwner; } /** * @dev used by a new owner to accept an ownership transfer */ function acceptOwnership() public { require(msg.sender == newOwner, "ERR_ACCESS_DENIED"); emit OwnerUpdate(owner, newOwner); owner = newOwner; newOwner = address(0); } } // File: contracts/utility/TokenHandler.sol pragma solidity 0.4.26; contract TokenHandler { bytes4 private constant APPROVE_FUNC_SELECTOR = bytes4(keccak256("approve(address,uint256)")); bytes4 private constant TRANSFER_FUNC_SELECTOR = bytes4(keccak256("transfer(address,uint256)")); bytes4 private constant TRANSFER_FROM_FUNC_SELECTOR = bytes4(keccak256("transferFrom(address,address,uint256)")); /** * @dev executes the ERC20 token's `approve` function and reverts upon failure * the main purpose of this function is to prevent a non standard ERC20 token * from failing silently * * @param _token ERC20 token address * @param _spender approved address * @param _value allowance amount */ function safeApprove(IERC20Token _token, address _spender, uint256 _value) internal { execute(_token, abi.encodeWithSelector(APPROVE_FUNC_SELECTOR, _spender, _value)); } /** * @dev executes the ERC20 token's `transfer` function and reverts upon failure * the main purpose of this function is to prevent a non standard ERC20 token * from failing silently * * @param _token ERC20 token address * @param _to target address * @param _value transfer amount */ function safeTransfer(IERC20Token _token, address _to, uint256 _value) internal { execute(_token, abi.encodeWithSelector(TRANSFER_FUNC_SELECTOR, _to, _value)); } /** * @dev executes the ERC20 token's `transferFrom` function and reverts upon failure * the main purpose of this function is to prevent a non standard ERC20 token * from failing silently * * @param _token ERC20 token address * @param _from source address * @param _to target address * @param _value transfer amount */ function safeTransferFrom(IERC20Token _token, address _from, address _to, uint256 _value) internal { execute(_token, abi.encodeWithSelector(TRANSFER_FROM_FUNC_SELECTOR, _from, _to, _value)); } /** * @dev executes a function on the ERC20 token and reverts upon failure * the main purpose of this function is to prevent a non standard ERC20 token * from failing silently * * @param _token ERC20 token address * @param _data data to pass in to the token's contract for execution */ function execute(IERC20Token _token, bytes memory _data) private { uint256[1] memory ret = [uint256(1)]; assembly { let success := call( gas, // gas remaining _token, // destination address 0, // no ether add(_data, 32), // input buffer (starts after the first 32 bytes in the `data` array) mload(_data), // input length (loaded from the first 32 bytes in the `data` array) ret, // output buffer 32 // output length ) if iszero(success) { revert(0, 0) } } require(ret[0] != 0, "ERR_TRANSFER_FAILED"); } } // File: contracts/utility/TokenHolder.sol pragma solidity 0.4.26; /** * @dev We consider every contract to be a 'token holder' since it's currently not possible * for a contract to deny receiving tokens. * * The TokenHolder's contract sole purpose is to provide a safety mechanism that allows * the owner to send tokens that were sent to the contract by mistake back to their sender. * * Note that we use the non standard ERC-20 interface which has no return value for transfer * in order to support both non standard as well as standard token contracts. * see https://github.com/ethereum/solidity/issues/4116 */ contract TokenHolder is ITokenHolder, TokenHandler, Owned, Utils { /** * @dev withdraws tokens held by the contract and sends them to an account * can only be called by the owner * * @param _token ERC20 token contract address * @param _to account to receive the new amount * @param _amount amount to withdraw */ function withdrawTokens(IERC20Token _token, address _to, uint256 _amount) public ownerOnly validAddress(_token) validAddress(_to) notThis(_to) { safeTransfer(_token, _to, _amount); } } // File: contracts/token/SmartToken.sol pragma solidity 0.4.26; /** * @dev Smart Token * * 'Owned' is specified here for readability reasons */ contract SmartToken is ISmartToken, Owned, ERC20Token, TokenHolder { using SafeMath for uint256; uint16 public constant version = 4; bool public transfersEnabled = true; // true if transfer/transferFrom are enabled, false otherwise /** * @dev triggered when the total supply is increased * * @param _amount amount that gets added to the supply */ event Issuance(uint256 _amount); /** * @dev triggered when the total supply is decreased * * @param _amount amount that gets removed from the supply */ event Destruction(uint256 _amount); /** * @dev initializes a new SmartToken instance * * @param _name token name * @param _symbol token short symbol, minimum 1 character * @param _decimals for display purposes only */ constructor(string _name, string _symbol, uint8 _decimals) public ERC20Token(_name, _symbol, _decimals, 0) { } // allows execution only when transfers are enabled modifier transfersAllowed { _transfersAllowed(); _; } // error message binary size optimization function _transfersAllowed() internal view { require(transfersEnabled, "ERR_TRANSFERS_DISABLED"); } /** * @dev disables/enables transfers * can only be called by the contract owner * * @param _disable true to disable transfers, false to enable them */ function disableTransfers(bool _disable) public ownerOnly { transfersEnabled = !_disable; } /** * @dev increases the token supply and sends the new tokens to the given account * can only be called by the contract owner * * @param _to account to receive the new amount * @param _amount amount to increase the supply by */ function issue(address _to, uint256 _amount) public ownerOnly validAddress(_to) notThis(_to) { totalSupply = totalSupply.add(_amount); balanceOf[_to] = balanceOf[_to].add(_amount); emit Issuance(_amount); emit Transfer(address(0), _to, _amount); } /** * @dev removes tokens from the given account and decreases the token supply * can only be called by the contract owner * * @param _from account to remove the amount from * @param _amount amount to decrease the supply by */ function destroy(address _from, uint256 _amount) public ownerOnly { balanceOf[_from] = balanceOf[_from].sub(_amount); totalSupply = totalSupply.sub(_amount); emit Transfer(_from, address(0), _amount); emit Destruction(_amount); } // ERC20 standard method overrides with some extra functionality /** * @dev send coins * throws on any error rather then return a false flag to minimize user errors * in addition to the standard checks, the function throws if transfers are disabled * * @param _to target address * @param _value transfer amount * * @return true if the transfer was successful, false if it wasn't */ function transfer(address _to, uint256 _value) public transfersAllowed returns (bool success) { assert(super.transfer(_to, _value)); return true; } /** * @dev an account/contract attempts to get the coins * throws on any error rather then return a false flag to minimize user errors * in addition to the standard checks, the function throws if transfers are disabled * * @param _from source address * @param _to target address * @param _value transfer amount * * @return true if the transfer was successful, false if it wasn't */ function transferFrom(address _from, address _to, uint256 _value) public transfersAllowed returns (bool success) { assert(super.transferFrom(_from, _to, _value)); return true; } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"constant":true,"inputs":[],"name":"name","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_spender","type":"address"},{"name":"_value","type":"uint256"}],"name":"approve","outputs":[{"name":"success","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_disable","type":"bool"}],"name":"disableTransfers","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_from","type":"address"},{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"name":"transferFrom","outputs":[{"name":"success","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"version","outputs":[{"name":"","type":"uint16"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_token","type":"address"},{"name":"_to","type":"address"},{"name":"_amount","type":"uint256"}],"name":"withdrawTokens","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"balanceOf","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"acceptOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_amount","type":"uint256"}],"name":"issue","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_from","type":"address"},{"name":"_amount","type":"uint256"}],"name":"destroy","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_to","type":"address"},{"name":"_value","type":"uint256"}],"name":"transfer","outputs":[{"name":"success","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"transfersEnabled","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"newOwner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"},{"name":"","type":"address"}],"name":"allowance","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"inputs":[{"name":"_name","type":"string"},{"name":"_symbol","type":"string"},{"name":"_decimals","type":"uint8"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"name":"_amount","type":"uint256"}],"name":"Issuance","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"_amount","type":"uint256"}],"name":"Destruction","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"_from","type":"address"},{"indexed":true,"name":"_to","type":"address"},{"indexed":false,"name":"_value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"_owner","type":"address"},{"indexed":true,"name":"_spender","type":"address"},{"indexed":false,"name":"_value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"_prevOwner","type":"address"},{"indexed":true,"name":"_newOwner","type":"address"}],"name":"OwnerUpdate","type":"event"}]
Deployed Bytecode
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
Deployed Bytecode Sourcemap
16018:4125:0:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4170:18;;8:9:-1;5:2;;;30:1;27;20:12;5:2;4170:18:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;4170:18:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8005:492;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;8005:492:0;-1:-1:-1;;;;;8005:492:0;;;;;;;;;;;;;;;;;;;;;;;;;17547:105;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;17547:105:0;;;;;;;;;4250:26;;8:9:-1;5:2;;;30:1;27;20:12;5:2;4250:26:0;;;;;;;;;;;;;;;;;;;;19940:200;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;19940:200:0;-1:-1:-1;;;;;19940:200:0;;;;;;;;;;;;4222:21;;8:9:-1;5:2;;;30:1;27;20:12;5:2;4222:21:0;;;;;;;;;;;;;;;;;;;;;;;16127:34;;8:9:-1;5:2;;;30:1;27;20:12;5:2;16127:34:0;;;;;;;;;;;;;;;;;;;;;;;15596:246;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;15596:246:0;-1:-1:-1;;;;;15596:246:0;;;;;;;;;;;;4283:45;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;4283:45:0;-1:-1:-1;;;;;4283:45:0;;;;;11084:208;;8:9:-1;5:2;;;30:1;27;20:12;5:2;11084:208:0;;;;17940:331;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;17940:331:0;-1:-1:-1;;;;;17940:331:0;;;;;;;9899:20;;8:9:-1;5:2;;;30:1;27;20:12;5:2;9899:20:0;;;;;;;;-1:-1:-1;;;;;9899:20:0;;;;;;;;;;;;;;4195;;8:9:-1;5:2;;;30:1;27;20:12;5:2;4195:20:0;;;;18555:272;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;18555:272:0;-1:-1:-1;;;;;18555:272:0;;;;;;;19297:170;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;19297:170:0;-1:-1:-1;;;;;19297:170:0;;;;;;;16170:35;;8:9:-1;5:2;;;30:1;27;20:12;5:2;16170:35:0;;;;9926:23;;8:9:-1;5:2;;;30:1;27;20:12;5:2;9926:23:0;;;;4335:66;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;4335:66:0;-1:-1:-1;;;;;4335:66:0;;;;;;;;;;10835:158;;8:9:-1;5:2;;;30:1;27;20:12;5:2;-1:-1;10835:158:0;-1:-1:-1;;;;;10835:158:0;;;;;4170:18;;;;;;;;;;;;;;-1:-1:-1;;4170:18:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;8005:492::-;8122:12;8094:8;1574:23;1588:8;1574:13;:23::i;:::-;8286:11;;;:51;;-1:-1:-1;8311:10:0;8301:21;;;;:9;:21;;;;;;;;-1:-1:-1;;;;;8301:31:0;;;;;;;;;;:36;8286:51;8278:82;;;;;;;-1:-1:-1;;;;;8278:82:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;8383:10;8373:21;;;;:9;:21;;;;;;;;-1:-1:-1;;;;;8373:31:0;;;;;;;;;;;;:40;;;8429:38;;;;;;;8373:31;;8383:10;8429:38;;;;;;;;;;;-1:-1:-1;8485:4:0;;8005:492;-1:-1:-1;;;8005:492:0:o;17547:105::-;10397:12;:10;:12::i;:::-;17616:16;:28;;-1:-1:-1;;17616:28:0;17635:9;;17616:28;;;;;;17547:105::o;4250:26::-;;;;:::o;19940:200::-;20039:12;17139:19;:17;:19::i;:::-;20071:38;20090:5;20097:3;20102:6;20071:18;:38::i;:::-;20064:46;;;;;;-1:-1:-1;20128:4:0;19940:200;;;;;:::o;4222:21::-;;;;;;:::o;16127:34::-;16160:1;16127:34;:::o;15596:246::-;10397:12;:10;:12::i;:::-;15727:6;1574:23;1588:8;1574:13;:23::i;:::-;15757:3;1574:23;1588:8;1574:13;:23::i;:::-;15779:3;1928:18;1937:8;1928;:18::i;:::-;15800:34;15813:6;15821:3;15826:7;15800:12;:34::i;:::-;1608:1;;10420;15596:246;;;:::o;4283:45::-;;;;;;;;;;;;;:::o;11084:208::-;11151:8;;-1:-1:-1;;;;;11151:8:0;11137:10;:22;11129:52;;;;;-1:-1:-1;;;;;11129:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;11216:8;;;11209:5;;11197:28;;-1:-1:-1;;;;;11216:8:0;;;;11209:5;;;;11197:28;;;11244:8;;;;11236:16;;-1:-1:-1;;11236:16:0;;;-1:-1:-1;;;;;11244:8:0;;11236:16;;;;11263:21;;;11084:208::o;17940:331::-;10397:12;:10;:12::i;:::-;18042:3;1574:23;1588:8;1574:13;:23::i;:::-;18064:3;1928:18;1937:8;1928;:18::i;:::-;18099:11;;:24;;18115:7;18099:24;:15;:24;:::i;:::-;18085:11;:38;-1:-1:-1;;;;;18151:14:0;;;;;;:9;:14;;;;;;:27;;18170:7;18151:27;:18;:27;:::i;:::-;-1:-1:-1;;;;;18134:14:0;;;;;;:9;:14;;;;;;;;;:44;;;;18196:17;;;;;;;;;;;;;;;;;;18229:34;;;;;;;;-1:-1:-1;;;;;18229:34:0;;;18246:1;;-1:-1:-1;;;;;;;;;;;18229:34:0;;;;;;;;1608:1;10420;17940:331;;:::o;9899:20::-;;;-1:-1:-1;;;;;9899:20:0;;:::o;4195:::-;;;;;;;;;;;;;;;-1:-1:-1;;4195:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18555:272;10397:12;:10;:12::i;:::-;-1:-1:-1;;;;;18651:16:0;;;;;;:9;:16;;;;;;:29;;18672:7;18651:29;:20;:29;:::i;:::-;-1:-1:-1;;;;;18632:16:0;;;;;;:9;:16;;;;;:48;18705:11;;:24;;18721:7;18705:24;:15;:24;:::i;:::-;18691:11;:38;18747:36;;;;;;;;18771:1;;-1:-1:-1;;;;;18747:36:0;;;-1:-1:-1;;;;;;;;;;;18747:36:0;;;;;;;;18799:20;;;;;;;;;;;;;;;;;18555:272;;:::o;19297:170::-;19377:12;17139:19;:17;:19::i;:::-;19409:27;19424:3;19429:6;19409:14;:27::i;:::-;19402:35;;;;;;-1:-1:-1;19455:4:0;19297:170;;;;:::o;16170:35::-;;;;;;:::o;9926:23::-;;;-1:-1:-1;;;;;9926:23:0;;:::o;4335:66::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;10835:158::-;10397:12;:10;:12::i;:::-;10930:5;;-1:-1:-1;;;;;10917:18:0;;;10930:5;;10917:18;;10909:45;;;;;-1:-1:-1;;;;;10909:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;10965:8;:20;;-1:-1:-1;;10965:20:0;-1:-1:-1;;;;;10965:20:0;;;;;;;;;;10835:158::o;1672:128::-;-1:-1:-1;;;;;1746:22:0;;;;1738:54;;;;;-1:-1:-1;;;;;1738:54:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;1672:128;:::o;10484:104::-;10553:5;;-1:-1:-1;;;;;10553:5:0;10539:10;:19;10531:49;;;;;-1:-1:-1;;;;;10531:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;10484:104::o;17233:113::-;17295:16;;;;17287:51;;;;;;;-1:-1:-1;;;;;17287:51:0;;;;;;;;;;;;;;;;;;;;;;;;;;;6847:443;7003:12;6951:5;1574:23;1588:8;1574:13;:23::i;:::-;6980:3;1574:23;1588:8;1574:13;:23::i;:::-;-1:-1:-1;;;;;7064:16:0;;;;;;:9;:16;;;;;;;;7081:10;7064:28;;;;;;;;:40;;7097:6;7064:40;:32;:40;:::i;:::-;-1:-1:-1;;;;;7033:16:0;;;;;;:9;:16;;;;;;;;7050:10;7033:28;;;;;;;:71;;;;7134:16;;;:9;:16;;;;;:28;;7155:6;7134:28;:20;:28;:::i;:::-;-1:-1:-1;;;;;7115:16:0;;;;;;;:9;:16;;;;;;:47;;;;7190:14;;;;;;;:26;;7209:6;7190:26;:18;:26;:::i;:::-;-1:-1:-1;;;;;7173:14:0;;;;;;;:9;:14;;;;;;;;;:43;;;;7232:28;;;;;;;7173:14;;7232:28;;;;-1:-1:-1;;;;;;;;;;;7232:28:0;;;;;;;;-1:-1:-1;7278:4:0;;6847:443;-1:-1:-1;;;;;6847:443:0:o;2021:126::-;-1:-1:-1;;;;;2090:25:0;;2110:4;2090:25;;2082:57;;;;;-1:-1:-1;;;;;2082:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;12625:174;11560:38;;;;;;;;;;;;;;;;-1:-1:-1;;;;;12731:59:0;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;12731:59:0;;;;;;;;25:18:-1;;61:17;;12731:59:0;182:15:-1;12731:59:0;;;;179:29:-1;;;;160:49;;;12715:76:0;;12723:6;;12715:7;:76::i;:::-;12625:174;;;:::o;2531:169::-;2591:7;2623;;;2649;;;;2641:32;;;;;-1:-1:-1;;;;;2641:32:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;2691:1;2531:169;-1:-1:-1;;;2531:169:0:o;2923:147::-;2983:7;3011:8;;;;3003:34;;;;;-1:-1:-1;;;;;3003:34:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3055:7:0;;;2923:147::o;6118:328::-;6226:12;6203:3;1574:23;1588:8;1574:13;:23::i;:::-;6290:10;6280:21;;;;:9;:21;;;;;;:33;;6306:6;6280:33;:25;:33;:::i;:::-;6266:10;6256:21;;;;:9;:21;;;;;;:57;;;;-1:-1:-1;;;;;6341:14:0;;;;;;:26;;6360:6;6341:26;:18;:26;:::i;:::-;-1:-1:-1;;;;;6324:14:0;;;;;;:9;:14;;;;;;;;;:43;;;;6383:33;;;;;;;6324:14;;6392:10;;-1:-1:-1;;;;;;;;;;;6383:33:0;;;;;;;;;-1:-1:-1;6434:4:0;;6118:328;-1:-1:-1;;;6118:328:0:o;13760:793::-;13836:21;;:::i;:::-;:36;;;;;;;;;13869:1;13836:36;;;;;14353:2;14303:3;14207:5;14201:12;14109:2;14102:5;14098:14;14053:1;13997:6;13947:3;13924:476;14424:7;14417:15;14414:2;;;14462:1;14459;14452:12;14414:2;-1:-1:-1;14510:6:0;;:11;;14502:43;;;;;-1:-1:-1;;;;;14502:43:0;;;;;;;;;;;;;;;;;;;;;;;;;;;16018:4125;;;;;;;;;;;;29:2:-1;21:6;17:15;117:4;105:10;97:6;88:34;-1:-1;16018:4125:0;;;-1:-1:-1;;16018:4125:0:o
Swarm Source
bzzr://beee208c22ae870537d105c61a090e7f41fa6f1fef41c468ae684af1b789c865
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.