Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;

import {IMetadataRenderer} from "../interfaces/IMetadataRenderer.sol";
import {IERC721Drop} from "../interfaces/IERC721Drop.sol";
import {IERC721MetadataUpgradeable} from "@openzeppelin/contracts-upgradeable/interfaces/IERC721MetadataUpgradeable.sol";
import {IERC2981Upgradeable} from "@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol";
import {NFTMetadataRenderer} from "../utils/NFTMetadataRenderer.sol";
import {MetadataRenderAdminCheck} from "./MetadataRenderAdminCheck.sol";

interface DropConfigGetter {
    function config()
        external
        view
        returns (IERC721Drop.Configuration memory config);
}

/// @notice EditionMetadataRenderer for editions support
contract EditionMetadataRenderer is
    IMetadataRenderer,
    MetadataRenderAdminCheck
{
    /// @notice Storage for token edition information
    struct TokenEditionInfo {
        string description;
        string imageURI;
        string animationURI;
    }

    /// @notice Event for updated Media URIs
    event MediaURIsUpdated(
        address indexed target,
        address sender,
        string imageURI,
        string animationURI
    );

    /// @notice Event for a new edition initialized
    /// @dev admin function indexer feedback
    event EditionInitialized(
        address indexed target,
        string description,
        string imageURI,
        string animationURI
    );

    /// @notice Description updated for this edition
    /// @dev admin function indexer feedback
    event DescriptionUpdated(
        address indexed target,
        address sender,
        string newDescription
    );

    /// @notice Token information mapping storage
    mapping(address => TokenEditionInfo) public tokenInfos;

    /// @notice Update media URIs
    /// @param target target for contract to update metadata for
    /// @param imageURI new image uri address
    /// @param animationURI new animation uri address
    function updateMediaURIs(
        address target,
        string memory imageURI,
        string memory animationURI
    ) external requireSenderAdmin(target) {
        tokenInfos[target].imageURI = imageURI;
        tokenInfos[target].animationURI = animationURI;
        emit MediaURIsUpdated({
            target: target,
            sender: msg.sender,
            imageURI: imageURI,
            animationURI: animationURI
        });
    }

    /// @notice Admin function to update description
    /// @param target target description
    /// @param newDescription new description
    function updateDescription(address target, string memory newDescription)
        external
        requireSenderAdmin(target)
    {
        tokenInfos[target].description = newDescription;

        emit DescriptionUpdated({
            target: target,
            sender: msg.sender,
            newDescription: newDescription
        });
    }

    /// @notice Default initializer for edition data from a specific contract
    /// @param data data to init with
    function initializeWithData(bytes memory data) external {
        // data format: description, imageURI, animationURI
        (
            string memory description,
            string memory imageURI,
            string memory animationURI
        ) = abi.decode(data, (string, string, string));

        tokenInfos[msg.sender] = TokenEditionInfo({
            description: description,
            imageURI: imageURI,
            animationURI: animationURI
        });
        emit EditionInitialized({
            target: msg.sender,
            description: description,
            imageURI: imageURI,
            animationURI: animationURI
        });
    }

    /// @notice no-op 
    /// @param target target contract to update metadata for
    /// @param metadataBase new base URI to update metadata with
    /// @param metadataExtension new extension to append to base metadata URI
    /// @param freezeAt time to freeze the contract metadata at (set to 0 to disable)
    function updateMetadataBaseWithDetails(
        address target,
        string memory metadataBase,
        string memory metadataExtension,
        string memory newContractURI,
        uint256 freezeAt
    ) external requireSenderAdmin(target) {
        // no-op
    }

    /// @notice Contract URI information getter
    /// @return contract uri (if set)
    function contractURI() external view override returns (string memory) {
        address target = msg.sender;
        TokenEditionInfo storage editionInfo = tokenInfos[target];
        IERC721Drop.Configuration memory config = DropConfigGetter(target)
            .config();

        return
            NFTMetadataRenderer.encodeContractURIJSON({
                name: IERC721MetadataUpgradeable(target).name(),
                description: editionInfo.description,
                imageURI: editionInfo.imageURI,
                animationURI: editionInfo.animationURI,
                royaltyBPS: uint256(config.royaltyBPS),
                royaltyRecipient: config.fundsRecipient
            });
    }

    /// @notice Token URI information getter
    /// @param tokenId to get uri for
    /// @return contract uri (if set)
    function tokenURI(uint256 tokenId)
        external
        view
        override
        returns (string memory)
    {
        address target = msg.sender;

        TokenEditionInfo memory info = tokenInfos[target];
        IERC721Drop media = IERC721Drop(target);

        uint256 maxSupply = media.saleDetails().maxSupply;

        // For open editions, set max supply to 0 for renderer to remove the edition max number
        // This will be added back on once the open edition is "finalized"
        if (maxSupply == type(uint64).max) {
            maxSupply = 0;
        }

        return
            NFTMetadataRenderer.createMetadataEdition({
                name: IERC721MetadataUpgradeable(target).name(),
                description: info.description,
                imageURI: info.imageURI,
                animationURI: info.animationURI,
                tokenOfEdition: tokenId,
                editionSize: maxSupply
            });
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;

interface IMetadataRenderer {
    function tokenURI(uint256) external view returns (string memory);
    function contractURI() external view returns (string memory);
    function initializeWithData(bytes memory initData) external;
    function updateMetadataBaseWithDetails(
        address target,
        string memory metadataBase,
        string memory metadataExtension,
        string memory newContractURI,
        uint256 freezeAt
    ) external;
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;

import {IMetadataRenderer} from "../interfaces/IMetadataRenderer.sol";

/// @notice Interface for Freee Drops contract
interface IERC721Drop {
    // Enums

    /// @notice Phase type
    enum PhaseType {
        Public,
        Presale,
        Airdrop,
        AdminMint
    }

    // Access errors

    /// @notice Only admin can access this function
    error Access_OnlyAdmin();
    /// @notice Missing the given role or admin access
    error Access_MissingRoleOrAdmin(bytes32 role);
    /// @notice Withdraw is not allowed by this user
    error Access_WithdrawNotAllowed();
    /// @notice Cannot withdraw funds due to ETH send failure.
    error Withdraw_FundsSendFailure();
    /// @notice Mint fee send failure
    error MintFee_FundsSendFailure();
    /// @notice Protocol Rewards withdraw failure
    error ProtocolRewards_WithdrawSendFailure();

    /// @notice Call to external metadata renderer failed.
    error ExternalMetadataRenderer_CallFailed();

    /// @notice Thrown when the operator for the contract is not allowed
    /// @dev Used when strict enforcement of marketplaces for creator royalties is desired.
    error OperatorNotAllowed(address operator);

    /// @notice Thrown when there is no active market filter DAO address supported for the current chain
    /// @dev Used for enabling and disabling filter for the given chain.
    error MarketFilterDAOAddressNotSupportedForChain();

    /// @notice Used when the operator filter registry external call fails
    /// @dev Used for bubbling error up to clients.
    error RemoteOperatorFilterRegistryCallFailed();

    /// @notice Used when attempt to transfer soulbound token
    error Transfer_NotAllowed();

    // Sale/Purchase errors
    /// @notice Sale is inactive
    error Sale_Inactive();
    /// @notice Presale is inactive
    error Presale_Inactive();
    /// @notice Presale merkle root is invalid
    error Presale_MerkleNotApproved();
    /// @notice Wrong price for purchase
    error Purchase_WrongPrice(uint256 correctPrice);
    /// @notice NFT sold out
    error Mint_SoldOut();
    /// @notice Too many purchase for address
    error Purchase_TooManyForAddress();
    /// @notice Too many presale for address
    error Presale_TooManyForAddress();

    // Admin errors
    /// @notice Royalty percentage too high
    error Setup_RoyaltyPercentageTooHigh(uint16 maxRoyaltyBPS);
    /// @notice Invalid admin upgrade address
    error Admin_InvalidUpgradeAddress(address proposedAddress);
    /// @notice invalid collection size when update
    error Admin_InvalidCollectionSize();    
    /// @notice Unable to finalize an edition not marked as open (size set to uint64_max_value)
    error Admin_UnableToFinalizeNotOpenEdition();
    /// @notice Cannot reserve every mint for admin
    error InvalidMintSchedule();

    /// @notice Event emitted for mint fee payout
    /// @param mintFeeAmount amount of the mint fee
    /// @param mintFeeRecipient recipient of the mint fee
    /// @param success if the payout succeeded
    event MintFeePayout(uint256 mintFeeAmount, address mintFeeRecipient, bool success);

    /// @notice Event emitted for each sale
    /// @param phase phase of the sale
    /// @param to address sale was made to
    /// @param quantity quantity of the minted nfts
    /// @param pricePerToken price for each token
    /// @param firstPurchasedTokenId first purchased token ID (to get range add to quantity for max)
    event Sale(PhaseType phase, address indexed to, uint256 indexed quantity, uint256 indexed pricePerToken, uint256 firstPurchasedTokenId);

    /// @notice Event emitted for each sale
    /// @param sender address sale was made to
    /// @param tokenContract address of the token contract
    /// @param tokenId first purchased token ID (to get range add to quantity for max)
    /// @param quantity quantity of the minted nfts
    /// @param comment caller provided comment
    event MintComment(address indexed sender, address indexed tokenContract, uint256 indexed tokenId, uint256 quantity, string comment);

    /// @notice Sales configuration has been changed
    /// @dev To access new sales configuration, use getter function.
    /// @param changedBy Changed by user
    event SalesConfigChanged(address indexed changedBy);

    /// @notice Edition size reduced
    /// @param changedBy changed by user
    /// @param newSize new collection size
    event CollectionSizeReduced(address indexed changedBy, uint64 newSize);

    /// @notice Event emitted when the funds recipient is changed
    /// @param newAddress new address for the funds recipient
    /// @param changedBy address that the recipient is changed by
    event FundsRecipientChanged(address indexed newAddress, address indexed changedBy);

    /// @notice Event emitted when the funds are withdrawn from the minting contract
    /// @param withdrawnBy address that issued the withdraw
    /// @param withdrawnTo address that the funds were withdrawn to
    /// @param amount amount that was withdrawn
    /// @param feeRecipient user getting withdraw fee (if any)
    /// @param feeAmount amount of the fee getting sent (if any)
    event FundsWithdrawn(address indexed withdrawnBy, address indexed withdrawnTo, uint256 amount, address feeRecipient, uint256 feeAmount);

    /// @notice Event emitted when an open mint is finalized and further minting is closed forever on the contract.
    /// @param sender address sending close mint
    /// @param numberOfMints number of mints the contract is finalized at
    event OpenMintFinalized(address indexed sender, uint256 numberOfMints);

    /// @notice Event emitted when the soulbound status is changed
    /// @param isSoulbound new soulbound status
    /// @param changedBy address that the soulbound status is changed by
    event SoulboundStatusChanged(bool isSoulbound, address changedBy);

    /// @notice Event emitted when metadata renderer is updated.
    /// @param sender address of the updater
    /// @param renderer new metadata renderer address
    event UpdatedMetadataRenderer(address sender, IMetadataRenderer renderer);

    /// @notice Admin function to update the sales configuration settings
    /// @param publicSalePrice public sale price in ether
    /// @param maxSalePurchasePerAddress Max # of purchases (public) per address allowed
    /// @param publicSaleStart unix timestamp when the public sale starts
    /// @param publicSaleEnd unix timestamp when the public sale ends (set to 0 to disable)
    /// @param presaleStart unix timestamp when the presale starts
    /// @param presaleEnd unix timestamp when the presale ends
    /// @param presaleMerkleRoot merkle root for the presale information
    function setSaleConfiguration(
        uint104 publicSalePrice,
        uint32 maxSalePurchasePerAddress,
        uint64 publicSaleStart,
        uint64 publicSaleEnd,
        uint64 presaleStart,
        uint64 presaleEnd,
        bytes32 presaleMerkleRoot
    ) external;

    /// @notice General configuration for NFT Minting and bookkeeping
    struct Configuration {
        /// @dev Metadata renderer (uint160)
        IMetadataRenderer metadataRenderer;
        /// @dev Total size of edition that can be minted (uint160+64 = 224)
        uint64 editionSize;
        /// @dev Royalty amount in bps (uint224+16 = 240)
        uint16 royaltyBPS;
        /// @dev Funds recipient for sale (new slot, uint160)
        address payable fundsRecipient;
        /// @dev soulboundNFT
        bool isSoulbound;
    }

    /// @notice Sales states and configuration
    /// @dev Uses 3 storage slots
    struct SalesConfiguration {
        /// @dev Public sale price (max ether value > 1000 ether with this value)
        uint104 publicSalePrice;
        /// @notice Purchase mint limit per address (if set to 0 === unlimited mints)
        /// @dev Max purchase number per txn (90+32 = 122)
        uint32 maxSalePurchasePerAddress;
        /// @dev uint64 type allows for dates into 292 billion years
        /// @notice Public sale start timestamp (136+64 = 186)
        uint64 publicSaleStart;
        /// @notice Public sale end timestamp (186+64 = 250)
        uint64 publicSaleEnd;
        /// @notice Presale start timestamp
        /// @dev new storage slot
        uint64 presaleStart;
        /// @notice Presale end timestamp
        uint64 presaleEnd;
        /// @notice Presale merkle root
        bytes32 presaleMerkleRoot;
    }

    /// @notice Return value for sales details to use with front-ends
    struct SaleDetails {
        // Synthesized status variables for sale and presale
        bool publicSaleActive;
        bool presaleActive;
        // Price for public sale
        uint256 publicSalePrice;
        // Timed sale actions for public sale
        uint64 publicSaleStart;
        uint64 publicSaleEnd;
        // Timed sale actions for presale
        uint64 presaleStart;
        uint64 presaleEnd;
        // Merkle root (includes address, quantity, and price data for each entry)
        bytes32 presaleMerkleRoot;
        // Limit public sale to a specific number of mints per wallet
        uint256 maxSalePurchasePerAddress;
        // Information about the rest of the supply
        // Total that have been minted
        uint256 totalMinted;
        // The total supply available
        uint256 maxSupply;
    }

    /// @notice Return type of specific mint counts and details per address
    struct AddressMintDetails {
        /// Number of total mints from the given address
        uint256 totalMints;
        /// Number of presale mints from the given address
        uint256 presaleMints;
        /// Number of public mints from the given address
        uint256 publicMints;
    }

    /// @notice External purchase function (payable in eth)
    /// @param quantity to purchase
    /// @return first minted token ID
    function purchase(uint256 quantity) external payable returns (uint256);

    /// @notice External purchase presale function (takes a merkle proof and matches to root) (payable in eth)
    /// @param quantity to purchase
    /// @param maxQuantity can purchase (verified by merkle root)
    /// @param pricePerToken price per token allowed (verified by merkle root)
    /// @param merkleProof input for merkle proof leaf verified by merkle root
    /// @return first minted token ID
    function purchasePresale(uint256 quantity, uint256 maxQuantity, uint256 pricePerToken, bytes32[] memory merkleProof) external payable returns (uint256);

    /// @notice Function to return the global sales details for the given drop
    function saleDetails() external view returns (SaleDetails memory);

    /// @notice Function to return the specific sales details for a given address
    /// @param minter address for minter to return mint information for
    function mintedPerAddress(address minter) external view returns (AddressMintDetails memory);

    /// @notice This is the opensea/public owner setting that can be set by the contract admin
    function owner() external view returns (address);

    /// @notice Update the metadata renderer
    /// @param newRenderer new address for renderer
    /// @param setupRenderer data to call to bootstrap data for the new renderer (optional)
    function setMetadataRenderer(IMetadataRenderer newRenderer, bytes memory setupRenderer) external;

    /// @notice This is an admin mint function to mint a quantity to a specific address
    /// @param to address to mint to
    /// @param quantity quantity to mint
    /// @return the id of the first minted NFT
    function adminMint(address to, uint256 quantity) external returns (uint256);

    /// @notice This is an admin mint function to mint a single nft each to a list of addresses
    /// @param to list of addresses to mint an NFT each to
    /// @return the id of the first minted NFT
    function adminMintAirdrop(address[] memory to) external returns (uint256);

    /// @dev Getter for admin role associated with the contract to handle metadata
    /// @return boolean if address is admin
    function isAdmin(address user) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (interfaces/IERC721Metadata.sol)

pragma solidity ^0.8.0;

import "../token/ERC721/extensions/IERC721MetadataUpgradeable.sol";

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC2981.sol)

pragma solidity ^0.8.0;

import "../utils/introspection/IERC165Upgradeable.sol";

/**
 * @dev Interface for the NFT Royalty Standard.
 *
 * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal
 * support for royalty payments across all NFT marketplaces and ecosystem participants.
 *
 * _Available since v4.5._
 */
interface IERC2981Upgradeable is IERC165Upgradeable {
    /**
     * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of
     * exchange. The royalty amount is denominated and should be paid in that same unit of exchange.
     */
    function royaltyInfo(
        uint256 tokenId,
        uint256 salePrice
    ) external view returns (address receiver, uint256 royaltyAmount);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;

import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
import {Base64} from "@openzeppelin/contracts/utils/Base64.sol";

/// NFT metadata library for rendering metadata associated with editions
library NFTMetadataRenderer {
    /// Generate edition metadata from storage information as base64-json blob
    /// Combines the media data and metadata
    /// @param name Name of NFT in metadata
    /// @param description Description of NFT in metadata
    /// @param imageURI URI of image to render for edition
    /// @param animationURI URI of animation to render for edition
    /// @param tokenOfEdition Token ID for specific token
    /// @param editionSize Size of entire edition to show
    function createMetadataEdition(
        string memory name,
        string memory description,
        string memory imageURI,
        string memory animationURI,
        uint256 tokenOfEdition,
        uint256 editionSize
    ) internal pure returns (string memory) {
        string memory _tokenMediaData = tokenMediaData(
            imageURI,
            animationURI
        );
        bytes memory json = createMetadataJSON(
            name,
            description,
            _tokenMediaData,
            tokenOfEdition,
            editionSize
        );
        return encodeMetadataJSON(json);
    }

    function encodeContractURIJSON(
        string memory name,
        string memory description,
        string memory imageURI,
        string memory animationURI,
        uint256 royaltyBPS,
        address royaltyRecipient
    ) internal pure returns (string memory) {
        bytes memory imageSpace = bytes("");
        if (bytes(imageURI).length > 0) {
            imageSpace = abi.encodePacked('", "image": "', imageURI);
        }
        bytes memory animationSpace = bytes("");
        if (bytes(animationURI).length > 0) {
            animationSpace = abi.encodePacked('", "animation_url": "', animationURI);
        }

        return
            string(
                encodeMetadataJSON(
                    abi.encodePacked(
                        '{"name": "',
                        name,
                        '", "description": "',
                        description,
                        // this is for opensea since they don't respect ERC2981 right now
                        '", "seller_fee_basis_points": ',
                        Strings.toString(royaltyBPS),
                        ', "fee_recipient": "',
                        Strings.toHexString(uint256(uint160(royaltyRecipient)), 20),
                        imageSpace,
                        animationSpace,
                        '"}'
                    )
                )
            );
    }

    /// Function to create the metadata json string for the nft edition
    /// @param name Name of NFT in metadata
    /// @param description Description of NFT in metadata
    /// @param mediaData Data for media to include in json object
    /// @param tokenOfEdition Token ID for specific token
    /// @param editionSize Size of entire edition to show
    function createMetadataJSON(
        string memory name,
        string memory description,
        string memory mediaData,
        uint256 tokenOfEdition,
        uint256 editionSize
    ) internal pure returns (bytes memory) {
        bytes memory editionSizeText;
        if (editionSize > 0) {
            editionSizeText = abi.encodePacked(
                "#",
                Strings.toString(tokenOfEdition)
            );
        }
        return
            abi.encodePacked(
                '{"name": "',
                name,
                " ",
                editionSizeText,
                '", "',
                'description": "',
                description,
                '", "',
                mediaData,
                'properties": {"number": ',
                Strings.toString(tokenOfEdition),
                ', "name": "',
                name,
                '"}}'
            );
    }

    /// Encodes the argument json bytes into base64-data uri format
    /// @param json Raw json to base64 and turn into a data-uri
    function encodeMetadataJSON(bytes memory json)
        internal
        pure
        returns (string memory)
    {
        return
            string(
                abi.encodePacked(
                    "data:application/json;base64,",
                    Base64.encode(json)
                )
            );
    }

    /// Generates edition metadata from storage information as base64-json blob
    /// Combines the media data and metadata
    /// @param imageUrl URL of image to render for edition
    /// @param animationUrl URL of animation to render for edition
    function tokenMediaData(
        string memory imageUrl,
        string memory animationUrl
    ) internal pure returns (string memory) {
        bool hasImage = bytes(imageUrl).length > 0;
        bool hasAnimation = bytes(animationUrl).length > 0;
        if (hasImage && hasAnimation) {
            return
                string(
                    abi.encodePacked(
                        'image": "',
                        imageUrl,
                        '", "animation_url": "',
                        animationUrl,
                        '", "'
                    )
                );
        }
        if (hasImage) {
            return string(abi.encodePacked('image": "', imageUrl, '", "'));
        }
        if (hasAnimation) {
            return
                string(
                    abi.encodePacked('animation_url": "', animationUrl, '", "')
                );
        }

        return "";
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;

import {IERC721Drop} from "../interfaces/IERC721Drop.sol";

contract MetadataRenderAdminCheck {
    error Access_OnlyAdmin();

    /// @notice Modifier to require the sender to be an admin
    /// @param target address that the user wants to modify
    modifier requireSenderAdmin(address target) {
        if (target != msg.sender && !IERC721Drop(target).isAdmin(msg.sender)) {
            revert Access_OnlyAdmin();
        }

        _;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;

import "../IERC721Upgradeable.sol";

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721MetadataUpgradeable is IERC721Upgradeable {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
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);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

import "./math/Math.sol";
import "./math/SignedMath.sol";

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toString(int256 value) internal pure returns (string memory) {
        return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.7.0) (utils/Base64.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides a set of functions to operate with Base64 strings.
 *
 * _Available since v4.5._
 */
library Base64 {
    /**
     * @dev Base64 Encoding/Decoding Table
     */
    string internal constant _TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

    /**
     * @dev Converts a `bytes` to its Bytes64 `string` representation.
     */
    function encode(bytes memory data) internal pure returns (string memory) {
        /**
         * Inspired by Brecht Devos (Brechtpd) implementation - MIT licence
         * https://github.com/Brechtpd/base64/blob/e78d9fd951e7b0977ddca77d92dc85183770daf4/base64.sol
         */
        if (data.length == 0) return "";

        // Loads the table into memory
        string memory table = _TABLE;

        // Encoding takes 3 bytes chunks of binary data from `bytes` data parameter
        // and split into 4 numbers of 6 bits.
        // The final Base64 length should be `bytes` data length multiplied by 4/3 rounded up
        // - `data.length + 2`  -> Round up
        // - `/ 3`              -> Number of 3-bytes chunks
        // - `4 *`              -> 4 characters for each chunk
        string memory result = new string(4 * ((data.length + 2) / 3));

        /// @solidity memory-safe-assembly
        assembly {
            // Prepare the lookup table (skip the first "length" byte)
            let tablePtr := add(table, 1)

            // Prepare result pointer, jump over length
            let resultPtr := add(result, 32)

            // Run over the input, 3 bytes at a time
            for {
                let dataPtr := data
                let endPtr := add(data, mload(data))
            } lt(dataPtr, endPtr) {

            } {
                // Advance 3 bytes
                dataPtr := add(dataPtr, 3)
                let input := mload(dataPtr)

                // To write each character, shift the 3 bytes (18 bits) chunk
                // 4 times in blocks of 6 bits for each character (18, 12, 6, 0)
                // and apply logical AND with 0x3F which is the number of
                // the previous character in the ASCII table prior to the Base64 Table
                // The result is then added to the table to get the character to write,
                // and finally write it in the result pointer but with a left shift
                // of 256 (1 byte) - 8 (1 ASCII char) = 248 bits

                mstore8(resultPtr, mload(add(tablePtr, and(shr(18, input), 0x3F))))
                resultPtr := add(resultPtr, 1) // Advance

                mstore8(resultPtr, mload(add(tablePtr, and(shr(12, input), 0x3F))))
                resultPtr := add(resultPtr, 1) // Advance

                mstore8(resultPtr, mload(add(tablePtr, and(shr(6, input), 0x3F))))
                resultPtr := add(resultPtr, 1) // Advance

                mstore8(resultPtr, mload(add(tablePtr, and(input, 0x3F))))
                resultPtr := add(resultPtr, 1) // Advance
            }

            // When data `bytes` is not exactly 3 bytes long
            // it is padded with `=` characters at the end
            switch mod(mload(data), 3)
            case 1 {
                mstore8(sub(resultPtr, 1), 0x3d)
                mstore8(sub(resultPtr, 2), 0x3d)
            }
            case 2 {
                mstore8(sub(resultPtr, 1), 0x3d)
            }
        }

        return result;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165Upgradeable.sol";

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
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);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1, "Math: mulDiv overflow");

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two signed numbers.
     */
    function min(int256 a, int256 b) internal pure returns (int256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

{
  "remappings": [
    "@openzeppelin/contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/",
    "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    "erc721a-upgradeable/=lib/ERC721A-Upgradeable/contracts/",
    "forge-std/=lib/forge-std/src/",
    "ERC721A-Upgradeable/=lib/ERC721A-Upgradeable/contracts/",
    "ds-test/=lib/forge-std/lib/ds-test/src/",
    "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    "openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/",
    "openzeppelin/=lib/openzeppelin-contracts/contracts/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "cancun",
  "viaIR": true,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"name":"Access_OnlyAdmin","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"target","type":"address"},{"indexed":false,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"string","name":"newDescription","type":"string"}],"name":"DescriptionUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"target","type":"address"},{"indexed":false,"internalType":"string","name":"description","type":"string"},{"indexed":false,"internalType":"string","name":"imageURI","type":"string"},{"indexed":false,"internalType":"string","name":"animationURI","type":"string"}],"name":"EditionInitialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"target","type":"address"},{"indexed":false,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"string","name":"imageURI","type":"string"},{"indexed":false,"internalType":"string","name":"animationURI","type":"string"}],"name":"MediaURIsUpdated","type":"event"},{"inputs":[],"name":"contractURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"data","type":"bytes"}],"name":"initializeWithData","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"tokenInfos","outputs":[{"internalType":"string","name":"description","type":"string"},{"internalType":"string","name":"imageURI","type":"string"},{"internalType":"string","name":"animationURI","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"target","type":"address"},{"internalType":"string","name":"newDescription","type":"string"}],"name":"updateDescription","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"target","type":"address"},{"internalType":"string","name":"imageURI","type":"string"},{"internalType":"string","name":"animationURI","type":"string"}],"name":"updateMediaURIs","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"target","type":"address"},{"internalType":"string","name":"metadataBase","type":"string"},{"internalType":"string","name":"metadataExtension","type":"string"},{"internalType":"string","name":"newContractURI","type":"string"},{"internalType":"uint256","name":"freezeAt","type":"uint256"}],"name":"updateMetadataBaseWithDetails","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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