@rarible/external-contracts 3.11.4

package/contracts/eip/queryable/ERC721A__Initializable.sol

@@ -0,0 +1,75 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/**
+ * @dev This is a base contract to aid in writing upgradeable diamond facet contracts, or any kind of contract that will be deployed
+ * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
+ * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
+ * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
+ *
+ * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
+ * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
+ *
+ * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
+ * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
+ */
+
+import { ERC721A__InitializableStorage } from "./ERC721A__InitializableStorage.sol";
+
+abstract contract ERC721A__Initializable {
+    using ERC721A__InitializableStorage for ERC721A__InitializableStorage.Layout;
+
+    /**
+     * @dev Modifier to protect an initializer function from being invoked twice.
+     */
+    modifier initializerERC721A() {
+        // If the contract is initializing we ignore whether _initialized is set in order to support multiple
+        // inheritance patterns, but we only do this in the context of a constructor, because in other contexts the
+        // contract may have been reentered.
+        require(
+            ERC721A__InitializableStorage.layout()._initializing
+                ? _isConstructor()
+                : !ERC721A__InitializableStorage.layout()._initialized,
+            "ERC721A__Initializable: contract is already initialized"
+        );
+
+        bool isTopLevelCall = !ERC721A__InitializableStorage.layout()._initializing;
+        if (isTopLevelCall) {
+            ERC721A__InitializableStorage.layout()._initializing = true;
+            ERC721A__InitializableStorage.layout()._initialized = true;
+        }
+
+        _;
+
+        if (isTopLevelCall) {
+            ERC721A__InitializableStorage.layout()._initializing = false;
+        }
+    }
+
+    /**
+     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
+     * {initializer} modifier, directly or indirectly.
+     */
+    modifier onlyInitializingERC721A() {
+        require(
+            ERC721A__InitializableStorage.layout()._initializing,
+            "ERC721A__Initializable: contract is not initializing"
+        );
+        _;
+    }
+
+    /// @dev Returns true if and only if the function is running in the constructor
+    function _isConstructor() private view returns (bool) {
+        // extcodesize checks the size of the code stored in an address, and
+        // address returns the current address. Since the code is still not
+        // deployed when running a constructor, any checks on its code size will
+        // yield zero, making it an effective way to detect if a contract is
+        // under construction or not.
+        address self = address(this);
+        uint256 cs;
+        assembly {
+            cs := extcodesize(self)
+        }
+        return cs == 0;
+    }
+}

package/contracts/eip/queryable/ERC721A__InitializableStorage.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.0;
+
+/**
+ * @dev This is a base storage for the  initialization function for upgradeable diamond facet contracts
+ **/
+
+library ERC721A__InitializableStorage {
+    struct Layout {
+        /*
+         * Indicates that the contract has been initialized.
+         */
+        bool _initialized;
+        /*
+         * Indicates that the contract is in the process of being initialized.
+         */
+        bool _initializing;
+    }
+
+    bytes32 internal constant STORAGE_SLOT = keccak256("ERC721A.contracts.storage.initializable.facet");
+
+    function layout() internal pure returns (Layout storage l) {
+        bytes32 slot = STORAGE_SLOT;
+        assembly {
+            l.slot := slot
+        }
+    }
+}

