@rarible/external-contracts 3.11.4

package/contracts/extension/DropSinglePhase1155.sol

@@ -0,0 +1,215 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import "./interface/IDropSinglePhase1155.sol";
+import "../lib/MerkleProof.sol";
+
+abstract contract DropSinglePhase1155 is IDropSinglePhase1155 {
+    /*///////////////////////////////////////////////////////////////
+                                Mappings
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev Mapping from tokenId => active claim condition for the tokenId.
+    mapping(uint256 => ClaimCondition) public claimCondition;
+
+    /// @dev Mapping from tokenId => active claim condition's UID.
+    mapping(uint256 => bytes32) private conditionId;
+
+    /**
+     *  @dev Map from a claim condition uid and account to supply claimed by account.
+     */
+    mapping(bytes32 => mapping(address => uint256)) private supplyClaimedByWallet;
+
+    /*///////////////////////////////////////////////////////////////
+                            Drop logic
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev Lets an account claim tokens.
+    function claim(
+        address _receiver,
+        uint256 _tokenId,
+        uint256 _quantity,
+        address _currency,
+        uint256 _pricePerToken,
+        AllowlistProof calldata _allowlistProof,
+        bytes memory _data
+    ) public payable virtual override {
+        _beforeClaim(_tokenId, _receiver, _quantity, _currency, _pricePerToken, _allowlistProof, _data);
+
+        ClaimCondition memory condition = claimCondition[_tokenId];
+        bytes32 activeConditionId = conditionId[_tokenId];
+
+        verifyClaim(_tokenId, _dropMsgSender(), _quantity, _currency, _pricePerToken, _allowlistProof);
+
+        // Update contract state.
+        condition.supplyClaimed += _quantity;
+        supplyClaimedByWallet[activeConditionId][_dropMsgSender()] += _quantity;
+        claimCondition[_tokenId] = condition;
+
+        // If there's a price, collect price.
+        _collectPriceOnClaim(address(0), _quantity, _currency, _pricePerToken);
+
+        // Mint the relevant NFTs to claimer.
+        _transferTokensOnClaim(_receiver, _tokenId, _quantity);
+
+        emit TokensClaimed(_dropMsgSender(), _receiver, _tokenId, _quantity);
+
+        _afterClaim(_tokenId, _receiver, _quantity, _currency, _pricePerToken, _allowlistProof, _data);
+    }
+
+    /// @dev Lets a contract admin set claim conditions.
+    function setClaimConditions(
+        uint256 _tokenId,
+        ClaimCondition calldata _condition,
+        bool _resetClaimEligibility
+    ) external override {
+        if (!_canSetClaimConditions()) {
+            revert("Not authorized");
+        }
+
+        ClaimCondition memory condition = claimCondition[_tokenId];
+        bytes32 targetConditionId = conditionId[_tokenId];
+
+        uint256 supplyClaimedAlready = condition.supplyClaimed;
+
+        if (targetConditionId == bytes32(0) || _resetClaimEligibility) {
+            supplyClaimedAlready = 0;
+            targetConditionId = keccak256(abi.encodePacked(_dropMsgSender(), block.number, _tokenId));
+        }
+
+        if (supplyClaimedAlready > _condition.maxClaimableSupply) {
+            revert("max supply claimed");
+        }
+
+        ClaimCondition memory updatedCondition = ClaimCondition({
+            startTimestamp: _condition.startTimestamp,
+            maxClaimableSupply: _condition.maxClaimableSupply,
+            supplyClaimed: supplyClaimedAlready,
+            quantityLimitPerWallet: _condition.quantityLimitPerWallet,
+            merkleRoot: _condition.merkleRoot,
+            pricePerToken: _condition.pricePerToken,
+            currency: _condition.currency,
+            metadata: _condition.metadata
+        });
+
+        claimCondition[_tokenId] = updatedCondition;
+        conditionId[_tokenId] = targetConditionId;
+
+        emit ClaimConditionUpdated(_tokenId, _condition, _resetClaimEligibility);
+    }
+
+    /// @dev Checks a request to claim NFTs against the active claim condition's criteria.
+    function verifyClaim(
+        uint256 _tokenId,
+        address _claimer,
+        uint256 _quantity,
+        address _currency,
+        uint256 _pricePerToken,
+        AllowlistProof calldata _allowlistProof
+    ) public view virtual returns (bool isOverride) {
+        ClaimCondition memory currentClaimPhase = claimCondition[_tokenId];
+        uint256 claimLimit = currentClaimPhase.quantityLimitPerWallet;
+        uint256 claimPrice = currentClaimPhase.pricePerToken;
+        address claimCurrency = currentClaimPhase.currency;
+
+        /*
+         * Here `isOverride` implies that if the merkle proof verification fails,
+         * the claimer would claim through open claim limit instead of allowlisted limit.
+         */
+        if (currentClaimPhase.merkleRoot != bytes32(0)) {
+            (isOverride, ) = MerkleProof.verify(
+                _allowlistProof.proof,
+                currentClaimPhase.merkleRoot,
+                keccak256(
+                    abi.encodePacked(
+                        _claimer,
+                        _allowlistProof.quantityLimitPerWallet,
+                        _allowlistProof.pricePerToken,
+                        _allowlistProof.currency
+                    )
+                )
+            );
+        }
+
+        if (isOverride) {
+            claimLimit = _allowlistProof.quantityLimitPerWallet != 0
+                ? _allowlistProof.quantityLimitPerWallet
+                : claimLimit;
+            claimPrice = _allowlistProof.pricePerToken != type(uint256).max
+                ? _allowlistProof.pricePerToken
+                : claimPrice;
+            claimCurrency = _allowlistProof.pricePerToken != type(uint256).max && _allowlistProof.currency != address(0)
+                ? _allowlistProof.currency
+                : claimCurrency;
+        }
+
+        uint256 _supplyClaimedByWallet = supplyClaimedByWallet[conditionId[_tokenId]][_claimer];
+
+        if (_currency != claimCurrency || _pricePerToken != claimPrice) {
+            revert("!PriceOrCurrency");
+        }
+
+        if (_quantity == 0 || (_quantity + _supplyClaimedByWallet > claimLimit)) {
+            revert("!Qty");
+        }
+
+        if (currentClaimPhase.supplyClaimed + _quantity > currentClaimPhase.maxClaimableSupply) {
+            revert("!MaxSupply");
+        }
+
+        if (currentClaimPhase.startTimestamp > block.timestamp) {
+            revert("cant claim yet");
+        }
+    }
+
+    /// @dev Returns the supply claimed by claimer for active conditionId.
+    function getSupplyClaimedByWallet(uint256 _tokenId, address _claimer) public view returns (uint256) {
+        return supplyClaimedByWallet[conditionId[_tokenId]][_claimer];
+    }
+
+    /*////////////////////////////////////////////////////////////////////
+        Optional hooks that can be implemented in the derived contract
+    ///////////////////////////////////////////////////////////////////*/
+
+    /// @dev Exposes the ability to override the msg sender.
+    function _dropMsgSender() internal virtual returns (address) {
+        return msg.sender;
+    }
+
+    /// @dev Runs before every `claim` function call.
+    function _beforeClaim(
+        uint256 _tokenId,
+        address _receiver,
+        uint256 _quantity,
+        address _currency,
+        uint256 _pricePerToken,
+        AllowlistProof calldata _allowlistProof,
+        bytes memory _data
+    ) internal virtual {}
+
+    /// @dev Runs after every `claim` function call.
+    function _afterClaim(
+        uint256 _tokenId,
+        address _receiver,
+        uint256 _quantity,
+        address _currency,
+        uint256 _pricePerToken,
+        AllowlistProof calldata _allowlistProof,
+        bytes memory _data
+    ) internal virtual {}
+
+    /// @dev Collects and distributes the primary sale value of NFTs being claimed.
+    function _collectPriceOnClaim(
+        address _primarySaleRecipient,
+        uint256 _quantityToClaim,
+        address _currency,
+        uint256 _pricePerToken
+    ) internal virtual;
+
+    /// @dev Transfers the NFTs being claimed.
+    function _transferTokensOnClaim(address _to, uint256 _tokenId, uint256 _quantityBeingClaimed) internal virtual;
+
+    function _canSetClaimConditions() internal view virtual returns (bool);
+}

