lens-modules 1.0.13 → 1.1.0

package/contracts/base/LensGovernable.sol

@@ -0,0 +1,114 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.15;
+
+import {ILensGovernable} from '../interfaces/ILensGovernable.sol';
+import {GovernanceLib} from '../libraries/GovernanceLib.sol';
+import {ValidationLib} from '../libraries/ValidationLib.sol';
+import {StorageLib} from '../libraries/StorageLib.sol';
+import {Types} from '../libraries/constants/Types.sol';
+import {Events} from '../libraries/constants/Events.sol';
+
+abstract contract LensGovernable is ILensGovernable {
+    /**
+     * @dev This modifier reverts if the caller is not the configured governance address.
+     */
+    modifier onlyGov() {
+        ValidationLib.validateCallerIsGovernance();
+        _;
+    }
+
+    /////////////////////////////////
+    ///        GOV FUNCTIONS      ///
+    /////////////////////////////////
+
+    /// @inheritdoc ILensGovernable
+    function setGovernance(address newGovernance) external override onlyGov {
+        GovernanceLib.setGovernance(newGovernance);
+    }
+
+    /// @inheritdoc ILensGovernable
+    function setEmergencyAdmin(address newEmergencyAdmin) external override onlyGov {
+        GovernanceLib.setEmergencyAdmin(newEmergencyAdmin);
+    }
+
+    /// @inheritdoc ILensGovernable
+    function setState(Types.ProtocolState newState) external override {
+        // Access control is handled inside the library because we need to check for both EmergencyAdmin and Governance.
+        GovernanceLib.setState(newState);
+    }
+
+    /// @inheritdoc ILensGovernable
+    function setTreasury(address newTreasury) external override onlyGov {
+        GovernanceLib.setTreasury(newTreasury);
+    }
+
+    /// @inheritdoc ILensGovernable
+    function setTreasuryFee(uint16 newTreasuryFee) external override onlyGov {
+        GovernanceLib.setTreasuryFee(newTreasuryFee);
+    }
+
+    ///@inheritdoc ILensGovernable
+    function whitelistProfileCreator(address profileCreator, bool whitelist) external override onlyGov {
+        GovernanceLib.whitelistProfileCreator(profileCreator, whitelist);
+    }
+
+    function setProfileTokenURIContract(address profileTokenURIContract) external override onlyGov {
+        GovernanceLib.setProfileTokenURIContract(profileTokenURIContract);
+        emit Events.BatchMetadataUpdate({fromTokenId: 0, toTokenId: type(uint256).max});
+    }
+
+    function setFollowTokenURIContract(address followTokenURIContract) external override onlyGov {
+        GovernanceLib.setFollowTokenURIContract(followTokenURIContract);
+    }
+
+    ///////////////////////////////////////////
+    ///        EXTERNAL VIEW FUNCTIONS      ///
+    ///////////////////////////////////////////
+
+    /// @inheritdoc ILensGovernable
+    function getGovernance() external view override returns (address) {
+        return StorageLib.getGovernance();
+    }
+
+    function getProfileTokenURIContract() external view override returns (address) {
+        return StorageLib.getProfileTokenURIContract();
+    }
+
+    function getFollowTokenURIContract() external view override returns (address) {
+        return StorageLib.getFollowTokenURIContract();
+    }
+
+    /**
+     * @notice Returns the current protocol state.
+     *
+     * @return ProtocolState The Protocol state, an enum, where:
+     *      0: Unpaused
+     *      1: PublishingPaused
+     *      2: Paused
+     */
+    function getState() external view override returns (Types.ProtocolState) {
+        return StorageLib.getState();
+    }
+
+    /// @inheritdoc ILensGovernable
+    function isProfileCreatorWhitelisted(address profileCreator) external view override returns (bool) {
+        return StorageLib.profileCreatorWhitelisted()[profileCreator];
+    }
+
+    /// @inheritdoc ILensGovernable
+    function getTreasury() external view override returns (address) {
+        return StorageLib.getTreasuryData().treasury;
+    }
+
+    /// @inheritdoc ILensGovernable
+    function getTreasuryFee() external view override returns (uint16) {
+        return StorageLib.getTreasuryData().treasuryFeeBPS;
+    }
+
+    /// @inheritdoc ILensGovernable
+    function getTreasuryData() external view override returns (address, uint16) {
+        Types.TreasuryData storage treasuryData = StorageLib.getTreasuryData();
+        return (treasuryData.treasury, treasuryData.treasuryFeeBPS);
+    }
+}