package/contracts/eip/queryable/IERC721AQueryable.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: MIT
+// ERC721A Contracts v3.3.0
+// Creator: Chiru Labs
+
+pragma solidity ^0.8.4;
+
+import "../interface/IERC721A.sol";
+
+/**
+ * @dev Interface of an ERC721AQueryable compliant contract.
+ */
+interface IERC721AQueryable is IERC721A {
+    /**
+     * Invalid query range (`start` >= `stop`).
+     */
+    error InvalidQueryRange();
+
+    /**
+     * @dev Returns the `TokenOwnership` struct at `tokenId` without reverting.
+     *
+     * If the `tokenId` is out of bounds:
+     *   - `addr` = `address(0)`
+     *   - `startTimestamp` = `0`
+     *   - `burned` = `false`
+     *
+     * If the `tokenId` is burned:
+     *   - `addr` = `<Address of owner before token was burned>`
+     *   - `startTimestamp` = `<Timestamp when token was burned>`
+     *   - `burned = `true`
+     *
+     * Otherwise:
+     *   - `addr` = `<Address of owner>`
+     *   - `startTimestamp` = `<Timestamp of start of ownership>`
+     *   - `burned = `false`
+     */
+    function explicitOwnershipOf(uint256 tokenId) external view returns (TokenOwnership memory);
+
+    /**
+     * @dev Returns an array of `TokenOwnership` structs at `tokenIds` in order.
+     * See {ERC721AQueryable-explicitOwnershipOf}
+     */
+    function explicitOwnershipsOf(uint256[] memory tokenIds) external view returns (TokenOwnership[] memory);
+
+    /**
+     * @dev Returns an array of token IDs owned by `owner`,
+     * in the range [`start`, `stop`)
+     * (i.e. `start <= tokenId < stop`).
+     *
+     * This function allows for tokens to be queried if the collection
+     * grows too big for a single call of {ERC721AQueryable-tokensOfOwner}.
+     *
+     * Requirements:
+     *
+     * - `start` < `stop`
+     */
+    function tokensOfOwnerIn(address owner, uint256 start, uint256 stop) external view returns (uint256[] memory);
+
+    /**
+     * @dev Returns an array of token IDs owned by `owner`.
+     *
+     * This function scans the ownership mapping and is O(totalSupply) in complexity.
+     * It is meant to be called off-chain.
+     *
+     * See {ERC721AQueryable-tokensOfOwnerIn} for splitting the scan into
+     * multiple smaller scans if the collection is large enough to cause
+     * an out-of-gas error (10K pfp collections should be fine).
+     */
+    function tokensOfOwner(address owner) external view returns (uint256[] memory);
+}

package/contracts/eip/queryable/IERC721AQueryableUpgradeable.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: MIT
+// ERC721A Contracts v4.2.3
+// Creator: Chiru Labs
+
+pragma solidity ^0.8.4;
+
+import "./IERC721AUpgradeable.sol";
+
+/**
+ * @dev Interface of ERC721AQueryable.
+ */
+interface IERC721AQueryableUpgradeable is IERC721AUpgradeable {
+    /**
+     * Invalid query range (`start` >= `stop`).
+     */
+    error InvalidQueryRange();
+
+    /**
+     * @dev Returns the `TokenOwnership` struct at `tokenId` without reverting.
+     *
+     * If the `tokenId` is out of bounds:
+     *
+     * - `addr = address(0)`
+     * - `startTimestamp = 0`
+     * - `burned = false`
+     * - `extraData = 0`
+     *
+     * If the `tokenId` is burned:
+     *
+     * - `addr = <Address of owner before token was burned>`
+     * - `startTimestamp = <Timestamp when token was burned>`
+     * - `burned = true`
+     * - `extraData = <Extra data when token was burned>`
+     *
+     * Otherwise:
+     *
+     * - `addr = <Address of owner>`
+     * - `startTimestamp = <Timestamp of start of ownership>`
+     * - `burned = false`
+     * - `extraData = <Extra data at start of ownership>`
+     */
+    function explicitOwnershipOf(uint256 tokenId) external view returns (TokenOwnership memory);
+
+    /**
+     * @dev Returns an array of token IDs owned by `owner`,
+     * in the range [`start`, `stop`)
+     * (i.e. `start <= tokenId < stop`).
+     *
+     * This function allows for tokens to be queried if the collection
+     * grows too big for a single call of {ERC721AQueryable-tokensOfOwner}.
+     *
+     * Requirements:
+     *
+     * - `start < stop`
+     */
+    function tokensOfOwnerIn(address owner, uint256 start, uint256 stop) external view returns (uint256[] memory);
+
+    /**
+     * @dev Returns an array of token IDs owned by `owner`.
+     *
+     * This function scans the ownership mapping and is O(`totalSupply`) in complexity.
+     * It is meant to be called off-chain.
+     *
+     * See {ERC721AQueryable-tokensOfOwnerIn} for splitting the scan into
+     * multiple smaller scans if the collection is large enough to cause
+     * an out-of-gas error (10K collections should be fine).
+     */
+    function tokensOfOwner(address owner) external view returns (uint256[] memory);
+}

package/contracts/eip/queryable/IERC721AUpgradeable.sol