package/contracts/extension/Initializable.sol

@@ -0,0 +1,136 @@
+// SPDX-License-Identifier: Apache 2.0
+pragma solidity ^0.8.0;
+
+import "../lib/Address.sol";
+
+/**
+ * @dev This is a base contract to aid in writing upgradeable 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.
+ *
+ * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
+ * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
+ * case an upgrade adds a module that needs to be initialized.
+ *
+ * For example:
+ *
+ * [.hljs-theme-light.nopadding]
+ * ```
+ * contract MyToken is ERC20Upgradeable {
+ *     function initialize() initializer public {
+ *         __ERC20_init("MyToken", "MTK");
+ *     }
+ * }
+ * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
+ *     function initializeV2() reinitializer(2) public {
+ *         __ERC20Permit_init("MyToken");
+ *     }
+ * }
+ * ```
+ *
+ * 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.
+ *
+ * [CAUTION]
+ * ====
+ * Avoid leaving a contract uninitialized.
+ *
+ * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
+ * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
+ * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
+ *
+ * [.hljs-theme-light.nopadding]
+ * ```
+ * /// @custom:oz-upgrades-unsafe-allow constructor
+ * constructor() {
+ *     _disableInitializers();
+ * }
+ * ```
+ * ====
+ */
+abstract contract Initializable {
+    /**
+     * @dev Indicates that the contract has been initialized.
+     * @custom:oz-retyped-from bool
+     */
+    uint8 private _initialized;
+
+    /**
+     * @dev Indicates that the contract is in the process of being initialized.
+     */
+    bool private _initializing;
+
+    /**
+     * @dev Triggered when the contract has been initialized or reinitialized.
+     */
+    event Initialized(uint8 version);
+
+    /**
+     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
+     * `onlyInitializing` functions can be used to initialize parent contracts. Equivalent to `reinitializer(1)`.
+     */
+    modifier initializer() {
+        bool isTopLevelCall = !_initializing;
+        require(
+            (isTopLevelCall && _initialized < 1) || (!Address.isContract(address(this)) && _initialized == 1),
+            "Initializable: contract is already initialized"
+        );
+        _initialized = 1;
+        if (isTopLevelCall) {
+            _initializing = true;
+        }
+        _;
+        if (isTopLevelCall) {
+            _initializing = false;
+            emit Initialized(1);
+        }
+    }
+
+    /**
+     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
+     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
+     * used to initialize parent contracts.
+     *
+     * `initializer` is equivalent to `reinitializer(1)`, so a reinitializer may be used after the original
+     * initialization step. This is essential to configure modules that are added through upgrades and that require
+     * initialization.
+     *
+     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
+     * a contract, executing them in the right order is up to the developer or operator.
+     */
+    modifier reinitializer(uint8 version) {
+        require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
+        _initialized = version;
+        _initializing = true;
+        _;
+        _initializing = false;
+        emit Initialized(version);
+    }
+
+    /**
+     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
+     * {initializer} and {reinitializer} modifiers, directly or indirectly.
+     */
+    modifier onlyInitializing() {
+        require(_initializing, "Initializable: contract is not initializing");
+        _;
+    }
+
+    /**
+     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
+     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
+     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called
+     * through proxies.
+     */
+    function _disableInitializers() internal virtual {
+        require(!_initializing, "Initializable: contract is initializing");
+        if (_initialized < type(uint8).max) {
+            _initialized = type(uint8).max;
+            emit Initialized(type(uint8).max);
+        }
+    }
+}

