Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
Latest 25 from a total of 1,090 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
|||||
---|---|---|---|---|---|---|---|---|---|
Mint | 17014416 | 465 days ago | IN | 0 ETH | 0.00091769 | ||||
Mint | 17014416 | 465 days ago | IN | 0 ETH | 0.00091769 | ||||
Mint | 17008417 | 465 days ago | IN | 0 ETH | 0.00295771 | ||||
Mint | 17000980 | 466 days ago | IN | 0 ETH | 0.00288149 | ||||
Mint | 16997813 | 467 days ago | IN | 0 ETH | 0.00580728 | ||||
Mint | 16997070 | 467 days ago | IN | 0 ETH | 0.00444381 | ||||
Mint | 16993910 | 467 days ago | IN | 0 ETH | 0.00336103 | ||||
Mint | 16993853 | 467 days ago | IN | 0 ETH | 0.00307443 | ||||
Mint | 16992965 | 468 days ago | IN | 0 ETH | 0.00324406 | ||||
Mint | 16992546 | 468 days ago | IN | 0 ETH | 0.00344549 | ||||
Mint | 16992450 | 468 days ago | IN | 0 ETH | 0.00337585 | ||||
Mint | 16992379 | 468 days ago | IN | 0 ETH | 0.00348706 | ||||
Mint | 16992368 | 468 days ago | IN | 0 ETH | 0.00358397 | ||||
Mint | 16992361 | 468 days ago | IN | 0 ETH | 0.00378642 | ||||
Mint | 16992051 | 468 days ago | IN | 0 ETH | 0.00401715 | ||||
Mint | 16991976 | 468 days ago | IN | 0 ETH | 0.0038961 | ||||
Mint | 16991890 | 468 days ago | IN | 0 ETH | 0.00132832 | ||||
Mint | 16991890 | 468 days ago | IN | 0 ETH | 0.00133085 | ||||
Mint | 16991871 | 468 days ago | IN | 0 ETH | 0.00128578 | ||||
Mint | 16991840 | 468 days ago | IN | 0 ETH | 0.00136632 | ||||
Mint | 16991840 | 468 days ago | IN | 0 ETH | 0.00145236 | ||||
Mint | 16991832 | 468 days ago | IN | 0 ETH | 0.00164262 | ||||
Mint | 16991827 | 468 days ago | IN | 0 ETH | 0.00147978 | ||||
Mint | 16991823 | 468 days ago | IN | 0 ETH | 0.00257891 | ||||
Mint | 16991822 | 468 days ago | IN | 0 ETH | 0.00181415 |
Advanced mode: Intended for advanced users or developers and will display all Internal Transactions including zero value transfers. Name tag integration is not available in advanced view.
Latest 25 internal transactions (View All)
Advanced mode:
Parent Transaction Hash | Block | From | To | ||||
---|---|---|---|---|---|---|---|
17008417 | 465 days ago | 0 ETH | |||||
17000980 | 466 days ago | 0 ETH | |||||
16997813 | 467 days ago | 0 ETH | |||||
16997070 | 467 days ago | 0 ETH | |||||
16993910 | 467 days ago | 0 ETH | |||||
16993853 | 467 days ago | 0 ETH | |||||
16992965 | 468 days ago | 0 ETH | |||||
16992546 | 468 days ago | 0 ETH | |||||
16992450 | 468 days ago | 0 ETH | |||||
16992379 | 468 days ago | 0 ETH | |||||
16992368 | 468 days ago | 0 ETH | |||||
16992361 | 468 days ago | 0 ETH | |||||
16992051 | 468 days ago | 0 ETH | |||||
16991976 | 468 days ago | 0 ETH | |||||
16991818 | 468 days ago | 0 ETH | |||||
16991818 | 468 days ago | 0 ETH | |||||
16991818 | 468 days ago | 0 ETH | |||||
16991816 | 468 days ago | 0 ETH | |||||
16991816 | 468 days ago | 0 ETH | |||||
16991816 | 468 days ago | 0 ETH | |||||
16991816 | 468 days ago | 0 ETH | |||||
16991816 | 468 days ago | 0 ETH | |||||
16991815 | 468 days ago | 0 ETH | |||||
16991814 | 468 days ago | 0 ETH | |||||
16991813 | 468 days ago | 0 ETH |
Loading...
Loading
Similar Match Source Code This contract matches the deployed Bytecode of the Source Code for Contract 0xdC1Ea3d2...F7938b1a7 The constructor portion of the code might be different and could alter the actual behaviour of the contract
Contract Name:
MEMint
Compiler Version
v0.8.19+commit.7dd6d404
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2023-04-06 */ interface IERC165Upgradeable { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * 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); } interface IERC721Upgradeable is IERC165Upgradeable { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes calldata data ) external; /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721 * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must * understand this adds an external call which potentially creates a reentrancy vulnerability. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the caller. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool _approved) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); } interface IERC4906Upgradeable is IERC165Upgradeable, IERC721Upgradeable { /// @dev This event emits when the metadata of a token is changed. /// So that the third-party platforms such as NFT market could /// timely update the images and related attributes of the NFT. event MetadataUpdate(uint256 _tokenId); /// @dev This event emits when the metadata of a range of tokens is changed. /// So that the third-party platforms such as NFT market could /// timely update the images and related attributes of the NFTs. event BatchMetadataUpdate(uint256 _fromTokenId, uint256 _toTokenId); } interface IRenovaItemBase is IERC4906Upgradeable { /// @notice Emitted when an item is minted. /// @param player The player who owns the item. /// @param tokenId The token ID. /// @param hashverseItemId The Hashverse Item ID. event Mint( address indexed player, uint256 tokenId, uint256 hashverseItemId ); /// @notice Emitted when the Custom Metadata URI is updated. /// @param uri The new URI. event UpdateCustomURI(string uri); /// @notice Emitted when an item is bridged out of the current chain. /// @param player The player. /// @param tokenId The Token ID. /// @param hashverseItemId The Hashverse Item ID. /// @param dstWormholeChainId The Wormhole Chain ID of the chain the item is being bridged to. /// @param sequence The Wormhole sequence number. event XChainBridgeOut( address indexed player, uint256 tokenId, uint256 hashverseItemId, uint16 dstWormholeChainId, uint256 sequence, uint256 relayerFee ); /// @notice Emitted when an item was bridged into the current chain. /// @param player The player. /// @param tokenId The Token ID. /// @param hashverseItemId The Hashverse Item ID. /// @param srcWormholeChainId The Wormhole Chain ID of the chain the item is being bridged from. event XChainBridgeIn( address indexed player, uint256 tokenId, uint256 hashverseItemId, uint16 srcWormholeChainId ); /// @notice Bridges an item into the chain via Wormhole. /// @param vaa The Wormhole VAA. function wormholeBridgeIn(bytes memory vaa) external; /// @notice Bridges an item out of the chain via Wormhole. /// @param tokenId The Token ID. /// @param dstWormholeChainId The Wormhole Chain ID of the chain the item is being bridged to. function wormholeBridgeOut( uint256 tokenId, uint16 dstWormholeChainId, uint256 wormholeMessageFee ) external payable; /// @notice Sets the default royalty for the Item collection. /// @param receiver The receiver of royalties. /// @param feeNumerator The numerator of the fraction denoting the royalty percentage. function setDefaultRoyalty(address receiver, uint96 feeNumerator) external; /// @notice Sets a custom base URI for the token metadata. /// @param customBaseURI The new Custom URI. function setCustomBaseURI(string memory customBaseURI) external; /// @notice Emits a refresh metadata event for a token. /// @param tokenId The ID of the token. function refreshMetadata(uint256 tokenId) external; /// @notice Emits a refresh metadata event for all tokens. function refreshAllMetadata() external; } interface IRenovaItem is IRenovaItemBase { /// @notice Emitted when the authorization status of a minter changes. /// @param minter The minter for which the status was updated. /// @param status The new status. event UpdateMinterAuthorization(address minter, bool status); /// @notice Initializer function. /// @param minter The initial authorized minter. /// @param wormhole The Wormhole Endpoint address. See {IWormholeBaseUpgradeable}. /// @param wormholeConsistencyLevel The Wormhole Consistency Level. See {IWormholeBaseUpgradeable}. function initialize( address minter, address wormhole, uint8 wormholeConsistencyLevel ) external; /// @notice Mints an item. /// @param tokenOwner The owner of the item. /// @param hashverseItemId The Hashverse Item ID. function mint(address tokenOwner, uint256 hashverseItemId) external; /// @notice Updates the authorization status of a minter. /// @param minter The minter to update the authorization status for. /// @param status The new status. function updateMinterAuthorization(address minter, bool status) external; } library MerkleProof { /** * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree * defined by `root`. For this, a `proof` must be provided, containing * sibling hashes on the branch from the leaf to the root of the tree. Each * pair of leaves and each pair of pre-images are assumed to be sorted. */ function verify( bytes32[] memory proof, bytes32 root, bytes32 leaf ) internal pure returns (bool) { return processProof(proof, leaf) == root; } /** * @dev Calldata version of {verify} * * _Available since v4.7._ */ function verifyCalldata( bytes32[] calldata proof, bytes32 root, bytes32 leaf ) internal pure returns (bool) { return processProofCalldata(proof, leaf) == root; } /** * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt * hash matches the root of the tree. When processing the proof, the pairs * of leafs & pre-images are assumed to be sorted. * * _Available since v4.4._ */ function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) { bytes32 computedHash = leaf; for (uint256 i = 0; i < proof.length; i++) { computedHash = _hashPair(computedHash, proof[i]); } return computedHash; } /** * @dev Calldata version of {processProof} * * _Available since v4.7._ */ function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) { bytes32 computedHash = leaf; for (uint256 i = 0; i < proof.length; i++) { computedHash = _hashPair(computedHash, proof[i]); } return computedHash; } /** * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a merkle tree defined by * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}. * * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details. * * _Available since v4.7._ */ function multiProofVerify( bytes32[] memory proof, bool[] memory proofFlags, bytes32 root, bytes32[] memory leaves ) internal pure returns (bool) { return processMultiProof(proof, proofFlags, leaves) == root; } /** * @dev Calldata version of {multiProofVerify} * * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details. * * _Available since v4.7._ */ function multiProofVerifyCalldata( bytes32[] calldata proof, bool[] calldata proofFlags, bytes32 root, bytes32[] memory leaves ) internal pure returns (bool) { return processMultiProofCalldata(proof, proofFlags, leaves) == root; } /** * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false * respectively. * * CAUTION: Not all merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer). * * _Available since v4.7._ */ function processMultiProof( bytes32[] memory proof, bool[] memory proofFlags, bytes32[] memory leaves ) internal pure returns (bytes32 merkleRoot) { // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of // the merkle tree. uint256 leavesLen = leaves.length; uint256 totalHashes = proofFlags.length; // Check proof validity. require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof"); // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop". bytes32[] memory hashes = new bytes32[](totalHashes); uint256 leafPos = 0; uint256 hashPos = 0; uint256 proofPos = 0; // At each step, we compute the next hash using two values: // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we // get the next hash. // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the // `proof` array. for (uint256 i = 0; i < totalHashes; i++) { bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++]; bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++]; hashes[i] = _hashPair(a, b); } if (totalHashes > 0) { return hashes[totalHashes - 1]; } else if (leavesLen > 0) { return leaves[0]; } else { return proof[0]; } } /** * @dev Calldata version of {processMultiProof}. * * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details. * * _Available since v4.7._ */ function processMultiProofCalldata( bytes32[] calldata proof, bool[] calldata proofFlags, bytes32[] memory leaves ) internal pure returns (bytes32 merkleRoot) { // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of // the merkle tree. uint256 leavesLen = leaves.length; uint256 totalHashes = proofFlags.length; // Check proof validity. require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof"); // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop". bytes32[] memory hashes = new bytes32[](totalHashes); uint256 leafPos = 0; uint256 hashPos = 0; uint256 proofPos = 0; // At each step, we compute the next hash using two values: // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we // get the next hash. // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the // `proof` array. for (uint256 i = 0; i < totalHashes; i++) { bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++]; bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++]; hashes[i] = _hashPair(a, b); } if (totalHashes > 0) { return hashes[totalHashes - 1]; } else if (leavesLen > 0) { return leaves[0]; } else { return proof[0]; } } function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) { return a < b ? _efficientHash(a, b) : _efficientHash(b, a); } function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) { /// @solidity memory-safe-assembly assembly { mstore(0x00, a) mstore(0x20, b) value := keccak256(0x00, 0x40) } } } abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } contract MEMint is Context { bytes32 private _preAllocatedMerkleRoot; bytes32 private _publicMerkleRoot; address private _renovaItem; mapping(address => bool) _minted; uint256 private _maxPublicMints; uint256 private _numPublicMints; uint256 public totalMinted; event Mint(address player); constructor( bytes32 preAllocatedMerkleRoot, bytes32 publicMerkleRoot, address renovaItem, uint256 maxPublicMints ) { require( preAllocatedMerkleRoot != bytes32(0), 'MEMint::constructor Pre-allocated Merkle Root cannot be 0.' ); require( publicMerkleRoot != bytes32(0), 'MEMint::constructor Public Merkle Root cannot be 0.' ); require( renovaItem != address(0), 'MEMint::constructor RenovaItem cannot be 0.' ); _preAllocatedMerkleRoot = preAllocatedMerkleRoot; _publicMerkleRoot = publicMerkleRoot; _renovaItem = renovaItem; _maxPublicMints = maxPublicMints; _numPublicMints = 0; } function mint( uint256[] calldata hashverseItemIds, bytes32[] calldata proof ) external { require(!_minted[_msgSender()], 'MEMint::mint Already minted.'); bytes32 leaf = keccak256( abi.encodePacked(_msgSender(), hashverseItemIds) ); if (!MerkleProof.verifyCalldata(proof, _preAllocatedMerkleRoot, leaf)) { if (!MerkleProof.verifyCalldata(proof, _publicMerkleRoot, leaf)) { revert('MEMint::mint Proof invalid.'); } else { require( _numPublicMints < _maxPublicMints, 'MEMint::mint Mint limit reached.' ); _numPublicMints++; totalMinted++; } } _minted[_msgSender()] = true; emit Mint(_msgSender()); for (uint256 i = 0; i < hashverseItemIds.length; i++) { IRenovaItem(_renovaItem).mint(_msgSender(), hashverseItemIds[i]); } } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"bytes32","name":"preAllocatedMerkleRoot","type":"bytes32"},{"internalType":"bytes32","name":"publicMerkleRoot","type":"bytes32"},{"internalType":"address","name":"renovaItem","type":"address"},{"internalType":"uint256","name":"maxPublicMints","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"player","type":"address"}],"name":"Mint","type":"event"},{"inputs":[{"internalType":"uint256[]","name":"hashverseItemIds","type":"uint256[]"},{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]
Deployed Bytecode
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
Deployed Bytecode Sourcemap
18964:2198:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20127:1032;;;;;;:::i;:::-;;:::i;:::-;;19239:26;;;;;;;;;1310:25:1;;;1298:2;1283:18;19239:26:0;;;;;;;20127:1032;18830:10;20258:21;;;;:7;:21;;;;;;;;20257:22;20249:63;;;;-1:-1:-1;;;20249:63:0;;1548:2:1;20249:63:0;;;1530:21:1;1587:2;1567:18;;;1560:30;1626;1606:18;;;1599:58;1674:18;;20249:63:0;;;;;;;;;20325:12;18830:10;20395:16;;20364:48;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;20340:83;;;;;;20325:98;;20441:64;20468:5;;20475:23;;20500:4;20441:26;:64::i;:::-;20436:482;;20527:58;20554:5;;20561:17;;20580:4;20527:26;:58::i;:::-;20522:385;;20606:37;;-1:-1:-1;;;20606:37:0;;2470:2:1;20606:37:0;;;2452:21:1;2509:2;2489:18;;;2482:30;2548:29;2528:18;;;2521:57;2595:18;;20606:37:0;2268:351:1;20522:385:0;20732:15;;20714;;:33;20684:139;;;;-1:-1:-1;;;20684:139:0;;2826:2:1;20684:139:0;;;2808:21:1;;;2845:18;;;2838:30;2904:34;2884:18;;;2877:62;2956:18;;20684:139:0;2624:356:1;20684:139:0;20842:15;:17;;;:15;:17;;;:::i;:::-;;;;-1:-1:-1;;20878:11:0;:13;;;:11;:13;;;:::i;:::-;;;;;;20522:385;18830:10;20930:21;;;;:7;:21;;;;;;;;;:28;;;;20954:4;20930:28;;;20976:18;;3485:74:1;;;20976:18:0;;;;;;;;;;;;21012:9;21007:145;21027:27;;;21007:145;;;21088:11;;;;21076:29;18830:10;21120:16;;21137:1;21120:19;;;;;;;:::i;:::-;21076:64;;;;;;;;;;3963:42:1;3951:55;;;21076:64:0;;;3933:74:1;21120:19:0;;;;;;;4023:18:1;;;4016:34;-1:-1:-1;3906:18:1;;21076:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21056:3;;;;;:::i;:::-;;;;21007:145;;;;20238:921;20127:1032;;;;:::o;10676:208::-;10811:4;10872;10835:33;10856:5;;10863:4;10835:20;:33::i;:::-;:41;;10676:208;-1:-1:-1;;;;;10676:208:0:o;11655:306::-;11748:7;11791:4;11748:7;11806:118;11826:16;;;11806:118;;;11879:33;11889:12;11903:5;;11909:1;11903:8;;;;;;;:::i;:::-;;;;;;;11879:9;:33::i;:::-;11864:48;-1:-1:-1;11844:3:0;;;;:::i;:::-;;;;11806:118;;;-1:-1:-1;11941:12:0;11655:306;-1:-1:-1;;;;11655:306:0:o;18285:149::-;18348:7;18379:1;18375;:5;:51;;18510:13;18604:15;;;18640:4;18633:15;;;18687:4;18671:21;;18375:51;;;18510:13;18604:15;;;18640:4;18633:15;;;18687:4;18671:21;;18383:20;18368:58;18285:149;-1:-1:-1;;;18285:149:0:o;14:367:1:-;77:8;87:6;141:3;134:4;126:6;122:17;118:27;108:55;;159:1;156;149:12;108:55;-1:-1:-1;182:20:1;;225:18;214:30;;211:50;;;257:1;254;247:12;211:50;294:4;286:6;282:17;270:29;;354:3;347:4;337:6;334:1;330:14;322:6;318:27;314:38;311:47;308:67;;;371:1;368;361:12;308:67;14:367;;;;;:::o;386:773::-;508:6;516;524;532;585:2;573:9;564:7;560:23;556:32;553:52;;;601:1;598;591:12;553:52;641:9;628:23;670:18;711:2;703:6;700:14;697:34;;;727:1;724;717:12;697:34;766:70;828:7;819:6;808:9;804:22;766:70;:::i;:::-;855:8;;-1:-1:-1;740:96:1;-1:-1:-1;943:2:1;928:18;;915:32;;-1:-1:-1;959:16:1;;;956:36;;;988:1;985;978:12;956:36;;1027:72;1091:7;1080:8;1069:9;1065:24;1027:72;:::i;:::-;386:773;;;;-1:-1:-1;1118:8:1;-1:-1:-1;;;;386:773:1:o;1703:560::-;1953:66;1944:6;1940:2;1936:15;1932:88;1927:3;1920:101;1902:3;2044:66;2036:6;2033:78;2030:98;;;2124:1;2121;2114:12;2030:98;2158:6;2155:1;2151:14;2209:6;2201;2196:2;2191:3;2187:12;2174:42;2236:16;;;;2254:2;2232:25;;1703:560;-1:-1:-1;;;;1703:560:1:o;2985:349::-;3024:3;3055:66;3048:5;3045:77;3042:257;;3155:77;3152:1;3145:88;3256:4;3253:1;3246:15;3284:4;3281:1;3274:15;3042:257;-1:-1:-1;3326:1:1;3315:13;;2985:349::o;3570:184::-;3622:77;3619:1;3612:88;3719:4;3716:1;3709:15;3743:4;3740:1;3733:15
Swarm Source
ipfs://a0cf44b64640bcd507a1912732af1b268c5eaec1352dba9221672ca54dac0b50
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.