@rarible/external-contracts 3.11.4

package/contracts/prebuilts/evolving-nfts/EvolvingNFTLogic.sol

@@ -0,0 +1,251 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.11;
+
+/// @author thirdweb
+
+//   $$\     $$\       $$\                 $$\                         $$\
+//   $$ |    $$ |      \__|                $$ |                        $$ |
+// $$$$$$\   $$$$$$$\  $$\  $$$$$$\   $$$$$$$ |$$\  $$\  $$\  $$$$$$\  $$$$$$$\
+// \_$$  _|  $$  __$$\ $$ |$$  __$$\ $$  __$$ |$$ | $$ | $$ |$$  __$$\ $$  __$$\
+//   $$ |    $$ |  $$ |$$ |$$ |  \__|$$ /  $$ |$$ | $$ | $$ |$$$$$$$$ |$$ |  $$ |
+//   $$ |$$\ $$ |  $$ |$$ |$$ |      $$ |  $$ |$$ | $$ | $$ |$$   ____|$$ |  $$ |
+//   \$$$$  |$$ |  $$ |$$ |$$ |      \$$$$$$$ |\$$$$$\$$$$  |\$$$$$$$\ $$$$$$$  |
+//    \____/ \__|  \__|\__|\__|       \_______| \_____\____/  \_______|\_______/
+
+//  ==========  External imports    ==========
+
+import "@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol";
+
+import "../../eip/queryable/ERC721AQueryableUpgradeable.sol";
+
+//  ==========  Internal imports    ==========
+
+import "../../external-deps/openzeppelin/metatx/ERC2771ContextUpgradeable.sol";
+import { CurrencyTransferLib } from "../../lib/CurrencyTransferLib.sol";
+
+//  ==========  Features    ==========
+
+import "../../extension/Multicall.sol";
+import "../../extension/upgradeable/ContractMetadata.sol";
+import "../../extension/upgradeable/Royalty.sol";
+import "../../extension/upgradeable/PrimarySale.sol";
+import "../../extension/upgradeable/Ownable.sol";
+import "../../extension/upgradeable/Permissions.sol";
+import "../../extension/upgradeable/Drop.sol";
+import "../../extension/upgradeable/SharedMetadataBatch.sol";
+import { RulesEngine } from "../../extension/upgradeable/RulesEngine.sol";
+
+contract EvolvingNFTLogic is
+    ContractMetadata,
+    Royalty,
+    PrimarySale,
+    Ownable,
+    SharedMetadataBatch,
+    Drop,
+    ERC2771ContextUpgradeable,
+    ERC721AQueryableUpgradeable
+{
+    using StringsUpgradeable for uint256;
+    using EnumerableSet for EnumerableSet.Bytes32Set;
+
+    /*///////////////////////////////////////////////////////////////
+                            State variables
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev Default admin role for all roles. Only accounts with this role can grant/revoke other roles.
+    bytes32 private constant DEFAULT_ADMIN_ROLE = 0x00;
+    /// @dev Only TRANSFER_ROLE holders can have tokens transferred from or to them, during restricted transfers.
+    bytes32 private constant TRANSFER_ROLE = keccak256("TRANSFER_ROLE");
+    /// @dev Only MINTER_ROLE holders can sign off on `MintRequest`s.
+    bytes32 private constant MINTER_ROLE = keccak256("MINTER_ROLE");
+
+    /*///////////////////////////////////////////////////////////////
+                        ERC 165 / 721 / 2981 logic
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev Returns the URI for a given tokenId.
+    function tokenURI(
+        uint256 _tokenId
+    ) public view virtual override(ERC721AUpgradeable, IERC721AUpgradeable) returns (string memory) {
+        if (!_exists(_tokenId)) {
+            revert("!ID");
+        }
+
+        // Get score
+        address owner = ownerOf(_tokenId);
+        uint256 score = 0;
+
+        address engine = RulesEngine(address(this)).getRulesEngineOverride();
+        if (engine != address(0)) {
+            score = RulesEngine(engine).getScore(owner);
+        } else {
+            score = RulesEngine(address(this)).getScore(owner);
+        }
+
+        // Get the target ID i.e. `start` of the range that the score falls into.
+        bytes32[] memory ids = _sharedMetadataBatchStorage().ids.values();
+        bytes32 targetId = 0;
+        uint256 check = 0;
+
+        for (uint256 i = 0; i < ids.length; i += 1) {
+            uint256 id = uint256(ids[i]);
+
+            if (id <= score && id >= check) {
+                targetId = ids[i];
+                check = id;
+            }
+        }
+        return _getURIFromSharedMetadata(targetId, _tokenId);
+    }
+
+    /// @dev See ERC 165
+    function supportsInterface(
+        bytes4 interfaceId
+    ) public view virtual override(ERC721AUpgradeable, IERC721AUpgradeable, IERC165) returns (bool) {
+        return super.supportsInterface(interfaceId) || type(IERC2981Upgradeable).interfaceId == interfaceId;
+    }
+
+    /// @dev The start token ID for the contract.
+    function _startTokenId() internal pure override returns (uint256) {
+        return 1;
+    }
+
+    function startTokenId() public pure returns (uint256) {
+        return _startTokenId();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                        Internal functions
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev Collects and distributes the primary sale value of NFTs being claimed.
+    function _collectPriceOnClaim(
+        address _primarySaleRecipient,
+        uint256 _quantityToClaim,
+        address _currency,
+        uint256 _pricePerToken
+    ) internal override {
+        if (_pricePerToken == 0) {
+            require(msg.value == 0, "!Value");
+            return;
+        }
+
+        uint256 totalPrice = _quantityToClaim * _pricePerToken;
+
+        bool validMsgValue;
+        if (_currency == CurrencyTransferLib.NATIVE_TOKEN) {
+            validMsgValue = msg.value == totalPrice;
+        } else {
+            validMsgValue = msg.value == 0;
+        }
+        require(validMsgValue, "!V");
+
+        address saleRecipient = _primarySaleRecipient == address(0) ? primarySaleRecipient() : _primarySaleRecipient;
+
+        CurrencyTransferLib.transferCurrency(_currency, _msgSender(), saleRecipient, totalPrice);
+    }
+
+    /// @dev Transfers the NFTs being claimed.
+    function _transferTokensOnClaim(
+        address _to,
+        uint256 _quantityBeingClaimed
+    ) internal override returns (uint256 startTokenId_) {
+        startTokenId_ = _nextTokenId();
+        _safeMint(_to, _quantityBeingClaimed);
+    }
+
+    /// @dev Checks whether primary sale recipient can be set in the given execution context.
+    function _canSetPrimarySaleRecipient() internal view override returns (bool) {
+        return _hasRole(DEFAULT_ADMIN_ROLE, _msgSender());
+    }
+
+    /// @dev Checks whether owner can be set in the given execution context.
+    function _canSetOwner() internal view override returns (bool) {
+        return _hasRole(DEFAULT_ADMIN_ROLE, _msgSender());
+    }
+
+    /// @dev Checks whether royalty info can be set in the given execution context.
+    function _canSetRoyaltyInfo() internal view override returns (bool) {
+        return _hasRole(DEFAULT_ADMIN_ROLE, _msgSender());
+    }
+
+    /// @dev Checks whether contract metadata can be set in the given execution context.
+    function _canSetContractURI() internal view override returns (bool) {
+        return _hasRole(DEFAULT_ADMIN_ROLE, _msgSender());
+    }
+
+    /// @dev Checks whether platform fee info can be set in the given execution context.
+    function _canSetClaimConditions() internal view override returns (bool) {
+        return _hasRole(DEFAULT_ADMIN_ROLE, _msgSender());
+    }
+
+    /// @dev Returns whether shared metadata can be set in the given execution context.
+    function _canSetSharedMetadata() internal view virtual override returns (bool) {
+        return _hasRole(MINTER_ROLE, _msgSender());
+    }
+
+    /// @dev Checks whether an account has a particular role.
+    function _hasRole(bytes32 _role, address _account) internal view returns (bool) {
+        PermissionsStorage.Data storage data = PermissionsStorage.data();
+        return data._hasRole[_role][_account];
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                        Miscellaneous
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * Returns the total amount of tokens minted in the contract.
+     */
+    function totalMinted() external view returns (uint256) {
+        unchecked {
+            return _nextTokenId() - _startTokenId();
+        }
+    }
+
+    /// @dev The tokenId of the next NFT that will be minted / lazy minted.
+    function nextTokenIdToMint() external view returns (uint256) {
+        return _nextTokenId();
+    }
+
+    /// @dev The next token ID of the NFT that can be claimed.
+    function nextTokenIdToClaim() external view returns (uint256) {
+        return _nextTokenId();
+    }
+
+    /// @dev Burns `tokenId`. See {ERC721-_burn}.
+    function burn(uint256 tokenId) external virtual {
+        // note: ERC721AUpgradeable's `_burn(uint256,bool)` internally checks for token approvals.
+        _burn(tokenId, true);
+    }
+
+    /// @dev See {ERC721-_beforeTokenTransfer}.
+    function _beforeTokenTransfers(
+        address from,
+        address to,
+        uint256 startTokenId_,
+        uint256 quantity
+    ) internal virtual override {
+        super._beforeTokenTransfers(from, to, startTokenId_, quantity);
+
+        // if transfer is restricted on the contract, we still want to allow burning and minting
+        if (!_hasRole(TRANSFER_ROLE, address(0)) && from != address(0) && to != address(0)) {
+            if (!_hasRole(TRANSFER_ROLE, from) && !_hasRole(TRANSFER_ROLE, to)) {
+                revert("!T");
+            }
+        }
+    }
+
+    function _dropMsgSender() internal view virtual override returns (address) {
+        return _msgSender();
+    }
+
+    function _msgSender() internal view virtual override returns (address sender) {
+        return ERC2771ContextUpgradeable._msgSender();
+    }
+
+    function _msgData() internal view virtual override returns (bytes calldata) {
+        return ERC2771ContextUpgradeable._msgData();
+    }
+}

package/contracts/prebuilts/evolving-nfts/extension/RulesEngineExtension.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.11;
+
+/// @author thirdweb
+
+import { PermissionsStorage } from "../../../extension/upgradeable/Permissions.sol";
+import { RulesEngine } from "../../../extension/upgradeable/RulesEngine.sol";
+
+contract RulesEngineExtension is RulesEngine {
+    /// @dev Returns whether the rules of the contract can be set in the given execution context.
+    function _canSetRules() internal view virtual override returns (bool) {
+        return _hasRole(keccak256("MINTER_ROLE"), msg.sender);
+    }
+
+    /// @dev Returns whether the rules engine used by the contract can be overriden in the given execution context.
+    function _canOverrideRulesEngine() internal view virtual override returns (bool) {
+        // DEFAULT_ADMIN_ROLE
+        return _hasRole(0x00, msg.sender);
+    }
+
+    /// @dev Checks whether an account has a particular role.
+    function _hasRole(bytes32 _role, address _account) internal view returns (bool) {
+        PermissionsStorage.Data storage data = PermissionsStorage.data();
+        return data._hasRole[_role][_account];
+    }
+}

package/contracts/prebuilts/interface/ILoyaltyCard.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.11;
+
+import "../../extension/interface/INFTMetadata.sol";
+import "../../extension/interface/ISignatureMintERC721.sol";
+import "../../eip/interface/IERC721.sol";
+
+interface ILoyaltyCard {
+    /// @dev Emitted when an account with MINTER_ROLE mints an NFT.
+    event TokensMinted(address indexed mintedTo, uint256 indexed tokenIdMinted, string uri);
+
+    /**
+     *  @notice Lets an account with MINTER_ROLE mint an NFT.
+     *
+     *  @param to The address to mint the NFT to.
+     *  @param uri The URI to assign to the NFT.
+     *
+     *  @return tokenId of the NFT minted.
+     */
+    function mintTo(address to, string calldata uri) external returns (uint256);
+
+    /// @notice Let's a loyalty card owner or approved operator cancel the loyalty card.
+    function cancel(uint256 tokenId) external;
+
+    /// @notice Let's an approved party cancel the loyalty card (no approval needed).
+    function revoke(uint256 tokenId) external;
+}

package/contracts/prebuilts/interface/ILoyaltyPoints.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.11;
+
+interface ILoyaltyPoints {
+    /// @dev Emitted when an account with MINTER_ROLE mints an NFT.
+    event TokensMinted(address indexed mintedTo, uint256 quantityMinted);
+
+    /// @notice Returns the total tokens minted to `owner` in the contract's lifetime.
+    function getTotalMintedInLifetime(address owner) external view returns (uint256);
+
+    /**
+     *  @notice Lets an account with MINTER_ROLE mint an NFT.
+     *
+     *  @param to The address to mint tokens to.
+     *  @param amount The amount of tokens to mint.
+     */
+    function mintTo(address to, uint256 amount) external;
+
+    /// @notice Let's a loyalty pointsß owner or approved operator cancel the given amount of loyalty points.
+    function cancel(address owner, uint256 amount) external;
+
+    /// @notice Let's an approved party revoke a holder's loyalty points (no approval needed).
+    function revoke(address owner, uint256 amount) external;
+}

package/contracts/prebuilts/interface/IMultiwrap.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.11;
+
+import "../../extension/interface/ITokenBundle.sol";
+
+/**
+ *  Thirdweb's Multiwrap contract lets you wrap arbitrary ERC20, ERC721 and ERC1155
+ *  tokens you own into a single wrapped token / NFT.
+ *
+ *  A wrapped NFT can be unwrapped i.e. burned in exchange for its underlying contents.
+ */
+
+interface IMultiwrap is ITokenBundle {
+    /// @dev Emitted when tokens are wrapped.
+    event TokensWrapped(
+        address indexed wrapper,
+        address indexed recipientOfWrappedToken,
+        uint256 indexed tokenIdOfWrappedToken,
+        Token[] wrappedContents
+    );
+
+    /// @dev Emitted when tokens are unwrapped.
+    event TokensUnwrapped(
+        address indexed unwrapper,
+        address indexed recipientOfWrappedContents,
+        uint256 indexed tokenIdOfWrappedToken
+    );
+
+    /**
+     *  @notice Wrap multiple ERC1155, ERC721, ERC20 tokens into a single wrapped NFT.
+     *
+     *  @param wrappedContents    The tokens to wrap.
+     *  @param uriForWrappedToken The metadata URI for the wrapped NFT.
+     *  @param recipient          The recipient of the wrapped NFT.
+     */
+    function wrap(
+        Token[] memory wrappedContents,
+        string calldata uriForWrappedToken,
+        address recipient
+    ) external payable returns (uint256 tokenId);
+
+    /**
+     *  @notice Unwrap a wrapped NFT to retrieve underlying ERC1155, ERC721, ERC20 tokens.
+     *
+     *  @param tokenId   The token Id of the wrapped NFT to unwrap.
+     *  @param recipient The recipient of the underlying ERC1155, ERC721, ERC20 tokens of the wrapped NFT.
+     */
+    function unwrap(uint256 tokenId, address recipient) external;
+}

package/contracts/prebuilts/interface/IPack.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.11;
+
+import "../../extension/interface/ITokenBundle.sol";
+
+/**
+ *  The thirdweb `Pack` contract is a lootbox mechanism. An account can bundle up arbitrary ERC20, ERC721 and ERC1155 tokens into
+ *  a set of packs. A pack can then be opened in return for a selection of the tokens in the pack. The selection of tokens distributed
+ *  on opening a pack depends on the relative supply of all tokens in the packs.
+ */
+
+interface IPack is ITokenBundle {
+    /**
+     *  @notice All info relevant to packs.
+     *
+     *  @param perUnitAmounts           Mapping from a UID -> to the per-unit amount of that asset i.e. `Token` at that index.
+     *  @param openStartTimestamp       The timestamp after which packs can be opened.
+     *  @param amountDistributedPerOpen The number of reward units distributed per open.
+     */
+    struct PackInfo {
+        uint256[] perUnitAmounts;
+        uint128 openStartTimestamp;
+        uint128 amountDistributedPerOpen;
+    }
+
+    /// @notice Emitted when a set of packs is created.
+    event PackCreated(uint256 indexed packId, address recipient, uint256 totalPacksCreated);
+
+    /// @notice Emitted when more packs are minted for a packId.
+    event PackUpdated(uint256 indexed packId, address recipient, uint256 totalPacksCreated);
+
+    /// @notice Emitted when a pack is opened.
+    event PackOpened(
+        uint256 indexed packId,
+        address indexed opener,
+        uint256 numOfPacksOpened,
+        Token[] rewardUnitsDistributed
+    );
+
+    /**
+     *  @notice Creates a pack with the stated contents.
+     *
+     *  @param contents                 The reward units to pack in the packs.
+     *  @param numOfRewardUnits         The number of reward units to create, for each asset specified in `contents`.
+     *  @param packUri                  The (metadata) URI assigned to the packs created.
+     *  @param openStartTimestamp       The timestamp after which packs can be opened.
+     *  @param amountDistributedPerOpen The number of reward units distributed per open.
+     *  @param recipient                The recipient of the packs created.
+     *
+     *  @return packId The unique identifier of the created set of packs.
+     *  @return packTotalSupply The total number of packs created.
+     */
+    function createPack(
+        Token[] calldata contents,
+        uint256[] calldata numOfRewardUnits,
+        string calldata packUri,
+        uint128 openStartTimestamp,
+        uint128 amountDistributedPerOpen,
+        address recipient
+    ) external payable returns (uint256 packId, uint256 packTotalSupply);
+
+    /**
+     *  @notice Lets a pack owner open a pack and receive the pack's reward unit.
+     *
+     *  @param packId       The identifier of the pack to open.
+     *  @param amountToOpen The number of packs to open at once.
+     */
+    function openPack(uint256 packId, uint256 amountToOpen) external returns (Token[] memory);
+}

package/contracts/prebuilts/interface/IPackVRFDirect.sol

@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.11;
+
+import "../../extension/interface/ITokenBundle.sol";
+
+/**
+ *  The thirdweb `Pack` contract is a lootbox mechanism. An account can bundle up arbitrary ERC20, ERC721 and ERC1155 tokens into
+ *  a set of packs. A pack can then be opened in return for a selection of the tokens in the pack. The selection of tokens distributed
+ *  on opening a pack depends on the relative supply of all tokens in the packs.
+ */
+
+interface IPackVRFDirect is ITokenBundle {
+    /**
+     *  @notice All info relevant to packs.
+     *
+     *  @param perUnitAmounts           Mapping from a UID -> to the per-unit amount of that asset i.e. `Token` at that index.
+     *  @param openStartTimestamp       The timestamp after which packs can be opened.
+     *  @param amountDistributedPerOpen The number of reward units distributed per open.
+     */
+    struct PackInfo {
+        uint256[] perUnitAmounts;
+        uint128 openStartTimestamp;
+        uint128 amountDistributedPerOpen;
+    }
+
+    /// @notice Emitted when a set of packs is created.
+    event PackCreated(uint256 indexed packId, address recipient, uint256 totalPacksCreated);
+
+    /// @notice Emitted when the opening of a pack is requested.
+    event PackOpenRequested(address indexed opener, uint256 indexed packId, uint256 amountToOpen, uint256 requestId);
+
+    /// @notice Emitted when Chainlink VRF fulfills a random number request.
+    event PackRandomnessFulfilled(uint256 indexed packId, uint256 indexed requestId);
+
+    /// @notice Emitted when a pack is opened.
+    event PackOpened(
+        uint256 indexed packId,
+        address indexed opener,
+        uint256 numOfPacksOpened,
+        Token[] rewardUnitsDistributed
+    );
+
+    /**
+     *  @notice Creates a pack with the stated contents.
+     *
+     *  @param contents                 The reward units to pack in the packs.
+     *  @param numOfRewardUnits         The number of reward units to create, for each asset specified in `contents`.
+     *  @param packUri                  The (metadata) URI assigned to the packs created.
+     *  @param openStartTimestamp       The timestamp after which packs can be opened.
+     *  @param amountDistributedPerOpen The number of reward units distributed per open.
+     *  @param recipient                The recipient of the packs created.
+     *
+     *  @return packId The unique identifier of the created set of packs.
+     *  @return packTotalSupply The total number of packs created.
+     */
+    function createPack(
+        Token[] calldata contents,
+        uint256[] calldata numOfRewardUnits,
+        string calldata packUri,
+        uint128 openStartTimestamp,
+        uint128 amountDistributedPerOpen,
+        address recipient
+    ) external payable returns (uint256 packId, uint256 packTotalSupply);
+
+    /**
+     *  @notice Lets a pack owner request to open a pack.
+     *
+     *  @param packId       The identifier of the pack to open.
+     *  @param amountToOpen The number of packs to open at once.
+     */
+    function openPack(uint256 packId, uint256 amountToOpen) external returns (uint256 requestId);
+
+    /// @notice Called by a pack opener to claim rewards from the opened pack.
+    function claimRewards() external returns (Token[] memory rewardUnits);
+
+    /// @notice Called by a pack opener to open a pack in a single transaction, instead of calling openPack and claimRewards separately.
+    function openPackAndClaimRewards(
+        uint256 _packId,
+        uint256 _amountToOpen,
+        uint32 _callBackGasLimit
+    ) external returns (uint256);
+
+    /// @notice Returns whether a pack opener is ready to call `claimRewards`.
+    function canClaimRewards(address _opener) external view returns (bool);
+}

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

@@ -0,0 +1,45 @@
+// 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.
+ *
+ *  `AirdropERC1155` contract is an airdrop contract for ERC1155 tokens. It follows a
+ *  push mechanism for transfer of tokens to intended recipients.
+ */
+
+interface IAirdropERC1155 {
+    /// @notice Emitted when an airdrop fails for a recipient address.
+    event AirdropFailed(
+        address indexed tokenAddress,
+        address indexed tokenOwner,
+        address indexed recipient,
+        uint256 tokenId,
+        uint256 amount
+    );
+
+    /**
+     *  @notice Details of amount and recipient for airdropped token.
+     *
+     *  @param recipient The recipient of the tokens.
+     *  @param tokenId ID of the ERC1155 token being airdropped.
+     *  @param amount The quantity of tokens to airdrop.
+     */
+    struct AirdropContent {
+        address recipient;
+        uint256 tokenId;
+        uint256 amount;
+    }
+
+    /**
+     *  @notice          Lets contract-owner send ERC1155 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 airdropERC1155(address tokenAddress, address tokenOwner, AirdropContent[] calldata contents) external;
+}

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

@@ -0,0 +1,40 @@
+// 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.
+ *
+ *  `AirdropERC1155Claimable` contract is an airdrop contract for ERC1155 tokens. It follows a
+ *  pull mechanism for transfer of tokens, where allowlisted recipients can claim tokens from
+ *  the contract.
+ */
+
+interface IAirdropERC1155Claimable {
+    /// @dev Emitted when tokens are claimed.
+    event TokensClaimed(
+        address indexed claimer,
+        address indexed receiver,
+        uint256 indexed tokenId,
+        uint256 quantityClaimed
+    );
+
+    /**
+     *  @notice Lets an account claim a given quantity of ERC1155 tokens.
+     *
+     *  @param receiver                       The receiver of the tokens to claim.
+     *  @param quantity                       The quantity of tokens to claim.
+     *  @param tokenId                        Token Id 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 tokens an address included in an
+     *                                        allowlist can claim.
+     */
+    function claim(
+        address receiver,
+        uint256 quantity,
+        uint256 tokenId,
+        bytes32[] calldata proofs,
+        uint256 proofMaxQuantityForWallet
+    ) external;
+}

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

@@ -0,0 +1,46 @@
+// 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.
+ *
+ *  `AirdropERC20` contract is an airdrop contract for ERC20 tokens. It follows a
+ *  push mechanism for transfer of tokens to intended recipients.
+ */
+
+interface IAirdropERC20 {
+    /// @notice Emitted when an airdrop fails for a recipient address.
+    event AirdropFailed(
+        address indexed tokenAddress,
+        address indexed tokenOwner,
+        address indexed recipient,
+        uint256 amount
+    );
+
+    /**
+     *  @notice Details of amount and recipient for airdropped token.
+     *
+     *  @param recipient The recipient of the tokens.
+     *  @param amount The quantity of tokens to airdrop.
+     */
+    struct AirdropContent {
+        address recipient;
+        uint256 amount;
+    }
+
+    /**
+     *  @notice          Lets contract-owner send ERC20 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 airdropERC20(
+        address tokenAddress,
+        address tokenOwner,
+        AirdropContent[] calldata contents
+    ) external payable;
+}