@rarible/external-contracts 3.11.4

package/contracts/prebuilts/interface/airdrop/IAirdropERC20Claimable.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.11;
+
+/**
+ *  Thirdweb's `Airdrop` contracts provide a lightweight and easy to use mechanism
+ *  to drop tokens.
+ *
+ *  `AirdropERC20Claimable` contract is an airdrop contract for ERC20 tokens. It follows a
+ *  pull mechanism for transfer of tokens, where allowlisted recipients can claim tokens from
+ *  the contract.
+ */
+
+interface IAirdropERC20Claimable {
+    /// @dev Emitted when tokens are claimed.
+    event TokensClaimed(address indexed claimer, address indexed receiver, uint256 quantityClaimed);
+
+    /**
+     *  @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 proofs                         The proof of the claimer's inclusion in the merkle root allowlist
+     *                                        of the claim conditions that apply.
+     *  @param proofMaxQuantityForWallet      The maximum number of NFTs an address included in an
+     *                                        allowlist can claim.
+     */
+    function claim(
+        address receiver,
+        uint256 quantity,
+        bytes32[] calldata proofs,
+        uint256 proofMaxQuantityForWallet
+    ) external;
+}

package/contracts/prebuilts/interface/airdrop/IAirdropERC721.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.11;
+
+/**
+ *  Thirdweb's `Airdrop` contracts provide a lightweight and easy to use mechanism
+ *  to drop tokens.
+ *
+ *  `AirdropERC721` contract is an airdrop contract for ERC721 tokens. It follows a
+ *  push mechanism for transfer of tokens to intended recipients.
+ */
+
+interface IAirdropERC721 {
+    /// @notice Emitted when an airdrop fails for a recipient address.
+    event AirdropFailed(
+        address indexed tokenAddress,
+        address indexed tokenOwner,
+        address indexed recipient,
+        uint256 tokenId
+    );
+
+    /**
+     *  @notice Details of amount and recipient for airdropped token.
+     *
+     *  @param recipient The recipient of the tokens.
+     *  @param tokenId ID of the ERC721 token being airdropped.
+     */
+    struct AirdropContent {
+        address recipient;
+        uint256 tokenId;
+    }
+
+    /**
+     *  @notice          Lets contract-owner send ERC721 tokens to a list of addresses.
+     *  @dev             The token-owner should approve target tokens to Airdrop contract,
+     *                   which acts as operator for the tokens.
+     *
+     *  @param tokenAddress    The contract address of the tokens to transfer.
+     *  @param tokenOwner      The owner of the tokens to transfer.
+     *  @param contents        List containing recipient, tokenId to airdrop.
+     */
+    function airdropERC721(address tokenAddress, address tokenOwner, AirdropContent[] calldata contents) external;
+}

package/contracts/prebuilts/interface/airdrop/IAirdropERC721Claimable.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.11;
+
+/**
+ *  Thirdweb's `Airdrop` contracts provide a lightweight and easy to use mechanism
+ *  to drop tokens.
+ *
+ *  `AirdropERC721Claimable` contract is an airdrop contract for ERC721 tokens. It follows a
+ *  pull mechanism for transfer of tokens, where allowlisted recipients can claim tokens from
+ *  the contract.
+ */
+
+interface IAirdropERC721Claimable {
+    /// @dev Emitted when tokens are claimed.
+    event TokensClaimed(address indexed claimer, address indexed receiver, uint256 quantityClaimed);
+
+    /**
+     *  @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 proofs                         The proof of the claimer's inclusion in the merkle root allowlist
+     *                                        of the claim conditions that apply.
+     *  @param proofMaxQuantityForWallet      The maximum number of NFTs an address included in an
+     *                                        allowlist can claim.
+     */
+    function claim(
+        address receiver,
+        uint256 quantity,
+        bytes32[] calldata proofs,
+        uint256 proofMaxQuantityForWallet
+    ) external;
+}

