lens-modules 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+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
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,51 @@
+# Lens Module Contracts
+
+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.
+
+## Installation
+
+```
+npm install lens-modules
+```
+
+## Usage
+
+```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
+    )
+        HubRestricted(hub)
+        LensModuleMetadata()
+    {
+        // ...
+    }
+
+    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) {
+        // ...
+    }
+}
+```

package/contracts/base/HubRestricted.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.15;
+
+import {Errors} from '../libraries/constants/Errors.sol';
+
+/**
+ * @title HubRestricted
+ * @author Lens Protocol
+ *
+ * @notice This abstract contract adds a public `HUB` immutable field, as well as an `onlyHub` modifier,
+ * to inherit from contracts that have functions restricted to be only called by the Lens hub.
+ */
+abstract contract HubRestricted {
+    address public immutable HUB;
+
+    modifier onlyHub() {
+        if (msg.sender != HUB) {
+            revert Errors.NotHub();
+        }
+        _;
+    }
+
+    constructor(address hub) {
+        HUB = hub;
+    }
+}

package/contracts/interfaces/ICollectNFT.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.6.0;
+
+/**
+ * @title ICollectNFT
+ * @author Lens Protocol
+ *
+ * @notice This is the interface for the CollectNFT contract. Which is cloned upon the first collect for any given
+ * publication.
+ */
+interface ICollectNFT {
+    /**
+     * @notice Initializes the collect NFT, setting the feed as the privileged minter, storing the collected publication pointer
+     * and initializing the name and symbol in the LensNFTBase contract.
+     * @custom:permissions CollectPublicationAction.
+     *
+     * @param profileId The token ID of the profile in the hub that this Collect NFT points to.
+     * @param pubId The profile publication ID in the hub that this Collect NFT points to.
+     */
+    function initialize(uint256 profileId, uint256 pubId) external;
+
+    /**
+     * @notice Mints a collect NFT to the specified address. This can only be called by the hub and is called
+     * upon collection.
+     * @custom:permissions CollectPublicationAction.
+     *
+     * @param to The address to mint the NFT to.
+     *
+     * @return uint256 An integer representing the minted token ID.
+     */
+    function mint(address to) external returns (uint256);
+
+    /**
+     * @notice Returns the source publication of this collect NFT.
+     *
+     * @return tuple First is the profile ID, and second is the publication ID.
+     */
+    function getSourcePublicationPointer() external view returns (uint256, uint256);
+}

package/contracts/interfaces/IERC721Burnable.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.6.0;
+
+/**
+ * @title IERC721Burnable
+ * @author Lens Protocol
+ *
+ * @notice Extension of ERC-721 including a function that allows the token to be burned.
+ */
+interface IERC721Burnable {
+    /**
+     * @notice Burns an NFT, removing it from circulation and essentially destroying it.
+     * @custom:permission Owner of the NFT.
+     *
+     * @param tokenId The token ID of the token to burn.
+     */
+    function burn(uint256 tokenId) external;
+}

package/contracts/interfaces/IERC721MetaTx.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.6.0;
+
+/**
+ * @title IERC721MetaTx
+ * @author Lens Protocol
+ *
+ * @notice Extension of ERC-721 including meta-tx signatures related functions.
+ */
+interface IERC721MetaTx {
+    /**
+     * @notice Returns the current signature nonce of the given signer.
+     *
+     * @param signer The address for which to query the nonce.
+     *
+     * @return uint256 The current nonce of the given signer.
+     */
+    function nonces(address signer) external view returns (uint256);
+
+    /**
+     * @notice Returns the EIP-712 domain separator for this contract.
+     *
+     * @return bytes32 The domain separator.
+     */
+    function getDomainSeparator() external view returns (bytes32);
+}

