@lukso/lsp8-contracts 0.15.0-rc.0

package/contracts/LSP8IdentifiableDigitalAssetInitAbstract.sol

@@ -0,0 +1,248 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.12;
+
+// interfaces
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+
+// modules
+import {ERC725YCore} from "@erc725/smart-contracts/contracts/ERC725YCore.sol";
+import {
+    LSP8IdentifiableDigitalAssetCore
+} from "./LSP8IdentifiableDigitalAssetCore.sol";
+import {
+    LSP4DigitalAssetMetadataInitAbstract
+} from "@lukso/lsp4-contracts/contracts/LSP4DigitalAssetMetadataInitAbstract.sol";
+
+import {
+    LSP4DigitalAssetMetadataCore
+} from "@lukso/lsp4-contracts/contracts/LSP4DigitalAssetMetadataCore.sol";
+
+import {
+    LSP17Extendable
+} from "@lukso/lsp17contractextension-contracts/contracts/LSP17Extendable.sol";
+
+// libraries
+import {LSP2Utils} from "@lukso/lsp2-contracts/contracts/LSP2Utils.sol";
+
+// constants
+import {_INTERFACEID_LSP8, _LSP8_TOKENID_FORMAT_KEY} from "./LSP8Constants.sol";
+
+// errors
+import {
+    LSP8TokenContractCannotHoldValue,
+    LSP8TokenIdFormatNotEditable
+} from "./LSP8Errors.sol";
+
+import {
+    _LSP17_EXTENSION_PREFIX
+} from "@lukso/lsp17contractextension-contracts/contracts/LSP17Constants.sol";
+
+// errors
+
+import {
+    NoExtensionFoundForFunctionSelector,
+    InvalidFunctionSelector,
+    InvalidExtensionAddress
+} from "@lukso/lsp17contractextension-contracts/contracts/LSP17Errors.sol";
+
+/**
+ * @title Implementation of a LSP8 Identifiable Digital Asset, a contract that represents a non-fungible token.
+ * @author Matthew Stevens
+ *
+ * @dev Inheritable proxy implementation contract of the LSP8 standard.
+ *
+ * Minting and transferring are done using by giving a unique `tokenId`.
+ * This implementation is agnostic to the way tokens are created.
+ * A supply mechanism has to be added in a derived contract using {_mint}
+ * For a generic mechanism, see {LSP7Mintable}.
+ */
+abstract contract LSP8IdentifiableDigitalAssetInitAbstract is
+    LSP4DigitalAssetMetadataInitAbstract,
+    LSP8IdentifiableDigitalAssetCore,
+    LSP17Extendable
+{
+    /**
+     * @dev Initialize a `LSP8IdentifiableDigitalAsset` contract and set the tokenId format inside the ERC725Y storage of the contract.
+     * This will also set the token `name_` and `symbol_` under the ERC725Y data keys `LSP4TokenName` and `LSP4TokenSymbol`.
+     *
+     * @param name_ The name of the token
+     * @param symbol_ The symbol of the token
+     * @param newOwner_ The owner of the the token-Metadata
+     * @param lsp4TokenType_ The type of token this digital asset contract represents (`0` = Token, `1` = NFT, `2` = Collection).
+     * @param lsp8TokenIdFormat_ The format of tokenIds (= NFTs) that this contract will create.
+     *
+     * @custom:warning Make sure the tokenId format provided on deployment is correct, as it can only be set once
+     * and cannot be changed in the ERC725Y storage after the contract has been initialized.
+     */
+    function _initialize(
+        string memory name_,
+        string memory symbol_,
+        address newOwner_,
+        uint256 lsp4TokenType_,
+        uint256 lsp8TokenIdFormat_
+    ) internal virtual onlyInitializing {
+        LSP4DigitalAssetMetadataInitAbstract._initialize(
+            name_,
+            symbol_,
+            newOwner_,
+            lsp4TokenType_
+        );
+
+        LSP4DigitalAssetMetadataInitAbstract._setData(
+            _LSP8_TOKENID_FORMAT_KEY,
+            abi.encode(lsp8TokenIdFormat_)
+        );
+    }
+
+    // fallback function
+
+    /**
+     * @notice The `fallback` function was called with the following amount of native tokens: `msg.value`; and the following calldata: `callData`.
+     *
+     * @dev Achieves the goal of [LSP-17-ContractExtension] standard by extending the contract to handle calls of functions that do not exist natively,
+     * forwarding the function call to the extension address mapped to the function being called.
+     *
+     * This function is executed when:
+     *    - Sending data of length less than 4 bytes to the contract.
+     *    - The first 4 bytes of the calldata do not match any publicly callable functions from the contract ABI.
+     *    - Receiving native tokens
+     *
+     * 1. If the data is equal or longer than 4 bytes, the [ERC-725Y] storage is queried with the following data key: [_LSP17_EXTENSION_PREFIX] + `bytes4(msg.sig)` (Check [LSP-2-ERC725YJSONSchema] for encoding the data key)
+     *
+     *   - If there is no address stored under the following data key, revert with {NoExtensionFoundForFunctionSelector(bytes4)}. The data key relative to `bytes4(0)` is an exception, where no reverts occurs if there is no extension address stored under. This exception is made to allow users to send random data (graffiti) to the account and to be able to react on it.
+     *
+     *   - If there is an address, forward the `msg.data` to the extension using the CALL opcode, appending 52 bytes (20 bytes of `msg.sender` and 32 bytes of `msg.value`). Return what the calls returns, or revert if the call failed.
+     *
+     * 2. If the data sent to this function is of length less than 4 bytes (not a function selector), revert.
+     */
+    // solhint-disable-next-line no-complex-fallback
+    fallback(
+        bytes calldata callData
+    ) external payable virtual returns (bytes memory) {
+        if (msg.data.length < 4) {
+            revert InvalidFunctionSelector(callData);
+        }
+        return _fallbackLSP17Extendable(callData);
+    }
+
+    /**
+     * @dev Reverts whenever someone tries to send native tokens to a LSP8 contract.
+     * @notice LSP8 contract cannot receive native tokens.
+     */
+    receive() external payable virtual {
+        // revert on empty calls with no value
+        if (msg.value == 0) {
+            revert InvalidFunctionSelector(hex"00000000");
+        }
+
+        revert LSP8TokenContractCannotHoldValue();
+    }
+
+    /**
+     * @dev Forwards the call with the received value to an extension mapped to a function selector.
+     *
+     * Calls {_getExtensionAndForwardValue} to get the address of the extension mapped to the function selector being
+     * called on the account. If there is no extension, the address(0) will be returned.
+     * We will always forward the value to the extension, as the LSP8 contract is not supposed to hold any native tokens.
+     *
+     * Reverts if there is no extension for the function being called.
+     *
+     * If there is an extension for the function selector being called, it calls the extension with the
+     * CALL opcode, passing the {msg.data} appended with the 20 bytes of the {msg.sender} and
+     * 32 bytes of the {msg.value}
+     *
+     * @custom:info The LSP8 Token contract should not hold any native tokens. Any native tokens received by the contract
+     * will be forwarded to the extension address mapped to the selector from `msg.sig`.
+     */
+    function _fallbackLSP17Extendable(
+        bytes calldata callData
+    ) internal virtual override returns (bytes memory) {
+        // If there is a function selector
+        (address extension, ) = _getExtensionAndForwardValue(msg.sig);
+
+        // if no extension was found, revert
+        if (extension == address(0))
+            revert NoExtensionFoundForFunctionSelector(msg.sig);
+
+        (bool success, bytes memory result) = extension.call{value: msg.value}(
+            abi.encodePacked(callData, msg.sender, msg.value)
+        );
+
+        if (success) {
+            return result;
+        } else {
+            // `mload(result)` -> offset in memory where `result.length` is located
+            // `add(result, 32)` -> offset in memory where `result` data starts
+            // solhint-disable no-inline-assembly
+            /// @solidity memory-safe-assembly
+            assembly {
+                let resultdata_size := mload(result)
+                revert(add(result, 32), resultdata_size)
+            }
+        }
+    }
+
+    /**
+     * @dev Returns the extension address stored under the following data key:
+     * - {_LSP17_EXTENSION_PREFIX} + `<bytes4>` (Check [LSP2-ERC725YJSONSchema] for encoding the data key).
+     * - If no extension is stored, returns the address(0).
+     */
+    function _getExtensionAndForwardValue(
+        bytes4 functionSelector
+    ) internal view virtual override returns (address, bool) {
+        // Generate the data key relevant for the functionSelector being called
+        bytes32 mappedExtensionDataKey = LSP2Utils.generateMappingKey(
+            _LSP17_EXTENSION_PREFIX,
+            functionSelector
+        );
+
+        // Check if there is an extension stored under the generated data key
+        bytes memory extensionAddress = ERC725YCore._getData(
+            mappedExtensionDataKey
+        );
+        if (extensionAddress.length != 20 && extensionAddress.length != 0)
+            revert InvalidExtensionAddress(extensionAddress);
+
+        return (address(bytes20(extensionAddress)), true);
+    }
+
+    /**
+     * @dev See {IERC165-supportsInterface}.
+     */
+    function supportsInterface(
+        bytes4 interfaceId
+    )
+        public
+        view
+        virtual
+        override(IERC165, ERC725YCore, LSP17Extendable)
+        returns (bool)
+    {
+        return
+            interfaceId == _INTERFACEID_LSP8 ||
+            super.supportsInterface(interfaceId) ||
+            LSP17Extendable._supportsInterfaceInERC165Extension(interfaceId);
+    }
+
+    /**
+     * @inheritdoc LSP4DigitalAssetMetadataInitAbstract
+     * @dev The ERC725Y data key `_LSP8_TOKENID_FORMAT_KEY` cannot be changed
+     * once the identifiable digital asset contract has been deployed.
+     */
+    function _setData(
+        bytes32 dataKey,
+        bytes memory dataValue
+    )
+        internal
+        virtual
+        override(
+            LSP4DigitalAssetMetadataInitAbstract,
+            LSP4DigitalAssetMetadataCore
+        )
+    {
+        if (dataKey == _LSP8_TOKENID_FORMAT_KEY) {
+            revert LSP8TokenIdFormatNotEditable();
+        }
+        LSP4DigitalAssetMetadataInitAbstract._setData(dataKey, dataValue);
+    }
+}