@@ -0,0 +1,269 @@
+// SPDX-License-Identifier: MIT
+// ERC721A Contracts v4.2.3
+// Creator: Chiru Labs
+
+pragma solidity ^0.8.4;
+
+/**
+ * @dev Interface of ERC721A.
+ */
+interface IERC721AUpgradeable {
+    /**
+     * The caller must own the token or be an approved operator.
+     */
+    error ApprovalCallerNotOwnerNorApproved();
+
+    /**
+     * The token does not exist.
+     */
+    error ApprovalQueryForNonexistentToken();
+
+    /**
+     * Cannot query the balance for the zero address.
+     */
+    error BalanceQueryForZeroAddress();
+
+    /**
+     * Cannot mint to the zero address.
+     */
+    error MintToZeroAddress();
+
+    /**
+     * The quantity of tokens minted must be more than zero.
+     */
+    error MintZeroQuantity();
+
+    /**
+     * The token does not exist.
+     */
+    error OwnerQueryForNonexistentToken();
+
+    /**
+     * The caller must own the token or be an approved operator.
+     */
+    error TransferCallerNotOwnerNorApproved();
+
+    /**
+     * The token must be owned by `from`.
+     */
+    error TransferFromIncorrectOwner();
+
+    /**
+     * Cannot safely transfer to a contract that does not implement the
+     * ERC721Receiver interface.
+     */
+    error TransferToNonERC721ReceiverImplementer();
+
+    /**
+     * Cannot transfer to the zero address.
+     */
+    error TransferToZeroAddress();
+
+    /**
+     * The token does not exist.
+     */
+    error URIQueryForNonexistentToken();
+
+    /**
+     * The `quantity` minted with ERC2309 exceeds the safety limit.
+     */
+    error MintERC2309QuantityExceedsLimit();
+
+    /**
+     * The `extraData` cannot be set on an unintialized ownership slot.
+     */
+    error OwnershipNotInitializedForExtraData();
+
+    // =============================================================
+    //                            STRUCTS
+    // =============================================================
+
+    struct TokenOwnership {
+        // The address of the owner.
+        address addr;
+        // Stores the start time of ownership with minimal overhead for tokenomics.
+        uint64 startTimestamp;
+        // Whether the token has been burned.
+        bool burned;
+        // Arbitrary data similar to `startTimestamp` that can be set via {_extraData}.
+        uint24 extraData;
+    }
+
+    // =============================================================
+    //                         TOKEN COUNTERS
+    // =============================================================
+
+    /**
+     * @dev Returns the total number of tokens in existence.
+     * Burned tokens will reduce the count.
+     * To get the total number of tokens minted, please see {_totalMinted}.
+     */
+    function totalSupply() external view returns (uint256);
+
+    // =============================================================
+    //                            IERC165
+    // =============================================================
+
+    /**
+     * @dev Returns true if this contract implements the interface defined by
+     * `interfaceId`. See the corresponding
+     * [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)
+     * to learn more about how these ids are created.
+     *
+     * This function call must use less than 30000 gas.
+     */
+    function supportsInterface(bytes4 interfaceId) external view returns (bool);
+
+    // =============================================================
+    //                            IERC721
+    // =============================================================
+
+    /**
+     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
+     */
+    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
+
+    /**
+     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
+     */
+    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
+
+    /**
+     * @dev Emitted when `owner` enables or disables
+     * (`approved`) `operator` to manage all of its assets.
+     */
+    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
+
+    /**
+     * @dev Returns the number of tokens in `owner`'s account.
+     */
+    function balanceOf(address owner) external view returns (uint256 balance);
+
+    /**
+     * @dev Returns the owner of the `tokenId` token.
+     *
+     * Requirements:
+     *
+     * - `tokenId` must exist.
+     */
+    function ownerOf(uint256 tokenId) external view returns (address owner);
+
+    /**
+     * @dev Safely transfers `tokenId` token from `from` to `to`,
+     * checking first that contract recipients are aware of the ERC721 protocol
+     * to prevent tokens from being forever locked.
+     *
+     * Requirements:
+     *
+     * - `from` cannot be the zero address.
+     * - `to` cannot be the zero address.
+     * - `tokenId` token must exist and be owned by `from`.
+     * - If the caller is not `from`, it must be have been allowed to move
+     * this token by either {approve} or {setApprovalForAll}.
+     * - If `to` refers to a smart contract, it must implement
+     * {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
+     *
+     * Emits a {Transfer} event.
+     */
+    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external payable;
+
+    /**
+     * @dev Equivalent to `safeTransferFrom(from, to, tokenId, '')`.
+     */
+    function safeTransferFrom(address from, address to, uint256 tokenId) external payable;
+
+    /**
+     * @dev Transfers `tokenId` from `from` to `to`.
+     *
+     * WARNING: Usage of this method is discouraged, use {safeTransferFrom}
+     * whenever possible.
+     *
+     * Requirements:
+     *
+     * - `from` cannot be the zero address.
+     * - `to` cannot be the zero address.
+     * - `tokenId` token must be owned by `from`.
+     * - If the caller is not `from`, it must be approved to move this token
+     * by either {approve} or {setApprovalForAll}.
+     *
+     * Emits a {Transfer} event.
+     */
+    function transferFrom(address from, address to, uint256 tokenId) external payable;
+
+    /**
+     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
+     * The approval is cleared when the token is transferred.
+     *
+     * Only a single account can be approved at a time, so approving the
+     * zero address clears previous approvals.
+     *
+     * Requirements:
+     *
+     * - The caller must own the token or be an approved operator.
+     * - `tokenId` must exist.
+     *
+     * Emits an {Approval} event.
+     */
+    function approve(address to, uint256 tokenId) external payable;
+
+    /**
+     * @dev Approve or remove `operator` as an operator for the caller.
+     * Operators can call {transferFrom} or {safeTransferFrom}
+     * for any token owned by the caller.
+     *
+     * Requirements:
+     *
+     * - The `operator` cannot be the caller.
+     *
+     * Emits an {ApprovalForAll} event.
+     */
+    function setApprovalForAll(address operator, bool _approved) external;
+
+    /**
+     * @dev Returns the account approved for `tokenId` token.
+     *
+     * Requirements:
+     *
+     * - `tokenId` must exist.
+     */
+    function getApproved(uint256 tokenId) external view returns (address operator);
+
+    /**
+     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
+     *
+     * See {setApprovalForAll}.
+     */
+    function isApprovedForAll(address owner, address operator) external view returns (bool);
+
+    // =============================================================
+    //                        IERC721Metadata
+    // =============================================================
+
+    /**
+     * @dev Returns the token collection name.
+     */
+    function name() external view returns (string memory);
+
+    /**
+     * @dev Returns the token collection symbol.
+     */
+    function symbol() external view returns (string memory);
+
+    /**
+     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
+     */
+    function tokenURI(uint256 tokenId) external view returns (string memory);
+
+    // =============================================================
+    //                           IERC2309
+    // =============================================================
+
+    /**
+     * @dev Emitted when tokens in `fromTokenId` to `toTokenId`
+     * (inclusive) is transferred from `from` to `to`, as defined in the
+     * [ERC2309](https://eips.ethereum.org/EIPS/eip-2309) standard.
+     *
+     * See {_mintERC2309} for more details.
+     */
+    event ConsecutiveTransfer(uint256 indexed fromTokenId, uint256 toTokenId, address indexed from, address indexed to);
+}