package/contracts/extension/LazyMint.sol

@@ -0,0 +1,56 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import "./interface/ILazyMint.sol";
+import "./BatchMintMetadata.sol";
+
+/**
+ *  The `LazyMint` is a contract extension for any base NFT contract. It lets you 'lazy mint' any number of NFTs
+ *  at once. Here, 'lazy mint' means defining the metadata for particular tokenIds of your NFT contract, without actually
+ *  minting a non-zero balance of NFTs of those tokenIds.
+ */
+
+abstract contract LazyMint is ILazyMint, BatchMintMetadata {
+    /// @dev The sender is not authorized to perform the action
+    error LazyMintUnauthorized();
+    error LazyMintInvalidAmount();
+
+    /// @notice The tokenId assigned to the next new NFT to be lazy minted.
+    uint256 internal nextTokenIdToLazyMint;
+
+    /**
+     *  @notice                  Lets an authorized address lazy mint a given amount of NFTs.
+     *
+     *  @param _amount           The number of NFTs to lazy mint.
+     *  @param _baseURIForTokens The base URI for the 'n' number of NFTs being lazy minted, where the metadata for each
+     *                           of those NFTs is `${baseURIForTokens}/${tokenId}`.
+     *  @param _data             Additional bytes data to be used at the discretion of the consumer of the contract.
+     *  @return batchId          A unique integer identifier for the batch of NFTs lazy minted together.
+     */
+    function lazyMint(
+        uint256 _amount,
+        string calldata _baseURIForTokens,
+        bytes calldata _data
+    ) public virtual override returns (uint256 batchId) {
+        if (!_canLazyMint()) {
+            revert LazyMintUnauthorized();
+        }
+
+        if (_amount == 0) {
+            revert LazyMintInvalidAmount();
+        }
+
+        uint256 startId = nextTokenIdToLazyMint;
+
+        (nextTokenIdToLazyMint, batchId) = _batchMintMetadata(startId, _amount, _baseURIForTokens);
+
+        emit TokensLazyMinted(startId, startId + _amount - 1, _baseURIForTokens, _data);
+
+        return batchId;
+    }
+
+    /// @dev Returns whether lazy minting can be performed in the given execution context.
+    function _canLazyMint() internal view virtual returns (bool);
+}