package/contracts/base/LensHubEventHooks.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.15;
+
+import {ILensHubEventHooks} from '../interfaces/ILensHubEventHooks.sol';
+import {Errors} from '../libraries/constants/Errors.sol';
+import {StorageLib} from '../libraries/StorageLib.sol';
+import {Events} from '../libraries/constants/Events.sol';
+
+abstract contract LensHubEventHooks is ILensHubEventHooks {
+    /// @inheritdoc ILensHubEventHooks
+    function emitUnfollowedEvent(
+        uint256 unfollowerProfileId,
+        uint256 idOfProfileUnfollowed,
+        address transactionExecutor
+    ) external override {
+        address expectedFollowNFT = StorageLib.getProfile(idOfProfileUnfollowed).followNFT;
+        if (msg.sender != expectedFollowNFT) {
+            revert Errors.CallerNotFollowNFT();
+        }
+        emit Events.Unfollowed(unfollowerProfileId, idOfProfileUnfollowed, transactionExecutor, block.timestamp);
+    }
+
+    //////////////////////////////////////
+    ///       DEPRECATED FUNCTIONS     ///
+    //////////////////////////////////////
+
+    // Deprecated in V2. Kept here just for backwards compatibility with Lens V1 Collect NFTs.
+    function emitCollectNFTTransferEvent(
+        uint256 profileId,
+        uint256 pubId,
+        uint256 collectNFTId,
+        address from,
+        address to
+    ) external {
+        address expectedCollectNFT = StorageLib.getPublication(profileId, pubId).__DEPRECATED__collectNFT;
+        if (msg.sender != expectedCollectNFT) {
+            revert Errors.CallerNotCollectNFT();
+        }
+        emit Events.CollectNFTTransferred(profileId, pubId, collectNFTId, from, to, block.timestamp);
+    }
+}

package/contracts/base/LensHubStorage.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.18;
+
+import {Types} from '../libraries/constants/Types.sol';
+
+/**
+ * @title LensHubStorage
+ * @author Lens Protocol
+ *
+ * @notice This is an abstract contract that ONLY contains storage for the LensHub contract. This MUST be inherited last
+ * to preserve the LensHub storage layout. Adding storage variables should be done ONLY at the bottom of this contract.
+ */
+abstract contract LensHubStorage {
+    // For upgradeability purposes, used at `VersionedInitializable` file, which needs to be included if the LensHub
+    // has an initializer function.
+    uint256 private _lastInitializedRevision; // Slot 11.
+
+    Types.ProtocolState internal _state; // Slot 12
+
+    mapping(address profileCreator => bool isWhitelisted) internal _profileCreatorWhitelisted; // Slot 13
+
+    mapping(address => bool isWhitelisted) internal __DEPRECATED__followModuleWhitelisted; // Slot 14
+
+    mapping(address collectModule => bool isWhitelisted) internal __DEPRECATED__collectModuleWhitelisted; // Slot 15
+
+    mapping(address referenceModule => bool isWhitelisted) internal __DEPRECATED__referenceModuleWhitelisted; // Slot 16
+
+    mapping(uint256 profileId => address dispatcher) internal __DEPRECATED__dispatcherByProfile; // Slot 17
+
+    mapping(bytes32 handleHash => uint256 profileId) internal __DEPRECATED__profileIdByHandleHash; // Slot 18
+
+    mapping(uint256 profileId => Types.Profile profile) internal _profiles; // Slot 19
+
+    mapping(uint256 profileId => mapping(uint256 pubId => Types.Publication publication)) internal _publications; // Slot 20
+
+    mapping(address userAddress => uint256 profileId) internal __DEPRECATED__defaultProfiles; // Slot 21
+
+    uint256 internal _profileCounter; // Slot 22 - different from totalSupply, as this is not decreased when burning profiles
+
+    address internal _governance; // Slot 23
+
+    address internal _emergencyAdmin; // Slot 24
+
+    ////////////////////////////////////////////
+    // Slots introduced by Lens V1.3 upgrade. //
+    ////////////////////////////////////////////
+    mapping(address => uint256) internal _tokenGuardianDisablingTimestamp; // Slot 25
+
+    ////////////////////////////////////////////
+    //  Slots introduced by Lens V2 upgrade.  //
+    ////////////////////////////////////////////
+
+    mapping(uint256 profileId => Types.DelegatedExecutorsConfig config) internal _delegatedExecutorsConfigs; // Slot 26
+
+    mapping(uint256 blockerProfileId => mapping(uint256 blockedProfileId => bool isBlocked)) internal _blockedStatus; // Slot 27
+
+    uint256 internal _profileRoyaltiesBps; // Slot 28
+
+    mapping(address migrationAdmin => bool allowed) internal _migrationAdminWhitelisted; // Slot 29
+
+    Types.TreasuryData internal _treasuryData; // Slot 30
+
+    address internal _profileTokenURIContract; // Slot 31
+
+    address internal _followTokenURIContract; // Slot 32
+
+    mapping(address => uint256) internal _legacyCollectFollowValidationHelper; // Slot 33
+}

