@lukso/lsp8-contracts 0.16.7 → 0.18.1

package/contracts/presets/LSP8CustomizableTokenInit.sol

@@ -0,0 +1,318 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.27;
+
+// modules
+import {
+    OwnableUpgradeable
+} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";
+import {
+    LSP8IdentifiableDigitalAssetInitAbstract
+} from "../LSP8IdentifiableDigitalAssetInitAbstract.sol";
+
+// extensions
+import {
+    LSP8BurnableInitAbstract
+} from "../extensions/LSP8Burnable/LSP8BurnableInitAbstract.sol";
+import {
+    LSP8MintableInitAbstract
+} from "../extensions/LSP8Mintable/LSP8MintableInitAbstract.sol";
+import {
+    LSP8CappedSupplyInitAbstract
+} from "../extensions/LSP8CappedSupply/LSP8CappedSupplyInitAbstract.sol";
+import {
+    LSP8CappedBalanceInitAbstract
+} from "../extensions/LSP8CappedBalance/LSP8CappedBalanceInitAbstract.sol";
+import {
+    LSP8NonTransferableInitAbstract
+} from "../extensions/LSP8NonTransferable/LSP8NonTransferableInitAbstract.sol";
+import {
+    LSP8RevokableInitAbstract
+} from "../extensions/LSP8Revokable/LSP8RevokableInitAbstract.sol";
+
+// constants
+import {
+    LSP8MintableParams,
+    LSP8NonTransferableParams,
+    LSP8CappedParams,
+    LSP8RevokableParams
+} from "./LSP8CustomizableTokenConstants.sol";
+
+// errors
+import {
+    LSP8MintDisabled
+} from "../extensions/LSP8Mintable/LSP8MintableErrors.sol";
+import {
+    LSP8CappedSupplyCannotMintOverCap
+} from "../extensions/LSP8CappedSupply/LSP8CappedSupplyErrors.sol";
+
+/// @title LSP8CustomizableTokenInit
+/// @dev A customizable LSP8 token that implements multiple features and uses role-based exemptions. This version of the contract is the implementation to use behind proxies.
+/// Implements {LSP8BurnableInitAbstract} to allow burning.
+/// Implements {LSP8MintableInitAbstract} to allow minting.
+/// Implements {LSP8CappedSupplyInitAbstract} to set total supply cap.
+/// Implements {LSP8CappedBalanceInitAbstract} to set balance caps.
+/// Implements {LSP8NonTransferableInitAbstract} to restrict transfers.
+/// Implements {LSP8RevokableInitAbstract} to allow revoking tokens.
+contract LSP8CustomizableTokenInit is
+    LSP8BurnableInitAbstract,
+    LSP8MintableInitAbstract,
+    LSP8CappedBalanceInitAbstract,
+    LSP8CappedSupplyInitAbstract,
+    LSP8NonTransferableInitAbstract,
+    LSP8RevokableInitAbstract
+{
+    /// @dev Locks the base implementation contract from being initialized.
+    constructor() {
+        _disableInitializers();
+    }
+
+    /// @notice Initializes the token with name, symbol, owner, and customizable features.
+    /// @dev Sets up minting, balance cap, transfer restrictions and supply cap. Mints initial tokens if specified. Reverts if initialMintTokenIds length exceeds tokenSupplyCap.
+    /// @param name_ The name of the token.
+    /// @param symbol_ The symbol of the token.
+    /// @param newOwner_ The initial owner of the token.
+    /// @param lsp4TokenType_ The LSP4 token type (e.g., 1 for NFT, 2 for Collection).
+    /// @param lsp8TokenIdFormat_ The format of tokenIds (= NFTs) that this contract will create.
+    /// @param mintableParams Deployment configuration for minting feature (see above).
+    /// @param nonTransferableParams Deployment configuration for non-transferable feature (see above).
+    /// @param cappedParams Deployment configuration for capped balance and capped supply features (see above).
+    function initialize(
+        string calldata name_,
+        string calldata symbol_,
+        address newOwner_,
+        uint256 lsp4TokenType_,
+        uint256 lsp8TokenIdFormat_,
+        LSP8MintableParams calldata mintableParams,
+        LSP8CappedParams calldata cappedParams,
+        LSP8NonTransferableParams calldata nonTransferableParams,
+        LSP8RevokableParams calldata revokableParams
+    ) external virtual initializer {
+        __LSP8CustomizableToken_init(
+            name_,
+            symbol_,
+            newOwner_,
+            lsp4TokenType_,
+            lsp8TokenIdFormat_,
+            mintableParams,
+            cappedParams,
+            nonTransferableParams,
+            revokableParams
+        );
+    }
+
+    /// @dev Internal initialization function.
+    function __LSP8CustomizableToken_init(
+        string calldata name_,
+        string calldata symbol_,
+        address newOwner_,
+        uint256 lsp4TokenType_,
+        uint256 lsp8TokenIdFormat_,
+        LSP8MintableParams calldata mintableParams,
+        LSP8CappedParams calldata cappedParams,
+        LSP8NonTransferableParams calldata nonTransferableParams,
+        LSP8RevokableParams calldata revokableParams
+    ) internal virtual onlyInitializing {
+        LSP8IdentifiableDigitalAssetInitAbstract._initialize(
+            name_,
+            symbol_,
+            newOwner_,
+            lsp4TokenType_,
+            lsp8TokenIdFormat_
+        );
+        __AccessControlExtended_init_unchained();
+        __LSP8Mintable_init_unchained(mintableParams.isMintable);
+        __LSP8CappedSupply_init_unchained(cappedParams.tokenSupplyCap);
+        __LSP8CappedBalance_init_unchained(cappedParams.tokenBalanceCap);
+        __LSP8NonTransferable_init_unchained(
+            nonTransferableParams.transferLockStart,
+            nonTransferableParams.transferLockEnd
+        );
+        __LSP8Revokable_init_unchained(revokableParams.isRevokable);
+
+        _initialMint({
+            to: newOwner_,
+            initialMintTokenIds: mintableParams.initialMintTokenIds
+        });
+    }
+
+    /// @inheritdoc LSP8CappedSupplyInitAbstract
+    /// @notice Returns the token supply cap.
+    /// @dev If minting is enabled, returns the configured supply cap defining the maximum number of NFTs that can be minted.
+    /// If minting is disabled, returns the current total supply as the effective cap (no more NFTs can be created).
+    function tokenSupplyCap() public view virtual override returns (uint256) {
+        return isMintable ? super.tokenSupplyCap() : totalSupply();
+    }
+
+    /// @dev Required override to resolve multiple inheritance. Calls every parent {supportsInterface} functions
+    /// via `super` to aggregate the interface IDs supported across all inherited modules.
+    function supportsInterface(
+        bytes4 interfaceId
+    )
+        public
+        view
+        virtual
+        override(
+            LSP8IdentifiableDigitalAssetInitAbstract,
+            LSP8MintableInitAbstract,
+            LSP8CappedBalanceInitAbstract,
+            LSP8NonTransferableInitAbstract,
+            LSP8RevokableInitAbstract
+        )
+        returns (bool)
+    {
+        return super.supportsInterface(interfaceId);
+    }
+
+    /// @dev Override to bypass the non transferable check when revokers revoke users' tokens.
+    function _nonTransferableCheck(
+        address from,
+        address to,
+        bytes32 tokenId,
+        bool force,
+        bytes memory data
+    ) internal virtual override {
+        if (_isRevocationBypass(to)) return;
+        super._nonTransferableCheck(from, to, tokenId, force, data);
+    }
+
+    /// @dev Override to bypass the token balance cap check when revokers revoke users' tokens.
+    function _tokenBalanceCapCheck(
+        address from,
+        address to,
+        bytes32 tokenId,
+        bool force,
+        bytes memory data
+    ) internal virtual override {
+        if (_isRevocationBypass(to)) return;
+        super._tokenBalanceCapCheck(from, to, tokenId, force, data);
+    }
+
+    /// @inheritdoc LSP8MintableInitAbstract
+    /// @dev Overridden function to allow minting only if:
+    /// - the minting feature is enabled, from {LSP8MintableInitAbstract}
+    /// - the total number of NFTs does not exceed the capped supply after minting, from {LSP8CappedSupplyInitAbstract}
+    function _mint(
+        address to,
+        bytes32 tokenId,
+        bool force,
+        bytes memory data
+    )
+        internal
+        virtual
+        override(
+            LSP8IdentifiableDigitalAssetInitAbstract,
+            LSP8MintableInitAbstract,
+            LSP8CappedSupplyInitAbstract
+        )
+    {
+        require(isMintable, LSP8MintDisabled());
+        LSP8CappedSupplyInitAbstract._mint(to, tokenId, force, data);
+    }
+
+    /// @notice Hook called before a token transfer to enforce restrictions.
+    /// @dev Combines checks from {LSP8CappedBalanceInitAbstract} and {LSP8NonTransferableInitAbstract}.
+    /// - Bypasses {LSP8NonTransferableInitAbstract} checks for senders (`from`) holding the `NON_TRANSFERABLE_BYPASS_ROLE` role.
+    /// - Bypasses {LSP8CappedBalanceInitAbstract} checks for recipients (`to`) holding the `UNCAPPED_BALANCE_ROLE` role.
+    /// - Allows minting (from address(0)) and burning to address(0) regardless of restrictions.
+    /// @param from The address sending the token.
+    /// @param to The address receiving the token.
+    /// @param tokenId The unique identifier of the token being transferred.
+    /// @param force Whether to force the transfer.
+    /// @param data Additional data for the transfer.
+    function _beforeTokenTransfer(
+        address from,
+        address to,
+        bytes32 tokenId,
+        bool force,
+        bytes memory data
+    )
+        internal
+        virtual
+        override(
+            LSP8IdentifiableDigitalAssetInitAbstract,
+            LSP8CappedBalanceInitAbstract,
+            LSP8NonTransferableInitAbstract
+        )
+    {
+        super._beforeTokenTransfer(from, to, tokenId, force, data);
+    }
+
+    /// @dev Required override to resolve multiple inheritance. Calls every parent {_transferOwnership} function
+    /// via `super` so that each inherited module updates its ownership-dependent state.
+    ///
+    /// When contract ownership changes, this will:
+    /// - clear the admin role for: `MINTER_ROLE`, `REVOKER_ROLE`, `NON_TRANSFERABLE_BYPASS_ROLE`, `UNCAPPED_BALANCE_ROLE`
+    /// - clear the list of addresses holding the `REVOKER_ROLE`
+    function _transferOwnership(
+        address newOwner
+    )
+        internal
+        virtual
+        override(
+            OwnableUpgradeable,
+            LSP8MintableInitAbstract,
+            LSP8CappedBalanceInitAbstract,
+            LSP8NonTransferableInitAbstract,
+            LSP8RevokableInitAbstract
+        )
+    {
+        super._transferOwnership(newOwner);
+    }
+
+    /// @dev Mint initial NFTs without enforcing check if the token contract is mintable or not.
+    /// Enforces the configured capped-supply value directly (not {tokenSupplyCap} when minting is disabled).
+    function _initialMint(
+        address to,
+        bytes32[] memory initialMintTokenIds
+    ) private {
+        uint256 configuredTokenSupplyCap = LSP8CappedSupplyInitAbstract
+            .tokenSupplyCap();
+        bool isCappedSupplyConfigured = configuredTokenSupplyCap > 0;
+
+        if (isCappedSupplyConfigured) {
+            bool mintingExceedsSupplyCap = initialMintTokenIds.length >
+                configuredTokenSupplyCap;
+
+            require(
+                !mintingExceedsSupplyCap,
+                LSP8CappedSupplyCannotMintOverCap()
+            );
+        }
+        for (uint256 ii = 0; ii < initialMintTokenIds.length; ++ii) {
+            LSP8IdentifiableDigitalAssetInitAbstract._mint(
+                to,
+                initialMintTokenIds[ii],
+                true,
+                ""
+            );
+
+            if (isCappedSupplyConfigured) {
+                // CHECK if the `to` address is a contract that minted more tokens
+                // through its `universalReceiver(...)` function after being notified via LSP1.
+                bool currentSupplyExceedsSupplyCap = totalSupply() >
+                    configuredTokenSupplyCap;
+
+                require(
+                    !currentSupplyExceedsSupplyCap,
+                    LSP8CappedSupplyCannotMintOverCap()
+                );
+            }
+        }
+    }
+
+    /// @dev Returns whether the current call is a legitimate revocation that should bypass the
+    /// {LSP8NonTransferableInitAbstract} and {LSP8CappedBalanceInitAbstract} restrictions when revoking tokens from a token holder.
+    ///
+    /// Returns `true` only when all of the following conditions are met:
+    /// - the function being called is {revoke}.
+    /// - the revoking feature is enabled.
+    /// - the caller (`msg.sender`) holds the `REVOKER_ROLE`.
+    /// - the recipient (`to`) is either the contract `owner()` or a revoker (an address holding the `REVOKER_ROLE`).
+    function _isRevocationBypass(address to) private view returns (bool) {
+        return
+            msg.sig == this.revoke.selector &&
+            isRevokable() &&
+            hasRole(REVOKER_ROLE, msg.sender) &&
+            (to == owner() || hasRole(REVOKER_ROLE, to));
+    }
+}