package/contracts/extensions/LSP8Burnable.sol

@@ -0,0 +1,30 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.12;
+
+import {
+    LSP8IdentifiableDigitalAsset
+} from "../LSP8IdentifiableDigitalAsset.sol";
+
+// errors
+import {LSP8NotTokenOperator} from "../LSP8Errors.sol";
+
+/**
+ * @dev LSP8 token extension that allows token holders to destroy both
+ * their own tokens and those that they have an allowance for as an operator.
+ */
+abstract contract LSP8Burnable is LSP8IdentifiableDigitalAsset {
+    /**
+     * @notice Burning tokenId `tokenId`. This tokenId will not be recoverable! (additional data sent: `data`).
+     *
+     * @dev See internal {_burn} function for details.
+     *
+     * @param tokenId The tokenId to burn.
+     * @param data Any extra data to be sent alongside burning the tokenId.
+     */
+    function burn(bytes32 tokenId, bytes memory data) public virtual {
+        if (!_isOperatorOrOwner(msg.sender, tokenId)) {
+            revert LSP8NotTokenOperator(tokenId, msg.sender);
+        }
+        _burn(tokenId, data);
+    }
+}

package/contracts/extensions/LSP8BurnableInitAbstract.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.12;
+
+import {
+    LSP8IdentifiableDigitalAssetInitAbstract
+} from "../LSP8IdentifiableDigitalAssetInitAbstract.sol";
+
+// errors
+import {LSP8NotTokenOperator} from "../LSP8Errors.sol";
+
+/**
+ * @dev LSP8 extension (proxy version) that allows token holders to destroy both
+ * their own tokens and those that they have an allowance for as an operator.
+ */
+abstract contract LSP8BurnableInitAbstract is
+    LSP8IdentifiableDigitalAssetInitAbstract
+{
+    function burn(bytes32 tokenId, bytes memory data) public virtual {
+        if (!_isOperatorOrOwner(msg.sender, tokenId)) {
+            revert LSP8NotTokenOperator(tokenId, msg.sender);
+        }
+        _burn(tokenId, data);
+    }
+}

