@rarible/external-contracts 3.11.4

package/contracts/prebuilts/unaudited/airdrop/AirdropERC721.sol

@@ -0,0 +1,143 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.11;
+
+/// @author thirdweb
+
+//   $$\     $$\       $$\                 $$\                         $$\
+//   $$ |    $$ |      \__|                $$ |                        $$ |
+// $$$$$$\   $$$$$$$\  $$\  $$$$$$\   $$$$$$$ |$$\  $$\  $$\  $$$$$$\  $$$$$$$\
+// \_$$  _|  $$  __$$\ $$ |$$  __$$\ $$  __$$ |$$ | $$ | $$ |$$  __$$\ $$  __$$\
+//   $$ |    $$ |  $$ |$$ |$$ |  \__|$$ /  $$ |$$ | $$ | $$ |$$$$$$$$ |$$ |  $$ |
+//   $$ |$$\ $$ |  $$ |$$ |$$ |      $$ |  $$ |$$ | $$ | $$ |$$   ____|$$ |  $$ |
+//   \$$$$  |$$ |  $$ |$$ |$$ |      \$$$$$$$ |\$$$$$\$$$$  |\$$$$$$$\ $$$$$$$  |
+//    \____/ \__|  \__|\__|\__|       \_______| \_____\____/  \_______|\_______/
+
+//  ==========  External imports    ==========
+import "../../../eip/interface/IERC721.sol";
+
+import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
+import "../../../extension/Multicall.sol";
+
+//  ==========  Internal imports    ==========
+
+import "../../interface/airdrop/IAirdropERC721.sol";
+import "../../../external-deps/openzeppelin/metatx/ERC2771ContextUpgradeable.sol";
+
+//  ==========  Features    ==========
+import "../../../extension/PermissionsEnumerable.sol";
+import "../../../extension/ContractMetadata.sol";
+
+contract AirdropERC721 is
+    Initializable,
+    ContractMetadata,
+    PermissionsEnumerable,
+    ReentrancyGuardUpgradeable,
+    ERC2771ContextUpgradeable,
+    Multicall,
+    IAirdropERC721
+{
+    /*///////////////////////////////////////////////////////////////
+                            State variables
+    //////////////////////////////////////////////////////////////*/
+
+    bytes32 private constant MODULE_TYPE = bytes32("AirdropERC721");
+    uint256 private constant VERSION = 2;
+
+    /*///////////////////////////////////////////////////////////////
+                    Constructor + initializer logic
+    //////////////////////////////////////////////////////////////*/
+
+    constructor() {
+        _disableInitializers();
+    }
+
+    /// @dev Initializes the contract, like a constructor.
+    function initialize(
+        address _defaultAdmin,
+        string memory _contractURI,
+        address[] memory _trustedForwarders
+    ) external initializer {
+        __ERC2771Context_init_unchained(_trustedForwarders);
+
+        _setupContractURI(_contractURI);
+        _setupRole(DEFAULT_ADMIN_ROLE, _defaultAdmin);
+        __ReentrancyGuard_init();
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                        Generic contract logic
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev Returns the type of the contract.
+    function contractType() external pure returns (bytes32) {
+        return MODULE_TYPE;
+    }
+
+    /// @dev Returns the version of the contract.
+    function contractVersion() external pure returns (uint8) {
+        return uint8(VERSION);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                            Airdrop logic
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     *  @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 nonReentrant {
+        require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "Not authorized.");
+
+        uint256 len = _contents.length;
+
+        for (uint256 i = 0; i < len; ) {
+            try
+                IERC721(_tokenAddress).safeTransferFrom(_tokenOwner, _contents[i].recipient, _contents[i].tokenId)
+            {} catch {
+                // revert if failure is due to unapproved tokens
+                require(
+                    (IERC721(_tokenAddress).ownerOf(_contents[i].tokenId) == _tokenOwner &&
+                        address(this) == IERC721(_tokenAddress).getApproved(_contents[i].tokenId)) ||
+                        IERC721(_tokenAddress).isApprovedForAll(_tokenOwner, address(this)),
+                    "Not owner or approved"
+                );
+
+                emit AirdropFailed(_tokenAddress, _tokenOwner, _contents[i].recipient, _contents[i].tokenId);
+            }
+
+            unchecked {
+                i += 1;
+            }
+        }
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                        Miscellaneous
+    //////////////////////////////////////////////////////////////*/
+
+    /// @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 See ERC2771
+    function _msgSender()
+        internal
+        view
+        virtual
+        override(ERC2771ContextUpgradeable, Multicall)
+        returns (address sender)
+    {
+        return ERC2771ContextUpgradeable._msgSender();
+    }
+}

package/contracts/prebuilts/unaudited/airdrop/AirdropERC721Claimable.sol

@@ -0,0 +1,197 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.11;
+
+/// @author thirdweb
+
+//   $$\     $$\       $$\                 $$\                         $$\
+//   $$ |    $$ |      \__|                $$ |                        $$ |
+// $$$$$$\   $$$$$$$\  $$\  $$$$$$\   $$$$$$$ |$$\  $$\  $$\  $$$$$$\  $$$$$$$\
+// \_$$  _|  $$  __$$\ $$ |$$  __$$\ $$  __$$ |$$ | $$ | $$ |$$  __$$\ $$  __$$\
+//   $$ |    $$ |  $$ |$$ |$$ |  \__|$$ /  $$ |$$ | $$ | $$ |$$$$$$$$ |$$ |  $$ |
+//   $$ |$$\ $$ |  $$ |$$ |$$ |      $$ |  $$ |$$ | $$ | $$ |$$   ____|$$ |  $$ |
+//   \$$$$  |$$ |  $$ |$$ |$$ |      \$$$$$$$ |\$$$$$\$$$$  |\$$$$$$$\ $$$$$$$  |
+//    \____/ \__|  \__|\__|\__|       \_______| \_____\____/  \_______|\_______/
+
+//  ==========  External imports    ==========
+import "../../../eip/interface/IERC721.sol";
+
+import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
+import "../../../extension/Multicall.sol";
+
+//  ==========  Internal imports    ==========
+
+import "../../interface/airdrop/IAirdropERC721Claimable.sol";
+
+//  ==========  Features    ==========
+
+import "../../../external-deps/openzeppelin/metatx/ERC2771ContextUpgradeable.sol";
+import "../../../lib/MerkleProof.sol";
+
+contract AirdropERC721Claimable is
+    Initializable,
+    ReentrancyGuardUpgradeable,
+    ERC2771ContextUpgradeable,
+    Multicall,
+    IAirdropERC721Claimable
+{
+    /*///////////////////////////////////////////////////////////////
+                            State variables
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev address of token being airdropped.
+    address public airdropTokenAddress;
+
+    /// @dev address of owner of tokens being airdropped.
+    address public tokenOwner;
+
+    /// @dev list of tokens to airdrop.
+    uint256[] public tokenIds;
+
+    /// @dev next index in tokenIds[] to claim in the airdrop.
+    uint256 public nextIndex;
+
+    /// @dev number tokens available to claim in tokenIds[].
+    uint256 public availableAmount;
+
+    /// @dev airdrop expiration timestamp.
+    uint256 public expirationTimestamp;
+
+    /// @dev claim limit for open/public claiming without allowlist.
+    uint256 public openClaimLimitPerWallet;
+
+    /// @dev merkle root of the allowlist of addresses eligible to claim.
+    bytes32 public merkleRoot;
+
+    /*///////////////////////////////////////////////////////////////
+                                Mappings
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev Mapping from address => total number of tokens a wallet has claimed.
+    mapping(address => uint256) public supplyClaimedByWallet;
+
+    /*///////////////////////////////////////////////////////////////
+                    Constructor + initializer logic
+    //////////////////////////////////////////////////////////////*/
+
+    constructor() {
+        _disableInitializers();
+    }
+
+    /// @dev Initializes the contract, like a constructor.
+    function initialize(
+        address[] memory _trustedForwarders,
+        address _tokenOwner,
+        address _airdropTokenAddress,
+        uint256[] memory _tokenIds,
+        uint256 _expirationTimestamp,
+        uint256 _openClaimLimitPerWallet,
+        bytes32 _merkleRoot
+    ) external initializer {
+        __ReentrancyGuard_init();
+        __ERC2771Context_init(_trustedForwarders);
+
+        tokenOwner = _tokenOwner;
+        airdropTokenAddress = _airdropTokenAddress;
+        tokenIds = _tokenIds;
+        expirationTimestamp = _expirationTimestamp;
+        openClaimLimitPerWallet = _openClaimLimitPerWallet;
+        merkleRoot = _merkleRoot;
+
+        availableAmount = _tokenIds.length;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                            Claim logic
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     *  @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 nonReentrant {
+        address claimer = _msgSender();
+
+        verifyClaim(claimer, _quantity, _proofs, _proofMaxQuantityForWallet);
+
+        _transferClaimedTokens(_receiver, _quantity);
+
+        emit TokensClaimed(_msgSender(), _receiver, _quantity);
+    }
+
+    /// @dev Checks a request to claim tokens against the active claim condition's criteria.
+    function verifyClaim(
+        address _claimer,
+        uint256 _quantity,
+        bytes32[] calldata _proofs,
+        uint256 _proofMaxQuantityForWallet
+    ) public view {
+        bool isOverride;
+
+        /*
+         * Here `isOverride` implies that if the merkle proof verification fails,
+         * the claimer would claim through open claim limit instead of allowlisted limit.
+         */
+        if (merkleRoot != bytes32(0)) {
+            (isOverride, ) = MerkleProof.verify(
+                _proofs,
+                merkleRoot,
+                keccak256(abi.encodePacked(_claimer, _proofMaxQuantityForWallet))
+            );
+        }
+
+        uint256 supplyClaimedAlready = supplyClaimedByWallet[_claimer];
+
+        require(_quantity > 0, "Claiming zero tokens");
+        require(_quantity <= availableAmount, "exceeds available tokens.");
+
+        uint256 expTimestamp = expirationTimestamp;
+        require(expTimestamp == 0 || block.timestamp < expTimestamp, "airdrop expired.");
+
+        uint256 claimLimitForWallet = isOverride ? _proofMaxQuantityForWallet : openClaimLimitPerWallet;
+        require(_quantity + supplyClaimedAlready <= claimLimitForWallet, "invalid quantity.");
+    }
+
+    /// @dev Transfers the tokens being claimed.
+    function _transferClaimedTokens(address _to, uint256 _quantityBeingClaimed) internal {
+        // if transfer claimed tokens is called when `to != msg.sender`, it'd use msg.sender's limits.
+        // behavior would be similar to `msg.sender` mint for itself, then transfer to `_to`.
+        supplyClaimedByWallet[_msgSender()] += _quantityBeingClaimed;
+        availableAmount -= _quantityBeingClaimed;
+
+        uint256 index = nextIndex;
+        uint256[] memory _tokenIds = tokenIds;
+        address _tokenAddress = airdropTokenAddress;
+        address _tokenOwner = tokenOwner;
+
+        for (uint256 i = 0; i < _quantityBeingClaimed; i += 1) {
+            IERC721(_tokenAddress).safeTransferFrom(_tokenOwner, _to, _tokenIds[index]);
+            index += 1;
+        }
+        nextIndex = index;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                        Miscellaneous
+    //////////////////////////////////////////////////////////////*/
+
+    function _msgSender()
+        internal
+        view
+        virtual
+        override(ERC2771ContextUpgradeable, Multicall)
+        returns (address sender)
+    {
+        return ERC2771ContextUpgradeable._msgSender();
+    }
+}

package/contracts/prebuilts/unaudited/burn-to-claim-drop/BurnToClaimDropERC721.sol

@@ -0,0 +1,137 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.11;
+
+/// @author thirdweb
+
+//   $$\     $$\       $$\                 $$\                         $$\
+//   $$ |    $$ |      \__|                $$ |                        $$ |
+// $$$$$$\   $$$$$$$\  $$\  $$$$$$\   $$$$$$$ |$$\  $$\  $$\  $$$$$$\  $$$$$$$\
+// \_$$  _|  $$  __$$\ $$ |$$  __$$\ $$  __$$ |$$ | $$ | $$ |$$  __$$\ $$  __$$\
+//   $$ |    $$ |  $$ |$$ |$$ |  \__|$$ /  $$ |$$ | $$ | $$ |$$$$$$$$ |$$ |  $$ |
+//   $$ |$$\ $$ |  $$ |$$ |$$ |      $$ |  $$ |$$ | $$ | $$ |$$   ____|$$ |  $$ |
+//   \$$$$  |$$ |  $$ |$$ |$$ |      \$$$$$$$ |\$$$$$\$$$$  |\$$$$$$$\ $$$$$$$  |
+//    \____/ \__|  \__|\__|\__|       \_______| \_____\____/  \_______|\_______/
+
+import "@thirdweb-dev/dynamic-contracts/src/presets/BaseRouter.sol";
+
+import "../../../extension/Multicall.sol";
+
+import "../../../extension/upgradeable/Initializable.sol";
+import "../../../extension/upgradeable/Permissions.sol";
+import "../../../extension/upgradeable/ERC2771ContextUpgradeable.sol";
+
+import "../../../extension/upgradeable/init/ContractMetadataInit.sol";
+import "../../../extension/upgradeable/init/PlatformFeeInit.sol";
+import "../../../extension/upgradeable/init/RoyaltyInit.sol";
+import "../../../extension/upgradeable/init/PrimarySaleInit.sol";
+import "../../../extension/upgradeable/init/OwnableInit.sol";
+import "../../../extension/upgradeable/init/ERC721AInit.sol";
+import "../../../extension/upgradeable/init/PermissionsEnumerableInit.sol";
+import "../../../extension/upgradeable/init/ReentrancyGuardInit.sol";
+
+contract BurnToClaimDropERC721 is
+    Initializable,
+    Multicall,
+    ERC2771ContextUpgradeable,
+    BaseRouter,
+    ContractMetadataInit,
+    PlatformFeeInit,
+    RoyaltyInit,
+    PrimarySaleInit,
+    OwnableInit,
+    PermissionsEnumerableInit,
+    ERC721AInit
+{
+    /*///////////////////////////////////////////////////////////////
+                    Constructor + initializer logic
+    //////////////////////////////////////////////////////////////*/
+
+    constructor(Extension[] memory _extensions) BaseRouter(_extensions) {
+        _disableInitializers();
+    }
+
+    /// @notice Initializes the contract.
+    function initialize(
+        address _defaultAdmin,
+        string memory _name,
+        string memory _symbol,
+        string memory _contractURI,
+        address[] memory _trustedForwarders,
+        address _saleRecipient,
+        address _royaltyRecipient,
+        uint128 _royaltyBps,
+        uint128 _platformFeeBps,
+        address _platformFeeRecipient
+    ) external initializer {
+        // Initialize extensions
+        __BaseRouter_init();
+
+        // Initialize inherited contracts, most base-like -> most derived.
+        __ERC2771Context_init(_trustedForwarders);
+        __ERC721A_init(_name, _symbol);
+
+        _setupContractURI(_contractURI);
+        _setupOwner(_defaultAdmin);
+
+        _setupRoles(_defaultAdmin);
+
+        _setupPlatformFeeInfo(_platformFeeRecipient, _platformFeeBps);
+        _setupDefaultRoyaltyInfo(_royaltyRecipient, _royaltyBps);
+        _setupPrimarySaleRecipient(_saleRecipient);
+    }
+
+    /// @dev Called in the initialize function. Sets up roles.
+    function _setupRoles(address _defaultAdmin) internal onlyInitializing {
+        bytes32 _transferRole = keccak256("TRANSFER_ROLE");
+        bytes32 _minterRole = keccak256("MINTER_ROLE");
+        bytes32 _extensionRole = keccak256("EXTENSION_ROLE");
+        bytes32 _defaultAdminRole = 0x00;
+
+        _setupRole(_defaultAdminRole, _defaultAdmin);
+        _setupRole(_minterRole, _defaultAdmin);
+        _setupRole(_transferRole, _defaultAdmin);
+        _setupRole(_transferRole, address(0));
+        _setupRole(_extensionRole, _defaultAdmin);
+        _setRoleAdmin(_extensionRole, _extensionRole);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                        Contract identifiers
+    //////////////////////////////////////////////////////////////*/
+
+    /// @notice Returns the type of contract.
+    function contractType() external pure returns (bytes32) {
+        return bytes32("BurnToClaimDropERC721");
+    }
+
+    /// @notice Returns the contract version.
+    function contractVersion() external pure returns (uint8) {
+        return uint8(5);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                        Internal functions
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev Returns whether all relevant permission and other checks are met before any upgrade.
+    function _isAuthorizedCallToUpgrade() internal view virtual override returns (bool) {
+        return _hasRole(keccak256("EXTENSION_ROLE"), msg.sender);
+    }
+
+    /// @dev Checks whether an account holds the given role.
+    function _hasRole(bytes32 role, address addr) internal view returns (bool) {
+        PermissionsStorage.Data storage data = PermissionsStorage.data();
+        return data._hasRole[role][addr];
+    }
+
+    /// @notice Returns the sender in the given execution context.
+    function _msgSender()
+        internal
+        view
+        virtual
+        override(ERC2771ContextUpgradeable, Multicall)
+        returns (address sender)
+    {
+        return ERC2771ContextUpgradeable._msgSender();
+    }
+}