package/contracts/interfaces/IERC721Timestamped.sol

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.6.0;
+
+import {Types} from '../libraries/constants/Types.sol';
+
+/**
+ * @title IERC721Timestamped
+ * @author Lens Protocol
+ *
+ * @notice Extension of ERC-721 including a struct for token data, which contains the owner and the mint timestamp, as
+ * well as their associated getters.
+ */
+interface IERC721Timestamped {
+    /**
+     * @notice Returns the mint timestamp associated with a given NFT.
+     *
+     * @param tokenId The token ID of the NFT to query the mint timestamp for.
+     *
+     * @return uint256 Mint timestamp, this is stored as a uint96 but returned as a uint256 to reduce unnecessary
+     * padding.
+     */
+    function mintTimestampOf(uint256 tokenId) external view returns (uint256);
+
+    /**
+     * @notice Returns the token data associated with a given NFT. This allows fetching the token owner and
+     * mint timestamp in a single call.
+     *
+     * @param tokenId The token ID of the NFT to query the token data for.
+     *
+     * @return TokenData A struct containing both the owner address and the mint timestamp.
+     */
+    function tokenDataOf(uint256 tokenId) external view returns (Types.TokenData memory);
+
+    /**
+     * @notice Returns whether a token with the given token ID exists.
+     *
+     * @param tokenId The token ID of the NFT to check existence for.
+     *
+     * @return bool True if the token exists.
+     */
+    function exists(uint256 tokenId) external view returns (bool);
+
+    /**
+     * @notice Returns the amount of tokens in circulation.
+     *
+     * @return uint256 The current total supply of tokens.
+     */
+    function totalSupply() external view returns (uint256);
+}

package/contracts/interfaces/IFollowModule.sol

@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.6.0;
+
+/**
+ * @title IFollowModule
+ * @author Lens Protocol
+ *
+ * @notice This is the standard interface for all Lens-compatible Follow Modules.
+ * These are responsible for processing the follow actions and can be used to implement any kind of follow logic.
+ * For example:
+ *  - Token-gated follows (e.g. a user must hold a certain amount of a token to follow a profile).
+ *  - Paid follows (e.g. a user must pay a certain amount of a token to follow a profile).
+ *  - Rewarding users for following a profile.
+ *  - Etc.
+ */
+interface IFollowModule {
+    /**
+     * @notice Initializes a follow module for a given Lens profile.
+     * @custom:permissions LensHub.
+     *
+     * @param profileId The Profile ID to initialize this follow module for.
+     * @param transactionExecutor The address of the transaction executor (e.g. for any funds to transferFrom).
+     * @param data Arbitrary data passed from the user to be decoded by the Follow Module during initialization.
+     *
+     * @return bytes The encoded data to be emitted from the hub.
+     */
+    function initializeFollowModule(
+        uint256 profileId,
+        address transactionExecutor,
+        bytes calldata data
+    ) external returns (bytes memory);
+
+    /**
+     * @notice Processes a given follow.
+     * @custom:permissions LensHub.
+     *
+     * @param followerProfileId The Profile ID of the follower's profile.
+     * @param followTokenId The Follow Token ID that is being used to follow. Zero if we are processing a new fresh
+     * follow, in this case, the follow ID assigned can be queried from the Follow NFT collection if needed.
+     * @param transactionExecutor The address of the transaction executor (e.g. for any funds to transferFrom).
+     * @param targetProfileId The token ID of the profile being followed.
+     * @param data Arbitrary data passed by the follower.
+     *
+     * @return bytes Any custom ABI-encoded data. This will be a LensHub event params that can be used by
+     * indexers or UIs.
+     */
+    function processFollow(
+        uint256 followerProfileId,
+        uint256 followTokenId,
+        address transactionExecutor,
+        uint256 targetProfileId,
+        bytes calldata data
+    ) external returns (bytes memory);
+}

package/contracts/interfaces/ILensERC721.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.6.0;
+
+import {IERC721} from '@openzeppelin/contracts/token/ERC721/IERC721.sol';
+import {IERC721Timestamped} from '../interfaces/IERC721Timestamped.sol';
+import {IERC721Burnable} from '../interfaces/IERC721Burnable.sol';
+import {IERC721MetaTx} from '../interfaces/IERC721MetaTx.sol';
+import {IERC721Metadata} from '@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol';
+
+interface ILensERC721 is IERC721, IERC721Timestamped, IERC721Burnable, IERC721MetaTx, IERC721Metadata {}

package/contracts/interfaces/ILensGovernable.sol