package/contracts/extensions/LSP8CappedSupply.sol

@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.12;
+
+// modules
+import {
+    LSP8IdentifiableDigitalAsset
+} from "../LSP8IdentifiableDigitalAsset.sol";
+
+/**
+ * @dev LSP8 token extension to add a max token supply cap.
+ */
+abstract contract LSP8CappedSupply is LSP8IdentifiableDigitalAsset {
+    // --- Errors
+
+    /**
+     * @notice The `tokenSupplyCap` must be set and cannot be `0`.
+     * @dev Reverts when setting `0` for the {tokenSupplyCap}. The max token supply MUST be set to a number greater than 0.
+     */
+    error LSP8CappedSupplyRequired();
+
+    /**
+     * @notice Cannot mint anymore as total supply reached the maximum cap.
+     * @dev Reverts when trying to mint tokens but the {totalSupply} has reached the maximum {tokenSupplyCap}.
+     */
+    error LSP8CappedSupplyCannotMintOverCap();
+
+    // --- Storage
+    uint256 private immutable _TOKEN_SUPPLY_CAP;
+
+    /**
+     * @notice Deploying a `LSP8CappedSupply` token contract with max token supply cap set to `tokenSupplyCap_`.
+     * @dev Deploy a `LSP8CappedSupply` token contract and set the maximum token supply token cap up to which
+     * it is not possible to mint more tokens.
+     *
+     * @param tokenSupplyCap_ The maximum token supply.
+     *
+     * @custom:requirements
+     * - `tokenSupplyCap_` MUST NOT be 0.
+     */
+    constructor(uint256 tokenSupplyCap_) {
+        if (tokenSupplyCap_ == 0) {
+            revert LSP8CappedSupplyRequired();
+        }
+
+        _TOKEN_SUPPLY_CAP = tokenSupplyCap_;
+    }
+
+    // --- Token queries
+
+    /**
+     * @notice The maximum supply amount of tokens allowed to exist is `_TOKEN_SUPPLY_CAP`.
+     *
+     * @dev Get the maximum number of tokens that can exist to circulate. Once {totalSupply} reaches
+     * reaches {totalSuuplyCap}, it is not possible to mint more tokens.
+     *
+     * @return The maximum number of tokens that can exist in the contract.
+     */
+    function tokenSupplyCap() public view virtual returns (uint256) {
+        return _TOKEN_SUPPLY_CAP;
+    }
+
+    // --- Transfer functionality
+
+    /**
+     * @dev Same as {_mint} but allows to mint only if newly minted `tokenId` does not increase the {totalSupply}
+     * over the {tokenSupplyCap}.
+     * after a new `tokenId` has of tokens have been minted.
+     *
+     * @custom:requirements
+     * - {totalSupply} + 1 must not be greater than the {tokenSupplyCap} when calling this function.
+     * - `to` cannot be the zero address.
+     */
+    function _mint(
+        address to,
+        bytes32 tokenId,
+        bool force,
+        bytes memory data
+    ) internal virtual override {
+        if (totalSupply() + 1 > tokenSupplyCap()) {
+            revert LSP8CappedSupplyCannotMintOverCap();
+        }
+
+        super._mint(to, tokenId, force, data);
+    }
+}