package/contracts/base/LensImplGetters.sol

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.15;
+
+import {ILensImplGetters} from '../interfaces/ILensImplGetters.sol';
+
+contract LensImplGetters is ILensImplGetters {
+    address internal immutable FOLLOW_NFT_IMPL;
+    address internal immutable __LEGACY__COLLECT_NFT_IMPL;
+    address internal immutable MODULE_REGISTRY;
+
+    constructor(address followNFTImpl, address collectNFTImpl, address moduleRegistry) {
+        FOLLOW_NFT_IMPL = followNFTImpl;
+        __LEGACY__COLLECT_NFT_IMPL = collectNFTImpl;
+        MODULE_REGISTRY = moduleRegistry;
+    }
+
+    /// @inheritdoc ILensImplGetters
+    function getFollowNFTImpl() external view override returns (address) {
+        return FOLLOW_NFT_IMPL;
+    }
+
+    /// @inheritdoc ILensImplGetters
+    function getLegacyCollectNFTImpl() external view override returns (address) {
+        return __LEGACY__COLLECT_NFT_IMPL; // LEGACY support: Used only for compatibility with V1 collectible posts.
+    }
+
+    /// @inheritdoc ILensImplGetters
+    function getModuleRegistry() external view override returns (address) {
+        return MODULE_REGISTRY;
+    }
+}

package/contracts/base/LensProfiles.sol