package/contracts/prebuilts/interface/drop/IDropClaimCondition.sol

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts-upgradeable/utils/structs/BitMapsUpgradeable.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 IDropClaimCondition {
+    /**
+     *  @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 waitTimeInSecondsBetweenClaims The least number of seconds an account must wait after claiming
+     *                                        tokens, to be able to claim tokens again.
+     *
+     *  @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.
+     */
+    struct ClaimCondition {
+        uint256 startTimestamp;
+        uint256 maxClaimableSupply;
+        uint256 supplyClaimed;
+        uint256 quantityLimitPerWallet;
+        uint256 waitTimeInSecondsBetweenClaims;
+        bytes32 merkleRoot;
+        uint256 pricePerToken;
+        address currency;
+    }
+
+    /**
+     *  @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 phases                   The claim conditions at a given uid. Claim conditions
+     *                                  are ordered in an ascending order by their `startTimestamp`.
+     *
+     *  @param limitLastClaimTimestamp  Map from an account and uid for a claim condition, to the last timestamp
+     *                                  at which the account claimed tokens under that claim condition.
+     *
+     *  @param limitMerkleProofClaim    Map from a claim condition uid to whether an address in an allowlist
+     *                                  has already claimed tokens i.e. used their place in the allowlist.
+     *
+     *  @param supplyClaimedByWallet    Map from a claim condition uid and account to supply claimed by account.
+     */
+    struct ClaimConditionList {
+        uint256 currentStartId;
+        uint256 count;
+        mapping(uint256 => ClaimCondition) phases;
+        mapping(uint256 => mapping(address => uint256)) limitLastClaimTimestamp;
+        mapping(uint256 => BitMapsUpgradeable.BitMap) limitMerkleProofClaim;
+        mapping(uint256 => mapping(address => uint256)) supplyClaimedByWallet;
+    }
+}

package/contracts/prebuilts/interface/drop/IDropERC1155.sol