package/contracts/extensions/LSP8CappedSupplyInitAbstract.sol

@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.12;
+
+// modules
+import {
+    LSP8IdentifiableDigitalAssetInitAbstract
+} from "../LSP8IdentifiableDigitalAssetInitAbstract.sol";
+
+/**
+ * @dev LSP8 token extension to add a max token supply cap.
+ */
+abstract contract LSP8CappedSupplyInitAbstract is
+    LSP8IdentifiableDigitalAssetInitAbstract
+{
+    // --- Errors
+
+    /**
+     * @notice The `tokenSupplyCap` must be set and cannot be `0`.
+     * @dev Reverts when setting `0` for the {tokenSupplyCap}. The max token supply MUST be set to a number greater than 0.
+     */
+    error LSP8CappedSupplyRequired();
+
+    /**
+     * @notice Cannot mint anymore as total supply reached the maximum cap.
+     * @dev Reverts when trying to mint tokens but the {totalSupply} has reached the maximum {tokenSupplyCap}.
+     */
+    error LSP8CappedSupplyCannotMintOverCap();
+
+    // --- Storage
+    uint256 private _tokenSupplyCap;
+
+    /**
+     * @dev Initialize a `LSP8CappedSupplyInitAbstract` token contract and set the maximum token supply token cap up to which
+     * it is not possible to mint more tokens.
+     *
+     * @param tokenSupplyCap_ The maximum token supply.
+     *
+     * @custom:requirements
+     * - `tokenSupplyCap_` MUST NOT be 0.
+     */
+    function _initialize(
+        uint256 tokenSupplyCap_
+    ) internal virtual onlyInitializing {
+        if (tokenSupplyCap_ == 0) {
+            revert LSP8CappedSupplyRequired();
+        }
+
+        _tokenSupplyCap = tokenSupplyCap_;
+    }
+
+    // --- Token queries
+
+    /**
+     * @notice The maximum supply amount of tokens allowed to exist is `_tokenSupplyCap`.
+     *
+     * @dev Get the maximum number of tokens that can exist to circulate. Once {totalSupply} reaches
+     * reaches {totalSuuplyCap}, it is not possible to mint more tokens.
+     *
+     * @return The maximum number of tokens that can exist in the contract.
+     */
+    function tokenSupplyCap() public view virtual returns (uint256) {
+        return _tokenSupplyCap;
+    }
+
+    // --- Transfer functionality
+
+    /**
+     * @dev Same as {_mint} but allows to mint only if newly minted `tokenId` does not increase the {totalSupply}
+     * over the {tokenSupplyCap}.
+     * after a new `tokenId` has of tokens have been minted.
+     *
+     * @custom:requirements
+     * - {totalSupply} + 1 must not be greater than the {tokenSupplyCap} when calling this function.
+     * - `to` cannot be the zero address.
+     */
+    function _mint(
+        address to,
+        bytes32 tokenId,
+        bool force,
+        bytes memory data
+    ) internal virtual override {
+        if (totalSupply() + 1 > tokenSupplyCap()) {
+            revert LSP8CappedSupplyCannotMintOverCap();
+        }
+
+        super._mint(to, tokenId, force, data);
+    }
+}