@@ -0,0 +1,162 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.15;
+
+import {IERC721} from '@openzeppelin/contracts/token/ERC721/IERC721.sol';
+import {IERC721Metadata} from '@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol';
+import {IERC165} from '@openzeppelin/contracts/utils/introspection/IERC165.sol';
+import {ILensProfiles} from '../interfaces/ILensProfiles.sol';
+import {IERC721Burnable} from '../interfaces/IERC721Burnable.sol';
+
+import {LensBaseERC721} from './LensBaseERC721.sol';
+import {ProfileLib} from '../libraries/ProfileLib.sol';
+import {StorageLib} from '../libraries/StorageLib.sol';
+import {ValidationLib} from '../libraries/ValidationLib.sol';
+import {IProfileTokenURI} from '../interfaces/IProfileTokenURI.sol';
+
+import {ERC2981CollectionRoyalties} from './ERC2981CollectionRoyalties.sol';
+
+import {Errors} from '../libraries/constants/Errors.sol';
+import {Types} from '../libraries/constants/Types.sol';
+import {Events} from '../libraries/constants/Events.sol';
+
+import {Address} from '@openzeppelin/contracts/utils/Address.sol';
+
+abstract contract LensProfiles is LensBaseERC721, ERC2981CollectionRoyalties, ILensProfiles {
+    using Address for address;
+
+    uint256 public immutable TOKEN_GUARDIAN_COOLDOWN;
+
+    constructor(uint256 tokenGuardianCooldown) {
+        TOKEN_GUARDIAN_COOLDOWN = tokenGuardianCooldown;
+    }
+
+    modifier whenNotPaused() {
+        if (StorageLib.getState() == Types.ProtocolState.Paused) {
+            revert Errors.Paused();
+        }
+        _;
+    }
+
+    modifier onlyProfileOwner(address expectedOwner, uint256 profileId) {
+        ValidationLib.validateAddressIsProfileOwner(expectedOwner, profileId);
+        _;
+    }
+
+    modifier onlyEOA() {
+        if (msg.sender.isContract()) {
+            revert Errors.NotEOA();
+        }
+        _;
+    }
+
+    /// @inheritdoc ILensProfiles
+    function getTokenGuardianDisablingTimestamp(address wallet) external view returns (uint256) {
+        return StorageLib.tokenGuardianDisablingTimestamp()[wallet];
+    }
+
+    /// @inheritdoc ILensProfiles
+    function DANGER__disableTokenGuardian() external onlyEOA {
+        if (StorageLib.tokenGuardianDisablingTimestamp()[msg.sender] != 0) {
+            revert Errors.DisablingAlreadyTriggered();
+        }
+        StorageLib.tokenGuardianDisablingTimestamp()[msg.sender] = block.timestamp + TOKEN_GUARDIAN_COOLDOWN;
+        emit Events.TokenGuardianStateChanged({
+            wallet: msg.sender,
+            enabled: false,
+            tokenGuardianDisablingTimestamp: block.timestamp + TOKEN_GUARDIAN_COOLDOWN,
+            timestamp: block.timestamp
+        });
+    }
+
+    /// @inheritdoc ILensProfiles
+    function enableTokenGuardian() external onlyEOA {
+        if (StorageLib.tokenGuardianDisablingTimestamp()[msg.sender] == 0) {
+            revert Errors.AlreadyEnabled();
+        }
+        StorageLib.tokenGuardianDisablingTimestamp()[msg.sender] = 0;
+        emit Events.TokenGuardianStateChanged({
+            wallet: msg.sender,
+            enabled: true,
+            tokenGuardianDisablingTimestamp: 0,
+            timestamp: block.timestamp
+        });
+    }
+
+    /**
+     * @notice Burns a profile, this maintains the profile data struct.
+     */
+    function burn(
+        uint256 tokenId
+    ) public override(LensBaseERC721, IERC721Burnable) whenNotPaused onlyProfileOwner(msg.sender, tokenId) {
+        _burn(tokenId);
+    }
+
+    /**
+     * @dev Overrides the ERC721 tokenURI function to return the associated URI with a given profile.
+     */
+    function tokenURI(uint256 tokenId) public view override(LensBaseERC721, IERC721Metadata) returns (string memory) {
+        if (!_exists(tokenId)) {
+            revert Errors.TokenDoesNotExist();
+        }
+        uint256 mintTimestamp = StorageLib.getTokenData(tokenId).mintTimestamp;
+        return IProfileTokenURI(StorageLib.getProfileTokenURIContract()).getTokenURI(tokenId, mintTimestamp);
+    }
+
+    function approve(address to, uint256 tokenId) public override(LensBaseERC721, IERC721) {
+        // We allow removing approvals even if the wallet has the token guardian enabled
+        if (to != address(0) && _hasTokenGuardianEnabled(ownerOf(tokenId))) {
+            revert Errors.GuardianEnabled();
+        }
+        super.approve(to, tokenId);
+    }
+
+    function setApprovalForAll(address operator, bool approved) public override(LensBaseERC721, IERC721) {
+        // We allow removing approvals even if the wallet has the token guardian enabled
+        if (approved && _hasTokenGuardianEnabled(msg.sender)) {
+            revert Errors.GuardianEnabled();
+        }
+        super.setApprovalForAll(operator, approved);
+    }
+
+    /**
+     * @dev See {IERC165-supportsInterface}.
+     */
+    function supportsInterface(
+        bytes4 interfaceId
+    ) public view virtual override(LensBaseERC721, ERC2981CollectionRoyalties, IERC165) returns (bool) {
+        return
+            LensBaseERC721.supportsInterface(interfaceId) || ERC2981CollectionRoyalties.supportsInterface(interfaceId);
+    }
+
+    function _hasTokenGuardianEnabled(address wallet) internal view returns (bool) {
+        return
+            !wallet.isContract() &&
+            (StorageLib.tokenGuardianDisablingTimestamp()[wallet] == 0 ||
+                block.timestamp < StorageLib.tokenGuardianDisablingTimestamp()[wallet]);
+    }
+
+    function _getRoyaltiesInBasisPointsSlot() internal pure override returns (uint256) {
+        return StorageLib.PROFILE_ROYALTIES_BPS_SLOT;
+    }
+
+    function _getReceiver(uint256 /* tokenId */) internal view override returns (address) {
+        return StorageLib.getTreasuryData().treasury;
+    }
+
+    function _beforeRoyaltiesSet(uint256 /* royaltiesInBasisPoints */) internal view override {
+        ValidationLib.validateCallerIsGovernance();
+    }
+
+    function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal override whenNotPaused {
+        if (from != address(0) && _hasTokenGuardianEnabled(from)) {
+            // Cannot transfer profile if the guardian is enabled, except at minting time.
+            revert Errors.GuardianEnabled();
+        }
+        // Switches to new fresh delegated executors configuration (except on minting, as it already has a fresh setup).
+        if (from != address(0)) {
+            ProfileLib.switchToNewFreshDelegatedExecutorsConfig(tokenId);
+        }
+        super._beforeTokenTransfer(from, to, tokenId);
+    }
+}