@@ -0,0 +1,141 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.6.0;
+
+import {Types} from '../libraries/constants/Types.sol';
+
+/**
+ * @title ILensGovernable
+ * @author Lens Protocol
+ *
+ * @notice This is the interface for the Lens Protocol main governance functions.
+ */
+interface ILensGovernable {
+    /**
+     * @notice Sets the privileged governance role.
+     * @custom:permissions Governance.
+     *
+     * @param newGovernance The new governance address to set.
+     */
+    function setGovernance(address newGovernance) external;
+
+    /**
+     * @notice Sets the emergency admin, which is a permissioned role able to set the protocol state.
+     * @custom:permissions Governance.
+     *
+     * @param newEmergencyAdmin The new emergency admin address to set.
+     */
+    function setEmergencyAdmin(address newEmergencyAdmin) external;
+
+    /**
+     * @notice Sets the protocol state to either a global pause, a publishing pause or an unpaused state.
+     * @custom:permissions Governance or Emergency Admin. Emergency Admin can only restrict more.
+     *
+     * @param newState The state to set. It can be one of the following:
+     *  - Unpaused: The protocol is fully operational.
+     *  - PublishingPaused: The protocol is paused for publishing, but it is still operational for others operations.
+     *  - Paused: The protocol is paused for all operations.
+     */
+    function setState(Types.ProtocolState newState) external;
+
+    /**
+     * @notice Adds or removes a profile creator from the whitelist.
+     * @custom:permissions Governance.
+     *
+     * @param profileCreator The profile creator address to add or remove from the whitelist.
+     * @param whitelist Whether or not the profile creator should be whitelisted.
+     */
+    function whitelistProfileCreator(address profileCreator, bool whitelist) external;
+
+    /**
+     * @notice Sets the profile token URI contract.
+     * @custom:permissions Governance.
+     *
+     * @param profileTokenURIContract The profile token URI contract to set.
+     */
+    function setProfileTokenURIContract(address profileTokenURIContract) external;
+
+    /**
+     * @notice Sets the follow token URI contract.
+     * @custom:permissions Governance.
+     *
+     * @param followTokenURIContract The follow token URI contract to set.
+     */
+    function setFollowTokenURIContract(address followTokenURIContract) external;
+
+    /**
+     * @notice Sets the treasury address.
+     * @custom:permissions Governance
+     *
+     * @param newTreasury The new treasury address to set.
+     */
+    function setTreasury(address newTreasury) external;
+
+    /**
+     * @notice Sets the treasury fee.
+     * @custom:permissions Governance
+     *
+     * @param newTreasuryFee The new treasury fee to set.
+     */
+    function setTreasuryFee(uint16 newTreasuryFee) external;
+
+    /**
+     * @notice Returns the currently configured governance address.
+     *
+     * @return address The address of the currently configured governance.
+     */
+    function getGovernance() external view returns (address);
+
+    /**
+     * @notice Gets the state currently set in the protocol. It could be a global pause, a publishing pause or an
+     * unpaused state.
+     * @custom:permissions Anyone.
+     *
+     * @return Types.ProtocolState The state currently set in the protocol.
+     */
+    function getState() external view returns (Types.ProtocolState);
+
+    /**
+     * @notice Returns whether or not a profile creator is whitelisted.
+     *
+     * @param profileCreator The address of the profile creator to check.
+     *
+     * @return bool True if the profile creator is whitelisted, false otherwise.
+     */
+    function isProfileCreatorWhitelisted(address profileCreator) external view returns (bool);
+
+    /**
+     * @notice Returns the treasury address.
+     *
+     * @return address The treasury address.
+     */
+    function getTreasury() external view returns (address);
+
+    /**
+     * @notice Returns the treasury fee.
+     *
+     * @return uint16 The treasury fee.
+     */
+    function getTreasuryFee() external view returns (uint16);
+
+    /**
+     * @notice Returns the treasury address and treasury fee in a single call.
+     *
+     * @return tuple First, the treasury address, second, the treasury fee.
+     */
+    function getTreasuryData() external view returns (address, uint16);
+
+    /**
+     * @notice Gets the profile token URI contract.
+     *
+     * @return address The profile token URI contract.
+     */
+    function getProfileTokenURIContract() external view returns (address);
+
+    /**
+     * @notice Gets the follow token URI contract.
+     *
+     * @return address The follow token URI contract.
+     */
+    function getFollowTokenURIContract() external view returns (address);
+}