package/contracts/extensions/LSP8Enumerable.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.12;
+
+// modules
+import {
+    LSP8IdentifiableDigitalAsset,
+    LSP8IdentifiableDigitalAssetCore
+} from "../LSP8IdentifiableDigitalAsset.sol";
+
+/**
+ * @dev LSP8 extension that enables to enumerate over all the `tokenIds` ever minted.
+ *
+ * @custom:warning Note that in this extension contract, any `tokenId` that been burnt is removed from the set of the enumerable tokenIds.
+ */
+abstract contract LSP8Enumerable is LSP8IdentifiableDigitalAsset {
+    // Mapping from token index to token id
+    mapping(uint256 => bytes32) private _indexToken;
+
+    // Mapping from token id to index
+    mapping(bytes32 => uint256) private _tokenIndex;
+
+    /**
+     * @notice Retrieving the `tokenId` for `msg.sender` located in its list at index number `index`.
+     *
+     * @dev Returns a token id at index. See {totalSupply} to get total number of minted tokens.
+     * @param index The index to search to search in the enumerable mapping.
+     * @return TokenId or `bytes32(0)` if no tokenId exist at `index`.
+     */
+    function tokenAt(uint256 index) public view returns (bytes32) {
+        return _indexToken[index];
+    }
+
+    /**
+     * @inheritdoc LSP8IdentifiableDigitalAssetCore
+     *
+     * @param from The address sending the `tokenId` (`address(0)` when `tokenId` is being minted).
+     * @param to The address receiving the `tokenId` (`address(0)` when `tokenId` is being burnt).
+     * @param tokenId The bytes32 identifier of the token being transferred.
+     * @param data The data sent alongside the the token transfer.
+     */
+    function _beforeTokenTransfer(
+        address from,
+        address to,
+        bytes32 tokenId,
+        bytes memory data
+    ) internal virtual override(LSP8IdentifiableDigitalAssetCore) {
+        // `tokenId` being minted
+        if (from == address(0)) {
+            uint256 index = totalSupply();
+            _indexToken[index] = tokenId;
+            _tokenIndex[tokenId] = index;
+        }
+
+        // `tokenId` being burnt
+        if (to == address(0)) {
+            uint256 lastIndex = totalSupply() - 1;
+            uint256 index = _tokenIndex[tokenId];
+            if (index < lastIndex) {
+                bytes32 lastTokenId = _indexToken[lastIndex];
+                _indexToken[index] = lastTokenId;
+                _tokenIndex[lastTokenId] = index;
+            }
+            delete _indexToken[lastIndex];
+            delete _tokenIndex[tokenId];
+        }
+
+        super._beforeTokenTransfer(from, to, tokenId, data);
+    }
+}

