lens-modules 1.2.0 → 3.0.1

package/LICENSE

@@ -1,7 +1,5 @@
 MIT License
 
-Copyright (c) 2023 Avara Labs Ltd
-
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights

package/README.md

@@ -1,8 +1,10 @@
-# Lens Module Contracts
+# Lens Modules
 
-This repository contains the module contracts from the core Lens Protocol repo ([link](https://github.com/lens-protocol/core/tree/5454b58664fab805b6888a68ff40915d251f32f3/contracts)) as a standalone library, useful in Hardhat and Foundry projects.
+This repository contains the contracts from the core Lens Protocol repo ([link](https://github.com/lens-protocol/lens-v3/tree/latest-mainnet)) as a standalone library, useful in Hardhat and Foundry projects.
 
-It provides all the libraries, interfaces, and base contracts required when creating follow, collect, and Open Action modules.
+It includes the Solidity source code of the contracts, their ABIs, and deployment addresses for Lens Chain mainnet and testnet.
+
+The files are kept in sync with the `latest-mainnet` tag.
 
 ## Installation
 
@@ -12,138 +14,39 @@ npm i lens-modules
 
 ## Usage
 
-Boilerplate for an Open Action module:
+#### Contracts
+
+Import Lens contracts you want to use in your Solidity project. The paths mirror the `lens-v3` repo structure. Eg:
 
 ```solidity
-pragma solidity ^0.8.21;
-
-import {HubRestricted} from "lens-modules/contracts/base/HubRestricted.sol";
-import {IPublicationActionModule} from "lens-modules/contracts/interfaces/IPublicationActionModule.sol";
-import {Types} from "lens-modules/contracts/libraries/constants/Types.sol";
-import {LensModuleMetadata} from "lens-modules/contracts/modules/LensModuleMetadata.sol";
-
-contract OpenActionModule is 
-    HubRestricted,
-    IPublicationActionModule,
-    LensModuleMetadata
-{
-    constructor(
-        address owner,
-        address hub
-    )
-        Ownable(owner)
-        HubRestricted(hub)
-        LensModuleMetadata()
-    {
-        // ...
-    }
-
-    function supportsInterface(
-        bytes4 interfaceID
-    ) public pure virtual override returns (bool) {
-        return
-            interfaceID == type(IPublicationActionModule).interfaceId ||
-            super.supportsInterface(interfaceID);
-    }
-    
-    function initializePublicationAction(
-        uint256 profileId,
-        uint256 pubId,
-        address /* transactionExecutor */,
-        bytes calldata data
-    ) external override onlyHub returns (bytes memory) {
-        // ...
-    }
-
-    function processPublicationAction(
-        Types.ProcessActionParams calldata params
-    ) external override onlyHub returns (bytes memory) {
-        // ...
-    }
-}
+import {Account} from "lens-modules/contracts/extensions/account/Account.sol";
+import {IGraph} from "lens-modules/contracts/core/interfaces/IGraph.sol";
+import {KeyValue} from "lens-modules/contracts/core/types/Types.sol";
 ```
 
-The library also has the contracts needed to create a Follow or Collect Module. Here's a basic example of a `CollectModule` that can be registered with the platform `CollectPublicationAction` contract.
+#### Deployments
 
-```solidity
-// SPDX-License-Identifier: MIT
-pragma solidity 0.8.23;
-
-import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
-import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
-import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
-import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
-
-import {Types} from "lens-modules/contracts/libraries/constants/Types.sol";
-import {IPublicationActionModule} from "lens-modules/contracts/interfaces/IPublicationActionModule.sol";
-import {HubRestricted} from "lens-modules/contracts/base/HubRestricted.sol";
-import {IModuleRegistry} from "lens-modules/contracts/interfaces/IModuleRegistry.sol";
-import {LensModuleMetadata} from "lens-modules/contracts/modules/LensModuleMetadata.sol";
-import {LensModuleRegistrant} from "lens-modules/contracts/modules/base/LensModuleRegistrant.sol";
-import {ICollectModule} from "lens-modules/contracts/modules/interfaces/ICollectModule.sol";
-import {BaseFeeCollectModule} from "lens-modules/contracts/modules/act/collect/base/BaseFeeCollectModule.sol";
-import {IBaseFeeCollectModule, BaseFeeCollectModuleInitData} from "lens-modules/contracts/modules/interfaces/IBaseFeeCollectModule.sol";
-import {ModuleTypes} from "lens-modules/contracts/modules/libraries/constants/ModuleTypes.sol";
-import {LensModule} from "lens-modules/contracts/modules/LensModule.sol";
-
-contract YourCollectModule is Ownable, BaseFeeCollectModule, LensModuleMetadata {
-    using SafeERC20 for IERC20;
-
-    constructor(
-        address hub,
-        address actionModule,
-        address moduleRegistry,
-        address moduleOwner
-    )
-        Ownable(moduleOwner)
-        BaseFeeCollectModule(hub, actionModule, moduleRegistry)
-        LensModuleMetadata()
-    {}
-
-    function supportsInterface(
-        bytes4 interfaceID
-    ) public pure override(BaseFeeCollectModule, LensModule) returns (bool) {
-        return
-            BaseFeeCollectModule.supportsInterface(interfaceID) ||
-            LensModule.supportsInterface(interfaceID);
-    }
-
-    function initializePublicationCollectModule(
-        uint256 profileId,
-        uint256 pubId,
-        address /* transactionExecutor */,
-        bytes calldata data
-    ) external override onlyActionModule returns (bytes memory) {
-        BaseFeeCollectModuleInitData memory baseInitData = abi.decode(
-            data,
-            (BaseFeeCollectModuleInitData)
-        );
-        _validateBaseInitData(baseInitData);
-        _storeBasePublicationCollectParameters(profileId, pubId, baseInitData);
-        return data;
-    }
-
-    function calculateFee(
-        ModuleTypes.ProcessCollectParams calldata processCollectParams
-    ) public view virtual override returns (uint160) {
-        // Override calculateFee to add custom logic to calculate the fee
-        return
-            _dataByPublicationByProfile[processCollectParams.profileId][
-                processCollectParams.pubId
-            ].amount;
-    }
-
-    function processCollect(
-        ModuleTypes.ProcessCollectParams calldata processCollectParams
-    ) external override returns (bytes memory) {
-        _validateAndStoreCollect(processCollectParams);
-        // Override processCollect to add custom logic to process the collect
-        if (processCollectParams.referrerProfileIds.length == 0) {
-            _processCollect(processCollectParams);
-        } else {
-            _processCollectWithReferral(processCollectParams);
-        }
-        return processCollectParams.data;
-    }
-}
+Use the `Deployments` helper JavaScript class to get the contract addresses of the Lens deployments on mainnet and testnet. Eg:
+
+```javascript
+import { lensDeployments } from "lens-modules/deployments";
+
+const lensFactoryAddress = lensDeployments.mainnet.LensFactory.address;
+```
+
+#### ABIs
+
+Use the `ABIs` helper JavaScript class to get the ABI of any Lens contract. Eg:
+
+```javascript
+import { accountAbi } from "lens-modules/abis";
+
+await walletClient.writeContract({
+  address: "0xYourAccountContractAddress",
+  abi: accountAbi,
+  functionName: "executeTransaction",
+  args: [
+    // ... your function arguments
+  ],
+});
 ```

package/contracts/actions/account/TippingAccountAction.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: UNLICENSED
+// Copyright (C) 2024 Lens Labs. All Rights Reserved.
+pragma solidity ^0.8.26;
+
+import {OwnableMetadataBasedAccountAction} from "./base/OwnableMetadataBasedAccountAction.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {KeyValue} from "../../core/types/Types.sol";
+import {Errors} from "../../core/types/Errors.sol";
+
+contract TippingAccountAction is OwnableMetadataBasedAccountAction {
+    using SafeERC20 for IERC20;
+
+    /// @custom:keccak lens.param.amount
+    bytes32 constant PARAM__TIP_AMOUNT = 0xc8a06abcb0f2366f32dc2741bdf075c3215e3108918311ec0ac742f1ffd37f49;
+    /// @custom:keccak lens.param.token
+    bytes32 constant PARAM__TIP_TOKEN = 0xee737c77be2981e91c179485406e6d793521b20aca5e2137b6c497949a74bc94;
+
+    constructor(address actionHub, address owner, string memory metadataURI)
+        OwnableMetadataBasedAccountAction(actionHub, owner, metadataURI)
+    {}
+
+    function _execute(address originalMsgSender, address account, KeyValue[] calldata params)
+        internal
+        override
+        returns (bytes memory)
+    {
+        address erc20Token;
+        uint256 tipAmount;
+        for (uint256 i = 0; i < params.length; i++) {
+            if (params[i].key == PARAM__TIP_AMOUNT) {
+                tipAmount = abi.decode(params[i].value, (uint256));
+            } else if (params[i].key == PARAM__TIP_TOKEN) {
+                erc20Token = abi.decode(params[i].value, (address));
+            }
+        }
+        require(tipAmount > 0, Errors.InvalidParameter());
+        IERC20(erc20Token).safeTransferFrom(originalMsgSender, account, tipAmount);
+        return "";
+    }
+}

package/contracts/actions/account/base/BaseAccountAction.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: UNLICENSED
+// Copyright (C) 2024 Lens Labs. All Rights Reserved.
+pragma solidity ^0.8.26;
+
+import {KeyValue} from "../../../core/types/Types.sol";
+import {BaseAction} from "../../base/BaseAction.sol";
+import {IAccountAction} from "../../../extensions/actions/ActionHub.sol";
+import {Errors} from "../../../core/types/Errors.sol";
+
+abstract contract BaseAccountAction is BaseAction, IAccountAction {
+    constructor(address actionHub) BaseAction(actionHub) {}
+
+    function configure(address originalMsgSender, address account, KeyValue[] calldata params)
+        external
+        override
+        onlyActionHub
+        returns (bytes memory)
+    {
+        return _configure(originalMsgSender, account, params);
+    }
+
+    function execute(address originalMsgSender, address account, KeyValue[] calldata params)
+        external
+        override
+        onlyActionHub
+        returns (bytes memory)
+    {
+        return _execute(originalMsgSender, account, params);
+    }
+
+    function setDisabled(address originalMsgSender, address account, bool isDisabled, KeyValue[] calldata params)
+        external
+        override
+        onlyActionHub
+        returns (bytes memory)
+    {
+        return _setDisabled(originalMsgSender, account, isDisabled, params);
+    }
+
+    function _configure(address originalMsgSender, address, /* account */ KeyValue[] calldata /* params */ )
+        internal
+        virtual
+        returns (bytes memory)
+    {
+        return _configureUniversalAction(originalMsgSender);
+    }
+
+    function _execute(address originalMsgSender, address account, KeyValue[] calldata params)
+        internal
+        virtual
+        returns (bytes memory);
+
+    function _setDisabled(
+        address, /* originalMsgSender */
+        address, /* account */
+        bool, /* isDisabled */
+        KeyValue[] calldata /* params */
+    ) internal virtual returns (bytes memory) {
+        revert Errors.NotImplemented();
+    }
+}

package/contracts/actions/account/base/OwnableMetadataBasedAccountAction.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: UNLICENSED
+// Copyright (C) 2024 Lens Labs. All Rights Reserved.
+pragma solidity ^0.8.26;
+
+import {Ownable} from "../../../core/access/Ownable.sol";
+import {MetadataBased} from "../../../core/base/MetadataBased.sol";
+import {BaseAccountAction} from "./BaseAccountAction.sol";
+
+abstract contract OwnableMetadataBasedAccountAction is BaseAccountAction, Ownable, MetadataBased {
+    event Lens_AccountAction_MetadataURISet(string metadataURI);
+
+    constructor(address actionHub, address owner, string memory metadataURI) BaseAccountAction(actionHub) {
+        _transferOwnership(owner);
+        _setMetadataURI(metadataURI);
+    }
+
+    function _emitMetadataURISet(string memory metadataURI, address /* source */ ) internal virtual override {
+        emit Lens_AccountAction_MetadataURISet(metadataURI);
+    }
+
+    function _beforeMetadataURIUpdate(string memory /* metadataURI */ ) internal virtual override onlyOwner {
+        return;
+    }
+}

package/contracts/actions/base/BaseAction.sol

@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: UNLICENSED
+// Copyright (C) 2024 Lens Labs. All Rights Reserved.
+pragma solidity ^0.8.26;
+
+import {UNIVERSAL_ACTION_MAGIC_VALUE} from "../../extensions/actions/ActionHub.sol";
+import {Errors} from "../../core/types/Errors.sol";
+
+abstract contract BaseAction {
+    address immutable ACTION_HUB;
+
+    /// @custom:keccak lens.storage.Action.configured
+    bytes32 constant STORAGE__ACTION_CONFIGURED = 0x852bead036b7ef35b8026346140cc688bafe817a6c3491812e6d994b1bcda6d9;
+
+    modifier onlyActionHub() {
+        require(msg.sender == ACTION_HUB, Errors.InvalidMsgSender());
+        _;
+    }
+
+    constructor(address actionHub) {
+        ACTION_HUB = actionHub;
+    }
+
+    function _configureUniversalAction(address originalMsgSender) internal onlyActionHub returns (bytes memory) {
+        bool configured;
+        assembly {
+            configured := sload(STORAGE__ACTION_CONFIGURED)
+        }
+        require(!configured, Errors.RedundantStateChange());
+        require(originalMsgSender == address(0), Errors.InvalidParameter());
+        assembly {
+            sstore(STORAGE__ACTION_CONFIGURED, 1)
+        }
+        return abi.encode(UNIVERSAL_ACTION_MAGIC_VALUE);
+    }
+}

package/contracts/actions/post/TippingPostAction.sol

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: UNLICENSED
+// Copyright (C) 2024 Lens Labs. All Rights Reserved.
+pragma solidity ^0.8.26;
+
+import {OwnableMetadataBasedPostAction} from "./base/OwnableMetadataBasedPostAction.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+import {KeyValue} from "../../core/types/Types.sol";
+import {IFeed} from "../../core/interfaces/IFeed.sol";
+import {Errors} from "../../core/types/Errors.sol";
+
+contract TippingPostAction is OwnableMetadataBasedPostAction {
+    using SafeERC20 for IERC20;
+
+    /// @custom:keccak lens.param.amount
+    bytes32 constant PARAM__TIP_AMOUNT = 0xc8a06abcb0f2366f32dc2741bdf075c3215e3108918311ec0ac742f1ffd37f49;
+    /// @custom:keccak lens.param.token
+    bytes32 constant PARAM__TIP_TOKEN = 0xee737c77be2981e91c179485406e6d793521b20aca5e2137b6c497949a74bc94;
+
+    constructor(address actionHub, address owner, string memory metadataURI)
+        OwnableMetadataBasedPostAction(actionHub, owner, metadataURI)
+    {}
+
+    function _execute(address originalMsgSender, address feed, uint256 postId, KeyValue[] calldata params)
+        internal
+        override
+        returns (bytes memory)
+    {
+        address erc20Token;
+        uint256 tipAmount;
+        for (uint256 i = 0; i < params.length; i++) {
+            if (params[i].key == PARAM__TIP_AMOUNT) {
+                tipAmount = abi.decode(params[i].value, (uint256));
+            } else if (params[i].key == PARAM__TIP_TOKEN) {
+                erc20Token = abi.decode(params[i].value, (address));
+            }
+        }
+        require(tipAmount > 0, Errors.InvalidParameter());
+        address account = IFeed(feed).getPostAuthor(postId);
+        IERC20(erc20Token).safeTransferFrom(originalMsgSender, account, tipAmount);
+        return abi.encode(account);
+    }
+}

package/contracts/actions/post/base/BasePostAction.sol

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: UNLICENSED
+// Copyright (C) 2024 Lens Labs. All Rights Reserved.
+pragma solidity ^0.8.26;
+
+import {KeyValue} from "../../../core/types/Types.sol";
+import {BaseAction} from "../../base/BaseAction.sol";
+import {IPostAction} from "../../../extensions/actions/ActionHub.sol";
+import {Errors} from "../../../core/types/Errors.sol";
+
+abstract contract BasePostAction is BaseAction, IPostAction {
+    constructor(address actionHub) BaseAction(actionHub) {}
+
+    function configure(address originalMsgSender, address feed, uint256 postId, KeyValue[] calldata params)
+        external
+        override
+        onlyActionHub
+        returns (bytes memory)
+    {
+        return _configure(originalMsgSender, feed, postId, params);
+    }
+
+    function execute(address originalMsgSender, address feed, uint256 postId, KeyValue[] calldata params)
+        external
+        override
+        onlyActionHub
+        returns (bytes memory)
+    {
+        return _execute(originalMsgSender, feed, postId, params);
+    }
+
+    function setDisabled(
+        address originalMsgSender,
+        address feed,
+        uint256 postId,
+        bool isDisabled,
+        KeyValue[] calldata params
+    ) external override onlyActionHub returns (bytes memory) {
+        return _setDisabled(originalMsgSender, feed, postId, isDisabled, params);
+    }
+
+    function _configure(
+        address originalMsgSender,
+        address, /* feed */
+        uint256, /* postId */
+        KeyValue[] calldata /* params */
+    ) internal virtual returns (bytes memory) {
+        return _configureUniversalAction(originalMsgSender);
+    }
+
+    function _execute(address originalMsgSender, address feed, uint256 postId, KeyValue[] calldata params)
+        internal
+        virtual
+        returns (bytes memory);
+
+    function _setDisabled(
+        address, /* originalMsgSender */
+        address, /* feed */
+        uint256, /* postId */
+        bool, /* isDisabled */
+        KeyValue[] calldata /* params */
+    ) internal virtual returns (bytes memory) {
+        revert Errors.NotImplemented();
+    }
+}

package/contracts/actions/post/base/OwnableMetadataBasedPostAction.sol

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: UNLICENSED
+// Copyright (C) 2024 Lens Labs. All Rights Reserved.
+pragma solidity ^0.8.26;
+
+import {Ownable} from "../../../core/access/Ownable.sol";
+import {MetadataBased} from "../../../core/base/MetadataBased.sol";
+import {BasePostAction} from "./BasePostAction.sol";
+
+abstract contract OwnableMetadataBasedPostAction is BasePostAction, Ownable, MetadataBased {
+    event Lens_PostAction_MetadataURISet(string metadataURI);
+
+    constructor(address actionHub, address owner, string memory metadataURI) BasePostAction(actionHub) {
+        _transferOwnership(owner);
+        _setMetadataURI(metadataURI);
+    }
+
+    function _emitMetadataURISet(string memory metadataURI, address /* source */ ) internal virtual override {
+        emit Lens_PostAction_MetadataURISet(metadataURI);
+    }
+
+    function _beforeMetadataURIUpdate(string memory /* metadataURI */ ) internal virtual override onlyOwner {
+        return;
+    }
+}

package/contracts/actions/post/collect/IERC7572.sol

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: UNLICENSED
+// Copyright (C) 2024 Lens Labs. All Rights Reserved.
+// As appears in https://eips.ethereum.org/EIPS/eip-7572
+
+pragma solidity ^0.8.26;
+
+/**
+ * This specification standardizes contractURI() to return contract-level metadata. This is useful for dapps and
+ * offchain indexers to show rich information about a contract, such as its name, description and image, without
+ * specifying it manually or individually for each dapp.
+ */
+interface IERC7572 {
+    function contractURI() external view returns (string memory);
+
+    event ContractURIUpdated();
+}

package/contracts/actions/post/collect/ISimpleCollectAction.sol

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: UNLICENSED
+// Copyright (C) 2024 Lens Labs. All Rights Reserved.
+pragma solidity ^0.8.26;
+
+import {IPostAction} from "../../../extensions/actions/ActionHub.sol";
+
+/**
+ * @notice A storage struct containing all data regarding a post's collect action.
+ *
+ * @param amount The collecting cost associated with this publication. 0 for free collect.
+ * @param collectLimit The maximum number of collects for this publication. 0 for no limit.
+ * @param token The token associated with this publication.
+ * @param currentCollects The current number of collects for this publication.
+ * @param recipient Recipient of collect fees.
+ * @param endTimestamp The end timestamp after which collecting is impossible. 0 for no expiry.
+ * @param collectionAddress The address of the collectible ERC721 contract.
+ */
+struct CollectActionData {
+    uint160 amount;
+    uint96 collectLimit;
+    address token;
+    uint96 currentCollects;
+    address recipient;
+    uint72 endTimestamp;
+    address followerOnlyGraph;
+    address collectionAddress;
+    bool isImmutable;
+    bool isDisabled;
+}
+
+interface ISimpleCollectAction is IPostAction {
+    function getCollectActionData(address feed, uint256 postId) external view returns (CollectActionData memory);
+}

package/contracts/actions/post/collect/LensCollectedPost.sol

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: UNLICENSED
+// Copyright (C) 2024 Lens Labs. All Rights Reserved.
+pragma solidity ^0.8.26;
+
+import "../../../../../../../core/base/LensERC721.sol";
+import {IERC7572} from "./IERC7572.sol";
+import {IFeed} from "../../../core/interfaces/IFeed.sol";
+import {ITokenURIProvider} from "../../../core/interfaces/ITokenURIProvider.sol";
+import {Errors} from "../../../core/types/Errors.sol";
+
+/**
+ * @notice A contract that represents a Lens Collected Post.
+ *
+ * @dev This contract is used to store the metadata of a Lens Collected Post.
+ * It inherits from LensERC721 and implements the IERC7572 interface.
+ * The contractURI() function returns the contract-level metadata making it compatible with the EIP-7572 proposed
+ * standard and useful for dapps and offchain indexers to show rich information about the post itself.
+ *
+ * If the Collect is immutable - it will snapshot the content of the post and always return the snapshotted tokenURI
+ * even if the post was updated or deleted. The contractURI, however, always stays the same, as it was at the moment of
+ * Collect creation.
+ */
+contract LensCollectedPost is LensERC721, IERC7572 {
+    string internal _contentURISnapshot;
+    string internal _contractURI;
+    address internal immutable _feed;
+    uint256 internal immutable _postId;
+    address internal immutable _collectAction;
+
+    constructor(address feed, uint256 postId, bool isImmutable) {
+        LensERC721._initialize("Lens Collected Post", "LCP", ITokenURIProvider(address(0)));
+        string memory contentURI = IFeed(feed).getPost(postId).contentURI;
+        require(bytes(contentURI).length > 0, Errors.InvalidParameter());
+        _feed = feed;
+        _postId = postId;
+        _contractURI = contentURI;
+        _collectAction = msg.sender;
+        if (isImmutable) {
+            _contentURISnapshot = contentURI;
+        }
+        emit ContractURIUpdated();
+    }
+
+    function mint(address to, uint256 tokenId) external {
+        require(msg.sender == _collectAction, Errors.InvalidMsgSender());
+        _mint(to, tokenId);
+    }
+
+    // Getters
+
+    function contractURI() external view returns (string memory) {
+        return _contractURI;
+    }
+
+    function tokenURI(uint256 /*tokenId*/ ) public view override returns (string memory) {
+        if (bytes(_contentURISnapshot).length > 0) {
+            return _contentURISnapshot;
+        } else {
+            string memory contentURI = IFeed(_feed).getPost(_postId).contentURI;
+            // If content was deleted we fail. You can override this to return the empty URI if preferred.
+            require(bytes(contentURI).length > 0, Errors.DoesNotExist());
+            return contentURI;
+        }
+    }
+
+    // Internal
+
+    // Disabling integrated LensERC721 tokenURIProvider
+    function _beforeTokenURIProviderSet(ITokenURIProvider /* tokenURIProvider */ ) internal pure override {
+        revert Errors.NotImplemented();
+    }
+}