package/contracts/base/LensVersion.sol

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.15;
+
+import {ILensVersion} from '../interfaces/ILensVersion.sol';
+import {Errors} from '../libraries/constants/Errors.sol';
+import {TransparentUpgradeableProxy} from '@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol';
+
+contract LensVersion is ILensVersion {
+    string internal constant version = '2.0.3';
+
+    bytes20 internal constant gitCommit = hex'3bb1438b28b69f584ab9a290f261e3452fd34ad0';
+
+    event LensUpgradeVersion(address implementation, string version, bytes20 gitCommit, uint256 timestamp);
+
+    /// @inheritdoc ILensVersion
+    function getVersion() external pure override returns (string memory) {
+        return version;
+    }
+
+    /// @inheritdoc ILensVersion
+    function getGitCommit() external pure override returns (bytes20) {
+        return gitCommit;
+    }
+
+    function emitVersion() external {
+        (, bytes memory adminData) = address(this).delegatecall(abi.encodeCall(TransparentUpgradeableProxy.admin, ()));
+        (, bytes memory implementationData) = address(this).delegatecall(
+            abi.encodeCall(TransparentUpgradeableProxy.implementation, ())
+        );
+        if (msg.sender != abi.decode(adminData, (address))) {
+            revert Errors.NotHub();
+        }
+        emit LensUpgradeVersion(abi.decode(implementationData, (address)), version, gitCommit, block.timestamp);
+    }
+}

package/contracts/base/upgradeability/FollowNFTProxy.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.15;
+
+import {ILensHub} from '../../interfaces/ILensHub.sol';
+import {Proxy} from '@openzeppelin/contracts/proxy/Proxy.sol';
+import {Address} from '@openzeppelin/contracts/utils/Address.sol';
+
+contract FollowNFTProxy is Proxy {
+    using Address for address;
+    address immutable HUB;
+
+    constructor(bytes memory data) {
+        HUB = msg.sender;
+        ILensHub(msg.sender).getFollowNFTImpl().functionDelegateCall(data);
+    }
+
+    function _implementation() internal view override returns (address) {
+        return ILensHub(HUB).getFollowNFTImpl();
+    }
+}

package/contracts/interfaces/IFollowTokenURI.sol

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.15;
+
+interface IFollowTokenURI {
+    function getTokenURI(
+        uint256 followTokenId,
+        uint256 followedProfileId,
+        uint256 originalFollowTimestamp
+    ) external pure returns (string memory);
+}

package/contracts/interfaces/ILegacyCollectModule.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.6.0;
+
+/**
+ * @title ICollectModule
+ * @author Lens Protocol
+ * @custom:pending-deprecation
+ *
+ * @notice This is the deprecated interface for previously Lens-compatible CollectModules.
+ */
+interface ILegacyCollectModule {
+    /**
+     * @notice Initializes data for a given publication being published. This can only be called by the hub.
+     *
+     * @param profileId The token ID of the profile publishing the publication.
+     * @param pubId The associated publication's LensHub publication ID.
+     * @param data Arbitrary data __passed from the user!__ to be decoded.
+     *
+     * @return bytes An ABI-encoded encapsulating the execution's state changes. This will be emitted by the
+     * hub alongside the collect module's address and should be consumed by front ends.
+     */
+    function initializePublicationCollectModule(
+        uint256 profileId,
+        uint256 pubId,
+        bytes calldata data
+    ) external returns (bytes memory);
+
+    /**
+     * @notice Processes a collect action for a given publication, this can only be called by the hub.
+     *
+     * @param referrerProfileId The LensHub profile token ID of the referrer's profile (only different in case of mirrors).
+     * @param collector The collector address.
+     * @param profileId The token ID of the profile associated with the publication being collected.
+     * @param pubId The LensHub publication ID associated with the publication being collected.
+     * @param data Arbitrary data __passed from the collector!__ to be decoded.
+     */
+    function processCollect(
+        uint256 referrerProfileId,
+        address collector,
+        uint256 profileId,
+        uint256 pubId,
+        bytes calldata data
+    ) external;
+}