package/contracts/presets/LSP8Mintable.sol

@@ -1,22 +1,24 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.12;
-
-// interfaces
-import {ILSP8Mintable} from "./ILSP8Mintable.sol";
+pragma solidity ^0.8.27;
 
 // modules
 import {
     LSP8IdentifiableDigitalAsset
 } from "../LSP8IdentifiableDigitalAsset.sol";
+import {
+    LSP8MintableAbstract
+} from "../extensions/LSP8Mintable/LSP8MintableAbstract.sol";
+import {
+    AccessControlExtendedAbstract
+} from "../extensions/AccessControlExtended/AccessControlExtendedAbstract.sol";
 
 /**
- * @title LSP8IdentifiableDigitalAsset deployable preset contract with a public {mint} function callable only by the contract {owner}.
+ * @title LSP8IdentifiableDigitalAsset deployable preset contract with a public {mint} function callable by addresses holding `MINTER_ROLE`.
  */
-contract LSP8Mintable is LSP8IdentifiableDigitalAsset, ILSP8Mintable {
+contract LSP8Mintable is LSP8MintableAbstract {
     /**
-     * @notice Deploying a `LSP8Mintable` token contract with: token name = `name_`, token symbol = `symbol_`, and
-     * address `newOwner_` as the token contract owner.
-     *
+     * @notice Deploying a `LSP8Mintable` token contract.
+     * @dev Set the token to be mintable to allow minting more tokens after deployment.
      * @param name_ The name of the token.
      * @param symbol_ The symbol of the token.
      * @param newOwner_ The owner of the token contract.
@@ -37,24 +39,7 @@ contract LSP8Mintable is LSP8IdentifiableDigitalAsset, ILSP8Mintable {
             lsp4TokenType_,
             lsp8TokenIdFormat_
         )
+        AccessControlExtendedAbstract()
+        LSP8MintableAbstract(true)
     {}
-
-    /**
-     * @notice Minting tokenId `tokenId` for address `to` with the additional data `data` (Note: allow non-LSP1 recipient is set to `force`).
-     *
-     * @dev Public {_mint} function only callable by the {owner}.
-     *
-     * @param to The address that will receive the minted `tokenId`.
-     * @param tokenId The tokenId to mint.
-     * @param force Set to `false` to ensure that you are minting for a recipient that implements LSP1, `false` otherwise for forcing the minting.
-     * @param data Any addition data to be sent alongside the minting.
-     */
-    function mint(
-        address to,
-        bytes32 tokenId,
-        bool force,
-        bytes memory data
-    ) public virtual override onlyOwner {
-        _mint(to, tokenId, force, data);
-    }
 }

package/contracts/presets/LSP8MintableInit.sol

@@ -1,11 +1,16 @@
 // SPDX-License-Identifier: Apache-2.0
-pragma solidity ^0.8.12;
+pragma solidity ^0.8.27;
 
 // modules
-import {LSP8MintableInitAbstract} from "./LSP8MintableInitAbstract.sol";
+import {
+    LSP8IdentifiableDigitalAssetInitAbstract
+} from "../LSP8IdentifiableDigitalAssetInitAbstract.sol";
+import {
+    LSP8MintableInitAbstract
+} from "../extensions/LSP8Mintable/LSP8MintableInitAbstract.sol";
 
 /**
- * @dev LSP8IdentifiableDigitalAsset deployable preset contract (proxy version) with a public {mint} function callable only by the contract {owner}.
+ * @dev LSP8IdentifiableDigitalAsset deployable preset contract (proxy version) with a public {mint} function callable by addresses holding `MINTER_ROLE`.
  */
 contract LSP8MintableInit is LSP8MintableInitAbstract {
     /**
@@ -26,18 +31,20 @@ contract LSP8MintableInit is LSP8MintableInitAbstract {
      * @param lsp8TokenIdFormat_ The format of tokenIds (= NFTs) that this contract will create.
      */
     function initialize(
-        string memory name_,
-        string memory symbol_,
+        string calldata name_,
+        string calldata symbol_,
         address newOwner_,
         uint256 lsp4TokenType_,
         uint256 lsp8TokenIdFormat_
     ) external virtual initializer {
-        LSP8MintableInitAbstract._initialize(
+        LSP8IdentifiableDigitalAssetInitAbstract._initialize(
             name_,
             symbol_,
             newOwner_,
             lsp4TokenType_,
             lsp8TokenIdFormat_
         );
+        __AccessControlExtended_init();
+        __LSP8Mintable_init_unchained(true);
     }
 }