creation_sourcecode: {{
    "language": "Solidity",
    "sources": {
      "@nftculture/nftc-contracts-private/contracts/access/v2/OwnableDeferral.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n/**\n * @title OwnableDeferral\n * @author @NiftyMike | @NFTCulture\n * @dev Implements checks for contract admin operations. Will be Backed by\n * OZ Ownable.\n *\n * This contract is helpful when a contract tree gets complicated,\n * and multiple contracts need to leverage Ownable.\n *\n * Sample Implementation:\n *\n * modifier isOwner() override(...) {\n *     _isOwner();\n *     _;\n * }\n *\n * function _isOwner() internal view override(...) {\n *     _checkOwner();\n * }\n */\nabstract contract OwnableDeferral {\n    modifier isOwner() virtual;\n\n    function _isOwner() internal view virtual;\n}\n"
      },
      "@nftculture/nftc-contracts-private/contracts/access/v2/OwnableDeferralResolution.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n// OZ Libraries\nimport '@openzeppelin/contracts/access/Ownable.sol';\n\n// Local References\nimport './OwnableDeferral.sol';\n\n// Error Codes\nerror CallerIsNotOwner();\n\n/**\n * @title OwnableDeferralResolution\n * @author @NiftyMike | @NFTCulture\n * @dev Implements checks for contract admin (Owner) operations. Backed by OZ Ownable.\n *\n * Ownership is assigned to contract deployer wallet by default.\n *\n * NOTE: IMPORTANT - This resolution will work great in a simple inheritance situation,\n * however, if multiple inheritance is involved, it might not adequately satisfy\n * override (...) conditions. In those scenarios, this code should be used as a\n * starting point and then adjusted appropriately.\n */\ncontract OwnableDeferralResolution is Ownable, OwnableDeferral {\n    modifier isOwner() virtual override {\n        _isOwner();\n        _;\n    }\n\n    function _isOwner() internal view virtual override {\n        // Same as _checkOwner() but using error code instead of a require statement.\n        if (owner() != _msgSender()) revert CallerIsNotOwner();\n    }\n}\n"
      },
      "@nftculture/nftc-contracts-private/contracts/metadata/v2/interfaces/AbstractMetadataConsumer.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n// Local References\nimport './IChainNativeMetadataConsumer.sol';\nimport './IChainNativeMetadataProducer.sol';\n\n/**\n * @title AbstractMetadataConsumer\n * @author @NiftyMike | @NFTCulture\n * @dev Abstract contract that defines what a MetadataConsumer should do.\n */\nabstract contract AbstractMetadataConsumer is IChainNativeMetadataConsumer {\n    function _getMetadataProducer(\n        address collection,\n        uint256 selectionCriteria\n    ) internal view virtual returns (IChainNativeMetadataProducer);\n}\n"
      },
      "@nftculture/nftc-contracts-private/contracts/metadata/v2/interfaces/IChainNativeMetadataConsumer.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n/**\n * @title IChainNativeMetadataConsumer\n * @author @NiftyMike | @NFTCulture\n * @dev Super thin interface definition for a contract that\n * consumes art from an IChainNativeMetadataProducer\n */\ninterface IChainNativeMetadataConsumer {\n    /**\n     * Given a collection address, provide a metadata producer.\n     *\n     * @param collection collection we are requesting a producer for.\n     * @param selectionCriteria data pertinent to selection of the producer.\n     *\n     * NOTE: It is important to realize that selectionCriteria is generic and does not imply a tokenType or\n     * tokenId or anything else, it depends on the circumstance of the implementation.\n     */\n    function getMetadataProducer(address collection, uint256 selectionCriteria) external view returns (address);\n}\n"
      },
      "@nftculture/nftc-contracts-private/contracts/metadata/v2/interfaces/IChainNativeMetadataProducer.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n/**\n * @title IChainNativeMetadataProducer\n * @author @NiftyMike | @NFTCulture\n * @dev Super thin interface definition for a contract that\n * produces metadata in a chain native way.\n */\ninterface IChainNativeMetadataProducer {\n    /**\n     *\n     * @param collection - the collection details that we are providing info for.\n     * @param tokenId - the tokenId that we should provide a tokenType for.\n     */\n    function getTokenTypeForToken(address collection, uint256 tokenId) external view returns (uint64);\n\n    /**\n     * Provide a human-readable version of the metadata JSON.\n     *\n     * @param collection - the collection details that we are providing info for.\n     * @param tokenType - the type of the token we should provide metadata for\n     * @param tokenId - the specific tokenId\n     * @param extraData - extra info that might be used to effect the metadata\n     */\n    function getJsonAsString(\n        address collection,\n        uint64 tokenType,\n        uint256 tokenId,\n        uint256 extraData\n    ) external view returns (string memory);\n\n    /**\n     * Provide base64 encoded metadata JSON that can be consumed by an external service.\n     *\n     * @param collection - the collection details that we are providing info for.\n     * @param tokenType - the type of the token we should provide metadata for\n     * @param tokenId - the specific tokenIds\n     * @param extraData - extra info that might be used to effect the metadata\n     */\n    function getJsonAsEncodedString(\n        address collection,\n        uint64 tokenType,\n        uint256 tokenId,\n        uint256 extraData\n    ) external view returns (string memory);\n}\n"
      },
      "@nftculture/nftc-contracts-private/contracts/metadata/v2/metadata-consumers/SingletonMetadataConsumer.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n// Local References\nimport '../../../access/v2/OwnableDeferral.sol';\nimport '../interfaces/AbstractMetadataConsumer.sol';\n\n/**\n * @title SingletonMetadataConsumer\n * @author @NiftyMike | @NFTCulture\n * @dev Contract intended to be used to consume from a single on-chain source for NFT metadata.\n */\nabstract contract SingletonMetadataConsumer is AbstractMetadataConsumer, OwnableDeferral {\n    // External contract that manages the collection's metadata in a chain-native way.\n    address private _metadataProducer;\n\n    constructor(address __metadataProducer) {\n        _setMetadataProducer(__metadataProducer);\n    }\n\n    /**\n     * @notice Set the on-chain metadata producer contract.\n     * Can only be called if caller is owner.\n     *\n     * @param __metadataProducer address of the producer contract.\n     */\n    function setMetadataProducer(address __metadataProducer) external isOwner {\n        _setMetadataProducer(__metadataProducer);\n    }\n\n    function _setMetadataProducer(address __metadataProducer) internal {\n        if (__metadataProducer != address(0)) {\n            _metadataProducer = __metadataProducer;\n        }\n    }\n\n    function getMetadataProducer(address, uint256) external view override returns (address) {\n        return _metadataProducer;\n    }\n\n    function _getMetadataProducer(address, uint256) internal view override returns (IChainNativeMetadataProducer) {\n        return IChainNativeMetadataProducer(_metadataProducer);\n    }\n}\n"
      },
      "@nftculture/nftc-contracts-private/contracts/token-phasing/v2/basic/BasicPhasedMintBase.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n// NFTC Open Source Contracts See: https://github.com/NFTCulture/nftc-contracts\nimport {BooleanPacking} from '@nftculture/nftc-contracts/contracts/utility/BooleanPacking.sol';\n\n// NFTC Prerelease Contracts\nimport '../../../access/v2/OwnableDeferral.sol';\nimport '../IMintablePublic.sol';\n\n/**\n * @title BasicPhasedMintBase\n * @author @NiftyMike | @NFTCulture\n * @dev\n * PhasedMint: An approach to a standard system of controlling mint phases.\n * The 'Basic' flavor only provides on/off controls for each phase, no pricing info or anything else.\n */\nabstract contract BasicPhasedMintBase is IMintablePublic, OwnableDeferral {\n    using BooleanPacking for uint256;\n\n    // BooleanPacking used on _mintControlFlags\n    uint256 internal _mintControlFlags;\n\n    uint256 private immutable PUBLIC_MINT_PHASE;\n\n    modifier isPublicMinting() {\n        require(_mintControlFlags.getBoolean(PUBLIC_MINT_PHASE), 'Minting stopped');\n        _;\n    }\n\n    constructor(uint256 publicMintPhase) {\n        PUBLIC_MINT_PHASE = publicMintPhase;\n    }\n\n    function _calculateMintingState(bool __publicMintingActive) internal view returns (uint256) {\n        uint256 tempControlFlags;\n\n        tempControlFlags = tempControlFlags.setBoolean(PUBLIC_MINT_PHASE, __publicMintingActive);\n\n        // This does not set state, because state is held by the child classes.\n        return tempControlFlags;\n    }\n\n    function isPublicMintingActive() external view virtual returns (bool) {\n        return _isPublicMintingActive();\n    }\n\n    function _isPublicMintingActive() internal view returns (bool) {\n        return _mintControlFlags.getBoolean(PUBLIC_MINT_PHASE);\n    }\n\n    function supportedPhases() external view returns (uint256) {\n        return PUBLIC_MINT_PHASE;\n    }\n}\n"
      },
      "@nftculture/nftc-contracts-private/contracts/token-phasing/v2/basic/BasicPhasedMintThree.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n// OZ Libraries\nimport '@openzeppelin/contracts/access/Ownable.sol';\n\n// Local References\nimport './BasicPhasedMintBase.sol';\nimport '../IMintablePhaseOne.sol';\nimport '../IMintablePhaseTwo.sol';\n\n/**\n * @title BasicPhasedMintThree\n * @author @NiftyMike | @NFTCulture\n * @dev\n * PhasedMint: An approach to a standard system of controlling mint phases.\n * The 'Basic' flavor only provides on/off controls for each phase, no pricing info or anything else.\n *\n * This is the \"Three\" phase mint flavor of the PhasedMint approach.\n *\n * Note: Since the last phase is always assumed to be the public mint phase, we only\n * need to define the first and second phases here.\n */\nabstract contract BasicPhasedMintThree is BasicPhasedMintBase, IMintablePhaseOne, IMintablePhaseTwo {\n    using BooleanPacking for uint256;\n\n    uint256 private constant PHASE_ONE = 1;\n    uint256 private constant PHASE_TWO = 2;\n\n    modifier isPhaseOne() {\n        require(_mintControlFlags.getBoolean(PHASE_ONE), 'Phase one stopped');\n        _;\n    }\n\n    modifier isPhaseTwo() {\n        require(_mintControlFlags.getBoolean(PHASE_TWO), 'Phase two stopped');\n        _;\n    }\n\n    constructor() BasicPhasedMintBase(3) {}\n\n    function setMintingState(\n        bool __phaseOneActive,\n        bool __phaseTwoActive,\n        bool __publicMintingActive\n    ) external virtual isOwner {\n        uint256 tempControlFlags = _calculateMintingState(__publicMintingActive);\n\n        tempControlFlags = tempControlFlags.setBoolean(PHASE_ONE, __phaseOneActive);\n\n        tempControlFlags = tempControlFlags.setBoolean(PHASE_TWO, __phaseTwoActive);\n\n        _mintControlFlags = tempControlFlags;\n    }\n\n    function isPhaseOneActive() external view virtual returns (bool) {\n        return _isPhaseOneActive();\n    }\n\n    function _isPhaseOneActive() internal view returns (bool) {\n        return _mintControlFlags.getBoolean(PHASE_ONE);\n    }\n\n    function isPhaseTwoActive() external view virtual returns (bool) {\n        return _isPhaseTwoActive();\n    }\n\n    function _isPhaseTwoActive() internal view returns (bool) {\n        return _mintControlFlags.getBoolean(PHASE_TWO);\n    }\n}\n"
      },
      "@nftculture/nftc-contracts-private/contracts/token-phasing/v2/IMintablePhaseOne.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n/**\n * @title IMintablePhaseOne\n * @author @NFTCulture\n * @dev Interface to define standardized functionality that should be exposed\n * on NFTC Mint contracts, so that Front End widgets can rely on a standard set\n * capabilities.\n *\n * Supported Contract Specs:\n *  - ERC721A Static\n *  - ERC721A Expandable\n *  - ERC1155\n */\ninterface IMintablePhaseOne {\n    /*°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°\\\n    |                   API - Phase One Functions                 |\n    \\____________________________________________________________*/\n\n    function isPhaseOneActive() external view returns (bool);\n\n    function phaseOneBatchSize() external view returns (uint256);\n}\n"
      },
      "@nftculture/nftc-contracts-private/contracts/token-phasing/v2/IMintablePhaseTwo.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n/**\n * @title IMintablePhaseTwo\n * @author @NFTCulture\n * @dev Interface to define standardized functionality that should be exposed\n * on NFTC Mint contracts, so that Front End widgets can rely on a standard set\n * capabilities.\n *\n * Supported Contract Specs:\n *  - ERC721A Static\n *  - ERC721A Expandable\n *  - ERC1155\n */\ninterface IMintablePhaseTwo {\n    /*°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°\\\n    |                   API - Phase Two Functions                 |\n    \\____________________________________________________________*/\n\n    function isPhaseTwoActive() external view returns (bool);\n\n    function phaseTwoBatchSize() external view returns (uint256);\n}\n"
      },
      "@nftculture/nftc-contracts-private/contracts/token-phasing/v2/IMintablePublic.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n/**\n * @title IMintablePublic\n * @author @NFTCulture\n * @dev Interface to define standardized functionality that should be exposed\n * on NFTC Mint contracts, so that Front End widgets can rely on a standard set\n * capabilities.\n *\n * Supported Contract Specs:\n *  - ERC721A Static\n *  - ERC721A Expandable\n *  - ERC1155\n */\ninterface IMintablePublic {\n    /*°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°\\\n    |                   API - Public Mint Functions               |\n    \\____________________________________________________________*/\n\n    function isPublicMintingActive() external returns (bool);\n\n    function publicMintBatchSize() external returns (uint256);\n}\n"
      },
      "@nftculture/nftc-contracts-private/contracts/token-phasing/v2/static-extensions/StaticPhasedMintBase.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n/**\n * @title StaticPhasedMintBase\n * @author @NiftyMike | @NFTCulture\n * @dev The base static phased mint implementation.\n *\n * PhasedMint: An approach to a standard system of controlling mint phases.\n * Static: An approach to ERC721 contracts that allows only a single type of tokens.\n *\n * This implementation also contains code to hold on to the pricing info, since it is global for all NFTs.\n */\nabstract contract StaticPhasedMintBase {\n    uint256 public publicMintPricePerNft;\n\n    constructor(uint256 __publicMintPricePerNft) {\n        publicMintPricePerNft = __publicMintPricePerNft;\n    }\n\n    function getPublicMintPricePerNft() external view virtual returns (uint256) {\n        return publicMintPricePerNft;\n    }\n}\n"
      },
      "@nftculture/nftc-contracts-private/contracts/token-phasing/v2/static-extensions/StaticPhasedMintThree.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n// Local References\nimport '../basic/BasicPhasedMintThree.sol';\nimport './StaticPhasedMintBase.sol';\n\n/**\n * @title StaticPhasedMintThree\n * @author @NiftyMike | @NFTCulture\n * @dev Static, PhasedMint, Implementation for Three phases.\n *\n * PhasedMint: An approach to a standard system of controlling mint phases.\n * Static: An approach to ERC721 contracts that allows only a single type of tokens.\n *\n * This is the \"Three\" phase mint flavor of the PhasedMint approach.\n *\n * Note: Since the last phase is always assumed to be the public mint phase, we only\n * need to define the first and second phases here.\n *\n * This implementation also contains code to hold on to the pricing info, since it is global for all NFTs.\n */\nabstract contract StaticPhasedMintThree is BasicPhasedMintThree, StaticPhasedMintBase {\n    uint256 public phaseOnePricePerNft;\n    uint256 public phaseTwoPricePerNft;\n\n    constructor(\n        uint256 __phaseOnePricePerNft,\n        uint256 __phaseTwoPricePerNft,\n        uint256 __publicMintPricePerNft\n    ) StaticPhasedMintBase(__publicMintPricePerNft) {\n        phaseOnePricePerNft = __phaseOnePricePerNft;\n        phaseTwoPricePerNft = __phaseTwoPricePerNft;\n    }\n\n    function setMintingPrice(\n        uint256 __phaseOnePricePerNft,\n        uint256 __phaseTwoPricePerNft,\n        uint256 __publicMintPricePerNft\n    ) external virtual isOwner {\n        phaseOnePricePerNft = __phaseOnePricePerNft;\n        phaseTwoPricePerNft = __phaseTwoPricePerNft;\n        publicMintPricePerNft = __publicMintPricePerNft;\n    }\n\n    function getPhaseOnePricePerNft() external view virtual returns (uint256) {\n        return phaseOnePricePerNft;\n    }\n\n    function getPhaseTwoPricePerNft() external view virtual returns (uint256) {\n        return phaseTwoPricePerNft;\n    }\n}\n"
      },
      "@nftculture/nftc-contracts-private/contracts/token/v4/ERC1155_NFTC.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n// ClosedSea by Vectorized\nimport 'closedsea/src/OperatorFilterer.sol';\n\n// OZ Libraries\nimport '@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol';\nimport '@openzeppelin/contracts/access/Ownable.sol';\n\n// NFTC Prerelease Contracts\nimport '../../access/v2/OwnableDeferral.sol';\n\n/**\n * @title  ERC1155_NFTC\n * @author @NFTCulture\n * @dev OZ ERC1155 plus NFTC-preferred extensions and add-ons.\n *  - Burnable\n *  - Ownable\n *  - OperatorFilterer\n *\n * Using implementation and approach created by Vectorized for OperatorFilterer.\n * See: https://github.com/Vectorized/closedsea/blob/main/src/example/ExampleERC721A.sol\n *\n * @notice Be sure to add the following to your impl constructor:\n * >>  _registerForOperatorFiltering();\n * >>  operatorFilteringEnabled = true;\n */\nabstract contract ERC1155_NFTC is ERC1155Burnable, OperatorFilterer, OwnableDeferral {\n    bool public operatorFilteringEnabled;\n\n    function setApprovalForAll(address operator, bool approved) public override onlyAllowedOperatorApproval(operator) {\n        super.setApprovalForAll(operator, approved);\n    }\n\n    function safeTransferFrom(\n        address from,\n        address to,\n        uint256 tokenId,\n        uint256 amount,\n        bytes memory data\n    ) public override onlyAllowedOperator(from) {\n        super.safeTransferFrom(from, to, tokenId, amount, data);\n    }\n\n    function safeBatchTransferFrom(\n        address from,\n        address to,\n        uint256[] memory ids,\n        uint256[] memory amounts,\n        bytes memory data\n    ) public override onlyAllowedOperator(from) {\n        super.safeBatchTransferFrom(from, to, ids, amounts, data);\n    }\n\n    /**\n     * Failsafe in case we need to turn operator filtering off.\n     */\n    function setOperatorFilteringEnabled(bool value) public isOwner {\n        operatorFilteringEnabled = value;\n    }\n\n    /**\n     * Failsafe in case we need to change what subscription we are using, for whatever reason.\n     */\n    function registerForOperatorFiltering(address subscription, bool subscribe) external isOwner {\n        _registerForOperatorFiltering(subscription, subscribe);\n    }\n\n    function _operatorFilteringEnabled() internal view override returns (bool) {\n        return operatorFilteringEnabled;\n    }\n\n    function _isPriorityOperator(address operator) internal pure override returns (bool) {\n        // OpenSea Seaport Conduit:\n        // https://etherscan.io/address/0x1E0049783F008A0085193E00003D00cd54003c71\n        // https://goerli.etherscan.io/address/0x1E0049783F008A0085193E00003D00cd54003c71\n        return operator == address(0x1E0049783F008A0085193E00003D00cd54003c71);\n    }\n}\n"
      },
      "@nftculture/nftc-contracts-private/contracts/token/v4/interfaces/IBaseURIConfigurable.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n/**\n * @title IBaseURIConfigurable\n * @author @NFTCulture\n * @dev Interface to define Base URI configuration functions.\n *\n * Supported Contract Specs:\n *  - ERC721A Static\n *  - ERC721A Expandable\n *  - ERC1155\n */\ninterface IBaseURIConfigurable {\n    /*°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°\\\n    |                   API - General Functions                   |\n    \\____________________________________________________________*/\n\n    // Set Art URI for all tokens. ERC721 - Base URI. ERC1155 - Uri.\n    function setArtURI(string memory) external;\n\n    // Get Art URI for all tokens. ERC721 - Base URI. ERC1155 - Uri.\n    function getArtURI() external view returns (string memory);\n}\n"
      },
      "@nftculture/nftc-contracts-private/contracts/token/v4/interfaces/INFTCNonFungibleToken.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n// NFTC Prerelease Contracts\nimport './IBaseURIConfigurable.sol';\nimport './INonFungibleTokenQueryable.sol';\n\n/**\n * @title INFTCNonFungibleToken\n * @author @NFTCulture\n * @dev Interface to define standardized functionality that should be exposed\n * on NFTC NonFungible Token contracts.\n */\ninterface INFTCNonFungibleToken is IBaseURIConfigurable, INonFungibleTokenQueryable {\n    // Tag Interface\n}\n"
      },
      "@nftculture/nftc-contracts-private/contracts/token/v4/interfaces/INonFungibleTokenQueryable.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n/**\n * @title INonFungibleTokenQueryable\n * @author @NFTCulture\n * @dev Interface to define data-retrieval functions for a NonFungible Token contract.\n */\ninterface INonFungibleTokenQueryable {\n    /*°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°\\\n    |                   API - General Functions                   |\n    \\____________________________________________________________*/\n\n    // Return the maximum possible number of tokens that can be minted by this contract.\n    function maxSupply() external view returns (uint256);\n\n    // Return the number of tokens that have been minted.\n    function totalMinted() external view returns (uint256);\n\n    // Return the current number of tokens that exist, minted less burned.\n    function totalTokensExist() external view returns (uint256);\n\n    // Return the balance owned by an address.\n    function balanceOwnedBy(address) external view returns (uint256);\n}\n"
      },
      "@nftculture/nftc-contracts-private/contracts/token/v4/minter-extensions/FullInteractiveNFTMinter_1155Fixed.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n// Local References\nimport '../ERC1155_NFTC.sol';\nimport '../interfaces/INFTCNonFungibleToken.sol';\nimport '../minter-interfaces/INFTCInteractiveMintFull.sol';\n\nerror InvalidBurnAmount();\n\n/**\n * @title FullInteractiveNFTMinter_1155Fixed\n * @author @NiftyMike | @NFTCulture\n * @dev Minter for mints that can be directly interacted with by users, the full version.\n *\n * Note: This implementation should only be used by a subset of 1155 collections that use a fixed tokenType.\n * By enforcing a fixed tokenType, we can apply the same API for minting dApps.\n *\n *  - INFTCNonFungibleToken: Important mint functions for Base URI Management\n *    and Query Helpers\n */\nabstract contract FullInteractiveNFTMinter_1155Fixed is ERC1155_NFTC, INFTCNonFungibleToken, INFTCInteractiveMintFull {\n    string private _artUri; // For tracking changes to the base uri()\n    uint256 private _fixedTokenId;\n    uint64 private _totalSupply;\n    uint64 private _numberMinted;\n\n    constructor(uint256 __fixedTokenId) {\n        _fixedTokenId = __fixedTokenId;\n    }\n\n    function _getFixedTokenId() internal view returns (uint256) {\n        return _fixedTokenId;\n    }\n\n    function setArtURI(string memory newuri) external override isOwner {\n        _artUri = newuri;\n        _setURI(newuri); // also set it as the contract's base uri.\n    }\n\n    function getArtURI() external view override returns (string memory) {\n        return _getArtURI();\n    }\n\n    function _getArtURI() internal view returns (string memory) {\n        return _artUri;\n    }\n\n    function totalMinted() external view override returns (uint256) {\n        return _totalMinted();\n    }\n\n    function _totalMinted() internal view returns (uint256) {\n        return _numberMinted;\n    }\n\n    function totalTokensExist() external view override returns (uint256) {\n        return _totalTokensExist();\n    }\n\n    function _totalTokensExist() internal view returns (uint256) {\n        return _totalSupply;\n    }\n\n    function balanceOwnedBy(address tokenOwner) external view override returns (uint256) {\n        return super.balanceOf(tokenOwner, _fixedTokenId);\n    }\n\n    /**\n     * @dev See {ERC1155-_beforeTokenTransfer}.\n     */\n    function _beforeTokenTransfer(\n        address operator,\n        address from,\n        address to,\n        uint256[] memory tokenIds,\n        uint256[] memory amounts,\n        bytes memory data\n    ) internal virtual override {\n        super._beforeTokenTransfer(operator, from, to, tokenIds, amounts, data);\n\n        if (from == address(0)) {\n            uint64 numberMinted;\n            for (uint256 i = 0; i < tokenIds.length; ) {\n                unchecked {\n                    numberMinted += uint64(amounts[i]);\n                    ++i;\n                }\n            }\n\n            _numberMinted += numberMinted;\n            _totalSupply += numberMinted;\n        }\n\n        if (to == address(0)) {\n            uint64 numberBurned;\n            for (uint256 i = 0; i < tokenIds.length; ) {\n                unchecked {\n                    numberBurned += uint64(amounts[i]);\n                    ++i;\n                }\n            }\n\n            if (_totalSupply < numberBurned) revert InvalidBurnAmount();\n            _totalSupply -= numberBurned;\n        }\n    }\n}\n"
      },
      "@nftculture/nftc-contracts-private/contracts/token/v4/minter-interfaces/INFTCInteractiveMintFull.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n/**\n * @title INFTCInteractiveMintFull\n * @author @NFTCulture\n * @dev This interface is tailored towards NFTs that will be\n * minted interactively by their recipients. To that end, it attempts to provide a\n * standardized set of capabilities upon which Front End dApps can rely.\n *\n * This interface is compatible with both Fungible and Non-Fungible tokens.\n *\n * Note: NFTC \"Mint-Tag\" interfaces are just helpers to set guidelines for implementing token\n * minting functions in a consistent way across projects, and to help readers more quickly\n * understand the public endpoints in the contract.\n */\ninterface INFTCInteractiveMintFull {\n    function premintTokens(uint256 count, uint256 flavorId, address[] calldata destinations) external payable;\n\n    function reserveTokens(uint256 count, uint256 flavorId, address[] calldata destinations) external payable;\n\n    function publicMintTokens(\n        uint256 count,\n        uint256 flavorId,\n        uint256 validationData,\n        address provider\n    ) external payable;\n\n    function publicMintTokensTo(\n        uint256 count,\n        uint256 flavorId,\n        uint256 validationData,\n        address provider,\n        address destination\n    ) external payable;\n}\n"
      },
      "@nftculture/nftc-contracts-private/contracts/token/v4/token-types/FlavorInfo.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n/**\n * @title FlavorInfo\n * @author @NFTCulture\n * @dev Library for FlavorInfoV4 objects.\n *\n *  Bits Layout:\n *    256 bit slot #1\n *    - [0..63]    `flavorId`\n *    - [64..127]  `maxSupply`\n *    - [128..191] `totalMinted`\n *    - [192..255] `totalSupply`\n *\n *    256 bit slot #2\n *    - [0..159]   `provider`\n *    - [160..255] `price`\n *\n *  NOTE: Provider is responsible for the following:\n *  - Storage of ipfsHash and uriFragment, if they exist\n *      bytes32 uriFragment; // Fragment to append to URI\n *      string ipfsHash; // IPFS Hash to append to URI\n *  - Splitting out uriFragment and ipfsHash to live with the provider makes FlavorInfo objects much more gas efficient.\n *\n *  - Instead of updating uri details, a new product list contract can be deployed that contains the updated data.\n *  Updating FlavorInfos in the main contract would just involve passing one new address to an update address function.\n *  This would involve many fewer writes of ipfsHashes if all that has changed is the ipfsHash, as the replacement contract wouldn't\n *  need to contain all the original flavor definitions.\n *\n *  URI should be built like: `${baseURI}${ipfsHash}${uriFragment}\n *    - Care should be taken to properly include '/' chars. Typically baseURI will have a trailing slash.\n *    - If ipfsHash is used, uriFragment should contain a leading '/'.\n *    - If ipfsHash is not used, uriFragment should not contain a leading '/'.\n */\nlibrary FlavorInfo {\n    struct FlavorInfoV4 {\n        uint64 flavorId;\n        uint64 maxSupply;\n        uint64 totalMinted;\n        uint64 totalSupply; // TotalSupply or Extra storage space that can be used however needed by the caller.\n        address provider; // Address of the provider.\n        uint96 price; // Price needs to be 96 bit. 64bit for value sets a cap at about 9.2 ETH (9.2e18 wei)\n    }\n}\n"
      },
      "@nftculture/nftc-contracts-private/contracts/token/v4/user-interactive/IMintable.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n// Local References\nimport '../token-types/FlavorInfo.sol';\n\n/**\n * @title IMintable\n * @author @NFTCulture\n * @dev Interface to define standardized functionality that is needed to drive\n * user-interactive functionality via a generalized front-end interface.\n *\n * Supported Contract Specs:\n *  - ERC721A Static\n *  - ERC721A Expandable\n *  - ERC1155\n */\ninterface IMintable {\n    /*°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°\\\n    |                   API - General Functions                   |\n    \\____________________________________________________________*/\n\n    // Return a JSON representation of contract capabilities.\n    function nftcContractDefinition() external view returns (string memory);\n\n    // Return the list of TokenTypes that can be minted (was formerly getFlavors)\n    function nftcTokenTypeList() external view returns (uint64[] memory);\n\n    // Return the tokenTypeDefinition for a specific tokenType\n    function nftcTokenTypeDefinition(uint64 tokenType) external view returns (FlavorInfo.FlavorInfoV4 memory);\n}\n"
      },
      "@nftculture/nftc-contracts-private/contracts/token/v4/user-interactive/IUserInteractivePhaseOne.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n/**\n * @title IUserInteractivePhaseOne\n * @author @NFTCulture\n *\n * Supported Contract Specs:\n *  - ERC721A Static\n *  - ERC721A Expandable\n *  - ERC1155\n */\ninterface IUserInteractivePhaseOne {\n    /*°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°\\\n    |                   API - User Interactive Functions               |\n    \\____________________________________________________________*/\n\n    function getTokensPurchased_PhaseOne(address) external view returns (uint256);\n}\n"
      },
      "@nftculture/nftc-contracts-private/contracts/token/v4/user-interactive/IUserInteractivePhaseTwo.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n/**\n * @title IUserInteractivePhaseTwo\n * @author @NFTCulture\n *\n * Supported Contract Specs:\n *  - ERC721A Static\n *  - ERC721A Expandable\n *  - ERC1155\n */\ninterface IUserInteractivePhaseTwo {\n    /*°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°\\\n    |                   API - User Interactive Functions               |\n    \\____________________________________________________________*/\n\n    function getTokensPurchased_PhaseTwo(address) external view returns (uint256);\n}\n"
      },
      "@nftculture/nftc-contracts-private/contracts/token/v4/user-interactive/merkle/IMintablePhaseOneMerkleAux.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n// Local References\nimport '../IUserInteractivePhaseOne.sol';\n\n/**\n * @title IMintablePhaseOneMerkleTiered\n * @author @NFTCulture\n * @dev Interface to define standardized functionality that should be exposed\n * on NFTC Mint contracts, so that Front End widgets can rely on a standard set\n * capabilities.\n *\n * Supported Contract Specs:\n *  - ERC721A Static\n *  - ERC721A Expandable\n *  - ERC1155\n *\n * Merkle Aux: Leaves are generated using an Int value (which can be anything) and an \"Auxillary\" value (which is a string).\n */\ninterface IMintablePhaseOneMerkleAux is IUserInteractivePhaseOne {\n    /*°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°\\\n    |                   API - Phase One Functions                 |\n    \\____________________________________________________________*/\n\n    function getTokensPurchased_PhaseOne(address) external view returns (uint256);\n\n    function checkProof_PhaseOne(\n        bytes32[] calldata proof,\n        string memory auxInfo,\n        uint256 extraData\n    ) external view returns (bool);\n\n    function phaseOneMintTokens(\n        bytes32[] calldata proof,\n        string memory auxInfo,\n        uint256 extraData,\n        uint256 count,\n        uint256 flavorId,\n        uint256 validationData,\n        address provider\n    ) external payable;\n\n    function phaseOneMintTokensTo(\n        bytes32[] calldata proof,\n        string memory auxInfo,\n        uint256 extraData,\n        uint256 count,\n        uint256 flavorId,\n        uint256 validationData,\n        address provider,\n        address destination\n    ) external payable;\n}\n"
      },
      "@nftculture/nftc-contracts-private/contracts/token/v4/user-interactive/merkle/IMintablePhaseTwoMerkleAux.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n// Local References\nimport '../IUserInteractivePhaseTwo.sol';\n\n/**\n * @title IMintablePhaseTwoMerkleTiered\n * @author @NFTCulture\n * @dev Interface to define standardized functionality that should be exposed\n * on NFTC Mint contracts, so that Front End widgets can rely on a standard set\n * capabilities.\n *\n * Supported Contract Specs:\n *  - ERC721A Static\n *  - ERC721A Expandable\n *  - ERC1155\n *\n * Merkle Aux: Leaves are generated using an Int value (which can be anything) and an \"Auxillary\" value (which is a string).\n */\ninterface IMintablePhaseTwoMerkleAux is IUserInteractivePhaseTwo {\n    /*°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°°\\\n    |                   API - Phase Two Functions                 |\n    \\____________________________________________________________*/\n\n    function getTokensPurchased_PhaseTwo(address) external view returns (uint256);\n\n    function checkProof_PhaseTwo(\n        bytes32[] calldata proof,\n        string memory auxInfo,\n        uint256 extraData\n    ) external view returns (bool);\n\n    function phaseTwoMintTokens(\n        bytes32[] calldata proof,\n        string memory auxInfo,\n        uint256 extraData,\n        uint256 count,\n        uint256 flavorId,\n        uint256 validationData,\n        address provider\n    ) external payable;\n\n    function phaseTwoMintTokensTo(\n        bytes32[] calldata proof,\n        string memory auxInfo,\n        uint256 extraData,\n        uint256 count,\n        uint256 flavorId,\n        uint256 validationData,\n        address provider,\n        address destination\n    ) external payable;\n}\n"
      },
      "@nftculture/nftc-contracts-private/contracts/token/v4/user-interactive/merkle/PhaseOneIsAuxillary.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n// NFTC Open Source Contracts See: https://github.com/NFTCulture/nftc-open-contracts\nimport '@nftculture/nftc-contracts/contracts/utility/AuxHelper32.sol';\n\n// NFTC Prerelease Contracts\nimport './IMintablePhaseOneMerkleAux.sol';\nimport '../../../../whitelisting/MerkleLeavesExtended.sol';\n\n// NFTC Prerelease Libraries\nimport {MerkleClaimList} from '../../../../whitelisting/MerkleClaimList.sol';\n\nerror AuxProofInvalid_PhaseOne();\n\n/**\n * @title PhaseOneIsAuxillary\n */\nabstract contract PhaseOneIsAuxillary is MerkleLeavesExtended, AuxHelper32, IMintablePhaseOneMerkleAux {\n    using MerkleClaimList for MerkleClaimList.Root;\n\n    MerkleClaimList.Root private _phaseOneRoot;\n\n    constructor() {}\n\n    function _setPhaseOneRoot(bytes32 __root) internal {\n        _phaseOneRoot._setRoot(__root);\n    }\n\n    function checkProof_PhaseOne(\n        bytes32[] calldata proof,\n        string calldata auxInfo,\n        uint256 extraData\n    ) external view returns (bool) {\n        return _phaseOneRoot._checkLeaf(proof, _generateAuxillaryLeaf(auxInfo, extraData));\n    }\n\n    function getTokensPurchased_PhaseOne(address wallet) external view returns (uint256) {\n        (uint32 phaseOnePurchases, ) = _unpack32(_getPackedPurchasesAs64(wallet));\n        return phaseOnePurchases;\n    }\n\n    function _getPackedPurchasesAs64(address wallet) internal view virtual returns (uint64);\n\n    function _proofMintTokens_PhaseOne(\n        address,\n        bytes32[] calldata proof,\n        string memory auxInfo,\n        uint256 extraData,\n        uint256 count,\n        address destination\n    ) internal {\n        // Verify address is eligible for mints in this tier.\n        if (!_phaseOneRoot._checkLeaf(proof, _generateAuxillaryLeaf(auxInfo, extraData))) {\n            revert AuxProofInvalid_PhaseOne();\n        }\n\n        _internalMintTokens(destination, count);\n    }\n\n    function _internalMintTokens(address minter, uint256 count) internal virtual;\n\n    function _proofMintTokensOfFlavor_PhaseOne(\n        address,\n        bytes32[] calldata proof,\n        string memory auxInfo,\n        uint256 extraData,\n        uint256 count,\n        uint256 flavorId,\n        address destination\n    ) internal {\n        // Verify address is eligible for mints in this tier.\n        if (!_phaseOneRoot._checkLeaf(proof, _generateAuxillaryLeaf(auxInfo, extraData))) {\n            revert AuxProofInvalid_PhaseOne();\n        }\n\n        _internalMintTokens(destination, count, flavorId);\n    }\n\n    function _internalMintTokens(address minter, uint256 count, uint256 flavorId) internal virtual;\n}\n"
      },
      "@nftculture/nftc-contracts-private/contracts/token/v4/user-interactive/merkle/PhaseTwoIsAuxillary.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n// NFTC Open Source Contracts See: https://github.com/NFTCulture/nftc-open-contracts\nimport '@nftculture/nftc-contracts/contracts/utility/AuxHelper32.sol';\n\n// NFTC Prerelease Contracts\nimport './IMintablePhaseTwoMerkleAux.sol';\nimport '../../../../whitelisting/MerkleLeavesExtended.sol';\n\n// NFTC Prerelease Libraries\nimport {MerkleClaimList} from '../../../../whitelisting/MerkleClaimList.sol';\n\nerror AuxProofInvalid_PhaseTwo();\n\n/**\n * @title PhaseTwoIsAuxillary\n */\nabstract contract PhaseTwoIsAuxillary is MerkleLeavesExtended, AuxHelper32, IMintablePhaseTwoMerkleAux {\n    using MerkleClaimList for MerkleClaimList.Root;\n\n    MerkleClaimList.Root private _phaseTwoRoot;\n\n    constructor() {}\n\n    function _setPhaseTwoRoot(bytes32 __root) internal {\n        _phaseTwoRoot._setRoot(__root);\n    }\n\n    function checkProof_PhaseTwo(\n        bytes32[] calldata proof,\n        string calldata auxInfo,\n        uint256 extraData\n    ) external view returns (bool) {\n        return _phaseTwoRoot._checkLeaf(proof, _generateAuxillaryLeaf(auxInfo, extraData));\n    }\n\n    function getTokensPurchased_PhaseTwo(address wallet) external view returns (uint256) {\n        (uint32 phaseTwoPurchases, ) = _unpack32(_getPackedPurchasesAs64(wallet));\n        return phaseTwoPurchases;\n    }\n\n    function _getPackedPurchasesAs64(address wallet) internal view virtual returns (uint64);\n\n    function _proofMintTokens_PhaseTwo(\n        address,\n        bytes32[] calldata proof,\n        string memory auxInfo,\n        uint256 extraData,\n        uint256 count,\n        address destination\n    ) internal {\n        // Verify address is eligible for mints in this tier.\n        if (!_phaseTwoRoot._checkLeaf(proof, _generateAuxillaryLeaf(auxInfo, extraData))) {\n            revert AuxProofInvalid_PhaseTwo();\n        }\n\n        _internalMintTokens(destination, count);\n    }\n\n    function _internalMintTokens(address minter, uint256 count) internal virtual;\n\n    function _proofMintTokensOfFlavor_PhaseTwo(\n        address,\n        bytes32[] calldata proof,\n        string memory auxInfo,\n        uint256 extraData,\n        uint256 count,\n        uint256 flavorId,\n        address destination\n    ) internal {\n        // Verify address is eligible for mints in this tier.\n        if (!_phaseTwoRoot._checkLeaf(proof, _generateAuxillaryLeaf(auxInfo, extraData))) {\n            revert AuxProofInvalid_PhaseTwo();\n        }\n\n        _internalMintTokens(destination, count, flavorId);\n    }\n\n    function _internalMintTokens(address minter, uint256 count, uint256 flavorId) internal virtual;\n}\n"
      },
      "@nftculture/nftc-contracts-private/contracts/whitelisting/MerkleClaimList.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\nimport {MerkleRoot} from './MerkleRoot.sol';\n\n/**\n * @title MerkleClaimList\n * @author @NiftyMike | @NFTCulture\n * @dev Basic functionality for a MerkleTree that will be used as a \"Claimlist\"\n *\n * \"Claimlist\" - an approach for validating callers that is backed by a Merkle Tree.\n * Cheap to set the master claim, not that expensive to check the claim. Requires\n * off-chain generation of the Merkle Tree.\n *\n * This library allows you to declare a member variable like:\n * MerkleClaimList.Root private _claimRoot;\n *\n * The benefit of packaging this as a library, is that if you need multiple merkle trees in your\n * contract, you can declare multiple member variables using this library, and use them in similar fashion.\n *\n * see also: NFTC Labs' MerkleLeaves.sol, which is a companion abstract contract which contains helper\n * methods for generating leaves for the Merkle Tree.\n */\nlibrary MerkleClaimList {\n    using MerkleRoot for bytes32;\n\n    struct Root {\n        // This variable should never be directly accessed by users of the library. See OZ comments in other libraries for more info.\n        bytes32 _root;\n    }\n\n    /**\n     * @dev Validate that a leaf is part of this merkle tree.\n     */\n    function _checkLeaf(Root storage root, bytes32[] calldata proof, bytes32 leaf) internal view returns (bool) {\n        return root._root.check(proof, leaf);\n    }\n\n    /**\n     * @dev Set the root of this merkle tree.\n     */\n    function _setRoot(Root storage root, bytes32 __root) internal {\n        root._root = __root;\n    }\n}\n"
      },
      "@nftculture/nftc-contracts-private/contracts/whitelisting/MerkleLeavesExtended.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n/**\n * @title MerkleLeavesExtended\n * @author @NiftyMike | @NFTCulture\n * @dev Merkle Leaves for Merkle Trees - This is a companion contract to NFTC Labs' MerkleClaimList.sol library.\n *\n * It provides leaf generation functions for merkle trees.\n * It also provides wrapper methods to expose the leaf generation functions to off-chain callers.\n *\n * Off-chain access is useful, because both the contract and the caller need to be able to generate the\n * leaves in a perfectly identical manner, so the generators are exposed to make it easier.\n */\nabstract contract MerkleLeavesExtended {\n    /**\n     * @notice External: generate a leaf for an embedded index value and an additional piece of data.\n     *\n     * @param auxInfo auxInfo to assign the leaf.\n     * @param extraData extra data that is pertinent to the leaf.\n     */\n    function getAuxillaryLeafFor(string calldata auxInfo, uint256 extraData) external pure returns (bytes32) {\n        return _generateAuxillaryLeaf(auxInfo, extraData);\n    }\n\n    /**\n     * @dev Generate a merkle leaf based on auxInfo and a second piece of data.\n     * This is useful when users need to distribute claims via some sort of code.\n     */\n    function _generateAuxillaryLeaf(string memory auxInfo, uint256 extraData) internal pure returns (bytes32) {\n        return keccak256(abi.encodePacked(auxInfo, '_', extraData));\n    }\n}\n"
      },
      "@nftculture/nftc-contracts-private/contracts/whitelisting/MerkleRoot.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\nimport {MerkleProof} from '@openzeppelin/contracts/utils/cryptography/MerkleProof.sol';\n\n/**\n * @title MerkleRoot\n * @author @NiftyMike | @NFTCulture\n * @dev Companion library to OpenZeppelin's MerkleProof.\n * Allows you to abstract away merkle functionality a bit further, you now just need to\n * worry about dealing with your merkle root.\n *\n * Using this library allows you to treat bytes32 member variables as Merkle Roots, with a\n * slightly easier to use api then the OZ library.\n */\nlibrary MerkleRoot {\n    using MerkleProof for bytes32[];\n\n    function check(bytes32 root, bytes32[] calldata proof, bytes32 leaf) internal pure returns (bool) {\n        return proof.verify(root, leaf);\n    }\n}\n"
      },
      "@nftculture/nftc-contracts/contracts/financial/ERC2981_NFTCExtended.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\nimport '@openzeppelin/contracts/access/Ownable.sol';\nimport '@openzeppelin/contracts/token/common/ERC2981.sol';\n\n/**\n * @title ERC2981_NFTCExtended\n * @author @NiftyMike | @NFTCulture\n * @dev A wrapper around ERC2981 which adds some common functionality.\n */\nabstract contract ERC2981_NFTCExtended is ERC2981 {\n    function setDefaultRoyalty(address newReceiver, uint96 newRoyalty) external {\n        _isOwner();\n\n        _setDefaultRoyalty(newReceiver, newRoyalty);\n    }\n\n    function _isOwner() internal view virtual;\n}\n"
      },
      "@nftculture/nftc-contracts/contracts/financial/NFTCPaymentSplitter.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n// NFTC Open Source Contracts See: https://github.com/NFTCulture/nftc-contracts\nimport './NFTCPaymentSplitterBase.sol';\n\n/**\n * @title NFTCPaymentSplitter\n * @author @NiftyMike | @NFTCulture\n * @dev NFTC's Implementation of a Payment Splitter\n *\n * Underlying is based on OpenZeppelin Contracts v4.8.0 (finance/PaymentSplitter.sol)\n */\nabstract contract NFTCPaymentSplitter is NFTCPaymentSplitterBase {\n    /**\n     * @dev Overrides release() method, so that it can only be called by owner.\n     * @notice Owner: Release funds to a specific address.\n     *\n     * @param account Payable address that will receive funds.\n     */\n    function release(address payable account) public override {\n        _isOwner();\n\n        _release(account);\n    }\n\n    /**\n     * @dev Triggers a transfer to caller's address of the amount of Ether they are owed, according to their percentage of the\n     * total shares and their previous withdrawals.\n     * @notice Sender: request payment.\n     */\n    function releaseToSelf() public {\n        _release(payable(_msgSender()));\n    }\n\n    function _isOwner() internal view virtual;\n}\n"
      },
      "@nftculture/nftc-contracts/contracts/financial/NFTCPaymentSplitterBase.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\nimport '@openzeppelin/contracts/utils/Address.sol';\nimport '@openzeppelin/contracts/utils/Context.sol';\n\n/**\n * @title NFTCPaymentSplitterBase\n * @author @NiftyMike | @NFTCulture\n * @dev An opinionated replacement of OZ's Payment Splitter.\n *\n * Notes:\n *  - Based on OZ Contracts v4.8.0 (finance/PaymentSplitter.sol)\n *  - ERC-20 token functionality removed to save gas.\n *  - Transferability of Payees, but only by Payee\n *  - Some require messages are shortened.\n *  - contract changed to abstract and release() functionality moved to internal method.\n *\n * IMPORTANT: changes to release() require higher level classes to expose release() in order\n * for funds to be withdrawn. This allows higher level classes to enforce better controls.\n */\nabstract contract NFTCPaymentSplitterBase is Context {\n    event PayeeAdded(address account, uint256 shares);\n    event PaymentReleased(address to, uint256 amount);\n    event PaymentReceived(address from, uint256 amount);\n    event PayeeTransferred(address oldOwner, address newOwner);\n\n    uint256 private _totalShares;\n    uint256 private _totalReleased;\n\n    mapping(address => uint256) private _shares;\n    mapping(address => uint256) private _released;\n    address[] private _payees;\n\n    /**\n     * @dev Creates an instance of `PaymentSplitter` where each account in `payees` is assigned the number of shares at\n     * the matching position in the `shares` array.\n     *\n     * All addresses in `payees` must be non-zero. Both arrays must have the same non-zero length, and there must be no\n     * duplicates in `payees`.\n     */\n    constructor(address[] memory payees, uint256[] memory shares_) payable {\n        require(payees.length == shares_.length, 'PaymentSplitter: length mismatch');\n        require(payees.length > 0, 'PaymentSplitter: no payees');\n\n        for (uint256 i = 0; i < payees.length; i++) {\n            _addPayee(payees[i], shares_[i]);\n        }\n    }\n\n    /**\n     * @dev The Ether received will be logged with {PaymentReceived} events. Note that these events are not fully\n     * reliable: it's possible for a contract to receive Ether without triggering this function. This only affects the\n     * reliability of the events, and not the actual splitting of Ether.\n     *\n     * To learn more about this see the Solidity documentation for\n     * https://solidity.readthedocs.io/en/latest/contracts.html#fallback-function[fallback\n     * functions].\n     */\n    receive() external payable virtual {\n        emit PaymentReceived(_msgSender(), msg.value);\n    }\n\n    /**\n     * @dev Getter for the total shares held by payees.\n     */\n    function totalShares() public view returns (uint256) {\n        return _totalShares;\n    }\n\n    /**\n     * @dev Getter for the total amount of Ether already released.\n     */\n    function totalReleased() public view returns (uint256) {\n        return _totalReleased;\n    }\n\n    /**\n     * @dev Getter for the amount of shares held by an account.\n     */\n    function shares(address account) public view returns (uint256) {\n        return _shares[account];\n    }\n\n    /**\n     * @dev Getter for the amount of Ether already released to a payee.\n     */\n    function released(address account) public view returns (uint256) {\n        return _released[account];\n    }\n\n    /**\n     * @dev Getter for the address of the payee number `index`.\n     */\n    function payee(uint256 index) public view returns (address) {\n        return _payees[index];\n    }\n\n    /**\n     * @dev Getter for the amount of payee's releasable Ether.\n     */\n    function releasable(address account) public view returns (uint256) {\n        return _releasable(account);\n    }\n\n    function _releasable(address account) internal view returns (uint256) {\n        uint256 totalReceived = address(this).balance + totalReleased();\n        return _pendingPayment(account, totalReceived, released(account));\n    }\n\n    /**\n     * @dev Triggers a transfer to `account` of the amount of Ether they are owed, according to their percentage of the\n     * total shares and their previous withdrawals.\n     */\n    function _release(address payable account) internal {\n        require(_shares[account] > 0, 'PaymentSplitter: no shares');\n\n        uint256 payment = _releasable(account);\n\n        require(payment != 0, 'PaymentSplitter: not due payment');\n\n        // _totalReleased is the sum of all values in _released.\n        // If \"_totalReleased += payment\" does not overflow, then \"_released[account] += payment\" cannot overflow.\n        _totalReleased += payment;\n        unchecked {\n            _released[account] += payment;\n        }\n\n        Address.sendValue(account, payment);\n        emit PaymentReleased(account, payment);\n    }\n\n    /**\n     * @dev internal logic for computing the pending payment of an `account` given the token historical balances and\n     * already released amounts.\n     */\n    function _pendingPayment(\n        address account,\n        uint256 totalReceived,\n        uint256 alreadyReleased\n    ) private view returns (uint256) {\n        return (totalReceived * _shares[account]) / _totalShares - alreadyReleased;\n    }\n\n    /**\n     * @dev Add a new payee to the contract.\n     * @param account The address of the payee to add.\n     * @param shares_ The number of shares owned by the payee.\n     */\n    function _addPayee(address account, uint256 shares_) private {\n        require(account != address(0), 'PaymentSplitter: zero address');\n        require(shares_ > 0, 'PaymentSplitter: no shares');\n        require(_shares[account] == 0, 'PaymentSplitter: payee has shares');\n\n        _payees.push(account);\n        _shares[account] = shares_;\n        _totalShares = _totalShares + shares_;\n        emit PayeeAdded(account, shares_);\n    }\n\n    /**\n     * @dev Allows owner to transfer their shares to somebody else; it can only be called by of a share.\n     * @notice Owner: Release funds to a specific address.\n     *\n     * @param newOwner Payable address which has no shares and will receive the shares of the current owner.\n     */\n    function transferPayee(address payable newOwner) public {\n        require(newOwner != address(0), 'PaymentSplitter: zero address');\n        require(_shares[_msgSender()] > 0, 'PaymentSplitter: no owned shares');\n        require(_shares[newOwner] == 0, 'PaymentSplitter: payee has shares');\n\n        _transferPayee(newOwner);\n        emit PayeeTransferred(_msgSender(), newOwner);\n    }\n\n    function _transferPayee(address newOwner) private {\n        if (_payees.length == 0) return;\n\n        for (uint i = 0; i < _payees.length - 1; i++) {\n            if (_payees[i] == _msgSender()) {\n                _payees[i] = newOwner;\n                _shares[newOwner] = _shares[_msgSender()];\n                _shares[_msgSender()] = 0;\n            }\n        }\n    }\n\n    function release(address payable account) public virtual;\n}\n"
      },
      "@nftculture/nftc-contracts/contracts/financial/NFTCSplitsAndRoyalties.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n// NFTC Open Source Contracts See: https://github.com/NFTCulture/nftc-contracts\nimport './ERC2981_NFTCExtended.sol';\nimport './NFTCPaymentSplitter.sol';\n\n/**\n * @title NFTCSplitsAndRoyalties\n * @author @NiftyMike | @NFTCulture\n * @dev One stop shop for Payment Splits and ERC2981 Royalty Definition.\n */\nabstract contract NFTCSplitsAndRoyalties is NFTCPaymentSplitter, ERC2981_NFTCExtended {\n    constructor(\n        address[] memory __addresses,\n        uint256[] memory __splits,\n        address defaultRoyaltyReceiver,\n        uint96 defaultRoyaltyBasisPoints\n    ) NFTCPaymentSplitterBase(__addresses, __splits) {\n        // Default royalty information to be this contract, so that no potential\n        // royalty payments are missed by marketplaces that support ERC2981.\n        _setDefaultRoyalty(defaultRoyaltyReceiver, defaultRoyaltyBasisPoints);\n    }\n\n    function _isOwner() internal view virtual override(NFTCPaymentSplitter, ERC2981_NFTCExtended);\n}\n"
      },
      "@nftculture/nftc-contracts/contracts/meta/ERC7572_ContractMetadata.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n// Local References\nimport './IERC7572.sol';\n\n// OZ References\nimport '@openzeppelin/contracts/utils/introspection/ERC165.sol';\n\n/**\n * @title ERC7572_ContractMetadata\n * @author @NiftyMike | @NFTCulture\n * @dev A basic implementation of ERC-7572 for exposing contract-level metadata for\n * external marketplaces via IPFS. This approach can be used to provide out-of-the-box\n * pretty metadata on contract deployment.\n */\nabstract contract ERC7572_ContractMetadata is IERC7572, ERC165 {\n    string private _contractURI;\n\n    /**\n     * @dev return the contract URI.\n     *\n     * See: https://docs.opensea.io/docs/contract-level-metadata\n     *\n     * Three approaches:\n     *\n     * - Native IPFS Addressing: \"ipfs://QmTNgv3jx2HHfBjQX9RnKtxj2xv2xQDtbVXoRi5rJ3a46e\"\n     * - Link to a JSON file: \"https://external-link-url.com/my-contract-metadata.json\"\n     * - OnChain/Encoded in Contract:\n     *      string memory json = '{\"name\": \"Creatures\",\"description\":\"...\"}';\n     *      return string.concat(\"data:application/json;utf8,\", json);\n     */\n    function contractURI() external view override returns (string memory) {\n        return _contractURI;\n    }\n\n    function setContractURI(string calldata __contractUri) external {\n        _isOwner();\n\n        _setContractURI(__contractUri);\n    }\n\n    function _setContractURI(string memory __contractUri) internal {\n        _contractURI = __contractUri;\n\n        emit ContractURIUpdated();\n    }\n\n    function _getContractURI() internal view returns (string memory) {\n        return _contractURI;\n    }\n\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165) returns (bool) {\n        return interfaceId == type(IERC7572).interfaceId || super.supportsInterface(interfaceId);\n    }\n\n    function _isOwner() internal view virtual;\n}\n"
      },
      "@nftculture/nftc-contracts/contracts/meta/IERC7572.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n/**\n * @title IERC7572\n * @author @NiftyMike | @NFTCulture\n * @dev This specification standardizes contractURI() to return contract-level metadata.\n *\n * @notice See: https://eips.ethereum.org/EIPS/eip-7572\n */\ninterface IERC7572 {\n    function contractURI() external view returns (string memory);\n\n    event ContractURIUpdated();\n}\n"
      },
      "@nftculture/nftc-contracts/contracts/utility/AuxHelper32.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n/**\n * @title AuxHelper32\n * @author @NiftyMike | @NFTCulture\n * @dev Helper class for ERC721a Aux storage, using 32 bit ints.\n */\nabstract contract AuxHelper32 {\n    function _pack32(uint32 left32, uint32 right32) internal pure returns (uint64) {\n        return (uint64(left32) << 32) | uint32(right32);\n    }\n\n    function _unpack32(uint64 aux) internal pure returns (uint32 left32, uint32 right32) {\n        return (uint32(aux >> 32), uint32(aux));\n    }\n}\n"
      },
      "@nftculture/nftc-contracts/contracts/utility/BooleanPacking.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.11;\n\n/**\n * @title BooleanPacking\n * @author @NiftyMike | @NFTCulture\n * @dev Credit to Zimri Leijen\n * See https://ethereum.stackexchange.com/a/92235\n */\nlibrary BooleanPacking {\n    function getBoolean(uint256 _packedBools, uint256 _columnNumber) internal pure returns (bool) {\n        uint256 flag = (_packedBools >> _columnNumber) & uint256(1);\n        return (flag == 1 ? true : false);\n    }\n\n    function setBoolean(uint256 _packedBools, uint256 _columnNumber, bool _value) internal pure returns (uint256) {\n        if (_value) {\n            _packedBools = _packedBools | (uint256(1) << _columnNumber);\n            return _packedBools;\n        } else {\n            _packedBools = _packedBools & ~(uint256(1) << _columnNumber);\n            return _packedBools;\n        }\n    }\n}\n"
      },
      "@openzeppelin/contracts/access/Ownable.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n    address private _owner;\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the deployer as the initial owner.\n     */\n    constructor() {\n        _transferOwnership(_msgSender());\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby disabling any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n"
      },
      "@openzeppelin/contracts/interfaces/IERC2981.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC2981.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/introspection/IERC165.sol\";\n\n/**\n * @dev Interface for the NFT Royalty Standard.\n *\n * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal\n * support for royalty payments across all NFT marketplaces and ecosystem participants.\n *\n * _Available since v4.5._\n */\ninterface IERC2981 is IERC165 {\n    /**\n     * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of\n     * exchange. The royalty amount is denominated and should be paid in that same unit of exchange.\n     */\n    function royaltyInfo(\n        uint256 tokenId,\n        uint256 salePrice\n    ) external view returns (address receiver, uint256 royaltyAmount);\n}\n"
      },
      "@openzeppelin/contracts/security/ReentrancyGuard.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Contract module that helps prevent reentrant calls to a function.\n *\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\n * available, which can be applied to functions to make sure there are no nested\n * (reentrant) calls to them.\n *\n * Note that because there is a single `nonReentrant` guard, functions marked as\n * `nonReentrant` may not call one another. This can be worked around by making\n * those functions `private`, and then adding `external` `nonReentrant` entry\n * points to them.\n *\n * TIP: If you would like to learn more about reentrancy and alternative ways\n * to protect against it, check out our blog post\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\n */\nabstract contract ReentrancyGuard {\n    // Booleans are more expensive than uint256 or any type that takes up a full\n    // word because each write operation emits an extra SLOAD to first read the\n    // slot's contents, replace the bits taken up by the boolean, and then write\n    // back. This is the compiler's defense against contract upgrades and\n    // pointer aliasing, and it cannot be disabled.\n\n    // The values being non-zero value makes deployment a bit more expensive,\n    // but in exchange the refund on every call to nonReentrant will be lower in\n    // amount. Since refunds are capped to a percentage of the total\n    // transaction's gas, it is best to keep them low in cases like this one, to\n    // increase the likelihood of the full refund coming into effect.\n    uint256 private constant _NOT_ENTERED = 1;\n    uint256 private constant _ENTERED = 2;\n\n    uint256 private _status;\n\n    constructor() {\n        _status = _NOT_ENTERED;\n    }\n\n    /**\n     * @dev Prevents a contract from calling itself, directly or indirectly.\n     * Calling a `nonReentrant` function from another `nonReentrant`\n     * function is not supported. It is possible to prevent this from happening\n     * by making the `nonReentrant` function external, and making it call a\n     * `private` function that does the actual work.\n     */\n    modifier nonReentrant() {\n        _nonReentrantBefore();\n        _;\n        _nonReentrantAfter();\n    }\n\n    function _nonReentrantBefore() private {\n        // On the first call to nonReentrant, _status will be _NOT_ENTERED\n        require(_status != _ENTERED, \"ReentrancyGuard: reentrant call\");\n\n        // Any calls to nonReentrant after this point will fail\n        _status = _ENTERED;\n    }\n\n    function _nonReentrantAfter() private {\n        // By storing the original value once again, a refund is triggered (see\n        // https://eips.ethereum.org/EIPS/eip-2200)\n        _status = _NOT_ENTERED;\n    }\n\n    /**\n     * @dev Returns true if the reentrancy guard is currently set to \"entered\", which indicates there is a\n     * `nonReentrant` function in the call stack.\n     */\n    function _reentrancyGuardEntered() internal view returns (bool) {\n        return _status == _ENTERED;\n    }\n}\n"
      },
      "@openzeppelin/contracts/token/common/ERC2981.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/common/ERC2981.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../../interfaces/IERC2981.sol\";\nimport \"../../utils/introspection/ERC165.sol\";\n\n/**\n * @dev Implementation of the NFT Royalty Standard, a standardized way to retrieve royalty payment information.\n *\n * Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for\n * specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first.\n *\n * Royalty is specified as a fraction of sale price. {_feeDenominator} is overridable but defaults to 10000, meaning the\n * fee is specified in basis points by default.\n *\n * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See\n * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to\n * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported.\n *\n * _Available since v4.5._\n */\nabstract contract ERC2981 is IERC2981, ERC165 {\n    struct RoyaltyInfo {\n        address receiver;\n        uint96 royaltyFraction;\n    }\n\n    RoyaltyInfo private _defaultRoyaltyInfo;\n    mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo;\n\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC165) returns (bool) {\n        return interfaceId == type(IERC2981).interfaceId || super.supportsInterface(interfaceId);\n    }\n\n    /**\n     * @inheritdoc IERC2981\n     */\n    function royaltyInfo(uint256 tokenId, uint256 salePrice) public view virtual override returns (address, uint256) {\n        RoyaltyInfo memory royalty = _tokenRoyaltyInfo[tokenId];\n\n        if (royalty.receiver == address(0)) {\n            royalty = _defaultRoyaltyInfo;\n        }\n\n        uint256 royaltyAmount = (salePrice * royalty.royaltyFraction) / _feeDenominator();\n\n        return (royalty.receiver, royaltyAmount);\n    }\n\n    /**\n     * @dev The denominator with which to interpret the fee set in {_setTokenRoyalty} and {_setDefaultRoyalty} as a\n     * fraction of the sale price. Defaults to 10000 so fees are expressed in basis points, but may be customized by an\n     * override.\n     */\n    function _feeDenominator() internal pure virtual returns (uint96) {\n        return 10000;\n    }\n\n    /**\n     * @dev Sets the royalty information that all ids in this contract will default to.\n     *\n     * Requirements:\n     *\n     * - `receiver` cannot be the zero address.\n     * - `feeNumerator` cannot be greater than the fee denominator.\n     */\n    function _setDefaultRoyalty(address receiver, uint96 feeNumerator) internal virtual {\n        require(feeNumerator <= _feeDenominator(), \"ERC2981: royalty fee will exceed salePrice\");\n        require(receiver != address(0), \"ERC2981: invalid receiver\");\n\n        _defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator);\n    }\n\n    /**\n     * @dev Removes default royalty information.\n     */\n    function _deleteDefaultRoyalty() internal virtual {\n        delete _defaultRoyaltyInfo;\n    }\n\n    /**\n     * @dev Sets the royalty information for a specific token id, overriding the global default.\n     *\n     * Requirements:\n     *\n     * - `receiver` cannot be the zero address.\n     * - `feeNumerator` cannot be greater than the fee denominator.\n     */\n    function _setTokenRoyalty(uint256 tokenId, address receiver, uint96 feeNumerator) internal virtual {\n        require(feeNumerator <= _feeDenominator(), \"ERC2981: royalty fee will exceed salePrice\");\n        require(receiver != address(0), \"ERC2981: Invalid parameters\");\n\n        _tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator);\n    }\n\n    /**\n     * @dev Resets royalty information for the token id back to the global default.\n     */\n    function _resetTokenRoyalty(uint256 tokenId) internal virtual {\n        delete _tokenRoyaltyInfo[tokenId];\n    }\n}\n"
      },
      "@openzeppelin/contracts/token/ERC1155/ERC1155.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC1155/ERC1155.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC1155.sol\";\nimport \"./IERC1155Receiver.sol\";\nimport \"./extensions/IERC1155MetadataURI.sol\";\nimport \"../../utils/Address.sol\";\nimport \"../../utils/Context.sol\";\nimport \"../../utils/introspection/ERC165.sol\";\n\n/**\n * @dev Implementation of the basic standard multi-token.\n * See https://eips.ethereum.org/EIPS/eip-1155\n * Originally based on code by Enjin: https://github.com/enjin/erc-1155\n *\n * _Available since v3.1._\n */\ncontract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI {\n    using Address for address;\n\n    // Mapping from token ID to account balances\n    mapping(uint256 => mapping(address => uint256)) private _balances;\n\n    // Mapping from account to operator approvals\n    mapping(address => mapping(address => bool)) private _operatorApprovals;\n\n    // Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json\n    string private _uri;\n\n    /**\n     * @dev See {_setURI}.\n     */\n    constructor(string memory uri_) {\n        _setURI(uri_);\n    }\n\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {\n        return\n            interfaceId == type(IERC1155).interfaceId ||\n            interfaceId == type(IERC1155MetadataURI).interfaceId ||\n            super.supportsInterface(interfaceId);\n    }\n\n    /**\n     * @dev See {IERC1155MetadataURI-uri}.\n     *\n     * This implementation returns the same URI for *all* token types. It relies\n     * on the token type ID substitution mechanism\n     * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].\n     *\n     * Clients calling this function must replace the `\\{id\\}` substring with the\n     * actual token type ID.\n     */\n    function uri(uint256) public view virtual override returns (string memory) {\n        return _uri;\n    }\n\n    /**\n     * @dev See {IERC1155-balanceOf}.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     */\n    function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {\n        require(account != address(0), \"ERC1155: address zero is not a valid owner\");\n        return _balances[id][account];\n    }\n\n    /**\n     * @dev See {IERC1155-balanceOfBatch}.\n     *\n     * Requirements:\n     *\n     * - `accounts` and `ids` must have the same length.\n     */\n    function balanceOfBatch(\n        address[] memory accounts,\n        uint256[] memory ids\n    ) public view virtual override returns (uint256[] memory) {\n        require(accounts.length == ids.length, \"ERC1155: accounts and ids length mismatch\");\n\n        uint256[] memory batchBalances = new uint256[](accounts.length);\n\n        for (uint256 i = 0; i < accounts.length; ++i) {\n            batchBalances[i] = balanceOf(accounts[i], ids[i]);\n        }\n\n        return batchBalances;\n    }\n\n    /**\n     * @dev See {IERC1155-setApprovalForAll}.\n     */\n    function setApprovalForAll(address operator, bool approved) public virtual override {\n        _setApprovalForAll(_msgSender(), operator, approved);\n    }\n\n    /**\n     * @dev See {IERC1155-isApprovedForAll}.\n     */\n    function isApprovedForAll(address account, address operator) public view virtual override returns (bool) {\n        return _operatorApprovals[account][operator];\n    }\n\n    /**\n     * @dev See {IERC1155-safeTransferFrom}.\n     */\n    function safeTransferFrom(\n        address from,\n        address to,\n        uint256 id,\n        uint256 amount,\n        bytes memory data\n    ) public virtual override {\n        require(\n            from == _msgSender() || isApprovedForAll(from, _msgSender()),\n            \"ERC1155: caller is not token owner or approved\"\n        );\n        _safeTransferFrom(from, to, id, amount, data);\n    }\n\n    /**\n     * @dev See {IERC1155-safeBatchTransferFrom}.\n     */\n    function safeBatchTransferFrom(\n        address from,\n        address to,\n        uint256[] memory ids,\n        uint256[] memory amounts,\n        bytes memory data\n    ) public virtual override {\n        require(\n            from == _msgSender() || isApprovedForAll(from, _msgSender()),\n            \"ERC1155: caller is not token owner or approved\"\n        );\n        _safeBatchTransferFrom(from, to, ids, amounts, data);\n    }\n\n    /**\n     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.\n     *\n     * Emits a {TransferSingle} event.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     * - `from` must have a balance of tokens of type `id` of at least `amount`.\n     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the\n     * acceptance magic value.\n     */\n    function _safeTransferFrom(\n        address from,\n        address to,\n        uint256 id,\n        uint256 amount,\n        bytes memory data\n    ) internal virtual {\n        require(to != address(0), \"ERC1155: transfer to the zero address\");\n\n        address operator = _msgSender();\n        uint256[] memory ids = _asSingletonArray(id);\n        uint256[] memory amounts = _asSingletonArray(amount);\n\n        _beforeTokenTransfer(operator, from, to, ids, amounts, data);\n\n        uint256 fromBalance = _balances[id][from];\n        require(fromBalance >= amount, \"ERC1155: insufficient balance for transfer\");\n        unchecked {\n            _balances[id][from] = fromBalance - amount;\n        }\n        _balances[id][to] += amount;\n\n        emit TransferSingle(operator, from, to, id, amount);\n\n        _afterTokenTransfer(operator, from, to, ids, amounts, data);\n\n        _doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);\n    }\n\n    /**\n     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.\n     *\n     * Emits a {TransferBatch} event.\n     *\n     * Requirements:\n     *\n     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the\n     * acceptance magic value.\n     */\n    function _safeBatchTransferFrom(\n        address from,\n        address to,\n        uint256[] memory ids,\n        uint256[] memory amounts,\n        bytes memory data\n    ) internal virtual {\n        require(ids.length == amounts.length, \"ERC1155: ids and amounts length mismatch\");\n        require(to != address(0), \"ERC1155: transfer to the zero address\");\n\n        address operator = _msgSender();\n\n        _beforeTokenTransfer(operator, from, to, ids, amounts, data);\n\n        for (uint256 i = 0; i < ids.length; ++i) {\n            uint256 id = ids[i];\n            uint256 amount = amounts[i];\n\n            uint256 fromBalance = _balances[id][from];\n            require(fromBalance >= amount, \"ERC1155: insufficient balance for transfer\");\n            unchecked {\n                _balances[id][from] = fromBalance - amount;\n            }\n            _balances[id][to] += amount;\n        }\n\n        emit TransferBatch(operator, from, to, ids, amounts);\n\n        _afterTokenTransfer(operator, from, to, ids, amounts, data);\n\n        _doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);\n    }\n\n    /**\n     * @dev Sets a new URI for all token types, by relying on the token type ID\n     * substitution mechanism\n     * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].\n     *\n     * By this mechanism, any occurrence of the `\\{id\\}` substring in either the\n     * URI or any of the amounts in the JSON file at said URI will be replaced by\n     * clients with the token type ID.\n     *\n     * For example, the `https://token-cdn-domain/\\{id\\}.json` URI would be\n     * interpreted by clients as\n     * `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json`\n     * for token type ID 0x4cce0.\n     *\n     * See {uri}.\n     *\n     * Because these URIs cannot be meaningfully represented by the {URI} event,\n     * this function emits no events.\n     */\n    function _setURI(string memory newuri) internal virtual {\n        _uri = newuri;\n    }\n\n    /**\n     * @dev Creates `amount` tokens of token type `id`, and assigns them to `to`.\n     *\n     * Emits a {TransferSingle} event.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the\n     * acceptance magic value.\n     */\n    function _mint(address to, uint256 id, uint256 amount, bytes memory data) internal virtual {\n        require(to != address(0), \"ERC1155: mint to the zero address\");\n\n        address operator = _msgSender();\n        uint256[] memory ids = _asSingletonArray(id);\n        uint256[] memory amounts = _asSingletonArray(amount);\n\n        _beforeTokenTransfer(operator, address(0), to, ids, amounts, data);\n\n        _balances[id][to] += amount;\n        emit TransferSingle(operator, address(0), to, id, amount);\n\n        _afterTokenTransfer(operator, address(0), to, ids, amounts, data);\n\n        _doSafeTransferAcceptanceCheck(operator, address(0), to, id, amount, data);\n    }\n\n    /**\n     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.\n     *\n     * Emits a {TransferBatch} event.\n     *\n     * Requirements:\n     *\n     * - `ids` and `amounts` must have the same length.\n     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the\n     * acceptance magic value.\n     */\n    function _mintBatch(\n        address to,\n        uint256[] memory ids,\n        uint256[] memory amounts,\n        bytes memory data\n    ) internal virtual {\n        require(to != address(0), \"ERC1155: mint to the zero address\");\n        require(ids.length == amounts.length, \"ERC1155: ids and amounts length mismatch\");\n\n        address operator = _msgSender();\n\n        _beforeTokenTransfer(operator, address(0), to, ids, amounts, data);\n\n        for (uint256 i = 0; i < ids.length; i++) {\n            _balances[ids[i]][to] += amounts[i];\n        }\n\n        emit TransferBatch(operator, address(0), to, ids, amounts);\n\n        _afterTokenTransfer(operator, address(0), to, ids, amounts, data);\n\n        _doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);\n    }\n\n    /**\n     * @dev Destroys `amount` tokens of token type `id` from `from`\n     *\n     * Emits a {TransferSingle} event.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `from` must have at least `amount` tokens of token type `id`.\n     */\n    function _burn(address from, uint256 id, uint256 amount) internal virtual {\n        require(from != address(0), \"ERC1155: burn from the zero address\");\n\n        address operator = _msgSender();\n        uint256[] memory ids = _asSingletonArray(id);\n        uint256[] memory amounts = _asSingletonArray(amount);\n\n        _beforeTokenTransfer(operator, from, address(0), ids, amounts, \"\");\n\n        uint256 fromBalance = _balances[id][from];\n        require(fromBalance >= amount, \"ERC1155: burn amount exceeds balance\");\n        unchecked {\n            _balances[id][from] = fromBalance - amount;\n        }\n\n        emit TransferSingle(operator, from, address(0), id, amount);\n\n        _afterTokenTransfer(operator, from, address(0), ids, amounts, \"\");\n    }\n\n    /**\n     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.\n     *\n     * Emits a {TransferBatch} event.\n     *\n     * Requirements:\n     *\n     * - `ids` and `amounts` must have the same length.\n     */\n    function _burnBatch(address from, uint256[] memory ids, uint256[] memory amounts) internal virtual {\n        require(from != address(0), \"ERC1155: burn from the zero address\");\n        require(ids.length == amounts.length, \"ERC1155: ids and amounts length mismatch\");\n\n        address operator = _msgSender();\n\n        _beforeTokenTransfer(operator, from, address(0), ids, amounts, \"\");\n\n        for (uint256 i = 0; i < ids.length; i++) {\n            uint256 id = ids[i];\n            uint256 amount = amounts[i];\n\n            uint256 fromBalance = _balances[id][from];\n            require(fromBalance >= amount, \"ERC1155: burn amount exceeds balance\");\n            unchecked {\n                _balances[id][from] = fromBalance - amount;\n            }\n        }\n\n        emit TransferBatch(operator, from, address(0), ids, amounts);\n\n        _afterTokenTransfer(operator, from, address(0), ids, amounts, \"\");\n    }\n\n    /**\n     * @dev Approve `operator` to operate on all of `owner` tokens\n     *\n     * Emits an {ApprovalForAll} event.\n     */\n    function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {\n        require(owner != operator, \"ERC1155: setting approval status for self\");\n        _operatorApprovals[owner][operator] = approved;\n        emit ApprovalForAll(owner, operator, approved);\n    }\n\n    /**\n     * @dev Hook that is called before any token transfer. This includes minting\n     * and burning, as well as batched variants.\n     *\n     * The same hook is called on both single and batched variants. For single\n     * transfers, the length of the `ids` and `amounts` arrays will be 1.\n     *\n     * Calling conditions (for each `id` and `amount` pair):\n     *\n     * - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * of token type `id` will be  transferred to `to`.\n     * - When `from` is zero, `amount` tokens of token type `id` will be minted\n     * for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens of token type `id`\n     * will be burned.\n     * - `from` and `to` are never both zero.\n     * - `ids` and `amounts` have the same, non-zero length.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _beforeTokenTransfer(\n        address operator,\n        address from,\n        address to,\n        uint256[] memory ids,\n        uint256[] memory amounts,\n        bytes memory data\n    ) internal virtual {}\n\n    /**\n     * @dev Hook that is called after any token transfer. This includes minting\n     * and burning, as well as batched variants.\n     *\n     * The same hook is called on both single and batched variants. For single\n     * transfers, the length of the `id` and `amount` arrays will be 1.\n     *\n     * Calling conditions (for each `id` and `amount` pair):\n     *\n     * - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * of token type `id` will be  transferred to `to`.\n     * - When `from` is zero, `amount` tokens of token type `id` will be minted\n     * for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens of token type `id`\n     * will be burned.\n     * - `from` and `to` are never both zero.\n     * - `ids` and `amounts` have the same, non-zero length.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _afterTokenTransfer(\n        address operator,\n        address from,\n        address to,\n        uint256[] memory ids,\n        uint256[] memory amounts,\n        bytes memory data\n    ) internal virtual {}\n\n    function _doSafeTransferAcceptanceCheck(\n        address operator,\n        address from,\n        address to,\n        uint256 id,\n        uint256 amount,\n        bytes memory data\n    ) private {\n        if (to.isContract()) {\n            try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {\n                if (response != IERC1155Receiver.onERC1155Received.selector) {\n                    revert(\"ERC1155: ERC1155Receiver rejected tokens\");\n                }\n            } catch Error(string memory reason) {\n                revert(reason);\n            } catch {\n                revert(\"ERC1155: transfer to non-ERC1155Receiver implementer\");\n            }\n        }\n    }\n\n    function _doSafeBatchTransferAcceptanceCheck(\n        address operator,\n        address from,\n        address to,\n        uint256[] memory ids,\n        uint256[] memory amounts,\n        bytes memory data\n    ) private {\n        if (to.isContract()) {\n            try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (\n                bytes4 response\n            ) {\n                if (response != IERC1155Receiver.onERC1155BatchReceived.selector) {\n                    revert(\"ERC1155: ERC1155Receiver rejected tokens\");\n                }\n            } catch Error(string memory reason) {\n                revert(reason);\n            } catch {\n                revert(\"ERC1155: transfer to non-ERC1155Receiver implementer\");\n            }\n        }\n    }\n\n    function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {\n        uint256[] memory array = new uint256[](1);\n        array[0] = element;\n\n        return array;\n    }\n}\n"
      },
      "@openzeppelin/contracts/token/ERC1155/extensions/ERC1155Burnable.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC1155/extensions/ERC1155Burnable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../ERC1155.sol\";\n\n/**\n * @dev Extension of {ERC1155} that allows token holders to destroy both their\n * own tokens and those that they have been approved to use.\n *\n * _Available since v3.1._\n */\nabstract contract ERC1155Burnable is ERC1155 {\n    function burn(address account, uint256 id, uint256 value) public virtual {\n        require(\n            account == _msgSender() || isApprovedForAll(account, _msgSender()),\n            \"ERC1155: caller is not token owner or approved\"\n        );\n\n        _burn(account, id, value);\n    }\n\n    function burnBatch(address account, uint256[] memory ids, uint256[] memory values) public virtual {\n        require(\n            account == _msgSender() || isApprovedForAll(account, _msgSender()),\n            \"ERC1155: caller is not token owner or approved\"\n        );\n\n        _burnBatch(account, ids, values);\n    }\n}\n"
      },
      "@openzeppelin/contracts/token/ERC1155/extensions/IERC1155MetadataURI.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC1155/extensions/IERC1155MetadataURI.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../IERC1155.sol\";\n\n/**\n * @dev Interface of the optional ERC1155MetadataExtension interface, as defined\n * in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP].\n *\n * _Available since v3.1._\n */\ninterface IERC1155MetadataURI is IERC1155 {\n    /**\n     * @dev Returns the URI for token type `id`.\n     *\n     * If the `\\{id\\}` substring is present in the URI, it must be replaced by\n     * clients with the actual token type ID.\n     */\n    function uri(uint256 id) external view returns (string memory);\n}\n"
      },
      "@openzeppelin/contracts/token/ERC1155/IERC1155.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC1155/IERC1155.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../../utils/introspection/IERC165.sol\";\n\n/**\n * @dev Required interface of an ERC1155 compliant contract, as defined in the\n * https://eips.ethereum.org/EIPS/eip-1155[EIP].\n *\n * _Available since v3.1._\n */\ninterface IERC1155 is IERC165 {\n    /**\n     * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.\n     */\n    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);\n\n    /**\n     * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all\n     * transfers.\n     */\n    event TransferBatch(\n        address indexed operator,\n        address indexed from,\n        address indexed to,\n        uint256[] ids,\n        uint256[] values\n    );\n\n    /**\n     * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to\n     * `approved`.\n     */\n    event ApprovalForAll(address indexed account, address indexed operator, bool approved);\n\n    /**\n     * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.\n     *\n     * If an {URI} event was emitted for `id`, the standard\n     * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value\n     * returned by {IERC1155MetadataURI-uri}.\n     */\n    event URI(string value, uint256 indexed id);\n\n    /**\n     * @dev Returns the amount of tokens of token type `id` owned by `account`.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     */\n    function balanceOf(address account, uint256 id) external view returns (uint256);\n\n    /**\n     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.\n     *\n     * Requirements:\n     *\n     * - `accounts` and `ids` must have the same length.\n     */\n    function balanceOfBatch(\n        address[] calldata accounts,\n        uint256[] calldata ids\n    ) external view returns (uint256[] memory);\n\n    /**\n     * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,\n     *\n     * Emits an {ApprovalForAll} event.\n     *\n     * Requirements:\n     *\n     * - `operator` cannot be the caller.\n     */\n    function setApprovalForAll(address operator, bool approved) external;\n\n    /**\n     * @dev Returns true if `operator` is approved to transfer ``account``'s tokens.\n     *\n     * See {setApprovalForAll}.\n     */\n    function isApprovedForAll(address account, address operator) external view returns (bool);\n\n    /**\n     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.\n     *\n     * Emits a {TransferSingle} event.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}.\n     * - `from` must have a balance of tokens of type `id` of at least `amount`.\n     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the\n     * acceptance magic value.\n     */\n    function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external;\n\n    /**\n     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.\n     *\n     * Emits a {TransferBatch} event.\n     *\n     * Requirements:\n     *\n     * - `ids` and `amounts` must have the same length.\n     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the\n     * acceptance magic value.\n     */\n    function safeBatchTransferFrom(\n        address from,\n        address to,\n        uint256[] calldata ids,\n        uint256[] calldata amounts,\n        bytes calldata data\n    ) external;\n}\n"
      },
      "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../../utils/introspection/IERC165.sol\";\n\n/**\n * @dev _Available since v3.1._\n */\ninterface IERC1155Receiver is IERC165 {\n    /**\n     * @dev Handles the receipt of a single ERC1155 token type. This function is\n     * called at the end of a `safeTransferFrom` after the balance has been updated.\n     *\n     * NOTE: To accept the transfer, this must return\n     * `bytes4(keccak256(\"onERC1155Received(address,address,uint256,uint256,bytes)\"))`\n     * (i.e. 0xf23a6e61, or its own function selector).\n     *\n     * @param operator The address which initiated the transfer (i.e. msg.sender)\n     * @param from The address which previously owned the token\n     * @param id The ID of the token being transferred\n     * @param value The amount of tokens being transferred\n     * @param data Additional data with no specified format\n     * @return `bytes4(keccak256(\"onERC1155Received(address,address,uint256,uint256,bytes)\"))` if transfer is allowed\n     */\n    function onERC1155Received(\n        address operator,\n        address from,\n        uint256 id,\n        uint256 value,\n        bytes calldata data\n    ) external returns (bytes4);\n\n    /**\n     * @dev Handles the receipt of a multiple ERC1155 token types. This function\n     * is called at the end of a `safeBatchTransferFrom` after the balances have\n     * been updated.\n     *\n     * NOTE: To accept the transfer(s), this must return\n     * `bytes4(keccak256(\"onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)\"))`\n     * (i.e. 0xbc197c81, or its own function selector).\n     *\n     * @param operator The address which initiated the batch transfer (i.e. msg.sender)\n     * @param from The address which previously owned the token\n     * @param ids An array containing ids of each token being transferred (order and length must match values array)\n     * @param values An array containing amounts of each token being transferred (order and length must match ids array)\n     * @param data Additional data with no specified format\n     * @return `bytes4(keccak256(\"onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)\"))` if transfer is allowed\n     */\n    function onERC1155BatchReceived(\n        address operator,\n        address from,\n        uint256[] calldata ids,\n        uint256[] calldata values,\n        bytes calldata data\n    ) external returns (bytes4);\n}\n"
      },
      "@openzeppelin/contracts/utils/Address.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n    /**\n     * @dev Returns true if `account` is a contract.\n     *\n     * [IMPORTANT]\n     * ====\n     * It is unsafe to assume that an address for which this function returns\n     * false is an externally-owned account (EOA) and not a contract.\n     *\n     * Among others, `isContract` will return false for the following\n     * types of addresses:\n     *\n     *  - an externally-owned account\n     *  - a contract in construction\n     *  - an address where a contract will be created\n     *  - an address where a contract lived, but was destroyed\n     *\n     * Furthermore, `isContract` will also return true if the target contract within\n     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,\n     * which only has an effect at the end of a transaction.\n     * ====\n     *\n     * [IMPORTANT]\n     * ====\n     * You shouldn't rely on `isContract` to protect against flash loan attacks!\n     *\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n     * constructor.\n     * ====\n     */\n    function isContract(address account) internal view returns (bool) {\n        // This method relies on extcodesize/address.code.length, which returns 0\n        // for contracts in construction, since the code is only stored at the end\n        // of the constructor execution.\n\n        return account.code.length > 0;\n    }\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        require(success, \"Address: unable to send value, recipient may have reverted\");\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason, it is bubbled up by this\n     * function (like regular Solidity function calls).\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, \"Address: low-level call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n     * `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        require(address(this).balance >= value, \"Address: insufficient balance for call\");\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        return functionStaticCall(target, data, \"Address: low-level static call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\n     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\n     *\n     * _Available since v4.8._\n     */\n    function verifyCallResultFromTarget(\n        address target,\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        if (success) {\n            if (returndata.length == 0) {\n                // only check isContract if the call was successful and the return data is empty\n                // otherwise we already know that it was a contract\n                require(isContract(target), \"Address: call to non-contract\");\n            }\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    /**\n     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\n     * revert reason or using the provided one.\n     *\n     * _Available since v4.3._\n     */\n    function verifyCallResult(\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal pure returns (bytes memory) {\n        if (success) {\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    function _revert(bytes memory returndata, string memory errorMessage) private pure {\n        // Look for revert reason and bubble it up if present\n        if (returndata.length > 0) {\n            // The easiest way to bubble the revert reason is using memory via assembly\n            /// @solidity memory-safe-assembly\n            assembly {\n                let returndata_size := mload(returndata)\n                revert(add(32, returndata), returndata_size)\n            }\n        } else {\n            revert(errorMessage);\n        }\n    }\n}\n"
      },
      "@openzeppelin/contracts/utils/Context.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n}\n"
      },
      "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.2) (utils/cryptography/MerkleProof.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev These functions deal with verification of Merkle Tree proofs.\n *\n * The tree and the proofs can be generated using our\n * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].\n * You will find a quickstart guide in the readme.\n *\n * WARNING: You should avoid using leaf values that are 64 bytes long prior to\n * hashing, or use a hash function other than keccak256 for hashing leaves.\n * This is because the concatenation of a sorted pair of internal nodes in\n * the merkle tree could be reinterpreted as a leaf value.\n * OpenZeppelin's JavaScript library generates merkle trees that are safe\n * against this attack out of the box.\n */\nlibrary MerkleProof {\n    /**\n     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree\n     * defined by `root`. For this, a `proof` must be provided, containing\n     * sibling hashes on the branch from the leaf to the root of the tree. Each\n     * pair of leaves and each pair of pre-images are assumed to be sorted.\n     */\n    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\n        return processProof(proof, leaf) == root;\n    }\n\n    /**\n     * @dev Calldata version of {verify}\n     *\n     * _Available since v4.7._\n     */\n    function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {\n        return processProofCalldata(proof, leaf) == root;\n    }\n\n    /**\n     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up\n     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt\n     * hash matches the root of the tree. When processing the proof, the pairs\n     * of leafs & pre-images are assumed to be sorted.\n     *\n     * _Available since v4.4._\n     */\n    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {\n        bytes32 computedHash = leaf;\n        for (uint256 i = 0; i < proof.length; i++) {\n            computedHash = _hashPair(computedHash, proof[i]);\n        }\n        return computedHash;\n    }\n\n    /**\n     * @dev Calldata version of {processProof}\n     *\n     * _Available since v4.7._\n     */\n    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {\n        bytes32 computedHash = leaf;\n        for (uint256 i = 0; i < proof.length; i++) {\n            computedHash = _hashPair(computedHash, proof[i]);\n        }\n        return computedHash;\n    }\n\n    /**\n     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a merkle tree defined by\n     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.\n     *\n     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.\n     *\n     * _Available since v4.7._\n     */\n    function multiProofVerify(\n        bytes32[] memory proof,\n        bool[] memory proofFlags,\n        bytes32 root,\n        bytes32[] memory leaves\n    ) internal pure returns (bool) {\n        return processMultiProof(proof, proofFlags, leaves) == root;\n    }\n\n    /**\n     * @dev Calldata version of {multiProofVerify}\n     *\n     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.\n     *\n     * _Available since v4.7._\n     */\n    function multiProofVerifyCalldata(\n        bytes32[] calldata proof,\n        bool[] calldata proofFlags,\n        bytes32 root,\n        bytes32[] memory leaves\n    ) internal pure returns (bool) {\n        return processMultiProofCalldata(proof, proofFlags, leaves) == root;\n    }\n\n    /**\n     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction\n     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another\n     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false\n     * respectively.\n     *\n     * CAUTION: Not all merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree\n     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the\n     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).\n     *\n     * _Available since v4.7._\n     */\n    function processMultiProof(\n        bytes32[] memory proof,\n        bool[] memory proofFlags,\n        bytes32[] memory leaves\n    ) internal pure returns (bytes32 merkleRoot) {\n        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by\n        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the\n        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of\n        // the merkle tree.\n        uint256 leavesLen = leaves.length;\n        uint256 proofLen = proof.length;\n        uint256 totalHashes = proofFlags.length;\n\n        // Check proof validity.\n        require(leavesLen + proofLen - 1 == totalHashes, \"MerkleProof: invalid multiproof\");\n\n        // The xxxPos values are \"pointers\" to the next value to consume in each array. All accesses are done using\n        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's \"pop\".\n        bytes32[] memory hashes = new bytes32[](totalHashes);\n        uint256 leafPos = 0;\n        uint256 hashPos = 0;\n        uint256 proofPos = 0;\n        // At each step, we compute the next hash using two values:\n        // - a value from the \"main queue\". If not all leaves have been consumed, we get the next leaf, otherwise we\n        //   get the next hash.\n        // - depending on the flag, either another value from the \"main queue\" (merging branches) or an element from the\n        //   `proof` array.\n        for (uint256 i = 0; i < totalHashes; i++) {\n            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];\n            bytes32 b = proofFlags[i]\n                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])\n                : proof[proofPos++];\n            hashes[i] = _hashPair(a, b);\n        }\n\n        if (totalHashes > 0) {\n            require(proofPos == proofLen, \"MerkleProof: invalid multiproof\");\n            unchecked {\n                return hashes[totalHashes - 1];\n            }\n        } else if (leavesLen > 0) {\n            return leaves[0];\n        } else {\n            return proof[0];\n        }\n    }\n\n    /**\n     * @dev Calldata version of {processMultiProof}.\n     *\n     * CAUTION: Not all merkle trees admit multiproofs. See {processMultiProof} for details.\n     *\n     * _Available since v4.7._\n     */\n    function processMultiProofCalldata(\n        bytes32[] calldata proof,\n        bool[] calldata proofFlags,\n        bytes32[] memory leaves\n    ) internal pure returns (bytes32 merkleRoot) {\n        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by\n        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the\n        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of\n        // the merkle tree.\n        uint256 leavesLen = leaves.length;\n        uint256 proofLen = proof.length;\n        uint256 totalHashes = proofFlags.length;\n\n        // Check proof validity.\n        require(leavesLen + proofLen - 1 == totalHashes, \"MerkleProof: invalid multiproof\");\n\n        // The xxxPos values are \"pointers\" to the next value to consume in each array. All accesses are done using\n        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's \"pop\".\n        bytes32[] memory hashes = new bytes32[](totalHashes);\n        uint256 leafPos = 0;\n        uint256 hashPos = 0;\n        uint256 proofPos = 0;\n        // At each step, we compute the next hash using two values:\n        // - a value from the \"main queue\". If not all leaves have been consumed, we get the next leaf, otherwise we\n        //   get the next hash.\n        // - depending on the flag, either another value from the \"main queue\" (merging branches) or an element from the\n        //   `proof` array.\n        for (uint256 i = 0; i < totalHashes; i++) {\n            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];\n            bytes32 b = proofFlags[i]\n                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])\n                : proof[proofPos++];\n            hashes[i] = _hashPair(a, b);\n        }\n\n        if (totalHashes > 0) {\n            require(proofPos == proofLen, \"MerkleProof: invalid multiproof\");\n            unchecked {\n                return hashes[totalHashes - 1];\n            }\n        } else if (leavesLen > 0) {\n            return leaves[0];\n        } else {\n            return proof[0];\n        }\n    }\n\n    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {\n        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);\n    }\n\n    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            mstore(0x00, a)\n            mstore(0x20, b)\n            value := keccak256(0x00, 0x40)\n        }\n    }\n}\n"
      },
      "@openzeppelin/contracts/utils/introspection/ERC165.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC165.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n *\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\n */\nabstract contract ERC165 is IERC165 {\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n        return interfaceId == type(IERC165).interfaceId;\n    }\n}\n"
      },
      "@openzeppelin/contracts/utils/introspection/IERC165.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"
      },
      "@openzeppelin/contracts/utils/math/Math.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n    enum Rounding {\n        Down, // Toward negative infinity\n        Up, // Toward infinity\n        Zero // Toward zero\n    }\n\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a > b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b) / 2 can overflow.\n        return (a & b) + (a ^ b) / 2;\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds up instead\n     * of rounding down.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b - 1) / b can overflow on addition, so we distribute.\n        return a == 0 ? 0 : (a - 1) / b + 1;\n    }\n\n    /**\n     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\n     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\n     * with further edits by Uniswap Labs also under MIT license.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {\n        unchecked {\n            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\n            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n            // variables such that product = prod1 * 2^256 + prod0.\n            uint256 prod0; // Least significant 256 bits of the product\n            uint256 prod1; // Most significant 256 bits of the product\n            assembly {\n                let mm := mulmod(x, y, not(0))\n                prod0 := mul(x, y)\n                prod1 := sub(sub(mm, prod0), lt(mm, prod0))\n            }\n\n            // Handle non-overflow cases, 256 by 256 division.\n            if (prod1 == 0) {\n                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\n                // The surrounding unchecked block does not change this fact.\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\n                return prod0 / denominator;\n            }\n\n            // Make sure the result is less than 2^256. Also prevents denominator == 0.\n            require(denominator > prod1, \"Math: mulDiv overflow\");\n\n            ///////////////////////////////////////////////\n            // 512 by 256 division.\n            ///////////////////////////////////////////////\n\n            // Make division exact by subtracting the remainder from [prod1 prod0].\n            uint256 remainder;\n            assembly {\n                // Compute remainder using mulmod.\n                remainder := mulmod(x, y, denominator)\n\n                // Subtract 256 bit number from 512 bit number.\n                prod1 := sub(prod1, gt(remainder, prod0))\n                prod0 := sub(prod0, remainder)\n            }\n\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\n            // See https://cs.stackexchange.com/q/138556/92363.\n\n            // Does not overflow because the denominator cannot be zero at this stage in the function.\n            uint256 twos = denominator & (~denominator + 1);\n            assembly {\n                // Divide denominator by twos.\n                denominator := div(denominator, twos)\n\n                // Divide [prod1 prod0] by twos.\n                prod0 := div(prod0, twos)\n\n                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\n                twos := add(div(sub(0, twos), twos), 1)\n            }\n\n            // Shift in bits from prod1 into prod0.\n            prod0 |= prod1 * twos;\n\n            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\n            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\n            // four bits. That is, denominator * inv = 1 mod 2^4.\n            uint256 inverse = (3 * denominator) ^ 2;\n\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\n            // in modular arithmetic, doubling the correct bits in each step.\n            inverse *= 2 - denominator * inverse; // inverse mod 2^8\n            inverse *= 2 - denominator * inverse; // inverse mod 2^16\n            inverse *= 2 - denominator * inverse; // inverse mod 2^32\n            inverse *= 2 - denominator * inverse; // inverse mod 2^64\n            inverse *= 2 - denominator * inverse; // inverse mod 2^128\n            inverse *= 2 - denominator * inverse; // inverse mod 2^256\n\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\n            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\n            // is no longer required.\n            result = prod0 * inverse;\n            return result;\n        }\n    }\n\n    /**\n     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\n     */\n    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {\n        uint256 result = mulDiv(x, y, denominator);\n        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\n            result += 1;\n        }\n        return result;\n    }\n\n    /**\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\n     *\n     * Inspired by Henry S. Warren, Jr.'s \"Hacker's Delight\" (Chapter 11).\n     */\n    function sqrt(uint256 a) internal pure returns (uint256) {\n        if (a == 0) {\n            return 0;\n        }\n\n        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\n        //\n        // We know that the \"msb\" (most significant bit) of our target number `a` is a power of 2 such that we have\n        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\n        //\n        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\n        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\n        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\n        //\n        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\n        uint256 result = 1 << (log2(a) >> 1);\n\n        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\n        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\n        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\n        // into the expected uint128 result.\n        unchecked {\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            return min(result, a / result);\n        }\n    }\n\n    /**\n     * @notice Calculates sqrt(a), following the selected rounding direction.\n     */\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = sqrt(a);\n            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 128;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 64;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 32;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 16;\n            }\n            if (value >> 8 > 0) {\n                value >>= 8;\n                result += 8;\n            }\n            if (value >> 4 > 0) {\n                value >>= 4;\n                result += 4;\n            }\n            if (value >> 2 > 0) {\n                value >>= 2;\n                result += 2;\n            }\n            if (value >> 1 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log2(value);\n            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 10, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >= 10 ** 64) {\n                value /= 10 ** 64;\n                result += 64;\n            }\n            if (value >= 10 ** 32) {\n                value /= 10 ** 32;\n                result += 32;\n            }\n            if (value >= 10 ** 16) {\n                value /= 10 ** 16;\n                result += 16;\n            }\n            if (value >= 10 ** 8) {\n                value /= 10 ** 8;\n                result += 8;\n            }\n            if (value >= 10 ** 4) {\n                value /= 10 ** 4;\n                result += 4;\n            }\n            if (value >= 10 ** 2) {\n                value /= 10 ** 2;\n                result += 2;\n            }\n            if (value >= 10 ** 1) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log10(value);\n            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 256, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     *\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n     */\n    function log256(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 16;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 8;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 4;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 2;\n            }\n            if (value >> 8 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log256(value);\n            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);\n        }\n    }\n}\n"
      },
      "@openzeppelin/contracts/utils/math/SignedMath.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard signed math utilities missing in the Solidity language.\n */\nlibrary SignedMath {\n    /**\n     * @dev Returns the largest of two signed numbers.\n     */\n    function max(int256 a, int256 b) internal pure returns (int256) {\n        return a > b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two signed numbers.\n     */\n    function min(int256 a, int256 b) internal pure returns (int256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two signed numbers without overflow.\n     * The result is rounded towards zero.\n     */\n    function average(int256 a, int256 b) internal pure returns (int256) {\n        // Formula from the book \"Hacker's Delight\"\n        int256 x = (a & b) + ((a ^ b) >> 1);\n        return x + (int256(uint256(x) >> 255) & (a ^ b));\n    }\n\n    /**\n     * @dev Returns the absolute unsigned value of a signed value.\n     */\n    function abs(int256 n) internal pure returns (uint256) {\n        unchecked {\n            // must be unchecked in order to support `n = type(int256).min`\n            return uint256(n >= 0 ? n : -n);\n        }\n    }\n}\n"
      },
      "@openzeppelin/contracts/utils/Strings.sol": {
        "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./math/Math.sol\";\nimport \"./math/SignedMath.sol\";\n\n/**\n * @dev String operations.\n */\nlibrary Strings {\n    bytes16 private constant _SYMBOLS = \"0123456789abcdef\";\n    uint8 private constant _ADDRESS_LENGTH = 20;\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n     */\n    function toString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            uint256 length = Math.log10(value) + 1;\n            string memory buffer = new string(length);\n            uint256 ptr;\n            /// @solidity memory-safe-assembly\n            assembly {\n                ptr := add(buffer, add(32, length))\n            }\n            while (true) {\n                ptr--;\n                /// @solidity memory-safe-assembly\n                assembly {\n                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\n                }\n                value /= 10;\n                if (value == 0) break;\n            }\n            return buffer;\n        }\n    }\n\n    /**\n     * @dev Converts a `int256` to its ASCII `string` decimal representation.\n     */\n    function toString(int256 value) internal pure returns (string memory) {\n        return string(abi.encodePacked(value < 0 ? \"-\" : \"\", toString(SignedMath.abs(value))));\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            return toHexString(value, Math.log256(value) + 1);\n        }\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n     */\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n        bytes memory buffer = new bytes(2 * length + 2);\n        buffer[0] = \"0\";\n        buffer[1] = \"x\";\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\n            buffer[i] = _SYMBOLS[value & 0xf];\n            value >>= 4;\n        }\n        require(value == 0, \"Strings: hex length insufficient\");\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.\n     */\n    function toHexString(address addr) internal pure returns (string memory) {\n        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);\n    }\n\n    /**\n     * @dev Returns true if the two strings are equal.\n     */\n    function equal(string memory a, string memory b) internal pure returns (bool) {\n        return keccak256(bytes(a)) == keccak256(bytes(b));\n    }\n}\n"
      },
      "closedsea/src/OperatorFilterer.sol": {
        "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n/// @notice Optimized and flexible operator filterer to abide to OpenSea's\n/// mandatory on-chain royalty enforcement in order for new collections to\n/// receive royalties.\n/// For more information, see:\n/// See: https://github.com/ProjectOpenSea/operator-filter-registry\nabstract contract OperatorFilterer {\n    /// @dev The default OpenSea operator blocklist subscription.\n    address internal constant _DEFAULT_SUBSCRIPTION = 0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6;\n\n    /// @dev The OpenSea operator filter registry.\n    address internal constant _OPERATOR_FILTER_REGISTRY = 0x000000000000AAeB6D7670E522A718067333cd4E;\n\n    /// @dev Registers the current contract to OpenSea's operator filter,\n    /// and subscribe to the default OpenSea operator blocklist.\n    /// Note: Will not revert nor update existing settings for repeated registration.\n    function _registerForOperatorFiltering() internal virtual {\n        _registerForOperatorFiltering(_DEFAULT_SUBSCRIPTION, true);\n    }\n\n    /// @dev Registers the current contract to OpenSea's operator filter.\n    /// Note: Will not revert nor update existing settings for repeated registration.\n    function _registerForOperatorFiltering(address subscriptionOrRegistrantToCopy, bool subscribe)\n        internal\n        virtual\n    {\n        /// @solidity memory-safe-assembly\n        assembly {\n            let functionSelector := 0x7d3e3dbe // `registerAndSubscribe(address,address)`.\n\n            // Clean the upper 96 bits of `subscriptionOrRegistrantToCopy` in case they are dirty.\n            subscriptionOrRegistrantToCopy := shr(96, shl(96, subscriptionOrRegistrantToCopy))\n\n            for {} iszero(subscribe) {} {\n                if iszero(subscriptionOrRegistrantToCopy) {\n                    functionSelector := 0x4420e486 // `register(address)`.\n                    break\n                }\n                functionSelector := 0xa0af2903 // `registerAndCopyEntries(address,address)`.\n                break\n            }\n            // Store the function selector.\n            mstore(0x00, shl(224, functionSelector))\n            // Store the `address(this)`.\n            mstore(0x04, address())\n            // Store the `subscriptionOrRegistrantToCopy`.\n            mstore(0x24, subscriptionOrRegistrantToCopy)\n            // Register into the registry.\n            if iszero(call(gas(), _OPERATOR_FILTER_REGISTRY, 0, 0x00, 0x44, 0x00, 0x04)) {\n                // If the function selector has not been overwritten,\n                // it is an out-of-gas error.\n                if eq(shr(224, mload(0x00)), functionSelector) {\n                    // To prevent gas under-estimation.\n                    revert(0, 0)\n                }\n            }\n            // Restore the part of the free memory pointer that was overwritten,\n            // which is guaranteed to be zero, because of Solidity's memory size limits.\n            mstore(0x24, 0)\n        }\n    }\n\n    /// @dev Modifier to guard a function and revert if the caller is a blocked operator.\n    modifier onlyAllowedOperator(address from) virtual {\n        if (from != msg.sender) {\n            if (!_isPriorityOperator(msg.sender)) {\n                if (_operatorFilteringEnabled()) _revertIfBlocked(msg.sender);\n            }\n        }\n        _;\n    }\n\n    /// @dev Modifier to guard a function from approving a blocked operator..\n    modifier onlyAllowedOperatorApproval(address operator) virtual {\n        if (!_isPriorityOperator(operator)) {\n            if (_operatorFilteringEnabled()) _revertIfBlocked(operator);\n        }\n        _;\n    }\n\n    /// @dev Helper function that reverts if the `operator` is blocked by the registry.\n    function _revertIfBlocked(address operator) private view {\n        /// @solidity memory-safe-assembly\n        assembly {\n            // Store the function selector of `isOperatorAllowed(address,address)`,\n            // shifted left by 6 bytes, which is enough for 8tb of memory.\n            // We waste 6-3 = 3 bytes to save on 6 runtime gas (PUSH1 0x224 SHL).\n            mstore(0x00, 0xc6171134001122334455)\n            // Store the `address(this)`.\n            mstore(0x1a, address())\n            // Store the `operator`.\n            mstore(0x3a, operator)\n\n            // `isOperatorAllowed` always returns true if it does not revert.\n            if iszero(staticcall(gas(), _OPERATOR_FILTER_REGISTRY, 0x16, 0x44, 0x00, 0x00)) {\n                // Bubble up the revert if the staticcall reverts.\n                returndatacopy(0x00, 0x00, returndatasize())\n                revert(0x00, returndatasize())\n            }\n\n            // We'll skip checking if `from` is inside the blacklist.\n            // Even though that can block transferring out of wrapper contracts,\n            // we don't want tokens to be stuck.\n\n            // Restore the part of the free memory pointer that was overwritten,\n            // which is guaranteed to be zero, if less than 8tb of memory is used.\n            mstore(0x3a, 0)\n        }\n    }\n\n    /// @dev For deriving contracts to override, so that operator filtering\n    /// can be turned on / off.\n    /// Returns true by default.\n    function _operatorFilteringEnabled() internal view virtual returns (bool) {\n        return true;\n    }\n\n    /// @dev For deriving contracts to override, so that preferred marketplaces can\n    /// skip operator filtering, helping users save gas.\n    /// Returns false for all inputs by default.\n    function _isPriorityOperator(address) internal view virtual returns (bool) {\n        return false;\n    }\n}\n"
      },
      "contracts/AuxInfoStorage.sol": {
        "content": "// SPDX-License-Identifier: MIT\r\npragma solidity ^0.8.11;\r\n\r\nerror InvalidAuxInfo(string);\r\nerror InvalidExtraData(uint256);\r\nerror CannotOverwriteData();\r\n\r\n/**\r\n * @title AuxInfoStorage\r\n * @author @NiftyMike | @NFTCulture\r\n * @dev This is a utility class for storing and retrieving auxInfo and extraData values.\r\n */\r\nabstract contract AuxInfoStorage {\r\n    bytes20[] private _auxData;\r\n\r\n    constructor() {\r\n        _auxData = new bytes20[](100);\r\n    }\r\n\r\n    function hasAuxData(uint256 extraData) external view returns (bool) {\r\n        return _hasAuxData(extraData);\r\n    }\r\n\r\n    function _hasAuxData(uint256 extraData) internal view returns (bool) {\r\n        if (extraData == 0 || extraData > 100) return false;\r\n        if (_auxData[extraData - 1] == bytes20(0)) return false;\r\n        return true;\r\n    }\r\n\r\n    function readFromAux(uint256 extraData) external view returns (string memory) {\r\n        return _readFromAux(extraData);\r\n    }\r\n\r\n    function _readFromAux(uint256 extraData) internal view returns (string memory) {\r\n        if (extraData == 0 || extraData > 100) return '';\r\n        bytes20 aux = _auxData[extraData - 1];\r\n        if (aux == bytes20(0)) return '';\r\n        return string(bytes.concat(aux));\r\n    }\r\n\r\n    function _storeToAux(uint256 extraData, string memory auxInfo, bool force) internal {\r\n        if (extraData == 0 || extraData > 100) revert InvalidExtraData(extraData);\r\n        if (bytes(auxInfo).length != 20) revert InvalidAuxInfo(auxInfo);\r\n        if (!force && _hasAuxData(extraData)) revert CannotOverwriteData();\r\n        _auxData[extraData - 1] = bytes20(bytes(auxInfo));\r\n    }\r\n\r\n    function _deleteAux(uint256 extraData) internal {\r\n        if (extraData == 0 || extraData > 100) revert InvalidExtraData(extraData);\r\n        delete _auxData[extraData - 1];\r\n    }\r\n}\r\n"
      },
      "contracts/EncodingHelper.sol": {
        "content": "// SPDX-License-Identifier: MIT\r\npragma solidity ^0.8.11;\r\n\r\nerror InvalidLength(string);\r\n\r\n/**\r\n * @title EncodingHelper\r\n * @author @NiftyMike | @NFTCulture\r\n * @dev This is a utility class for encoding and decoding specially built strings to uint256 and back.\r\n * - Handles 16 byte Salt strings.\r\n * - Handles 20 byte AuxInfo strings.\r\n */\r\nabstract contract EncodingHelper {\r\n    function encodeSaltToUint256(string memory salt) external pure returns (uint256) {\r\n        return _encodeSaltToUint256(salt);\r\n    }\r\n\r\n    function _encodeSaltToUint256(string memory salt) internal pure returns (uint256) {\r\n        if (bytes(salt).length != 16) revert InvalidLength(salt);\r\n        return uint128(bytes16(bytes(salt)));\r\n    }\r\n\r\n    function encodeAuxInfoToUint256(string memory auxInfo) external pure returns (uint256) {\r\n        return _encodeAuxInfoToUint256(auxInfo);\r\n    }\r\n\r\n    function _encodeAuxInfoToUint256(string memory auxInfo) internal pure returns (uint256) {\r\n        if (bytes(auxInfo).length != 20) revert InvalidLength(auxInfo);\r\n        return uint160(bytes20(bytes(auxInfo)));\r\n    }\r\n\r\n    function decodeSaltFromUint256(uint256 saltAsInt) external pure returns (string memory) {\r\n        return _decodeSaltFromUint256(saltAsInt);\r\n    }\r\n\r\n    function _decodeSaltFromUint256(uint256 saltAsInt) internal pure returns (string memory) {\r\n        return string(bytes.concat(bytes16(uint128(saltAsInt))));\r\n    }\r\n\r\n    function decodeAuxInfoFromUint256(uint256 auxInfoAsInt) external pure returns (string memory) {\r\n        return _decodeAuxInfoFromUint256(auxInfoAsInt);\r\n    }\r\n\r\n    function _decodeAuxInfoFromUint256(uint256 auxInfoAsInt) internal pure returns (string memory) {\r\n        return string(bytes.concat(bytes20(uint160(auxInfoAsInt))));\r\n    }\r\n}\r\n"
      },
      "contracts/MaintainableAuxInfoStorage.sol": {
        "content": "// SPDX-License-Identifier: MIT\r\npragma solidity ^0.8.11;\r\n\r\n// NFTC Prerelease Contracts\r\nimport '@nftculture/nftc-contracts-private/contracts/access/v2/OwnableDeferral.sol';\r\n\r\n// Local References\r\nimport './AuxInfoStorage.sol';\r\nimport './EncodingHelper.sol';\r\n\r\n/**\r\n * @title MaintainableAuxInfoStorage\r\n * @author @NiftyMike | @NFTCulture\r\n * @dev Extension contract that enables maintenance of the data stored in AuxInfoStorage.\r\n */\r\nabstract contract MaintainableAuxInfoStorage is AuxInfoStorage, EncodingHelper, OwnableDeferral {\r\n    function storeToAux(uint256 extraData, string memory auxInfo, bool force) external isOwner {\r\n        _storeToAux(extraData, auxInfo, force);\r\n    }\r\n\r\n    function deleteAux(uint256 extraData) external isOwner {\r\n        _deleteAux(extraData);\r\n    }\r\n}\r\n"
      },
      "contracts/NBNFTA2/NFTBookArtistTwoBase.sol": {
        "content": "// SPDX-License-Identifier: MIT\r\npragma solidity ^0.8.11;\r\n\r\n// NFTC Prerelease Contracts\r\nimport '@nftculture/nftc-contracts-private/contracts/metadata/v2/metadata-consumers/SingletonMetadataConsumer.sol';\r\nimport '@nftculture/nftc-contracts-private/contracts/token/v4/minter-extensions/FullInteractiveNFTMinter_1155Fixed.sol';\r\nimport '@nftculture/nftc-contracts-private/contracts/token/v4/user-interactive/IMintable.sol';\r\nimport '@nftculture/nftc-contracts-private/contracts/token/v4/user-interactive/merkle/PhaseOneIsAuxillary.sol';\r\nimport '@nftculture/nftc-contracts-private/contracts/token/v4/user-interactive/merkle/PhaseTwoIsAuxillary.sol';\r\nimport '@nftculture/nftc-contracts-private/contracts/token-phasing/v2/static-extensions/StaticPhasedMintThree.sol';\r\n\r\n// OZ Libraries\r\nimport '@openzeppelin/contracts/security/ReentrancyGuard.sol';\r\nimport '@openzeppelin/contracts/utils/Strings.sol';\r\n\r\n// Local References\r\nimport '../MaintainableAuxInfoStorage.sol';\r\n\r\n// Error Codes\r\nerror ExceedsBatchSize();\r\nerror ExceedsSupplyCap();\r\nerror InvalidPayment();\r\nerror InvalidTokenId();\r\nerror MintNotAvailable();\r\nerror ClaimAlreadyMinted();\r\n\r\n/**\r\n * @title NFTBookArtistTwoBase\r\n * @author @NiftyMike | @NFTCulture\r\n * @dev ERC721a Implementation with @NFTCulture standardized components.\r\n *\r\n * Public Mint is Phase Three.\r\n */\r\nabstract contract NFTBookArtistTwoBase is\r\n    IMintable,\r\n    FullInteractiveNFTMinter_1155Fixed,\r\n    SingletonMetadataConsumer,\r\n    StaticPhasedMintThree,\r\n    PhaseOneIsAuxillary,\r\n    PhaseTwoIsAuxillary,\r\n    MaintainableAuxInfoStorage,\r\n    ReentrancyGuard\r\n{\r\n    using Strings for uint256;\r\n\r\n    uint256 private constant MAX_RESERVE_BATCH_SIZE = 1;\r\n\r\n    uint256 private constant PHASE_ONE_BATCH_SIZE = 1;\r\n    uint256 private constant PHASE_ONE_SUPPLY_CAP = 100;\r\n\r\n    uint256 private constant PHASE_TWO_BATCH_SIZE = 1;\r\n    uint256 private constant PHASE_TWO_SUPPLY_CAP = 100;\r\n\r\n    uint256 private constant PUBLIC_MINT_BATCH_SIZE = 1;\r\n    uint256 private constant PUBLIC_MINT_SUPPLY_CAP = 100;\r\n\r\n    constructor(\r\n        string memory __baseURI,\r\n        uint256 __fixedTokenId,\r\n        uint256[] memory __phasePrices\r\n    )\r\n        ERC1155(__baseURI)\r\n        FullInteractiveNFTMinter_1155Fixed(__fixedTokenId)\r\n        StaticPhasedMintThree(__phasePrices[0], __phasePrices[1], __phasePrices[2])\r\n    {\r\n        _registerForOperatorFiltering();\r\n        operatorFilteringEnabled = true;\r\n    }\r\n\r\n    function nftcContractDefinition() external pure override returns (string memory) {\r\n        // NFTC Contract Definition for front-end websites.\r\n        return\r\n            string.concat(\r\n                '{',\r\n                '\"ncdVersion\":1,', // NFTC Contract Definition version.\r\n                '\"phases\":3,', // # of mint phases?\r\n                '\"type\":\"Static\",', // do tokens have a type? [Static | Expandable]\r\n                '\"openEdition\":false', // is collection an open edition? [true | false]\r\n                '}'\r\n            );\r\n    }\r\n\r\n    /**\r\n     * Not relevant to typical static contracts.\r\n     */\r\n    function nftcTokenTypeList() external pure override returns (uint64[] memory) {\r\n        return new uint64[](0);\r\n    }\r\n\r\n    /**\r\n     * Not relevant to typical static contracts.\r\n     */\r\n    function nftcTokenTypeDefinition(\r\n        uint64\r\n    ) external pure override returns (FlavorInfo.FlavorInfoV4 memory emptyFlavor) {\r\n        return emptyFlavor;\r\n    }\r\n\r\n    /**\r\n     * @notice Max number of tokens that can exist.\r\n     */\r\n    function maxSupply() external pure returns (uint256) {\r\n        return PUBLIC_MINT_SUPPLY_CAP;\r\n    }\r\n\r\n    function phaseOneBatchSize() external pure returns (uint256) {\r\n        return PHASE_ONE_BATCH_SIZE;\r\n    }\r\n\r\n    function phaseTwoBatchSize() external pure returns (uint256) {\r\n        return PHASE_TWO_BATCH_SIZE;\r\n    }\r\n\r\n    function publicMintBatchSize() external pure returns (uint256) {\r\n        return PUBLIC_MINT_BATCH_SIZE;\r\n    }\r\n\r\n    function uri(uint256 tokenId) public view virtual override returns (string memory) {\r\n        if (tokenId != _getFixedTokenId()) revert InvalidTokenId();\r\n\r\n        // ERC1155: All tokens get the exact same metadata.\r\n        uint64 tokenType = _getMetadataProducer(address(this), tokenId).getTokenTypeForToken(address(this), tokenId);\r\n        return\r\n            _getMetadataProducer(address(this), tokenId).getJsonAsEncodedString(address(this), tokenType, tokenId, 0);\r\n    }\r\n\r\n    function setMerkleRoots(bytes32 __phaseOneRoot, bytes32 __phaseTwoRoot) external isOwner {\r\n        _setMerkleRoots(__phaseOneRoot, __phaseTwoRoot);\r\n    }\r\n\r\n    function _setMerkleRoots(bytes32 __phaseOneRoot, bytes32 __phaseTwoRoot) internal {\r\n        if (__phaseOneRoot != 0) {\r\n            _setPhaseOneRoot(__phaseOneRoot);\r\n        }\r\n\r\n        if (__phaseTwoRoot != 0) {\r\n            _setPhaseTwoRoot(__phaseTwoRoot);\r\n        }\r\n    }\r\n\r\n    function _getPackedPurchasesAs64(\r\n        address\r\n    ) internal view virtual override(PhaseOneIsAuxillary, PhaseTwoIsAuxillary) returns (uint64) {\r\n        return 0; // Not tracking phase-specific purchases.\r\n    }\r\n\r\n    /**\r\n     * @notice Owner: reserve tokens for team.\r\n     *\r\n     * @param bookNumber - extraData for the mint\r\n     * @param auxInfoAsInt - auxInfo for the mint, encoded to a uint256\r\n     * @param destinations - addresses to send tokens to.\r\n     */\r\n    function reserveTokens(\r\n        uint256 bookNumber,\r\n        uint256 auxInfoAsInt,\r\n        address[] calldata destinations\r\n    ) external payable override isOwner {\r\n        uint256 count = 1;\r\n        if (0 >= count || count > MAX_RESERVE_BATCH_SIZE || destinations.length > 1) revert ExceedsBatchSize();\r\n        if (_totalMinted() + (destinations.length * count) > PUBLIC_MINT_SUPPLY_CAP) revert ExceedsSupplyCap();\r\n\r\n        if (auxInfoAsInt > 0) {\r\n            if (_hasAuxData(bookNumber)) revert ClaimAlreadyMinted();\r\n            _storeToAux(bookNumber, _decodeAuxInfoFromUint256(auxInfoAsInt), false);\r\n        } else {\r\n            // Will need to perform maintenance later, not recommended.\r\n        }\r\n\r\n        _internalMintTokens(destinations[0], count, bookNumber);\r\n    }\r\n\r\n    /**\r\n     * @dev - not used\r\n     */\r\n    function premintTokens(uint256, uint256, address[] calldata) external payable override {\r\n        revert MintNotAvailable();\r\n    }\r\n\r\n    /**\r\n     * @dev - not used\r\n     */\r\n    function publicMintTokens(uint256, uint256, uint256, address) external payable override {\r\n        revert MintNotAvailable();\r\n    }\r\n\r\n    /**\r\n     * @dev - not used\r\n     */\r\n    function publicMintTokensTo(uint256, uint256, uint256, address, address) external payable override {\r\n        revert MintNotAvailable();\r\n    }\r\n\r\n    /**\r\n     * @notice Mint tokens (Phase One) - purchase bound by terms & conditions of project.\r\n     *\r\n     * @param proof the merkle proof for this purchase.\r\n     * @param count the number of tokens to mint.\r\n     */\r\n    function phaseOneMintTokens(\r\n        bytes32[] calldata proof,\r\n        string calldata auxInfo,\r\n        uint256 extraData,\r\n        uint256 count,\r\n        uint256 flavorId,\r\n        uint256 validationData,\r\n        address provider\r\n    ) external payable nonReentrant isPhaseOne {\r\n        _phaseOneMintTokensTo(proof, auxInfo, extraData, count, flavorId, validationData, provider, msg.sender);\r\n    }\r\n\r\n    /**\r\n     * @notice Mint tokens (Phase One) - purchase bound by terms & conditions of project.\r\n     *\r\n     * @param proof the merkle proof for this purchase.\r\n     * @param count the number of tokens to mint.\r\n     */\r\n    function phaseOneMintTokensTo(\r\n        bytes32[] calldata proof,\r\n        string calldata auxInfo,\r\n        uint256 extraData,\r\n        uint256 count,\r\n        uint256 flavorId,\r\n        uint256 validationData,\r\n        address provider,\r\n        address destination\r\n    ) external payable nonReentrant isPhaseOne {\r\n        _phaseOneMintTokensTo(proof, auxInfo, extraData, count, flavorId, validationData, provider, destination);\r\n    }\r\n\r\n    function _phaseOneMintTokensTo(\r\n        bytes32[] calldata proof,\r\n        string calldata auxInfo,\r\n        uint256 extraData,\r\n        uint256 count,\r\n        uint256,\r\n        uint256 validationData,\r\n        address,\r\n        address destination\r\n    ) internal {\r\n        if (0 >= count || count > PHASE_ONE_BATCH_SIZE) revert ExceedsBatchSize();\r\n        if (msg.value != phaseOnePricePerNft * count) revert InvalidPayment();\r\n        if (_totalMinted() + count > PHASE_ONE_SUPPLY_CAP) revert ExceedsSupplyCap();\r\n        if (_hasAuxData(extraData)) revert ClaimAlreadyMinted();\r\n\r\n        _storeToAux(extraData, auxInfo, false); // Note: Not extended!\r\n\r\n        if (validationData > 0) {\r\n            string memory exAuxInfo = string.concat(_decodeSaltFromUint256(validationData), '_', auxInfo);\r\n            _proofMintTokensOfFlavor_PhaseOne(msg.sender, proof, exAuxInfo, extraData, count, extraData, destination);\r\n        } else {\r\n            _proofMintTokensOfFlavor_PhaseOne(msg.sender, proof, auxInfo, extraData, count, extraData, destination);\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @notice Mint tokens (Phase Two) - purchase bound by terms & conditions of project.\r\n     *\r\n     * @param proof the merkle proof for this purchase.\r\n     * @param count the number of tokens to mint.\r\n     */\r\n    function phaseTwoMintTokens(\r\n        bytes32[] calldata proof,\r\n        string calldata auxInfo,\r\n        uint256 extraData,\r\n        uint256 count,\r\n        uint256 flavorId,\r\n        uint256 validationData,\r\n        address provider\r\n    ) external payable nonReentrant isPhaseTwo {\r\n        _phaseTwoMintTokensTo(proof, auxInfo, extraData, count, flavorId, validationData, provider, msg.sender);\r\n    }\r\n\r\n    /**\r\n     * @notice Mint tokens (Phase Two) - purchase bound by terms & conditions of project.\r\n     *\r\n     * @param proof the merkle proof for this purchase.\r\n     * @param count the number of tokens to mint.\r\n     */\r\n    function phaseTwoMintTokensTo(\r\n        bytes32[] calldata proof,\r\n        string calldata auxInfo,\r\n        uint256 extraData,\r\n        uint256 count,\r\n        uint256 flavorId,\r\n        uint256 validationData,\r\n        address provider,\r\n        address destination\r\n    ) external payable nonReentrant isPhaseTwo {\r\n        _phaseTwoMintTokensTo(proof, auxInfo, extraData, count, flavorId, validationData, provider, destination);\r\n    }\r\n\r\n    function _phaseTwoMintTokensTo(\r\n        bytes32[] calldata proof,\r\n        string calldata auxInfo,\r\n        uint256 extraData,\r\n        uint256 count,\r\n        uint256,\r\n        uint256 validationData,\r\n        address,\r\n        address destination\r\n    ) internal {\r\n        if (0 >= count || count > PHASE_TWO_BATCH_SIZE) revert ExceedsBatchSize();\r\n        if (msg.value != phaseTwoPricePerNft * count) revert InvalidPayment();\r\n        if (_totalMinted() + count > PHASE_TWO_SUPPLY_CAP) revert ExceedsSupplyCap();\r\n        if (_hasAuxData(extraData)) revert ClaimAlreadyMinted();\r\n\r\n        _storeToAux(extraData, auxInfo, false); // Note: Not extended!\r\n\r\n        if (validationData > 0) {\r\n            string memory exAuxInfo = string.concat(_decodeSaltFromUint256(validationData), '_', auxInfo);\r\n            _proofMintTokensOfFlavor_PhaseTwo(msg.sender, proof, exAuxInfo, extraData, count, extraData, destination);\r\n        } else {\r\n            _proofMintTokensOfFlavor_PhaseTwo(msg.sender, proof, auxInfo, extraData, count, extraData, destination);\r\n        }\r\n    }\r\n\r\n    function _internalMintTokens(\r\n        address minter,\r\n        uint256 count\r\n    ) internal override(PhaseOneIsAuxillary, PhaseTwoIsAuxillary) {\r\n        // Do nothing\r\n    }\r\n\r\n    function _internalMintTokens(\r\n        address minter,\r\n        uint256 count,\r\n        uint256\r\n    ) internal override(PhaseOneIsAuxillary, PhaseTwoIsAuxillary) {\r\n        // ERC1155 does not distinguish between bookNumbers.\r\n        _mint(minter, _getFixedTokenId(), count, '');\r\n    }\r\n}\r\n"
      },
      "contracts/NBNFTA2/NFTBookArtistTwoSplitsAndRoyalties.sol": {
        "content": "// SPDX-License-Identifier: MIT\r\npragma solidity ^0.8.11;\r\n\r\n// NFTC Open Source Contracts See: https://github.com/NFTCulture/nftc-contracts\r\nimport '@nftculture/nftc-contracts/contracts/financial/NFTCSplitsAndRoyalties.sol';\r\n\r\nabstract contract NFTBookArtistTwoSplitsAndRoyalties is NFTCSplitsAndRoyalties {\r\n    address[] internal addresses = [\r\n        0x2f950a29CB4A784a187032e9DF33De289f1B46D4 // OnNFTs Royalty Receiver\r\n    ];\r\n\r\n    uint256[] internal splits = [100];\r\n\r\n    uint96 private constant DEFAULT_ROYALTY_BASIS_POINTS = 750;\r\n\r\n    constructor() NFTCSplitsAndRoyalties(addresses, splits, address(this), DEFAULT_ROYALTY_BASIS_POINTS) {\r\n        // Nothing to do.\r\n    }\r\n}\r\n"
      },
      "contracts/NBNFTA2/OnNFTsDmitriCherniak.sol": {
        "content": "// SPDX-License-Identifier: MIT\r\npragma solidity 0.8.19;\r\n\r\n// NFTC Open Source Contracts See: https://github.com/NFTCulture/nftc-contracts\r\nimport '@nftculture/nftc-contracts/contracts/meta/ERC7572_ContractMetadata.sol';\r\n\r\n// NFTC Prerelease Contracts\r\nimport '@nftculture/nftc-contracts-private/contracts/access/v2/OwnableDeferralResolution.sol';\r\n\r\n// Local References\r\nimport './NFTBookArtistTwoBase.sol';\r\nimport './NFTBookArtistTwoSplitsAndRoyalties.sol';\r\n\r\n/**\r\n *      OOOOOOOOO                           NNNNNNNN        NNNNNNNN FFFFFFFFFFFFFFFFFFFFFF TTTTTTTTTTTTTTTTTTTTTTT\r\n *    OO:::::::::OO                         N:::::::N       N::::::N F::::::::::::::::::::F T:::::::::::::::::::::T\r\n *  OO:::::::::::::OO                       N::::::::N      N::::::N F::::::::::::::::::::F T:::::::::::::::::::::T\r\n * O:::::::OOO:::::::O                      N:::::::::N     N::::::N F:::::::FFFFFFFFFFFFFF TTTTTTTT:::::::TTTTTTTT\r\n * O::::::O   O::::::Onnnn  nnnnnnnn        N::::::::::N    N::::::N F:::::::F                     T:::::::T     ssssssssss\r\n * O:::::O     O:::::On:::nn::::::::nn      N:::::::::::N   N::::::N F:::::::F                     T:::::::T   ss::::::::::s\r\n * O:::::O     O:::::On::::::::::::::nn     N:::::::N::::N  N::::::N F::::::::FFFFFFFFFF           T:::::::T ss:::::::::::::s\r\n * O:::::O     O:::::Onn:::::::::::::::n    N::::::N N::::N N::::::N F:::::::::::::::::F           T:::::::T s::::::ssss:::::s\r\n * O:::::O     O:::::O  n:::::nnnn:::::n    N::::::N  N::::N:::::::N F:::::::::::::::::F           T:::::::T  s:::::s  ssssss\r\n * O:::::O     O:::::O  n::::n    n::::n    N::::::N   N:::::::::::N F::::::::FFFFFFFFFF           T:::::::T    s::::::s\r\n * O:::::O     O:::::O  n::::n    n::::n    N::::::N    N::::::::::N F:::::::F                     T:::::::T       s::::::s\r\n * O::::::O   O::::::O  n::::n    n::::n    N::::::N     N:::::::::N F:::::::F                     T:::::::T ssssss   s:::::s\r\n * O:::::::OOO:::::::O  n::::n    n::::n    N::::::N      N::::::::N F:::::::F                     T:::::::T s:::::ssss::::::s\r\n *  OO:::::::::::::OO   n::::n    n::::n    N::::::N       N:::::::N F:::::::F                     T:::::::T s::::::::::::::s\r\n *    OO:::::::::OO     n::::n    n::::n    N::::::N        N::::::N F:::::::F                     T:::::::T  s:::::::::::ss\r\n *      OOOOOOOOO       nnnnnn    nnnnnn    NNNNNNNN         NNNNNNN FFFFFFFFF                     TTTTTTTTT   sssssssssss\r\n *\r\n * On NFTs Art Edition - Dmitri Cherniak - Published by Taschen\r\n */\r\ncontract OnNFTsDmitriCherniak is\r\n    NFTBookArtistTwoSplitsAndRoyalties,\r\n    NFTBookArtistTwoBase,\r\n    ERC7572_ContractMetadata,\r\n    OwnableDeferralResolution\r\n{\r\n    // Mainnet\r\n    string private constant DEFAULT_CONTRACT_METADATA_URI =\r\n        'https://arweave.net/dKFDckMXIyJ0os3KZYLh2Ung9dJd5DoTME-Re0Q7LAU/onnfts-ae2.json'; // contract-metadata v1.0.4\r\n    address private constant DEFAULT_METADATA_CONTRACT = 0xB5a9f4d240187a60A311a3fAd7cC72dEA59a06F8;\r\n\r\n    uint256[] private DEFAULT_PHASE_PRICES = [0.000 ether, 0.000 ether, 0.000 ether];\r\n    string private constant DEFAULT_ART_URI = ''; // Unused. Art is hosted via chainnative stack.\r\n    uint256 private constant FIXED_TOKEN_ID = 1; // This is an ERC1155_Fixed contract, and will host 1 single tokenId.\r\n\r\n    constructor()\r\n        NFTBookArtistTwoBase(DEFAULT_ART_URI, FIXED_TOKEN_ID, DEFAULT_PHASE_PRICES)\r\n        SingletonMetadataConsumer(DEFAULT_METADATA_CONTRACT)\r\n    {\r\n        _setContractURI(DEFAULT_CONTRACT_METADATA_URI);\r\n    }\r\n\r\n    function supportsInterface(\r\n        bytes4 interfaceId\r\n    ) public view virtual override(ERC1155, ERC2981, ERC7572_ContractMetadata) returns (bool) {\r\n        return\r\n            ERC1155.supportsInterface(interfaceId) ||\r\n            ERC2981.supportsInterface(interfaceId) ||\r\n            ERC7572_ContractMetadata.supportsInterface(interfaceId);\r\n    }\r\n\r\n    /**\r\n     * Fulfill _isOwner() implementation, backed by OZ Ownable.\r\n     *\r\n     * @dev see OwnableDeferral/OwnableDeferralResolution for more explanation on this.\r\n     */\r\n    function _isOwner()\r\n        internal\r\n        view\r\n        override(ERC7572_ContractMetadata, NFTCSplitsAndRoyalties, OwnableDeferral, OwnableDeferralResolution)\r\n    {\r\n        OwnableDeferralResolution._isOwner();\r\n    }\r\n}\r\n"
      }
    },
    "settings": {
      "optimizer": {
        "enabled": true,
        "runs": 1000
      },
      "outputSelection": {
        "*": {
          "*": [
            "evm.bytecode",
            "evm.deployedBytecode",
            "devdoc",
            "userdoc",
            "metadata",
            "abi"
          ]
        }
      },
      "libraries": {}
    }
  }}