package/contracts/interfaces/ILegacyCollectNFT.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.6.0;
+
+/**
+ * @title ILegacyCollectNFT
+ * @author Lens Protocol
+ *
+ * @notice This is the interface for the Lens V1 CollectNFT contract. Which is cloned upon the first collect for any
+ * given publication.
+ */
+interface ILegacyCollectNFT {
+    /**
+     * @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 LensHub.
+     *
+     * @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.
+     * @param name The name to set for this NFT.
+     * @param symbol The symbol to set for this NFT.
+     */
+    function initialize(
+        uint256 profileId,
+        uint256 pubId,
+        string calldata name,
+        string calldata symbol
+    ) external;
+
+    /**
+     * @notice Mints a collect NFT to the specified address.
+     * @custom:permissions LensHub.
+     *
+     * @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/ILegacyFollowModule.sol

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.15;
+
+/**
+ * @title IFollowModule
+ * @author Lens Protocol
+ *
+ * @notice This is the deprecated interface for previously Lens-compatible FollowModules.
+ */
+interface ILegacyFollowModule {
+    /**
+     * @notice Initializes a follow module for a given Lens profile. This can only be called by the hub contract.
+     *
+     * @param profileId The token ID of the profile to initialize this follow module for.
+     * @param data Arbitrary data passed by the profile creator.
+     *
+     * @return bytes The encoded data to emit in the hub.
+     */
+    function initializeFollowModule(uint256 profileId, bytes calldata data) external returns (bytes memory);
+
+    /**
+     * @notice Processes a given follow, this can only be called from the LensHub contract.
+     *
+     * @param follower The follower address.
+     * @param profileId The token ID of the profile being followed.
+     * @param data Arbitrary data passed by the follower.
+     */
+    function processFollow(
+        address follower,
+        uint256 profileId,
+        bytes calldata data
+    ) external;
+
+    /**
+     * @notice This is a transfer hook that is called upon follow NFT transfer in `beforeTokenTransfer. This can
+     * only be called from the LensHub contract.
+     *
+     * NOTE: Special care needs to be taken here: It is possible that follow NFTs were issued before this module
+     * was initialized if the profile's follow module was previously different. This transfer hook should take this
+     * into consideration, especially when the module holds a state associated with individual follow NFTs.
+     *
+     * @param profileId The token ID of the profile associated with the follow NFT being transferred.
+     * @param from The address sending the follow NFT.
+     * @param to The address receiving the follow NFT.
+     * @param followNFTTokenId The token ID of the follow NFT being transferred.
+     */
+    function followModuleTransferHook(
+        uint256 profileId,
+        address from,
+        address to,
+        uint256 followNFTTokenId
+    ) external;
+
+    /**
+     * @notice This is a helper function that could be used in conjunction with specific collect modules.
+     *
+     * NOTE: This function IS meant to replace a check on follower NFT ownership.
+     *
+     * NOTE: It is assumed that not all collect modules are aware of the token ID to pass. In these cases,
+     * this should receive a `followNFTTokenId` of 0, which is impossible regardless.
+     *
+     * One example of a use case for this would be a subscription-based following system:
+     *      1. The collect module:
+     *          - Decodes a follower NFT token ID from user-passed data.
+     *          - Fetches the follow module from the hub.
+     *          - Calls `isFollowing` passing the profile ID, follower & follower token ID and checks it returned true.
+     *      2. The follow module:
+     *          - Validates the subscription status for that given NFT, reverting on an invalid subscription.
+     *
+     * @param profileId The token ID of the profile to validate the follow for.
+     * @param follower The follower address to validate the follow for.
+     * @param followNFTTokenId The followNFT token ID to validate the follow for.
+     *
+     * @return true if the given address is following the given profile ID, false otherwise.
+     */
+    function isFollowing(
+        uint256 profileId,
+        address follower,
+        uint256 followNFTTokenId
+    ) external view returns (bool);
+}

package/contracts/interfaces/IProfileTokenURI.sol

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.15;
+
+interface IProfileTokenURI {
+    function getTokenURI(uint256 profileId, uint256 mintTimestamp) external view returns (string memory);
+}