@rarible/external-contracts 3.11.4

package/contracts/base/ERC1155LazyMint.sol

@@ -0,0 +1,286 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import { ERC1155 } from "../eip/ERC1155.sol";
+
+import "../extension/ContractMetadata.sol";
+import "../extension/Multicall.sol";
+import "../extension/Ownable.sol";
+import "../extension/Royalty.sol";
+import "../extension/BatchMintMetadata.sol";
+import "../extension/LazyMint.sol";
+import "../extension/interface/IClaimableERC1155.sol";
+
+import "../lib/Strings.sol";
+import "../external-deps/openzeppelin/security/ReentrancyGuard.sol";
+
+/**
+ *      BASE:      ERC1155Base
+ *      EXTENSION: LazyMint
+ *
+ *  The `ERC1155LazyMint` smart contract implements the ERC1155 NFT standard.
+ *  It includes the following additions to standard ERC1155 logic:
+ *
+ *      - Lazy minting
+ *
+ *      - Ability to mint NFTs via the provided `mintTo` and `batchMintTo` functions.
+ *
+ *      - Contract metadata for royalty support on platforms such as OpenSea that use
+ *        off-chain information to distribute roaylties.
+ *
+ *      - Ownership of the contract, with the ability to restrict certain functions to
+ *        only be called by the contract's owner.
+ *
+ *      - Multicall capability to perform multiple actions atomically
+ *
+ *      - EIP 2981 compliance for royalty support on NFT marketplaces.
+ *
+ *
+ *  The `ERC1155LazyMint` contract uses the `LazyMint` extension.
+ *
+ *  'Lazy minting' means defining the metadata of NFTs without minting it to an address. Regular 'minting'
+ *  of  NFTs means actually assigning an owner to an NFT.
+ *
+ *  As a contract admin, this lets you prepare the metadata for NFTs that will be minted by an external party,
+ *  without paying the gas cost for actually minting the NFTs.
+ *
+ */
+
+contract ERC1155LazyMint is
+    ERC1155,
+    ContractMetadata,
+    Ownable,
+    Royalty,
+    Multicall,
+    BatchMintMetadata,
+    LazyMint,
+    IClaimableERC1155,
+    ReentrancyGuard
+{
+    using Strings for uint256;
+
+    /*//////////////////////////////////////////////////////////////
+                        Mappings
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     *  @notice Returns the total supply of NFTs of a given tokenId
+     *  @dev Mapping from tokenId => total circulating supply of NFTs of that tokenId.
+     */
+    mapping(uint256 => uint256) public totalSupply;
+
+    /*//////////////////////////////////////////////////////////////
+                            Constructor
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice Initializes the contract during construction.
+     *
+     * @param _defaultAdmin     The default admin of the contract.
+     * @param _name             The name of the contract.
+     * @param _symbol           The symbol of the contract.
+     * @param _royaltyRecipient The address to receive royalties.
+     * @param _royaltyBps       The royalty basis points to be charged. Max = 10000 (10000 = 100%, 1000 = 10%)
+     */
+    constructor(
+        address _defaultAdmin,
+        string memory _name,
+        string memory _symbol,
+        address _royaltyRecipient,
+        uint128 _royaltyBps
+    ) ERC1155(_name, _symbol) {
+        _setupOwner(_defaultAdmin);
+        _setupDefaultRoyaltyInfo(_royaltyRecipient, _royaltyBps);
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                    Overriden metadata logic
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice Returns the metadata URI for the given tokenId.
+     *
+     * @param _tokenId The tokenId of the NFT.
+     * @return The metadata URI for the given tokenId.
+     */
+    function uri(uint256 _tokenId) public view virtual override returns (string memory) {
+        string memory batchUri = _getBaseURI(_tokenId);
+        return string(abi.encodePacked(batchUri, _tokenId.toString()));
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                            CLAIM LOGIC
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     *  @notice          Lets an address claim multiple lazy minted NFTs at once to a recipient.
+     *                   This function prevents any reentrant calls, and is not allowed to be overridden.
+     *
+     *                   Contract creators should override `verifyClaim` and `transferTokensOnClaim`
+     *                   functions to create custom logic for verification and claiming,
+     *                   for e.g. price collection, allowlist, max quantity, etc.
+     *
+     *  @dev             The logic in `verifyClaim` determines whether the caller is authorized to mint NFTs.
+     *                   The logic in `transferTokensOnClaim` does actual minting of tokens,
+     *                   can also be used to apply other state changes.
+     *
+     *  @param _receiver  The recipient of the tokens to mint.
+     *  @param _tokenId   The tokenId of the lazy minted NFT to mint.
+     *  @param _quantity  The number of tokens to mint.
+     */
+    function claim(address _receiver, uint256 _tokenId, uint256 _quantity) public payable virtual nonReentrant {
+        require(_tokenId < nextTokenIdToMint(), "invalid id");
+        verifyClaim(msg.sender, _tokenId, _quantity); // Add your claim verification logic by overriding this function.
+
+        _transferTokensOnClaim(_receiver, _tokenId, _quantity); // Mints tokens. Apply any state updates by overriding this function.
+        emit TokensClaimed(msg.sender, _receiver, _tokenId, _quantity);
+    }
+
+    /**
+     *  @notice          Override this function to add logic for claim verification, based on conditions
+     *                   such as allowlist, price, max quantity etc.
+     *
+     *  @dev             Checks a request to claim NFTs against a custom condition.
+     *
+     *  @param _claimer   Caller of the claim function.
+     *  @param _tokenId   The tokenId of the lazy minted NFT to mint.
+     *  @param _quantity  The number of NFTs being claimed.
+     */
+    function verifyClaim(address _claimer, uint256 _tokenId, uint256 _quantity) public view virtual {}
+
+    /**
+     *  @notice         Lets an owner or approved operator burn NFTs of the given tokenId.
+     *
+     *  @param _owner   The owner of the NFT to burn.
+     *  @param _tokenId The tokenId of the NFT to burn.
+     *  @param _amount  The amount of the NFT to burn.
+     */
+    function burn(address _owner, uint256 _tokenId, uint256 _amount) external virtual {
+        address caller = msg.sender;
+
+        require(caller == _owner || isApprovedForAll[_owner][caller], "Unapproved caller");
+        require(balanceOf[_owner][_tokenId] >= _amount, "Not enough tokens owned");
+
+        _burn(_owner, _tokenId, _amount);
+    }
+
+    /**
+     *  @notice         Lets an owner or approved operator burn NFTs of the given tokenIds.
+     *
+     *  @param _owner    The owner of the NFTs to burn.
+     *  @param _tokenIds The tokenIds of the NFTs to burn.
+     *  @param _amounts  The amounts of the NFTs to burn.
+     */
+    function burnBatch(address _owner, uint256[] memory _tokenIds, uint256[] memory _amounts) external virtual {
+        address caller = msg.sender;
+
+        require(caller == _owner || isApprovedForAll[_owner][caller], "Unapproved caller");
+        require(_tokenIds.length == _amounts.length, "Length mismatch");
+
+        for (uint256 i = 0; i < _tokenIds.length; i += 1) {
+            require(balanceOf[_owner][_tokenIds[i]] >= _amounts[i], "Not enough tokens owned");
+        }
+
+        _burnBatch(_owner, _tokenIds, _amounts);
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                            ERC165 Logic
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See ERC165: https://eips.ethereum.org/EIPS/eip-165
+     * @inheritdoc IERC165
+     */
+    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC1155, IERC165) returns (bool) {
+        return
+            interfaceId == 0x01ffc9a7 || // ERC165 Interface ID for ERC165
+            interfaceId == 0xd9b67a26 || // ERC165 Interface ID for ERC1155
+            interfaceId == 0x0e89341c || // ERC165 Interface ID for ERC1155MetadataURI
+            interfaceId == type(IERC2981).interfaceId; // ERC165 ID for ERC2981
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                            View functions
+    //////////////////////////////////////////////////////////////*/
+
+    /// @notice The tokenId assigned to the next new NFT to be lazy minted.
+    function nextTokenIdToMint() public view virtual returns (uint256) {
+        return nextTokenIdToLazyMint;
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                        Internal functions
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     *  @notice          Mints tokens to receiver on claim.
+     *                   Any state changes related to `claim` must be applied
+     *                   here by overriding this function.
+     *
+     *  @dev             Override this function to add logic for state updation.
+     *                   When overriding, apply any state changes before `_mint`.
+     *
+     *  @param _receiver The receiver of the tokens to mint.
+     *  @param _tokenId  The tokenId of the lazy minted NFT to mint.
+     *  @param _quantity The number of tokens to mint.
+     */
+    function _transferTokensOnClaim(address _receiver, uint256 _tokenId, uint256 _quantity) internal virtual {
+        _mint(_receiver, _tokenId, _quantity, "");
+    }
+
+    /// @dev Returns whether lazy minting can be done in the given execution context.
+    function _canLazyMint() internal view virtual override returns (bool) {
+        return msg.sender == owner();
+    }
+
+    /// @dev Returns whether contract metadata can be set in the given execution context.
+    function _canSetContractURI() internal view virtual override returns (bool) {
+        return msg.sender == owner();
+    }
+
+    /// @dev Returns whether owner can be set in the given execution context.
+    function _canSetOwner() internal view virtual override returns (bool) {
+        return msg.sender == owner();
+    }
+
+    /// @dev Returns whether royalty info can be set in the given execution context.
+    function _canSetRoyaltyInfo() internal view virtual override returns (bool) {
+        return msg.sender == owner();
+    }
+
+    /**
+     * @dev Runs before every token transfer / mint / burn.
+     *
+     * @param operator The address performing the token transfer.
+     * @param from     The address from which the token is being transferred.
+     * @param to       The address to which the token is being transferred.
+     * @param ids      The tokenIds of the tokens being transferred.
+     * @param amounts  The amounts of the tokens being transferred.
+     * @param data     Any additional data being passed in the token transfer.
+     */
+    function _beforeTokenTransfer(
+        address operator,
+        address from,
+        address to,
+        uint256[] memory ids,
+        uint256[] memory amounts,
+        bytes memory data
+    ) internal virtual override {
+        super._beforeTokenTransfer(operator, from, to, ids, amounts, data);
+
+        if (from == address(0)) {
+            for (uint256 i = 0; i < ids.length; ++i) {
+                totalSupply[ids[i]] += amounts[i];
+            }
+        }
+
+        if (to == address(0)) {
+            for (uint256 i = 0; i < ids.length; ++i) {
+                totalSupply[ids[i]] -= amounts[i];
+            }
+        }
+    }
+}

package/contracts/base/ERC1155SignatureMint.sol

@@ -0,0 +1,132 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import "./ERC1155Base.sol";
+
+import "../extension/PrimarySale.sol";
+import "../extension/SignatureMintERC1155.sol";
+import { ReentrancyGuard } from "../extension/upgradeable/ReentrancyGuard.sol";
+import { CurrencyTransferLib } from "../lib/CurrencyTransferLib.sol";
+
+/**
+ *      BASE:      ERC1155Base
+ *      EXTENSION: SignatureMintERC1155
+ *
+ *  The `ERC1155SignatureMint` contract uses the `ERC1155Base` contract, along with the `SignatureMintERC1155` extension.
+ *
+ *  The 'signature minting' mechanism in the `SignatureMintERC1155` extension uses EIP 712, and is a way for a contract
+ *  admin to authorize an external party's request to mint tokens on the admin's contract. At a high level, this means
+ *  you can authorize some external party to mint tokens on your contract, and specify what exactly will be minted by
+ *  that external party.
+ *
+ */
+
+contract ERC1155SignatureMint is ERC1155Base, PrimarySale, SignatureMintERC1155, ReentrancyGuard {
+    /*//////////////////////////////////////////////////////////////
+                            Constructor
+    //////////////////////////////////////////////////////////////*/
+
+    constructor(
+        address _defaultAdmin,
+        string memory _name,
+        string memory _symbol,
+        address _royaltyRecipient,
+        uint128 _royaltyBps,
+        address _primarySaleRecipient
+    ) ERC1155Base(_defaultAdmin, _name, _symbol, _royaltyRecipient, _royaltyBps) {
+        _setupPrimarySaleRecipient(_primarySaleRecipient);
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                        Signature minting logic
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     *  @notice           Mints tokens according to the provided mint request.
+     *
+     *  @param _req       The payload / mint request.
+     *  @param _signature The signature produced by an account signing the mint request.
+     */
+    function mintWithSignature(
+        MintRequest calldata _req,
+        bytes calldata _signature
+    ) external payable virtual override nonReentrant returns (address signer) {
+        require(_req.quantity > 0, "Minting zero tokens.");
+
+        uint256 tokenIdToMint;
+        uint256 nextIdToMint = nextTokenIdToMint();
+
+        if (_req.tokenId == type(uint256).max) {
+            tokenIdToMint = nextIdToMint;
+            nextTokenIdToMint_ += 1;
+        } else {
+            require(_req.tokenId < nextIdToMint, "invalid id");
+            tokenIdToMint = _req.tokenId;
+        }
+
+        // Verify and process payload.
+        signer = _processRequest(_req, _signature);
+
+        address receiver = _req.to;
+
+        // Collect price
+        _collectPriceOnClaim(_req.primarySaleRecipient, _req.quantity, _req.currency, _req.pricePerToken);
+
+        // Set royalties, if applicable.
+        if (_req.royaltyRecipient != address(0)) {
+            _setupRoyaltyInfoForToken(tokenIdToMint, _req.royaltyRecipient, _req.royaltyBps);
+        }
+
+        // Set URI
+        if (_req.tokenId == type(uint256).max) {
+            _setTokenURI(tokenIdToMint, _req.uri);
+        }
+
+        // Mint tokens.
+        _mint(receiver, tokenIdToMint, _req.quantity, "");
+
+        emit TokensMintedWithSignature(signer, receiver, tokenIdToMint, _req);
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                            Internal functions
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev Returns whether a given address is authorized to sign mint requests.
+    function _canSignMintRequest(address _signer) internal view virtual override returns (bool) {
+        return _signer == owner();
+    }
+
+    /// @dev Returns whether primary sale recipient can be set in the given execution context.
+    function _canSetPrimarySaleRecipient() internal view virtual override returns (bool) {
+        return msg.sender == owner();
+    }
+
+    /// @dev Collects and distributes the primary sale value of NFTs being claimed.
+    function _collectPriceOnClaim(
+        address _primarySaleRecipient,
+        uint256 _quantityToClaim,
+        address _currency,
+        uint256 _pricePerToken
+    ) internal virtual {
+        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, "Invalid msg value");
+
+        address saleRecipient = _primarySaleRecipient == address(0) ? primarySaleRecipient() : _primarySaleRecipient;
+        CurrencyTransferLib.transferCurrency(_currency, msg.sender, saleRecipient, totalPrice);
+    }
+}

package/contracts/base/ERC20Base.sol

@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import "../external-deps/openzeppelin/token/ERC20/extensions/ERC20Permit.sol";
+
+import "../extension/ContractMetadata.sol";
+import "../extension/Multicall.sol";
+import "../extension/Ownable.sol";
+import "../extension/interface/IMintableERC20.sol";
+import "../extension/interface/IBurnableERC20.sol";
+
+/**
+ *  The `ERC20Base` smart contract implements the ERC20 standard.
+ *  It includes the following additions to standard ERC20 logic:
+ *
+ *      - Ability to mint & burn tokens via the provided `mint` & `burn` functions.
+ *
+ *      - Ownership of the contract, with the ability to restrict certain functions to
+ *        only be called by the contract's owner.
+ *
+ *      - Multicall capability to perform multiple actions atomically
+ *
+ *      - EIP 2612 compliance: See {ERC20-permit} method, which can be used to change an account's ERC20 allowance by
+ *                             presenting a message signed by the account.
+ */
+
+contract ERC20Base is ContractMetadata, Multicall, Ownable, ERC20Permit, IMintableERC20, IBurnableERC20 {
+    /*//////////////////////////////////////////////////////////////
+                            Constructor
+    //////////////////////////////////////////////////////////////*/
+
+    constructor(address _defaultAdmin, string memory _name, string memory _symbol) ERC20Permit(_name, _symbol) {
+        _setupOwner(_defaultAdmin);
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                            Minting logic
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     *  @notice          Lets an authorized address mint tokens to a recipient.
+     *  @dev             The logic in the `_canMint` function determines whether the caller is authorized to mint tokens.
+     *
+     *  @param _to       The recipient of the tokens to mint.
+     *  @param _amount   Quantity of tokens to mint.
+     */
+    function mintTo(address _to, uint256 _amount) public virtual {
+        require(_canMint(), "Not authorized to mint.");
+        require(_amount != 0, "Minting zero tokens.");
+
+        _mint(_to, _amount);
+    }
+
+    /**
+     *  @notice          Lets an owner a given amount of their tokens.
+     *  @dev             Caller should own the `_amount` of tokens.
+     *
+     *  @param _amount   The number of tokens to burn.
+     */
+    function burn(uint256 _amount) external virtual {
+        require(balanceOf(msg.sender) >= _amount, "not enough balance");
+        _burn(msg.sender, _amount);
+    }
+
+    /**
+     *  @notice          Lets an owner burn a given amount of an account's tokens.
+     *  @dev             `_account` should own the `_amount` of tokens.
+     *
+     *  @param _account  The account to burn tokens from.
+     *  @param _amount   The number of tokens to burn.
+     */
+    function burnFrom(address _account, uint256 _amount) external virtual override {
+        require(_canBurn(), "Not authorized to burn.");
+        require(balanceOf(_account) >= _amount, "not enough balance");
+        uint256 decreasedAllowance = allowance(_account, msg.sender) - _amount;
+        _approve(_account, msg.sender, 0);
+        _approve(_account, msg.sender, decreasedAllowance);
+        _burn(_account, _amount);
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                        Internal (overrideable) functions
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev Returns whether contract metadata can be set in the given execution context.
+    function _canSetContractURI() internal view virtual override returns (bool) {
+        return msg.sender == owner();
+    }
+
+    /// @dev Returns whether tokens can be minted in the given execution context.
+    function _canMint() internal view virtual returns (bool) {
+        return msg.sender == owner();
+    }
+
+    /// @dev Returns whether tokens can be burned in the given execution context.
+    function _canBurn() internal view virtual returns (bool) {
+        return msg.sender == owner();
+    }
+
+    /// @dev Returns whether owner can be set in the given execution context.
+    function _canSetOwner() internal view virtual override returns (bool) {
+        return msg.sender == owner();
+    }
+
+    /// @notice Returns the sender in the given execution context.
+    function _msgSender() internal view override(Multicall, Context) returns (address) {
+        return msg.sender;
+    }
+}