@@ -0,0 +1,92 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.11;
+
+import "@openzeppelin/contracts-upgradeable/token/ERC1155/IERC1155Upgradeable.sol";
+import "./IDropClaimCondition.sol";
+
+/**
+ *  Thirdweb's 'Drop' contracts are distribution mechanisms for tokens. The
+ *  `DropERC721` contract is a distribution mechanism for ERC721 tokens.
+ *
+ *  A minter wallet (i.e. holder of `MINTER_ROLE`) can (lazy)mint 'n' tokens
+ *  at once by providing a single base URI for all tokens being lazy minted.
+ *  The URI for each of the 'n' tokens lazy minted is the provided base URI +
+ *  `{tokenId}` of the respective token. (e.g. "ipsf://Qmece.../1").
+ *
+ *  A minter can choose to lazy mint 'delayed-reveal' tokens. More on 'delayed-reveal'
+ *  tokens in [this article](https://blog.thirdweb.com/delayed-reveal-nfts).
+ *
+ *  A contract admin (i.e. holder of `DEFAULT_ADMIN_ROLE`) can create claim conditions
+ *  with non-overlapping time windows, and accounts can claim the tokens according to
+ *  restrictions defined in the claim condition that is active at the time of the transaction.
+ */
+
+interface IDropERC1155 is IERC1155Upgradeable, IDropClaimCondition {
+    struct AllowlistProof {
+        bytes32[] proof;
+        uint256 maxQuantityInAllowlist;
+    }
+
+    /// @dev Emitted when tokens are claimed.
+    event TokensClaimed(
+        uint256 indexed claimConditionIndex,
+        uint256 indexed tokenId,
+        address indexed claimer,
+        address receiver,
+        uint256 quantityClaimed
+    );
+
+    /// @dev Emitted when tokens are lazy minted.
+    event TokensLazyMinted(uint256 startTokenId, uint256 endTokenId, string baseURI);
+
+    /// @dev Emitted when new claim conditions are set for a token.
+    event ClaimConditionsUpdated(uint256 indexed tokenId, ClaimCondition[] claimConditions);
+
+    /// @dev Emitted when the global max supply of a token is updated.
+    event MaxTotalSupplyUpdated(uint256 tokenId, uint256 maxTotalSupply);
+
+    /// @dev Emitted when the sale recipient for a particular tokenId is updated.
+    event SaleRecipientForTokenUpdated(uint256 indexed tokenId, address saleRecipient);
+
+    /**
+     *  @notice Lets an account with `MINTER_ROLE` lazy mint 'n' NFTs.
+     *          The URIs for each token is the provided `_baseURIForTokens` + `{tokenId}`.
+     *
+     *  @param amount           The amount of NFTs to lazy mint.
+     *  @param baseURIForTokens The URI for the NFTs to lazy mint.
+     */
+    function lazyMint(uint256 amount, string calldata baseURIForTokens) external;
+
+    /**
+     *  @notice Lets an account claim a given quantity of NFTs.
+     *
+     *  @param receiver                       The receiver of the NFT to claim.
+     *  @param tokenId                        The tokenId of the NFT to claim.
+     *  @param quantity                       The quantity of the NFT to claim.
+     *  @param currency                       The currency in which to pay for the claim.
+     *  @param pricePerToken                  The price per token to pay for the claim.
+     *  @param allowlistProof                 The proof of the claimer's inclusion in the merkle root allowlist
+     *                                        of the claim conditions that apply.
+     *  @param data                           Arbitrary bytes data that can be leveraged in the implementation of this interface.
+     */
+    function claim(
+        address receiver,
+        uint256 tokenId,
+        uint256 quantity,
+        address currency,
+        uint256 pricePerToken,
+        AllowlistProof calldata allowlistProof,
+        bytes memory data
+    ) external payable;
+
+    /**
+     *  @notice Lets a contract admin (account with `DEFAULT_ADMIN_ROLE`) set claim conditions.
+     *
+     *  @param tokenId               The token ID for which to set mint conditions.
+     *  @param phases                Claim conditions in ascending order by `startTimestamp`.
+     *  @param resetClaimEligibility Whether to reset `limitLastClaimTimestamp` and
+     *                               `limitMerkleProofClaim` values when setting new
+     *                               claim conditions.
+     */
+    function setClaimConditions(uint256 tokenId, ClaimCondition[] calldata phases, bool resetClaimEligibility) external;
+}

package/contracts/prebuilts/interface/drop/IDropERC20.sol

@@ -0,0 +1,68 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.11;
+
+import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
+import "./IDropClaimCondition.sol";
+
+/**
+ *  Thirdweb's 'Drop' contracts are distribution mechanisms for tokens. The
+ *  `DropERC20` contract is a distribution mechanism for ERC20 tokens.
+ *
+ *  A contract admin (i.e. holder of `DEFAULT_ADMIN_ROLE`) can create claim conditions
+ *  with non-overlapping time windows, and accounts can claim the tokens according to
+ *  restrictions defined in the claim condition that is active at the time of the transaction.
+ */
+
+interface IDropERC20 is IERC20Upgradeable, IDropClaimCondition {
+    struct AllowlistProof {
+        bytes32[] proof;
+        uint256 maxQuantityInAllowlist;
+    }
+
+    /// @dev Emitted when tokens are claimed.
+    event TokensClaimed(
+        uint256 indexed claimConditionIndex,
+        address indexed claimer,
+        address indexed receiver,
+        uint256 quantityClaimed
+    );
+
+    /// @dev Emitted when new claim conditions are set.
+    event ClaimConditionsUpdated(ClaimCondition[] claimConditions);
+
+    /// @dev Emitted when the global max supply of tokens is updated.
+    event MaxTotalSupplyUpdated(uint256 maxTotalSupply);
+
+    /// @dev Emitted when the contract URI is updated.
+    event ContractURIUpdated(string prevURI, string newURI);
+
+    /**
+     *  @notice Lets an account claim a given quantity of NFTs.
+     *
+     *  @param receiver                       The receiver of the tokens to claim.
+     *  @param quantity                       The quantity of tokens 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 reset `limitLastClaimTimestamp` and
+     *                               `limitMerkleProofClaim` values when setting new
+     *                               claim conditions.
+     */
+    function setClaimConditions(ClaimCondition[] calldata phases, bool resetClaimEligibility) external;
+}

