@rarible/external-contracts 3.11.4

package/contracts/prebuilts/drop/DropERC721.sol

@@ -0,0 +1,397 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.11;
+
+/// @author rarible
+
+// $$$$$$$\                      $$\ $$\       $$\           
+// $$  __$$\                     \__|$$ |      $$ |          
+// $$ |  $$ | $$$$$$\   $$$$$$\  $$\ $$$$$$$\  $$ | $$$$$$\  
+// $$$$$$$  | \____$$\ $$  __$$\ $$ |$$  __$$\ $$ |$$  __$$\ 
+// $$  __$$<  $$$$$$$ |$$ |  \__|$$ |$$ |  $$ |$$ |$$$$$$$$ |
+// $$ |  $$ |$$  __$$ |$$ |      $$ |$$ |  $$ |$$ |$$   ____|
+// $$ |  $$ |\$$$$$$$ |$$ |      $$ |$$$$$$$  |$$ |\$$$$$$$\ 
+// \__|  \__| \_______|\__|      \__|\_______/ \__| \_______|                                                          
+
+//  ==========  External imports    ==========
+
+import "../../extension/Multicall.sol";
+import "@openzeppelin/contracts-upgradeable/utils/StringsUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/interfaces/IERC2981Upgradeable.sol";
+
+import "../../eip/ERC721AVirtualApproveUpgradeable.sol";
+
+//  ==========  Internal imports    ==========
+
+import "../../external-deps/openzeppelin/metatx/ERC2771ContextUpgradeable.sol";
+import "../../lib/CurrencyTransferLib.sol";
+
+//  ==========  Features    ==========
+
+import "../../extension/ContractMetadata.sol";
+import "../../extension/PlatformFee.sol";
+import "../../extension/Royalty.sol";
+import "../../extension/PrimarySale.sol";
+import "../../extension/Ownable.sol";
+import "../../extension/DelayedReveal.sol";
+import "../../extension/LazyMint.sol";
+import "../../extension/PermissionsEnumerable.sol";
+import "../../extension/Drop.sol";
+
+contract DropERC721 is
+    Initializable,
+    ContractMetadata,
+    PlatformFee,
+    Royalty,
+    PrimarySale,
+    Ownable,
+    DelayedReveal,
+    LazyMint,
+    PermissionsEnumerable,
+    Drop,
+    ERC2771ContextUpgradeable,
+    Multicall,
+    ERC721AUpgradeable
+{
+    using StringsUpgradeable for uint256;
+
+    /*///////////////////////////////////////////////////////////////
+                            State variables
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev Only transfers to or from TRANSFER_ROLE holders are valid, when transfers are restricted.
+    bytes32 private transferRole;
+    /// @dev Only MINTER_ROLE holders can sign off on `MintRequest`s and lazy mint tokens.
+    bytes32 private minterRole;
+    /// @dev Only METADATA_ROLE holders can reveal the URI for a batch of delayed reveal NFTs, and update or freeze batch metadata.
+    bytes32 private metadataRole;
+
+    /// @dev Max bps in the thirdweb system.
+    uint256 private constant MAX_BPS = 10_000;
+
+    address public constant DEFAULT_FEE_RECIPIENT = 0x1Af20C6B23373350aD464700B5965CE4B0D2aD94;
+    uint16 private constant DEFAULT_FEE_BPS = 100;
+
+    /// @dev Global max total supply of NFTs.
+    uint256 public maxTotalSupply;
+
+    /// @dev Emitted when the global max supply of tokens is updated.
+    event MaxTotalSupplyUpdated(uint256 maxTotalSupply);
+
+    /*///////////////////////////////////////////////////////////////
+                    Constructor + initializer logic
+    //////////////////////////////////////////////////////////////*/
+
+    constructor() initializer {}
+
+    /// @dev Initializes the contract, like a constructor.
+    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 {
+        bytes32 _transferRole = keccak256("TRANSFER_ROLE");
+        bytes32 _minterRole = keccak256("MINTER_ROLE");
+        bytes32 _metadataRole = keccak256("METADATA_ROLE");
+
+        // Initialize inherited contracts, most base-like -> most derived.
+        __ERC2771Context_init(_trustedForwarders);
+        __ERC721A_init(_name, _symbol);
+
+        _setupContractURI(_contractURI);
+        _setupOwner(_defaultAdmin);
+
+        _setupRole(DEFAULT_ADMIN_ROLE, _defaultAdmin);
+        _setupRole(_minterRole, _defaultAdmin);
+        _setupRole(_transferRole, _defaultAdmin);
+        _setupRole(_transferRole, address(0));
+        _setupRole(_metadataRole, _defaultAdmin);
+        _setRoleAdmin(_metadataRole, _metadataRole);
+
+        _setupPlatformFeeInfo(_platformFeeRecipient, _platformFeeBps);
+        _setupDefaultRoyaltyInfo(_royaltyRecipient, _royaltyBps);
+        _setupPrimarySaleRecipient(_saleRecipient);
+
+        transferRole = _transferRole;
+        minterRole = _minterRole;
+        metadataRole = _metadataRole;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                        ERC 165 / 721 / 2981 logic
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev Returns the URI for a given tokenId.
+    function tokenURI(uint256 _tokenId) public view override returns (string memory) {
+        (uint256 batchId, ) = _getBatchId(_tokenId);
+        string memory batchUri = _getBaseURI(_tokenId);
+
+        if (isEncryptedBatch(batchId)) {
+            return string(abi.encodePacked(batchUri, "0"));
+        } else {
+            return string(abi.encodePacked(batchUri, _tokenId.toString()));
+        }
+    }
+
+    /// @dev See ERC 165
+    function supportsInterface(
+        bytes4 interfaceId
+    ) public view virtual override(ERC721AUpgradeable, IERC165) returns (bool) {
+        return super.supportsInterface(interfaceId) || type(IERC2981Upgradeable).interfaceId == interfaceId;
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                        Contract identifiers
+    //////////////////////////////////////////////////////////////*/
+
+    function contractType() external pure returns (bytes32) {
+        return bytes32("DropERC721");
+    }
+
+    function contractVersion() external pure returns (uint8) {
+        return uint8(4);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                    Lazy minting + delayed-reveal logic
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     *  @dev Lets an account with `MINTER_ROLE` lazy mint 'n' NFTs.
+     *       The URIs for each token is the provided `_baseURIForTokens` + `{tokenId}`.
+     */
+    function lazyMint(
+        uint256 _amount,
+        string calldata _baseURIForTokens,
+        bytes calldata _data
+    ) public override returns (uint256 batchId) {
+        if (_data.length > 0) {
+            (bytes memory encryptedURI, bytes32 provenanceHash) = abi.decode(_data, (bytes, bytes32));
+            if (encryptedURI.length != 0 && provenanceHash != "") {
+                _setEncryptedData(nextTokenIdToLazyMint + _amount, _data);
+            }
+        }
+
+        return super.lazyMint(_amount, _baseURIForTokens, _data);
+    }
+
+    /// @dev Lets an account with `METADATA_ROLE` reveal the URI for a batch of 'delayed-reveal' NFTs.
+    /// @param _index the ID of a token with the desired batch.
+    /// @param _key the key to decrypt the batch's URI.
+    function reveal(
+        uint256 _index,
+        bytes calldata _key
+    ) external onlyRole(metadataRole) returns (string memory revealedURI) {
+        uint256 batchId = getBatchIdAtIndex(_index);
+        revealedURI = getRevealURI(batchId, _key);
+
+        _setEncryptedData(batchId, "");
+        _setBaseURI(batchId, revealedURI);
+
+        emit TokenURIRevealed(_index, revealedURI);
+    }
+
+    /**
+     * @notice Updates the base URI for a batch of tokens. Can only be called if the batch has been revealed/is not encrypted.
+     *
+     * @param _index Index of the desired batch in batchIds array
+     * @param _uri   the new base URI for the batch.
+     */
+    function updateBatchBaseURI(uint256 _index, string calldata _uri) external onlyRole(metadataRole) {
+        require(!isEncryptedBatch(getBatchIdAtIndex(_index)), "Encrypted batch");
+        uint256 batchId = getBatchIdAtIndex(_index);
+        _setBaseURI(batchId, _uri);
+    }
+
+    /**
+     * @notice Freezes the base URI for a batch of tokens.
+     *
+     * @param _index Index of the desired batch in batchIds array.
+     */
+    function freezeBatchBaseURI(uint256 _index) external onlyRole(metadataRole) {
+        require(!isEncryptedBatch(getBatchIdAtIndex(_index)), "Encrypted batch");
+        uint256 batchId = getBatchIdAtIndex(_index);
+        _freezeBaseURI(batchId);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                        Setter functions
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev Lets a contract admin set the global maximum supply for collection's NFTs.
+    function setMaxTotalSupply(uint256 _maxTotalSupply) external onlyRole(DEFAULT_ADMIN_ROLE) {
+        maxTotalSupply = _maxTotalSupply;
+        emit MaxTotalSupplyUpdated(_maxTotalSupply);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                        Internal functions
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev Runs before every `claim` function call.
+    function _beforeClaim(
+        address,
+        uint256 _quantity,
+        address,
+        uint256,
+        AllowlistProof calldata,
+        bytes memory
+    ) internal view override {
+        require(_currentIndex + _quantity <= nextTokenIdToLazyMint, "!Tokens");
+        require(maxTotalSupply == 0 || _currentIndex + _quantity <= maxTotalSupply, "!Supply");
+    }
+
+    /// @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, "!V");
+            return;
+        }
+
+        (address platformFeeRecipient, uint16 platformFeeBps) = getPlatformFeeInfo();
+
+        address saleRecipient = _primarySaleRecipient == address(0) ? primarySaleRecipient() : _primarySaleRecipient;
+
+        uint256 totalPrice = _quantityToClaim * _pricePerToken;
+        uint256 platformFees = (totalPrice * platformFeeBps) / MAX_BPS;
+
+        bool validMsgValue;
+        if (_currency == CurrencyTransferLib.NATIVE_TOKEN) {
+            validMsgValue = msg.value == totalPrice;
+        } else {
+            validMsgValue = msg.value == 0;
+        }
+        require(validMsgValue, "!V");
+
+        CurrencyTransferLib.transferCurrency(_currency, _msgSender(), platformFeeRecipient, platformFees);
+        CurrencyTransferLib.transferCurrency(
+            _currency,
+            _msgSender(),
+            saleRecipient,
+            totalPrice - platformFees
+        );
+    }
+
+    /// @dev Transfers the NFTs being claimed.
+    function _transferTokensOnClaim(
+        address _to,
+        uint256 _quantityBeingClaimed
+    ) internal override returns (uint256 startTokenId) {
+        startTokenId = _currentIndex;
+        _safeMint(_to, _quantityBeingClaimed);
+    }
+
+    /// @dev Checks whether platform fee info can be set in the given execution context.
+    function _canSetPlatformFeeInfo() internal view override returns (bool) {
+        return hasRole(DEFAULT_ADMIN_ROLE, _msgSender());
+    }
+
+    /// @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 lazy minting can be done in the given execution context.
+    function _canLazyMint() internal view virtual override returns (bool) {
+        return hasRole(minterRole, _msgSender());
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                        Miscellaneous
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * Returns the total amount of tokens minted in the contract.
+     */
+    function totalMinted() external view returns (uint256) {
+        return _totalMinted();
+    }
+
+    /// @dev The tokenId of the next NFT that will be minted / lazy minted.
+    function nextTokenIdToMint() external view returns (uint256) {
+        return nextTokenIdToLazyMint;
+    }
+
+    /// @dev The next token ID of the NFT that can be claimed.
+    function nextTokenIdToClaim() external view returns (uint256) {
+        return _currentIndex;
+    }
+
+    /// @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(transferRole, address(0)) && from != address(0) && to != address(0)) {
+            if (!hasRole(transferRole, from) && !hasRole(transferRole, to)) {
+                revert("!Transfer-Role");
+            }
+        }
+    }
+
+    function _dropMsgSender() internal view virtual override returns (address) {
+        return _msgSender();
+    }
+
+    function _msgSender()
+        internal
+        view
+        virtual
+        override(ContextUpgradeable, ERC2771ContextUpgradeable, Multicall)
+        returns (address sender)
+    {
+        return ERC2771ContextUpgradeable._msgSender();
+    }
+
+    function _msgData()
+        internal
+        view
+        virtual
+        override(ContextUpgradeable, ERC2771ContextUpgradeable)
+        returns (bytes calldata)
+    {
+        return ERC2771ContextUpgradeable._msgData();
+    }
+}

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

@@ -0,0 +1,101 @@
+// 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/init/ContractMetadataInit.sol";
+import "../../extension/upgradeable/init/RoyaltyInit.sol";
+import "../../extension/upgradeable/init/PrimarySaleInit.sol";
+import "../../extension/upgradeable/init/OwnableInit.sol";
+import "../../extension/upgradeable/init/PermissionsEnumerableInit.sol";
+import "../../extension/upgradeable/init/ERC2771ContextInit.sol";
+import "../../extension/upgradeable/init/ERC721AQueryableInit.sol";
+
+contract EvolvingNFT is
+    Initializable,
+    BaseRouter,
+    Multicall,
+    ERC721AQueryableInit,
+    ERC2771ContextInit,
+    ContractMetadataInit,
+    RoyaltyInit,
+    PrimarySaleInit,
+    OwnableInit,
+    PermissionsEnumerableInit
+{
+    /// @dev Only EXTENSION_ROLE holders can update the contract's extensions.
+    bytes32 private constant EXTENSION_ROLE = keccak256("EXTENSION_ROLE");
+
+    constructor(Extension[] memory _extensions) BaseRouter(_extensions) {
+        _disableInitializers();
+    }
+
+    /// @dev Initializes the contract, like a constructor.
+    function initialize(
+        address _defaultAdmin,
+        string memory _name,
+        string memory _symbol,
+        string memory _contractURI,
+        address[] memory _trustedForwarders,
+        address _saleRecipient,
+        address _royaltyRecipient,
+        uint128 _royaltyBps
+    ) external initializer initializerERC721A {
+        bytes32 _transferRole = keccak256("TRANSFER_ROLE");
+
+        // Initialize extensions
+        __BaseRouter_init();
+
+        // Initialize inherited contracts, most base-like -> most derived.
+        __ERC2771Context_init(_trustedForwarders);
+        __ERC721A_init(_name, _symbol);
+
+        _setupContractURI(_contractURI);
+        _setupOwner(_defaultAdmin);
+
+        _setupRole(DEFAULT_ADMIN_ROLE, _defaultAdmin);
+        _setupRole(EXTENSION_ROLE, _defaultAdmin);
+        _setupRole(keccak256("MINTER_ROLE"), _defaultAdmin);
+        _setupRole(_transferRole, _defaultAdmin);
+        _setupRole(_transferRole, address(0));
+
+        _setupDefaultRoyaltyInfo(_royaltyRecipient, _royaltyBps);
+        _setupPrimarySaleRecipient(_saleRecipient);
+
+        _setupRole(EXTENSION_ROLE, _defaultAdmin);
+        _setRoleAdmin(EXTENSION_ROLE, EXTENSION_ROLE);
+    }
+
+    /*///////////////////////////////////////////////////////////////
+                        Internal functions
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev The start token ID for the contract.
+    function _startTokenId() internal pure override returns (uint256) {
+        return 1;
+    }
+
+    /// @dev Returns whether all relevant permission and other checks are met before any upgrade.
+    function _isAuthorizedCallToUpgrade() internal view virtual override returns (bool) {
+        return _hasRole(EXTENSION_ROLE, 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];
+    }
+}