package/contracts/extension/LazyMintWithTier.sol

@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import "./interface/ILazyMintWithTier.sol";
+import "../extension/BatchMintMetadata.sol";
+
+/**
+ *  The `LazyMint` is a contract extension for any base NFT contract. It lets you 'lazy mint' any number of NFTs
+ *  at once. Here, 'lazy mint' means defining the metadata for particular tokenIds of your NFT contract, without actually
+ *  minting a non-zero balance of NFTs of those tokenIds.
+ */
+
+abstract contract LazyMintWithTier is ILazyMintWithTier, BatchMintMetadata {
+    struct TokenRange {
+        uint256 startIdInclusive;
+        uint256 endIdNonInclusive;
+    }
+
+    struct TierMetadata {
+        string tier;
+        TokenRange[] ranges;
+        string[] baseURIs;
+    }
+
+    /// @notice The tokenId assigned to the next new NFT to be lazy minted.
+    uint256 internal nextTokenIdToLazyMint;
+
+    /// @notice Mapping from a tier -> the token IDs grouped under that tier.
+    mapping(string => TokenRange[]) internal tokensInTier;
+
+    /// @notice A list of tiers used in this contract.
+    string[] private tiers;
+
+    /**
+     *  @notice                  Lets an authorized address lazy mint a given amount of NFTs.
+     *
+     *  @param _amount           The number of NFTs to lazy mint.
+     *  @param _baseURIForTokens The base URI for the 'n' number of NFTs being lazy minted, where the metadata for each
+     *                           of those NFTs is `${baseURIForTokens}/${tokenId}`.
+     *  @param _data             Additional bytes data to be used at the discretion of the consumer of the contract.
+     *  @return batchId          A unique integer identifier for the batch of NFTs lazy minted together.
+     */
+    function lazyMint(
+        uint256 _amount,
+        string calldata _baseURIForTokens,
+        string calldata _tier,
+        bytes calldata _data
+    ) public virtual override returns (uint256 batchId) {
+        if (!_canLazyMint()) {
+            revert("Not authorized");
+        }
+
+        if (_amount == 0) {
+            revert("0 amt");
+        }
+
+        uint256 startId = nextTokenIdToLazyMint;
+
+        (nextTokenIdToLazyMint, batchId) = _batchMintMetadata(startId, _amount, _baseURIForTokens);
+
+        // Handle tier info.
+        if (!(tokensInTier[_tier].length > 0)) {
+            tiers.push(_tier);
+        }
+        tokensInTier[_tier].push(TokenRange(startId, batchId));
+
+        emit TokensLazyMinted(_tier, startId, startId + _amount - 1, _baseURIForTokens, _data);
+
+        return batchId;
+    }
+
+    /// @notice Returns all metadata lazy minted for the given tier.
+    function _getMetadataInTier(
+        string memory _tier
+    ) private view returns (TokenRange[] memory tokens, string[] memory baseURIs) {
+        tokens = tokensInTier[_tier];
+
+        uint256 len = tokens.length;
+        baseURIs = new string[](len);
+
+        for (uint256 i = 0; i < len; i += 1) {
+            baseURIs[i] = _getBaseURI(tokens[i].startIdInclusive);
+        }
+    }
+
+    /// @notice Returns all metadata for all tiers created on the contract.
+    function getMetadataForAllTiers() external view returns (TierMetadata[] memory metadataForAllTiers) {
+        string[] memory allTiers = tiers;
+        uint256 len = allTiers.length;
+
+        metadataForAllTiers = new TierMetadata[](len);
+
+        for (uint256 i = 0; i < len; i += 1) {
+            (TokenRange[] memory tokens, string[] memory baseURIs) = _getMetadataInTier(allTiers[i]);
+            metadataForAllTiers[i] = TierMetadata(allTiers[i], tokens, baseURIs);
+        }
+    }
+
+    /**
+     *  @notice Returns whether any metadata is lazy minted for the given tier.
+     *
+     *  @param _tier We check whether this given tier is empty.
+     */
+    function isTierEmpty(string memory _tier) internal view returns (bool) {
+        return tokensInTier[_tier].length == 0;
+    }
+
+    /// @dev Returns whether lazy minting can be performed in the given execution context.
+    function _canLazyMint() internal view virtual returns (bool);
+}