package/contracts/prebuilts/interface/drop/IDropERC721.sol

@@ -0,0 +1,94 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.11;
+
+import "@openzeppelin/contracts-upgradeable/token/ERC721/IERC721Upgradeable.sol";
+import "./IDropClaimCondition.sol";
+
+/**
+ *  Thirdweb's 'Drop' contracts are distribution mechanisms for tokens. The
+ *  `DropERC721` contract is a distribution mechanism for ERC721 tokens.
+ *
+ *  A minter wallet (i.e. holder of `MINTER_ROLE`) can (lazy)mint 'n' tokens
+ *  at once by providing a single base URI for all tokens being lazy minted.
+ *  The URI for each of the 'n' tokens lazy minted is the provided base URI +
+ *  `{tokenId}` of the respective token. (e.g. "ipsf://Qmece.../1").
+ *
+ *  A minter can choose to lazy mint 'delayed-reveal' tokens. More on 'delayed-reveal'
+ *  tokens in [this article](https://blog.thirdweb.com/delayed-reveal-nfts).
+ *
+ *  A contract admin (i.e. holder of `DEFAULT_ADMIN_ROLE`) can create claim conditions
+ *  with non-overlapping time windows, and accounts can claim the tokens according to
+ *  restrictions defined in the claim condition that is active at the time of the transaction.
+ */
+
+interface IDropERC721 is IERC721Upgradeable, IDropClaimCondition {
+    struct AllowlistProof {
+        bytes32[] proof;
+        uint256 maxQuantityInAllowlist;
+    }
+
+    /// @dev Emitted when tokens are claimed.
+    event TokensClaimed(
+        uint256 indexed claimConditionIndex,
+        address indexed claimer,
+        address indexed receiver,
+        uint256 startTokenId,
+        uint256 quantityClaimed
+    );
+
+    /// @dev Emitted when tokens are lazy minted.
+    event TokensLazyMinted(uint256 startTokenId, uint256 endTokenId, string baseURI, bytes encryptedBaseURI);
+
+    /// @dev Emitted when the URI for a batch of 'delayed-reveal' NFTs is revealed.
+    event NFTRevealed(uint256 endTokenId, string revealedURI);
+
+    /// @dev Emitted when new claim conditions are set.
+    event ClaimConditionsUpdated(ClaimCondition[] claimConditions);
+
+    /// @dev Emitted when the global max supply of tokens is updated.
+    event MaxTotalSupplyUpdated(uint256 maxTotalSupply);
+
+    /**
+     *  @notice Lets an account with `MINTER_ROLE` lazy mint 'n' NFTs.
+     *          The URIs for each token is the provided `_baseURIForTokens` + `{tokenId}`.
+     *
+     *  @param amount           The amount of NFTs to lazy mint.
+     *  @param baseURIForTokens The URI for the NFTs to lazy mint. If lazy minting
+     *                           'delayed-reveal' NFTs, the is a URI for NFTs in the
+     *                           un-revealed state.
+     *  @param encryptedBaseURI If lazy minting 'delayed-reveal' NFTs, this is the
+     *                           result of encrypting the URI of the NFTs in the revealed
+     *                           state.
+     */
+    function lazyMint(uint256 amount, string calldata baseURIForTokens, bytes calldata encryptedBaseURI) external;
+
+    /**
+     *  @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 reset `limitLastClaimTimestamp` and
+     *                               `limitMerkleProofClaim` values when setting new
+     *                               claim conditions.
+     */
+    function setClaimConditions(ClaimCondition[] calldata phases, bool resetClaimEligibility) external;
+}