More Info
Private Name Tags
ContractCreator
Latest 25 from a total of 91,215 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Set Many | 14592693 | 864 days ago | IN | 0 ETH | 0.00249998 | ||||
Set Many | 14555117 | 869 days ago | IN | 0 ETH | 0.00116321 | ||||
Set Many | 14555014 | 869 days ago | IN | 0 ETH | 0.00424745 | ||||
Set Many | 14351004 | 901 days ago | IN | 0 ETH | 0.00298308 | ||||
Set Many | 12728323 | 1154 days ago | IN | 0 ETH | 0.00128412 | ||||
Set Many | 12728291 | 1154 days ago | IN | 0 ETH | 0.00499215 | ||||
Set Many | 12664236 | 1164 days ago | IN | 0 ETH | 0.00054729 | ||||
Set Many | 12643317 | 1167 days ago | IN | 0 ETH | 0.00039065 | ||||
Set Many | 12643281 | 1167 days ago | IN | 0 ETH | 0.00067701 | ||||
Set Many For | 12491302 | 1191 days ago | IN | 0 ETH | 0.0107283 | ||||
Set Many For | 12453783 | 1197 days ago | IN | 0 ETH | 0.0039879 | ||||
Set Many For | 12427083 | 1201 days ago | IN | 0 ETH | 0.0107271 | ||||
Set Many For | 12426482 | 1201 days ago | IN | 0 ETH | 0.0082374 | ||||
Set Many For | 12330199 | 1216 days ago | IN | 0 ETH | 0.0067638 | ||||
Set Many For | 12305393 | 1220 days ago | IN | 0 ETH | 0.0142281 | ||||
Set Many For | 12305348 | 1220 days ago | IN | 0 ETH | 0.01112454 | ||||
Set Many For | 12305271 | 1220 days ago | IN | 0 ETH | 0.00445505 | ||||
Set Many | 12305112 | 1220 days ago | IN | 0 ETH | 0.00556115 | ||||
Set Many | 12305012 | 1220 days ago | IN | 0 ETH | 0.00567525 | ||||
Set Many For | 12304985 | 1220 days ago | IN | 0 ETH | 0.00832197 | ||||
Set Many | 12304638 | 1220 days ago | IN | 0 ETH | 0.00658329 | ||||
Set Many For | 12286394 | 1223 days ago | IN | 0 ETH | 0.0252483 | ||||
Set Many For | 12164831 | 1241 days ago | IN | 0 ETH | 0.0071209 | ||||
Set Many For | 12003468 | 1266 days ago | IN | 0 ETH | 0.0120298 | ||||
Set Many For | 11994918 | 1267 days ago | IN | 0 ETH | 0.0065322 |
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
Resolver
Compiler Version
v0.5.12+commit.7709ece9
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2019-12-14 */ // File: @openzeppelin/contracts/introspection/IERC165.sol pragma solidity ^0.5.0; /** * @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); } // File: @openzeppelin/contracts/token/ERC721/IERC721.sol pragma solidity ^0.5.0; /** * @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; } // File: @openzeppelin/contracts/token/ERC721/IERC721Metadata.sol pragma solidity ^0.5.0; /** * @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); } // File: contracts/IRegistry.sol pragma solidity 0.5.12; 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; } // File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol pragma solidity ^0.5.0; /** * @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); } // File: @openzeppelin/contracts/math/SafeMath.sol pragma solidity ^0.5.0; /** * @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; } } // File: @openzeppelin/contracts/utils/Address.sol pragma solidity ^0.5.0; /** * @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; } } // File: @openzeppelin/contracts/drafts/Counters.sol pragma solidity ^0.5.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); } } // File: @openzeppelin/contracts/introspection/ERC165.sol pragma solidity ^0.5.0; /** * @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; } } // File: @openzeppelin/contracts/token/ERC721/ERC721.sol pragma solidity ^0.5.0; /** * @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); } } } // File: @openzeppelin/contracts/token/ERC721/ERC721Burnable.sol pragma solidity ^0.5.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); } } // File: @openzeppelin/contracts/access/Roles.sol pragma solidity ^0.5.0; /** * @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]; } } // File: contracts/util/ControllerRole.sol pragma solidity 0.5.12; // 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); } } // File: contracts/Registry.sol pragma solidity 0.5.12; // 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; } } // File: @openzeppelin/contracts/cryptography/ECDSA.sol pragma solidity ^0.5.0; /** * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations. * * These functions can be used to verify that a message was signed by the holder * of the private keys of a given address. */ library ECDSA { /** * @dev Returns the address that signed a hashed message (`hash`) with * `signature`. This address can then be used for verification purposes. * * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures: * this function rejects them by requiring the `s` value to be in the lower * half order, and the `v` value to be either 27 or 28. * * (.note) This call _does not revert_ if the signature is invalid, or * if the signer is otherwise unable to be retrieved. In those scenarios, * the zero address is returned. * * (.warning) `hash` _must_ be the result of a hash operation for the * verification to be secure: it is possible to craft signatures that * recover to arbitrary addresses for non-hashed data. A safe way to ensure * this is by receiving a hash of the original message (which may otherwise) * be too long), and then calling `toEthSignedMessageHash` on it. */ function recover(bytes32 hash, bytes memory signature) internal pure returns (address) { // Check the signature length if (signature.length != 65) { return (address(0)); } // Divide the signature in r, s and v variables bytes32 r; bytes32 s; uint8 v; // ecrecover takes the signature parameters, and the only way to get them // currently is to use assembly. // solhint-disable-next-line no-inline-assembly assembly { r := mload(add(signature, 0x20)) s := mload(add(signature, 0x40)) v := byte(0, mload(add(signature, 0x60))) } // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines // the valid range for s in (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): v ∈ {27, 28}. Most // signatures from current libraries generate a unique signature with an s-value in the lower half order. // // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept // these malleable signatures as well. if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) { return address(0); } if (v != 27 && v != 28) { return address(0); } // If the signature is valid (and not malleable), return the signer address return ecrecover(hash, v, r, s); } /** * @dev Returns an Ethereum Signed Message, created from a `hash`. This * replicates the behavior of the * [`eth_sign`](https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_sign) * JSON-RPC method. * * See `recover`. */ function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) { // 32 is the length in bytes of hash, // enforced by the type signature above return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash)); } } // File: contracts/util/SignatureUtil.sol pragma solidity 0.5.12; // solium-disable error-reason contract SignatureUtil { using ECDSA for bytes32; // Mapping from owner to a nonce mapping (uint256 => uint256) internal _nonces; Registry internal _registry; constructor(Registry registry) public { _registry = registry; } function registry() external view returns (address) { return address(_registry); } /** * @dev Gets the nonce of the specified address. * @param tokenId token ID for nonce query * @return nonce of the given address */ function nonceOf(uint256 tokenId) external view returns (uint256) { return _nonces[tokenId]; } function _validate(bytes32 hash, uint256 tokenId, bytes memory signature) internal { uint256 nonce = _nonces[tokenId]; address signer = keccak256(abi.encodePacked(hash, address(this), nonce)).toEthSignedMessageHash().recover(signature); require( signer != address(0) && _registry.isApprovedOrOwner( signer, tokenId ) ); _nonces[tokenId] += 1; } } // File: @openzeppelin/contracts/access/roles/MinterRole.sol pragma solidity ^0.5.0; 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); } } // File: contracts/controllers/IMintingController.sol pragma solidity 0.5.12; 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; } // File: contracts/controllers/MintingController.sol pragma solidity 0.5.12; /** * @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)); } } // File: contracts/Resolver.sol pragma solidity 0.5.12; pragma experimental ABIEncoderV2; // solium-disable error-reason contract Resolver is SignatureUtil { event Set(uint256 indexed preset, string indexed key, string value, uint256 indexed tokenId); event SetPreset(uint256 indexed preset, uint256 indexed tokenId); // Mapping from token ID to preset id to key to value mapping (uint256 => mapping (uint256 => mapping (string => string))) internal _records; // Mapping from token ID to current preset id mapping (uint256 => uint256) _tokenPresets; MintingController internal _mintingController; constructor(Registry registry, MintingController mintingController) public SignatureUtil(registry) { require(address(registry) == mintingController.registry()); _mintingController = mintingController; } /** * @dev Throws if called when not the resolver. */ modifier whenResolver(uint256 tokenId) { require(address(this) == _registry.resolverOf(tokenId), "SimpleResolver: is not the resolver"); _; } function presetOf(uint256 tokenId) external view returns (uint256) { return _tokenPresets[tokenId]; } function setPreset(uint256 presetId, uint256 tokenId) external { require(_registry.isApprovedOrOwner(msg.sender, tokenId)); _setPreset(presetId, tokenId); } function setPresetFor(uint256 presetId, uint256 tokenId, bytes calldata signature) external { _validate(keccak256(abi.encodeWithSelector(this.setPreset.selector, presetId, tokenId)), tokenId, signature); _setPreset(presetId, tokenId); } function reset(uint256 tokenId) external { require(_registry.isApprovedOrOwner(msg.sender, tokenId)); _setPreset(now, tokenId); } function resetFor(uint256 tokenId, bytes calldata signature) external { _validate(keccak256(abi.encodeWithSelector(this.reset.selector, tokenId)), tokenId, signature); _setPreset(now, tokenId); } /** * @dev Function to get record. * @param key The key to query the value of. * @param tokenId The token id to fetch. * @return The value string. */ function get(string memory key, uint256 tokenId) public view whenResolver(tokenId) returns (string memory) { return _records[tokenId][_tokenPresets[tokenId]][key]; } function preconfigure( string[] memory keys, string[] memory values, uint256 tokenId ) public { require(msg.sender == address(_mintingController)); _setMany(_tokenPresets[tokenId], keys, values, tokenId); } /** * @dev Function to set record. * @param key The key set the value of. * @param value The value to set key to. * @param tokenId The token id to set. */ function set(string calldata key, string calldata value, uint256 tokenId) external { require(_registry.isApprovedOrOwner(msg.sender, tokenId)); _set(_tokenPresets[tokenId], key, value, tokenId); } /** * @dev Function to set record on behalf of an address. * @param key The key set the value of. * @param value The value to set key to. * @param tokenId The token id to set. * @param signature The signature to verify the transaction with. */ function setFor( string calldata key, string calldata value, uint256 tokenId, bytes calldata signature ) external { _validate(keccak256(abi.encodeWithSelector(this.set.selector, key, value, tokenId)), tokenId, signature); _set(_tokenPresets[tokenId], key, value, tokenId); } /** * @dev Function to get multiple record. * @param keys The keys to query the value of. * @param tokenId The token id to fetch. * @return The values. */ function getMany(string[] calldata keys, uint256 tokenId) external view whenResolver(tokenId) returns (string[] memory) { uint256 keyCount = keys.length; string[] memory values = new string[](keyCount); uint256 preset = _tokenPresets[tokenId]; for (uint256 i = 0; i < keyCount; i++) { values[i] = _records[tokenId][preset][keys[i]]; } return values; } function setMany( string[] memory keys, string[] memory values, uint256 tokenId ) public { require(_registry.isApprovedOrOwner(msg.sender, tokenId)); _setMany(_tokenPresets[tokenId], keys, values, tokenId); } /** * @dev Function to set record on behalf of an address. * @param keys The keys set the values of. * @param values The values to set keys to. * @param tokenId The token id to set. * @param signature The signature to verify the transaction with. */ function setManyFor( string[] memory keys, string[] memory values, uint256 tokenId, bytes memory signature ) public { _validate(keccak256(abi.encodeWithSelector(this.setMany.selector, keys, values, tokenId)), tokenId, signature); _setMany(_tokenPresets[tokenId], keys, values, tokenId); } function _setPreset(uint256 presetId, uint256 tokenId) internal { _tokenPresets[tokenId] = presetId; emit SetPreset(presetId, tokenId); } /** * @dev Internal function to to set record. As opposed to set, this imposes * no restrictions on msg.sender. * @param preset preset to set key/values on * @param key key of record to be set * @param value value of record to be set * @param tokenId uint256 ID of the token */ function _set(uint256 preset, string memory key, string memory value, uint256 tokenId) internal { _registry.sync(tokenId, uint256(keccak256(bytes(key)))); _records[tokenId][preset][key] = value; emit Set(preset, key, value, tokenId); } /** * @dev Internal function to to set multiple records. As opposed to setMany, this imposes * no restrictions on msg.sender. * @param preset preset to set key/values on * @param keys keys of record to be set * @param values values of record to be set * @param tokenId uint256 ID of the token */ function _setMany(uint256 preset, string[] memory keys, string[] memory values, uint256 tokenId) internal { uint256 keyCount = keys.length; for (uint256 i = 0; i < keyCount; i++) { _set(preset, keys[i], values[i], tokenId); } } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"contract Registry","name":"registry","type":"address"},{"internalType":"contract MintingController","name":"mintingController","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"preset","type":"uint256"},{"indexed":true,"internalType":"string","name":"key","type":"string"},{"indexed":false,"internalType":"string","name":"value","type":"string"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Set","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"preset","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"SetPreset","type":"event"},{"constant":true,"inputs":[{"internalType":"string","name":"key","type":"string"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"get","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"string[]","name":"keys","type":"string[]"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getMany","outputs":[{"internalType":"string[]","name":"","type":"string[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"nonceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"string[]","name":"keys","type":"string[]"},{"internalType":"string[]","name":"values","type":"string[]"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"preconfigure","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"presetOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"registry","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"reset","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"resetFor","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"string","name":"key","type":"string"},{"internalType":"string","name":"value","type":"string"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"set","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"string","name":"key","type":"string"},{"internalType":"string","name":"value","type":"string"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"setFor","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"string[]","name":"keys","type":"string[]"},{"internalType":"string[]","name":"values","type":"string[]"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"setMany","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"string[]","name":"keys","type":"string[]"},{"internalType":"string[]","name":"values","type":"string[]"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"setManyFor","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"presetId","type":"uint256"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"setPreset","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"presetId","type":"uint256"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"setPresetFor","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)
000000000000000000000000d1e5b0ff1287aa9f9a268759062e4ab08b9dacbe000000000000000000000000b0ee56339c3253361730f50c08d3d7817ecd60ca
-----Decoded View---------------
Arg [0] : registry (address): 0xD1E5b0FF1287aA9f9A268759062E4Ab08b9Dacbe
Arg [1] : mintingController (address): 0xb0EE56339C3253361730F50c08d3d7817ecD60Ca
-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000d1e5b0ff1287aa9f9a268759062e4ab08b9dacbe
Arg [1] : 000000000000000000000000b0ee56339c3253361730f50c08d3d7817ecd60ca
Deployed Bytecode Sourcemap
51372:6586:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;51372:6586:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55217:423;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;53523:179;;;;;;;;;:::i;:::-;;;;;;;;52952:152;;;;;;;;;:::i;:::-;;52498:179;;;;;;;;;:::i;52685:259::-;;;;;;;;;:::i;54169:219::-;;;;;;;;;:::i;46714:108::-;;;;;;;;;:::i;:::-;;;;;;;;52375:115;;;;;;;;;:::i;46447:96::-;;;:::i;:::-;;;;;;;;56210:352;;;;;;;;;:::i;53112:218::-;;;;;;;;;:::i;54681:338::-;;;;;;;;;:::i;55648:263::-;;;;;;;;;:::i;53710:261::-;;;;;;;;;:::i;55217:423::-;52278:9;;:29;;-1:-1:-1;;;52278:29:0;;55320:15;;55302:7;;-1:-1:-1;;;;;52278:9:0;;;;:20;;:29;;55302:7;;52278:29;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;52278:29:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;52278:29: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;52278:29:0;;;;;;;;;-1:-1:-1;;;;;52261:46:0;52269:4;-1:-1:-1;;;;;52261:46:0;;52253:94;;;;-1:-1:-1;;;52253:94:0;;;;;;;;;;;;;;;;;55414:22;;;;;;;;;;;;;;;;55367:4;;55389:22;;55367:4;55414:22;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;55447:14:0;55464:22;;;:13;:22;;;;;;55389:47;;-1:-1:-1;55497:112:0;55521:8;55517:1;:12;55497:112;;;55563:17;;;;:8;:17;;;;;;;;:25;;;;;;;;55589:4;;55594:1;55589:7;;;;;;;;;;;;-1:-1:-1;30:25;;-1:-1;;100:14;96:29;;;92:48;68:73;;58:2;;155:1;152;145:12;58:2;174:33;;;69:4;55:19;;;-1:-1;16:22;-1:-1;;;;;82:30;;79:2;;;125:1;122;115:12;79:2;155:14;151:37;;;137:52;;134:2;;;202:1;199;192:12;134:2;55563:34:0;;;;;;;;;;;;;;;;;;;;;;;;55551:46;;;;;;;;;-1:-1:-1;;55551:46:0;;;;;;;;;;;;;;;;;;;;;;;55563:34;;;;55551:46;;;55563:34;55551:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:6;55558:1;55551:9;;;;;;;;;;;;;;;;;:46;55531:3;;55497:112;;;-1:-1:-1;55626:6:0;;55217:423;-1:-1:-1;;;;;;;55217:423:0:o;53523:179::-;52278:9;;:29;;-1:-1:-1;;;52278:29:0;;53615:13;;53597:7;;-1:-1:-1;;;;;52278:9:0;;;;:20;;:29;;53597:7;;52278:29;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;52278:29:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;52278:29: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;52278:29:0;;;;;;;;;-1:-1:-1;;;;;52261:46:0;52269:4;-1:-1:-1;;;;;52261:46:0;;52253:94;;;;-1:-1:-1;;;52253:94:0;;;;;;;;;53648:17;;;;:8;:17;;;;;;;;53666:13;:22;;;;;;53648:41;;;;;;;;;:46;;;;53690:3;;53648:46;;;;;;;;;;;;;;;;;;53641:53;;;;;;;;;-1:-1:-1;;53641:53:0;;;;;;;;;;;;;;;;;;;;;;;53648:46;;;;53641:53;;;53648:46;53641:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53523:179;;;;;:::o;52952:152::-;53012:9;;:48;;-1:-1:-1;;;53012:48:0;;-1:-1:-1;;;;;53012:9:0;;;;:27;;:48;;53040:10;;53052:7;;53012:48;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;53012:48:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;53012:48: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;53012:48:0;;;;;;;;;53004:57;;;;;;53072:24;53083:3;53088:7;53072:10;:24::i;:::-;52952:152;:::o;52498:179::-;52580:9;;:48;;-1:-1:-1;;;52580:48:0;;-1:-1:-1;;;;;52580:9:0;;;;:27;;:48;;52608:10;;52620:7;;52580:48;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;52580:48:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;52580:48: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;52580:48:0;;;;;;;;;52572:57;;;;;;52640:29;52651:8;52661:7;52640:10;:29::i;:::-;52498:179;;:::o;52685:259::-;52788:108;52831:23;;;52856:8;52866:7;52808:66;;;;;;;;;;;;;;-1:-1:-1;;26:21;;;22:32;6:49;;52808:66:0;;;49:4:-1;25:18;;;61:17;;-1:-1;;;;;182:15;-1:-1;;;;;;52808:66:0;;;179:29:-1;;;;160:49;;52798:77:0;;;;;52788:108;;;;;;;;;;;;;;;;;;;;52798:77;52877:7;;52886:9;;;;;;52788:108;;52886:9;;;;52788:108;1:33:-1;99:1;81:16;;74:27;;;;-1:-1;52788:9:0;;-1:-1:-1;;;52788:108:0:i;:::-;52907:29;52918:8;52928:7;52907:10;:29::i;:::-;52685:259;;;;:::o;54169:219::-;54271:9;;:48;;-1:-1:-1;;;54271:48:0;;-1:-1:-1;;;;;54271:9:0;;;;:27;;:48;;54299:10;;54311:7;;54271:48;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;54271:48:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;54271:48: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;54271:48:0;;;;;;;;;54263:57;;;;;;54331:49;54336:13;:22;54350:7;54336:22;;;;;;;;;;;;54360:3;;54331:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;;54331:49:0;;;;137:4:-1;54331:49:0;;;;;;;;;;;;;;;;;;-1:-1:-1;54365:5:0;;-1:-1:-1;54365:5:0;;;;54331:49;;54365:5;;;;54331:49;1:33:-1;99:1;81:16;;74:27;;;;-1:-1;54372:7:0;;-1:-1:-1;54331:4:0;;-1:-1:-1;;54331:49:0:i;:::-;54169:219;;;;;:::o;46714:108::-;46771:7;46798:16;;;;;;;;;;;;46714:108::o;52375:115::-;52433:7;52460:22;;;:13;:22;;;;;;;52375:115::o;46447:96::-;46525:9;;-1:-1:-1;;;;;46525:9:0;46447:96;;:::o;56210:352::-;56378:110;56421:21;;;56444:4;56450:6;56458:7;56398:68;;;;;;;;;;;;;;;-1:-1:-1;;26:21;;;22:32;6:49;;56398:68:0;;;49:4:-1;25:18;;61:17;;-1:-1;;;;;182:15;-1:-1;;;;;;56398:68:0;;;179:29:-1;;;;160:49;;56388:79:0;;;56469:7;56478:9;56378;:110::i;:::-;56508:22;;;;:13;:22;;;;;;56499:55;;56532:4;56538:6;56522:7;56499:8;:55::i;53112:218::-;53193:94;53236:19;;;53257:7;53213:52;;;;;;;;;53193:94;53298:24;53309:3;53314:7;53298:10;:24::i;:::-;53112:218;;;:::o;54681:338::-;54847:104;54890:17;;;54909:3;;54914:5;;54921:7;54867:62;;;;;;;;;;;;;54847:104;54962:49;54967:13;:22;54981:7;54967:22;;;;;;;;;;;;54991:3;;54962:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;;54962:49:0;;;;137:4:-1;54962:49:0;;;;;;;;;;;;;;;;;;-1:-1:-1;54996:5:0;;-1:-1:-1;54996:5:0;;;;54962:49;;54996:5;;;;54962:49;1:33:-1;99:1;81:16;;74:27;;;;-1:-1;55003:7:0;;-1:-1:-1;54962:4:0;;-1:-1:-1;;54962:49:0:i;:::-;54681:338;;;;;;;:::o;55648:263::-;55788:9;;:48;;-1:-1:-1;;;55788:48:0;;-1:-1:-1;;;;;55788:9:0;;;;:27;;:48;;55816:10;;55828:7;;55788:48;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;55788:48:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;55788:48: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;55788:48:0;;;;;;;;;55780:57;;;;;;55857:22;;;;:13;:22;;;;;;55848:55;;55881:4;55887:6;55871:7;55848:8;:55::i;53710:261::-;53877:18;;-1:-1:-1;;;;;53877:18:0;53855:10;:41;53847:50;;;;;56570:160;56645:22;;;;:13;:22;;;;;;:33;;;56694:28;56659:7;;56670:8;;56694:28;;56645:22;56694:28;56570:160;;:::o;46830:471::-;46924:13;46940:16;;;;;;;;;;;;46996:44;;46940:16;;46924:13;46986:99;;47075:9;;46986:80;;46996:44;;47013:4;;47027;;46940:16;;46996:44;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;46996:44:0;;;46986:55;;;;;;:78;:80::i;:::-;:88;:99;:88;:99;:::i;:::-;46969:116;-1:-1:-1;;;;;;47118:20:0;;;;;;:130;;-1:-1:-1;47155:9:0;;:93;;-1:-1:-1;;;47155:93:0;;-1:-1:-1;;;;;47155:9:0;;;;:27;;:93;;47201:6;;47226:7;;47155:93;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;47155:93:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;47155:93: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;47155:93:0;;;;;;;;;47096:163;;;;;;-1:-1:-1;;;47272:7:0;:16;;;;;;;;;;:21;;47292:1;47272:21;;;-1:-1:-1;46830:471:0:o;57063:267::-;57170:9;;57202:21;;;;;;57170:55;;-1:-1:-1;;;57170:55:0;;-1:-1:-1;;;;;57170:9:0;;;;:14;;:55;;57185:7;;57202:21;57170:55;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;57170:55:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;;57236:17:0;;;;:8;:17;;;;;;;;:25;;;;;;;;;;:30;;57269:5;;-1:-1:-1;57236:30:0;;57262:3;;57236:30;;;;;;;;;;;;;;;:38;;;;;;;;;;;;:::i;:::-;;57314:7;57302:3;57290:32;;;;;;;;;;;;;;;57294:6;57290:32;57307:5;57290:32;;;;;;;;;;;;;;;57063:267;;;;:::o;57681:272::-;57817:11;;57798:16;57839:107;57863:8;57859:1;:12;57839:107;;;57893:41;57898:6;57906:4;57911:1;57906:7;;;;;;;;;;;;;;57915:6;57922:1;57915:9;;;;;;;;;;;;;;57926:7;57893:4;:41::i;:::-;57873:3;;57839:107;;;;57681:272;;;;;:::o;45786:269::-;45855:7;46041:4;45988:58;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;45988:58:0;;;45978:69;;;;;;45971:76;;45786:269;;;:::o;43580:1930::-;43658:7;43721:9;:16;43741:2;43721:22;43717:74;;-1:-1:-1;43776:1:0;43760:19;;43717:74;44152:4;44137:20;;44131:27;44198:4;44183:20;;44177:27;44252:4;44237:20;;44231:27;43860:9;44223:36;45182:66;45169:79;;45165:129;;;45280:1;45265:17;;;;;;;45165:129;45310:1;:7;;45315:2;45310:7;;:18;;;;;45321:1;:7;;45326:2;45321:7;;45310:18;45306:68;;;45360:1;45345:17;;;;;;;45306:68;45478:24;45488:4;45494:1;45497;45500;45478:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;45478:24:0;;;;;;;;45471:31;;;;;43580:1930;;;;;:::o;51372:6586::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;51372:6586:0;;;-1:-1:-1;51372:6586:0;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;5:134:-1;83:13;;101:33;83:13;101:33;;163:360;;;301:3;294:4;286:6;282:17;278:27;268:2;;319:1;316;309:12;268:2;-1:-1;339:20;;-1:-1;;;;;368:30;;365:2;;;411:1;408;401:12;365:2;445:4;437:6;433:17;421:29;;496:3;488:4;480:6;476:17;466:8;462:32;459:41;456:2;;;513:1;510;503:12;456:2;261:262;;;;;;548:696;;671:3;664:4;656:6;652:17;648:27;638:2;;689:1;686;679:12;638:2;726:6;713:20;748:86;763:70;826:6;763:70;;;748:86;;;862:21;;;906:4;894:17;;;;739:95;;-1:-1;919:14;;894:17;1014:1;999:239;1024:6;1021:1;1018:13;999:239;;;1107:3;1094:17;1086:6;1082:30;1131:43;1170:3;1158:10;1131:43;;;1119:56;;-1:-1;1198:4;1189:14;;;;1217;;;;;1046:1;1039:9;999:239;;;1003:14;631:613;;;;;;;;1252:128;1327:13;;1345:30;1327:13;1345:30;;1401:335;;;1515:3;1508:4;1500:6;1496:17;1492:27;1482:2;;1533:1;1530;1523:12;1482:2;-1:-1;1553:20;;-1:-1;;;;;1582:30;;1579:2;;;1625:1;1622;1615:12;1579:2;1659:4;1651:6;1647:17;1635:29;;1709:3;1702;1694:6;1690:16;1680:8;1676:31;1673:40;1670:2;;;1726:1;1723;1716:12;1745:440;;1846:3;1839:4;1831:6;1827:17;1823:27;1813:2;;1864:1;1861;1854:12;1813:2;1901:6;1888:20;1923:64;1938:48;1979:6;1938:48;;1923:64;1914:73;;2007:6;2000:5;1993:21;2043:4;2035:6;2031:17;2076:4;2069:5;2065:16;2111:3;2102:6;2097:3;2093:16;2090:25;2087:2;;;2128:1;2125;2118:12;2087:2;2138:41;2172:6;2167:3;2162;2138:41;;;1806:379;;;;;;;;3446:130;3513:20;;3538:33;3513:20;3538:33;;3583:263;;3698:2;3686:9;3677:7;3673:23;3669:32;3666:2;;;3714:1;3711;3704:12;3666:2;3749:1;3766:64;3822:7;3802:9;3766:64;;;3756:74;3660:186;-1:-1;;;;3660:186;3853:538;;;;4017:2;4005:9;3996:7;3992:23;3988:32;3985:2;;;4033:1;4030;4023:12;3985:2;4068:31;;-1:-1;;;;;4108:30;;4105:2;;;4151:1;4148;4141:12;4105:2;4179:88;4259:7;4250:6;4239:9;4235:22;4179:88;;;4169:98;;;;4047:226;4304:2;4322:53;4367:7;4358:6;4347:9;4343:22;4322:53;;;4312:63;;4283:98;3979:412;;;;;;4398:787;;;;4598:2;4586:9;4577:7;4573:23;4569:32;4566:2;;;4614:1;4611;4604:12;4566:2;4649:31;;-1:-1;;;;;4689:30;;4686:2;;;4732:1;4729;4722:12;4686:2;4752:84;4828:7;4819:6;4808:9;4804:22;4752:84;;;4742:94;;4628:214;4901:2;4890:9;4886:18;4873:32;-1:-1;;;;;4917:6;4914:30;4911:2;;;4957:1;4954;4947:12;4911:2;4977:84;5053:7;5044:6;5033:9;5029:22;4977:84;;;4967:94;;4852:215;5098:2;5116:53;5161:7;5152:6;5141:9;5137:22;5116:53;;5192:1017;;;;;5418:3;5406:9;5397:7;5393:23;5389:33;5386:2;;;5435:1;5432;5425:12;5386:2;5470:31;;-1:-1;;;;;5510:30;;5507:2;;;5553:1;5550;5543:12;5507:2;5573:84;5649:7;5640:6;5629:9;5625:22;5573:84;;;5563:94;;5449:214;5722:2;5711:9;5707:18;5694:32;-1:-1;;;;;5738:6;5735:30;5732:2;;;5778:1;5775;5768:12;5732:2;5798:84;5874:7;5865:6;5854:9;5850:22;5798:84;;;5788:94;;5673:215;5919:2;5937:53;5982:7;5973:6;5962:9;5958:22;5937:53;;;5927:63;;5898:98;6055:2;6044:9;6040:18;6027:32;-1:-1;;;;;6071:6;6068:30;6065:2;;;6111:1;6108;6101:12;6065:2;6131:62;6185:7;6176:6;6165:9;6161:22;6131:62;;;6121:72;;6006:193;5380:829;;;;;;;;6216:257;;6328:2;6316:9;6307:7;6303:23;6299:32;6296:2;;;6344:1;6341;6334:12;6296:2;6379:1;6396:61;6449:7;6429:9;6396:61;;6480:743;;;;;;6658:2;6646:9;6637:7;6633:23;6629:32;6626:2;;;6674:1;6671;6664:12;6626:2;6709:31;;-1:-1;;;;;6749:30;;6746:2;;;6792:1;6789;6782:12;6746:2;6820:65;6877:7;6868:6;6857:9;6853:22;6820:65;;;6810:75;;;;6688:203;6950:2;6939:9;6935:18;6922:32;-1:-1;;;;;6966:6;6963:30;6960:2;;;7006:1;7003;6996:12;6960:2;7034:65;7091:7;7082:6;7071:9;7067:22;7034:65;;;7024:75;;;;6901:204;7136:2;7154:53;7199:7;7190:6;7179:9;7175:22;7154:53;;;7144:63;;7115:98;6620:603;;;;;;;;;7230:993;;;;;;;;7444:3;7432:9;7423:7;7419:23;7415:33;7412:2;;;7461:1;7458;7451:12;7412:2;7496:31;;-1:-1;;;;;7536:30;;7533:2;;;7579:1;7576;7569:12;7533:2;7607:65;7664:7;7655:6;7644:9;7640:22;7607:65;;;7597:75;;;;7475:203;7737:2;7726:9;7722:18;7709:32;-1:-1;;;;;7753:6;7750:30;7747:2;;;7793:1;7790;7783:12;7747:2;7821:65;7878:7;7869:6;7858:9;7854:22;7821:65;;;7811:75;;;;7688:204;7923:2;7941:53;7986:7;7977:6;7966:9;7962:22;7941:53;;;7931:63;;7902:98;8059:2;8048:9;8044:18;8031:32;-1:-1;;;;;8075:6;8072:30;8069:2;;;8115:1;8112;8105:12;8069:2;8143:64;8199:7;8190:6;8179:9;8175:22;8143:64;;;8133:74;;;;8010:203;7406:817;;;;;;;;;;;8230:472;;;8361:2;8349:9;8340:7;8336:23;8332:32;8329:2;;;8377:1;8374;8367:12;8329:2;8412:31;;-1:-1;;;;;8452:30;;8449:2;;;8495:1;8492;8485:12;8449:2;8515:63;8570:7;8561:6;8550:9;8546:22;8515:63;;;8505:73;;8391:193;8615:2;8633:53;8678:7;8669:6;8658:9;8654:22;8633:53;;;8623:63;;8594:98;8323:379;;;;;;8709:241;;8813:2;8801:9;8792:7;8788:23;8784:32;8781:2;;;8829:1;8826;8819:12;8781:2;8864:1;8881:53;8926:7;8906:9;8881:53;;8957:490;;;;9097:2;9085:9;9076:7;9072:23;9068:32;9065:2;;;9113:1;9110;9103:12;9065:2;9148:1;9165:53;9210:7;9190:9;9165:53;;;9155:63;;9127:97;9283:2;9272:9;9268:18;9255:32;-1:-1;;;;;9299:6;9296:30;9293:2;;;9339:1;9336;9329:12;9293:2;9367:64;9423:7;9414:6;9403:9;9399:22;9367:64;;;9357:74;;;;9234:203;9059:388;;;;;;9454:366;;;9575:2;9563:9;9554:7;9550:23;9546:32;9543:2;;;9591:1;9588;9581:12;9543:2;9626:1;9643:53;9688:7;9668:9;9643:53;;9827:615;;;;;9984:2;9972:9;9963:7;9959:23;9955:32;9952:2;;;10000:1;9997;9990:12;9952:2;10035:1;10052:53;10097:7;10077:9;10052:53;;;10042:63;;10014:97;10142:2;10160:53;10205:7;10196:6;10185:9;10181:22;10160:53;;;10150:63;;10121:98;10278:2;10267:9;10263:18;10250:32;-1:-1;;;;;10294:6;10291:30;10288:2;;;10334:1;10331;10324:12;10288:2;10362:64;10418:7;10409:6;10398:9;10394:22;10362:64;;;9946:496;;;;-1:-1;10352:74;-1:-1;;;;9946:496;10450:181;;10563:62;10621:3;10613:6;10563:62;;;10549:76;10542:89;-1:-1;;;10542:89;10639:142;10730:45;10769:5;10730:45;;;10725:3;10718:58;10712:69;;;10788:113;10871:24;10889:5;10871:24;;10908:152;11009:45;11029:24;11047:5;11029:24;;;11009:45;;11096:896;;11253:60;11307:5;11253:60;;;11326:92;11411:6;11406:3;11326:92;;;11319:99;;11441:3;11483:4;11475:6;11471:17;11466:3;11462:27;11510:62;11566:5;11510:62;;;11592:7;11620:1;11605:348;11630:6;11627:1;11624:13;11605:348;;;11692:9;11686:4;11682:20;11677:3;11670:33;11737:6;11731:13;11759:76;11830:4;11815:13;11759:76;;;11751:84;;11852:66;11911:6;11852:66;;;11941:4;11932:14;;;;;11842:76;-1:-1;;11652:1;11645:9;11605:348;;;-1:-1;11966:4;;11232:760;-1:-1;;;;;;;11232:760;12000:113;12083:24;12101:5;12083:24;;12120:152;12221:45;12241:24;12259:5;12241:24;;;12221:45;;12304:300;;12420:71;12484:6;12479:3;12420:71;;;12413:78;;12503:43;12539:6;12534:3;12527:5;12503:43;;;12568:29;12590:6;12568:29;;;12559:39;;;;12406:198;-1:-1;;;12406:198;12637:309;;12767:89;12849:6;12844:3;12767:89;;;12760:96;;12868:43;12904:6;12899:3;12892:5;12868:43;;;-1:-1;;12924:16;;12753:193;12954:347;;13066:39;13099:5;13066:39;;;13117:71;13181:6;13176:3;13117:71;;;13110:78;;13193:52;13238:6;13233:3;13226:4;13219:5;13215:16;13193:52;;;13266:29;13288:6;13266:29;;13308:360;;13438:39;13471:5;13438:39;;;13489:89;13571:6;13566:3;13489:89;;;13482:96;;13583:52;13628:6;13623:3;13616:4;13609:5;13605:16;13583:52;;;13647:16;;;;;13418:250;-1:-1;;13418:250;14002:400;;14180:85;14262:2;14257:3;14180:85;;;14298:66;14278:87;;14393:2;14384:12;;14166:236;-1:-1;;14166:236;14411:465;;14571:67;14635:2;14630:3;14571:67;;;14671:66;14651:87;;-1:-1;;;14767:2;14758:12;;14751:88;14867:2;14858:12;;14557:319;-1:-1;;14557:319;15163:107;15242:22;15258:5;15242:22;;15277:522;;15452:75;15523:3;15514:6;15452:75;;;15549:2;15544:3;15540:12;15533:19;;15563:75;15634:3;15625:6;15563:75;;;15660:2;15655:3;15651:12;15644:19;;15674:75;15745:3;15736:6;15674:75;;;-1:-1;15771:2;15762:12;;15440:359;-1:-1;;;15440:359;15806:278;;15958:101;16055:3;16046:6;16038;15958:101;;16091:266;;16237:95;16328:3;16319:6;16237:95;;16364:511;;16591:148;16735:3;16591:148;;;16584:155;;16750:75;16821:3;16812:6;16750:75;;;-1:-1;16847:2;16838:12;;16572:303;-1:-1;16572:303;16882:213;17000:2;16985:18;;17014:71;16989:9;17058:6;17014:71;;17102:340;17256:2;17241:18;;17270:79;17245:9;17322:6;17270:79;;;17360:72;17428:2;17417:9;17413:18;17404:6;17360:72;;17449:324;17595:2;17580:18;;17609:71;17584:9;17653:6;17609:71;;17780:385;17960:2;17974:47;;;17945:18;;18035:120;17945:18;18141:6;18035:120;;18172:779;18470:2;18484:47;;;18455:18;;18545:120;18455:18;18651:6;18545:120;;;18537:128;;18713:9;18707:4;18703:20;18698:2;18687:9;18683:18;18676:48;18738:120;18853:4;18844:6;18738:120;;;18730:128;;18869:72;18937:2;18926:9;18922:18;18913:6;18869:72;;18958:539;19156:3;19141:19;;19171:71;19145:9;19215:6;19171:71;;;19253:68;19317:2;19306:9;19302:18;19293:6;19253:68;;;19332:72;19400:2;19389:9;19385:18;19376:6;19332:72;;;19415;19483:2;19472:9;19468:18;19459:6;19415:72;;;19127:370;;;;;;;;19504:651;19738:2;19752:47;;;19723:18;;19813:88;19723:18;19887:6;19879;19813:88;;;19805:96;;19949:9;19943:4;19939:20;19934:2;19923:9;19919:18;19912:48;19974:88;20057:4;20048:6;20040;19974:88;;;19966:96;;20073:72;20141:2;20130:9;20126:18;20117:6;20073:72;;;19709:446;;;;;;;;;20162:301;20300:2;20314:47;;;20285:18;;20375:78;20285:18;20439:6;20375:78;;20470:407;20661:2;20675:47;;;20646:18;;20736:131;20646:18;20736:131;;20884:213;21002:2;20987:18;;21016:71;20991:9;21060:6;21016:71;;21104:324;21250:2;21235:18;;21264:71;21239:9;21308:6;21264:71;;21435:256;21497:2;21491:9;21523:17;;;-1:-1;;;;;21583:34;;21619:22;;;21580:62;21577:2;;;21655:1;21652;21645:12;21577:2;21671;21664:22;21475:216;;-1:-1;21475:216;21698:310;;-1:-1;;;;;21855:6;21852:30;21849:2;;;21895:1;21892;21885:12;21849:2;-1:-1;21930:4;21918:17;;;21983:15;;21786:222;22015:321;;-1:-1;;;;;22150:6;22147:30;22144:2;;;22190:1;22187;22180:12;22144:2;-1:-1;22321:4;22257;22234:17;;;;-1:-1;;22230:33;22311:15;;22081:255;22997:157;23127:4;23118:14;;23075:79;23161:143;23270:12;;23241:63;23687:184;23811:19;;;23860:4;23851:14;;23804:67;24214:145;24350:3;24328:31;-1:-1;24328:31;24367:91;;24429:24;24447:5;24429:24;;24465:85;24531:13;24524:21;;24507:43;24636:121;-1:-1;;;;;24698:54;;24681:76;24843:81;24914:4;24903:16;;24886:38;24931:129;;25018:37;25049:5;25067:121;25146:37;25177:5;25146:37;;25311:145;25392:6;25387:3;25382;25369:30;-1:-1;25448:1;25430:16;;25423:27;25362:94;25465:268;25530:1;25537:101;25551:6;25548:1;25545:13;25537:101;;;25618:11;;;25612:18;25599:11;;;25592:39;25573:2;25566:10;25537:101;;;25653:6;25650:1;25647:13;25644:2;;;-1:-1;;25718:1;25700:16;;25693:27;25514:219;25741:95;;25805:26;25825:5;25924:89;25988:20;26002:5;25988:20;;26101:97;26189:2;26169:14;-1:-1;;26165:28;;26149:49;26206:94;26280:2;26276:14;;26248:52;26308:117;26377:24;26395:5;26377:24;;;26370:5;26367:35;26357:2;;26416:1;26413;26406:12;26432:111;26498:21;26513:5;26498:21;;26550:117;26619:24;26637:5;26619:24;
Swarm Source
bzzr://95c236bb08d6c28ac249309622ed4f27245cd933140c6b7fdf9ef20e10e2908c
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.