@rarible/external-contracts 3.11.4

package/contracts/extension/interface/IAccountPermissions.sol

@@ -0,0 +1,114 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+interface IAccountPermissions {
+    /*///////////////////////////////////////////////////////////////
+                                Types
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     *  @notice The payload that must be signed by an authorized wallet to set permissions for a signer to use the smart wallet.
+     *
+     *  @param signer The addres of the signer to give permissions.
+     *  @param approvedTargets The list of approved targets that a role holder can call using the smart wallet.
+     *  @param nativeTokenLimitPerTransaction The maximum value that can be transferred by a role holder in a single transaction.
+     *  @param permissionStartTimestamp The UNIX timestamp at and after which a signer has permission to use the smart wallet.
+     *  @param permissionEndTimestamp The UNIX timestamp at and after which a signer no longer has permission to use the smart wallet.
+     *  @param reqValidityStartTimestamp The UNIX timestamp at and after which a signature is valid.
+     *  @param reqValidityEndTimestamp The UNIX timestamp at and after which a signature is invalid/expired.
+     *  @param uid A unique non-repeatable ID for the payload.
+     *  @param isAdmin Whether the signer should be an admin.
+     */
+    struct SignerPermissionRequest {
+        address signer;
+        uint8 isAdmin;
+        address[] approvedTargets;
+        uint256 nativeTokenLimitPerTransaction;
+        uint128 permissionStartTimestamp;
+        uint128 permissionEndTimestamp;
+        uint128 reqValidityStartTimestamp;
+        uint128 reqValidityEndTimestamp;
+        bytes32 uid;
+    }
+
+    /**
+     *  @notice The permissions that a signer has to use the smart wallet.
+     *
+     *  @param signer The address of the signer.
+     *  @param approvedTargets The list of approved targets that a role holder can call using the smart wallet.
+     *  @param nativeTokenLimitPerTransaction The maximum value that can be transferred by a role holder in a single transaction.
+     *  @param startTimestamp The UNIX timestamp at and after which a signer has permission to use the smart wallet.
+     *  @param endTimestamp The UNIX timestamp at and after which a signer no longer has permission to use the smart wallet.
+     */
+    struct SignerPermissions {
+        address signer;
+        address[] approvedTargets;
+        uint256 nativeTokenLimitPerTransaction;
+        uint128 startTimestamp;
+        uint128 endTimestamp;
+    }
+
+    /**
+     *  @notice Internal struct for storing permissions for a signer (without approved targets).
+     *
+     *  @param nativeTokenLimitPerTransaction The maximum value that can be transferred by a role holder in a single transaction.
+     *  @param startTimestamp The UNIX timestamp at and after which a signer has permission to use the smart wallet.
+     *  @param endTimestamp The UNIX timestamp at and after which a signer no longer has permission to use the smart wallet.
+     */
+    struct SignerPermissionsStatic {
+        uint256 nativeTokenLimitPerTransaction;
+        uint128 startTimestamp;
+        uint128 endTimestamp;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                                Events
+    //////////////////////////////////////////////////////////////*/
+
+    /// @notice Emitted when permissions for a signer are updated.
+    event SignerPermissionsUpdated(
+        address indexed authorizingSigner,
+        address indexed targetSigner,
+        SignerPermissionRequest permissions
+    );
+
+    /// @notice Emitted when an admin is set or removed.
+    event AdminUpdated(address indexed signer, bool isAdmin);
+
+    /*///////////////////////////////////////////////////////////////
+                            View functions
+    //////////////////////////////////////////////////////////////*/
+
+    /// @notice Returns whether the given account is an admin.
+    function isAdmin(address signer) external view returns (bool);
+
+    /// @notice Returns whether the given account is an active signer on the account.
+    function isActiveSigner(address signer) external view returns (bool);
+
+    /// @notice Returns the restrictions under which a signer can use the smart wallet.
+    function getPermissionsForSigner(address signer) external view returns (SignerPermissions memory permissions);
+
+    /// @notice Returns all active and inactive signers of the account.
+    function getAllSigners() external view returns (SignerPermissions[] memory signers);
+
+    /// @notice Returns all signers with active permissions to use the account.
+    function getAllActiveSigners() external view returns (SignerPermissions[] memory signers);
+
+    /// @notice Returns all admins of the account.
+    function getAllAdmins() external view returns (address[] memory admins);
+
+    /// @dev Verifies that a request is signed by an authorized account.
+    function verifySignerPermissionRequest(
+        SignerPermissionRequest calldata req,
+        bytes calldata signature
+    ) external view returns (bool success, address signer);
+
+    /*///////////////////////////////////////////////////////////////
+                            External functions
+    //////////////////////////////////////////////////////////////*/
+
+    /// @notice Sets the permissions for a given signer.
+    function setPermissionsForSigner(SignerPermissionRequest calldata req, bytes calldata signature) external;
+}

package/contracts/extension/interface/IAppURI.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+/**
+ *  Thirdweb's `AppURI` is a contract extension for any base contracts. It lets you set a metadata URI
+ *  for you contract.
+ *
+ */
+
+interface IAppURI {
+    /// @dev Returns the metadata URI of the contract.
+    function appURI() 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 setAppURI(string calldata _uri) external;
+
+    /// @dev Emitted when the contract URI is updated.
+    event AppURIUpdated(string prevURI, string newURI);
+}

package/contracts/extension/interface/IBurnToClaim.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+interface IBurnToClaim {
+    /// @notice The type of assets that can be burned.
+    enum TokenType {
+        ERC721,
+        ERC1155
+    }
+
+    /**
+     *  @notice Configuration for burning tokens to claim new tokens.
+     *
+     *  @param originContractAddress The address of the contract that the tokens are burned from.
+     *  @param tokenType The type of token to burn.
+     *  @param tokenId The token ID of the token to burn. Only used if tokenType is ERC1155.
+     *  @param mintPriceForNewToken The price to mint a new token.
+     *  @param currency The currency to pay the mint price in.
+     */
+    struct BurnToClaimInfo {
+        address originContractAddress;
+        TokenType tokenType;
+        uint256 tokenId; // used only if tokenType is ERC1155
+        uint256 mintPriceForNewToken;
+        address currency;
+    }
+
+    /// @notice Emitted when tokens are burned to claim new tokens
+    event TokensBurnedAndClaimed(
+        address indexed originContract,
+        address indexed tokenOwner,
+        uint256 indexed burnTokenId,
+        uint256 quantity
+    );
+
+    /**
+     *  @notice Sets the configuration for burning tokens to claim new tokens.
+     *  @param burnToClaimInfo The configuration for burning tokens to claim new tokens.
+     */
+    function setBurnToClaimInfo(BurnToClaimInfo calldata burnToClaimInfo) external;
+}

package/contracts/extension/interface/IBurnableERC1155.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+/**
+ *  `SignatureMint1155` is an ERC 1155 contract. It lets anyone mint NFTs by producing a mint request
+ *  and a signature (produced by an account with MINTER_ROLE, signing the mint request).
+ */
+interface IBurnableERC1155 {
+    /// @dev Lets a token owner burn the tokens they own (i.e. destroy for good)
+    function burn(address account, uint256 id, uint256 value) external;
+
+    /// @dev Lets a token owner burn multiple tokens they own at once (i.e. destroy for good)
+    function burnBatch(address account, uint256[] memory ids, uint256[] memory values) external;
+}

package/contracts/extension/interface/IBurnableERC20.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+interface IBurnableERC20 {
+    /**
+     * @dev Destroys `amount` tokens from the caller.
+     *
+     * See {ERC20-_burn}.
+     */
+    function burn(uint256 amount) external;
+
+    /**
+     * @dev Destroys `amount` tokens from `account`, deducting from the caller's
+     * allowance.
+     *
+     * See {ERC20-_burn} and {ERC20-allowance}.
+     *
+     * Requirements:
+     *
+     * - the caller must have allowance for ``accounts``'s tokens of at least
+     * `amount`.
+     */
+    function burnFrom(address account, uint256 amount) external;
+}

package/contracts/extension/interface/IBurnableERC721.sol

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+interface IBurnableERC721 {
+    /**
+     * @dev Burns `tokenId`. See {ERC721-_burn}.
+     *
+     * Requirements:
+     *
+     * - The caller must own `tokenId` or be an approved operator.
+     */
+    function burn(uint256 tokenId) external;
+}

package/contracts/extension/interface/IClaimCondition.sol

@@ -0,0 +1,48 @@
+// 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;
+    }
+}