package/contracts/extensions/LSP8EnumerableInitAbstract.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.12;
+
+// modules
+import {
+    LSP8IdentifiableDigitalAssetInitAbstract,
+    LSP8IdentifiableDigitalAssetCore
+} from "../LSP8IdentifiableDigitalAssetInitAbstract.sol";
+
+/**
+ * @dev LSP8 extension.
+ */
+abstract contract LSP8EnumerableInitAbstract is
+    LSP8IdentifiableDigitalAssetInitAbstract
+{
+    // Mapping from token index to token id
+    mapping(uint256 => bytes32) private _indexToken;
+
+    // Mapping from token id to index
+    mapping(bytes32 => uint256) private _tokenIndex;
+
+    /**
+     * @notice Retrieving the `tokenId` for `msg.sender` located in its list at index number `index`.
+     *
+     * @dev Returns a token id at index. See {totalSupply} to get total number of minted tokens.
+     * @param index The index to search to search in the enumerable mapping.
+     * @return TokenId or `bytes32(0)` if no tokenId exist at `index`.
+     */
+    function tokenAt(uint256 index) public view returns (bytes32) {
+        return _indexToken[index];
+    }
+
+    /**
+     * @inheritdoc LSP8IdentifiableDigitalAssetCore
+     *
+     * @param from The address sending the `tokenId` (`address(0)` when `tokenId` is being minted).
+     * @param to The address receiving the `tokenId` (`address(0)` when `tokenId` is being burnt).
+     * @param tokenId The bytes32 identifier of the token being transferred.
+     * @param data The data sent alongside the the token transfer.
+     */
+    function _beforeTokenTransfer(
+        address from,
+        address to,
+        bytes32 tokenId,
+        bytes memory data
+    ) internal virtual override(LSP8IdentifiableDigitalAssetCore) {
+        if (from == address(0)) {
+            uint256 index = totalSupply();
+            _indexToken[index] = tokenId;
+            _tokenIndex[tokenId] = index;
+        } else if (to == address(0)) {
+            uint256 lastIndex = totalSupply() - 1;
+            uint256 index = _tokenIndex[tokenId];
+            if (index < lastIndex) {
+                bytes32 lastTokenId = _indexToken[lastIndex];
+                _indexToken[index] = lastTokenId;
+                _tokenIndex[lastTokenId] = index;
+            }
+            delete _indexToken[lastIndex];
+            delete _tokenIndex[tokenId];
+        }
+        super._beforeTokenTransfer(from, to, tokenId, data);
+    }
+}

package/contracts/presets/ILSP8Mintable.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.4;
+
+// interfaces
+import {
+    ILSP8IdentifiableDigitalAsset
+} from "../ILSP8IdentifiableDigitalAsset.sol";
+
+/**
+ * @dev LSP8 extension, mintable.
+ */
+interface ILSP8Mintable is ILSP8IdentifiableDigitalAsset {
+    /**
+     * @param to The address to mint tokens
+     * @param tokenId The tokenId to mint
+     * @param force When set to TRUE, to may be any address but
+     * when set to FALSE to must be a contract that supports LSP1 UniversalReceiver
+     * @param data Additional data the caller wants included in the emitted event, and sent in the hooks to `from` and `to` addresses.
+     * @dev Mints `amount` tokens and transfers it to `to`.
+     *
+     * Requirements:
+     *
+     * - `to` cannot be the zero address.
+     *
+     * Emits a {Transfer} event.
+     */
+    function mint(
+        address to,
+        bytes32 tokenId,
+        bool force,
+        bytes memory data
+    ) external;
+}