package/contracts/extension/Multicall.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: Apache 2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import "../lib/Address.sol";
+import "./interface/IMulticall.sol";
+
+/**
+ * @dev Provides a function to batch together multiple calls in a single external call.
+ *
+ * _Available since v4.1._
+ */
+contract Multicall is IMulticall {
+    /**
+     *  @notice Receives and executes a batch of function calls on this contract.
+     *  @dev Receives and executes a batch of function calls on this contract.
+     *
+     *  @param data The bytes data that makes up the batch of function calls to execute.
+     *  @return results The bytes data that makes up the result of the batch of function calls executed.
+     */
+    function multicall(bytes[] calldata data) external returns (bytes[] memory results) {
+        results = new bytes[](data.length);
+        address sender = _msgSender();
+        bool isForwarder = msg.sender != sender;
+        for (uint256 i = 0; i < data.length; i++) {
+            if (isForwarder) {
+                results[i] = Address.functionDelegateCall(address(this), abi.encodePacked(data[i], sender));
+            } else {
+                results[i] = Address.functionDelegateCall(address(this), data[i]);
+            }
+        }
+        return results;
+    }
+
+    /// @notice Returns the sender in the given execution context.
+    function _msgSender() internal view virtual returns (address) {
+        return msg.sender;
+    }
+}

package/contracts/extension/NFTMetadata.sol

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+import "./interface/INFTMetadata.sol";
+
+abstract contract NFTMetadata is INFTMetadata {
+    /// @dev The sender is not authorized to perform the action
+    error NFTMetadataUnauthorized();
+
+    /// @dev Invalid token metadata url
+    error NFTMetadataInvalidUrl();
+
+    /// @dev the nft metadata is frozen
+    error NFTMetadataFrozen(uint256 tokenId);
+
+    bool public uriFrozen;
+
+    mapping(uint256 => string) internal _tokenURI;
+
+    /// @notice Returns the metadata URI for a given NFT.
+    function _getTokenURI(uint256 _tokenId) internal view virtual returns (string memory) {
+        return _tokenURI[_tokenId];
+    }
+
+    /// @notice Sets the metadata URI for a given NFT.
+    function _setTokenURI(uint256 _tokenId, string memory _uri) internal virtual {
+        if (bytes(_uri).length == 0) {
+            revert NFTMetadataInvalidUrl();
+        }
+        _tokenURI[_tokenId] = _uri;
+
+        emit MetadataUpdate(_tokenId);
+    }
+
+    /// @notice Sets the metadata URI for a given NFT.
+    function setTokenURI(uint256 _tokenId, string memory _uri) public virtual {
+        if (!_canSetMetadata()) {
+            revert NFTMetadataUnauthorized();
+        }
+        if (uriFrozen) {
+            revert NFTMetadataFrozen(_tokenId);
+        }
+        _setTokenURI(_tokenId, _uri);
+    }
+
+    function freezeMetadata() public virtual {
+        if (!_canFreezeMetadata()) {
+            revert NFTMetadataUnauthorized();
+        }
+        uriFrozen = true;
+        emit MetadataFrozen();
+    }
+
+    /// @dev Returns whether metadata can be set in the given execution context.
+    function _canSetMetadata() internal view virtual returns (bool);
+
+    function _canFreezeMetadata() internal view virtual returns (bool);
+}

package/contracts/extension/OperatorFilterToggle.sol

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: Apache 2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import "./interface/IOperatorFilterToggle.sol";
+
+abstract contract OperatorFilterToggle is IOperatorFilterToggle {
+    bool public operatorRestriction;
+
+    function setOperatorRestriction(bool _restriction) external {
+        require(_canSetOperatorRestriction(), "Not authorized to set operator restriction.");
+        _setOperatorRestriction(_restriction);
+    }
+
+    function _setOperatorRestriction(bool _restriction) internal {
+        operatorRestriction = _restriction;
+        emit OperatorRestriction(_restriction);
+    }
+
+    function _canSetOperatorRestriction() internal virtual returns (bool);
+}