package/contracts/extension/interface/IClaimConditionMultiPhase.sol

@@ -0,0 +1,39 @@
+// 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;
+    }
+}

package/contracts/extension/interface/IClaimConditionsSinglePhase.sol

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import "../../lib/BitMaps.sol";
+import "./IClaimCondition.sol";
+
+/**
+ *  Thirdweb's 'Drop' contracts are distribution mechanisms for tokens.
+ *
+ *  A contract admin (i.e. a holder of `DEFAULT_ADMIN_ROLE`) 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 IClaimConditionsSinglePhase is IClaimCondition {
+    event ClaimConditionUpdated(ClaimCondition claimConditions, bool resetClaimEligibility);
+
+    /**
+     *  @notice Lets a contract admin (account with `DEFAULT_ADMIN_ROLE`) set claim conditions.
+     *
+     *  @param phase                   Claim conditions in ascending order by `startTimestamp`.
+     *
+     *  @param resetClaimEligibility    Whether to reset `limitLastClaimTimestamp` and `limitMerkleProofClaim` values when setting new
+     *                                  claim conditions.
+     *
+     */
+    function setClaimConditions(ClaimCondition calldata phase, bool resetClaimEligibility) external;
+}

package/contracts/extension/interface/IClaimableERC1155.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+interface IClaimableERC1155 {
+    /// @dev Emitted when tokens are claimed
+    event TokensClaimed(
+        address indexed claimer,
+        address indexed receiver,
+        uint256 indexed tokenId,
+        uint256 quantityClaimed
+    );
+
+    /**
+     *  @notice          Lets an address claim multiple lazy minted NFTs at once to a recipient.
+     *                   Contract creators should override this function to create custom logic for claiming,
+     *                   for e.g. price collection, allowlist, max quantity, etc.
+     *
+     *  @dev             The logic in the `verifyClaim` function determines whether the caller is authorized to mint NFTs.
+     *
+     *  @param _receiver  The recipient of the tokens to mint.
+     *  @param _tokenId   The tokenId of the lazy minted NFT to mint.
+     *  @param _quantity  The number of tokens to mint.
+     */
+    function claim(address _receiver, uint256 _tokenId, uint256 _quantity) external payable;
+
+    /**
+     *  @notice          Override this function to add logic for claim verification, based on conditions
+     *                   such as allowlist, price, max quantity etc.
+     *
+     *  @dev             Checks a request to claim NFTs against a custom condition.
+     *
+     *  @param _claimer   Caller of the claim function.
+     *  @param _tokenId   The tokenId of the lazy minted NFT to mint.
+     *  @param _quantity  The number of NFTs being claimed.
+     */
+    function verifyClaim(address _claimer, uint256 _tokenId, uint256 _quantity) external view;
+}