package/contracts/interfaces/ILensHub.sol

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.6.0;
+
+import {ILensProtocol} from '../interfaces/ILensProtocol.sol';
+import {ILensGovernable} from '../interfaces/ILensGovernable.sol';
+import {ILensHubEventHooks} from '../interfaces/ILensHubEventHooks.sol';
+import {ILensImplGetters} from '../interfaces/ILensImplGetters.sol';
+import {ILensProfiles} from '../interfaces/ILensProfiles.sol';
+import {ILensVersion} from '../interfaces/ILensVersion.sol';
+
+interface ILensHub is
+    ILensProfiles,
+    ILensProtocol,
+    ILensGovernable,
+    ILensHubEventHooks,
+    ILensImplGetters,
+    ILensVersion
+{}

package/contracts/interfaces/ILensHubEventHooks.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.6.0;
+
+/**
+ * @title ILensHubEventHooks
+ * @author Lens Protocol
+ *
+ * @notice This is the interface for the LensHub contract's event hooks. As we want most of the core events to be
+ * emitted by the LensHub contract, event hooks are needed for core events generated by pheripheral contracts.
+ */
+interface ILensHubEventHooks {
+    /**
+     * @dev Helper function to emit an `Unfollowed` event from the hub, to be consumed by indexers to track unfollows.
+     * @custom:permissions FollowNFT of the Profile unfollowed.
+     *
+     * @param unfollowerProfileId The ID of the profile that executed the unfollow.
+     * @param idOfProfileUnfollowed The ID of the profile that was unfollowed.
+     * @param transactionExecutor The address of the account executing the unfollow operation.
+     */
+    function emitUnfollowedEvent(
+        uint256 unfollowerProfileId,
+        uint256 idOfProfileUnfollowed,
+        address transactionExecutor
+    ) external;
+}

package/contracts/interfaces/ILensImplGetters.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.6.0;
+
+/**
+ * @title ILensImplGetters
+ * @author Lens Protocol
+ *
+ * @notice This is the interface for the LensHub contract's implementation getters. These implementations will be used
+ * for deploying each respective contract for each profile.
+ */
+interface ILensImplGetters {
+    /**
+     * @notice Returns the Follow NFT implementation address that is used for all deployed Follow NFTs.
+     *
+     * @return address The Follow NFT implementation address.
+     */
+    function getFollowNFTImpl() external view returns (address);
+
+    /**
+     * @notice Returns the Collect NFT implementation address that is used for each new deployed Collect NFT.
+     * @custom:pending-deprecation
+     *
+     * @return address The Collect NFT implementation address.
+     */
+    function getLegacyCollectNFTImpl() external view returns (address);
+
+    /**
+     * @notice Returns the address of the registry that stores all modules that are used by the Lens Protocol.
+     *
+     * @return address The address of the Module Registry contract.
+     */
+    function getModuleRegistry() external view returns (address);
+}

package/contracts/interfaces/ILensProfiles.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.6.0;
+
+import {ILensERC721} from '../interfaces/ILensERC721.sol';
+
+interface ILensProfiles is ILensERC721 {
+    /**
+     * @notice DANGER: Triggers disabling the profile protection mechanism for the msg.sender, which will allow
+     * transfers or approvals over profiles held by it.
+     * Disabling the mechanism will have a timelock before it becomes effective, allowing the owner to re-enable
+     * the protection back in case of being under attack.
+     * The protection layer only applies to EOA wallets.
+     */
+    function DANGER__disableTokenGuardian() external;
+
+    /**
+     * @notice Enables back the profile protection mechanism for the msg.sender, preventing profile transfers or
+     * approvals (except when revoking them).
+     * The protection layer only applies to EOA wallets.
+     */
+    function enableTokenGuardian() external;
+
+    /**
+     * @notice Returns the timestamp at which the Token Guardian will become effectively disabled.
+     *
+     * @param wallet The address to check the timestamp for.
+     *
+     * @return uint256 The timestamp at which the Token Guardian will become effectively disabled. Zero if enabled.
+     */
+    function getTokenGuardianDisablingTimestamp(address wallet) external view returns (uint256);
+}