package/contracts/extension/AppURI.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import "./interface/IAppURI.sol";
+
+/**
+ *  Thirdweb's `AppURI` is a contract extension for any contract
+ *  that wants to add an official App URI that follows the appUri spec
+ *
+ */
+
+abstract contract AppURI is IAppURI {
+    /// @dev appURI
+    string public override appURI;
+
+    /// @dev Lets a contract admin set the URI for app metadata.
+    function setAppURI(string memory _uri) public override {
+        if (!_canSetAppURI()) {
+            revert("Not authorized");
+        }
+
+        _setupAppURI(_uri);
+    }
+
+    /// @dev Lets a contract admin set the URI for app metadata.
+    function _setupAppURI(string memory _uri) internal {
+        string memory prevURI = appURI;
+        appURI = _uri;
+
+        emit AppURIUpdated(prevURI, _uri);
+    }
+
+    /// @dev Returns whether appUri can be set in the given execution context.
+    function _canSetAppURI() internal view virtual returns (bool);
+}

package/contracts/extension/BatchMintMetadata.sol

@@ -0,0 +1,143 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+/**
+ *  @title   Batch-mint Metadata
+ *  @notice  The `BatchMintMetadata` is a contract extension for any base NFT contract. It lets the smart contract
+ *           using this extension set metadata for `n` number of NFTs all at once. This is enabled by storing a single
+ *           base URI for a batch of `n` NFTs, where the metadata for each NFT in a relevant batch is `baseURI/tokenId`.
+ */
+
+contract BatchMintMetadata {
+    /// @dev Invalid index for batch
+    error BatchMintInvalidBatchId(uint256 index);
+
+    /// @dev Invalid token
+    error BatchMintInvalidTokenId(uint256 tokenId);
+
+    /// @dev Metadata frozen
+    error BatchMintMetadataFrozen(uint256 batchId);
+
+    /// @dev Largest tokenId of each batch of tokens with the same baseURI + 1 {ex: batchId 100 at position 0 includes tokens 0-99}
+    uint256[] private batchIds;
+
+    /// @dev Mapping from id of a batch of tokens => to base URI for the respective batch of tokens.
+    mapping(uint256 => string) private baseURI;
+
+    /// @dev Mapping from id of a batch of tokens => to whether the base URI for the respective batch of tokens is frozen.
+    mapping(uint256 => bool) public batchFrozen;
+
+    /// @dev This event emits when the metadata of all tokens are frozen.
+    /// While not currently supported by marketplaces, this event allows
+    /// future indexing if desired.
+    event MetadataFrozen();
+
+    // @dev This event emits when the metadata of a range of tokens is updated.
+    /// So that the third-party platforms such as NFT market could
+    /// timely update the images and related attributes of the NFTs.
+    event BatchMetadataUpdate(uint256 _fromTokenId, uint256 _toTokenId);
+
+    /**
+     *  @notice         Returns the count of batches of NFTs.
+     *  @dev            Each batch of tokens has an in ID and an associated `baseURI`.
+     *                  See {batchIds}.
+     */
+    function getBaseURICount() public view returns (uint256) {
+        return batchIds.length;
+    }
+
+    /**
+     *  @notice         Returns the ID for the batch of tokens at the given index.
+     *  @dev            See {getBaseURICount}.
+     *  @param _index   Index of the desired batch in batchIds array.
+     */
+    function getBatchIdAtIndex(uint256 _index) public view returns (uint256) {
+        if (_index >= getBaseURICount()) {
+            revert BatchMintInvalidBatchId(_index);
+        }
+        return batchIds[_index];
+    }
+
+    /// @dev Returns the id for the batch of tokens the given tokenId belongs to.
+    function _getBatchId(uint256 _tokenId) internal view returns (uint256 batchId, uint256 index) {
+        uint256 numOfTokenBatches = getBaseURICount();
+        uint256[] memory indices = batchIds;
+
+        for (uint256 i = 0; i < numOfTokenBatches; i += 1) {
+            if (_tokenId < indices[i]) {
+                index = i;
+                batchId = indices[i];
+
+                return (batchId, index);
+            }
+        }
+
+        revert BatchMintInvalidTokenId(_tokenId);
+    }
+
+    /// @dev Returns the baseURI for a token. The intended metadata URI for the token is baseURI + tokenId.
+    function _getBaseURI(uint256 _tokenId) internal view returns (string memory) {
+        uint256 numOfTokenBatches = getBaseURICount();
+        uint256[] memory indices = batchIds;
+
+        for (uint256 i = 0; i < numOfTokenBatches; i += 1) {
+            if (_tokenId < indices[i]) {
+                return baseURI[indices[i]];
+            }
+        }
+
+        revert BatchMintInvalidTokenId(_tokenId);
+    }
+
+    /// @dev returns the starting tokenId of a given batchId.
+    function _getBatchStartId(uint256 _batchID) internal view returns (uint256) {
+        uint256 numOfTokenBatches = getBaseURICount();
+        uint256[] memory indices = batchIds;
+
+        for (uint256 i = 0; i < numOfTokenBatches; i++) {
+            if (_batchID == indices[i]) {
+                if (i > 0) {
+                    return indices[i - 1];
+                }
+                return 0;
+            }
+        }
+
+        revert BatchMintInvalidBatchId(_batchID);
+    }
+
+    /// @dev Sets the base URI for the batch of tokens with the given batchId.
+    function _setBaseURI(uint256 _batchId, string memory _baseURI) internal {
+        if (batchFrozen[_batchId]) {
+            revert BatchMintMetadataFrozen(_batchId);
+        }
+        baseURI[_batchId] = _baseURI;
+        emit BatchMetadataUpdate(_getBatchStartId(_batchId), _batchId);
+    }
+
+    /// @dev Freezes the base URI for the batch of tokens with the given batchId.
+    function _freezeBaseURI(uint256 _batchId) internal {
+        string memory baseURIForBatch = baseURI[_batchId];
+        if (bytes(baseURIForBatch).length == 0) {
+            revert BatchMintInvalidBatchId(_batchId);
+        }
+        batchFrozen[_batchId] = true;
+        emit MetadataFrozen();
+    }
+
+    /// @dev Mints a batch of tokenIds and associates a common baseURI to all those Ids.
+    function _batchMintMetadata(
+        uint256 _startId,
+        uint256 _amountToMint,
+        string memory _baseURIForTokens
+    ) internal returns (uint256 nextTokenIdToMint, uint256 batchId) {
+        batchId = _startId + _amountToMint;
+        nextTokenIdToMint = batchId;
+
+        batchIds.push(batchId);
+
+        baseURI[batchId] = _baseURIForTokens;
+    }
+}