package/contracts/extension/interface/IClaimableERC721.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+interface IClaimableERC721 {
+    /// @dev Emitted when tokens are claimed
+    event TokensClaimed(
+        address indexed claimer,
+        address indexed receiver,
+        uint256 indexed startTokenId,
+        uint256 quantityClaimed
+    );
+
+    /**
+     *  @notice          Lets an address claim multiple lazy minted NFTs at once to a recipient.
+     *                   Contract creators should override this function to create custom logic for claiming,
+     *                   for e.g. price collection, allowlist, max quantity, etc.
+     *
+     *  @dev             The logic in the `verifyClaim` function determines whether the caller is authorized to mint NFTs.
+     *
+     *  @param _receiver  The recipient of the NFT to mint.
+     *  @param _quantity  The number of NFTs to mint.
+     */
+    function claim(address _receiver, uint256 _quantity) external payable;
+
+    /**
+     *  @notice          Override this function to add logic for claim verification, based on conditions
+     *                   such as allowlist, price, max quantity etc.
+     *
+     *  @dev             Checks a request to claim NFTs against a custom condition.
+     *
+     *  @param _claimer   Caller of the claim function.
+     *  @param _quantity  The number of NFTs being claimed.
+     */
+    function verifyClaim(address _claimer, uint256 _quantity) external view;
+}

