More Info
Private Name Tags
ContractCreator
Latest 25 from a total of 216 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Swap | 15935707 | 627 days ago | IN | 0 ETH | 0.00634535 | ||||
Swap | 15354456 | 713 days ago | IN | 0 ETH | 0.00103795 | ||||
Swap | 14479009 | 853 days ago | IN | 0 ETH | 0.00230907 | ||||
Swap | 13495532 | 1006 days ago | IN | 0 ETH | 0.01017959 | ||||
Swap | 13479815 | 1009 days ago | IN | 0 ETH | 0.00401505 | ||||
Swap | 13375598 | 1025 days ago | IN | 0 ETH | 0.00607543 | ||||
Swap | 13375598 | 1025 days ago | IN | 0 ETH | 0.00901188 | ||||
Swap | 13362701 | 1027 days ago | IN | 0 ETH | 0.01395826 | ||||
Swap | 13347287 | 1030 days ago | IN | 0 ETH | 0.0023869 | ||||
Swap | 13347287 | 1030 days ago | IN | 0 ETH | 0.00387521 | ||||
Swap | 13262542 | 1043 days ago | IN | 0 ETH | 0.00567711 | ||||
Swap | 13248928 | 1045 days ago | IN | 0 ETH | 0.00280661 | ||||
Swap | 13205521 | 1052 days ago | IN | 0 ETH | 0.0065387 | ||||
Swap | 13180842 | 1055 days ago | IN | 0 ETH | 0.0105528 | ||||
Swap | 13166178 | 1058 days ago | IN | 0 ETH | 0.00667742 | ||||
Swap | 13139006 | 1062 days ago | IN | 0 ETH | 0.00762735 | ||||
Swap | 13136775 | 1062 days ago | IN | 0 ETH | 0.0088455 | ||||
Swap | 13135405 | 1063 days ago | IN | 0 ETH | 0.01651366 | ||||
Swap | 13055465 | 1075 days ago | IN | 0 ETH | 0.0022971 | ||||
Swap | 13031908 | 1079 days ago | IN | 0 ETH | 0.00412564 | ||||
Swap | 13016987 | 1081 days ago | IN | 0 ETH | 0.00283199 | ||||
Swap | 13016823 | 1081 days ago | IN | 0 ETH | 0.00123441 | ||||
Swap | 13013580 | 1081 days ago | IN | 0 ETH | 0.0047728 | ||||
Swap | 13007176 | 1082 days ago | IN | 0 ETH | 0.00296176 | ||||
Swap | 12993260 | 1084 days ago | IN | 0 ETH | 0.00630981 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
UNLSplit
Compiler Version
v0.6.12+commit.27d51765
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2021-05-07 */ /** *Submitted for verification at Etherscan.io on 2020-10-10 */ // SPDX-License-Identifier: MIT pragma solidity 0.6.12; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Returns the amount of tokens in existence. */ /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, uint256 amount) external returns (bool); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `sender` to `recipient` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); } /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when an * operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } /** * @dev Returns the integer division of two unsigned integers. Reverts on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } /** * @dev Returns the integer division of two unsigned integers. Reverts with custom message on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ } /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // This method relies in extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success, ) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain`call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return _functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); return _functionCallWithValue(target, data, value, errorMessage); } function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: weiValue }(data); if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin guidelines: functions revert instead * of returning `false` on failure. This behavior is nonetheless conventional * and does not conflict with the expectations of ERC20 applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract UNLSplit { using Address for address; using SafeMath for uint; address public newUNL; address public oldUNL; address public owner; uint public ratio; constructor(address _newUNL,address _oldUNL,uint _ratio) public{ owner = msg.sender; newUNL = _newUNL; oldUNL = _oldUNL; ratio = _ratio; } function changeConfig(address _newUNL,address _oldUNL,uint _ratio) public returns (uint){ require(msg.sender == owner, ' You are not allowed to execute this function'); newUNL = _newUNL; oldUNL = _oldUNL; ratio = _ratio; } function swap() public returns(uint){ uint balance = IERC20(address(oldUNL)).balanceOf(msg.sender); IERC20(address(oldUNL)).transferFrom(msg.sender,address(this),balance); IERC20(address(newUNL)).transfer(msg.sender,balance.mul(ratio)); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_newUNL","type":"address"},{"internalType":"address","name":"_oldUNL","type":"address"},{"internalType":"uint256","name":"_ratio","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"_newUNL","type":"address"},{"internalType":"address","name":"_oldUNL","type":"address"},{"internalType":"uint256","name":"_ratio","type":"uint256"}],"name":"changeConfig","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"newUNL","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"oldUNL","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ratio","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"swap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
608060405234801561001057600080fd5b506040516108463803806108468339818101604052606081101561003357600080fd5b8101908080519060200190929190805190602001909291908051906020019092919050505033600260006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550826000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555081600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555080600381905550505050610713806101336000396000f3fe608060405234801561001057600080fd5b50600436106100625760003560e01c806322a013351461006757806337f243b3146100e9578063545f1f941461011d57806371ca337d146101515780638119c0651461016f5780638da5cb5b1461018d575b600080fd5b6100d36004803603606081101561007d57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190803573ffffffffffffffffffffffffffffffffffffffff169060200190929190803590602001909291905050506101c1565b6040518082815260200191505060405180910390f35b6100f16102f8565b604051808273ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b61012561031c565b604051808273ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b610159610342565b6040518082815260200191505060405180910390f35b610177610348565b6040518082815260200191505060405180910390f35b6101956105e3565b604051808273ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b6000600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610269576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252602d815260200180610690602d913960400191505060405180910390fd5b836000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555082600160006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550816003819055509392505050565b60008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60035481565b600080600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a08231336040518263ffffffff1660e01b8152600401808273ffffffffffffffffffffffffffffffffffffffff16815260200191505060206040518083038186803b1580156103d457600080fd5b505afa1580156103e8573d6000803e3d6000fd5b505050506040513d60208110156103fe57600080fd5b81019080805190602001909291905050509050600160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166323b872dd3330846040518463ffffffff1660e01b8152600401808473ffffffffffffffffffffffffffffffffffffffff1681526020018373ffffffffffffffffffffffffffffffffffffffff1681526020018281526020019350505050602060405180830381600087803b1580156104c257600080fd5b505af11580156104d6573d6000803e3d6000fd5b505050506040513d60208110156104ec57600080fd5b81019080805190602001909291905050505060008054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663a9059cbb336105506003548561060990919063ffffffff16565b6040518363ffffffff1660e01b8152600401808373ffffffffffffffffffffffffffffffffffffffff16815260200182815260200192505050602060405180830381600087803b1580156105a357600080fd5b505af11580156105b7573d6000803e3d6000fd5b505050506040513d60208110156105cd57600080fd5b8101908080519060200190929190505050505090565b600260009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b60008083141561061c5760009050610689565b600082840290508284828161062d57fe5b0414610684576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260218152602001806106bd6021913960400191505060405180910390fd5b809150505b9291505056fe20596f7520617265206e6f7420616c6c6f77656420746f206578656375746520746869732066756e6374696f6e536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f77a26469706673582212207d55e24c9aa38d366b0f606230f3979ead1cf5988e6ae9a3ee336dd85bc2f4e964736f6c634300060c0033000000000000000000000000354e514c135c8603f840ffadb4c33cde6d2a37e000000000000000000000000004ab43d32d0172c76f5287b6619f0aa50af893030000000000000000000000000000000000000000000000000000000000004e20
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000354e514c135c8603f840ffadb4c33cde6d2a37e000000000000000000000000004ab43d32d0172c76f5287b6619f0aa50af893030000000000000000000000000000000000000000000000000000000000004e20
-----Decoded View---------------
Arg [0] : _newUNL (address): 0x354E514c135c8603f840ffADb4c33cDE6D2A37e0
Arg [1] : _oldUNL (address): 0x04aB43d32D0172C76F5287B6619f0aa50aF89303
Arg [2] : _ratio (uint256): 20000
-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000354e514c135c8603f840ffadb4c33cde6d2a37e0
Arg [1] : 00000000000000000000000004ab43d32d0172c76f5287b6619f0aa50af89303
Arg [2] : 0000000000000000000000000000000000000000000000000000000000004e20
Deployed Bytecode Sourcemap
14106:966:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14499:263;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;14194:21;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;14222:22;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;14278:17;;;:::i;:::-;;;;;;;;;;;;;;;;;;;14775:270;;;:::i;:::-;;;;;;;;;;;;;;;;;;;14251:20;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;14499:263;14582:4;14620:5;;;;;;;;;;;14606:19;;:10;:19;;;14598:77;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14695:7;14686:6;;:16;;;;;;;;;;;;;;;;;;14722:7;14713:6;;:16;;;;;;;;;;;;;;;;;;14748:6;14740:5;:14;;;;14499:263;;;;;:::o;14194:21::-;;;;;;;;;;;;:::o;14222:22::-;;;;;;;;;;;;;:::o;14278:17::-;;;;:::o;14775:270::-;14806:4;14822:12;14852:6;;;;;;;;;;;14837:33;;;14871:10;14837:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14822:60;;14908:6;;;;;;;;;;;14893:36;;;14930:10;14949:4;14955:7;14893:70;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14989:6;;;;;;;;;;14974:32;;;15007:10;15018:18;15030:5;;15018:7;:11;;:18;;;;:::i;:::-;14974:63;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14775:270;;:::o;14251:20::-;;;;;;;;;;;;;:::o;4614:471::-;4672:7;4922:1;4917;:6;4913:47;;;4947:1;4940:8;;;;4913:47;4972:9;4988:1;4984;:5;4972:17;;5017:1;5012;5008;:5;;;;;;:10;5000:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5076:1;5069:8;;;4614:471;;;;;:::o
Swarm Source
ipfs://7d55e24c9aa38d366b0f606230f3979ead1cf5988e6ae9a3ee336dd85bc2f4e9
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.