Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

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

import { Initializable } from "@openzeppelin/contracts/proxy/utils/Initializable.sol";
import { IERC1155 } from "@openzeppelin/contracts/token/ERC1155/IERC1155.sol";
import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import { IERC721 } from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

import { ICreatorCommands } from "../../interfaces/ICreatorCommands.sol";
import { SaleStrategy } from "../SaleStrategy.sol";
import { SaleCommandHelper } from "../utils/SaleCommandHelper.sol";

/// @title CreatorRedeemMinterStrategy
/// @notice A strategy that allows minting by redeeming other (ERC20/721/1155) tokens
contract CreatorRedeemMinterStrategy is SaleStrategy, Initializable {
    using SaleCommandHelper for ICreatorCommands.CommandSet;
    using SafeERC20 for IERC20;

    enum TokenType {
        NULL,
        ERC721,
        ERC1155,
        ERC20
    }

    struct MintToken {
        /// @notice The address of the minting token contract (always creatorContract)
        address tokenContract;
        /// @notice The mint tokenId
        uint256 tokenId;
        /// @notice The amount of tokens that can be minted
        uint256 amount;
        /// @notice The mint token type (alwas ERC1155)
        TokenType tokenType;
    }

    struct RedeemInstruction {
        /// @notice The type of token to be redeemed
        TokenType tokenType;
        /// @notice The amount of tokens to be redeemed
        uint256 amount;
        /// @notice The start of the range of token ids to be redeemed
        uint256 tokenIdStart;
        /// @notice The end of the range of token ids to be redeemed
        uint256 tokenIdEnd;
        /// @notice The address of the token contract to be redeemed
        address tokenContract;
        /// @notice The address to transfer the redeemed tokens to
        address transferRecipient;
        /// @notice The function to call on the token contract to burn the tokens
        bytes4 burnFunction;
    }

    struct RedeemInstructions {
        /// @notice The token to be minted
        MintToken mintToken;
        /// @notice The instructions for redeeming tokens
        RedeemInstruction[] instructions;
        /// @notice The start of the sale
        uint64 saleStart;
        /// @notice The end of the sale
        uint64 saleEnd;
        /// @notice The amount of ETH to send to the recipient
        uint256 ethAmount;
        /// @notice The address to send the ETH to (0x0 for the creator contract)
        address ethRecipient;
    }

    event RedeemSet(address indexed target, bytes32 indexed redeemsInstructionsHash, RedeemInstructions data);
    event RedeemProcessed(
        address indexed target,
        bytes32 indexed redeemsInstructionsHash,
        address sender,
        uint256[][] tokenIds,
        uint256[][] amounts
    );
    event RedeemsCleared(address indexed target, bytes32[] indexed redeemInstructionsHashes);

    error RedeemInstructionAlreadySet();
    error RedeemInstructionNotAllowed();
    error IncorrectNumberOfTokenIds();
    error InvalidTokenIdsForTokenType();
    error InvalidSaleEndOrStart();
    error EmptyRedeemInstructions();
    error MintTokenTypeMustBeERC1155();
    error MustBurnOrTransfer();
    error IncorrectMintAmount();
    error IncorrectBurnOrTransferAmount();
    error InvalidCreatorContract();
    error SaleEnded();
    error SaleHasNotStarted();
    error InvalidTokenType();
    error WrongValueSent();
    error CallerNotCreatorContract();
    error BurnFailed();
    error MustCallClearRedeem();
    error TokenIdOutOfRange();
    error MintTokenContractMustBeCreatorContract();
    error SenderIsNotTokenOwner();

    /// @notice tokenId, keccak256(abi.encode(RedeemInstructions)) => redeem instructions are allowed
    mapping(uint256 => mapping(bytes32 => bool)) public redeemInstructionsHashIsAllowed;

    /// @notice creator contract
    address public creatorContract;

    modifier onlyCreatorContract() {
        if (msg.sender != creatorContract) {
            revert CallerNotCreatorContract();
        }
        _;
    }

    function initialize(address _creatorContract) public initializer {
        if (_creatorContract == address(0)) {
            revert InvalidCreatorContract();
        }
        creatorContract = _creatorContract;
    }

    /// @notice Redeem Minter Strategy contract name
    function contractName() external pure override returns (string memory) {
        return "Redeem Minter Sale Strategy";
    }

    /// @notice Redeem Minter Strategy contract version
    function contractVersion() external pure override returns (string memory) {
        return "1";
    }

    /// @notice Redeem instructions object hash
    /// @param _redeemInstructions The redeem instructions object
    function redeemInstructionsHash(RedeemInstructions memory _redeemInstructions) public pure returns (bytes32) {
        return keccak256(abi.encode(_redeemInstructions));
    }

    function validateSingleRedeemInstruction(RedeemInstruction calldata _redeemInstruction) internal pure {
        if (_redeemInstruction.tokenType == TokenType.ERC20) {
            if (_redeemInstruction.tokenIdStart != 0 || _redeemInstruction.tokenIdEnd != 0) {
                revert InvalidTokenIdsForTokenType();
            }
        } else if (
            _redeemInstruction.tokenType == TokenType.ERC721 || _redeemInstruction.tokenType == TokenType.ERC1155
        ) {
            if (_redeemInstruction.tokenIdStart > _redeemInstruction.tokenIdEnd) {
                revert InvalidTokenIdsForTokenType();
            }
        } else {
            revert InvalidTokenType();
        }
        if (_redeemInstruction.burnFunction != 0 && _redeemInstruction.transferRecipient != address(0)) {
            revert MustBurnOrTransfer();
        }
        if (_redeemInstruction.burnFunction == 0 && _redeemInstruction.transferRecipient == address(0)) {
            revert MustBurnOrTransfer();
        }
        if (_redeemInstruction.amount == 0) {
            revert IncorrectMintAmount();
        }
    }

    /// @notice Validate redeem instructions
    /// @param _redeemInstructions The redeem instructions object
    function validateRedeemInstructions(RedeemInstructions calldata _redeemInstructions) public view {
        if (
            _redeemInstructions.saleEnd <= _redeemInstructions.saleStart
                || _redeemInstructions.saleEnd <= block.timestamp
        ) {
            revert InvalidSaleEndOrStart();
        }
        if (_redeemInstructions.instructions.length == 0) {
            revert EmptyRedeemInstructions();
        }
        if (_redeemInstructions.mintToken.tokenContract != creatorContract) {
            revert MintTokenContractMustBeCreatorContract();
        }
        if (_redeemInstructions.mintToken.tokenType != TokenType.ERC1155) {
            revert MintTokenTypeMustBeERC1155();
        }

        uint256 numInstructions = _redeemInstructions.instructions.length;

        unchecked {
            for (uint256 i; i < numInstructions; ++i) {
                validateSingleRedeemInstruction(_redeemInstructions.instructions[i]);
            }
        }
    }

    /// @notice Set redeem instructions
    /// @param tokenId The token id to set redeem instructions for
    /// @param _redeemInstructions The redeem instructions object
    function setRedeem(uint256 tokenId, RedeemInstructions calldata _redeemInstructions) external onlyCreatorContract {
        if (_redeemInstructions.mintToken.tokenId != tokenId) {
            revert InvalidTokenIdsForTokenType();
        }

        validateRedeemInstructions(_redeemInstructions);

        bytes32 hash = redeemInstructionsHash(_redeemInstructions);
        if (redeemInstructionsHashIsAllowed[tokenId][hash]) {
            revert RedeemInstructionAlreadySet();
        }
        redeemInstructionsHashIsAllowed[tokenId][hash] = true;

        emit RedeemSet(creatorContract, hash, _redeemInstructions);
    }

    /// @notice Clear redeem instructions
    /// @param tokenId The token id to clear redeem instructions for
    /// @param hashes Array of redeem instructions hashes to clear
    function clearRedeem(uint256 tokenId, bytes32[] calldata hashes) external onlyCreatorContract {
        uint256 numHashes = hashes.length;

        unchecked {
            for (uint256 i; i < numHashes; ++i) {
                redeemInstructionsHashIsAllowed[tokenId][hashes[i]] = false;
            }
        }

        emit RedeemsCleared(creatorContract, hashes);
    }

    /// @notice Request mint
    /// @param tokenId The token id to mint
    /// @param amount The amount to mint
    /// @param ethValueSent The amount of eth sent
    /// @param minterArguments The abi encoded minter arguments (address, RedeemInstructions, uint256[][], uint256[][])
    function requestMint(
        address sender,
        uint256 tokenId,
        uint256 amount,
        uint256 ethValueSent,
        bytes calldata minterArguments
    )
        external
        onlyCreatorContract
        returns (ICreatorCommands.CommandSet memory commands)
    {
        (RedeemInstructions memory redeemInstructions, uint256[][] memory tokenIds, uint256[][] memory amounts) = abi.decode(
            minterArguments,
            (RedeemInstructions, uint256[][], uint256[][])
        );
        bytes32 hash = redeemInstructionsHash(redeemInstructions);

        if (tokenId != redeemInstructions.mintToken.tokenId) {
            revert InvalidTokenIdsForTokenType();
        }
        if (!redeemInstructionsHashIsAllowed[tokenId][hash]) {
            revert RedeemInstructionNotAllowed();
        }
        if (redeemInstructions.saleStart > block.timestamp) {
            revert SaleHasNotStarted();
        }
        if (redeemInstructions.saleEnd < block.timestamp) {
            revert SaleEnded();
        }
        if (redeemInstructions.instructions.length != tokenIds.length) {
            revert IncorrectNumberOfTokenIds();
        }
        if (ethValueSent != redeemInstructions.ethAmount) {
            revert WrongValueSent();
        }
        if (amount != redeemInstructions.mintToken.amount) {
            revert IncorrectMintAmount();
        }

        uint256 numInstructions = redeemInstructions.instructions.length;

        unchecked {
            for (uint256 i; i < numInstructions; ++i) {
                RedeemInstruction memory instruction = redeemInstructions.instructions[i];
                if (instruction.tokenType == TokenType.ERC1155) {
                    _handleErc1155Redeem(sender, instruction, tokenIds[i], amounts[i]);
                } else if (instruction.tokenType == TokenType.ERC721) {
                    _handleErc721Redeem(sender, instruction, tokenIds[i]);
                } else if (instruction.tokenType == TokenType.ERC20) {
                    _handleErc20Redeem(sender, instruction);
                }
            }
        }

        bool shouldTransferFunds = redeemInstructions.ethRecipient != address(0);
        commands.setSize(shouldTransferFunds ? 2 : 1);
        commands.mint(sender, tokenId, amount);

        if (shouldTransferFunds) {
            commands.transfer(redeemInstructions.ethRecipient, ethValueSent);
        }

        emit RedeemProcessed(creatorContract, hash, sender, tokenIds, amounts);
    }

    function _handleErc721Redeem(
        address sender,
        RedeemInstruction memory instruction,
        uint256[] memory tokenIds
    )
        internal
    {
        uint256 numTokenIds = tokenIds.length;

        if (numTokenIds != instruction.amount) {
            revert IncorrectBurnOrTransferAmount();
        }

        unchecked {
            for (uint256 j; j < numTokenIds; j++) {
                if (tokenIds[j] < instruction.tokenIdStart || tokenIds[j] > instruction.tokenIdEnd) {
                    revert TokenIdOutOfRange();
                }
                if (instruction.burnFunction != 0) {
                    if (IERC721(instruction.tokenContract).ownerOf(tokenIds[j]) != sender) {
                        revert SenderIsNotTokenOwner();
                    }
                    (bool success,) =
                        instruction.tokenContract.call(abi.encodeWithSelector(instruction.burnFunction, tokenIds[j]));
                    if (!success) {
                        revert BurnFailed();
                    }
                } else {
                    IERC721(instruction.tokenContract).safeTransferFrom(
                        sender, instruction.transferRecipient, tokenIds[j]
                    );
                }
            }
        }
    }

    function _handleErc1155Redeem(
        address sender,
        RedeemInstruction memory instruction,
        uint256[] memory tokenIds,
        uint256[] memory amounts
    )
        internal
    {
        uint256 numTokenIds = tokenIds.length;

        if (amounts.length != numTokenIds) {
            revert IncorrectNumberOfTokenIds();
        }
        uint256 sum;
        for (uint256 j = 0; j < numTokenIds;) {
            sum += amounts[j];

            if (tokenIds[j] < instruction.tokenIdStart || tokenIds[j] > instruction.tokenIdEnd) {
                revert TokenIdOutOfRange();
            }

            unchecked {
                ++j;
            }
        }

        if (sum != instruction.amount) {
            revert IncorrectBurnOrTransferAmount();
        }
        if (instruction.burnFunction != 0) {
            (bool success,) = instruction.tokenContract.call(
                abi.encodeWithSelector(instruction.burnFunction, sender, tokenIds, amounts)
            );
            if (!success) {
                revert BurnFailed();
            }
        } else {
            IERC1155(instruction.tokenContract).safeBatchTransferFrom(
                sender, instruction.transferRecipient, tokenIds, amounts, ""
            );
        }
    }

    function _handleErc20Redeem(address sender, RedeemInstruction memory instruction) internal {
        if (instruction.burnFunction != 0) {
            (bool success,) = instruction.tokenContract.call(
                abi.encodeWithSelector(instruction.burnFunction, sender, instruction.amount)
            );
            if (!success) {
                revert BurnFailed();
            }
        } else {
            IERC20(instruction.tokenContract).transferFrom(sender, instruction.transferRecipient, instruction.amount);
        }
    }

    /// @notice Reset sale - Use clearRedeem instead
    function resetSale(uint256) external view override onlyCreatorContract {
        revert MustCallClearRedeem();
    }
}

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

