APE Price: $0.69 (-5.68%)
    /

    Contract Diff Checker

    Contract Name:
    MintpadERC1155Drop

    Contract Source Code:

    // SPDX-License-Identifier: Apache 2.0
    pragma solidity ^0.8.0;
    
    error TrxErrorAuth();
    error TrxErrorFee1();
    error TrxErrorFee2();
    
    /// @author Mintpad
    abstract contract TransactionFee {
        
        /// @dev Platform wallet address
        address public platformAddress = 0x4ec431790805909b0D3Dcf5C8dA25FCBF46E93F8;
    
        /// @dev Transaction cost
        uint256 public transactionFee;
    
        /// @dev At any given moment, returns the transaction fee.
        function getTransactionFee() public view returns (uint256) {
            return transactionFee;
        }
    
        /**
         *  @notice         Sets a new transaction fee in case of need.
         *  @dev            This function is only used in rare situations where
         *                  the transaction fee is not set correctly. This value can
         *                  only be lower than the current transaction fee to prevent
         *                  fraud. Only Mintpad can set this transaction fee.
         *
         *  @param _transactionFee The transaction fee to be set.
         */
        function setTransactionFee(uint256 _transactionFee) external {
            if (msg.sender != platformAddress) {
                revert TrxErrorAuth();
            }
            if (_transactionFee > transactionFee) {
                revert TrxErrorFee1();
            }
            if (_transactionFee <= 0) {
                revert TrxErrorFee2();
            }
    
            transactionFee = _transactionFee;
        }
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    import { ERC1155 } from "../eip/ERC1155.sol";
    
    import "../extension/ContractMetadata.sol";
    import "../extension/Multicall.sol";
    import "../extension/Ownable.sol";
    import "../extension/Royalty.sol";
    import "../extension/BatchMintMetadata.sol";
    
    import "../lib/TWStrings.sol";
    
    /**
     *  The `ERC1155Base` smart contract implements the ERC1155 NFT standard.
     *  It includes the following additions to standard ERC1155 logic:
     *
     *      - Ability to mint NFTs via the provided `mintTo` and `batchMintTo` functions.
     *
     *      - Contract metadata for royalty support on platforms such as OpenSea that use
     *        off-chain information to distribute roaylties.
     *
     *      - Ownership of the contract, with the ability to restrict certain functions to
     *        only be called by the contract's owner.
     *
     *      - Multicall capability to perform multiple actions atomically
     *
     *      - EIP 2981 compliance for royalty support on NFT marketplaces.
     */
    
    contract ERC1155Base is ERC1155, ContractMetadata, Ownable, Royalty, Multicall, BatchMintMetadata {
        using TWStrings for uint256;
    
        /*//////////////////////////////////////////////////////////////
                            State variables
        //////////////////////////////////////////////////////////////*/
    
        /// @dev The tokenId of the next NFT to mint.
        uint256 internal nextTokenIdToMint_;
    
        /*//////////////////////////////////////////////////////////////
                            Mappings
        //////////////////////////////////////////////////////////////*/
    
        /**
         *  @notice Returns the total supply of NFTs of a given tokenId
         *  @dev Mapping from tokenId => total circulating supply of NFTs of that tokenId.
         */
        mapping(uint256 => uint256) public totalSupply;
    
        /*//////////////////////////////////////////////////////////////
                                Constructor
        //////////////////////////////////////////////////////////////*/
    
        constructor(
            address _defaultAdmin,
            string memory _name,
            string memory _symbol,
            address _royaltyRecipient,
            uint128 _royaltyBps
        ) ERC1155(_name, _symbol) {
            _setupOwner(_defaultAdmin);
            _setupDefaultRoyaltyInfo(_royaltyRecipient, _royaltyBps);
        }
    
        /*//////////////////////////////////////////////////////////////
                        Overriden metadata logic
        //////////////////////////////////////////////////////////////*/
    
        /// @notice Returns the metadata URI for the given tokenId.
        /// @param _tokenId The tokenId of the token for which a URI should be returned.
        /// @return The metadata URI for the given tokenId.
        function uri(uint256 _tokenId) public view virtual override returns (string memory) {
            string memory uriForToken = _uri[_tokenId];
            if (bytes(uriForToken).length > 0) {
                return uriForToken;
            }
    
            string memory batchUri = _getBaseURI(_tokenId);
            return string(abi.encodePacked(batchUri, _tokenId.toString()));
        }
    
        /*//////////////////////////////////////////////////////////////
                            Mint / burn logic
        //////////////////////////////////////////////////////////////*/
    
        /**
         *  @notice          Lets an authorized address mint NFTs to a recipient.
         *  @dev             - The logic in the `_canMint` function determines whether the caller is authorized to mint NFTs.
         *                   - If `_tokenId == type(uint256).max` a new NFT at tokenId `nextTokenIdToMint` is minted. If the given
         *                     `tokenId < nextTokenIdToMint`, then additional supply of an existing NFT is being minted.
         *
         *  @param _to       The recipient of the NFTs to mint.
         *  @param _tokenId  The tokenId of the NFT to mint.
         *  @param _tokenURI The full metadata URI for the NFTs minted (if a new NFT is being minted).
         *  @param _amount   The amount of the same NFT to mint.
         */
        function mintTo(
            address _to,
            uint256 _tokenId,
            string memory _tokenURI,
            uint256 _amount
        ) public virtual {
            require(_canMint(), "Not authorized to mint.");
    
            uint256 tokenIdToMint;
            uint256 nextIdToMint = nextTokenIdToMint();
    
            if (_tokenId == type(uint256).max) {
                tokenIdToMint = nextIdToMint;
                nextTokenIdToMint_ += 1;
                _setTokenURI(nextIdToMint, _tokenURI);
            } else {
                require(_tokenId < nextIdToMint, "invalid id");
                tokenIdToMint = _tokenId;
            }
    
            _mint(_to, tokenIdToMint, _amount, "");
        }
    
        /**
         *  @notice          Lets an authorized address mint multiple NEW NFTs at once to a recipient.
         *  @dev             The logic in the `_canMint` function determines whether the caller is authorized to mint NFTs.
         *                   If `_tokenIds[i] == type(uint256).max` a new NFT at tokenId `nextTokenIdToMint` is minted. If the given
         *                   `tokenIds[i] < nextTokenIdToMint`, then additional supply of an existing NFT is minted.
         *                   The metadata for each new NFT is stored at `baseURI/{tokenID of NFT}`
         *
         *  @param _to       The recipient of the NFT to mint.
         *  @param _tokenIds The tokenIds of the NFTs to mint.
         *  @param _amounts  The amounts of each NFT to mint.
         *  @param _baseURI  The baseURI for the `n` number of NFTs minted. The metadata for each NFT is `baseURI/tokenId`
         */
        function batchMintTo(
            address _to,
            uint256[] memory _tokenIds,
            uint256[] memory _amounts,
            string memory _baseURI
        ) public virtual {
            require(_canMint(), "Not authorized to mint.");
            require(_amounts.length > 0, "Minting zero tokens.");
            require(_tokenIds.length == _amounts.length, "Length mismatch.");
    
            uint256 nextIdToMint = nextTokenIdToMint();
            uint256 startNextIdToMint = nextIdToMint;
    
            uint256 numOfNewNFTs;
    
            for (uint256 i = 0; i < _tokenIds.length; i += 1) {
                if (_tokenIds[i] == type(uint256).max) {
                    _tokenIds[i] = nextIdToMint;
    
                    nextIdToMint += 1;
                    numOfNewNFTs += 1;
                } else {
                    require(_tokenIds[i] < nextIdToMint, "invalid id");
                }
            }
    
            if (numOfNewNFTs > 0) {
                _batchMintMetadata(startNextIdToMint, numOfNewNFTs, _baseURI);
            }
    
            nextTokenIdToMint_ = nextIdToMint;
            _mintBatch(_to, _tokenIds, _amounts, "");
        }
    
        /**
         *  @notice         Lets an owner or approved operator burn NFTs of the given tokenId.
         *
         *  @param _owner   The owner of the NFT to burn.
         *  @param _tokenId The tokenId of the NFT to burn.
         *  @param _amount  The amount of the NFT to burn.
         */
        function burn(
            address _owner,
            uint256 _tokenId,
            uint256 _amount
        ) external virtual {
            address caller = msg.sender;
    
            require(caller == _owner || isApprovedForAll[_owner][caller], "Unapproved caller");
            require(balanceOf[_owner][_tokenId] >= _amount, "Not enough tokens owned");
    
            _burn(_owner, _tokenId, _amount);
        }
    
        /**
         *  @notice         Lets an owner or approved operator burn NFTs of the given tokenIds.
         *
         *  @param _owner    The owner of the NFTs to burn.
         *  @param _tokenIds The tokenIds of the NFTs to burn.
         *  @param _amounts  The amounts of the NFTs to burn.
         */
        function burnBatch(
            address _owner,
            uint256[] memory _tokenIds,
            uint256[] memory _amounts
        ) external virtual {
            address caller = msg.sender;
    
            require(caller == _owner || isApprovedForAll[_owner][caller], "Unapproved caller");
            require(_tokenIds.length == _amounts.length, "Length mismatch");
    
            for (uint256 i = 0; i < _tokenIds.length; i += 1) {
                require(balanceOf[_owner][_tokenIds[i]] >= _amounts[i], "Not enough tokens owned");
            }
    
            _burnBatch(_owner, _tokenIds, _amounts);
        }
    
        /*//////////////////////////////////////////////////////////////
                                ERC165 Logic
        //////////////////////////////////////////////////////////////*/
    
        /**
         * @dev See ERC165: https://eips.ethereum.org/EIPS/eip-165
         * @inheritdoc IERC165
         */
        function supportsInterface(bytes4 interfaceId) public view virtual override(ERC1155, IERC165) returns (bool) {
            return
                interfaceId == 0x01ffc9a7 || // ERC165 Interface ID for ERC165
                interfaceId == 0xd9b67a26 || // ERC165 Interface ID for ERC1155
                interfaceId == 0x0e89341c || // ERC165 Interface ID for ERC1155MetadataURI
                interfaceId == type(IERC2981).interfaceId; // ERC165 ID for ERC2981
        }
    
        /*//////////////////////////////////////////////////////////////
                                View functions
        //////////////////////////////////////////////////////////////*/
    
        /// @notice The tokenId assigned to the next new NFT to be minted.
        function nextTokenIdToMint() public view virtual returns (uint256) {
            return nextTokenIdToMint_;
        }
    
        /*//////////////////////////////////////////////////////////////
                        Internal (overrideable) functions
        //////////////////////////////////////////////////////////////*/
    
        /// @dev Returns whether contract metadata can be set in the given execution context.
        /// @return Whether contract metadata can be set in the given execution context.
        function _canSetContractURI() internal view virtual override returns (bool) {
            return msg.sender == owner();
        }
    
        /// @dev Returns whether a token can be minted in the given execution context.
        /// @return Whether a token can be minted in the given execution context.
        function _canMint() internal view virtual returns (bool) {
            return msg.sender == owner();
        }
    
        /// @dev Returns whether owner can be set in the given execution context.
        /// @return Whether owner can be set in the given execution context.
        function _canSetOwner() internal view virtual override returns (bool) {
            return msg.sender == owner();
        }
    
        /// @dev Returns whether royalty info can be set in the given execution context.
        /// @return Whether royalty info can be set in the given execution context.
        function _canSetRoyaltyInfo() internal view virtual override returns (bool) {
            return msg.sender == owner();
        }
    
        /// @dev Runs before every token transfer / mint / burn.
        /// @param operator The address of the caller.
        /// @param from The address of the sender.
        /// @param to The address of the recipient.
        /// @param ids The tokenIds of the tokens being transferred.
        /// @param amounts The amounts of the tokens being transferred.
        /// @param data Additional data with no specified format.
        function _beforeTokenTransfer(
            address operator,
            address from,
            address to,
            uint256[] memory ids,
            uint256[] memory amounts,
            bytes memory data
        ) internal virtual override {
            super._beforeTokenTransfer(operator, from, to, ids, amounts, data);
    
            if (from == address(0)) {
                for (uint256 i = 0; i < ids.length; ++i) {
                    totalSupply[ids[i]] += amounts[i];
                }
            }
    
            if (to == address(0)) {
                for (uint256 i = 0; i < ids.length; ++i) {
                    totalSupply[ids[i]] -= amounts[i];
                }
            }
        }
    }

    // SPDX-License-Identifier: Apache 2.0
    pragma solidity ^0.8.0;
    
    import "./interface/IERC1155.sol";
    import "./interface/IERC1155Metadata.sol";
    import "./interface/IERC1155Receiver.sol";
    
    contract ERC1155 is IERC1155, IERC1155Metadata {
        /*//////////////////////////////////////////////////////////////
                            State variables
        //////////////////////////////////////////////////////////////*/
    
        string public name;
        string public symbol;
    
        /*//////////////////////////////////////////////////////////////
                                Mappings
        //////////////////////////////////////////////////////////////*/
    
        mapping(address => mapping(uint256 => uint256)) public balanceOf;
    
        mapping(address => mapping(address => bool)) public isApprovedForAll;
    
        mapping(uint256 => string) internal _uri;
    
        /*//////////////////////////////////////////////////////////////
                                Constructor
        //////////////////////////////////////////////////////////////*/
    
        constructor(string memory _name, string memory _symbol) {
            name = _name;
            symbol = _symbol;
        }
    
        /*//////////////////////////////////////////////////////////////
                                View functions
        //////////////////////////////////////////////////////////////*/
    
        function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
            return
                interfaceId == 0x01ffc9a7 || // ERC165 Interface ID for ERC165
                interfaceId == 0xd9b67a26 || // ERC165 Interface ID for ERC1155
                interfaceId == 0x0e89341c; // ERC165 Interface ID for ERC1155MetadataURI
        }
    
        function uri(uint256 tokenId) public view virtual override returns (string memory) {
            return _uri[tokenId];
        }
    
        function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
            public
            view
            virtual
            override
            returns (uint256[] memory)
        {
            require(accounts.length == ids.length, "LENGTH_MISMATCH");
    
            uint256[] memory batchBalances = new uint256[](accounts.length);
    
            for (uint256 i = 0; i < accounts.length; ++i) {
                batchBalances[i] = balanceOf[accounts[i]][ids[i]];
            }
    
            return batchBalances;
        }
    
        /*//////////////////////////////////////////////////////////////
                                ERC1155 logic
        //////////////////////////////////////////////////////////////*/
    
        function setApprovalForAll(address operator, bool approved) public virtual override {
            address owner = msg.sender;
            require(owner != operator, "APPROVING_SELF");
            isApprovedForAll[owner][operator] = approved;
            emit ApprovalForAll(owner, operator, approved);
        }
    
        function safeTransferFrom(
            address from,
            address to,
            uint256 id,
            uint256 amount,
            bytes memory data
        ) public virtual override {
            require(from == msg.sender || isApprovedForAll[from][msg.sender], "!OWNER_OR_APPROVED");
            _safeTransferFrom(from, to, id, amount, data);
        }
    
        function safeBatchTransferFrom(
            address from,
            address to,
            uint256[] memory ids,
            uint256[] memory amounts,
            bytes memory data
        ) public virtual override {
            require(from == msg.sender || isApprovedForAll[from][msg.sender], "!OWNER_OR_APPROVED");
            _safeBatchTransferFrom(from, to, ids, amounts, data);
        }
    
        /*//////////////////////////////////////////////////////////////
                                Internal logic
        //////////////////////////////////////////////////////////////*/
    
        function _safeTransferFrom(
            address from,
            address to,
            uint256 id,
            uint256 amount,
            bytes memory data
        ) internal virtual {
            require(to != address(0), "TO_ZERO_ADDR");
    
            address operator = msg.sender;
    
            _beforeTokenTransfer(operator, from, to, _asSingletonArray(id), _asSingletonArray(amount), data);
    
            uint256 fromBalance = balanceOf[from][id];
            require(fromBalance >= amount, "INSUFFICIENT_BAL");
            unchecked {
                balanceOf[from][id] = fromBalance - amount;
            }
            balanceOf[to][id] += amount;
    
            emit TransferSingle(operator, from, to, id, amount);
    
            _doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
        }
    
        function _safeBatchTransferFrom(
            address from,
            address to,
            uint256[] memory ids,
            uint256[] memory amounts,
            bytes memory data
        ) internal virtual {
            require(ids.length == amounts.length, "LENGTH_MISMATCH");
            require(to != address(0), "TO_ZERO_ADDR");
    
            address operator = msg.sender;
    
            _beforeTokenTransfer(operator, from, to, ids, amounts, data);
    
            for (uint256 i = 0; i < ids.length; ++i) {
                uint256 id = ids[i];
                uint256 amount = amounts[i];
    
                uint256 fromBalance = balanceOf[from][id];
                require(fromBalance >= amount, "INSUFFICIENT_BAL");
                unchecked {
                    balanceOf[from][id] = fromBalance - amount;
                }
                balanceOf[to][id] += amount;
            }
    
            emit TransferBatch(operator, from, to, ids, amounts);
    
            _doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
        }
    
        function _setTokenURI(uint256 tokenId, string memory newuri) internal virtual {
            _uri[tokenId] = newuri;
        }
    
        function _mint(
            address to,
            uint256 id,
            uint256 amount,
            bytes memory data
        ) internal virtual {
            require(to != address(0), "TO_ZERO_ADDR");
    
            address operator = msg.sender;
    
            _beforeTokenTransfer(operator, address(0), to, _asSingletonArray(id), _asSingletonArray(amount), data);
    
            balanceOf[to][id] += amount;
            emit TransferSingle(operator, address(0), to, id, amount);
    
            _doSafeTransferAcceptanceCheck(operator, address(0), to, id, amount, data);
        }
    
        function _mintBatch(
            address to,
            uint256[] memory ids,
            uint256[] memory amounts,
            bytes memory data
        ) internal virtual {
            require(to != address(0), "TO_ZERO_ADDR");
            require(ids.length == amounts.length, "LENGTH_MISMATCH");
    
            address operator = msg.sender;
    
            _beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
    
            for (uint256 i = 0; i < ids.length; i++) {
                balanceOf[to][ids[i]] += amounts[i];
            }
    
            emit TransferBatch(operator, address(0), to, ids, amounts);
    
            _doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
        }
    
        function _burn(
            address from,
            uint256 id,
            uint256 amount
        ) internal virtual {
            require(from != address(0), "FROM_ZERO_ADDR");
    
            address operator = msg.sender;
    
            _beforeTokenTransfer(operator, from, address(0), _asSingletonArray(id), _asSingletonArray(amount), "");
    
            uint256 fromBalance = balanceOf[from][id];
            require(fromBalance >= amount, "INSUFFICIENT_BAL");
            unchecked {
                balanceOf[from][id] = fromBalance - amount;
            }
    
            emit TransferSingle(operator, from, address(0), id, amount);
        }
    
        function _burnBatch(
            address from,
            uint256[] memory ids,
            uint256[] memory amounts
        ) internal virtual {
            require(from != address(0), "FROM_ZERO_ADDR");
            require(ids.length == amounts.length, "LENGTH_MISMATCH");
    
            address operator = msg.sender;
    
            _beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
    
            for (uint256 i = 0; i < ids.length; i++) {
                uint256 id = ids[i];
                uint256 amount = amounts[i];
    
                uint256 fromBalance = balanceOf[from][id];
                require(fromBalance >= amount, "INSUFFICIENT_BAL");
                unchecked {
                    balanceOf[from][id] = fromBalance - amount;
                }
            }
    
            emit TransferBatch(operator, from, address(0), ids, amounts);
        }
    
        function _beforeTokenTransfer(
            address operator,
            address from,
            address to,
            uint256[] memory ids,
            uint256[] memory amounts,
            bytes memory data
        ) internal virtual {}
    
        function _doSafeTransferAcceptanceCheck(
            address operator,
            address from,
            address to,
            uint256 id,
            uint256 amount,
            bytes memory data
        ) private {
            if (to.code.length > 0) {
                try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
                    if (response != IERC1155Receiver.onERC1155Received.selector) {
                        revert("TOKENS_REJECTED");
                    }
                } catch Error(string memory reason) {
                    revert(reason);
                } catch {
                    revert("!ERC1155RECEIVER");
                }
            }
        }
    
        function _doSafeBatchTransferAcceptanceCheck(
            address operator,
            address from,
            address to,
            uint256[] memory ids,
            uint256[] memory amounts,
            bytes memory data
        ) private {
            if (to.code.length > 0) {
                try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (
                    bytes4 response
                ) {
                    if (response != IERC1155Receiver.onERC1155BatchReceived.selector) {
                        revert("TOKENS_REJECTED");
                    }
                } catch Error(string memory reason) {
                    revert(reason);
                } catch {
                    revert("!ERC1155RECEIVER");
                }
            }
        }
    
        function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
            uint256[] memory array = new uint256[](1);
            array[0] = element;
    
            return array;
        }
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /**
        @title ERC-1155 Multi Token Standard
        @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1155.md
        Note: The ERC-165 identifier for this interface is 0xd9b67a26.
     */
    interface IERC1155 {
        /**
            @dev Either `TransferSingle` or `TransferBatch` MUST emit when tokens are transferred, including zero value transfers as well as minting or burning (see "Safe Transfer Rules" section of the standard).
            The `_operator` argument MUST be msg.sender.
            The `_from` argument MUST be the address of the holder whose balance is decreased.
            The `_to` argument MUST be the address of the recipient whose balance is increased.
            The `_id` argument MUST be the token type being transferred.
            The `_value` argument MUST be the number of tokens the holder balance is decreased by and match what the recipient balance is increased by.
            When minting/creating tokens, the `_from` argument MUST be set to `0x0` (i.e. zero address).
            When burning/destroying tokens, the `_to` argument MUST be set to `0x0` (i.e. zero address).
        */
        event TransferSingle(
            address indexed _operator,
            address indexed _from,
            address indexed _to,
            uint256 _id,
            uint256 _value
        );
    
        /**
            @dev Either `TransferSingle` or `TransferBatch` MUST emit when tokens are transferred, including zero value transfers as well as minting or burning (see "Safe Transfer Rules" section of the standard).
            The `_operator` argument MUST be msg.sender.
            The `_from` argument MUST be the address of the holder whose balance is decreased.
            The `_to` argument MUST be the address of the recipient whose balance is increased.
            The `_ids` argument MUST be the list of tokens being transferred.
            The `_values` argument MUST be the list of number of tokens (matching the list and order of tokens specified in _ids) the holder balance is decreased by and match what the recipient balance is increased by.
            When minting/creating tokens, the `_from` argument MUST be set to `0x0` (i.e. zero address).
            When burning/destroying tokens, the `_to` argument MUST be set to `0x0` (i.e. zero address).
        */
        event TransferBatch(
            address indexed _operator,
            address indexed _from,
            address indexed _to,
            uint256[] _ids,
            uint256[] _values
        );
    
        /**
            @dev MUST emit when approval for a second party/operator address to manage all tokens for an owner address is enabled or disabled (absense of an event assumes disabled).
        */
        event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
    
        /**
            @dev MUST emit when the URI is updated for a token ID.
            URIs are defined in RFC 3986.
            The URI MUST point a JSON file that conforms to the "ERC-1155 Metadata URI JSON Schema".
        */
        event URI(string _value, uint256 indexed _id);
    
        /**
            @notice Transfers `_value` amount of an `_id` from the `_from` address to the `_to` address specified (with safety call).
            @dev Caller must be approved to manage the tokens being transferred out of the `_from` account (see "Approval" section of the standard).
            MUST revert if `_to` is the zero address.
            MUST revert if balance of holder for token `_id` is lower than the `_value` sent.
            MUST revert on any other error.
            MUST emit the `TransferSingle` event to reflect the balance change (see "Safe Transfer Rules" section of the standard).
            After the above conditions are met, this function MUST check if `_to` is a smart contract (e.g. code size > 0). If so, it MUST call `onERC1155Received` on `_to` and act appropriately (see "Safe Transfer Rules" section of the standard).
            @param _from    Source address
            @param _to      Target address
            @param _id      ID of the token type
            @param _value   Transfer amount
            @param _data    Additional data with no specified format, MUST be sent unaltered in call to `onERC1155Received` on `_to`
        */
        function safeTransferFrom(
            address _from,
            address _to,
            uint256 _id,
            uint256 _value,
            bytes calldata _data
        ) external;
    
        /**
            @notice Transfers `_values` amount(s) of `_ids` from the `_from` address to the `_to` address specified (with safety call).
            @dev Caller must be approved to manage the tokens being transferred out of the `_from` account (see "Approval" section of the standard).
            MUST revert if `_to` is the zero address.
            MUST revert if length of `_ids` is not the same as length of `_values`.
            MUST revert if any of the balance(s) of the holder(s) for token(s) in `_ids` is lower than the respective amount(s) in `_values` sent to the recipient.
            MUST revert on any other error.
            MUST emit `TransferSingle` or `TransferBatch` event(s) such that all the balance changes are reflected (see "Safe Transfer Rules" section of the standard).
            Balance changes and events MUST follow the ordering of the arrays (_ids[0]/_values[0] before _ids[1]/_values[1], etc).
            After the above conditions for the transfer(s) in the batch are met, this function MUST check if `_to` is a smart contract (e.g. code size > 0). If so, it MUST call the relevant `ERC1155TokenReceiver` hook(s) on `_to` and act appropriately (see "Safe Transfer Rules" section of the standard).
            @param _from    Source address
            @param _to      Target address
            @param _ids     IDs of each token type (order and length must match _values array)
            @param _values  Transfer amounts per token type (order and length must match _ids array)
            @param _data    Additional data with no specified format, MUST be sent unaltered in call to the `ERC1155TokenReceiver` hook(s) on `_to`
        */
        function safeBatchTransferFrom(
            address _from,
            address _to,
            uint256[] calldata _ids,
            uint256[] calldata _values,
            bytes calldata _data
        ) external;
    
        /**
            @notice Get the balance of an account's Tokens.
            @param _owner  The address of the token holder
            @param _id     ID of the Token
            @return        The _owner's balance of the Token type requested
         */
        function balanceOf(address _owner, uint256 _id) external view returns (uint256);
    
        /**
            @notice Get the balance of multiple account/token pairs
            @param _owners The addresses of the token holders
            @param _ids    ID of the Tokens
            @return        The _owner's balance of the Token types requested (i.e. balance for each (owner, id) pair)
         */
        function balanceOfBatch(address[] calldata _owners, uint256[] calldata _ids)
            external
            view
            returns (uint256[] memory);
    
        /**
            @notice Enable or disable approval for a third party ("operator") to manage all of the caller's tokens.
            @dev MUST emit the ApprovalForAll event on success.
            @param _operator  Address to add to the set of authorized operators
            @param _approved  True if the operator is approved, false to revoke approval
        */
        function setApprovalForAll(address _operator, bool _approved) external;
    
        /**
            @notice Queries the approval status of an operator for a given owner.
            @param _owner     The owner of the Tokens
            @param _operator  Address of authorized operator
            @return           True if the operator is approved, false if not
        */
        function isApprovedForAll(address _owner, address _operator) external view returns (bool);
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /**
        Note: The ERC-165 identifier for this interface is 0x0e89341c.
    */
    interface IERC1155Metadata {
        /**
            @notice A distinct Uniform Resource Identifier (URI) for a given token.
            @dev URIs are defined in RFC 3986.
            The URI may point to a JSON file that conforms to the "ERC-1155 Metadata URI JSON Schema".
            @return URI string
        */
        function uri(uint256 _id) external view returns (string memory);
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)
    
    pragma solidity ^0.8.0;
    
    import "./IERC165.sol";
    
    /**
     * @dev _Available since v3.1._
     */
    interface IERC1155Receiver is IERC165 {
        /**
         * @dev Handles the receipt of a single ERC1155 token type. This function is
         * called at the end of a `safeTransferFrom` after the balance has been updated.
         *
         * NOTE: To accept the transfer, this must return
         * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
         * (i.e. 0xf23a6e61, or its own function selector).
         *
         * @param operator The address which initiated the transfer (i.e. msg.sender)
         * @param from The address which previously owned the token
         * @param id The ID of the token being transferred
         * @param value The amount of tokens being transferred
         * @param data Additional data with no specified format
         * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
         */
        function onERC1155Received(
            address operator,
            address from,
            uint256 id,
            uint256 value,
            bytes calldata data
        ) external returns (bytes4);
    
        /**
         * @dev Handles the receipt of a multiple ERC1155 token types. This function
         * is called at the end of a `safeBatchTransferFrom` after the balances have
         * been updated.
         *
         * NOTE: To accept the transfer(s), this must return
         * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
         * (i.e. 0xbc197c81, or its own function selector).
         *
         * @param operator The address which initiated the batch transfer (i.e. msg.sender)
         * @param from The address which previously owned the token
         * @param ids An array containing ids of each token being transferred (order and length must match values array)
         * @param values An array containing amounts of each token being transferred (order and length must match ids array)
         * @param data Additional data with no specified format
         * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
         */
        function onERC1155BatchReceived(
            address operator,
            address from,
            uint256[] calldata ids,
            uint256[] calldata values,
            bytes calldata data
        ) external returns (bytes4);
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
    
    pragma solidity ^0.8.0;
    
    /**
     * @dev Interface of the ERC165 standard, as defined in the
     * [EIP](https://eips.ethereum.org/EIPS/eip-165).
     *
     * Implementers can declare support of contract interfaces, which can then be
     * queried by others ({ERC165Checker}).
     *
     * For an implementation, see {ERC165}.
     */
    interface IERC165 {
        /**
         * @dev Returns true if this contract implements the interface defined by
         * `interfaceId`. See the corresponding
         * [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)
         * to learn more about how these ids are created.
         *
         * This function call must use less than 30 000 gas.
         */
        function supportsInterface(bytes4 interfaceId) external view returns (bool);
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /**
     * @title ERC20 interface
     * @dev see https://github.com/ethereum/EIPs/issues/20
     */
    interface IERC20 {
        function totalSupply() external view returns (uint256);
    
        function balanceOf(address who) external view returns (uint256);
    
        function allowance(address owner, address spender) external view returns (uint256);
    
        function transfer(address to, uint256 value) external returns (bool);
    
        function approve(address spender, uint256 value) external returns (bool);
    
        function transferFrom(
            address from,
            address to,
            uint256 value
        ) external returns (bool);
    
        event Transfer(address indexed from, address indexed to, uint256 value);
    
        event Approval(address indexed owner, address indexed spender, uint256 value);
    }

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

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    /**
     *  @title   Batch-mint Metadata
     *  @notice  The `BatchMintMetadata` is a contract extension for any base NFT contract. It lets the smart contract
     *           using this extension set metadata for `n` number of NFTs all at once. This is enabled by storing a single
     *           base URI for a batch of `n` NFTs, where the metadata for each NFT in a relevant batch is `baseURI/tokenId`.
     */
    
    contract BatchMintMetadata {
        /// @dev Largest tokenId of each batch of tokens with the same baseURI.
        uint256[] private batchIds;
    
        /// @dev Mapping from id of a batch of tokens => to base URI for the respective batch of tokens.
        mapping(uint256 => string) private baseURI;
    
        /// @dev Mapping from id of a batch of tokens => to whether the base URI for the respective batch of tokens is frozen.
        mapping(uint256 => bool) public batchFrozen;
    
        /// @dev This event emits when the metadata of all tokens are frozen.
        /// While not currently supported by marketplaces, this event allows
        /// future indexing if desired.
        event MetadataFrozen();
    
        // @dev This event emits when the metadata of a range of tokens is updated.
        /// So that the third-party platforms such as NFT market could
        /// timely update the images and related attributes of the NFTs.
        event BatchMetadataUpdate(uint256 _fromTokenId, uint256 _toTokenId);
    
        /**
         *  @notice         Returns the count of batches of NFTs.
         *  @dev            Each batch of tokens has an in ID and an associated `baseURI`.
         *                  See {batchIds}.
         */
        function getBaseURICount() public view returns (uint256) {
            return batchIds.length;
        }
    
        /**
         *  @notice         Returns the ID for the batch of tokens at the given index.
         *  @dev            See {getBaseURICount}.
         *  @param _index   Index of the desired batch in batchIds array.
         */
        function getBatchIdAtIndex(uint256 _index) public view returns (uint256) {
            if (_index >= getBaseURICount()) {
                revert("Invalid index");
            }
            return batchIds[_index];
        }
    
        /// @dev Returns the id for the batch of tokens the given tokenId belongs to.
        function _getBatchId(uint256 _tokenId) internal view returns (uint256 batchId, uint256 index) {
            uint256 numOfTokenBatches = getBaseURICount();
            uint256[] memory indices = batchIds;
    
            for (uint256 i = 0; i < numOfTokenBatches; i += 1) {
                if (_tokenId < indices[i]) {
                    index = i;
                    batchId = indices[i];
    
                    return (batchId, index);
                }
            }
    
            revert("Invalid tokenId");
        }
    
        /// @dev Returns the baseURI for a token. The intended metadata URI for the token is baseURI + tokenId.
        function _getBaseURI(uint256 _tokenId) internal view returns (string memory) {
            uint256 numOfTokenBatches = getBaseURICount();
            uint256[] memory indices = batchIds;
    
            for (uint256 i = 0; i < numOfTokenBatches; i += 1) {
                if (_tokenId < indices[i]) {
                    return baseURI[indices[i]];
                }
            }
            revert("Invalid tokenId");
        }
    
        /// @dev returns the starting tokenId of a given batchId.
        function _getBatchStartId(uint256 _batchID) internal view returns (uint256) {
            uint256 numOfTokenBatches = getBaseURICount();
            uint256[] memory indices = batchIds;
    
            for (uint256 i = 0; i < numOfTokenBatches; i++) {
                if (_batchID == indices[i]) {
                    if (i > 0) {
                        return indices[i - 1];
                    }
                    return 0;
                }
            }
            revert("Invalid batchId");
        }
    
        /// @dev Sets the base URI for the batch of tokens with the given batchId.
        function _setBaseURI(uint256 _batchId, string memory _baseURI) internal {
            require(!batchFrozen[_batchId], "Batch frozen");
            baseURI[_batchId] = _baseURI;
            emit BatchMetadataUpdate(_getBatchStartId(_batchId), _batchId);
        }
    
        /// @dev Freezes the base URI for the batch of tokens with the given batchId.
        function _freezeBaseURI(uint256 _batchId) internal {
            string memory baseURIForBatch = baseURI[_batchId];
            require(bytes(baseURIForBatch).length > 0, "Invalid batch");
            batchFrozen[_batchId] = true;
            emit MetadataFrozen();
        }
    
        /// @dev Mints a batch of tokenIds and associates a common baseURI to all those Ids.
        function _batchMintMetadata(
            uint256 _startId,
            uint256 _amountToMint,
            string memory _baseURIForTokens
        ) internal returns (uint256 nextTokenIdToMint, uint256 batchId) {
            batchId = _startId + _amountToMint;
            nextTokenIdToMint = batchId;
    
            batchIds.push(batchId);
    
            baseURI[batchId] = _baseURIForTokens;
        }
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    import "./interface/IContractMetadata.sol";
    
    /**
     *  @title   Contract Metadata
     *  @notice  Thirdweb's `ContractMetadata` is a contract extension for any base contracts. It lets you set a metadata URI
     *           for you contract.
     *           Additionally, `ContractMetadata` is necessary for NFT contracts that want royalties to get distributed on OpenSea.
     */
    
    abstract contract ContractMetadata is IContractMetadata {
        /// @notice Returns the contract metadata URI.
        string public override contractURI;
    
        /**
         *  @notice         Lets a contract admin set the URI for contract-level metadata.
         *  @dev            Caller should be authorized to setup contractURI, e.g. contract admin.
         *                  See {_canSetContractURI}.
         *                  Emits {ContractURIUpdated Event}.
         *
         *  @param _uri     keccak256 hash of the role. e.g. keccak256("TRANSFER_ROLE")
         */
        function setContractURI(string memory _uri) external override {
            if (!_canSetContractURI()) {
                revert("Not authorized");
            }
    
            _setupContractURI(_uri);
        }
    
        /// @dev Lets a contract admin set the URI for contract-level metadata.
        function _setupContractURI(string memory _uri) internal {
            string memory prevURI = contractURI;
            contractURI = _uri;
    
            emit ContractURIUpdated(prevURI, _uri);
        }
    
        /// @dev Returns whether contract metadata can be set in the given execution context.
        function _canSetContractURI() internal view virtual returns (bool);
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    import "./interface/IDrop1155.sol";
    import "../lib/MerkleProof.sol";
    
    abstract contract Drop1155 is IDrop1155 {
        /*///////////////////////////////////////////////////////////////
                                State variables
        //////////////////////////////////////////////////////////////*/
    
        /// @dev Mapping from token ID => the set of all claim conditions, at any given moment, for tokens of the token ID.
        mapping(uint256 => ClaimConditionList) public claimCondition;
    
        /*///////////////////////////////////////////////////////////////
                                Drop logic
        //////////////////////////////////////////////////////////////*/
    
        /// @dev Lets an account claim tokens.
        function claim(
            address _receiver,
            uint256 _tokenId,
            uint256 _quantity,
            address _currency,
            uint256 _pricePerToken,
            AllowlistProof calldata _allowlistProof,
            bytes memory _data
        ) public payable virtual override {
            _beforeClaim(_tokenId, _receiver, _quantity, _currency, _pricePerToken, _allowlistProof, _data);
    
            uint256 activeConditionId = getActiveClaimConditionId(_tokenId);
    
            verifyClaim(
                activeConditionId,
                _dropMsgSender(),
                _tokenId,
                _quantity,
                _currency,
                _pricePerToken,
                _allowlistProof
            );
    
            // Update contract state.
            claimCondition[_tokenId].conditions[activeConditionId].supplyClaimed += _quantity;
            claimCondition[_tokenId].supplyClaimedByWallet[activeConditionId][_dropMsgSender()] += _quantity;
    
            // If there's a price, collect price.
            collectPriceOnClaim(_tokenId, address(0), _quantity, _currency, _pricePerToken);
    
            // Mint the relevant NFTs to claimer.
            transferTokensOnClaim(_receiver, _tokenId, _quantity);
    
            emit TokensClaimed(activeConditionId, _dropMsgSender(), _receiver, _tokenId, _quantity);
    
            _afterClaim(_tokenId, _receiver, _quantity, _currency, _pricePerToken, _allowlistProof, _data);
        }
    
        /// @dev Lets a contract admin set claim conditions.
        function setClaimConditions(
            uint256 _tokenId,
            ClaimCondition[] calldata _conditions,
            bool _resetClaimEligibility
        ) external virtual override {
            if (!_canSetClaimConditions()) {
                revert("Not authorized");
            }
            ClaimConditionList storage conditionList = claimCondition[_tokenId];
            uint256 existingStartIndex = conditionList.currentStartId;
            uint256 existingPhaseCount = conditionList.count;
    
            /**
             *  The mapping `supplyClaimedByWallet` uses a claim condition's UID as a key.
             *
             *  If `_resetClaimEligibility == true`, we assign completely new UIDs to the claim
             *  conditions in `_conditions`, effectively resetting the restrictions on claims expressed
             *  by `supplyClaimedByWallet`.
             */
            uint256 newStartIndex = existingStartIndex;
            if (_resetClaimEligibility) {
                newStartIndex = existingStartIndex + existingPhaseCount;
            }
    
            conditionList.count = _conditions.length;
            conditionList.currentStartId = newStartIndex;
    
            uint256 lastConditionStartTimestamp;
            for (uint256 i = 0; i < _conditions.length; i++) {
                require(i == 0 || lastConditionStartTimestamp < _conditions[i].startTimestamp, "ST");
    
                uint256 supplyClaimedAlready = conditionList.conditions[newStartIndex + i].supplyClaimed;
                if (supplyClaimedAlready > _conditions[i].maxClaimableSupply) {
                    revert("max supply claimed");
                }
    
                conditionList.conditions[newStartIndex + i] = _conditions[i];
                conditionList.conditions[newStartIndex + i].supplyClaimed = supplyClaimedAlready;
    
                lastConditionStartTimestamp = _conditions[i].startTimestamp;
            }
    
            /**
             *  Gas refunds (as much as possible)
             *
             *  If `_resetClaimEligibility == true`, we assign completely new UIDs to the claim
             *  conditions in `_conditions`. So, we delete claim conditions with UID < `newStartIndex`.
             *
             *  If `_resetClaimEligibility == false`, and there are more existing claim conditions
             *  than in `_conditions`, we delete the existing claim conditions that don't get replaced
             *  by the conditions in `_conditions`.
             */
            if (_resetClaimEligibility) {
                for (uint256 i = existingStartIndex; i < newStartIndex; i++) {
                    delete conditionList.conditions[i];
                }
            } else {
                if (existingPhaseCount > _conditions.length) {
                    for (uint256 i = _conditions.length; i < existingPhaseCount; i++) {
                        delete conditionList.conditions[newStartIndex + i];
                    }
                }
            }
    
            emit ClaimConditionsUpdated(_tokenId, _conditions, _resetClaimEligibility);
        }
    
        /// @dev Checks a request to claim NFTs against the active claim condition's criteria.
        function verifyClaim(
            uint256 _conditionId,
            address _claimer,
            uint256 _tokenId,
            uint256 _quantity,
            address _currency,
            uint256 _pricePerToken,
            AllowlistProof calldata _allowlistProof
        ) public view returns (bool isOverride) {
            ClaimCondition memory currentClaimPhase = claimCondition[_tokenId].conditions[_conditionId];
            uint256 claimLimit = currentClaimPhase.quantityLimitPerWallet;
            uint256 claimPrice = currentClaimPhase.pricePerToken;
            address claimCurrency = currentClaimPhase.currency;
    
            if (currentClaimPhase.merkleRoot != bytes32(0)) {
                (isOverride, ) = MerkleProof.verify(
                    _allowlistProof.proof,
                    currentClaimPhase.merkleRoot,
                    keccak256(
                        abi.encodePacked(
                            _claimer,
                            _allowlistProof.quantityLimitPerWallet,
                            _allowlistProof.pricePerToken,
                            _allowlistProof.currency
                        )
                    )
                );
            }
    
            if (isOverride) {
                claimLimit = _allowlistProof.quantityLimitPerWallet != 0
                    ? _allowlistProof.quantityLimitPerWallet
                    : claimLimit;
                claimPrice = _allowlistProof.pricePerToken != type(uint256).max
                    ? _allowlistProof.pricePerToken
                    : claimPrice;
                claimCurrency = _allowlistProof.pricePerToken != type(uint256).max && _allowlistProof.currency != address(0)
                    ? _allowlistProof.currency
                    : claimCurrency;
            }
    
            uint256 supplyClaimedByWallet = claimCondition[_tokenId].supplyClaimedByWallet[_conditionId][_claimer];
    
            if (_currency != claimCurrency || _pricePerToken != claimPrice) {
                revert("!PriceOrCurrency");
            }
    
            if (_quantity == 0 || (_quantity + supplyClaimedByWallet > claimLimit)) {
                revert("!Qty");
            }
    
            if (currentClaimPhase.supplyClaimed + _quantity > currentClaimPhase.maxClaimableSupply) {
                revert("!MaxSupply");
            }
    
            if (currentClaimPhase.startTimestamp > block.timestamp) {
                revert("cant claim yet");
            }
        }
    
        /// @dev At any given moment, returns the uid for the active claim condition.
        function getActiveClaimConditionId(uint256 _tokenId) public view returns (uint256) {
            ClaimConditionList storage conditionList = claimCondition[_tokenId];
            for (uint256 i = conditionList.currentStartId + conditionList.count; i > conditionList.currentStartId; i--) {
                if (block.timestamp >= conditionList.conditions[i - 1].startTimestamp) {
                    return i - 1;
                }
            }
    
            revert("!CONDITION.");
        }
    
        /// @dev Returns the claim condition at the given uid.
        function getClaimConditionById(uint256 _tokenId, uint256 _conditionId)
            external
            view
            returns (ClaimCondition memory condition)
        {
            condition = claimCondition[_tokenId].conditions[_conditionId];
        }
    
        /// @dev Returns the supply claimed by claimer for a given conditionId.
        function getSupplyClaimedByWallet(
            uint256 _tokenId,
            uint256 _conditionId,
            address _claimer
        ) public view returns (uint256 supplyClaimedByWallet) {
            supplyClaimedByWallet = claimCondition[_tokenId].supplyClaimedByWallet[_conditionId][_claimer];
        }
    
        /*////////////////////////////////////////////////////////////////////
            Optional hooks that can be implemented in the derived contract
        ///////////////////////////////////////////////////////////////////*/
    
        /// @dev Exposes the ability to override the msg sender.
        function _dropMsgSender() internal virtual returns (address) {
            return msg.sender;
        }
    
        /// @dev Runs before every `claim` function call.
        function _beforeClaim(
            uint256 _tokenId,
            address _receiver,
            uint256 _quantity,
            address _currency,
            uint256 _pricePerToken,
            AllowlistProof calldata _allowlistProof,
            bytes memory _data
        ) internal virtual {}
    
        /// @dev Runs after every `claim` function call.
        function _afterClaim(
            uint256 _tokenId,
            address _receiver,
            uint256 _quantity,
            address _currency,
            uint256 _pricePerToken,
            AllowlistProof calldata _allowlistProof,
            bytes memory _data
        ) internal virtual {}
    
        /*///////////////////////////////////////////////////////////////
            Virtual functions: to be implemented in derived contract
        //////////////////////////////////////////////////////////////*/
    
        /// @dev Collects and distributes the primary sale value of NFTs being claimed.
        function collectPriceOnClaim(
            uint256 _tokenId,
            address _primarySaleRecipient,
            uint256 _quantityToClaim,
            address _currency,
            uint256 _pricePerToken
        ) internal virtual;
    
        /// @dev Transfers the NFTs being claimed.
        function transferTokensOnClaim(
            address _to,
            uint256 _tokenId,
            uint256 _quantityBeingClaimed
        ) internal virtual;
    
        /// @dev Determine what wallet can update claim conditions
        function _canSetClaimConditions() internal view virtual returns (bool);
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    import "./interface/ILazyMint.sol";
    import "./BatchMintMetadata.sol";
    
    /**
     *  The `LazyMint` is a contract extension for any base NFT contract. It lets you 'lazy mint' any number of NFTs
     *  at once. Here, 'lazy mint' means defining the metadata for particular tokenIds of your NFT contract, without actually
     *  minting a non-zero balance of NFTs of those tokenIds.
     */
    
    abstract contract LazyMint is ILazyMint, BatchMintMetadata {
        /// @notice The tokenId assigned to the next new NFT to be lazy minted.
        uint256 internal nextTokenIdToLazyMint;
    
        /**
         *  @notice                  Lets an authorized address lazy mint a given amount of NFTs.
         *
         *  @param _amount           The number of NFTs to lazy mint.
         *  @param _baseURIForTokens The base URI for the 'n' number of NFTs being lazy minted, where the metadata for each
         *                           of those NFTs is `${baseURIForTokens}/${tokenId}`.
         *  @param _data             Additional bytes data to be used at the discretion of the consumer of the contract.
         *  @return batchId          A unique integer identifier for the batch of NFTs lazy minted together.
         */
        function lazyMint(
            uint256 _amount,
            string calldata _baseURIForTokens,
            bytes calldata _data
        ) public virtual override returns (uint256 batchId) {
            if (!_canLazyMint()) {
                revert("Not authorized");
            }
    
            if (_amount == 0) {
                revert("0 amt");
            }
    
            uint256 startId = nextTokenIdToLazyMint;
    
            (nextTokenIdToLazyMint, batchId) = _batchMintMetadata(startId, _amount, _baseURIForTokens);
    
            emit TokensLazyMinted(startId, startId + _amount - 1, _baseURIForTokens, _data);
    
            return batchId;
        }
    
        /// @dev Returns whether lazy minting can be performed in the given execution context.
        function _canLazyMint() internal view virtual returns (bool);
    }

    // SPDX-License-Identifier: Apache 2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    import "../lib/TWAddress.sol";
    import "./interface/IMulticall.sol";
    
    /**
     * @dev Provides a function to batch together multiple calls in a single external call.
     *
     * _Available since v4.1._
     */
    contract Multicall is IMulticall {
        /**
         *  @notice Receives and executes a batch of function calls on this contract.
         *  @dev Receives and executes a batch of function calls on this contract.
         *
         *  @param data The bytes data that makes up the batch of function calls to execute.
         *  @return results The bytes data that makes up the result of the batch of function calls executed.
         */
        function multicall(bytes[] calldata data) external virtual override returns (bytes[] memory results) {
            results = new bytes[](data.length);
            for (uint256 i = 0; i < data.length; i++) {
                results[i] = TWAddress.functionDelegateCall(address(this), data[i]);
            }
            return results;
        }
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    import "./interface/IOwnable.sol";
    
    /**
     *  @title   Ownable
     *  @notice  Thirdweb's `Ownable` is a contract extension to be used with any base contract. It exposes functions for setting and reading
     *           who the 'owner' of the inheriting smart contract is, and lets the inheriting contract perform conditional logic that uses
     *           information about who the contract's owner is.
     */
    
    abstract contract Ownable is IOwnable {
        /// @dev Owner of the contract (purpose: OpenSea compatibility)
        address private _owner;
    
        /// @dev Reverts if caller is not the owner.
        modifier onlyOwner() {
            if (msg.sender != _owner) {
                revert("Not authorized");
            }
            _;
        }
    
        /**
         *  @notice Returns the owner of the contract.
         */
        function owner() public view override returns (address) {
            return _owner;
        }
    
        /**
         *  @notice Lets an authorized wallet set a new owner for the contract.
         *  @param _newOwner The address to set as the new owner of the contract.
         */
        function setOwner(address _newOwner) external override {
            if (!_canSetOwner()) {
                revert("Not authorized");
            }
            _setupOwner(_newOwner);
        }
    
        /// @dev Lets a contract admin set a new owner for the contract. The new owner must be a contract admin.
        function _setupOwner(address _newOwner) internal {
            address _prevOwner = _owner;
            _owner = _newOwner;
    
            emit OwnerUpdated(_prevOwner, _newOwner);
        }
    
        /// @dev Returns whether owner can be set in the given execution context.
        function _canSetOwner() internal view virtual returns (bool);
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    import "./interface/IPermissions.sol";
    import "../lib/TWStrings.sol";
    
    /**
     *  @title   Permissions
     *  @dev     This contracts provides extending-contracts with role-based access control mechanisms
     */
    contract Permissions is IPermissions {
        /// @dev Map from keccak256 hash of a role => a map from address => whether address has role.
        mapping(bytes32 => mapping(address => bool)) private _hasRole;
    
        /// @dev Map from keccak256 hash of a role to role admin. See {getRoleAdmin}.
        mapping(bytes32 => bytes32) private _getRoleAdmin;
    
        /// @dev Default admin role for all roles. Only accounts with this role can grant/revoke other roles.
        bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
    
        /// @dev Modifier that checks if an account has the specified role; reverts otherwise.
        modifier onlyRole(bytes32 role) {
            _checkRole(role, msg.sender);
            _;
        }
    
        /**
         *  @notice         Checks whether an account has a particular role.
         *  @dev            Returns `true` if `account` has been granted `role`.
         *
         *  @param role     keccak256 hash of the role. e.g. keccak256("TRANSFER_ROLE")
         *  @param account  Address of the account for which the role is being checked.
         */
        function hasRole(bytes32 role, address account) public view override returns (bool) {
            return _hasRole[role][account];
        }
    
        /**
         *  @notice         Checks whether an account has a particular role;
         *                  role restrictions can be swtiched on and off.
         *
         *  @dev            Returns `true` if `account` has been granted `role`.
         *                  Role restrictions can be swtiched on and off:
         *                      - If address(0) has ROLE, then the ROLE restrictions
         *                        don't apply.
         *                      - If address(0) does not have ROLE, then the ROLE
         *                        restrictions will apply.
         *
         *  @param role     keccak256 hash of the role. e.g. keccak256("TRANSFER_ROLE")
         *  @param account  Address of the account for which the role is being checked.
         */
        function hasRoleWithSwitch(bytes32 role, address account) public view returns (bool) {
            if (!_hasRole[role][address(0)]) {
                return _hasRole[role][account];
            }
    
            return true;
        }
    
        /**
         *  @notice         Returns the admin role that controls the specified role.
         *  @dev            See {grantRole} and {revokeRole}.
         *                  To change a role's admin, use {_setRoleAdmin}.
         *
         *  @param role     keccak256 hash of the role. e.g. keccak256("TRANSFER_ROLE")
         */
        function getRoleAdmin(bytes32 role) external view override returns (bytes32) {
            return _getRoleAdmin[role];
        }
    
        /**
         *  @notice         Grants a role to an account, if not previously granted.
         *  @dev            Caller must have admin role for the `role`.
         *                  Emits {RoleGranted Event}.
         *
         *  @param role     keccak256 hash of the role. e.g. keccak256("TRANSFER_ROLE")
         *  @param account  Address of the account to which the role is being granted.
         */
        function grantRole(bytes32 role, address account) public virtual override {
            _checkRole(_getRoleAdmin[role], msg.sender);
            if (_hasRole[role][account]) {
                revert("Can only grant to non holders");
            }
            _setupRole(role, account);
        }
    
        /**
         *  @notice         Revokes role from an account.
         *  @dev            Caller must have admin role for the `role`.
         *                  Emits {RoleRevoked Event}.
         *
         *  @param role     keccak256 hash of the role. e.g. keccak256("TRANSFER_ROLE")
         *  @param account  Address of the account from which the role is being revoked.
         */
        function revokeRole(bytes32 role, address account) public virtual override {
            _checkRole(_getRoleAdmin[role], msg.sender);
            _revokeRole(role, account);
        }
    
        /**
         *  @notice         Revokes role from the account.
         *  @dev            Caller must have the `role`, with caller being the same as `account`.
         *                  Emits {RoleRevoked Event}.
         *
         *  @param role     keccak256 hash of the role. e.g. keccak256("TRANSFER_ROLE")
         *  @param account  Address of the account from which the role is being revoked.
         */
        function renounceRole(bytes32 role, address account) public virtual override {
            if (msg.sender != account) {
                revert("Can only renounce for self");
            }
            _revokeRole(role, account);
        }
    
        /// @dev Sets `adminRole` as `role`'s admin role.
        function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
            bytes32 previousAdminRole = _getRoleAdmin[role];
            _getRoleAdmin[role] = adminRole;
            emit RoleAdminChanged(role, previousAdminRole, adminRole);
        }
    
        /// @dev Sets up `role` for `account`
        function _setupRole(bytes32 role, address account) internal virtual {
            _hasRole[role][account] = true;
            emit RoleGranted(role, account, msg.sender);
        }
    
        /// @dev Revokes `role` from `account`
        function _revokeRole(bytes32 role, address account) internal virtual {
            _checkRole(role, account);
            delete _hasRole[role][account];
            emit RoleRevoked(role, account, msg.sender);
        }
    
        /// @dev Checks `role` for `account`. Reverts with a message including the required role.
        function _checkRole(bytes32 role, address account) internal view virtual {
            if (!_hasRole[role][account]) {
                revert(
                    string(
                        abi.encodePacked(
                            "Permissions: account ",
                            TWStrings.toHexString(uint160(account), 20),
                            " is missing role ",
                            TWStrings.toHexString(uint256(role), 32)
                        )
                    )
                );
            }
        }
    
        /// @dev Checks `role` for `account`. Reverts with a message including the required role.
        function _checkRoleWithSwitch(bytes32 role, address account) internal view virtual {
            if (!hasRoleWithSwitch(role, account)) {
                revert(
                    string(
                        abi.encodePacked(
                            "Permissions: account ",
                            TWStrings.toHexString(uint160(account), 20),
                            " is missing role ",
                            TWStrings.toHexString(uint256(role), 32)
                        )
                    )
                );
            }
        }
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    import "./interface/IPermissionsEnumerable.sol";
    import "./Permissions.sol";
    
    /**
     *  @title   PermissionsEnumerable
     *  @dev     This contracts provides extending-contracts with role-based access control mechanisms.
     *           Also provides interfaces to view all members with a given role, and total count of members.
     */
    contract PermissionsEnumerable is IPermissionsEnumerable, Permissions {
        /**
         *  @notice A data structure to store data of members for a given role.
         *
         *  @param index    Current index in the list of accounts that have a role.
         *  @param members  map from index => address of account that has a role
         *  @param indexOf  map from address => index which the account has.
         */
        struct RoleMembers {
            uint256 index;
            mapping(uint256 => address) members;
            mapping(address => uint256) indexOf;
        }
    
        /// @dev map from keccak256 hash of a role to its members' data. See {RoleMembers}.
        mapping(bytes32 => RoleMembers) private roleMembers;
    
        /**
         *  @notice         Returns the role-member from a list of members for a role,
         *                  at a given index.
         *  @dev            Returns `member` who has `role`, at `index` of role-members list.
         *                  See struct {RoleMembers}, and mapping {roleMembers}
         *
         *  @param role     keccak256 hash of the role. e.g. keccak256("TRANSFER_ROLE")
         *  @param index    Index in list of current members for the role.
         *
         *  @return member  Address of account that has `role`
         */
        function getRoleMember(bytes32 role, uint256 index) external view override returns (address member) {
            uint256 currentIndex = roleMembers[role].index;
            uint256 check;
    
            for (uint256 i = 0; i < currentIndex; i += 1) {
                if (roleMembers[role].members[i] != address(0)) {
                    if (check == index) {
                        member = roleMembers[role].members[i];
                        return member;
                    }
                    check += 1;
                } else if (hasRole(role, address(0)) && i == roleMembers[role].indexOf[address(0)]) {
                    check += 1;
                }
            }
        }
    
        /**
         *  @notice         Returns total number of accounts that have a role.
         *  @dev            Returns `count` of accounts that have `role`.
         *                  See struct {RoleMembers}, and mapping {roleMembers}
         *
         *  @param role     keccak256 hash of the role. e.g. keccak256("TRANSFER_ROLE")
         *
         *  @return count   Total number of accounts that have `role`
         */
        function getRoleMemberCount(bytes32 role) external view override returns (uint256 count) {
            uint256 currentIndex = roleMembers[role].index;
    
            for (uint256 i = 0; i < currentIndex; i += 1) {
                if (roleMembers[role].members[i] != address(0)) {
                    count += 1;
                }
            }
            if (hasRole(role, address(0))) {
                count += 1;
            }
        }
    
        /// @dev Revokes `role` from `account`, and removes `account` from {roleMembers}
        ///      See {_removeMember}
        function _revokeRole(bytes32 role, address account) internal override {
            super._revokeRole(role, account);
            _removeMember(role, account);
        }
    
        /// @dev Grants `role` to `account`, and adds `account` to {roleMembers}
        ///      See {_addMember}
        function _setupRole(bytes32 role, address account) internal override {
            super._setupRole(role, account);
            _addMember(role, account);
        }
    
        /// @dev adds `account` to {roleMembers}, for `role`
        function _addMember(bytes32 role, address account) internal {
            uint256 idx = roleMembers[role].index;
            roleMembers[role].index += 1;
    
            roleMembers[role].members[idx] = account;
            roleMembers[role].indexOf[account] = idx;
        }
    
        /// @dev removes `account` from {roleMembers}, for `role`
        function _removeMember(bytes32 role, address account) internal {
            uint256 idx = roleMembers[role].indexOf[account];
    
            delete roleMembers[role].members[idx];
            delete roleMembers[role].indexOf[account];
        }
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    import "./interface/IPrimarySale.sol";
    
    /**
     *  @title   Primary Sale
     *  @notice  Thirdweb's `PrimarySale` is a contract extension to be used with any base contract. It exposes functions for setting and reading
     *           the recipient of primary sales, and lets the inheriting contract perform conditional logic that uses information about
     *           primary sales, if desired.
     */
    
    abstract contract PrimarySale is IPrimarySale {
        /// @dev The address that receives all primary sales value.
        address private recipient;
    
        /// @dev Returns primary sale recipient address.
        function primarySaleRecipient() public view override returns (address) {
            return recipient;
        }
    
        /**
         *  @notice         Updates primary sale recipient.
         *  @dev            Caller should be authorized to set primary sales info.
         *                  See {_canSetPrimarySaleRecipient}.
         *                  Emits {PrimarySaleRecipientUpdated Event}; See {_setupPrimarySaleRecipient}.
         *
         *  @param _saleRecipient   Address to be set as new recipient of primary sales.
         */
        function setPrimarySaleRecipient(address _saleRecipient) external override {
            if (!_canSetPrimarySaleRecipient()) {
                revert("Not authorized");
            }
            _setupPrimarySaleRecipient(_saleRecipient);
        }
    
        /// @dev Lets a contract admin set the recipient for all primary sales.
        function _setupPrimarySaleRecipient(address _saleRecipient) internal {
            recipient = _saleRecipient;
            emit PrimarySaleRecipientUpdated(_saleRecipient);
        }
    
        /// @dev Returns whether primary sale recipient can be set in the given execution context.
        function _canSetPrimarySaleRecipient() internal view virtual returns (bool);
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    import "./interface/IRoyalty.sol";
    
    /**
     *  @title   Royalty
     *  @notice  Thirdweb's `Royalty` is a contract extension to be used with any base contract. It exposes functions for setting and reading
     *           the recipient of royalty fee and the royalty fee basis points, and lets the inheriting contract perform conditional logic
     *           that uses information about royalty fees, if desired.
     *
     *  @dev     The `Royalty` contract is ERC2981 compliant.
     */
    
    abstract contract Royalty is IRoyalty {
        /// @dev The (default) address that receives all royalty value.
        address private royaltyRecipient;
    
        /// @dev The (default) % of a sale to take as royalty (in basis points).
        uint16 private royaltyBps;
    
        /// @dev Token ID => royalty recipient and bps for token
        mapping(uint256 => RoyaltyInfo) private royaltyInfoForToken;
    
        /**
         *  @notice   View royalty info for a given token and sale price.
         *  @dev      Returns royalty amount and recipient for `tokenId` and `salePrice`.
         *  @param tokenId          The tokenID of the NFT for which to query royalty info.
         *  @param salePrice        Sale price of the token.
         *
         *  @return receiver        Address of royalty recipient account.
         *  @return royaltyAmount   Royalty amount calculated at current royaltyBps value.
         */
        function royaltyInfo(uint256 tokenId, uint256 salePrice)
            external
            view
            virtual
            override
            returns (address receiver, uint256 royaltyAmount)
        {
            (address recipient, uint256 bps) = getRoyaltyInfoForToken(tokenId);
            receiver = recipient;
            royaltyAmount = (salePrice * bps) / 10_000;
        }
    
        /**
         *  @notice          View royalty info for a given token.
         *  @dev             Returns royalty recipient and bps for `_tokenId`.
         *  @param _tokenId  The tokenID of the NFT for which to query royalty info.
         */
        function getRoyaltyInfoForToken(uint256 _tokenId) public view override returns (address, uint16) {
            RoyaltyInfo memory royaltyForToken = royaltyInfoForToken[_tokenId];
    
            return
                royaltyForToken.recipient == address(0)
                    ? (royaltyRecipient, uint16(royaltyBps))
                    : (royaltyForToken.recipient, uint16(royaltyForToken.bps));
        }
    
        /**
         *  @notice Returns the defualt royalty recipient and BPS for this contract's NFTs.
         */
        function getDefaultRoyaltyInfo() external view override returns (address, uint16) {
            return (royaltyRecipient, uint16(royaltyBps));
        }
    
        /**
         *  @notice         Updates default royalty recipient and bps.
         *  @dev            Caller should be authorized to set royalty info.
         *                  See {_canSetRoyaltyInfo}.
         *                  Emits {DefaultRoyalty Event}; See {_setupDefaultRoyaltyInfo}.
         *
         *  @param _royaltyRecipient   Address to be set as default royalty recipient.
         *  @param _royaltyBps         Updated royalty bps.
         */
        function setDefaultRoyaltyInfo(address _royaltyRecipient, uint256 _royaltyBps) external override {
            if (!_canSetRoyaltyInfo()) {
                revert("Not authorized");
            }
    
            _setupDefaultRoyaltyInfo(_royaltyRecipient, _royaltyBps);
        }
    
        /// @dev Lets a contract admin update the default royalty recipient and bps.
        function _setupDefaultRoyaltyInfo(address _royaltyRecipient, uint256 _royaltyBps) internal {
            if (_royaltyBps > 10_000) {
                revert("Exceeds max bps");
            }
    
            royaltyRecipient = _royaltyRecipient;
            royaltyBps = uint16(_royaltyBps);
    
            emit DefaultRoyalty(_royaltyRecipient, _royaltyBps);
        }
    
        /**
         *  @notice         Updates default royalty recipient and bps for a particular token.
         *  @dev            Sets royalty info for `_tokenId`. Caller should be authorized to set royalty info.
         *                  See {_canSetRoyaltyInfo}.
         *                  Emits {RoyaltyForToken Event}; See {_setupRoyaltyInfoForToken}.
         *
         *  @param _recipient   Address to be set as royalty recipient for given token Id.
         *  @param _bps         Updated royalty bps for the token Id.
         */
        function setRoyaltyInfoForToken(
            uint256 _tokenId,
            address _recipient,
            uint256 _bps
        ) external override {
            if (!_canSetRoyaltyInfo()) {
                revert("Not authorized");
            }
    
            _setupRoyaltyInfoForToken(_tokenId, _recipient, _bps);
        }
    
        /// @dev Lets a contract admin set the royalty recipient and bps for a particular token Id.
        function _setupRoyaltyInfoForToken(
            uint256 _tokenId,
            address _recipient,
            uint256 _bps
        ) internal {
            if (_bps > 10_000) {
                revert("Exceeds max bps");
            }
    
            royaltyInfoForToken[_tokenId] = RoyaltyInfo({ recipient: _recipient, bps: _bps });
    
            emit RoyaltyForToken(_tokenId, _recipient, _bps);
        }
    
        /// @dev Returns whether royalty info can be set in the given execution context.
        function _canSetRoyaltyInfo() internal view virtual returns (bool);
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    /**
     *  The interface `IClaimCondition` is written for thirdweb's 'Drop' contracts, which are distribution mechanisms for tokens.
     *
     *  A claim condition defines criteria under which accounts can mint tokens. Claim conditions can be overwritten
     *  or added to by the contract admin. At any moment, there is only one active claim condition.
     */
    
    interface IClaimCondition {
        /**
         *  @notice The criteria that make up a claim condition.
         *
         *  @param startTimestamp                 The unix timestamp after which the claim condition applies.
         *                                        The same claim condition applies until the `startTimestamp`
         *                                        of the next claim condition.
         *
         *  @param maxClaimableSupply             The maximum total number of tokens that can be claimed under
         *                                        the claim condition.
         *
         *  @param supplyClaimed                  At any given point, the number of tokens that have been claimed
         *                                        under the claim condition.
         *
         *  @param quantityLimitPerWallet         The maximum number of tokens that can be claimed by a wallet.
         *
         *  @param merkleRoot                     The allowlist of addresses that can claim tokens under the claim
         *                                        condition.
         *
         *  @param pricePerToken                  The price required to pay per token claimed.
         *
         *  @param currency                       The currency in which the `pricePerToken` must be paid.
         *
         *  @param metadata                       Claim condition metadata.
         */
        struct ClaimCondition {
            uint256 startTimestamp;
            uint256 maxClaimableSupply;
            uint256 supplyClaimed;
            uint256 quantityLimitPerWallet;
            bytes32 merkleRoot;
            uint256 pricePerToken;
            address currency;
            string metadata;
        }
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    import "./IClaimCondition.sol";
    
    /**
     *  The interface `IClaimConditionMultiPhase` is written for thirdweb's 'Drop' contracts, which are distribution mechanisms for tokens.
     *
     *  An authorized wallet can set a series of claim conditions, ordered by their respective `startTimestamp`.
     *  A claim condition defines criteria under which accounts can mint tokens. Claim conditions can be overwritten
     *  or added to by the contract admin. At any moment, there is only one active claim condition.
     */
    
    interface IClaimConditionMultiPhase is IClaimCondition {
        /**
         *  @notice The set of all claim conditions, at any given moment.
         *  Claim Phase ID = [currentStartId, currentStartId + length - 1];
         *
         *  @param currentStartId           The uid for the first claim condition amongst the current set of
         *                                  claim conditions. The uid for each next claim condition is one
         *                                  more than the previous claim condition's uid.
         *
         *  @param count                    The total number of phases / claim conditions in the list
         *                                  of claim conditions.
         *
         *  @param conditions                   The claim conditions at a given uid. Claim conditions
         *                                  are ordered in an ascending order by their `startTimestamp`.
         *
         *  @param supplyClaimedByWallet    Map from a claim condition uid and account to supply claimed by account.
         */
        struct ClaimConditionList {
            uint256 currentStartId;
            uint256 count;
            mapping(uint256 => ClaimCondition) conditions;
            mapping(uint256 => mapping(address => uint256)) supplyClaimedByWallet;
        }
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    /**
     *  Thirdweb's `ContractMetadata` is a contract extension for any base contracts. It lets you set a metadata URI
     *  for you contract.
     *
     *  Additionally, `ContractMetadata` is necessary for NFT contracts that want royalties to get distributed on OpenSea.
     */
    
    interface IContractMetadata {
        /// @dev Returns the metadata URI of the contract.
        function contractURI() external view returns (string memory);
    
        /**
         *  @dev Sets contract URI for the storefront-level metadata of the contract.
         *       Only module admin can call this function.
         */
        function setContractURI(string calldata _uri) external;
    
        /// @dev Emitted when the contract URI is updated.
        event ContractURIUpdated(string prevURI, string newURI);
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    import "./IClaimConditionMultiPhase.sol";
    
    /**
     *  The interface `IDrop1155` is written for thirdweb's 'Drop' contracts, which are distribution mechanisms for tokens.
     *
     *  An authorized wallet can set a series of claim conditions, ordered by their respective `startTimestamp`.
     *  A claim condition defines criteria under which accounts can mint tokens. Claim conditions can be overwritten
     *  or added to by the contract admin. At any moment, there is only one active claim condition.
     */
    
    interface IDrop1155 is IClaimConditionMultiPhase {
        /**
         *  @param proof Proof of concerned wallet's inclusion in an allowlist.
         *  @param quantityLimitPerWallet The total quantity of tokens the allowlisted wallet is eligible to claim over time.
         *  @param pricePerToken The price per token the allowlisted wallet must pay to claim tokens.
         *  @param currency The currency in which the allowlisted wallet must pay the price for claiming tokens.
         */
        struct AllowlistProof {
            bytes32[] proof;
            uint256 quantityLimitPerWallet;
            uint256 pricePerToken;
            address currency;
        }
    
        /// @notice Emitted when tokens are claimed.
        event TokensClaimed(
            uint256 indexed claimConditionIndex,
            address indexed claimer,
            address indexed receiver,
            uint256 tokenId,
            uint256 quantityClaimed
        );
    
        /// @notice Emitted when the contract's claim conditions are updated.
        event ClaimConditionsUpdated(uint256 indexed tokenId, ClaimCondition[] claimConditions, bool resetEligibility);
    
        /**
         *  @notice Lets an account claim a given quantity of NFTs.
         *
         *  @param receiver                       The receiver of the NFTs to claim.
         *  @param tokenId                        The tokenId of the NFT to claim.
         *  @param quantity                       The quantity of NFTs to claim.
         *  @param currency                       The currency in which to pay for the claim.
         *  @param pricePerToken                  The price per token to pay for the claim.
         *  @param allowlistProof                 The proof of the claimer's inclusion in the merkle root allowlist
         *                                        of the claim conditions that apply.
         *  @param data                           Arbitrary bytes data that can be leveraged in the implementation of this interface.
         */
        function claim(
            address receiver,
            uint256 tokenId,
            uint256 quantity,
            address currency,
            uint256 pricePerToken,
            AllowlistProof calldata allowlistProof,
            bytes memory data
        ) external payable;
    
        /**
         *  @notice Lets a contract admin (account with `DEFAULT_ADMIN_ROLE`) set claim conditions.
         *
         *  @param tokenId                  The token ID for which to set mint conditions.
         *  @param phases                   Claim conditions in ascending order by `startTimestamp`.
         *
         *  @param resetClaimEligibility    Whether to honor the restrictions applied to wallets who have claimed tokens in the current conditions,
         *                                  in the new claim conditions being set.
         *
         */
        function setClaimConditions(
            uint256 tokenId,
            ClaimCondition[] calldata phases,
            bool resetClaimEligibility
        ) external;
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    /**
     *  Thirdweb's `LazyMint` is a contract extension for any base NFT contract. It lets you 'lazy mint' any number of NFTs
     *  at once. Here, 'lazy mint' means defining the metadata for particular tokenIds of your NFT contract, without actually
     *  minting a non-zero balance of NFTs of those tokenIds.
     */
    
    interface ILazyMint {
        /// @dev Emitted when tokens are lazy minted.
        event TokensLazyMinted(uint256 indexed startTokenId, uint256 endTokenId, string baseURI, bytes encryptedBaseURI);
    
        /**
         *  @notice Lazy mints a given amount of NFTs.
         *
         *  @param amount           The number of NFTs to lazy mint.
         *
         *  @param baseURIForTokens The base URI for the 'n' number of NFTs being lazy minted, where the metadata for each
         *                          of those NFTs is `${baseURIForTokens}/${tokenId}`.
         *
         *  @param extraData        Additional bytes data to be used at the discretion of the consumer of the contract.
         *
         *  @return batchId         A unique integer identifier for the batch of NFTs lazy minted together.
         */
        function lazyMint(
            uint256 amount,
            string calldata baseURIForTokens,
            bytes calldata extraData
        ) external returns (uint256 batchId);
    }

    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    /**
     * @dev Provides a function to batch together multiple calls in a single external call.
     *
     * _Available since v4.1._
     */
    interface IMulticall {
        /**
         * @dev Receives and executes a batch of function calls on this contract.
         */
        function multicall(bytes[] calldata data) external returns (bytes[] memory results);
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    /**
     *  Thirdweb's `Ownable` is a contract extension to be used with any base contract. It exposes functions for setting and reading
     *  who the 'owner' of the inheriting smart contract is, and lets the inheriting contract perform conditional logic that uses
     *  information about who the contract's owner is.
     */
    
    interface IOwnable {
        /// @dev Returns the owner of the contract.
        function owner() external view returns (address);
    
        /// @dev Lets a module admin set a new owner for the contract. The new owner must be a module admin.
        function setOwner(address _newOwner) external;
    
        /// @dev Emitted when a new Owner is set.
        event OwnerUpdated(address indexed prevOwner, address indexed newOwner);
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    /**
     * @dev External interface of AccessControl declared to support ERC165 detection.
     */
    interface IPermissions {
        /**
         * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
         *
         * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
         * {RoleAdminChanged} not being emitted signaling this.
         *
         * _Available since v3.1._
         */
        event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
    
        /**
         * @dev Emitted when `account` is granted `role`.
         *
         * `sender` is the account that originated the contract call, an admin role
         * bearer except when using {AccessControl-_setupRole}.
         */
        event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
    
        /**
         * @dev Emitted when `account` is revoked `role`.
         *
         * `sender` is the account that originated the contract call:
         *   - if using `revokeRole`, it is the admin role bearer
         *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
         */
        event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
    
        /**
         * @dev Returns `true` if `account` has been granted `role`.
         */
        function hasRole(bytes32 role, address account) external view returns (bool);
    
        /**
         * @dev Returns the admin role that controls `role`. See {grantRole} and
         * {revokeRole}.
         *
         * To change a role's admin, use {AccessControl-_setRoleAdmin}.
         */
        function getRoleAdmin(bytes32 role) external view returns (bytes32);
    
        /**
         * @dev Grants `role` to `account`.
         *
         * If `account` had not been already granted `role`, emits a {RoleGranted}
         * event.
         *
         * Requirements:
         *
         * - the caller must have ``role``'s admin role.
         */
        function grantRole(bytes32 role, address account) external;
    
        /**
         * @dev Revokes `role` from `account`.
         *
         * If `account` had been granted `role`, emits a {RoleRevoked} event.
         *
         * Requirements:
         *
         * - the caller must have ``role``'s admin role.
         */
        function revokeRole(bytes32 role, address account) external;
    
        /**
         * @dev Revokes `role` from the calling account.
         *
         * Roles are often managed via {grantRole} and {revokeRole}: this function's
         * purpose is to provide a mechanism for accounts to lose their privileges
         * if they are compromised (such as when a trusted device is misplaced).
         *
         * If the calling account had been granted `role`, emits a {RoleRevoked}
         * event.
         *
         * Requirements:
         *
         * - the caller must be `account`.
         */
        function renounceRole(bytes32 role, address account) external;
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    import "./IPermissions.sol";
    
    /**
     * @dev External interface of AccessControlEnumerable declared to support ERC165 detection.
     */
    interface IPermissionsEnumerable is IPermissions {
        /**
         * @dev Returns one of the accounts that have `role`. `index` must be a
         * value between 0 and {getRoleMemberCount}, non-inclusive.
         *
         * Role bearers are not sorted in any particular way, and their ordering may
         * change at any point.
         *
         * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
         * you perform all queries on the same block. See the following
         * [forum post](https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296)
         * for more information.
         */
        function getRoleMember(bytes32 role, uint256 index) external view returns (address);
    
        /**
         * @dev Returns the number of accounts that have `role`. Can be used
         * together with {getRoleMember} to enumerate all bearers of a role.
         */
        function getRoleMemberCount(bytes32 role) external view returns (uint256);
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    /**
     *  Thirdweb's `Primary` is a contract extension to be used with any base contract. It exposes functions for setting and reading
     *  the recipient of primary sales, and lets the inheriting contract perform conditional logic that uses information about
     *  primary sales, if desired.
     */
    
    interface IPrimarySale {
        /// @dev The adress that receives all primary sales value.
        function primarySaleRecipient() external view returns (address);
    
        /// @dev Lets a module admin set the default recipient of all primary sales.
        function setPrimarySaleRecipient(address _saleRecipient) external;
    
        /// @dev Emitted when a new sale recipient is set.
        event PrimarySaleRecipientUpdated(address indexed recipient);
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    import "../../eip/interface/IERC2981.sol";
    
    /**
     *  Thirdweb's `Royalty` is a contract extension to be used with any base contract. It exposes functions for setting and reading
     *  the recipient of royalty fee and the royalty fee basis points, and lets the inheriting contract perform conditional logic
     *  that uses information about royalty fees, if desired.
     *
     *  The `Royalty` contract is ERC2981 compliant.
     */
    
    interface IRoyalty is IERC2981 {
        struct RoyaltyInfo {
            address recipient;
            uint256 bps;
        }
    
        /// @dev Returns the royalty recipient and fee bps.
        function getDefaultRoyaltyInfo() external view returns (address, uint16);
    
        /// @dev Lets a module admin update the royalty bps and recipient.
        function setDefaultRoyaltyInfo(address _royaltyRecipient, uint256 _royaltyBps) external;
    
        /// @dev Lets a module admin set the royalty recipient for a particular token Id.
        function setRoyaltyInfoForToken(
            uint256 tokenId,
            address recipient,
            uint256 bps
        ) external;
    
        /// @dev Returns the royalty recipient for a particular token Id.
        function getRoyaltyInfoForToken(uint256 tokenId) external view returns (address, uint16);
    
        /// @dev Emitted when royalty info is updated.
        event DefaultRoyalty(address indexed newRoyaltyRecipient, uint256 newRoyaltyBps);
    
        /// @dev Emitted when royalty recipient for tokenId is set
        event RoyaltyForToken(uint256 indexed tokenId, address indexed royaltyRecipient, uint256 royaltyBps);
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)
    
    pragma solidity ^0.8.0;
    
    import "../../../../../eip/interface/IERC20.sol";
    import "../../../../../lib/TWAddress.sol";
    
    /**
     * @title SafeERC20
     * @dev Wrappers around ERC20 operations that throw on failure (when the token
     * contract returns false). Tokens that return no value (and instead revert or
     * throw on failure) are also supported, non-reverting calls are assumed to be
     * successful.
     * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
     * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
     */
    library SafeERC20 {
        using TWAddress for address;
    
        function safeTransfer(
            IERC20 token,
            address to,
            uint256 value
        ) internal {
            _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
        }
    
        function safeTransferFrom(
            IERC20 token,
            address from,
            address to,
            uint256 value
        ) internal {
            _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
        }
    
        /**
         * @dev Deprecated. This function has issues similar to the ones found in
         * {IERC20-approve}, and its usage is discouraged.
         *
         * Whenever possible, use {safeIncreaseAllowance} and
         * {safeDecreaseAllowance} instead.
         */
        function safeApprove(
            IERC20 token,
            address spender,
            uint256 value
        ) internal {
            // safeApprove should only be called when setting an initial allowance,
            // or when resetting it to zero. To increase and decrease it, use
            // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
            require(
                (value == 0) || (token.allowance(address(this), spender) == 0),
                "SafeERC20: approve from non-zero to non-zero allowance"
            );
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
        }
    
        function safeIncreaseAllowance(
            IERC20 token,
            address spender,
            uint256 value
        ) internal {
            uint256 newAllowance = token.allowance(address(this), spender) + value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    
        function safeDecreaseAllowance(
            IERC20 token,
            address spender,
            uint256 value
        ) internal {
            unchecked {
                uint256 oldAllowance = token.allowance(address(this), spender);
                require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
                uint256 newAllowance = oldAllowance - value;
                _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
            }
        }
    
        /**
         * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
         * on the return value: the return value is optional (but if data is returned, it must not be false).
         * @param token The token targeted by the call.
         * @param data The call data (encoded using abi.encode or one of its variants).
         */
        function _callOptionalReturn(IERC20 token, bytes memory data) private {
            // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
            // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
            // the target address contains contract code and also asserts for success in the low-level call.
    
            bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
            if (returndata.length > 0) {
                // Return data is optional
                require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
            }
        }
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    interface IWETH {
        function deposit() external payable;
    
        function withdraw(uint256 amount) external;
    
        function transfer(address to, uint256 value) external returns (bool);
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    // Helper interfaces
    import { IWETH } from "../infra/interface/IWETH.sol";
    
    import "../external-deps/openzeppelin/token/ERC20/utils/SafeERC20.sol";
    
    library CurrencyTransferLib {
        using SafeERC20 for IERC20;
    
        /// @dev The address interpreted as native token of the chain.
        address public constant NATIVE_TOKEN = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
    
        /// @dev Transfers a given amount of currency.
        function transferCurrency(
            address _currency,
            address _from,
            address _to,
            uint256 _amount
        ) internal {
            if (_amount == 0) {
                return;
            }
    
            if (_currency == NATIVE_TOKEN) {
                safeTransferNativeToken(_to, _amount);
            } else {
                safeTransferERC20(_currency, _from, _to, _amount);
            }
        }
    
        /// @dev Transfers a given amount of currency. (With native token wrapping)
        function transferCurrencyWithWrapper(
            address _currency,
            address _from,
            address _to,
            uint256 _amount,
            address _nativeTokenWrapper
        ) internal {
            if (_amount == 0) {
                return;
            }
    
            if (_currency == NATIVE_TOKEN) {
                if (_from == address(this)) {
                    // withdraw from weth then transfer withdrawn native token to recipient
                    IWETH(_nativeTokenWrapper).withdraw(_amount);
                    safeTransferNativeTokenWithWrapper(_to, _amount, _nativeTokenWrapper);
                } else if (_to == address(this)) {
                    // store native currency in weth
                    require(_amount == msg.value, "msg.value != amount");
                    IWETH(_nativeTokenWrapper).deposit{ value: _amount }();
                } else {
                    safeTransferNativeTokenWithWrapper(_to, _amount, _nativeTokenWrapper);
                }
            } else {
                safeTransferERC20(_currency, _from, _to, _amount);
            }
        }
    
        /// @dev Transfer `amount` of ERC20 token from `from` to `to`.
        function safeTransferERC20(
            address _currency,
            address _from,
            address _to,
            uint256 _amount
        ) internal {
            if (_from == _to) {
                return;
            }
    
            if (_from == address(this)) {
                IERC20(_currency).safeTransfer(_to, _amount);
            } else {
                IERC20(_currency).safeTransferFrom(_from, _to, _amount);
            }
        }
    
        /// @dev Transfers `amount` of native token to `to`.
        function safeTransferNativeToken(address to, uint256 value) internal {
            // solhint-disable avoid-low-level-calls
            // slither-disable-next-line low-level-calls
            (bool success, ) = to.call{ value: value }("");
            require(success, "native token transfer failed");
        }
    
        /// @dev Transfers `amount` of native token to `to`. (With native token wrapping)
        function safeTransferNativeTokenWithWrapper(
            address to,
            uint256 value,
            address _nativeTokenWrapper
        ) internal {
            // solhint-disable avoid-low-level-calls
            // slither-disable-next-line low-level-calls
            (bool success, ) = to.call{ value: value }("");
            if (!success) {
                IWETH(_nativeTokenWrapper).deposit{ value: value }();
                IERC20(_nativeTokenWrapper).safeTransfer(to, value);
            }
        }
    }

    // SPDX-License-Identifier: Apache 2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    /**
     * @dev These functions deal with verification of Merkle Trees proofs.
     *
     * The proofs can be generated using the JavaScript library
     * https://github.com/miguelmota/merkletreejs[merkletreejs].
     * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
     *
     * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
     *
     * Source: https://github.com/ensdomains/governance/blob/master/contracts/MerkleProof.sol
     */
    library MerkleProof {
        /**
         * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
         * defined by `root`. For this, a `proof` must be provided, containing
         * sibling hashes on the branch from the leaf to the root of the tree. Each
         * pair of leaves and each pair of pre-images are assumed to be sorted.
         */
        function verify(
            bytes32[] memory proof,
            bytes32 root,
            bytes32 leaf
        ) internal pure returns (bool, uint256) {
            bytes32 computedHash = leaf;
            uint256 index = 0;
    
            for (uint256 i = 0; i < proof.length; i++) {
                index *= 2;
                bytes32 proofElement = proof[i];
    
                if (computedHash <= proofElement) {
                    // Hash(current computed hash + current element of the proof)
                    computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
                } else {
                    // Hash(current element of the proof + current computed hash)
                    computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
                    index += 1;
                }
            }
    
            // Check if the computed hash (root) is equal to the provided root
            return (computedHash == root, index);
        }
    }

    // SPDX-License-Identifier: Apache 2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    /**
     * @dev Collection of functions related to the address type
     */
    library TWAddress {
        /**
         * @dev Returns true if `account` is a contract.
         *
         * [IMPORTANT]
         * ====
         * It is unsafe to assume that an address for which this function returns
         * false is an externally-owned account (EOA) and not a contract.
         *
         * Among others, `isContract` will return false for the following
         * types of addresses:
         *
         *  - an externally-owned account
         *  - a contract in construction
         *  - an address where a contract will be created
         *  - an address where a contract lived, but was destroyed
         * ====
         *
         * [IMPORTANT]
         * ====
         * You shouldn't rely on `isContract` to protect against flash loan attacks!
         *
         * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
         * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
         * constructor.
         * ====
         */
        function isContract(address account) internal view returns (bool) {
            // This method relies on extcodesize/address.code.length, which returns 0
            // for contracts in construction, since the code is only stored at the end
            // of the constructor execution.
    
            return account.code.length > 0;
        }
    
        /**
         * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
         * `recipient`, forwarding all available gas and reverting on errors.
         *
         * [EIP1884](https://eips.ethereum.org/EIPS/eip-1884) increases the gas cost
         * of certain opcodes, possibly making contracts go over the 2300 gas limit
         * imposed by `transfer`, making them unable to receive funds via
         * `transfer`. {sendValue} removes this limitation.
         *
         * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
         *
         * IMPORTANT: because control is transferred to `recipient`, care must be
         * taken to not create reentrancy vulnerabilities. Consider using
         * {ReentrancyGuard} or the
         * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
         */
        function sendValue(address payable recipient, uint256 amount) internal {
            require(address(this).balance >= amount, "Address: insufficient balance");
    
            (bool success, ) = recipient.call{ value: amount }("");
            require(success, "Address: unable to send value, recipient may have reverted");
        }
    
        /**
         * @dev Performs a Solidity function call using a low level `call`. A
         * plain `call` is an unsafe replacement for a function call: use this
         * function instead.
         *
         * If `target` reverts with a revert reason, it is bubbled up by this
         * function (like regular Solidity function calls).
         *
         * Returns the raw returned data. To convert to the expected return value,
         * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
         *
         * Requirements:
         *
         * - `target` must be a contract.
         * - calling `target` with `data` must not revert.
         *
         * _Available since v3.1._
         */
        function functionCall(address target, bytes memory data) internal returns (bytes memory) {
            return functionCall(target, data, "Address: low-level call failed");
        }
    
        /**
         * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
         * `errorMessage` as a fallback revert reason when `target` reverts.
         *
         * _Available since v3.1._
         */
        function functionCall(
            address target,
            bytes memory data,
            string memory errorMessage
        ) internal returns (bytes memory) {
            return functionCallWithValue(target, data, 0, errorMessage);
        }
    
        /**
         * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
         * but also transferring `value` wei to `target`.
         *
         * Requirements:
         *
         * - the calling contract must have an ETH balance of at least `value`.
         * - the called Solidity function must be `payable`.
         *
         * _Available since v3.1._
         */
        function functionCallWithValue(
            address target,
            bytes memory data,
            uint256 value
        ) internal returns (bytes memory) {
            return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
        }
    
        /**
         * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
         * with `errorMessage` as a fallback revert reason when `target` reverts.
         *
         * _Available since v3.1._
         */
        function functionCallWithValue(
            address target,
            bytes memory data,
            uint256 value,
            string memory errorMessage
        ) internal returns (bytes memory) {
            require(address(this).balance >= value, "Address: insufficient balance for call");
            require(isContract(target), "Address: call to non-contract");
    
            (bool success, bytes memory returndata) = target.call{ value: value }(data);
            return verifyCallResult(success, returndata, errorMessage);
        }
    
        /**
         * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
         * but performing a static call.
         *
         * _Available since v3.3._
         */
        function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
            return functionStaticCall(target, data, "Address: low-level static call failed");
        }
    
        /**
         * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
         * but performing a static call.
         *
         * _Available since v3.3._
         */
        function functionStaticCall(
            address target,
            bytes memory data,
            string memory errorMessage
        ) internal view returns (bytes memory) {
            require(isContract(target), "Address: static call to non-contract");
    
            (bool success, bytes memory returndata) = target.staticcall(data);
            return verifyCallResult(success, returndata, errorMessage);
        }
    
        /**
         * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
         * but performing a delegate call.
         *
         * _Available since v3.4._
         */
        function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
            return functionDelegateCall(target, data, "Address: low-level delegate call failed");
        }
    
        /**
         * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
         * but performing a delegate call.
         *
         * _Available since v3.4._
         */
        function functionDelegateCall(
            address target,
            bytes memory data,
            string memory errorMessage
        ) internal returns (bytes memory) {
            require(isContract(target), "Address: delegate call to non-contract");
    
            (bool success, bytes memory returndata) = target.delegatecall(data);
            return verifyCallResult(success, returndata, errorMessage);
        }
    
        /**
         * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
         * revert reason using the provided one.
         *
         * _Available since v4.3._
         */
        function verifyCallResult(
            bool success,
            bytes memory returndata,
            string memory errorMessage
        ) internal pure returns (bytes memory) {
            if (success) {
                return returndata;
            } else {
                // Look for revert reason and bubble it up if present
                if (returndata.length > 0) {
                    // The easiest way to bubble the revert reason is using memory via assembly
    
                    assembly {
                        let returndata_size := mload(returndata)
                        revert(add(32, returndata), returndata_size)
                    }
                } else {
                    revert(errorMessage);
                }
            }
        }
    }

    // SPDX-License-Identifier: Apache 2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    /**
     * @dev String operations.
     */
    library TWStrings {
        bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
    
        /**
         * @dev Converts a `uint256` to its ASCII `string` decimal representation.
         */
        function toString(uint256 value) internal pure returns (string memory) {
            // Inspired by OraclizeAPI's implementation - MIT licence
            // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol
    
            if (value == 0) {
                return "0";
            }
            uint256 temp = value;
            uint256 digits;
            while (temp != 0) {
                digits++;
                temp /= 10;
            }
            bytes memory buffer = new bytes(digits);
            while (value != 0) {
                digits -= 1;
                buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
                value /= 10;
            }
            return string(buffer);
        }
    
        /**
         * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
         */
        function toHexString(uint256 value) internal pure returns (string memory) {
            if (value == 0) {
                return "0x00";
            }
            uint256 temp = value;
            uint256 length = 0;
            while (temp != 0) {
                length++;
                temp >>= 8;
            }
            return toHexString(value, length);
        }
    
        /**
         * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
         */
        function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
            bytes memory buffer = new bytes(2 * length + 2);
            buffer[0] = "0";
            buffer[1] = "x";
            for (uint256 i = 2 * length + 1; i > 1; --i) {
                buffer[i] = _HEX_SYMBOLS[value & 0xf];
                value >>= 4;
            }
            require(value == 0, "Strings: hex length insufficient");
            return string(buffer);
        }
    }

    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.0;
    
    import "@thirdweb-dev/contracts/base/ERC1155Base.sol";
    
    //  ==========  External imports    ==========
    
    //  ==========  Internal imports    ==========
    import "@thirdweb-dev/contracts/lib/CurrencyTransferLib.sol";
    import "@thirdweb-dev/contracts/lib/TWStrings.sol";
    
    //  ==========  Features    ==========
    import "@thirdweb-dev/contracts/extension/PrimarySale.sol";
    import "@thirdweb-dev/contracts/extension/LazyMint.sol";
    import "@thirdweb-dev/contracts/extension/PermissionsEnumerable.sol";
    import "@thirdweb-dev/contracts/extension/Drop1155.sol";
    import "../extension/TransactionFee.sol";
    
    contract MintpadERC1155Drop is 
        ERC1155Base,
        PrimarySale,
        LazyMint,
        TransactionFee,
        PermissionsEnumerable,
        Drop1155
    {
        using TWStrings for uint256;
    
        /*///////////////////////////////////////////////////////////////
                                State variables
        //////////////////////////////////////////////////////////////*/
    
        /// @dev Only transfers to or from TRANSFER_ROLE holders are valid, when transfers are restricted.
        bytes32 private transferRole;
        /// @dev Only MINTER_ROLE holders can sign off on `MintRequest`s and lazy mint tokens.
        bytes32 private minterRole;
    
        /*///////////////////////////////////////////////////////////////
                                    Mappings
        //////////////////////////////////////////////////////////////*/
    
        /// @dev Mapping from token ID => maximum possible total circulating supply of tokens with that ID.
        mapping(uint256 => uint256) public maxTotalSupply;
    
        /// @dev Mapping from token ID => the address of the recipient of primary sales.
        mapping(uint256 => address) public saleRecipient;
        
        constructor (
            address _defaultAdmin,
            string memory _name,
            string memory _symbol,
            address _saleRecipient,
            uint256 _transactionFee,
            address _royaltyRecipient,
            uint128 _royaltyBps
        ) 
            ERC1155Base(
                _defaultAdmin,
                _name,
                _symbol,
                _royaltyRecipient,
                _royaltyBps
            ) 
        {
            require(_transactionFee > 0, "!TransactionFee");
    
            bytes32 _transferRole = keccak256("TRANSFER_ROLE");
            bytes32 _minterRole = keccak256("MINTER_ROLE");
    
            _setupRole(DEFAULT_ADMIN_ROLE, _defaultAdmin);
            _setupRole(_minterRole, _defaultAdmin);
            _setupRole(_transferRole, _defaultAdmin);
            _setupRole(_transferRole, address(0));
    
            _setupPrimarySaleRecipient(_saleRecipient);
    
            transferRole = _transferRole;
            minterRole = _minterRole;
    
            transactionFee = _transactionFee;
        }
    
        /*///////////////////////////////////////////////////////////////
                            Contract identifiers
        //////////////////////////////////////////////////////////////*/
    
        function contractType() external pure returns (bytes32) {
            return bytes32("ERC1155");
        }
    
        /*//////////////////////////////////////////////////////////////
                            Overriden ERC1155 logic
        //////////////////////////////////////////////////////////////*/
    
        /// @dev Returns the uri for a given tokenId.
        function uri(uint256 _tokenId) public view override returns (string memory) {
            string memory batchUri = _getBaseURI(_tokenId);
            return string(abi.encodePacked(batchUri, _tokenId.toString()));
        }
    
        /*///////////////////////////////////////////////////////////////
                            Setter functions
        //////////////////////////////////////////////////////////////*/
    
        /// @dev Lets a module admin set a max total supply for token.
        function setMaxTotalSupply(uint256 _tokenId, uint256 _maxTotalSupply) external onlyRole(DEFAULT_ADMIN_ROLE) {
            maxTotalSupply[_tokenId] = _maxTotalSupply;
        }
    
        /// @dev Lets a contract admin set the recipient for all primary sales.
        function setSaleRecipientForToken(uint256 _tokenId, address _saleRecipient) external onlyRole(DEFAULT_ADMIN_ROLE) {
            saleRecipient[_tokenId] = _saleRecipient;
        }
    
        /*//////////////////////////////////////////////////////////////
                            Internal (overrideable) functions
        //////////////////////////////////////////////////////////////*/
    
        /// @dev Runs before every `claim` function call.
        function _beforeClaim(
            uint256 _tokenId,
            address,
            uint256 _quantity,
            address,
            uint256,
            AllowlistProof calldata,
            bytes memory
        ) internal view override {
            require(maxTotalSupply[_tokenId] == 0 || totalSupply[_tokenId] + _quantity <= maxTotalSupply[_tokenId], "!Supply");
        }
    
        /// @dev Collects and distributes the primary sale value of NFTs being claimed.
        function collectPriceOnClaim(
            uint256 _tokenId,
            address _primarySaleRecipient,
            uint256 _quantityToClaim,
            address _currency,
            uint256 _pricePerToken
        ) internal override {
            address _saleRecipient = _primarySaleRecipient == address(0)
                ? (saleRecipient[_tokenId] == address(0) ? primarySaleRecipient() : saleRecipient[_tokenId])
                : _primarySaleRecipient;
            uint256 totalPrice = _pricePerToken > 0 ? _quantityToClaim * _pricePerToken : 0;
    
            if (_currency == CurrencyTransferLib.NATIVE_TOKEN) {
                require (msg.value == (totalPrice + transactionFee), "!ClaimPrice");
            }
    
            if (_pricePerToken > 0) {
                CurrencyTransferLib.transferCurrency(_currency, _msgSender(), _saleRecipient, totalPrice);
            }
            CurrencyTransferLib.transferCurrency(_currency, _msgSender(), platformAddress, transactionFee);
        }
    
        /// @dev Transfers the NFTs being claimed.
        function transferTokensOnClaim(
            address _to,
            uint256 _tokenId,
            uint256 _quantityBeingClaimed
        ) internal override {
            _mint(_to, _tokenId, _quantityBeingClaimed, "");
        }
    
        /// @dev Checks whether primary sale recipient can be set in the given execution context.
        function _canSetPrimarySaleRecipient() internal view override returns (bool) {
            return hasRole(DEFAULT_ADMIN_ROLE, _msgSender());
        }
    
        /// @dev Checks whether owner can be set in the given execution context.
        function _canSetOwner() internal view override returns (bool) {
            return hasRole(DEFAULT_ADMIN_ROLE, _msgSender());
        }
    
        /// @dev Checks whether royalty info can be set in the given execution context.
        function _canSetRoyaltyInfo() internal view override returns (bool) {
            return hasRole(DEFAULT_ADMIN_ROLE, _msgSender());
        }
    
        /// @dev Checks whether contract metadata can be set in the given execution context.
        function _canSetContractURI() internal view override returns (bool) {
            return hasRole(DEFAULT_ADMIN_ROLE, _msgSender());
        }
    
        /// @dev Checks whether platform fee info can be set in the given execution context.
        function _canSetClaimConditions() internal view override returns (bool) {
            return hasRole(DEFAULT_ADMIN_ROLE, _msgSender());
        }
    
        /// @dev Returns whether lazy minting can be done in the given execution context.
        function _canLazyMint() internal view virtual override returns (bool) {
            return hasRole(minterRole, _msgSender());
        }
    
        /*///////////////////////////////////////////////////////////////
                            Miscellaneous
        //////////////////////////////////////////////////////////////*/
    
        /// @dev The tokenId of the next NFT that will be minted / lazy minted.
        function nextTokenIdToMint() public view virtual override returns (uint256) {
            return nextTokenIdToLazyMint;
        }
    
        function _dropMsgSender() internal view virtual override returns (address) {
            return _msgSender();
        }
    
        function _msgSender() internal view virtual returns (address) {
            return msg.sender;
        }
    
        function _msgData() internal view virtual returns (bytes calldata) {
            return msg.data;
        }
    }

    Contract Name:
    MintpadERC1155Drop

    Contract Source Code:

    // SPDX-License-Identifier: Apache 2.0
    pragma solidity ^0.8.0;
    
    error TrxErrorAuth();
    error TrxErrorFee1();
    error TrxErrorFee2();
    
    /// @author Mintpad
    abstract contract TransactionFee {
        
        /// @dev Platform wallet address
        address public platformAddress = 0x4ec431790805909b0D3Dcf5C8dA25FCBF46E93F8;
    
        /// @dev Transaction cost
        uint256 public transactionFee;
    
        /// @dev At any given moment, returns the transaction fee.
        function getTransactionFee() public view returns (uint256) {
            return transactionFee;
        }
    
        /**
         *  @notice         Sets a new transaction fee in case of need.
         *  @dev            This function is only used in rare situations where
         *                  the transaction fee is not set correctly. This value can
         *                  only be lower than the current transaction fee to prevent
         *                  fraud. Only Mintpad can set this transaction fee.
         *
         *  @param _transactionFee The transaction fee to be set.
         */
        function setTransactionFee(uint256 _transactionFee) external {
            if (msg.sender != platformAddress) {
                revert TrxErrorAuth();
            }
            if (_transactionFee > transactionFee) {
                revert TrxErrorFee1();
            }
            if (_transactionFee <= 0) {
                revert TrxErrorFee2();
            }
    
            transactionFee = _transactionFee;
        }
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    import { ERC1155 } from "../eip/ERC1155.sol";
    
    import "../extension/ContractMetadata.sol";
    import "../extension/Multicall.sol";
    import "../extension/Ownable.sol";
    import "../extension/Royalty.sol";
    import "../extension/BatchMintMetadata.sol";
    
    import "../lib/TWStrings.sol";
    
    /**
     *  The `ERC1155Base` smart contract implements the ERC1155 NFT standard.
     *  It includes the following additions to standard ERC1155 logic:
     *
     *      - Ability to mint NFTs via the provided `mintTo` and `batchMintTo` functions.
     *
     *      - Contract metadata for royalty support on platforms such as OpenSea that use
     *        off-chain information to distribute roaylties.
     *
     *      - Ownership of the contract, with the ability to restrict certain functions to
     *        only be called by the contract's owner.
     *
     *      - Multicall capability to perform multiple actions atomically
     *
     *      - EIP 2981 compliance for royalty support on NFT marketplaces.
     */
    
    contract ERC1155Base is ERC1155, ContractMetadata, Ownable, Royalty, Multicall, BatchMintMetadata {
        using TWStrings for uint256;
    
        /*//////////////////////////////////////////////////////////////
                            State variables
        //////////////////////////////////////////////////////////////*/
    
        /// @dev The tokenId of the next NFT to mint.
        uint256 internal nextTokenIdToMint_;
    
        /*//////////////////////////////////////////////////////////////
                            Mappings
        //////////////////////////////////////////////////////////////*/
    
        /**
         *  @notice Returns the total supply of NFTs of a given tokenId
         *  @dev Mapping from tokenId => total circulating supply of NFTs of that tokenId.
         */
        mapping(uint256 => uint256) public totalSupply;
    
        /*//////////////////////////////////////////////////////////////
                                Constructor
        //////////////////////////////////////////////////////////////*/
    
        constructor(
            address _defaultAdmin,
            string memory _name,
            string memory _symbol,
            address _royaltyRecipient,
            uint128 _royaltyBps
        ) ERC1155(_name, _symbol) {
            _setupOwner(_defaultAdmin);
            _setupDefaultRoyaltyInfo(_royaltyRecipient, _royaltyBps);
        }
    
        /*//////////////////////////////////////////////////////////////
                        Overriden metadata logic
        //////////////////////////////////////////////////////////////*/
    
        /// @notice Returns the metadata URI for the given tokenId.
        /// @param _tokenId The tokenId of the token for which a URI should be returned.
        /// @return The metadata URI for the given tokenId.
        function uri(uint256 _tokenId) public view virtual override returns (string memory) {
            string memory uriForToken = _uri[_tokenId];
            if (bytes(uriForToken).length > 0) {
                return uriForToken;
            }
    
            string memory batchUri = _getBaseURI(_tokenId);
            return string(abi.encodePacked(batchUri, _tokenId.toString()));
        }
    
        /*//////////////////////////////////////////////////////////////
                            Mint / burn logic
        //////////////////////////////////////////////////////////////*/
    
        /**
         *  @notice          Lets an authorized address mint NFTs to a recipient.
         *  @dev             - The logic in the `_canMint` function determines whether the caller is authorized to mint NFTs.
         *                   - If `_tokenId == type(uint256).max` a new NFT at tokenId `nextTokenIdToMint` is minted. If the given
         *                     `tokenId < nextTokenIdToMint`, then additional supply of an existing NFT is being minted.
         *
         *  @param _to       The recipient of the NFTs to mint.
         *  @param _tokenId  The tokenId of the NFT to mint.
         *  @param _tokenURI The full metadata URI for the NFTs minted (if a new NFT is being minted).
         *  @param _amount   The amount of the same NFT to mint.
         */
        function mintTo(
            address _to,
            uint256 _tokenId,
            string memory _tokenURI,
            uint256 _amount
        ) public virtual {
            require(_canMint(), "Not authorized to mint.");
    
            uint256 tokenIdToMint;
            uint256 nextIdToMint = nextTokenIdToMint();
    
            if (_tokenId == type(uint256).max) {
                tokenIdToMint = nextIdToMint;
                nextTokenIdToMint_ += 1;
                _setTokenURI(nextIdToMint, _tokenURI);
            } else {
                require(_tokenId < nextIdToMint, "invalid id");
                tokenIdToMint = _tokenId;
            }
    
            _mint(_to, tokenIdToMint, _amount, "");
        }
    
        /**
         *  @notice          Lets an authorized address mint multiple NEW NFTs at once to a recipient.
         *  @dev             The logic in the `_canMint` function determines whether the caller is authorized to mint NFTs.
         *                   If `_tokenIds[i] == type(uint256).max` a new NFT at tokenId `nextTokenIdToMint` is minted. If the given
         *                   `tokenIds[i] < nextTokenIdToMint`, then additional supply of an existing NFT is minted.
         *                   The metadata for each new NFT is stored at `baseURI/{tokenID of NFT}`
         *
         *  @param _to       The recipient of the NFT to mint.
         *  @param _tokenIds The tokenIds of the NFTs to mint.
         *  @param _amounts  The amounts of each NFT to mint.
         *  @param _baseURI  The baseURI for the `n` number of NFTs minted. The metadata for each NFT is `baseURI/tokenId`
         */
        function batchMintTo(
            address _to,
            uint256[] memory _tokenIds,
            uint256[] memory _amounts,
            string memory _baseURI
        ) public virtual {
            require(_canMint(), "Not authorized to mint.");
            require(_amounts.length > 0, "Minting zero tokens.");
            require(_tokenIds.length == _amounts.length, "Length mismatch.");
    
            uint256 nextIdToMint = nextTokenIdToMint();
            uint256 startNextIdToMint = nextIdToMint;
    
            uint256 numOfNewNFTs;
    
            for (uint256 i = 0; i < _tokenIds.length; i += 1) {
                if (_tokenIds[i] == type(uint256).max) {
                    _tokenIds[i] = nextIdToMint;
    
                    nextIdToMint += 1;
                    numOfNewNFTs += 1;
                } else {
                    require(_tokenIds[i] < nextIdToMint, "invalid id");
                }
            }
    
            if (numOfNewNFTs > 0) {
                _batchMintMetadata(startNextIdToMint, numOfNewNFTs, _baseURI);
            }
    
            nextTokenIdToMint_ = nextIdToMint;
            _mintBatch(_to, _tokenIds, _amounts, "");
        }
    
        /**
         *  @notice         Lets an owner or approved operator burn NFTs of the given tokenId.
         *
         *  @param _owner   The owner of the NFT to burn.
         *  @param _tokenId The tokenId of the NFT to burn.
         *  @param _amount  The amount of the NFT to burn.
         */
        function burn(
            address _owner,
            uint256 _tokenId,
            uint256 _amount
        ) external virtual {
            address caller = msg.sender;
    
            require(caller == _owner || isApprovedForAll[_owner][caller], "Unapproved caller");
            require(balanceOf[_owner][_tokenId] >= _amount, "Not enough tokens owned");
    
            _burn(_owner, _tokenId, _amount);
        }
    
        /**
         *  @notice         Lets an owner or approved operator burn NFTs of the given tokenIds.
         *
         *  @param _owner    The owner of the NFTs to burn.
         *  @param _tokenIds The tokenIds of the NFTs to burn.
         *  @param _amounts  The amounts of the NFTs to burn.
         */
        function burnBatch(
            address _owner,
            uint256[] memory _tokenIds,
            uint256[] memory _amounts
        ) external virtual {
            address caller = msg.sender;
    
            require(caller == _owner || isApprovedForAll[_owner][caller], "Unapproved caller");
            require(_tokenIds.length == _amounts.length, "Length mismatch");
    
            for (uint256 i = 0; i < _tokenIds.length; i += 1) {
                require(balanceOf[_owner][_tokenIds[i]] >= _amounts[i], "Not enough tokens owned");
            }
    
            _burnBatch(_owner, _tokenIds, _amounts);
        }
    
        /*//////////////////////////////////////////////////////////////
                                ERC165 Logic
        //////////////////////////////////////////////////////////////*/
    
        /**
         * @dev See ERC165: https://eips.ethereum.org/EIPS/eip-165
         * @inheritdoc IERC165
         */
        function supportsInterface(bytes4 interfaceId) public view virtual override(ERC1155, IERC165) returns (bool) {
            return
                interfaceId == 0x01ffc9a7 || // ERC165 Interface ID for ERC165
                interfaceId == 0xd9b67a26 || // ERC165 Interface ID for ERC1155
                interfaceId == 0x0e89341c || // ERC165 Interface ID for ERC1155MetadataURI
                interfaceId == type(IERC2981).interfaceId; // ERC165 ID for ERC2981
        }
    
        /*//////////////////////////////////////////////////////////////
                                View functions
        //////////////////////////////////////////////////////////////*/
    
        /// @notice The tokenId assigned to the next new NFT to be minted.
        function nextTokenIdToMint() public view virtual returns (uint256) {
            return nextTokenIdToMint_;
        }
    
        /*//////////////////////////////////////////////////////////////
                        Internal (overrideable) functions
        //////////////////////////////////////////////////////////////*/
    
        /// @dev Returns whether contract metadata can be set in the given execution context.
        /// @return Whether contract metadata can be set in the given execution context.
        function _canSetContractURI() internal view virtual override returns (bool) {
            return msg.sender == owner();
        }
    
        /// @dev Returns whether a token can be minted in the given execution context.
        /// @return Whether a token can be minted in the given execution context.
        function _canMint() internal view virtual returns (bool) {
            return msg.sender == owner();
        }
    
        /// @dev Returns whether owner can be set in the given execution context.
        /// @return Whether owner can be set in the given execution context.
        function _canSetOwner() internal view virtual override returns (bool) {
            return msg.sender == owner();
        }
    
        /// @dev Returns whether royalty info can be set in the given execution context.
        /// @return Whether royalty info can be set in the given execution context.
        function _canSetRoyaltyInfo() internal view virtual override returns (bool) {
            return msg.sender == owner();
        }
    
        /// @dev Runs before every token transfer / mint / burn.
        /// @param operator The address of the caller.
        /// @param from The address of the sender.
        /// @param to The address of the recipient.
        /// @param ids The tokenIds of the tokens being transferred.
        /// @param amounts The amounts of the tokens being transferred.
        /// @param data Additional data with no specified format.
        function _beforeTokenTransfer(
            address operator,
            address from,
            address to,
            uint256[] memory ids,
            uint256[] memory amounts,
            bytes memory data
        ) internal virtual override {
            super._beforeTokenTransfer(operator, from, to, ids, amounts, data);
    
            if (from == address(0)) {
                for (uint256 i = 0; i < ids.length; ++i) {
                    totalSupply[ids[i]] += amounts[i];
                }
            }
    
            if (to == address(0)) {
                for (uint256 i = 0; i < ids.length; ++i) {
                    totalSupply[ids[i]] -= amounts[i];
                }
            }
        }
    }

    // SPDX-License-Identifier: Apache 2.0
    pragma solidity ^0.8.0;
    
    import "./interface/IERC1155.sol";
    import "./interface/IERC1155Metadata.sol";
    import "./interface/IERC1155Receiver.sol";
    
    contract ERC1155 is IERC1155, IERC1155Metadata {
        /*//////////////////////////////////////////////////////////////
                            State variables
        //////////////////////////////////////////////////////////////*/
    
        string public name;
        string public symbol;
    
        /*//////////////////////////////////////////////////////////////
                                Mappings
        //////////////////////////////////////////////////////////////*/
    
        mapping(address => mapping(uint256 => uint256)) public balanceOf;
    
        mapping(address => mapping(address => bool)) public isApprovedForAll;
    
        mapping(uint256 => string) internal _uri;
    
        /*//////////////////////////////////////////////////////////////
                                Constructor
        //////////////////////////////////////////////////////////////*/
    
        constructor(string memory _name, string memory _symbol) {
            name = _name;
            symbol = _symbol;
        }
    
        /*//////////////////////////////////////////////////////////////
                                View functions
        //////////////////////////////////////////////////////////////*/
    
        function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
            return
                interfaceId == 0x01ffc9a7 || // ERC165 Interface ID for ERC165
                interfaceId == 0xd9b67a26 || // ERC165 Interface ID for ERC1155
                interfaceId == 0x0e89341c; // ERC165 Interface ID for ERC1155MetadataURI
        }
    
        function uri(uint256 tokenId) public view virtual override returns (string memory) {
            return _uri[tokenId];
        }
    
        function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
            public
            view
            virtual
            override
            returns (uint256[] memory)
        {
            require(accounts.length == ids.length, "LENGTH_MISMATCH");
    
            uint256[] memory batchBalances = new uint256[](accounts.length);
    
            for (uint256 i = 0; i < accounts.length; ++i) {
                batchBalances[i] = balanceOf[accounts[i]][ids[i]];
            }
    
            return batchBalances;
        }
    
        /*//////////////////////////////////////////////////////////////
                                ERC1155 logic
        //////////////////////////////////////////////////////////////*/
    
        function setApprovalForAll(address operator, bool approved) public virtual override {
            address owner = msg.sender;
            require(owner != operator, "APPROVING_SELF");
            isApprovedForAll[owner][operator] = approved;
            emit ApprovalForAll(owner, operator, approved);
        }
    
        function safeTransferFrom(
            address from,
            address to,
            uint256 id,
            uint256 amount,
            bytes memory data
        ) public virtual override {
            require(from == msg.sender || isApprovedForAll[from][msg.sender], "!OWNER_OR_APPROVED");
            _safeTransferFrom(from, to, id, amount, data);
        }
    
        function safeBatchTransferFrom(
            address from,
            address to,
            uint256[] memory ids,
            uint256[] memory amounts,
            bytes memory data
        ) public virtual override {
            require(from == msg.sender || isApprovedForAll[from][msg.sender], "!OWNER_OR_APPROVED");
            _safeBatchTransferFrom(from, to, ids, amounts, data);
        }
    
        /*//////////////////////////////////////////////////////////////
                                Internal logic
        //////////////////////////////////////////////////////////////*/
    
        function _safeTransferFrom(
            address from,
            address to,
            uint256 id,
            uint256 amount,
            bytes memory data
        ) internal virtual {
            require(to != address(0), "TO_ZERO_ADDR");
    
            address operator = msg.sender;
    
            _beforeTokenTransfer(operator, from, to, _asSingletonArray(id), _asSingletonArray(amount), data);
    
            uint256 fromBalance = balanceOf[from][id];
            require(fromBalance >= amount, "INSUFFICIENT_BAL");
            unchecked {
                balanceOf[from][id] = fromBalance - amount;
            }
            balanceOf[to][id] += amount;
    
            emit TransferSingle(operator, from, to, id, amount);
    
            _doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
        }
    
        function _safeBatchTransferFrom(
            address from,
            address to,
            uint256[] memory ids,
            uint256[] memory amounts,
            bytes memory data
        ) internal virtual {
            require(ids.length == amounts.length, "LENGTH_MISMATCH");
            require(to != address(0), "TO_ZERO_ADDR");
    
            address operator = msg.sender;
    
            _beforeTokenTransfer(operator, from, to, ids, amounts, data);
    
            for (uint256 i = 0; i < ids.length; ++i) {
                uint256 id = ids[i];
                uint256 amount = amounts[i];
    
                uint256 fromBalance = balanceOf[from][id];
                require(fromBalance >= amount, "INSUFFICIENT_BAL");
                unchecked {
                    balanceOf[from][id] = fromBalance - amount;
                }
                balanceOf[to][id] += amount;
            }
    
            emit TransferBatch(operator, from, to, ids, amounts);
    
            _doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
        }
    
        function _setTokenURI(uint256 tokenId, string memory newuri) internal virtual {
            _uri[tokenId] = newuri;
        }
    
        function _mint(
            address to,
            uint256 id,
            uint256 amount,
            bytes memory data
        ) internal virtual {
            require(to != address(0), "TO_ZERO_ADDR");
    
            address operator = msg.sender;
    
            _beforeTokenTransfer(operator, address(0), to, _asSingletonArray(id), _asSingletonArray(amount), data);
    
            balanceOf[to][id] += amount;
            emit TransferSingle(operator, address(0), to, id, amount);
    
            _doSafeTransferAcceptanceCheck(operator, address(0), to, id, amount, data);
        }
    
        function _mintBatch(
            address to,
            uint256[] memory ids,
            uint256[] memory amounts,
            bytes memory data
        ) internal virtual {
            require(to != address(0), "TO_ZERO_ADDR");
            require(ids.length == amounts.length, "LENGTH_MISMATCH");
    
            address operator = msg.sender;
    
            _beforeTokenTransfer(operator, address(0), to, ids, amounts, data);
    
            for (uint256 i = 0; i < ids.length; i++) {
                balanceOf[to][ids[i]] += amounts[i];
            }
    
            emit TransferBatch(operator, address(0), to, ids, amounts);
    
            _doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
        }
    
        function _burn(
            address from,
            uint256 id,
            uint256 amount
        ) internal virtual {
            require(from != address(0), "FROM_ZERO_ADDR");
    
            address operator = msg.sender;
    
            _beforeTokenTransfer(operator, from, address(0), _asSingletonArray(id), _asSingletonArray(amount), "");
    
            uint256 fromBalance = balanceOf[from][id];
            require(fromBalance >= amount, "INSUFFICIENT_BAL");
            unchecked {
                balanceOf[from][id] = fromBalance - amount;
            }
    
            emit TransferSingle(operator, from, address(0), id, amount);
        }
    
        function _burnBatch(
            address from,
            uint256[] memory ids,
            uint256[] memory amounts
        ) internal virtual {
            require(from != address(0), "FROM_ZERO_ADDR");
            require(ids.length == amounts.length, "LENGTH_MISMATCH");
    
            address operator = msg.sender;
    
            _beforeTokenTransfer(operator, from, address(0), ids, amounts, "");
    
            for (uint256 i = 0; i < ids.length; i++) {
                uint256 id = ids[i];
                uint256 amount = amounts[i];
    
                uint256 fromBalance = balanceOf[from][id];
                require(fromBalance >= amount, "INSUFFICIENT_BAL");
                unchecked {
                    balanceOf[from][id] = fromBalance - amount;
                }
            }
    
            emit TransferBatch(operator, from, address(0), ids, amounts);
        }
    
        function _beforeTokenTransfer(
            address operator,
            address from,
            address to,
            uint256[] memory ids,
            uint256[] memory amounts,
            bytes memory data
        ) internal virtual {}
    
        function _doSafeTransferAcceptanceCheck(
            address operator,
            address from,
            address to,
            uint256 id,
            uint256 amount,
            bytes memory data
        ) private {
            if (to.code.length > 0) {
                try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
                    if (response != IERC1155Receiver.onERC1155Received.selector) {
                        revert("TOKENS_REJECTED");
                    }
                } catch Error(string memory reason) {
                    revert(reason);
                } catch {
                    revert("!ERC1155RECEIVER");
                }
            }
        }
    
        function _doSafeBatchTransferAcceptanceCheck(
            address operator,
            address from,
            address to,
            uint256[] memory ids,
            uint256[] memory amounts,
            bytes memory data
        ) private {
            if (to.code.length > 0) {
                try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (
                    bytes4 response
                ) {
                    if (response != IERC1155Receiver.onERC1155BatchReceived.selector) {
                        revert("TOKENS_REJECTED");
                    }
                } catch Error(string memory reason) {
                    revert(reason);
                } catch {
                    revert("!ERC1155RECEIVER");
                }
            }
        }
    
        function _asSingletonArray(uint256 element) private pure returns (uint256[] memory) {
            uint256[] memory array = new uint256[](1);
            array[0] = element;
    
            return array;
        }
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /**
        @title ERC-1155 Multi Token Standard
        @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1155.md
        Note: The ERC-165 identifier for this interface is 0xd9b67a26.
     */
    interface IERC1155 {
        /**
            @dev Either `TransferSingle` or `TransferBatch` MUST emit when tokens are transferred, including zero value transfers as well as minting or burning (see "Safe Transfer Rules" section of the standard).
            The `_operator` argument MUST be msg.sender.
            The `_from` argument MUST be the address of the holder whose balance is decreased.
            The `_to` argument MUST be the address of the recipient whose balance is increased.
            The `_id` argument MUST be the token type being transferred.
            The `_value` argument MUST be the number of tokens the holder balance is decreased by and match what the recipient balance is increased by.
            When minting/creating tokens, the `_from` argument MUST be set to `0x0` (i.e. zero address).
            When burning/destroying tokens, the `_to` argument MUST be set to `0x0` (i.e. zero address).
        */
        event TransferSingle(
            address indexed _operator,
            address indexed _from,
            address indexed _to,
            uint256 _id,
            uint256 _value
        );
    
        /**
            @dev Either `TransferSingle` or `TransferBatch` MUST emit when tokens are transferred, including zero value transfers as well as minting or burning (see "Safe Transfer Rules" section of the standard).
            The `_operator` argument MUST be msg.sender.
            The `_from` argument MUST be the address of the holder whose balance is decreased.
            The `_to` argument MUST be the address of the recipient whose balance is increased.
            The `_ids` argument MUST be the list of tokens being transferred.
            The `_values` argument MUST be the list of number of tokens (matching the list and order of tokens specified in _ids) the holder balance is decreased by and match what the recipient balance is increased by.
            When minting/creating tokens, the `_from` argument MUST be set to `0x0` (i.e. zero address).
            When burning/destroying tokens, the `_to` argument MUST be set to `0x0` (i.e. zero address).
        */
        event TransferBatch(
            address indexed _operator,
            address indexed _from,
            address indexed _to,
            uint256[] _ids,
            uint256[] _values
        );
    
        /**
            @dev MUST emit when approval for a second party/operator address to manage all tokens for an owner address is enabled or disabled (absense of an event assumes disabled).
        */
        event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
    
        /**
            @dev MUST emit when the URI is updated for a token ID.
            URIs are defined in RFC 3986.
            The URI MUST point a JSON file that conforms to the "ERC-1155 Metadata URI JSON Schema".
        */
        event URI(string _value, uint256 indexed _id);
    
        /**
            @notice Transfers `_value` amount of an `_id` from the `_from` address to the `_to` address specified (with safety call).
            @dev Caller must be approved to manage the tokens being transferred out of the `_from` account (see "Approval" section of the standard).
            MUST revert if `_to` is the zero address.
            MUST revert if balance of holder for token `_id` is lower than the `_value` sent.
            MUST revert on any other error.
            MUST emit the `TransferSingle` event to reflect the balance change (see "Safe Transfer Rules" section of the standard).
            After the above conditions are met, this function MUST check if `_to` is a smart contract (e.g. code size > 0). If so, it MUST call `onERC1155Received` on `_to` and act appropriately (see "Safe Transfer Rules" section of the standard).
            @param _from    Source address
            @param _to      Target address
            @param _id      ID of the token type
            @param _value   Transfer amount
            @param _data    Additional data with no specified format, MUST be sent unaltered in call to `onERC1155Received` on `_to`
        */
        function safeTransferFrom(
            address _from,
            address _to,
            uint256 _id,
            uint256 _value,
            bytes calldata _data
        ) external;
    
        /**
            @notice Transfers `_values` amount(s) of `_ids` from the `_from` address to the `_to` address specified (with safety call).
            @dev Caller must be approved to manage the tokens being transferred out of the `_from` account (see "Approval" section of the standard).
            MUST revert if `_to` is the zero address.
            MUST revert if length of `_ids` is not the same as length of `_values`.
            MUST revert if any of the balance(s) of the holder(s) for token(s) in `_ids` is lower than the respective amount(s) in `_values` sent to the recipient.
            MUST revert on any other error.
            MUST emit `TransferSingle` or `TransferBatch` event(s) such that all the balance changes are reflected (see "Safe Transfer Rules" section of the standard).
            Balance changes and events MUST follow the ordering of the arrays (_ids[0]/_values[0] before _ids[1]/_values[1], etc).
            After the above conditions for the transfer(s) in the batch are met, this function MUST check if `_to` is a smart contract (e.g. code size > 0). If so, it MUST call the relevant `ERC1155TokenReceiver` hook(s) on `_to` and act appropriately (see "Safe Transfer Rules" section of the standard).
            @param _from    Source address
            @param _to      Target address
            @param _ids     IDs of each token type (order and length must match _values array)
            @param _values  Transfer amounts per token type (order and length must match _ids array)
            @param _data    Additional data with no specified format, MUST be sent unaltered in call to the `ERC1155TokenReceiver` hook(s) on `_to`
        */
        function safeBatchTransferFrom(
            address _from,
            address _to,
            uint256[] calldata _ids,
            uint256[] calldata _values,
            bytes calldata _data
        ) external;
    
        /**
            @notice Get the balance of an account's Tokens.
            @param _owner  The address of the token holder
            @param _id     ID of the Token
            @return        The _owner's balance of the Token type requested
         */
        function balanceOf(address _owner, uint256 _id) external view returns (uint256);
    
        /**
            @notice Get the balance of multiple account/token pairs
            @param _owners The addresses of the token holders
            @param _ids    ID of the Tokens
            @return        The _owner's balance of the Token types requested (i.e. balance for each (owner, id) pair)
         */
        function balanceOfBatch(address[] calldata _owners, uint256[] calldata _ids)
            external
            view
            returns (uint256[] memory);
    
        /**
            @notice Enable or disable approval for a third party ("operator") to manage all of the caller's tokens.
            @dev MUST emit the ApprovalForAll event on success.
            @param _operator  Address to add to the set of authorized operators
            @param _approved  True if the operator is approved, false to revoke approval
        */
        function setApprovalForAll(address _operator, bool _approved) external;
    
        /**
            @notice Queries the approval status of an operator for a given owner.
            @param _owner     The owner of the Tokens
            @param _operator  Address of authorized operator
            @return           True if the operator is approved, false if not
        */
        function isApprovedForAll(address _owner, address _operator) external view returns (bool);
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /**
        Note: The ERC-165 identifier for this interface is 0x0e89341c.
    */
    interface IERC1155Metadata {
        /**
            @notice A distinct Uniform Resource Identifier (URI) for a given token.
            @dev URIs are defined in RFC 3986.
            The URI may point to a JSON file that conforms to the "ERC-1155 Metadata URI JSON Schema".
            @return URI string
        */
        function uri(uint256 _id) external view returns (string memory);
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)
    
    pragma solidity ^0.8.0;
    
    import "./IERC165.sol";
    
    /**
     * @dev _Available since v3.1._
     */
    interface IERC1155Receiver is IERC165 {
        /**
         * @dev Handles the receipt of a single ERC1155 token type. This function is
         * called at the end of a `safeTransferFrom` after the balance has been updated.
         *
         * NOTE: To accept the transfer, this must return
         * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
         * (i.e. 0xf23a6e61, or its own function selector).
         *
         * @param operator The address which initiated the transfer (i.e. msg.sender)
         * @param from The address which previously owned the token
         * @param id The ID of the token being transferred
         * @param value The amount of tokens being transferred
         * @param data Additional data with no specified format
         * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
         */
        function onERC1155Received(
            address operator,
            address from,
            uint256 id,
            uint256 value,
            bytes calldata data
        ) external returns (bytes4);
    
        /**
         * @dev Handles the receipt of a multiple ERC1155 token types. This function
         * is called at the end of a `safeBatchTransferFrom` after the balances have
         * been updated.
         *
         * NOTE: To accept the transfer(s), this must return
         * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
         * (i.e. 0xbc197c81, or its own function selector).
         *
         * @param operator The address which initiated the batch transfer (i.e. msg.sender)
         * @param from The address which previously owned the token
         * @param ids An array containing ids of each token being transferred (order and length must match values array)
         * @param values An array containing amounts of each token being transferred (order and length must match ids array)
         * @param data Additional data with no specified format
         * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
         */
        function onERC1155BatchReceived(
            address operator,
            address from,
            uint256[] calldata ids,
            uint256[] calldata values,
            bytes calldata data
        ) external returns (bytes4);
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
    
    pragma solidity ^0.8.0;
    
    /**
     * @dev Interface of the ERC165 standard, as defined in the
     * [EIP](https://eips.ethereum.org/EIPS/eip-165).
     *
     * Implementers can declare support of contract interfaces, which can then be
     * queried by others ({ERC165Checker}).
     *
     * For an implementation, see {ERC165}.
     */
    interface IERC165 {
        /**
         * @dev Returns true if this contract implements the interface defined by
         * `interfaceId`. See the corresponding
         * [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)
         * to learn more about how these ids are created.
         *
         * This function call must use less than 30 000 gas.
         */
        function supportsInterface(bytes4 interfaceId) external view returns (bool);
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /**
     * @title ERC20 interface
     * @dev see https://github.com/ethereum/EIPs/issues/20
     */
    interface IERC20 {
        function totalSupply() external view returns (uint256);
    
        function balanceOf(address who) external view returns (uint256);
    
        function allowance(address owner, address spender) external view returns (uint256);
    
        function transfer(address to, uint256 value) external returns (bool);
    
        function approve(address spender, uint256 value) external returns (bool);
    
        function transferFrom(
            address from,
            address to,
            uint256 value
        ) external returns (bool);
    
        event Transfer(address indexed from, address indexed to, uint256 value);
    
        event Approval(address indexed owner, address indexed spender, uint256 value);
    }

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

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    /**
     *  @title   Batch-mint Metadata
     *  @notice  The `BatchMintMetadata` is a contract extension for any base NFT contract. It lets the smart contract
     *           using this extension set metadata for `n` number of NFTs all at once. This is enabled by storing a single
     *           base URI for a batch of `n` NFTs, where the metadata for each NFT in a relevant batch is `baseURI/tokenId`.
     */
    
    contract BatchMintMetadata {
        /// @dev Largest tokenId of each batch of tokens with the same baseURI.
        uint256[] private batchIds;
    
        /// @dev Mapping from id of a batch of tokens => to base URI for the respective batch of tokens.
        mapping(uint256 => string) private baseURI;
    
        /// @dev Mapping from id of a batch of tokens => to whether the base URI for the respective batch of tokens is frozen.
        mapping(uint256 => bool) public batchFrozen;
    
        /// @dev This event emits when the metadata of all tokens are frozen.
        /// While not currently supported by marketplaces, this event allows
        /// future indexing if desired.
        event MetadataFrozen();
    
        // @dev This event emits when the metadata of a range of tokens is updated.
        /// So that the third-party platforms such as NFT market could
        /// timely update the images and related attributes of the NFTs.
        event BatchMetadataUpdate(uint256 _fromTokenId, uint256 _toTokenId);
    
        /**
         *  @notice         Returns the count of batches of NFTs.
         *  @dev            Each batch of tokens has an in ID and an associated `baseURI`.
         *                  See {batchIds}.
         */
        function getBaseURICount() public view returns (uint256) {
            return batchIds.length;
        }
    
        /**
         *  @notice         Returns the ID for the batch of tokens at the given index.
         *  @dev            See {getBaseURICount}.
         *  @param _index   Index of the desired batch in batchIds array.
         */
        function getBatchIdAtIndex(uint256 _index) public view returns (uint256) {
            if (_index >= getBaseURICount()) {
                revert("Invalid index");
            }
            return batchIds[_index];
        }
    
        /// @dev Returns the id for the batch of tokens the given tokenId belongs to.
        function _getBatchId(uint256 _tokenId) internal view returns (uint256 batchId, uint256 index) {
            uint256 numOfTokenBatches = getBaseURICount();
            uint256[] memory indices = batchIds;
    
            for (uint256 i = 0; i < numOfTokenBatches; i += 1) {
                if (_tokenId < indices[i]) {
                    index = i;
                    batchId = indices[i];
    
                    return (batchId, index);
                }
            }
    
            revert("Invalid tokenId");
        }
    
        /// @dev Returns the baseURI for a token. The intended metadata URI for the token is baseURI + tokenId.
        function _getBaseURI(uint256 _tokenId) internal view returns (string memory) {
            uint256 numOfTokenBatches = getBaseURICount();
            uint256[] memory indices = batchIds;
    
            for (uint256 i = 0; i < numOfTokenBatches; i += 1) {
                if (_tokenId < indices[i]) {
                    return baseURI[indices[i]];
                }
            }
            revert("Invalid tokenId");
        }
    
        /// @dev returns the starting tokenId of a given batchId.
        function _getBatchStartId(uint256 _batchID) internal view returns (uint256) {
            uint256 numOfTokenBatches = getBaseURICount();
            uint256[] memory indices = batchIds;
    
            for (uint256 i = 0; i < numOfTokenBatches; i++) {
                if (_batchID == indices[i]) {
                    if (i > 0) {
                        return indices[i - 1];
                    }
                    return 0;
                }
            }
            revert("Invalid batchId");
        }
    
        /// @dev Sets the base URI for the batch of tokens with the given batchId.
        function _setBaseURI(uint256 _batchId, string memory _baseURI) internal {
            require(!batchFrozen[_batchId], "Batch frozen");
            baseURI[_batchId] = _baseURI;
            emit BatchMetadataUpdate(_getBatchStartId(_batchId), _batchId);
        }
    
        /// @dev Freezes the base URI for the batch of tokens with the given batchId.
        function _freezeBaseURI(uint256 _batchId) internal {
            string memory baseURIForBatch = baseURI[_batchId];
            require(bytes(baseURIForBatch).length > 0, "Invalid batch");
            batchFrozen[_batchId] = true;
            emit MetadataFrozen();
        }
    
        /// @dev Mints a batch of tokenIds and associates a common baseURI to all those Ids.
        function _batchMintMetadata(
            uint256 _startId,
            uint256 _amountToMint,
            string memory _baseURIForTokens
        ) internal returns (uint256 nextTokenIdToMint, uint256 batchId) {
            batchId = _startId + _amountToMint;
            nextTokenIdToMint = batchId;
    
            batchIds.push(batchId);
    
            baseURI[batchId] = _baseURIForTokens;
        }
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    import "./interface/IContractMetadata.sol";
    
    /**
     *  @title   Contract Metadata
     *  @notice  Thirdweb's `ContractMetadata` is a contract extension for any base contracts. It lets you set a metadata URI
     *           for you contract.
     *           Additionally, `ContractMetadata` is necessary for NFT contracts that want royalties to get distributed on OpenSea.
     */
    
    abstract contract ContractMetadata is IContractMetadata {
        /// @notice Returns the contract metadata URI.
        string public override contractURI;
    
        /**
         *  @notice         Lets a contract admin set the URI for contract-level metadata.
         *  @dev            Caller should be authorized to setup contractURI, e.g. contract admin.
         *                  See {_canSetContractURI}.
         *                  Emits {ContractURIUpdated Event}.
         *
         *  @param _uri     keccak256 hash of the role. e.g. keccak256("TRANSFER_ROLE")
         */
        function setContractURI(string memory _uri) external override {
            if (!_canSetContractURI()) {
                revert("Not authorized");
            }
    
            _setupContractURI(_uri);
        }
    
        /// @dev Lets a contract admin set the URI for contract-level metadata.
        function _setupContractURI(string memory _uri) internal {
            string memory prevURI = contractURI;
            contractURI = _uri;
    
            emit ContractURIUpdated(prevURI, _uri);
        }
    
        /// @dev Returns whether contract metadata can be set in the given execution context.
        function _canSetContractURI() internal view virtual returns (bool);
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    import "./interface/IDrop1155.sol";
    import "../lib/MerkleProof.sol";
    
    abstract contract Drop1155 is IDrop1155 {
        /*///////////////////////////////////////////////////////////////
                                State variables
        //////////////////////////////////////////////////////////////*/
    
        /// @dev Mapping from token ID => the set of all claim conditions, at any given moment, for tokens of the token ID.
        mapping(uint256 => ClaimConditionList) public claimCondition;
    
        /*///////////////////////////////////////////////////////////////
                                Drop logic
        //////////////////////////////////////////////////////////////*/
    
        /// @dev Lets an account claim tokens.
        function claim(
            address _receiver,
            uint256 _tokenId,
            uint256 _quantity,
            address _currency,
            uint256 _pricePerToken,
            AllowlistProof calldata _allowlistProof,
            bytes memory _data
        ) public payable virtual override {
            _beforeClaim(_tokenId, _receiver, _quantity, _currency, _pricePerToken, _allowlistProof, _data);
    
            uint256 activeConditionId = getActiveClaimConditionId(_tokenId);
    
            verifyClaim(
                activeConditionId,
                _dropMsgSender(),
                _tokenId,
                _quantity,
                _currency,
                _pricePerToken,
                _allowlistProof
            );
    
            // Update contract state.
            claimCondition[_tokenId].conditions[activeConditionId].supplyClaimed += _quantity;
            claimCondition[_tokenId].supplyClaimedByWallet[activeConditionId][_dropMsgSender()] += _quantity;
    
            // If there's a price, collect price.
            collectPriceOnClaim(_tokenId, address(0), _quantity, _currency, _pricePerToken);
    
            // Mint the relevant NFTs to claimer.
            transferTokensOnClaim(_receiver, _tokenId, _quantity);
    
            emit TokensClaimed(activeConditionId, _dropMsgSender(), _receiver, _tokenId, _quantity);
    
            _afterClaim(_tokenId, _receiver, _quantity, _currency, _pricePerToken, _allowlistProof, _data);
        }
    
        /// @dev Lets a contract admin set claim conditions.
        function setClaimConditions(
            uint256 _tokenId,
            ClaimCondition[] calldata _conditions,
            bool _resetClaimEligibility
        ) external virtual override {
            if (!_canSetClaimConditions()) {
                revert("Not authorized");
            }
            ClaimConditionList storage conditionList = claimCondition[_tokenId];
            uint256 existingStartIndex = conditionList.currentStartId;
            uint256 existingPhaseCount = conditionList.count;
    
            /**
             *  The mapping `supplyClaimedByWallet` uses a claim condition's UID as a key.
             *
             *  If `_resetClaimEligibility == true`, we assign completely new UIDs to the claim
             *  conditions in `_conditions`, effectively resetting the restrictions on claims expressed
             *  by `supplyClaimedByWallet`.
             */
            uint256 newStartIndex = existingStartIndex;
            if (_resetClaimEligibility) {
                newStartIndex = existingStartIndex + existingPhaseCount;
            }
    
            conditionList.count = _conditions.length;
            conditionList.currentStartId = newStartIndex;
    
            uint256 lastConditionStartTimestamp;
            for (uint256 i = 0; i < _conditions.length; i++) {
                require(i == 0 || lastConditionStartTimestamp < _conditions[i].startTimestamp, "ST");
    
                uint256 supplyClaimedAlready = conditionList.conditions[newStartIndex + i].supplyClaimed;
                if (supplyClaimedAlready > _conditions[i].maxClaimableSupply) {
                    revert("max supply claimed");
                }
    
                conditionList.conditions[newStartIndex + i] = _conditions[i];
                conditionList.conditions[newStartIndex + i].supplyClaimed = supplyClaimedAlready;
    
                lastConditionStartTimestamp = _conditions[i].startTimestamp;
            }
    
            /**
             *  Gas refunds (as much as possible)
             *
             *  If `_resetClaimEligibility == true`, we assign completely new UIDs to the claim
             *  conditions in `_conditions`. So, we delete claim conditions with UID < `newStartIndex`.
             *
             *  If `_resetClaimEligibility == false`, and there are more existing claim conditions
             *  than in `_conditions`, we delete the existing claim conditions that don't get replaced
             *  by the conditions in `_conditions`.
             */
            if (_resetClaimEligibility) {
                for (uint256 i = existingStartIndex; i < newStartIndex; i++) {
                    delete conditionList.conditions[i];
                }
            } else {
                if (existingPhaseCount > _conditions.length) {
                    for (uint256 i = _conditions.length; i < existingPhaseCount; i++) {
                        delete conditionList.conditions[newStartIndex + i];
                    }
                }
            }
    
            emit ClaimConditionsUpdated(_tokenId, _conditions, _resetClaimEligibility);
        }
    
        /// @dev Checks a request to claim NFTs against the active claim condition's criteria.
        function verifyClaim(
            uint256 _conditionId,
            address _claimer,
            uint256 _tokenId,
            uint256 _quantity,
            address _currency,
            uint256 _pricePerToken,
            AllowlistProof calldata _allowlistProof
        ) public view returns (bool isOverride) {
            ClaimCondition memory currentClaimPhase = claimCondition[_tokenId].conditions[_conditionId];
            uint256 claimLimit = currentClaimPhase.quantityLimitPerWallet;
            uint256 claimPrice = currentClaimPhase.pricePerToken;
            address claimCurrency = currentClaimPhase.currency;
    
            if (currentClaimPhase.merkleRoot != bytes32(0)) {
                (isOverride, ) = MerkleProof.verify(
                    _allowlistProof.proof,
                    currentClaimPhase.merkleRoot,
                    keccak256(
                        abi.encodePacked(
                            _claimer,
                            _allowlistProof.quantityLimitPerWallet,
                            _allowlistProof.pricePerToken,
                            _allowlistProof.currency
                        )
                    )
                );
            }
    
            if (isOverride) {
                claimLimit = _allowlistProof.quantityLimitPerWallet != 0
                    ? _allowlistProof.quantityLimitPerWallet
                    : claimLimit;
                claimPrice = _allowlistProof.pricePerToken != type(uint256).max
                    ? _allowlistProof.pricePerToken
                    : claimPrice;
                claimCurrency = _allowlistProof.pricePerToken != type(uint256).max && _allowlistProof.currency != address(0)
                    ? _allowlistProof.currency
                    : claimCurrency;
            }
    
            uint256 supplyClaimedByWallet = claimCondition[_tokenId].supplyClaimedByWallet[_conditionId][_claimer];
    
            if (_currency != claimCurrency || _pricePerToken != claimPrice) {
                revert("!PriceOrCurrency");
            }
    
            if (_quantity == 0 || (_quantity + supplyClaimedByWallet > claimLimit)) {
                revert("!Qty");
            }
    
            if (currentClaimPhase.supplyClaimed + _quantity > currentClaimPhase.maxClaimableSupply) {
                revert("!MaxSupply");
            }
    
            if (currentClaimPhase.startTimestamp > block.timestamp) {
                revert("cant claim yet");
            }
        }
    
        /// @dev At any given moment, returns the uid for the active claim condition.
        function getActiveClaimConditionId(uint256 _tokenId) public view returns (uint256) {
            ClaimConditionList storage conditionList = claimCondition[_tokenId];
            for (uint256 i = conditionList.currentStartId + conditionList.count; i > conditionList.currentStartId; i--) {
                if (block.timestamp >= conditionList.conditions[i - 1].startTimestamp) {
                    return i - 1;
                }
            }
    
            revert("!CONDITION.");
        }
    
        /// @dev Returns the claim condition at the given uid.
        function getClaimConditionById(uint256 _tokenId, uint256 _conditionId)
            external
            view
            returns (ClaimCondition memory condition)
        {
            condition = claimCondition[_tokenId].conditions[_conditionId];
        }
    
        /// @dev Returns the supply claimed by claimer for a given conditionId.
        function getSupplyClaimedByWallet(
            uint256 _tokenId,
            uint256 _conditionId,
            address _claimer
        ) public view returns (uint256 supplyClaimedByWallet) {
            supplyClaimedByWallet = claimCondition[_tokenId].supplyClaimedByWallet[_conditionId][_claimer];
        }
    
        /*////////////////////////////////////////////////////////////////////
            Optional hooks that can be implemented in the derived contract
        ///////////////////////////////////////////////////////////////////*/
    
        /// @dev Exposes the ability to override the msg sender.
        function _dropMsgSender() internal virtual returns (address) {
            return msg.sender;
        }
    
        /// @dev Runs before every `claim` function call.
        function _beforeClaim(
            uint256 _tokenId,
            address _receiver,
            uint256 _quantity,
            address _currency,
            uint256 _pricePerToken,
            AllowlistProof calldata _allowlistProof,
            bytes memory _data
        ) internal virtual {}
    
        /// @dev Runs after every `claim` function call.
        function _afterClaim(
            uint256 _tokenId,
            address _receiver,
            uint256 _quantity,
            address _currency,
            uint256 _pricePerToken,
            AllowlistProof calldata _allowlistProof,
            bytes memory _data
        ) internal virtual {}
    
        /*///////////////////////////////////////////////////////////////
            Virtual functions: to be implemented in derived contract
        //////////////////////////////////////////////////////////////*/
    
        /// @dev Collects and distributes the primary sale value of NFTs being claimed.
        function collectPriceOnClaim(
            uint256 _tokenId,
            address _primarySaleRecipient,
            uint256 _quantityToClaim,
            address _currency,
            uint256 _pricePerToken
        ) internal virtual;
    
        /// @dev Transfers the NFTs being claimed.
        function transferTokensOnClaim(
            address _to,
            uint256 _tokenId,
            uint256 _quantityBeingClaimed
        ) internal virtual;
    
        /// @dev Determine what wallet can update claim conditions
        function _canSetClaimConditions() internal view virtual returns (bool);
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    import "./interface/ILazyMint.sol";
    import "./BatchMintMetadata.sol";
    
    /**
     *  The `LazyMint` is a contract extension for any base NFT contract. It lets you 'lazy mint' any number of NFTs
     *  at once. Here, 'lazy mint' means defining the metadata for particular tokenIds of your NFT contract, without actually
     *  minting a non-zero balance of NFTs of those tokenIds.
     */
    
    abstract contract LazyMint is ILazyMint, BatchMintMetadata {
        /// @notice The tokenId assigned to the next new NFT to be lazy minted.
        uint256 internal nextTokenIdToLazyMint;
    
        /**
         *  @notice                  Lets an authorized address lazy mint a given amount of NFTs.
         *
         *  @param _amount           The number of NFTs to lazy mint.
         *  @param _baseURIForTokens The base URI for the 'n' number of NFTs being lazy minted, where the metadata for each
         *                           of those NFTs is `${baseURIForTokens}/${tokenId}`.
         *  @param _data             Additional bytes data to be used at the discretion of the consumer of the contract.
         *  @return batchId          A unique integer identifier for the batch of NFTs lazy minted together.
         */
        function lazyMint(
            uint256 _amount,
            string calldata _baseURIForTokens,
            bytes calldata _data
        ) public virtual override returns (uint256 batchId) {
            if (!_canLazyMint()) {
                revert("Not authorized");
            }
    
            if (_amount == 0) {
                revert("0 amt");
            }
    
            uint256 startId = nextTokenIdToLazyMint;
    
            (nextTokenIdToLazyMint, batchId) = _batchMintMetadata(startId, _amount, _baseURIForTokens);
    
            emit TokensLazyMinted(startId, startId + _amount - 1, _baseURIForTokens, _data);
    
            return batchId;
        }
    
        /// @dev Returns whether lazy minting can be performed in the given execution context.
        function _canLazyMint() internal view virtual returns (bool);
    }

    // SPDX-License-Identifier: Apache 2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    import "../lib/TWAddress.sol";
    import "./interface/IMulticall.sol";
    
    /**
     * @dev Provides a function to batch together multiple calls in a single external call.
     *
     * _Available since v4.1._
     */
    contract Multicall is IMulticall {
        /**
         *  @notice Receives and executes a batch of function calls on this contract.
         *  @dev Receives and executes a batch of function calls on this contract.
         *
         *  @param data The bytes data that makes up the batch of function calls to execute.
         *  @return results The bytes data that makes up the result of the batch of function calls executed.
         */
        function multicall(bytes[] calldata data) external virtual override returns (bytes[] memory results) {
            results = new bytes[](data.length);
            for (uint256 i = 0; i < data.length; i++) {
                results[i] = TWAddress.functionDelegateCall(address(this), data[i]);
            }
            return results;
        }
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    import "./interface/IOwnable.sol";
    
    /**
     *  @title   Ownable
     *  @notice  Thirdweb's `Ownable` is a contract extension to be used with any base contract. It exposes functions for setting and reading
     *           who the 'owner' of the inheriting smart contract is, and lets the inheriting contract perform conditional logic that uses
     *           information about who the contract's owner is.
     */
    
    abstract contract Ownable is IOwnable {
        /// @dev Owner of the contract (purpose: OpenSea compatibility)
        address private _owner;
    
        /// @dev Reverts if caller is not the owner.
        modifier onlyOwner() {
            if (msg.sender != _owner) {
                revert("Not authorized");
            }
            _;
        }
    
        /**
         *  @notice Returns the owner of the contract.
         */
        function owner() public view override returns (address) {
            return _owner;
        }
    
        /**
         *  @notice Lets an authorized wallet set a new owner for the contract.
         *  @param _newOwner The address to set as the new owner of the contract.
         */
        function setOwner(address _newOwner) external override {
            if (!_canSetOwner()) {
                revert("Not authorized");
            }
            _setupOwner(_newOwner);
        }
    
        /// @dev Lets a contract admin set a new owner for the contract. The new owner must be a contract admin.
        function _setupOwner(address _newOwner) internal {
            address _prevOwner = _owner;
            _owner = _newOwner;
    
            emit OwnerUpdated(_prevOwner, _newOwner);
        }
    
        /// @dev Returns whether owner can be set in the given execution context.
        function _canSetOwner() internal view virtual returns (bool);
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    import "./interface/IPermissions.sol";
    import "../lib/TWStrings.sol";
    
    /**
     *  @title   Permissions
     *  @dev     This contracts provides extending-contracts with role-based access control mechanisms
     */
    contract Permissions is IPermissions {
        /// @dev Map from keccak256 hash of a role => a map from address => whether address has role.
        mapping(bytes32 => mapping(address => bool)) private _hasRole;
    
        /// @dev Map from keccak256 hash of a role to role admin. See {getRoleAdmin}.
        mapping(bytes32 => bytes32) private _getRoleAdmin;
    
        /// @dev Default admin role for all roles. Only accounts with this role can grant/revoke other roles.
        bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
    
        /// @dev Modifier that checks if an account has the specified role; reverts otherwise.
        modifier onlyRole(bytes32 role) {
            _checkRole(role, msg.sender);
            _;
        }
    
        /**
         *  @notice         Checks whether an account has a particular role.
         *  @dev            Returns `true` if `account` has been granted `role`.
         *
         *  @param role     keccak256 hash of the role. e.g. keccak256("TRANSFER_ROLE")
         *  @param account  Address of the account for which the role is being checked.
         */
        function hasRole(bytes32 role, address account) public view override returns (bool) {
            return _hasRole[role][account];
        }
    
        /**
         *  @notice         Checks whether an account has a particular role;
         *                  role restrictions can be swtiched on and off.
         *
         *  @dev            Returns `true` if `account` has been granted `role`.
         *                  Role restrictions can be swtiched on and off:
         *                      - If address(0) has ROLE, then the ROLE restrictions
         *                        don't apply.
         *                      - If address(0) does not have ROLE, then the ROLE
         *                        restrictions will apply.
         *
         *  @param role     keccak256 hash of the role. e.g. keccak256("TRANSFER_ROLE")
         *  @param account  Address of the account for which the role is being checked.
         */
        function hasRoleWithSwitch(bytes32 role, address account) public view returns (bool) {
            if (!_hasRole[role][address(0)]) {
                return _hasRole[role][account];
            }
    
            return true;
        }
    
        /**
         *  @notice         Returns the admin role that controls the specified role.
         *  @dev            See {grantRole} and {revokeRole}.
         *                  To change a role's admin, use {_setRoleAdmin}.
         *
         *  @param role     keccak256 hash of the role. e.g. keccak256("TRANSFER_ROLE")
         */
        function getRoleAdmin(bytes32 role) external view override returns (bytes32) {
            return _getRoleAdmin[role];
        }
    
        /**
         *  @notice         Grants a role to an account, if not previously granted.
         *  @dev            Caller must have admin role for the `role`.
         *                  Emits {RoleGranted Event}.
         *
         *  @param role     keccak256 hash of the role. e.g. keccak256("TRANSFER_ROLE")
         *  @param account  Address of the account to which the role is being granted.
         */
        function grantRole(bytes32 role, address account) public virtual override {
            _checkRole(_getRoleAdmin[role], msg.sender);
            if (_hasRole[role][account]) {
                revert("Can only grant to non holders");
            }
            _setupRole(role, account);
        }
    
        /**
         *  @notice         Revokes role from an account.
         *  @dev            Caller must have admin role for the `role`.
         *                  Emits {RoleRevoked Event}.
         *
         *  @param role     keccak256 hash of the role. e.g. keccak256("TRANSFER_ROLE")
         *  @param account  Address of the account from which the role is being revoked.
         */
        function revokeRole(bytes32 role, address account) public virtual override {
            _checkRole(_getRoleAdmin[role], msg.sender);
            _revokeRole(role, account);
        }
    
        /**
         *  @notice         Revokes role from the account.
         *  @dev            Caller must have the `role`, with caller being the same as `account`.
         *                  Emits {RoleRevoked Event}.
         *
         *  @param role     keccak256 hash of the role. e.g. keccak256("TRANSFER_ROLE")
         *  @param account  Address of the account from which the role is being revoked.
         */
        function renounceRole(bytes32 role, address account) public virtual override {
            if (msg.sender != account) {
                revert("Can only renounce for self");
            }
            _revokeRole(role, account);
        }
    
        /// @dev Sets `adminRole` as `role`'s admin role.
        function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
            bytes32 previousAdminRole = _getRoleAdmin[role];
            _getRoleAdmin[role] = adminRole;
            emit RoleAdminChanged(role, previousAdminRole, adminRole);
        }
    
        /// @dev Sets up `role` for `account`
        function _setupRole(bytes32 role, address account) internal virtual {
            _hasRole[role][account] = true;
            emit RoleGranted(role, account, msg.sender);
        }
    
        /// @dev Revokes `role` from `account`
        function _revokeRole(bytes32 role, address account) internal virtual {
            _checkRole(role, account);
            delete _hasRole[role][account];
            emit RoleRevoked(role, account, msg.sender);
        }
    
        /// @dev Checks `role` for `account`. Reverts with a message including the required role.
        function _checkRole(bytes32 role, address account) internal view virtual {
            if (!_hasRole[role][account]) {
                revert(
                    string(
                        abi.encodePacked(
                            "Permissions: account ",
                            TWStrings.toHexString(uint160(account), 20),
                            " is missing role ",
                            TWStrings.toHexString(uint256(role), 32)
                        )
                    )
                );
            }
        }
    
        /// @dev Checks `role` for `account`. Reverts with a message including the required role.
        function _checkRoleWithSwitch(bytes32 role, address account) internal view virtual {
            if (!hasRoleWithSwitch(role, account)) {
                revert(
                    string(
                        abi.encodePacked(
                            "Permissions: account ",
                            TWStrings.toHexString(uint160(account), 20),
                            " is missing role ",
                            TWStrings.toHexString(uint256(role), 32)
                        )
                    )
                );
            }
        }
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    import "./interface/IPermissionsEnumerable.sol";
    import "./Permissions.sol";
    
    /**
     *  @title   PermissionsEnumerable
     *  @dev     This contracts provides extending-contracts with role-based access control mechanisms.
     *           Also provides interfaces to view all members with a given role, and total count of members.
     */
    contract PermissionsEnumerable is IPermissionsEnumerable, Permissions {
        /**
         *  @notice A data structure to store data of members for a given role.
         *
         *  @param index    Current index in the list of accounts that have a role.
         *  @param members  map from index => address of account that has a role
         *  @param indexOf  map from address => index which the account has.
         */
        struct RoleMembers {
            uint256 index;
            mapping(uint256 => address) members;
            mapping(address => uint256) indexOf;
        }
    
        /// @dev map from keccak256 hash of a role to its members' data. See {RoleMembers}.
        mapping(bytes32 => RoleMembers) private roleMembers;
    
        /**
         *  @notice         Returns the role-member from a list of members for a role,
         *                  at a given index.
         *  @dev            Returns `member` who has `role`, at `index` of role-members list.
         *                  See struct {RoleMembers}, and mapping {roleMembers}
         *
         *  @param role     keccak256 hash of the role. e.g. keccak256("TRANSFER_ROLE")
         *  @param index    Index in list of current members for the role.
         *
         *  @return member  Address of account that has `role`
         */
        function getRoleMember(bytes32 role, uint256 index) external view override returns (address member) {
            uint256 currentIndex = roleMembers[role].index;
            uint256 check;
    
            for (uint256 i = 0; i < currentIndex; i += 1) {
                if (roleMembers[role].members[i] != address(0)) {
                    if (check == index) {
                        member = roleMembers[role].members[i];
                        return member;
                    }
                    check += 1;
                } else if (hasRole(role, address(0)) && i == roleMembers[role].indexOf[address(0)]) {
                    check += 1;
                }
            }
        }
    
        /**
         *  @notice         Returns total number of accounts that have a role.
         *  @dev            Returns `count` of accounts that have `role`.
         *                  See struct {RoleMembers}, and mapping {roleMembers}
         *
         *  @param role     keccak256 hash of the role. e.g. keccak256("TRANSFER_ROLE")
         *
         *  @return count   Total number of accounts that have `role`
         */
        function getRoleMemberCount(bytes32 role) external view override returns (uint256 count) {
            uint256 currentIndex = roleMembers[role].index;
    
            for (uint256 i = 0; i < currentIndex; i += 1) {
                if (roleMembers[role].members[i] != address(0)) {
                    count += 1;
                }
            }
            if (hasRole(role, address(0))) {
                count += 1;
            }
        }
    
        /// @dev Revokes `role` from `account`, and removes `account` from {roleMembers}
        ///      See {_removeMember}
        function _revokeRole(bytes32 role, address account) internal override {
            super._revokeRole(role, account);
            _removeMember(role, account);
        }
    
        /// @dev Grants `role` to `account`, and adds `account` to {roleMembers}
        ///      See {_addMember}
        function _setupRole(bytes32 role, address account) internal override {
            super._setupRole(role, account);
            _addMember(role, account);
        }
    
        /// @dev adds `account` to {roleMembers}, for `role`
        function _addMember(bytes32 role, address account) internal {
            uint256 idx = roleMembers[role].index;
            roleMembers[role].index += 1;
    
            roleMembers[role].members[idx] = account;
            roleMembers[role].indexOf[account] = idx;
        }
    
        /// @dev removes `account` from {roleMembers}, for `role`
        function _removeMember(bytes32 role, address account) internal {
            uint256 idx = roleMembers[role].indexOf[account];
    
            delete roleMembers[role].members[idx];
            delete roleMembers[role].indexOf[account];
        }
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    import "./interface/IPrimarySale.sol";
    
    /**
     *  @title   Primary Sale
     *  @notice  Thirdweb's `PrimarySale` is a contract extension to be used with any base contract. It exposes functions for setting and reading
     *           the recipient of primary sales, and lets the inheriting contract perform conditional logic that uses information about
     *           primary sales, if desired.
     */
    
    abstract contract PrimarySale is IPrimarySale {
        /// @dev The address that receives all primary sales value.
        address private recipient;
    
        /// @dev Returns primary sale recipient address.
        function primarySaleRecipient() public view override returns (address) {
            return recipient;
        }
    
        /**
         *  @notice         Updates primary sale recipient.
         *  @dev            Caller should be authorized to set primary sales info.
         *                  See {_canSetPrimarySaleRecipient}.
         *                  Emits {PrimarySaleRecipientUpdated Event}; See {_setupPrimarySaleRecipient}.
         *
         *  @param _saleRecipient   Address to be set as new recipient of primary sales.
         */
        function setPrimarySaleRecipient(address _saleRecipient) external override {
            if (!_canSetPrimarySaleRecipient()) {
                revert("Not authorized");
            }
            _setupPrimarySaleRecipient(_saleRecipient);
        }
    
        /// @dev Lets a contract admin set the recipient for all primary sales.
        function _setupPrimarySaleRecipient(address _saleRecipient) internal {
            recipient = _saleRecipient;
            emit PrimarySaleRecipientUpdated(_saleRecipient);
        }
    
        /// @dev Returns whether primary sale recipient can be set in the given execution context.
        function _canSetPrimarySaleRecipient() internal view virtual returns (bool);
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    import "./interface/IRoyalty.sol";
    
    /**
     *  @title   Royalty
     *  @notice  Thirdweb's `Royalty` is a contract extension to be used with any base contract. It exposes functions for setting and reading
     *           the recipient of royalty fee and the royalty fee basis points, and lets the inheriting contract perform conditional logic
     *           that uses information about royalty fees, if desired.
     *
     *  @dev     The `Royalty` contract is ERC2981 compliant.
     */
    
    abstract contract Royalty is IRoyalty {
        /// @dev The (default) address that receives all royalty value.
        address private royaltyRecipient;
    
        /// @dev The (default) % of a sale to take as royalty (in basis points).
        uint16 private royaltyBps;
    
        /// @dev Token ID => royalty recipient and bps for token
        mapping(uint256 => RoyaltyInfo) private royaltyInfoForToken;
    
        /**
         *  @notice   View royalty info for a given token and sale price.
         *  @dev      Returns royalty amount and recipient for `tokenId` and `salePrice`.
         *  @param tokenId          The tokenID of the NFT for which to query royalty info.
         *  @param salePrice        Sale price of the token.
         *
         *  @return receiver        Address of royalty recipient account.
         *  @return royaltyAmount   Royalty amount calculated at current royaltyBps value.
         */
        function royaltyInfo(uint256 tokenId, uint256 salePrice)
            external
            view
            virtual
            override
            returns (address receiver, uint256 royaltyAmount)
        {
            (address recipient, uint256 bps) = getRoyaltyInfoForToken(tokenId);
            receiver = recipient;
            royaltyAmount = (salePrice * bps) / 10_000;
        }
    
        /**
         *  @notice          View royalty info for a given token.
         *  @dev             Returns royalty recipient and bps for `_tokenId`.
         *  @param _tokenId  The tokenID of the NFT for which to query royalty info.
         */
        function getRoyaltyInfoForToken(uint256 _tokenId) public view override returns (address, uint16) {
            RoyaltyInfo memory royaltyForToken = royaltyInfoForToken[_tokenId];
    
            return
                royaltyForToken.recipient == address(0)
                    ? (royaltyRecipient, uint16(royaltyBps))
                    : (royaltyForToken.recipient, uint16(royaltyForToken.bps));
        }
    
        /**
         *  @notice Returns the defualt royalty recipient and BPS for this contract's NFTs.
         */
        function getDefaultRoyaltyInfo() external view override returns (address, uint16) {
            return (royaltyRecipient, uint16(royaltyBps));
        }
    
        /**
         *  @notice         Updates default royalty recipient and bps.
         *  @dev            Caller should be authorized to set royalty info.
         *                  See {_canSetRoyaltyInfo}.
         *                  Emits {DefaultRoyalty Event}; See {_setupDefaultRoyaltyInfo}.
         *
         *  @param _royaltyRecipient   Address to be set as default royalty recipient.
         *  @param _royaltyBps         Updated royalty bps.
         */
        function setDefaultRoyaltyInfo(address _royaltyRecipient, uint256 _royaltyBps) external override {
            if (!_canSetRoyaltyInfo()) {
                revert("Not authorized");
            }
    
            _setupDefaultRoyaltyInfo(_royaltyRecipient, _royaltyBps);
        }
    
        /// @dev Lets a contract admin update the default royalty recipient and bps.
        function _setupDefaultRoyaltyInfo(address _royaltyRecipient, uint256 _royaltyBps) internal {
            if (_royaltyBps > 10_000) {
                revert("Exceeds max bps");
            }
    
            royaltyRecipient = _royaltyRecipient;
            royaltyBps = uint16(_royaltyBps);
    
            emit DefaultRoyalty(_royaltyRecipient, _royaltyBps);
        }
    
        /**
         *  @notice         Updates default royalty recipient and bps for a particular token.
         *  @dev            Sets royalty info for `_tokenId`. Caller should be authorized to set royalty info.
         *                  See {_canSetRoyaltyInfo}.
         *                  Emits {RoyaltyForToken Event}; See {_setupRoyaltyInfoForToken}.
         *
         *  @param _recipient   Address to be set as royalty recipient for given token Id.
         *  @param _bps         Updated royalty bps for the token Id.
         */
        function setRoyaltyInfoForToken(
            uint256 _tokenId,
            address _recipient,
            uint256 _bps
        ) external override {
            if (!_canSetRoyaltyInfo()) {
                revert("Not authorized");
            }
    
            _setupRoyaltyInfoForToken(_tokenId, _recipient, _bps);
        }
    
        /// @dev Lets a contract admin set the royalty recipient and bps for a particular token Id.
        function _setupRoyaltyInfoForToken(
            uint256 _tokenId,
            address _recipient,
            uint256 _bps
        ) internal {
            if (_bps > 10_000) {
                revert("Exceeds max bps");
            }
    
            royaltyInfoForToken[_tokenId] = RoyaltyInfo({ recipient: _recipient, bps: _bps });
    
            emit RoyaltyForToken(_tokenId, _recipient, _bps);
        }
    
        /// @dev Returns whether royalty info can be set in the given execution context.
        function _canSetRoyaltyInfo() internal view virtual returns (bool);
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    /**
     *  The interface `IClaimCondition` is written for thirdweb's 'Drop' contracts, which are distribution mechanisms for tokens.
     *
     *  A claim condition defines criteria under which accounts can mint tokens. Claim conditions can be overwritten
     *  or added to by the contract admin. At any moment, there is only one active claim condition.
     */
    
    interface IClaimCondition {
        /**
         *  @notice The criteria that make up a claim condition.
         *
         *  @param startTimestamp                 The unix timestamp after which the claim condition applies.
         *                                        The same claim condition applies until the `startTimestamp`
         *                                        of the next claim condition.
         *
         *  @param maxClaimableSupply             The maximum total number of tokens that can be claimed under
         *                                        the claim condition.
         *
         *  @param supplyClaimed                  At any given point, the number of tokens that have been claimed
         *                                        under the claim condition.
         *
         *  @param quantityLimitPerWallet         The maximum number of tokens that can be claimed by a wallet.
         *
         *  @param merkleRoot                     The allowlist of addresses that can claim tokens under the claim
         *                                        condition.
         *
         *  @param pricePerToken                  The price required to pay per token claimed.
         *
         *  @param currency                       The currency in which the `pricePerToken` must be paid.
         *
         *  @param metadata                       Claim condition metadata.
         */
        struct ClaimCondition {
            uint256 startTimestamp;
            uint256 maxClaimableSupply;
            uint256 supplyClaimed;
            uint256 quantityLimitPerWallet;
            bytes32 merkleRoot;
            uint256 pricePerToken;
            address currency;
            string metadata;
        }
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    import "./IClaimCondition.sol";
    
    /**
     *  The interface `IClaimConditionMultiPhase` is written for thirdweb's 'Drop' contracts, which are distribution mechanisms for tokens.
     *
     *  An authorized wallet can set a series of claim conditions, ordered by their respective `startTimestamp`.
     *  A claim condition defines criteria under which accounts can mint tokens. Claim conditions can be overwritten
     *  or added to by the contract admin. At any moment, there is only one active claim condition.
     */
    
    interface IClaimConditionMultiPhase is IClaimCondition {
        /**
         *  @notice The set of all claim conditions, at any given moment.
         *  Claim Phase ID = [currentStartId, currentStartId + length - 1];
         *
         *  @param currentStartId           The uid for the first claim condition amongst the current set of
         *                                  claim conditions. The uid for each next claim condition is one
         *                                  more than the previous claim condition's uid.
         *
         *  @param count                    The total number of phases / claim conditions in the list
         *                                  of claim conditions.
         *
         *  @param conditions                   The claim conditions at a given uid. Claim conditions
         *                                  are ordered in an ascending order by their `startTimestamp`.
         *
         *  @param supplyClaimedByWallet    Map from a claim condition uid and account to supply claimed by account.
         */
        struct ClaimConditionList {
            uint256 currentStartId;
            uint256 count;
            mapping(uint256 => ClaimCondition) conditions;
            mapping(uint256 => mapping(address => uint256)) supplyClaimedByWallet;
        }
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    /**
     *  Thirdweb's `ContractMetadata` is a contract extension for any base contracts. It lets you set a metadata URI
     *  for you contract.
     *
     *  Additionally, `ContractMetadata` is necessary for NFT contracts that want royalties to get distributed on OpenSea.
     */
    
    interface IContractMetadata {
        /// @dev Returns the metadata URI of the contract.
        function contractURI() external view returns (string memory);
    
        /**
         *  @dev Sets contract URI for the storefront-level metadata of the contract.
         *       Only module admin can call this function.
         */
        function setContractURI(string calldata _uri) external;
    
        /// @dev Emitted when the contract URI is updated.
        event ContractURIUpdated(string prevURI, string newURI);
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    import "./IClaimConditionMultiPhase.sol";
    
    /**
     *  The interface `IDrop1155` is written for thirdweb's 'Drop' contracts, which are distribution mechanisms for tokens.
     *
     *  An authorized wallet can set a series of claim conditions, ordered by their respective `startTimestamp`.
     *  A claim condition defines criteria under which accounts can mint tokens. Claim conditions can be overwritten
     *  or added to by the contract admin. At any moment, there is only one active claim condition.
     */
    
    interface IDrop1155 is IClaimConditionMultiPhase {
        /**
         *  @param proof Proof of concerned wallet's inclusion in an allowlist.
         *  @param quantityLimitPerWallet The total quantity of tokens the allowlisted wallet is eligible to claim over time.
         *  @param pricePerToken The price per token the allowlisted wallet must pay to claim tokens.
         *  @param currency The currency in which the allowlisted wallet must pay the price for claiming tokens.
         */
        struct AllowlistProof {
            bytes32[] proof;
            uint256 quantityLimitPerWallet;
            uint256 pricePerToken;
            address currency;
        }
    
        /// @notice Emitted when tokens are claimed.
        event TokensClaimed(
            uint256 indexed claimConditionIndex,
            address indexed claimer,
            address indexed receiver,
            uint256 tokenId,
            uint256 quantityClaimed
        );
    
        /// @notice Emitted when the contract's claim conditions are updated.
        event ClaimConditionsUpdated(uint256 indexed tokenId, ClaimCondition[] claimConditions, bool resetEligibility);
    
        /**
         *  @notice Lets an account claim a given quantity of NFTs.
         *
         *  @param receiver                       The receiver of the NFTs to claim.
         *  @param tokenId                        The tokenId of the NFT to claim.
         *  @param quantity                       The quantity of NFTs to claim.
         *  @param currency                       The currency in which to pay for the claim.
         *  @param pricePerToken                  The price per token to pay for the claim.
         *  @param allowlistProof                 The proof of the claimer's inclusion in the merkle root allowlist
         *                                        of the claim conditions that apply.
         *  @param data                           Arbitrary bytes data that can be leveraged in the implementation of this interface.
         */
        function claim(
            address receiver,
            uint256 tokenId,
            uint256 quantity,
            address currency,
            uint256 pricePerToken,
            AllowlistProof calldata allowlistProof,
            bytes memory data
        ) external payable;
    
        /**
         *  @notice Lets a contract admin (account with `DEFAULT_ADMIN_ROLE`) set claim conditions.
         *
         *  @param tokenId                  The token ID for which to set mint conditions.
         *  @param phases                   Claim conditions in ascending order by `startTimestamp`.
         *
         *  @param resetClaimEligibility    Whether to honor the restrictions applied to wallets who have claimed tokens in the current conditions,
         *                                  in the new claim conditions being set.
         *
         */
        function setClaimConditions(
            uint256 tokenId,
            ClaimCondition[] calldata phases,
            bool resetClaimEligibility
        ) external;
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    /**
     *  Thirdweb's `LazyMint` is a contract extension for any base NFT contract. It lets you 'lazy mint' any number of NFTs
     *  at once. Here, 'lazy mint' means defining the metadata for particular tokenIds of your NFT contract, without actually
     *  minting a non-zero balance of NFTs of those tokenIds.
     */
    
    interface ILazyMint {
        /// @dev Emitted when tokens are lazy minted.
        event TokensLazyMinted(uint256 indexed startTokenId, uint256 endTokenId, string baseURI, bytes encryptedBaseURI);
    
        /**
         *  @notice Lazy mints a given amount of NFTs.
         *
         *  @param amount           The number of NFTs to lazy mint.
         *
         *  @param baseURIForTokens The base URI for the 'n' number of NFTs being lazy minted, where the metadata for each
         *                          of those NFTs is `${baseURIForTokens}/${tokenId}`.
         *
         *  @param extraData        Additional bytes data to be used at the discretion of the consumer of the contract.
         *
         *  @return batchId         A unique integer identifier for the batch of NFTs lazy minted together.
         */
        function lazyMint(
            uint256 amount,
            string calldata baseURIForTokens,
            bytes calldata extraData
        ) external returns (uint256 batchId);
    }

    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    /**
     * @dev Provides a function to batch together multiple calls in a single external call.
     *
     * _Available since v4.1._
     */
    interface IMulticall {
        /**
         * @dev Receives and executes a batch of function calls on this contract.
         */
        function multicall(bytes[] calldata data) external returns (bytes[] memory results);
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    /**
     *  Thirdweb's `Ownable` is a contract extension to be used with any base contract. It exposes functions for setting and reading
     *  who the 'owner' of the inheriting smart contract is, and lets the inheriting contract perform conditional logic that uses
     *  information about who the contract's owner is.
     */
    
    interface IOwnable {
        /// @dev Returns the owner of the contract.
        function owner() external view returns (address);
    
        /// @dev Lets a module admin set a new owner for the contract. The new owner must be a module admin.
        function setOwner(address _newOwner) external;
    
        /// @dev Emitted when a new Owner is set.
        event OwnerUpdated(address indexed prevOwner, address indexed newOwner);
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    /**
     * @dev External interface of AccessControl declared to support ERC165 detection.
     */
    interface IPermissions {
        /**
         * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
         *
         * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
         * {RoleAdminChanged} not being emitted signaling this.
         *
         * _Available since v3.1._
         */
        event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
    
        /**
         * @dev Emitted when `account` is granted `role`.
         *
         * `sender` is the account that originated the contract call, an admin role
         * bearer except when using {AccessControl-_setupRole}.
         */
        event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
    
        /**
         * @dev Emitted when `account` is revoked `role`.
         *
         * `sender` is the account that originated the contract call:
         *   - if using `revokeRole`, it is the admin role bearer
         *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
         */
        event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
    
        /**
         * @dev Returns `true` if `account` has been granted `role`.
         */
        function hasRole(bytes32 role, address account) external view returns (bool);
    
        /**
         * @dev Returns the admin role that controls `role`. See {grantRole} and
         * {revokeRole}.
         *
         * To change a role's admin, use {AccessControl-_setRoleAdmin}.
         */
        function getRoleAdmin(bytes32 role) external view returns (bytes32);
    
        /**
         * @dev Grants `role` to `account`.
         *
         * If `account` had not been already granted `role`, emits a {RoleGranted}
         * event.
         *
         * Requirements:
         *
         * - the caller must have ``role``'s admin role.
         */
        function grantRole(bytes32 role, address account) external;
    
        /**
         * @dev Revokes `role` from `account`.
         *
         * If `account` had been granted `role`, emits a {RoleRevoked} event.
         *
         * Requirements:
         *
         * - the caller must have ``role``'s admin role.
         */
        function revokeRole(bytes32 role, address account) external;
    
        /**
         * @dev Revokes `role` from the calling account.
         *
         * Roles are often managed via {grantRole} and {revokeRole}: this function's
         * purpose is to provide a mechanism for accounts to lose their privileges
         * if they are compromised (such as when a trusted device is misplaced).
         *
         * If the calling account had been granted `role`, emits a {RoleRevoked}
         * event.
         *
         * Requirements:
         *
         * - the caller must be `account`.
         */
        function renounceRole(bytes32 role, address account) external;
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    import "./IPermissions.sol";
    
    /**
     * @dev External interface of AccessControlEnumerable declared to support ERC165 detection.
     */
    interface IPermissionsEnumerable is IPermissions {
        /**
         * @dev Returns one of the accounts that have `role`. `index` must be a
         * value between 0 and {getRoleMemberCount}, non-inclusive.
         *
         * Role bearers are not sorted in any particular way, and their ordering may
         * change at any point.
         *
         * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
         * you perform all queries on the same block. See the following
         * [forum post](https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296)
         * for more information.
         */
        function getRoleMember(bytes32 role, uint256 index) external view returns (address);
    
        /**
         * @dev Returns the number of accounts that have `role`. Can be used
         * together with {getRoleMember} to enumerate all bearers of a role.
         */
        function getRoleMemberCount(bytes32 role) external view returns (uint256);
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    /**
     *  Thirdweb's `Primary` is a contract extension to be used with any base contract. It exposes functions for setting and reading
     *  the recipient of primary sales, and lets the inheriting contract perform conditional logic that uses information about
     *  primary sales, if desired.
     */
    
    interface IPrimarySale {
        /// @dev The adress that receives all primary sales value.
        function primarySaleRecipient() external view returns (address);
    
        /// @dev Lets a module admin set the default recipient of all primary sales.
        function setPrimarySaleRecipient(address _saleRecipient) external;
    
        /// @dev Emitted when a new sale recipient is set.
        event PrimarySaleRecipientUpdated(address indexed recipient);
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    import "../../eip/interface/IERC2981.sol";
    
    /**
     *  Thirdweb's `Royalty` is a contract extension to be used with any base contract. It exposes functions for setting and reading
     *  the recipient of royalty fee and the royalty fee basis points, and lets the inheriting contract perform conditional logic
     *  that uses information about royalty fees, if desired.
     *
     *  The `Royalty` contract is ERC2981 compliant.
     */
    
    interface IRoyalty is IERC2981 {
        struct RoyaltyInfo {
            address recipient;
            uint256 bps;
        }
    
        /// @dev Returns the royalty recipient and fee bps.
        function getDefaultRoyaltyInfo() external view returns (address, uint16);
    
        /// @dev Lets a module admin update the royalty bps and recipient.
        function setDefaultRoyaltyInfo(address _royaltyRecipient, uint256 _royaltyBps) external;
    
        /// @dev Lets a module admin set the royalty recipient for a particular token Id.
        function setRoyaltyInfoForToken(
            uint256 tokenId,
            address recipient,
            uint256 bps
        ) external;
    
        /// @dev Returns the royalty recipient for a particular token Id.
        function getRoyaltyInfoForToken(uint256 tokenId) external view returns (address, uint16);
    
        /// @dev Emitted when royalty info is updated.
        event DefaultRoyalty(address indexed newRoyaltyRecipient, uint256 newRoyaltyBps);
    
        /// @dev Emitted when royalty recipient for tokenId is set
        event RoyaltyForToken(uint256 indexed tokenId, address indexed royaltyRecipient, uint256 royaltyBps);
    }

    // SPDX-License-Identifier: MIT
    // OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)
    
    pragma solidity ^0.8.0;
    
    import "../../../../../eip/interface/IERC20.sol";
    import "../../../../../lib/TWAddress.sol";
    
    /**
     * @title SafeERC20
     * @dev Wrappers around ERC20 operations that throw on failure (when the token
     * contract returns false). Tokens that return no value (and instead revert or
     * throw on failure) are also supported, non-reverting calls are assumed to be
     * successful.
     * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
     * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
     */
    library SafeERC20 {
        using TWAddress for address;
    
        function safeTransfer(
            IERC20 token,
            address to,
            uint256 value
        ) internal {
            _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
        }
    
        function safeTransferFrom(
            IERC20 token,
            address from,
            address to,
            uint256 value
        ) internal {
            _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
        }
    
        /**
         * @dev Deprecated. This function has issues similar to the ones found in
         * {IERC20-approve}, and its usage is discouraged.
         *
         * Whenever possible, use {safeIncreaseAllowance} and
         * {safeDecreaseAllowance} instead.
         */
        function safeApprove(
            IERC20 token,
            address spender,
            uint256 value
        ) internal {
            // safeApprove should only be called when setting an initial allowance,
            // or when resetting it to zero. To increase and decrease it, use
            // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
            require(
                (value == 0) || (token.allowance(address(this), spender) == 0),
                "SafeERC20: approve from non-zero to non-zero allowance"
            );
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
        }
    
        function safeIncreaseAllowance(
            IERC20 token,
            address spender,
            uint256 value
        ) internal {
            uint256 newAllowance = token.allowance(address(this), spender) + value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    
        function safeDecreaseAllowance(
            IERC20 token,
            address spender,
            uint256 value
        ) internal {
            unchecked {
                uint256 oldAllowance = token.allowance(address(this), spender);
                require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
                uint256 newAllowance = oldAllowance - value;
                _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
            }
        }
    
        /**
         * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
         * on the return value: the return value is optional (but if data is returned, it must not be false).
         * @param token The token targeted by the call.
         * @param data The call data (encoded using abi.encode or one of its variants).
         */
        function _callOptionalReturn(IERC20 token, bytes memory data) private {
            // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
            // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
            // the target address contains contract code and also asserts for success in the low-level call.
    
            bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
            if (returndata.length > 0) {
                // Return data is optional
                require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
            }
        }
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    interface IWETH {
        function deposit() external payable;
    
        function withdraw(uint256 amount) external;
    
        function transfer(address to, uint256 value) external returns (bool);
    }

    // SPDX-License-Identifier: Apache-2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    // Helper interfaces
    import { IWETH } from "../infra/interface/IWETH.sol";
    
    import "../external-deps/openzeppelin/token/ERC20/utils/SafeERC20.sol";
    
    library CurrencyTransferLib {
        using SafeERC20 for IERC20;
    
        /// @dev The address interpreted as native token of the chain.
        address public constant NATIVE_TOKEN = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
    
        /// @dev Transfers a given amount of currency.
        function transferCurrency(
            address _currency,
            address _from,
            address _to,
            uint256 _amount
        ) internal {
            if (_amount == 0) {
                return;
            }
    
            if (_currency == NATIVE_TOKEN) {
                safeTransferNativeToken(_to, _amount);
            } else {
                safeTransferERC20(_currency, _from, _to, _amount);
            }
        }
    
        /// @dev Transfers a given amount of currency. (With native token wrapping)
        function transferCurrencyWithWrapper(
            address _currency,
            address _from,
            address _to,
            uint256 _amount,
            address _nativeTokenWrapper
        ) internal {
            if (_amount == 0) {
                return;
            }
    
            if (_currency == NATIVE_TOKEN) {
                if (_from == address(this)) {
                    // withdraw from weth then transfer withdrawn native token to recipient
                    IWETH(_nativeTokenWrapper).withdraw(_amount);
                    safeTransferNativeTokenWithWrapper(_to, _amount, _nativeTokenWrapper);
                } else if (_to == address(this)) {
                    // store native currency in weth
                    require(_amount == msg.value, "msg.value != amount");
                    IWETH(_nativeTokenWrapper).deposit{ value: _amount }();
                } else {
                    safeTransferNativeTokenWithWrapper(_to, _amount, _nativeTokenWrapper);
                }
            } else {
                safeTransferERC20(_currency, _from, _to, _amount);
            }
        }
    
        /// @dev Transfer `amount` of ERC20 token from `from` to `to`.
        function safeTransferERC20(
            address _currency,
            address _from,
            address _to,
            uint256 _amount
        ) internal {
            if (_from == _to) {
                return;
            }
    
            if (_from == address(this)) {
                IERC20(_currency).safeTransfer(_to, _amount);
            } else {
                IERC20(_currency).safeTransferFrom(_from, _to, _amount);
            }
        }
    
        /// @dev Transfers `amount` of native token to `to`.
        function safeTransferNativeToken(address to, uint256 value) internal {
            // solhint-disable avoid-low-level-calls
            // slither-disable-next-line low-level-calls
            (bool success, ) = to.call{ value: value }("");
            require(success, "native token transfer failed");
        }
    
        /// @dev Transfers `amount` of native token to `to`. (With native token wrapping)
        function safeTransferNativeTokenWithWrapper(
            address to,
            uint256 value,
            address _nativeTokenWrapper
        ) internal {
            // solhint-disable avoid-low-level-calls
            // slither-disable-next-line low-level-calls
            (bool success, ) = to.call{ value: value }("");
            if (!success) {
                IWETH(_nativeTokenWrapper).deposit{ value: value }();
                IERC20(_nativeTokenWrapper).safeTransfer(to, value);
            }
        }
    }

    // SPDX-License-Identifier: Apache 2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    /**
     * @dev These functions deal with verification of Merkle Trees proofs.
     *
     * The proofs can be generated using the JavaScript library
     * https://github.com/miguelmota/merkletreejs[merkletreejs].
     * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
     *
     * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
     *
     * Source: https://github.com/ensdomains/governance/blob/master/contracts/MerkleProof.sol
     */
    library MerkleProof {
        /**
         * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
         * defined by `root`. For this, a `proof` must be provided, containing
         * sibling hashes on the branch from the leaf to the root of the tree. Each
         * pair of leaves and each pair of pre-images are assumed to be sorted.
         */
        function verify(
            bytes32[] memory proof,
            bytes32 root,
            bytes32 leaf
        ) internal pure returns (bool, uint256) {
            bytes32 computedHash = leaf;
            uint256 index = 0;
    
            for (uint256 i = 0; i < proof.length; i++) {
                index *= 2;
                bytes32 proofElement = proof[i];
    
                if (computedHash <= proofElement) {
                    // Hash(current computed hash + current element of the proof)
                    computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
                } else {
                    // Hash(current element of the proof + current computed hash)
                    computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
                    index += 1;
                }
            }
    
            // Check if the computed hash (root) is equal to the provided root
            return (computedHash == root, index);
        }
    }

    // SPDX-License-Identifier: Apache 2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    /**
     * @dev Collection of functions related to the address type
     */
    library TWAddress {
        /**
         * @dev Returns true if `account` is a contract.
         *
         * [IMPORTANT]
         * ====
         * It is unsafe to assume that an address for which this function returns
         * false is an externally-owned account (EOA) and not a contract.
         *
         * Among others, `isContract` will return false for the following
         * types of addresses:
         *
         *  - an externally-owned account
         *  - a contract in construction
         *  - an address where a contract will be created
         *  - an address where a contract lived, but was destroyed
         * ====
         *
         * [IMPORTANT]
         * ====
         * You shouldn't rely on `isContract` to protect against flash loan attacks!
         *
         * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
         * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
         * constructor.
         * ====
         */
        function isContract(address account) internal view returns (bool) {
            // This method relies on extcodesize/address.code.length, which returns 0
            // for contracts in construction, since the code is only stored at the end
            // of the constructor execution.
    
            return account.code.length > 0;
        }
    
        /**
         * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
         * `recipient`, forwarding all available gas and reverting on errors.
         *
         * [EIP1884](https://eips.ethereum.org/EIPS/eip-1884) increases the gas cost
         * of certain opcodes, possibly making contracts go over the 2300 gas limit
         * imposed by `transfer`, making them unable to receive funds via
         * `transfer`. {sendValue} removes this limitation.
         *
         * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
         *
         * IMPORTANT: because control is transferred to `recipient`, care must be
         * taken to not create reentrancy vulnerabilities. Consider using
         * {ReentrancyGuard} or the
         * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
         */
        function sendValue(address payable recipient, uint256 amount) internal {
            require(address(this).balance >= amount, "Address: insufficient balance");
    
            (bool success, ) = recipient.call{ value: amount }("");
            require(success, "Address: unable to send value, recipient may have reverted");
        }
    
        /**
         * @dev Performs a Solidity function call using a low level `call`. A
         * plain `call` is an unsafe replacement for a function call: use this
         * function instead.
         *
         * If `target` reverts with a revert reason, it is bubbled up by this
         * function (like regular Solidity function calls).
         *
         * Returns the raw returned data. To convert to the expected return value,
         * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
         *
         * Requirements:
         *
         * - `target` must be a contract.
         * - calling `target` with `data` must not revert.
         *
         * _Available since v3.1._
         */
        function functionCall(address target, bytes memory data) internal returns (bytes memory) {
            return functionCall(target, data, "Address: low-level call failed");
        }
    
        /**
         * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
         * `errorMessage` as a fallback revert reason when `target` reverts.
         *
         * _Available since v3.1._
         */
        function functionCall(
            address target,
            bytes memory data,
            string memory errorMessage
        ) internal returns (bytes memory) {
            return functionCallWithValue(target, data, 0, errorMessage);
        }
    
        /**
         * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
         * but also transferring `value` wei to `target`.
         *
         * Requirements:
         *
         * - the calling contract must have an ETH balance of at least `value`.
         * - the called Solidity function must be `payable`.
         *
         * _Available since v3.1._
         */
        function functionCallWithValue(
            address target,
            bytes memory data,
            uint256 value
        ) internal returns (bytes memory) {
            return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
        }
    
        /**
         * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
         * with `errorMessage` as a fallback revert reason when `target` reverts.
         *
         * _Available since v3.1._
         */
        function functionCallWithValue(
            address target,
            bytes memory data,
            uint256 value,
            string memory errorMessage
        ) internal returns (bytes memory) {
            require(address(this).balance >= value, "Address: insufficient balance for call");
            require(isContract(target), "Address: call to non-contract");
    
            (bool success, bytes memory returndata) = target.call{ value: value }(data);
            return verifyCallResult(success, returndata, errorMessage);
        }
    
        /**
         * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
         * but performing a static call.
         *
         * _Available since v3.3._
         */
        function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
            return functionStaticCall(target, data, "Address: low-level static call failed");
        }
    
        /**
         * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
         * but performing a static call.
         *
         * _Available since v3.3._
         */
        function functionStaticCall(
            address target,
            bytes memory data,
            string memory errorMessage
        ) internal view returns (bytes memory) {
            require(isContract(target), "Address: static call to non-contract");
    
            (bool success, bytes memory returndata) = target.staticcall(data);
            return verifyCallResult(success, returndata, errorMessage);
        }
    
        /**
         * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
         * but performing a delegate call.
         *
         * _Available since v3.4._
         */
        function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
            return functionDelegateCall(target, data, "Address: low-level delegate call failed");
        }
    
        /**
         * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
         * but performing a delegate call.
         *
         * _Available since v3.4._
         */
        function functionDelegateCall(
            address target,
            bytes memory data,
            string memory errorMessage
        ) internal returns (bytes memory) {
            require(isContract(target), "Address: delegate call to non-contract");
    
            (bool success, bytes memory returndata) = target.delegatecall(data);
            return verifyCallResult(success, returndata, errorMessage);
        }
    
        /**
         * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
         * revert reason using the provided one.
         *
         * _Available since v4.3._
         */
        function verifyCallResult(
            bool success,
            bytes memory returndata,
            string memory errorMessage
        ) internal pure returns (bytes memory) {
            if (success) {
                return returndata;
            } else {
                // Look for revert reason and bubble it up if present
                if (returndata.length > 0) {
                    // The easiest way to bubble the revert reason is using memory via assembly
    
                    assembly {
                        let returndata_size := mload(returndata)
                        revert(add(32, returndata), returndata_size)
                    }
                } else {
                    revert(errorMessage);
                }
            }
        }
    }

    // SPDX-License-Identifier: Apache 2.0
    pragma solidity ^0.8.0;
    
    /// @author thirdweb
    
    /**
     * @dev String operations.
     */
    library TWStrings {
        bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
    
        /**
         * @dev Converts a `uint256` to its ASCII `string` decimal representation.
         */
        function toString(uint256 value) internal pure returns (string memory) {
            // Inspired by OraclizeAPI's implementation - MIT licence
            // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol
    
            if (value == 0) {
                return "0";
            }
            uint256 temp = value;
            uint256 digits;
            while (temp != 0) {
                digits++;
                temp /= 10;
            }
            bytes memory buffer = new bytes(digits);
            while (value != 0) {
                digits -= 1;
                buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
                value /= 10;
            }
            return string(buffer);
        }
    
        /**
         * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
         */
        function toHexString(uint256 value) internal pure returns (string memory) {
            if (value == 0) {
                return "0x00";
            }
            uint256 temp = value;
            uint256 length = 0;
            while (temp != 0) {
                length++;
                temp >>= 8;
            }
            return toHexString(value, length);
        }
    
        /**
         * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
         */
        function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
            bytes memory buffer = new bytes(2 * length + 2);
            buffer[0] = "0";
            buffer[1] = "x";
            for (uint256 i = 2 * length + 1; i > 1; --i) {
                buffer[i] = _HEX_SYMBOLS[value & 0xf];
                value >>= 4;
            }
            require(value == 0, "Strings: hex length insufficient");
            return string(buffer);
        }
    }

    // SPDX-License-Identifier: MIT
    pragma solidity ^0.8.0;
    
    import "@thirdweb-dev/contracts/base/ERC1155Base.sol";
    
    //  ==========  External imports    ==========
    
    //  ==========  Internal imports    ==========
    import "@thirdweb-dev/contracts/lib/CurrencyTransferLib.sol";
    import "@thirdweb-dev/contracts/lib/TWStrings.sol";
    
    //  ==========  Features    ==========
    import "@thirdweb-dev/contracts/extension/PrimarySale.sol";
    import "@thirdweb-dev/contracts/extension/LazyMint.sol";
    import "@thirdweb-dev/contracts/extension/PermissionsEnumerable.sol";
    import "@thirdweb-dev/contracts/extension/Drop1155.sol";
    import "../extension/TransactionFee.sol";
    
    contract MintpadERC1155Drop is 
        ERC1155Base,
        PrimarySale,
        LazyMint,
        TransactionFee,
        PermissionsEnumerable,
        Drop1155
    {
        using TWStrings for uint256;
    
        /*///////////////////////////////////////////////////////////////
                                State variables
        //////////////////////////////////////////////////////////////*/
    
        /// @dev Only transfers to or from TRANSFER_ROLE holders are valid, when transfers are restricted.
        bytes32 private transferRole;
        /// @dev Only MINTER_ROLE holders can sign off on `MintRequest`s and lazy mint tokens.
        bytes32 private minterRole;
    
        /*///////////////////////////////////////////////////////////////
                                    Mappings
        //////////////////////////////////////////////////////////////*/
    
        /// @dev Mapping from token ID => maximum possible total circulating supply of tokens with that ID.
        mapping(uint256 => uint256) public maxTotalSupply;
    
        /// @dev Mapping from token ID => the address of the recipient of primary sales.
        mapping(uint256 => address) public saleRecipient;
        
        constructor (
            address _defaultAdmin,
            string memory _name,
            string memory _symbol,
            address _saleRecipient,
            uint256 _transactionFee,
            address _royaltyRecipient,
            uint128 _royaltyBps
        ) 
            ERC1155Base(
                _defaultAdmin,
                _name,
                _symbol,
                _royaltyRecipient,
                _royaltyBps
            ) 
        {
            require(_transactionFee > 0, "!TransactionFee");
    
            bytes32 _transferRole = keccak256("TRANSFER_ROLE");
            bytes32 _minterRole = keccak256("MINTER_ROLE");
    
            _setupRole(DEFAULT_ADMIN_ROLE, _defaultAdmin);
            _setupRole(_minterRole, _defaultAdmin);
            _setupRole(_transferRole, _defaultAdmin);
            _setupRole(_transferRole, address(0));
    
            _setupPrimarySaleRecipient(_saleRecipient);
    
            transferRole = _transferRole;
            minterRole = _minterRole;
    
            transactionFee = _transactionFee;
        }
    
        /*///////////////////////////////////////////////////////////////
                            Contract identifiers
        //////////////////////////////////////////////////////////////*/
    
        function contractType() external pure returns (bytes32) {
            return bytes32("ERC1155");
        }
    
        /*//////////////////////////////////////////////////////////////
                            Overriden ERC1155 logic
        //////////////////////////////////////////////////////////////*/
    
        /// @dev Returns the uri for a given tokenId.
        function uri(uint256 _tokenId) public view override returns (string memory) {
            string memory batchUri = _getBaseURI(_tokenId);
            return string(abi.encodePacked(batchUri, _tokenId.toString()));
        }
    
        /*///////////////////////////////////////////////////////////////
                            Setter functions
        //////////////////////////////////////////////////////////////*/
    
        /// @dev Lets a module admin set a max total supply for token.
        function setMaxTotalSupply(uint256 _tokenId, uint256 _maxTotalSupply) external onlyRole(DEFAULT_ADMIN_ROLE) {
            maxTotalSupply[_tokenId] = _maxTotalSupply;
        }
    
        /// @dev Lets a contract admin set the recipient for all primary sales.
        function setSaleRecipientForToken(uint256 _tokenId, address _saleRecipient) external onlyRole(DEFAULT_ADMIN_ROLE) {
            saleRecipient[_tokenId] = _saleRecipient;
        }
    
        /*//////////////////////////////////////////////////////////////
                            Internal (overrideable) functions
        //////////////////////////////////////////////////////////////*/
    
        /// @dev Runs before every `claim` function call.
        function _beforeClaim(
            uint256 _tokenId,
            address,
            uint256 _quantity,
            address,
            uint256,
            AllowlistProof calldata,
            bytes memory
        ) internal view override {
            require(maxTotalSupply[_tokenId] == 0 || totalSupply[_tokenId] + _quantity <= maxTotalSupply[_tokenId], "!Supply");
        }
    
        /// @dev Collects and distributes the primary sale value of NFTs being claimed.
        function collectPriceOnClaim(
            uint256 _tokenId,
            address _primarySaleRecipient,
            uint256 _quantityToClaim,
            address _currency,
            uint256 _pricePerToken
        ) internal override {
            address _saleRecipient = _primarySaleRecipient == address(0)
                ? (saleRecipient[_tokenId] == address(0) ? primarySaleRecipient() : saleRecipient[_tokenId])
                : _primarySaleRecipient;
            uint256 totalPrice = _pricePerToken > 0 ? _quantityToClaim * _pricePerToken : 0;
    
            if (_currency == CurrencyTransferLib.NATIVE_TOKEN) {
                require (msg.value == (totalPrice + transactionFee), "!ClaimPrice");
            }
    
            if (_pricePerToken > 0) {
                CurrencyTransferLib.transferCurrency(_currency, _msgSender(), _saleRecipient, totalPrice);
            }
            CurrencyTransferLib.transferCurrency(_currency, _msgSender(), platformAddress, transactionFee);
        }
    
        /// @dev Transfers the NFTs being claimed.
        function transferTokensOnClaim(
            address _to,
            uint256 _tokenId,
            uint256 _quantityBeingClaimed
        ) internal override {
            _mint(_to, _tokenId, _quantityBeingClaimed, "");
        }
    
        /// @dev Checks whether primary sale recipient can be set in the given execution context.
        function _canSetPrimarySaleRecipient() internal view override returns (bool) {
            return hasRole(DEFAULT_ADMIN_ROLE, _msgSender());
        }
    
        /// @dev Checks whether owner can be set in the given execution context.
        function _canSetOwner() internal view override returns (bool) {
            return hasRole(DEFAULT_ADMIN_ROLE, _msgSender());
        }
    
        /// @dev Checks whether royalty info can be set in the given execution context.
        function _canSetRoyaltyInfo() internal view override returns (bool) {
            return hasRole(DEFAULT_ADMIN_ROLE, _msgSender());
        }
    
        /// @dev Checks whether contract metadata can be set in the given execution context.
        function _canSetContractURI() internal view override returns (bool) {
            return hasRole(DEFAULT_ADMIN_ROLE, _msgSender());
        }
    
        /// @dev Checks whether platform fee info can be set in the given execution context.
        function _canSetClaimConditions() internal view override returns (bool) {
            return hasRole(DEFAULT_ADMIN_ROLE, _msgSender());
        }
    
        /// @dev Returns whether lazy minting can be done in the given execution context.
        function _canLazyMint() internal view virtual override returns (bool) {
            return hasRole(minterRole, _msgSender());
        }
    
        /*///////////////////////////////////////////////////////////////
                            Miscellaneous
        //////////////////////////////////////////////////////////////*/
    
        /// @dev The tokenId of the next NFT that will be minted / lazy minted.
        function nextTokenIdToMint() public view virtual override returns (uint256) {
            return nextTokenIdToLazyMint;
        }
    
        function _dropMsgSender() internal view virtual override returns (address) {
            return _msgSender();
        }
    
        function _msgSender() internal view virtual returns (address) {
            return msg.sender;
        }
    
        function _msgData() internal view virtual returns (bytes calldata) {
            return msg.data;
        }
    }

    Context size (optional):