package/contracts/extension/interface/IContractFactory.sol

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+interface IContractFactory {
+    /**
+     *  @notice Deploys a proxy that points to that points to the given implementation.
+     *
+     *  @param implementation           Address of the implementation to point to.
+     *
+     *  @param data                     Additional data to pass to the proxy constructor or any other data useful during deployement.
+     *  @param salt                     Salt to use for the deterministic address generation.
+     */
+    function deployProxyByImplementation(
+        address implementation,
+        bytes memory data,
+        bytes32 salt
+    ) external returns (address);
+}

package/contracts/extension/interface/IContractMetadata.sol

@@ -0,0 +1,25 @@
+// 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);
+}

package/contracts/extension/interface/IDelayedReveal.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+/**
+ *  Thirdweb's `DelayedReveal` is a contract extension for base NFT contracts. It lets you create batches of
+ *  'delayed-reveal' NFTs. You can learn more about the usage of delayed reveal NFTs here - https://blog.thirdweb.com/delayed-reveal-nfts
+ */
+
+interface IDelayedReveal {
+    /// @dev Emitted when tokens are revealed.
+    event TokenURIRevealed(uint256 indexed index, string revealedURI);
+
+    /**
+     *  @notice Reveals a batch of delayed reveal NFTs.
+     *
+     *  @param identifier The ID for the batch of delayed-reveal NFTs to reveal.
+     *
+     *  @param key        The key with which the base URI for the relevant batch of NFTs was encrypted.
+     */
+    function reveal(uint256 identifier, bytes calldata key) external returns (string memory revealedURI);
+
+    /**
+     *  @notice Performs XOR encryption/decryption.
+     *
+     *  @param data The data to encrypt. In the case of delayed-reveal NFTs, this is the "revealed" state
+     *              base URI of the relevant batch of NFTs.
+     *
+     *  @param key  The key with which to encrypt data
+     */
+    function encryptDecrypt(bytes memory data, bytes calldata key) external pure returns (bytes memory result);
+}

package/contracts/extension/interface/IDelayedRevealDeprecated.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+// [ DEPRECATED CONTRACT: use `contracts/extension/interface/IDelayedReveal.sol` instead ]
+
+/**
+ *  Thirdweb's `DelayedReveal` is a contract extension for base NFT contracts. It lets you create batches of
+ *  'delayed-reveal' NFTs. You can learn more about the usage of delayed reveal NFTs here - https://blog.thirdweb.com/delayed-reveal-nfts
+ */
+
+interface IDelayedRevealDeprecated {
+    /// @dev Emitted when tokens are revealed.
+    event TokenURIRevealed(uint256 indexed index, string revealedURI);
+
+    /// @dev Returns the encrypted base URI associated with the given identifier.
+    function encryptedBaseURI(uint256 identifier) external view returns (bytes memory);
+
+    /**
+     *  @notice Reveals a batch of delayed reveal NFTs.
+     *
+     *  @param identifier The ID for the batch of delayed-reveal NFTs to reveal.
+     *
+     *  @param key        The key with which the base URI for the relevant batch of NFTs was encrypted.
+     */
+    function reveal(uint256 identifier, bytes calldata key) external returns (string memory revealedURI);
+
+    /**
+     *  @notice Performs XOR encryption/decryption.
+     *
+     *  @param data The data to encrypt. In the case of delayed-reveal NFTs, this is the "revealed" state
+     *              base URI of the relevant batch of NFTs.
+     *
+     *  @param key  The key with which to encrypt data
+     */
+    function encryptDecrypt(bytes memory data, bytes calldata key) external pure returns (bytes memory result);
+}

package/contracts/extension/interface/IDrop.sol

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import "./IClaimConditionMultiPhase.sol";
+
+/**
+ *  The interface `IDrop` 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 IDrop 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 via `claim`.
+    event TokensClaimed(
+        uint256 indexed claimConditionIndex,
+        address indexed claimer,
+        address indexed receiver,
+        uint256 startTokenId,
+        uint256 quantityClaimed
+    );
+
+    /// @notice Emitted when the contract's claim conditions are updated.
+    event ClaimConditionsUpdated(ClaimCondition[] claimConditions, bool resetEligibility);
+
+    /**
+     *  @notice Lets an account claim a given quantity of NFTs.
+     *
+     *  @param receiver                       The receiver of the NFTs 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 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 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(ClaimCondition[] calldata phases, bool resetClaimEligibility) external;
+}