pragma solidity ^0.8.2;

import "../../utils/Address.sol";

/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
 * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
 * case an upgrade adds a module that needs to be initialized.
 *
 * For example:
 *
 * [.hljs-theme-light.nopadding]
 * ```solidity
 * contract MyToken is ERC20Upgradeable {
 *     function initialize() initializer public {
 *         __ERC20_init("MyToken", "MTK");
 *     }
 * }
 *
 * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
 *     function initializeV2() reinitializer(2) public {
 *         __ERC20Permit_init("MyToken");
 *     }
 * }
 * ```
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
 * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() {
 *     _disableInitializers();
 * }
 * ```
 * ====
 */
abstract contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     * @custom:oz-retyped-from bool
     */
    uint8 private _initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;

    /**
     * @dev Triggered when the contract has been initialized or reinitialized.
     */
    event Initialized(uint8 version);

    /**
     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
     * `onlyInitializing` functions can be used to initialize parent contracts.
     *
     * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a
     * constructor.
     *
     * Emits an {Initialized} event.
     */
    modifier initializer() {
        bool isTopLevelCall = !_initializing;
        require(
            (isTopLevelCall && _initialized < 1) || (!Address.isContract(address(this)) && _initialized == 1),
            "Initializable: contract is already initialized"
        );
        _initialized = 1;
        if (isTopLevelCall) {
            _initializing = true;
        }
        _;
        if (isTopLevelCall) {
            _initializing = false;
            emit Initialized(1);
        }
    }

    /**
     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
     * used to initialize parent contracts.
     *
     * A reinitializer may be used after the original initialization step. This is essential to configure modules that
     * are added through upgrades and that require initialization.
     *
     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
     * cannot be nested. If one is invoked in the context of another, execution will revert.
     *
     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
     * a contract, executing them in the right order is up to the developer or operator.
     *
     * WARNING: setting the version to 255 will prevent any future reinitialization.
     *
     * Emits an {Initialized} event.
     */
    modifier reinitializer(uint8 version) {
        require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
        _initialized = version;
        _initializing = true;
        _;
        _initializing = false;
        emit Initialized(version);
    }

    /**
     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
     * {initializer} and {reinitializer} modifiers, directly or indirectly.
     */
    modifier onlyInitializing() {
        require(_initializing, "Initializable: contract is not initializing");
        _;
    }

    /**
     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called
     * through proxies.
     *
     * Emits an {Initialized} event the first time it is successfully executed.
     */
    function _disableInitializers() internal virtual {
        require(!_initializing, "Initializable: contract is initializing");
        if (_initialized != type(uint8).max) {
            _initialized = type(uint8).max;
            emit Initialized(type(uint8).max);
        }
    }

    /**
     * @dev Returns the highest version that has been initialized. See {reinitializer}.
     */
    function _getInitializedVersion() internal view returns (uint8) {
        return _initialized;
    }

    /**
     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
     */
    function _isInitializing() internal view returns (bool) {
        return _initializing;
    }
}

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

pragma solidity ^0.8.0;

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

/**
 * @dev Required interface of an ERC1155 compliant contract, as defined in the
 * https://eips.ethereum.org/EIPS/eip-1155[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155 is IERC165 {
    /**
     * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
     */
    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);

    /**
     * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
     * transfers.
     */
    event TransferBatch(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256[] ids,
        uint256[] values
    );

    /**
     * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
     * `approved`.
     */
    event ApprovalForAll(address indexed account, address indexed operator, bool approved);

    /**
     * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
     *
     * If an {URI} event was emitted for `id`, the standard
     * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
     * returned by {IERC1155MetadataURI-uri}.
     */
    event URI(string value, uint256 indexed id);

    /**
     * @dev Returns the amount of tokens of token type `id` owned by `account`.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) external view returns (uint256);

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(
        address[] calldata accounts,
        uint256[] calldata ids
    ) external view returns (uint256[] memory);

    /**
     * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the caller.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
     *
     * See {setApprovalForAll}.
     */
    function isApprovedForAll(address account, address operator) external view returns (bool);

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata amounts,
        bytes calldata data
    ) external;
}

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

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
}

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

pragma solidity ^0.8.0;

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

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.3) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";
import "../extensions/IERC20Permit.sol";
import "../../../utils/Address.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 Address for address;

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    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));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    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");
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
            _callOptionalReturn(token, approvalCall);
        }
    }

    /**
     * @dev Use a ERC-2612 signature to set the `owner` approval toward `spender` on `token`.
     * Revert on invalid signature.
     */
    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

    /**
     * @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");
        require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
    }

    /**
     * @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).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // 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 cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return
            success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
    }
}

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

/// @notice Creator Commands used by minter modules passed back to the main modules
interface ICreatorCommands {
    /// @notice This enum is used to define supported creator action types.
    /// This can change in the future
    enum CreatorActions
    // No operation - also the default for mintings that may not return a command
    {
        NO_OP,
        // Send ether
        SEND_ETH,
        // Mint operation
        MINT
    }

    /// @notice This command is for
    struct Command {
        // Method for operation
        CreatorActions method;
        // Arguments used for this operation
        bytes args;
    }

    /// @notice This command set is returned from the minter back to the user
    struct CommandSet {
        Command[] commands;
        uint256 at;
    }
}

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

import { IERC165Upgradeable } from "@openzeppelin/contracts-upgradeable/interfaces/IERC165Upgradeable.sol";
import { IMinter1155 } from "../interfaces/IMinter1155.sol";
import { IContractMetadata } from "../interfaces/IContractMetadata.sol";
import { IVersionedContract } from "../interfaces/IVersionedContract.sol";

/// @notice Sales Strategy Helper contract template on top of IMinter1155
abstract contract SaleStrategy is IMinter1155, IVersionedContract, IContractMetadata {
    /// @notice This function resets the sales configuration for a given tokenId and contract.
    /// @dev This function is intentioned to be called directly from the affected sales contract
    function resetSale(uint256 tokenId) external virtual;

    function supportsInterface(bytes4 interfaceId) public pure virtual returns (bool) {
        return interfaceId == type(IMinter1155).interfaceId || interfaceId == type(IERC165Upgradeable).interfaceId;
    }
}

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

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

/// @title SaleCommandHelper
/// @notice Helper library for creating commands for the sale contract
library SaleCommandHelper {
    /// @notice Sets the size of commands and initializes command array. Empty entries are skipped by the resolver.
    /// @dev Beware: this removes all previous command entries from memory
    /// @param commandSet command set struct storage.
    /// @param size size to set for the new struct
    function setSize(ICreatorCommands.CommandSet memory commandSet, uint256 size) internal pure {
        commandSet.commands = new ICreatorCommands.Command[](size);
    }

    /// @notice Creates a command to mint a token
    /// @param commandSet The command set to add the command to
    /// @param to The address to mint to
    /// @param tokenId The token ID to mint
    /// @param quantity The quantity of tokens to mint
    function mint(
        ICreatorCommands.CommandSet memory commandSet,
        address to,
        uint256 tokenId,
        uint256 quantity
    )
        internal
        pure
    {
        unchecked {
            commandSet.commands[commandSet.at++] = ICreatorCommands.Command({
                method: ICreatorCommands.CreatorActions.MINT,
                args: abi.encode(to, tokenId, quantity)
            });
        }
    }

    /// @notice Creates a command to transfer ETH
    /// @param commandSet The command set to add the command to
    /// @param to The address to transfer to
    /// @param amount The amount of ETH to transfer
    function transfer(ICreatorCommands.CommandSet memory commandSet, address to, uint256 amount) internal pure {
        unchecked {
            commandSet.commands[commandSet.at++] = ICreatorCommands.Command({
                method: ICreatorCommands.CreatorActions.SEND_ETH,
                args: abi.encode(to, amount)
            });
        }
    }
}

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

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @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
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [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.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] 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://consensys.net/diligence/blog/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.8.0/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 functionCallWithValue(target, data, 0, "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");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or 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 {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

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

pragma solidity ^0.8.0;

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

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

pragma solidity ^0.8.0;

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

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

import { IERC165Upgradeable } from "@openzeppelin/contracts-upgradeable/interfaces/IERC165Upgradeable.sol";
import { ICreatorCommands } from "./ICreatorCommands.sol";

/// @notice Minter standard interface
/// @dev Minters need to confirm to the ERC165 selector of type(IMinter1155).interfaceId
interface IMinter1155 is IERC165Upgradeable {
    function requestMint(
        address sender,
        uint256 tokenId,
        uint256 quantity,
        uint256 ethValueSent,
        bytes calldata minterArguments
    )
        external
        returns (ICreatorCommands.CommandSet memory commands);
}

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

interface IContractMetadata {
    /// @notice Contract name returns the pretty contract name
    function contractName() external returns (string memory);
}

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

interface IVersionedContract {
    function contractVersion() external returns (string memory);
}

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

pragma solidity ^0.8.0;

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

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"name":"BurnFailed","type":"error"},{"inputs":[],"name":"CallerNotCreatorContract","type":"error"},{"inputs":[],"name":"EmptyRedeemInstructions","type":"error"},{"inputs":[],"name":"IncorrectBurnOrTransferAmount","type":"error"},{"inputs":[],"name":"IncorrectMintAmount","type":"error"},{"inputs":[],"name":"IncorrectNumberOfTokenIds","type":"error"},{"inputs":[],"name":"InvalidCreatorContract","type":"error"},{"inputs":[],"name":"InvalidSaleEndOrStart","type":"error"},{"inputs":[],"name":"InvalidTokenIdsForTokenType","type":"error"},{"inputs":[],"name":"InvalidTokenType","type":"error"},{"inputs":[],"name":"MintTokenContractMustBeCreatorContract","type":"error"},{"inputs":[],"name":"MintTokenTypeMustBeERC1155","type":"error"},{"inputs":[],"name":"MustBurnOrTransfer","type":"error"},{"inputs":[],"name":"MustCallClearRedeem","type":"error"},{"inputs":[],"name":"RedeemInstructionAlreadySet","type":"error"},{"inputs":[],"name":"RedeemInstructionNotAllowed","type":"error"},{"inputs":[],"name":"SaleEnded","type":"error"},{"inputs":[],"name":"SaleHasNotStarted","type":"error"},{"inputs":[],"name":"SenderIsNotTokenOwner","type":"error"},{"inputs":[],"name":"TokenIdOutOfRange","type":"error"},{"inputs":[],"name":"WrongValueSent","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"target","type":"address"},{"indexed":true,"internalType":"bytes32","name":"redeemsInstructionsHash","type":"bytes32"},{"indexed":false,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256[][]","name":"tokenIds","type":"uint256[][]"},{"indexed":false,"internalType":"uint256[][]","name":"amounts","type":"uint256[][]"}],"name":"RedeemProcessed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"target","type":"address"},{"indexed":true,"internalType":"bytes32","name":"redeemsInstructionsHash","type":"bytes32"},{"components":[{"components":[{"internalType":"address","name":"tokenContract","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"enum CreatorRedeemMinterStrategy.TokenType","name":"tokenType","type":"uint8"}],"internalType":"struct CreatorRedeemMinterStrategy.MintToken","name":"mintToken","type":"tuple"},{"components":[{"internalType":"enum CreatorRedeemMinterStrategy.TokenType","name":"tokenType","type":"uint8"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"tokenIdStart","type":"uint256"},{"internalType":"uint256","name":"tokenIdEnd","type":"uint256"},{"internalType":"address","name":"tokenContract","type":"address"},{"internalType":"address","name":"transferRecipient","type":"address"},{"internalType":"bytes4","name":"burnFunction","type":"bytes4"}],"internalType":"struct CreatorRedeemMinterStrategy.RedeemInstruction[]","name":"instructions","type":"tuple[]"},{"internalType":"uint64","name":"saleStart","type":"uint64"},{"internalType":"uint64","name":"saleEnd","type":"uint64"},{"internalType":"uint256","name":"ethAmount","type":"uint256"},{"internalType":"address","name":"ethRecipient","type":"address"}],"indexed":false,"internalType":"struct CreatorRedeemMinterStrategy.RedeemInstructions","name":"data","type":"tuple"}],"name":"RedeemSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"target","type":"address"},{"indexed":true,"internalType":"bytes32[]","name":"redeemInstructionsHashes","type":"bytes32[]"}],"name":"RedeemsCleared","type":"event"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes32[]","name":"hashes","type":"bytes32[]"}],"name":"clearRedeem","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"contractName","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"contractVersion","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"creatorContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_creatorContract","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"components":[{"internalType":"address","name":"tokenContract","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"enum CreatorRedeemMinterStrategy.TokenType","name":"tokenType","type":"uint8"}],"internalType":"struct CreatorRedeemMinterStrategy.MintToken","name":"mintToken","type":"tuple"},{"components":[{"internalType":"enum CreatorRedeemMinterStrategy.TokenType","name":"tokenType","type":"uint8"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"tokenIdStart","type":"uint256"},{"internalType":"uint256","name":"tokenIdEnd","type":"uint256"},{"internalType":"address","name":"tokenContract","type":"address"},{"internalType":"address","name":"transferRecipient","type":"address"},{"internalType":"bytes4","name":"burnFunction","type":"bytes4"}],"internalType":"struct CreatorRedeemMinterStrategy.RedeemInstruction[]","name":"instructions","type":"tuple[]"},{"internalType":"uint64","name":"saleStart","type":"uint64"},{"internalType":"uint64","name":"saleEnd","type":"uint64"},{"internalType":"uint256","name":"ethAmount","type":"uint256"},{"internalType":"address","name":"ethRecipient","type":"address"}],"internalType":"struct CreatorRedeemMinterStrategy.RedeemInstructions","name":"_redeemInstructions","type":"tuple"}],"name":"redeemInstructionsHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"redeemInstructionsHashIsAllowed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"ethValueSent","type":"uint256"},{"internalType":"bytes","name":"minterArguments","type":"bytes"}],"name":"requestMint","outputs":[{"components":[{"components":[{"internalType":"enum ICreatorCommands.CreatorActions","name":"method","type":"uint8"},{"internalType":"bytes","name":"args","type":"bytes"}],"internalType":"struct ICreatorCommands.Command[]","name":"commands","type":"tuple[]"},{"internalType":"uint256","name":"at","type":"uint256"}],"internalType":"struct ICreatorCommands.CommandSet","name":"commands","type":"tuple"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"resetSale","outputs":[],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"components":[{"components":[{"internalType":"address","name":"tokenContract","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"enum CreatorRedeemMinterStrategy.TokenType","name":"tokenType","type":"uint8"}],"internalType":"struct CreatorRedeemMinterStrategy.MintToken","name":"mintToken","type":"tuple"},{"components":[{"internalType":"enum CreatorRedeemMinterStrategy.TokenType","name":"tokenType","type":"uint8"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"tokenIdStart","type":"uint256"},{"internalType":"uint256","name":"tokenIdEnd","type":"uint256"},{"internalType":"address","name":"tokenContract","type":"address"},{"internalType":"address","name":"transferRecipient","type":"address"},{"internalType":"bytes4","name":"burnFunction","type":"bytes4"}],"internalType":"struct CreatorRedeemMinterStrategy.RedeemInstruction[]","name":"instructions","type":"tuple[]"},{"internalType":"uint64","name":"saleStart","type":"uint64"},{"internalType":"uint64","name":"saleEnd","type":"uint64"},{"internalType":"uint256","name":"ethAmount","type":"uint256"},{"internalType":"address","name":"ethRecipient","type":"address"}],"internalType":"struct CreatorRedeemMinterStrategy.RedeemInstructions","name":"_redeemInstructions","type":"tuple"}],"name":"setRedeem","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[{"components":[{"components":[{"internalType":"address","name":"tokenContract","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"enum CreatorRedeemMinterStrategy.TokenType","name":"tokenType","type":"uint8"}],"internalType":"struct CreatorRedeemMinterStrategy.MintToken","name":"mintToken","type":"tuple"},{"components":[{"internalType":"enum CreatorRedeemMinterStrategy.TokenType","name":"tokenType","type":"uint8"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"tokenIdStart","type":"uint256"},{"internalType":"uint256","name":"tokenIdEnd","type":"uint256"},{"internalType":"address","name":"tokenContract","type":"address"},{"internalType":"address","name":"transferRecipient","type":"address"},{"internalType":"bytes4","name":"burnFunction","type":"bytes4"}],"internalType":"struct CreatorRedeemMinterStrategy.RedeemInstruction[]","name":"instructions","type":"tuple[]"},{"internalType":"uint64","name":"saleStart","type":"uint64"},{"internalType":"uint64","name":"saleEnd","type":"uint64"},{"internalType":"uint256","name":"ethAmount","type":"uint256"},{"internalType":"address","name":"ethRecipient","type":"address"}],"internalType":"struct CreatorRedeemMinterStrategy.RedeemInstructions","name":"_redeemInstructions","type":"tuple"}],"name":"validateRedeemInstructions","outputs":[],"stateMutability":"view","type":"function"}]

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