Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 25 from a total of 71 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Claim | 17723099 | 370 days ago | IN | 0 ETH | 0.00320113 | ||||
Claim | 17715112 | 371 days ago | IN | 0 ETH | 0.00239437 | ||||
Claim | 17714977 | 371 days ago | IN | 0 ETH | 0.00413228 | ||||
Claim | 16866465 | 491 days ago | IN | 0 ETH | 0.00169775 | ||||
Claim | 16866365 | 491 days ago | IN | 0 ETH | 0.002347 | ||||
Claim To | 16634193 | 523 days ago | IN | 0 ETH | 0.0045915 | ||||
Claim | 16369621 | 560 days ago | IN | 0 ETH | 0.00235557 | ||||
Claim | 16266094 | 575 days ago | IN | 0 ETH | 0.00145445 | ||||
Claim | 16170775 | 588 days ago | IN | 0 ETH | 0.00264673 | ||||
Claim | 15965519 | 617 days ago | IN | 0 ETH | 0.0025904 | ||||
Claim | 15946530 | 619 days ago | IN | 0 ETH | 0.00228128 | ||||
Claim | 15830667 | 635 days ago | IN | 0 ETH | 0.00142491 | ||||
Claim | 15830652 | 635 days ago | IN | 0 ETH | 0.0017293 | ||||
Claim | 15829086 | 636 days ago | IN | 0 ETH | 0.00177315 | ||||
Claim | 15829052 | 636 days ago | IN | 0 ETH | 0.0015809 | ||||
Claim | 15638073 | 662 days ago | IN | 0 ETH | 0.00147167 | ||||
Claim | 15480689 | 686 days ago | IN | 0 ETH | 0.00143479 | ||||
Claim | 15403474 | 698 days ago | IN | 0 ETH | 0.00163975 | ||||
Claim | 15366160 | 704 days ago | IN | 0 ETH | 0.00452194 | ||||
Claim | 15191931 | 731 days ago | IN | 0 ETH | 0.00156756 | ||||
Claim | 14972633 | 767 days ago | IN | 0 ETH | 0.00603687 | ||||
Claim | 14444978 | 852 days ago | IN | 0 ETH | 0.00799559 | ||||
Claim | 14177816 | 893 days ago | IN | 0 ETH | 0.00509449 | ||||
Claim | 13638679 | 977 days ago | IN | 0 ETH | 0.0237542 | ||||
Claim | 13475902 | 1003 days ago | IN | 0 ETH | 0.01200996 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
FreeMinter
Compiler Version
v0.5.12+commit.7709ece9
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2020-11-24 */ pragma solidity 0.5.12; pragma experimental ABIEncoderV2; contract IResolver { /** * @dev Reset all domain records and set new ones * @param keys New record keys * @param values New record values * @param tokenId ERC-721 token id of the domain */ function reconfigure(string[] memory keys, string[] memory values, uint256 tokenId) public; /** * @dev Set all domain records for newly minted domain * @param keys New record keys * @param values New record values * @param tokenId ERC-721 token id of the domain */ function preconfigure(string[] memory keys, string[] memory values, uint256 tokenId) public; /** * @dev Set or update domain records * @param keys New record keys * @param values New record values * @param tokenId ERC-721 token id of the domain */ function setMany(string[] memory keys, string[] memory values, uint256 tokenId) public; /** * @dev Function to set record. * @param key The key set the value of. * @param value The value to set key to. * @param tokenId ERC-721 token id to set. */ function set(string calldata key, string calldata value, uint256 tokenId) external; /** * @dev Function to reset all existing records on a domain. * @param tokenId ERC-721 token id to set. */ function reset(uint256 tokenId) external; } interface IRegistryReader { function name() external view returns (string memory); function symbol() external view returns (string memory); function tokenURI(uint256 tokenId) external view returns (string memory); /** * @dev Returns whether the given spender can transfer a given token ID. Registry related function. * @param spender address of the spender to query * @param tokenId uint256 ID of the token to be transferred * @return bool whether the msg.sender is approved for the given token ID, * is an operator of the owner, or is the owner of the token */ function isApprovedOrOwner(address spender, uint256 tokenId) external view returns (bool); /** * @dev Gets the resolver of the specified token ID. Registry related function. * @param tokenId uint256 ID of the token to query the resolver of * @return address currently marked as the resolver of the given token ID */ function resolverOf(uint256 tokenId) external view returns (address); /** * @dev Provides child token (subdomain) of provided tokenId. Registry related function. * @param tokenId uint256 ID of the token * @param label label of subdomain (for `aaa.bbb.crypto` it will be `aaa`) */ function childIdOf(uint256 tokenId, string calldata label) external view returns (uint256); /** * @dev Controller related function. * @return bool whether the account is a controller */ function isController(address account) external view returns (bool); /** * @dev Returns the number of NFTs in `owner`'s account. ERC721 related function. */ function balanceOf(address owner) external view returns (uint256); /** * @dev Returns the owner of the NFT specified by `tokenId`. ERC721 related function. */ function ownerOf(uint256 tokenId) external view returns (address); /** * @dev ERC721 related function. */ function getApproved(uint256 tokenId) external view returns (address); /** * @dev ERC721 related function. */ function isApprovedForAll(address owner, address operator) external view returns (bool); /** * @dev Registry related function. * @return root hash. */ function root() external view returns (uint256); } /** * @title Roles * @dev Library for managing addresses assigned to a Role. */ library Roles { struct Role { mapping (address => bool) bearer; } /** * @dev Give an account access to this role. */ function add(Role storage role, address account) internal { require(!has(role, account), "Roles: account already has role"); role.bearer[account] = true; } /** * @dev Remove an account's access to this role. */ function remove(Role storage role, address account) internal { require(has(role, account), "Roles: account does not have role"); role.bearer[account] = false; } /** * @dev Check if an account has this role. * @return bool */ function has(Role storage role, address account) internal view returns (bool) { require(account != address(0), "Roles: account is the zero address"); return role.bearer[account]; } } contract MinterRole { using Roles for Roles.Role; event MinterAdded(address indexed account); event MinterRemoved(address indexed account); Roles.Role private _minters; constructor () internal { _addMinter(msg.sender); } modifier onlyMinter() { require(isMinter(msg.sender), "MinterRole: caller does not have the Minter role"); _; } function isMinter(address account) public view returns (bool) { return _minters.has(account); } function addMinter(address account) public onlyMinter { _addMinter(account); } function renounceMinter() public { _removeMinter(msg.sender); } function _addMinter(address account) internal { _minters.add(account); emit MinterAdded(account); } function _removeMinter(address account) internal { _minters.remove(account); emit MinterRemoved(account); } } interface IMintingController { /** * @dev Minter function that mints a Second Level Domain (SLD). * @param to address to mint the new SLD to. * @param label SLD label to mint. */ function mintSLD(address to, string calldata label) external; /** * @dev Minter function that safely mints a Second Level Domain (SLD). * Implements a ERC721Reciever check unlike mintSLD. * @param to address to mint the new SLD to. * @param label SLD label to mint. */ function safeMintSLD(address to, string calldata label) external; /** * @dev Minter function that safely mints a Second Level Domain (SLD). * Implements a ERC721Reciever check unlike mintSLD. * @param to address to mint the new SLD to. * @param label SLD label to mint. * @param _data bytes data to send along with a safe transfer check */ function safeMintSLD(address to, string calldata label, bytes calldata _data) external; } /** * @dev Interface of the ERC165 standard, as defined in the * [EIP](https://eips.ethereum.org/EIPS/eip-165). * * Implementers can declare support of contract interfaces, which can then be * queried by others (`ERC165Checker`). * * For an implementation, see `ERC165`. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified) * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); } /** * @dev Required interface of an ERC721 compliant contract. */ contract IERC721 is IERC165 { event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of NFTs in `owner`'s account. */ function balanceOf(address owner) public view returns (uint256 balance); /** * @dev Returns the owner of the NFT specified by `tokenId`. */ function ownerOf(uint256 tokenId) public view returns (address owner); /** * @dev Transfers a specific NFT (`tokenId`) from one account (`from`) to * another (`to`). * * * * Requirements: * - `from`, `to` cannot be zero. * - `tokenId` must be owned by `from`. * - If the caller is not `from`, it must be have been allowed to move this * NFT by either `approve` or `setApproveForAll`. */ function safeTransferFrom(address from, address to, uint256 tokenId) public; /** * @dev Transfers a specific NFT (`tokenId`) from one account (`from`) to * another (`to`). * * Requirements: * - If the caller is not `from`, it must be approved to move this NFT by * either `approve` or `setApproveForAll`. */ function transferFrom(address from, address to, uint256 tokenId) public; 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 safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public; } /** * @title ERC-721 Non-Fungible Token Standard, optional metadata extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ contract IERC721Metadata is IERC721 { function name() external view returns (string memory); function symbol() external view returns (string memory); function tokenURI(uint256 tokenId) external view returns (string memory); } contract IRegistry is IERC721Metadata { event NewURI(uint256 indexed tokenId, string uri); event NewURIPrefix(string prefix); event Resolve(uint256 indexed tokenId, address indexed to); event Sync(address indexed resolver, uint256 indexed updateId, uint256 indexed tokenId); /** * @dev Controlled function to set the token URI Prefix for all tokens. * @param prefix string URI to assign */ function controlledSetTokenURIPrefix(string calldata prefix) external; /** * @dev Returns whether the given spender can transfer a given token ID. * @param spender address of the spender to query * @param tokenId uint256 ID of the token to be transferred * @return bool whether the msg.sender is approved for the given token ID, * is an operator of the owner, or is the owner of the token */ function isApprovedOrOwner(address spender, uint256 tokenId) external view returns (bool); /** * @dev Mints a new a child token. * Calculates child token ID using a namehash function. * Requires the msg.sender to be the owner, approved, or operator of tokenId. * Requires the token not exist. * @param to address to receive the ownership of the given token ID * @param tokenId uint256 ID of the parent token * @param label subdomain label of the child token ID */ function mintChild(address to, uint256 tokenId, string calldata label) external; /** * @dev Controlled function to mint a given token ID. * Requires the msg.sender to be controller. * Requires the token ID to not exist. * @param to address the given token ID will be minted to * @param label string that is a subdomain * @param tokenId uint256 ID of the parent token */ function controlledMintChild(address to, uint256 tokenId, string calldata label) external; /** * @dev Transfers the ownership of a child token ID to another address. * Calculates child token ID using a namehash function. * Requires the msg.sender to be the owner, approved, or operator of tokenId. * Requires the token already exist. * @param from current owner of the token * @param to address to receive the ownership of the given token ID * @param tokenId uint256 ID of the token to be transferred * @param label subdomain label of the child token ID */ function transferFromChild(address from, address to, uint256 tokenId, string calldata label) external; /** * @dev Controlled function to transfers the ownership of a token ID to * another address. * Requires the msg.sender to be controller. * Requires the token already exist. * @param from current owner of the token * @param to address to receive the ownership of the given token ID * @param tokenId uint256 ID of the token to be transferred */ function controlledTransferFrom(address from, address to, uint256 tokenId) external; /** * @dev Safely transfers the ownership of a child token ID to another address. * Calculates child token ID using a namehash function. * Implements a ERC721Reciever check unlike transferFromChild. * Requires the msg.sender to be the owner, approved, or operator of tokenId. * Requires the token already exist. * @param from current owner of the token * @param to address to receive the ownership of the given token ID * @param tokenId uint256 parent ID of the token to be transferred * @param label subdomain label of the child token ID * @param _data bytes data to send along with a safe transfer check */ function safeTransferFromChild(address from, address to, uint256 tokenId, string calldata label, bytes calldata _data) external; /// Shorthand for calling the above ^^^ safeTransferFromChild function with an empty _data parameter. Similar to ERC721.safeTransferFrom. function safeTransferFromChild(address from, address to, uint256 tokenId, string calldata label) external; /** * @dev Controlled frunction to safely transfers the ownership of a token ID * to another address. * Implements a ERC721Reciever check unlike controlledSafeTransferFrom. * Requires the msg.sender to be controller. * Requires the token already exist. * @param from current owner of the token * @param to address to receive the ownership of the given token ID * @param tokenId uint256 parent ID of the token to be transferred * @param _data bytes data to send along with a safe transfer check */ function controlledSafeTransferFrom(address from, address to, uint256 tokenId, bytes calldata _data) external; /** * @dev Burns a child token ID. * Calculates child token ID using a namehash function. * Requires the msg.sender to be the owner, approved, or operator of tokenId. * Requires the token already exist. * @param tokenId uint256 ID of the token to be transferred * @param label subdomain label of the child token ID */ function burnChild(uint256 tokenId, string calldata label) external; /** * @dev Controlled function to burn a given token ID. * Requires the msg.sender to be controller. * Requires the token already exist. * @param tokenId uint256 ID of the token to be burned */ function controlledBurn(uint256 tokenId) external; /** * @dev Sets the resolver of a given token ID to another address. * Requires the msg.sender to be the owner, approved, or operator. * @param to address the given token ID will resolve to * @param tokenId uint256 ID of the token to be transferred */ function resolveTo(address to, uint256 tokenId) external; /** * @dev Gets the resolver of the specified token ID. * @param tokenId uint256 ID of the token to query the resolver of * @return address currently marked as the resolver of the given token ID */ function resolverOf(uint256 tokenId) external view returns (address); /** * @dev Controlled function to sets the resolver of a given token ID. * Requires the msg.sender to be controller. * @param to address the given token ID will resolve to * @param tokenId uint256 ID of the token to be transferred */ function controlledResolveTo(address to, uint256 tokenId) external; /** * @dev Provides child token (subdomain) of provided tokenId. * @param tokenId uint256 ID of the token * @param label label of subdomain (for `aaa.bbb.crypto` it will be `aaa`) */ function childIdOf(uint256 tokenId, string calldata label) external pure returns (uint256); /** * @dev Transfer domain ownership without resetting domain records. * @param to address of new domain owner * @param tokenId uint256 ID of the token to be transferred */ function setOwner(address to, uint256 tokenId) external; } /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ contract IERC721Receiver { /** * @notice Handle the receipt of an NFT * @dev The ERC721 smart contract calls this function on the recipient * after a `safeTransfer`. This function MUST return the function selector, * otherwise the caller will revert the transaction. The selector to be * returned can be obtained as `this.onERC721Received.selector`. This * function MAY throw to revert and reject the transfer. * Note: the ERC721 contract address is always the message sender. * @param operator The address which called `safeTransferFrom` function * @param from The address which previously owned the token * @param tokenId The NFT identifier which is being transferred * @param data Additional data with no specified format * @return bytes4 `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))` */ function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data) public returns (bytes4); } /** * @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) { require(b <= a, "SafeMath: subtraction overflow"); 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) { // Solidity only automatically asserts when dividing by 0 require(b > 0, "SafeMath: division by zero"); 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. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b != 0, "SafeMath: modulo by zero"); return a % b; } } /** * @dev Collection of functions related to the address type, */ library Address { /** * @dev Returns true if `account` is a contract. * * This test is non-exhaustive, and there may be false-negatives: during the * execution of a contract's constructor, its address will be reported as * not containing a contract. * * > It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. */ 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; } } /** * @title Counters * @author Matt Condon (@shrugs) * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number * of elements in a mapping, issuing ERC721 ids, or counting request ids. * * Include with `using Counters for Counters.Counter;` * Since it is not possible to overflow a 256 bit integer with increments of one, `increment` can skip the SafeMath * overflow check, thereby saving gas. This does assume however correct usage, in that the underlying `_value` is never * directly accessed. */ library Counters { using SafeMath for uint256; struct Counter { // This variable should never be directly accessed by users of the library: interactions must be restricted to // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add // this feature: see https://github.com/ethereum/solidity/issues/4637 uint256 _value; // default: 0 } function current(Counter storage counter) internal view returns (uint256) { return counter._value; } function increment(Counter storage counter) internal { counter._value += 1; } function decrement(Counter storage counter) internal { counter._value = counter._value.sub(1); } } /** * @dev Implementation of the `IERC165` interface. * * Contracts may inherit from this and call `_registerInterface` to declare * their support of an interface. */ contract ERC165 is IERC165 { /* * bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7 */ bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7; /** * @dev Mapping of interface ids to whether or not it's supported. */ mapping(bytes4 => bool) private _supportedInterfaces; constructor () internal { // Derived contracts need only register support for their own interfaces, // we register support for ERC165 itself here _registerInterface(_INTERFACE_ID_ERC165); } /** * @dev See `IERC165.supportsInterface`. * * Time complexity O(1), guaranteed to always use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool) { return _supportedInterfaces[interfaceId]; } /** * @dev Registers the contract as an implementer of the interface defined by * `interfaceId`. Support of the actual ERC165 interface is automatic and * registering its interface id is not required. * * See `IERC165.supportsInterface`. * * Requirements: * * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`). */ function _registerInterface(bytes4 interfaceId) internal { require(interfaceId != 0xffffffff, "ERC165: invalid interface id"); _supportedInterfaces[interfaceId] = true; } } /** * @title ERC721 Non-Fungible Token Standard basic implementation * @dev see https://eips.ethereum.org/EIPS/eip-721 */ contract ERC721 is ERC165, IERC721 { using SafeMath for uint256; using Address for address; using Counters for Counters.Counter; // Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))` // which can be also obtained as `IERC721Receiver(0).onERC721Received.selector` bytes4 private constant _ERC721_RECEIVED = 0x150b7a02; // Mapping from token ID to owner mapping (uint256 => address) private _tokenOwner; // Mapping from token ID to approved address mapping (uint256 => address) private _tokenApprovals; // Mapping from owner to number of owned token mapping (address => Counters.Counter) private _ownedTokensCount; // Mapping from owner to operator approvals mapping (address => mapping (address => bool)) private _operatorApprovals; /* * bytes4(keccak256('balanceOf(address)')) == 0x70a08231 * bytes4(keccak256('ownerOf(uint256)')) == 0x6352211e * bytes4(keccak256('approve(address,uint256)')) == 0x095ea7b3 * bytes4(keccak256('getApproved(uint256)')) == 0x081812fc * bytes4(keccak256('setApprovalForAll(address,bool)')) == 0xa22cb465 * bytes4(keccak256('isApprovedForAll(address,address)')) == 0xe985e9c * bytes4(keccak256('transferFrom(address,address,uint256)')) == 0x23b872dd * bytes4(keccak256('safeTransferFrom(address,address,uint256)')) == 0x42842e0e * bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)')) == 0xb88d4fde * * => 0x70a08231 ^ 0x6352211e ^ 0x095ea7b3 ^ 0x081812fc ^ * 0xa22cb465 ^ 0xe985e9c ^ 0x23b872dd ^ 0x42842e0e ^ 0xb88d4fde == 0x80ac58cd */ bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd; constructor () public { // register the supported interfaces to conform to ERC721 via ERC165 _registerInterface(_INTERFACE_ID_ERC721); } /** * @dev Gets the balance of the specified address. * @param owner address to query the balance of * @return uint256 representing the amount owned by the passed address */ function balanceOf(address owner) public view returns (uint256) { require(owner != address(0), "ERC721: balance query for the zero address"); return _ownedTokensCount[owner].current(); } /** * @dev Gets the owner of the specified token ID. * @param tokenId uint256 ID of the token to query the owner of * @return address currently marked as the owner of the given token ID */ function ownerOf(uint256 tokenId) public view returns (address) { address owner = _tokenOwner[tokenId]; require(owner != address(0), "ERC721: owner query for nonexistent token"); return owner; } /** * @dev Approves another address to transfer the given token ID * The zero address indicates there is no approved address. * There can only be one approved address per token at a given time. * Can only be called by the token owner or an approved operator. * @param to address to be approved for the given token ID * @param tokenId uint256 ID of the token to be approved */ function approve(address to, uint256 tokenId) public { address owner = ownerOf(tokenId); require(to != owner, "ERC721: approval to current owner"); require(msg.sender == owner || isApprovedForAll(owner, msg.sender), "ERC721: approve caller is not owner nor approved for all" ); _tokenApprovals[tokenId] = to; emit Approval(owner, to, tokenId); } /** * @dev Gets the approved address for a token ID, or zero if no address set * Reverts if the token ID does not exist. * @param tokenId uint256 ID of the token to query the approval of * @return address currently approved for the given token ID */ function getApproved(uint256 tokenId) public view returns (address) { require(_exists(tokenId), "ERC721: approved query for nonexistent token"); return _tokenApprovals[tokenId]; } /** * @dev Sets or unsets the approval of a given operator * An operator is allowed to transfer all tokens of the sender on their behalf. * @param to operator address to set the approval * @param approved representing the status of the approval to be set */ function setApprovalForAll(address to, bool approved) public { require(to != msg.sender, "ERC721: approve to caller"); _operatorApprovals[msg.sender][to] = approved; emit ApprovalForAll(msg.sender, to, approved); } /** * @dev Tells whether an operator is approved by a given owner. * @param owner owner address which you want to query the approval of * @param operator operator address which you want to query the approval of * @return bool whether the given operator is approved by the given owner */ function isApprovedForAll(address owner, address operator) public view returns (bool) { return _operatorApprovals[owner][operator]; } /** * @dev Transfers the ownership of a given token ID to another address. * Usage of this method is discouraged, use `safeTransferFrom` whenever possible. * Requires the msg.sender to be the owner, approved, or operator. * @param from current owner of the token * @param to address to receive the ownership of the given token ID * @param tokenId uint256 ID of the token to be transferred */ function transferFrom(address from, address to, uint256 tokenId) public { //solhint-disable-next-line max-line-length require(_isApprovedOrOwner(msg.sender, tokenId), "ERC721: transfer caller is not owner nor approved"); _transferFrom(from, to, tokenId); } /** * @dev Safely transfers the ownership of a given token ID to another address * If the target address is a contract, it must implement `onERC721Received`, * which is called upon a safe transfer, and return the magic value * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise, * the transfer is reverted. * Requires the msg.sender to be the owner, approved, or operator * @param from current owner of the token * @param to address to receive the ownership of the given token ID * @param tokenId uint256 ID of the token to be transferred */ function safeTransferFrom(address from, address to, uint256 tokenId) public { safeTransferFrom(from, to, tokenId, ""); } /** * @dev Safely transfers the ownership of a given token ID to another address * If the target address is a contract, it must implement `onERC721Received`, * which is called upon a safe transfer, and return the magic value * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise, * the transfer is reverted. * Requires the msg.sender to be the owner, approved, or operator * @param from current owner of the token * @param to address to receive the ownership of the given token ID * @param tokenId uint256 ID of the token to be transferred * @param _data bytes data to send along with a safe transfer check */ function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public { transferFrom(from, to, tokenId); require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer"); } /** * @dev Returns whether the specified token exists. * @param tokenId uint256 ID of the token to query the existence of * @return bool whether the token exists */ function _exists(uint256 tokenId) internal view returns (bool) { address owner = _tokenOwner[tokenId]; return owner != address(0); } /** * @dev Returns whether the given spender can transfer a given token ID. * @param spender address of the spender to query * @param tokenId uint256 ID of the token to be transferred * @return bool whether the msg.sender is approved for the given token ID, * is an operator of the owner, or is the owner of the token */ function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) { require(_exists(tokenId), "ERC721: operator query for nonexistent token"); address owner = ownerOf(tokenId); return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender)); } /** * @dev Internal function to mint a new token. * Reverts if the given token ID already exists. * @param to The address that will own the minted token * @param tokenId uint256 ID of the token to be minted */ function _mint(address to, uint256 tokenId) internal { require(to != address(0), "ERC721: mint to the zero address"); require(!_exists(tokenId), "ERC721: token already minted"); _tokenOwner[tokenId] = to; _ownedTokensCount[to].increment(); emit Transfer(address(0), to, tokenId); } /** * @dev Internal function to burn a specific token. * Reverts if the token does not exist. * Deprecated, use _burn(uint256) instead. * @param owner owner of the token to burn * @param tokenId uint256 ID of the token being burned */ function _burn(address owner, uint256 tokenId) internal { require(ownerOf(tokenId) == owner, "ERC721: burn of token that is not own"); _clearApproval(tokenId); _ownedTokensCount[owner].decrement(); _tokenOwner[tokenId] = address(0); emit Transfer(owner, address(0), tokenId); } /** * @dev Internal function to burn a specific token. * Reverts if the token does not exist. * @param tokenId uint256 ID of the token being burned */ function _burn(uint256 tokenId) internal { _burn(ownerOf(tokenId), tokenId); } /** * @dev Internal function to transfer ownership of a given token ID to another address. * As opposed to transferFrom, this imposes no restrictions on msg.sender. * @param from current owner of the token * @param to address to receive the ownership of the given token ID * @param tokenId uint256 ID of the token to be transferred */ function _transferFrom(address from, address to, uint256 tokenId) internal { require(ownerOf(tokenId) == from, "ERC721: transfer of token that is not own"); require(to != address(0), "ERC721: transfer to the zero address"); _clearApproval(tokenId); _ownedTokensCount[from].decrement(); _ownedTokensCount[to].increment(); _tokenOwner[tokenId] = to; emit Transfer(from, to, tokenId); } /** * @dev Internal function to invoke `onERC721Received` on a target address. * The call is not executed if the target address is not a contract. * * This function is deprecated. * @param from address representing the previous owner of the given token ID * @param to target address that will receive the tokens * @param tokenId uint256 ID of the token to be transferred * @param _data bytes optional data to send along with the call * @return bool whether the call correctly returned the expected magic value */ function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data) internal returns (bool) { if (!to.isContract()) { return true; } bytes4 retval = IERC721Receiver(to).onERC721Received(msg.sender, from, tokenId, _data); return (retval == _ERC721_RECEIVED); } /** * @dev Private function to clear current approval of a given token ID. * @param tokenId uint256 ID of the token to be transferred */ function _clearApproval(uint256 tokenId) private { if (_tokenApprovals[tokenId] != address(0)) { _tokenApprovals[tokenId] = address(0); } } } /** * @title ERC721 Burnable Token * @dev ERC721 Token that can be irreversibly burned (destroyed). */ contract ERC721Burnable is ERC721 { /** * @dev Burns a specific ERC721 token. * @param tokenId uint256 id of the ERC721 token to be burned. */ function burn(uint256 tokenId) public { //solhint-disable-next-line max-line-length require(_isApprovedOrOwner(msg.sender, tokenId), "ERC721Burnable: caller is not owner nor approved"); _burn(tokenId); } } // solium-disable error-reason /** * @title ControllerRole * @dev An Controller role defined using the Open Zeppelin Role system. */ contract ControllerRole { using Roles for Roles.Role; // NOTE: Commented out standard Role events to save gas. // event ControllerAdded(address indexed account); // event ControllerRemoved(address indexed account); Roles.Role private _controllers; constructor () public { _addController(msg.sender); } modifier onlyController() { require(isController(msg.sender)); _; } function isController(address account) public view returns (bool) { return _controllers.has(account); } function addController(address account) public onlyController { _addController(account); } function renounceController() public { _removeController(msg.sender); } function _addController(address account) internal { _controllers.add(account); // emit ControllerAdded(account); } function _removeController(address account) internal { _controllers.remove(account); // emit ControllerRemoved(account); } } // solium-disable no-empty-blocks,error-reason /** * @title Registry * @dev An ERC721 Token see https://eips.ethereum.org/EIPS/eip-721. With * additional functions so other trusted contracts to interact with the tokens. */ contract Registry is IRegistry, ControllerRole, ERC721Burnable { // Optional mapping for token URIs mapping(uint256 => string) internal _tokenURIs; string internal _prefix; // Mapping from token ID to resolver address mapping (uint256 => address) internal _tokenResolvers; // uint256(keccak256(abi.encodePacked(uint256(0x0), keccak256(abi.encodePacked("crypto"))))) uint256 private constant _CRYPTO_HASH = 0x0f4a10a4f46c288cea365fcf45cccf0e9d901b945b9829ccdb54c10dc3cb7a6f; modifier onlyApprovedOrOwner(uint256 tokenId) { require(_isApprovedOrOwner(msg.sender, tokenId)); _; } constructor () public { _mint(address(0xdead), _CRYPTO_HASH); // register the supported interfaces to conform to ERC721 via ERC165 _registerInterface(0x5b5e139f); // ERC721 Metadata Interface _tokenURIs[root()] = "crypto"; emit NewURI(root(), "crypto"); } /// ERC721 Metadata extension function name() external view returns (string memory) { return ".crypto"; } function symbol() external view returns (string memory) { return "UD"; } function tokenURI(uint256 tokenId) external view returns (string memory) { require(_exists(tokenId)); return string(abi.encodePacked(_prefix, _tokenURIs[tokenId])); } function controlledSetTokenURIPrefix(string calldata prefix) external onlyController { _prefix = prefix; emit NewURIPrefix(prefix); } /// Ownership function isApprovedOrOwner(address spender, uint256 tokenId) external view returns (bool) { return _isApprovedOrOwner(spender, tokenId); } /// Registry Constants function root() public pure returns (uint256) { return _CRYPTO_HASH; } function childIdOf(uint256 tokenId, string calldata label) external pure returns (uint256) { return _childId(tokenId, label); } /// Minting function mintChild(address to, uint256 tokenId, string calldata label) external onlyApprovedOrOwner(tokenId) { _mintChild(to, tokenId, label); } function controlledMintChild(address to, uint256 tokenId, string calldata label) external onlyController { _mintChild(to, tokenId, label); } function safeMintChild(address to, uint256 tokenId, string calldata label) external onlyApprovedOrOwner(tokenId) { _safeMintChild(to, tokenId, label, ""); } function safeMintChild(address to, uint256 tokenId, string calldata label, bytes calldata _data) external onlyApprovedOrOwner(tokenId) { _safeMintChild(to, tokenId, label, _data); } function controlledSafeMintChild(address to, uint256 tokenId, string calldata label, bytes calldata _data) external onlyController { _safeMintChild(to, tokenId, label, _data); } /// Transfering function setOwner(address to, uint256 tokenId) external onlyApprovedOrOwner(tokenId) { super._transferFrom(ownerOf(tokenId), to, tokenId); } function transferFromChild(address from, address to, uint256 tokenId, string calldata label) external onlyApprovedOrOwner(tokenId) { _transferFrom(from, to, _childId(tokenId, label)); } function controlledTransferFrom(address from, address to, uint256 tokenId) external onlyController { _transferFrom(from, to, tokenId); } function safeTransferFromChild( address from, address to, uint256 tokenId, string memory label, bytes memory _data ) public onlyApprovedOrOwner(tokenId) { uint256 childId = _childId(tokenId, label); _transferFrom(from, to, childId); require(_checkOnERC721Received(from, to, childId, _data)); } function safeTransferFromChild(address from, address to, uint256 tokenId, string calldata label) external { safeTransferFromChild(from, to, tokenId, label, ""); } function controlledSafeTransferFrom(address from, address to, uint256 tokenId, bytes calldata _data) external onlyController { _transferFrom(from, to, tokenId); require(_checkOnERC721Received(from, to, tokenId, _data)); } /// Burning function burnChild(uint256 tokenId, string calldata label) external onlyApprovedOrOwner(tokenId) { _burn(_childId(tokenId, label)); } function controlledBurn(uint256 tokenId) external onlyController { _burn(tokenId); } /// Resolution function resolverOf(uint256 tokenId) external view returns (address) { address resolver = _tokenResolvers[tokenId]; require(resolver != address(0)); return resolver; } function resolveTo(address to, uint256 tokenId) external onlyApprovedOrOwner(tokenId) { _resolveTo(to, tokenId); } function controlledResolveTo(address to, uint256 tokenId) external onlyController { _resolveTo(to, tokenId); } function sync(uint256 tokenId, uint256 updateId) external { require(_tokenResolvers[tokenId] == msg.sender); emit Sync(msg.sender, updateId, tokenId); } /// Internal function _childId(uint256 tokenId, string memory label) internal pure returns (uint256) { require(bytes(label).length != 0); return uint256(keccak256(abi.encodePacked(tokenId, keccak256(abi.encodePacked(label))))); } function _mintChild(address to, uint256 tokenId, string memory label) internal { uint256 childId = _childId(tokenId, label); _mint(to, childId); require(bytes(label).length != 0); require(_exists(childId)); bytes memory domain = abi.encodePacked(label, ".", _tokenURIs[tokenId]); _tokenURIs[childId] = string(domain); emit NewURI(childId, string(domain)); } function _safeMintChild(address to, uint256 tokenId, string memory label, bytes memory _data) internal { _mintChild(to, tokenId, label); require(_checkOnERC721Received(address(0), to, _childId(tokenId, label), _data)); } function _transferFrom(address from, address to, uint256 tokenId) internal { super._transferFrom(from, to, tokenId); // Clear resolver (if any) if (_tokenResolvers[tokenId] != address(0x0)) { delete _tokenResolvers[tokenId]; } } function _burn(uint256 tokenId) internal { super._burn(tokenId); // Clear resolver (if any) if (_tokenResolvers[tokenId] != address(0x0)) { delete _tokenResolvers[tokenId]; } // Clear metadata (if any) if (bytes(_tokenURIs[tokenId]).length != 0) { delete _tokenURIs[tokenId]; } } function _resolveTo(address to, uint256 tokenId) internal { require(_exists(tokenId)); emit Resolve(tokenId, to); _tokenResolvers[tokenId] = to; } } /** * @title MintingController * @dev Defines the functions for distribution of Second Level Domains (SLD)s. */ contract MintingController is IMintingController, MinterRole { Registry internal _registry; constructor (Registry registry) public { _registry = registry; } function registry() external view returns (address) { return address(_registry); } function mintSLD(address to, string memory label) public onlyMinter { _registry.controlledMintChild(to, _registry.root(), label); } function safeMintSLD(address to, string calldata label) external { safeMintSLD(to, label, ""); } function safeMintSLD(address to, string memory label, bytes memory _data) public onlyMinter { _registry.controlledSafeMintChild(to, _registry.root(), label, _data); } function mintSLDWithResolver(address to, string memory label, address resolver) public onlyMinter { _registry.controlledMintChild(to, _registry.root(), label); _registry.controlledResolveTo(resolver, _registry.childIdOf(_registry.root(), label)); } function safeMintSLDWithResolver(address to, string calldata label, address resolver) external { safeMintSLD(to, label, ""); _registry.controlledResolveTo(resolver, _registry.childIdOf(_registry.root(), label)); } function safeMintSLDWithResolver(address to, string calldata label, address resolver, bytes calldata _data) external { safeMintSLD(to, label, _data); _registry.controlledResolveTo(resolver, _registry.childIdOf(_registry.root(), label)); } } contract FreeMinter { string public constant NAME = 'Unstoppable Free Domains Minter'; string public constant VERSION = '0.1.0'; string private constant DOMAIN_NAME_PREFIX = 'udtestdev-'; MintingController private _mintingController; IResolver private _resolver; IRegistryReader private _registry; constructor(MintingController mintingController, IResolver resolver, IRegistryReader registry) public { _mintingController = mintingController; _resolver = resolver; _registry = registry; } function claim(string calldata label) external { mintSLD(label, msg.sender); } function claimTo(string calldata label, address receiver) external { mintSLD(label, receiver); } function claimToWithRecords(string calldata label, address receiver, string[] calldata keys, string[] calldata values) external { string memory labelWithPrefix = mintSLD(label, receiver); if (keys.length == 0) { return; } uint256 tokenId = _registry.childIdOf(_registry.root(), labelWithPrefix); _resolver.preconfigure(keys, values, tokenId); } function mintSLD(string memory label, address receiver) private returns (string memory) { string memory labelWithPrefix = string(abi.encodePacked(DOMAIN_NAME_PREFIX, label)); _mintingController.mintSLDWithResolver(receiver, labelWithPrefix, address(_resolver)); return labelWithPrefix; } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"contract MintingController","name":"mintingController","type":"address"},{"internalType":"contract IResolver","name":"resolver","type":"address"},{"internalType":"contract IRegistryReader","name":"registry","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"constant":true,"inputs":[],"name":"NAME","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"string","name":"label","type":"string"}],"name":"claim","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"string","name":"label","type":"string"},{"internalType":"address","name":"receiver","type":"address"}],"name":"claimTo","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"string","name":"label","type":"string"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"string[]","name":"keys","type":"string[]"},{"internalType":"string[]","name":"values","type":"string[]"}],"name":"claimToWithRecords","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000b0ee56339c3253361730f50c08d3d7817ecd60ca000000000000000000000000b66dce2da6afaaa98f2013446dbcb0f4b0ab2842000000000000000000000000d1e5b0ff1287aa9f9a268759062e4ab08b9dacbe
-----Decoded View---------------
Arg [0] : mintingController (address): 0xb0EE56339C3253361730F50c08d3d7817ecD60Ca
Arg [1] : resolver (address): 0xb66DcE2DA6afAAa98F2013446dBCB0f4B0ab2842
Arg [2] : registry (address): 0xD1E5b0FF1287aA9f9A268759062E4Ab08b9Dacbe
-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000b0ee56339c3253361730f50c08d3d7817ecd60ca
Arg [1] : 000000000000000000000000b66dce2da6afaaa98f2013446dbcb0f4b0ab2842
Arg [2] : 000000000000000000000000d1e5b0ff1287aa9f9a268759062e4ab08b9dacbe
Deployed Bytecode Sourcemap
49128:1523:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;49128:1523:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49912:407;;;;;;;;;;;;;;;;:::i;:::-;;49155:63;;;:::i;:::-;;;;;;;;;;;;;;;;49794:110;;;;;;;;;;;;;;;;:::i;:::-;;49694:92;;;;;;;;;;;;;;;;:::i;:::-;;49225:40;;;:::i;:::-;;;;;;;;;;;;;;;;49912:407;50051:29;50083:24;50091:5;;50083:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;50083:24:0;;;;;;50098:8;50083:7;:24::i;:::-;50051:56;;50137:1;50122:4;;:11;;:16;50118:55;;;50155:7;;;50118:55;50183:15;50201:9;;;;;;;;;;;:19;;;50221:9;;;;;;;;;;;:14;;;:16;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;50221:16:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;50221:16:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;50221:16:0;;;;;;;;;50239:15;50201:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;50201:54:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;50201:54:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;50201:54:0;;;;;;;;;50183:72;;50266:9;;;;;;;;;;;:22;;;50289:4;;50295:6;;50303:7;50266:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;50266:45:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;50266:45:0;;;;49912:407;;;;;;;;;;:::o;49155:63::-;;;;;;;;;;;;;;;;;;;:::o;49794:110::-;49872:24;49880:5;;49872:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;49872:24:0;;;;;;49887:8;49872:7;:24::i;:::-;;49794:110;;;:::o;49694:92::-;49752:26;49760:5;;49752:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;49752::0;;;;;;49767:10;49752:7;:26::i;:::-;;49694:92;;:::o;49225:40::-;;;;;;;;;;;;;;;;;;;:::o;50327:321::-;50400:13;50426:29;50482:18;;;;;;;;;;;;;;;;;50502:5;50465:43;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;50465:43:0;;;50426:83;;50520:18;;;;;;;;;;;:38;;;50559:8;50569:15;50594:9;;;;;;;;;;;50520:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;50520:85:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;50520:85:0;;;;50625:15;50618:22;;;50327:321;;;;:::o;5:130:-1:-;;85:6;72:20;63:29;;97:33;124:5;97:33;;;57:78;;;;;159:360;;;297:3;290:4;282:6;278:17;274:27;264:2;;315:1;312;305:12;264:2;348:6;335:20;325:30;;375:18;367:6;364:30;361:2;;;407:1;404;397:12;361:2;441:4;433:6;429:17;417:29;;492:3;484:4;476:6;472:17;462:8;458:32;455:41;452:2;;;509:1;506;499:12;452:2;257:262;;;;;;542:336;;;657:3;650:4;642:6;638:17;634:27;624:2;;675:1;672;665:12;624:2;708:6;695:20;685:30;;735:18;727:6;724:30;721:2;;;767:1;764;757:12;721:2;801:4;793:6;789:17;777:29;;851:3;844;836:6;832:16;822:8;818:31;815:40;812:2;;;868:1;865;858:12;812:2;617:261;;;;;;886:134;;970:6;964:13;955:22;;982:33;1009:5;982:33;;;949:71;;;;;1027:367;;;1151:2;1139:9;1130:7;1126:23;1122:32;1119:2;;;1167:1;1164;1157:12;1119:2;1230:1;1219:9;1215:17;1202:31;1253:18;1245:6;1242:30;1239:2;;;1285:1;1282;1275:12;1239:2;1313:65;1370:7;1361:6;1350:9;1346:22;1313:65;;;1303:75;;;;1181:203;1113:281;;;;;;1401:492;;;;1542:2;1530:9;1521:7;1517:23;1513:32;1510:2;;;1558:1;1555;1548:12;1510:2;1621:1;1610:9;1606:17;1593:31;1644:18;1636:6;1633:30;1630:2;;;1676:1;1673;1666:12;1630:2;1704:65;1761:7;1752:6;1741:9;1737:22;1704:65;;;1694:75;;;;1572:203;1806:2;1824:53;1869:7;1860:6;1849:9;1845:22;1824:53;;;1814:63;;1785:98;1504:389;;;;;;1900:1087;;;;;;;;2161:3;2149:9;2140:7;2136:23;2132:33;2129:2;;;2178:1;2175;2168:12;2129:2;2241:1;2230:9;2226:17;2213:31;2264:18;2256:6;2253:30;2250:2;;;2296:1;2293;2286:12;2250:2;2324:65;2381:7;2372:6;2361:9;2357:22;2324:65;;;2314:75;;;;2192:203;2426:2;2444:53;2489:7;2480:6;2469:9;2465:22;2444:53;;;2434:63;;2405:98;2562:2;2551:9;2547:18;2534:32;2586:18;2578:6;2575:30;2572:2;;;2618:1;2615;2608:12;2572:2;2646:88;2726:7;2717:6;2706:9;2702:22;2646:88;;;2636:98;;;;2513:227;2799:2;2788:9;2784:18;2771:32;2823:18;2815:6;2812:30;2809:2;;;2855:1;2852;2845:12;2809:2;2883:88;2963:7;2954:6;2943:9;2939:22;2883:88;;;2873:98;;;;2750:227;2123:864;;;;;;;;;;;2994:263;;3109:2;3097:9;3088:7;3084:23;3080:32;3077:2;;;3125:1;3122;3115:12;3077:2;3160:1;3177:64;3233:7;3224:6;3213:9;3209:22;3177:64;;;3167:74;;3139:108;3071:186;;;;;3265:201;;3388:72;3456:3;3448:6;3440;3388:72;;;3374:86;;3367:99;;;;;;3474:113;3557:24;3575:5;3557:24;;;3552:3;3545:37;3539:48;;;3623:911;;3791:92;3876:6;3871:3;3791:92;;;3784:99;;3906:3;3948:4;3940:6;3936:17;3931:3;3927:27;3975:66;4035:5;3975:66;;;4061:7;4089:1;4074:421;4099:6;4096:1;4093:13;4074:421;;;4161:9;4155:4;4151:20;4146:3;4139:33;4215:50;4258:6;4249:7;4215:50;;;4280:93;4368:4;4353:13;4338;4280:93;;;4272:101;;4390:70;4453:6;4390:70;;;4380:80;;4483:4;4478:3;4474:14;4467:21;;4131:364;;4121:1;4118;4114:9;4109:14;;4074:421;;;4078:14;4508:4;4501:11;;4525:3;4518:10;;3771:763;;;;;;;;;;4567:276;;4669:61;4723:6;4718:3;4669:61;;;4662:68;;4742:43;4778:6;4773:3;4766:5;4742:43;;;4807:29;4829:6;4807:29;;;4802:3;4798:39;4791:46;;4655:188;;;;;;4851:347;;4963:39;4996:5;4963:39;;;5014:71;5078:6;5073:3;5014:71;;;5007:78;;5090:52;5135:6;5130:3;5123:4;5116:5;5112:16;5090:52;;;5163:29;5185:6;5163:29;;;5158:3;5154:39;5147:46;;4943:255;;;;;;5205:360;;5335:39;5368:5;5335:39;;;5386:89;5468:6;5463:3;5386:89;;;5379:96;;5480:52;5525:6;5520:3;5513:4;5506:5;5502:16;5480:52;;;5553:6;5548:3;5544:16;5537:23;;5315:250;;;;;;5572:339;;5680:35;5709:5;5680:35;;;5727:71;5791:6;5786:3;5727:71;;;5720:78;;5803:52;5848:6;5843:3;5836:4;5829:5;5825:16;5803:52;;;5876:29;5898:6;5876:29;;;5871:3;5867:39;5860:46;;5660:251;;;;;;5918:352;;6044:35;6073:5;6044:35;;;6091:89;6173:6;6168:3;6091:89;;;6084:96;;6185:52;6230:6;6225:3;6218:4;6211:5;6207:16;6185:52;;;6258:6;6253:3;6249:16;6242:23;;6024:246;;;;;;6277:113;6360:24;6378:5;6360:24;;;6355:3;6348:37;6342:48;;;6397:419;;6587:91;6674:3;6665:6;6587:91;;;6580:98;;6696:95;6787:3;6778:6;6696:95;;;6689:102;;6808:3;6801:10;;6568:248;;;;;;6823:523;;7017:2;7006:9;7002:18;6994:26;;7031:71;7099:1;7088:9;7084:17;7075:6;7031:71;;;7150:9;7144:4;7140:20;7135:2;7124:9;7120:18;7113:48;7175:78;7248:4;7239:6;7175:78;;;7167:86;;7264:72;7332:2;7321:9;7317:18;7308:6;7264:72;;;6988:358;;;;;;;7353:827;;7675:2;7664:9;7660:18;7652:26;;7725:9;7719:4;7715:20;7711:1;7700:9;7696:17;7689:47;7750:132;7877:4;7868:6;7860;7750:132;;;7742:140;;7930:9;7924:4;7920:20;7915:2;7904:9;7900:18;7893:48;7955:132;8082:4;8073:6;8065;7955:132;;;7947:140;;8098:72;8166:2;8155:9;8151:18;8142:6;8098:72;;;7646:534;;;;;;;;;8187:293;;8321:2;8310:9;8306:18;8298:26;;8371:9;8365:4;8361:20;8357:1;8346:9;8342:17;8335:47;8396:74;8465:4;8456:6;8396:74;;;8388:82;;8292:188;;;;;8487:412;;8653:2;8642:9;8638:18;8630:26;;8667:71;8735:1;8724:9;8720:17;8711:6;8667:71;;;8786:9;8780:4;8776:20;8771:2;8760:9;8756:18;8749:48;8811:78;8884:4;8875:6;8811:78;;;8803:86;;8624:275;;;;;;8906:126;;9002:3;8994:11;;8988:44;;;;9039:118;;9129:5;9123:12;9113:22;;9094:63;;;;9164:122;;9258:5;9252:12;9242:22;;9223:63;;;;9293:118;;9401:4;9396:3;9392:14;9384:22;;9378:33;;;;9419:184;;9555:6;9550:3;9543:19;9592:4;9587:3;9583:14;9568:29;;9536:67;;;;;9612:153;;9717:6;9712:3;9705:19;9754:4;9749:3;9745:14;9730:29;;9698:67;;;;;9774:163;;9889:6;9884:3;9877:19;9926:4;9921:3;9917:14;9902:29;;9870:67;;;;;9946:145;;10082:3;10067:18;;10060:31;;;;;10100:497;;;10221:3;10208:17;10310:1;10304:4;10300:12;10289:8;10273:14;10269:29;10265:48;10245:18;10241:73;10231:2;;10328:1;10325;10318:12;10231:2;10371:8;10351:18;10347:33;10338:42;;10415:5;10402:19;10392:29;;10447:4;10440:5;10436:16;10427:25;;10472:18;10464:6;10461:30;10458:2;;;10504:1;10501;10494:12;10458:2;10563:3;10555:6;10551:16;10535:14;10531:37;10521:8;10517:52;10514:2;;;10582:1;10579;10572:12;10514:2;10175:422;;;;;;;10605:91;;10667:24;10685:5;10667:24;;;10656:35;;10650:46;;;;10703:121;;10776:42;10769:5;10765:54;10754:65;;10748:76;;;;10831:72;;10893:5;10882:16;;10876:27;;;;10911:145;10992:6;10987:3;10982;10969:30;11048:1;11039:6;11034:3;11030:16;11023:27;10962:94;;;;11065:268;11130:1;11137:101;11151:6;11148:1;11145:13;11137:101;;;11227:1;11222:3;11218:11;11212:18;11208:1;11203:3;11199:11;11192:39;11173:2;11170:1;11166:10;11161:15;;11137:101;;;11253:6;11250:1;11247:13;11244:2;;;11318:1;11309:6;11304:3;11300:16;11293:27;11244:2;11114:219;;;;;11341:97;;11429:2;11425:7;11420:2;11413:5;11409:14;11405:28;11395:38;;11389:49;;;;11446:117;11515:24;11533:5;11515:24;;;11508:5;11505:35;11495:2;;11554:1;11551;11544:12;11495:2;11489:74;;11570:117;11639:24;11657:5;11639:24;;;11632:5;11629:35;11619:2;;11678:1;11675;11668:12;11619:2;11613:74;
Swarm Source
bzzr://8219e324cc6187205eb892268d0f2cadbd7a31b2df54ce1e0ee2b0c87c21f640
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.