lens-modules 1.0.13 → 1.1.0

package/contracts/interfaces/ITokenHandleRegistry.sol

@@ -0,0 +1,90 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.6.0;
+
+/**
+ * @title ITokenHandleRegistry
+ * @author Lens Protocol
+ *
+ * @notice The interface for TokenHandleRegistry contract that is responsible for linking a handle NFT to a token NFT.
+ * Linking means a connection between the two NFTs is created, and the handle NFT can be used to resolve the token NFT
+ * or vice versa.
+ * The registry is responsible for keeping track of the links between the NFTs, and for resolving them.
+ * The first version of the registry is hard-coded to support only the .lens namespace and the Lens Protocol Profiles.
+ */
+interface ITokenHandleRegistry {
+    /**
+     * @notice Lens V1 -> V2 migration function. Links a handle NFT to a profile NFT without additional checks to save
+     * gas.
+     * Will be called by the migration function (in MigrationLib) in LensHub, only for new handles being migrated.
+     *
+     * @custom:permissions LensHub
+     *
+     * @param handleId ID of the .lens namespace handle NFT
+     * @param profileId ID of the Lens Protocol Profile NFT
+     */
+    function migrationLink(uint256 handleId, uint256 profileId) external;
+
+    /**
+     * @notice Links a handle NFT with a profile NFT.
+     * Linking means a connection between the two NFTs is created, and the handle NFT can be used to resolve the profile
+     * NFT or vice versa.
+     * @custom:permissions Both NFTs must be owned by the same address, and caller must be the owner of profile or its
+     * approved DelegatedExecutor.
+     *
+     * @dev In the first version of the registry, the NFT contracts are hard-coded:
+     *  - Handle is hard-coded to be of the .lens namespace
+     *  - Token is hard-coded to be of the Lens Protocol Profile
+     * In future versions, the registry will be more flexible and allow for different namespaces and tokens, so this
+     * function might be deprecated and replaced with a new one accepting addresses of the handle and token contracts.
+     *
+     * @param handleId ID of the .lens namespace handle NFT
+     * @param profileId ID of the Lens Protocol Profile NFT
+     */
+    function link(uint256 handleId, uint256 profileId) external;
+
+    /**
+     * @notice Unlinks a handle NFT from a profile NFT.
+     * @custom:permissions Caller can be the owner of either of the NFTs.
+     *
+     * @dev In the first version of the registry, the contracts are hard-coded:
+     *  - Handle is hard-coded to be of the .lens namespace
+     *  - Token is hard-coded to be of the Lens Protocol Profile
+     * In future versions, the registry will be more flexible and allow for different namespaces and tokens, so this
+     * function might be deprecated and replaced with a new one accepting addresses of the handle and token contracts.
+     *
+     * @param handleId ID of the .lens namespace handle NFT
+     * @param profileId ID of the Lens Protocol Profile NFT
+     */
+    function unlink(uint256 handleId, uint256 profileId) external;
+
+    /**
+     * @notice Resolves a handle NFT to a profile NFT.
+     *
+     * @dev In the first version of the registry, the contracts are hard-coded:
+     *  - Handle is hard-coded to be of the .lens namespace
+     *  - Token is hard-coded to be of the Lens Protocol Profile
+     * In future versions, the registry will be more flexible and allow for different namespaces and tokens, so this
+     * function might be deprecated and replaced with a new one.
+     *
+     * @param handleId ID of the .lens namespace handle NFT
+     *
+     * @return tokenId ID of the Lens Protocol Profile NFT
+     */
+    function resolve(uint256 handleId) external view returns (uint256);
+
+    /**
+     * @notice Gets a default handle for a profile NFT (aka reverse resolution).
+     *
+     * @dev In the first version of the registry, the contracts are hard-coded:
+     *  - Handle is hard-coded to be of the .lens namespace
+     *  - Token is hard-coded to be of the Lens Protocol Profile
+     * In future versions, the registry will be more flexible and allow for different namespaces and tokens, so this
+     * function might be deprecated and replaced with a new one.
+     *
+     * @param tokenId ID of the Lens Protocol Profile NFT
+     *
+     * @return handleId ID of the .lens namespace handle NFT
+     */
+    function getDefaultHandle(uint256 tokenId) external view returns (uint256);
+}

package/contracts/libraries/ActionLib.sol

@@ -0,0 +1,69 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.15;
+
+import {Types} from './constants/Types.sol';
+import {StorageLib} from './StorageLib.sol';
+import {ValidationLib} from './ValidationLib.sol';
+import {IPublicationActionModule} from '../interfaces/IPublicationActionModule.sol';
+import {Errors} from './constants/Errors.sol';
+import {Events} from './constants/Events.sol';
+
+library ActionLib {
+    function act(
+        Types.PublicationActionParams calldata publicationActionParams,
+        address transactionExecutor,
+        address actorProfileOwner
+    ) external returns (bytes memory) {
+        ValidationLib.validateNotBlocked({
+            profile: publicationActionParams.actorProfileId,
+            byProfile: publicationActionParams.publicationActedProfileId
+        });
+
+        Types.Publication storage _actedOnPublication = StorageLib.getPublication(
+            publicationActionParams.publicationActedProfileId,
+            publicationActionParams.publicationActedId
+        );
+
+        if (!_isActionEnabled(_actedOnPublication, publicationActionParams.actionModuleAddress)) {
+            // This will also revert for:
+            //   - Non-existent action modules
+            //   - Non-existent publications
+            //   - Legacy V1 publications
+            // Because the storage will be empty.
+            revert Errors.ActionNotAllowed();
+        }
+
+        Types.PublicationType[] memory referrerPubTypes = ValidationLib.validateReferrersAndGetReferrersPubTypes(
+            publicationActionParams.referrerProfileIds,
+            publicationActionParams.referrerPubIds,
+            publicationActionParams.publicationActedProfileId,
+            publicationActionParams.publicationActedId
+        );
+
+        bytes memory actionModuleReturnData = IPublicationActionModule(publicationActionParams.actionModuleAddress)
+            .processPublicationAction(
+                Types.ProcessActionParams({
+                    publicationActedProfileId: publicationActionParams.publicationActedProfileId,
+                    publicationActedId: publicationActionParams.publicationActedId,
+                    actorProfileId: publicationActionParams.actorProfileId,
+                    actorProfileOwner: actorProfileOwner,
+                    transactionExecutor: transactionExecutor,
+                    referrerProfileIds: publicationActionParams.referrerProfileIds,
+                    referrerPubIds: publicationActionParams.referrerPubIds,
+                    referrerPubTypes: referrerPubTypes,
+                    actionModuleData: publicationActionParams.actionModuleData
+                })
+            );
+        emit Events.Acted(publicationActionParams, actionModuleReturnData, transactionExecutor, block.timestamp);
+
+        return actionModuleReturnData;
+    }
+
+    function _isActionEnabled(
+        Types.Publication storage _publication,
+        address actionModuleAddress
+    ) private view returns (bool) {
+        return _publication.actionModuleEnabled[actionModuleAddress];
+    }
+}

package/contracts/libraries/FollowLib.sol

@@ -0,0 +1,175 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.15;
+
+import {IFollowModule} from '../interfaces/IFollowModule.sol';
+import {ValidationLib} from './ValidationLib.sol';
+import {Types} from './constants/Types.sol';
+import {Errors} from './constants/Errors.sol';
+import {Events} from './constants/Events.sol';
+import {StorageLib} from './StorageLib.sol';
+import {IFollowNFT} from '../interfaces/IFollowNFT.sol';
+import {FollowNFTProxy} from '../base/upgradeability/FollowNFTProxy.sol';
+
+library FollowLib {
+    function follow(
+        uint256 followerProfileId,
+        address transactionExecutor,
+        uint256[] calldata idsOfProfilesToFollow,
+        uint256[] calldata followTokenIds,
+        bytes[] calldata followModuleDatas
+    ) external returns (uint256[] memory) {
+        if (
+            idsOfProfilesToFollow.length != followTokenIds.length ||
+            idsOfProfilesToFollow.length != followModuleDatas.length
+        ) {
+            revert Errors.ArrayMismatch();
+        }
+        uint256[] memory followTokenIdsAssigned = new uint256[](idsOfProfilesToFollow.length);
+        uint256 i;
+        while (i < idsOfProfilesToFollow.length) {
+            ValidationLib.validateProfileExists({profileId: idsOfProfilesToFollow[i]});
+
+            ValidationLib.validateNotBlocked({
+                profile: followerProfileId,
+                byProfile: idsOfProfilesToFollow[i],
+                unidirectionalCheck: true // We allow to follow a blocked profile. Rest of interactions are restricted.
+            });
+
+            if (followerProfileId == idsOfProfilesToFollow[i]) {
+                revert Errors.SelfFollow();
+            }
+
+            followTokenIdsAssigned[i] = _follow({
+                followerProfileId: followerProfileId,
+                transactionExecutor: transactionExecutor,
+                idOfProfileToFollow: idsOfProfilesToFollow[i],
+                followTokenId: followTokenIds[i],
+                followModuleData: followModuleDatas[i]
+            });
+
+            unchecked {
+                ++i;
+            }
+        }
+        return followTokenIdsAssigned;
+    }
+
+    function unfollow(
+        uint256 unfollowerProfileId,
+        address transactionExecutor,
+        uint256[] calldata idsOfProfilesToUnfollow
+    ) external {
+        uint256 i;
+        while (i < idsOfProfilesToUnfollow.length) {
+            uint256 idOfProfileToUnfollow = idsOfProfilesToUnfollow[i];
+
+            address followNFT = StorageLib.getProfile(idOfProfileToUnfollow).followNFT;
+
+            // We don't validate the profile exists because we want to allow unfollowing a burnt profile.
+            // Because, if the profile never existed, followNFT will be address(0) and the call will revert.
+            if (followNFT == address(0)) {
+                revert Errors.NotFollowing();
+            }
+
+            IFollowNFT(followNFT).unfollow(unfollowerProfileId);
+
+            emit Events.Unfollowed(unfollowerProfileId, idOfProfileToUnfollow, transactionExecutor, block.timestamp);
+
+            unchecked {
+                ++i;
+            }
+        }
+    }
+
+    function isFollowing(uint256 followerProfileId, uint256 followedProfileId) internal view returns (bool) {
+        address followNFT = StorageLib.getProfile(followedProfileId).followNFT;
+        return followNFT != address(0) && IFollowNFT(followNFT).isFollowing(followerProfileId);
+    }
+
+    /**
+     * @notice Deploys the given profile's Follow NFT contract.
+     *
+     * @param profileId The token ID of the profile which Follow NFT should be deployed.
+     *
+     * @return address The address of the deployed Follow NFT contract.
+     */
+    function _deployFollowNFT(uint256 profileId) private returns (address) {
+        bytes memory functionData = abi.encodeCall(IFollowNFT.initialize, profileId);
+        address followNFT = address(new FollowNFTProxy(functionData));
+        emit Events.FollowNFTDeployed(profileId, followNFT, block.timestamp);
+
+        return followNFT;
+    }
+
+    function _follow(
+        uint256 followerProfileId,
+        address transactionExecutor,
+        uint256 idOfProfileToFollow,
+        uint256 followTokenId,
+        bytes calldata followModuleData
+    ) private returns (uint256) {
+        Types.Profile storage _profileToFollow = StorageLib.getProfile(idOfProfileToFollow);
+
+        address followNFT = _profileToFollow.followNFT;
+        if (followNFT == address(0)) {
+            followNFT = _deployFollowNFT(idOfProfileToFollow);
+            _profileToFollow.followNFT = followNFT;
+        }
+
+        return
+            _processFollow(
+                ProcessFollowParams({
+                    followNFT: followNFT,
+                    followerProfileId: followerProfileId,
+                    transactionExecutor: transactionExecutor,
+                    idOfProfileToFollow: idOfProfileToFollow,
+                    followTokenId: followTokenId,
+                    followModule: _profileToFollow.followModule,
+                    followModuleData: followModuleData
+                })
+            );
+    }
+
+    // Struct defined for the sole purpose of avoiding 'stack too deep' error.
+    struct ProcessFollowParams {
+        address followNFT;
+        uint256 followerProfileId;
+        address transactionExecutor;
+        uint256 idOfProfileToFollow;
+        uint256 followTokenId;
+        address followModule;
+        bytes followModuleData;
+    }
+
+    function _processFollow(ProcessFollowParams memory processFollowParams) private returns (uint256) {
+        uint256 followTokenIdAssigned = IFollowNFT(processFollowParams.followNFT).follow({
+            followerProfileId: processFollowParams.followerProfileId,
+            transactionExecutor: processFollowParams.transactionExecutor,
+            followTokenId: processFollowParams.followTokenId
+        });
+
+        bytes memory processFollowModuleReturnData;
+        if (processFollowParams.followModule != address(0)) {
+            processFollowModuleReturnData = IFollowModule(processFollowParams.followModule).processFollow(
+                processFollowParams.followerProfileId,
+                processFollowParams.followTokenId,
+                processFollowParams.transactionExecutor,
+                processFollowParams.idOfProfileToFollow,
+                processFollowParams.followModuleData
+            );
+        }
+
+        emit Events.Followed(
+            processFollowParams.followerProfileId,
+            processFollowParams.idOfProfileToFollow,
+            followTokenIdAssigned,
+            processFollowParams.followModuleData,
+            processFollowModuleReturnData,
+            processFollowParams.transactionExecutor,
+            block.timestamp
+        );
+
+        return followTokenIdAssigned;
+    }
+}

package/contracts/libraries/GovernanceLib.sol

@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.15;
+
+import {Types} from './constants/Types.sol';
+import {Errors} from './constants/Errors.sol';
+import {StorageLib} from './StorageLib.sol';
+import {Events} from './constants/Events.sol';
+
+library GovernanceLib {
+    uint16 internal constant BPS_MAX = 10000;
+
+    /**
+     * @notice Sets the governance address.
+     *
+     * @param newGovernance The new governance address to set.
+     */
+    function setGovernance(address newGovernance) external {
+        address prevGovernance = StorageLib.getGovernance();
+        StorageLib.setGovernance(newGovernance);
+        emit Events.GovernanceSet(msg.sender, prevGovernance, newGovernance, block.timestamp);
+    }
+
+    /**
+     * @notice Sets the emergency admin address.
+     *
+     * @param newEmergencyAdmin The new governance address to set.
+     */
+    function setEmergencyAdmin(address newEmergencyAdmin) external {
+        address prevEmergencyAdmin = StorageLib.getEmergencyAdmin();
+        StorageLib.setEmergencyAdmin(newEmergencyAdmin);
+        emit Events.EmergencyAdminSet(msg.sender, prevEmergencyAdmin, newEmergencyAdmin, block.timestamp);
+    }
+
+    /**
+     * @notice Sets the protocol state, only meant to be called at initialization since
+     * this does not validate the caller.
+     *
+     * @param newState The new protocol state to set.
+     */
+    function initState(Types.ProtocolState newState) external {
+        _setState(newState);
+    }
+
+    /**
+     * @notice Sets the protocol state and validates the caller. The emergency admin can only
+     * pause further (Unpaused => PublishingPaused => Paused). Whereas governance can set any
+     * state.
+     *
+     * @param newState The new protocol state to set.
+     */
+    function setState(Types.ProtocolState newState) external {
+        // NOTE: This does not follow the CEI-pattern, but there is no interaction and this allows to abstract `_setState` logic.
+        Types.ProtocolState prevState = _setState(newState);
+
+        if (msg.sender != StorageLib.getGovernance()) {
+            // If the sender is the emergency admin, prevent them from reducing restrictions.
+            if (msg.sender == StorageLib.getEmergencyAdmin()) {
+                if (newState <= prevState) {
+                    revert Errors.EmergencyAdminCanOnlyPauseFurther();
+                }
+            } else {
+                revert Errors.NotGovernanceOrEmergencyAdmin();
+            }
+        }
+    }
+
+    function _setState(Types.ProtocolState newState) private returns (Types.ProtocolState) {
+        Types.ProtocolState prevState = StorageLib.getState();
+        StorageLib.setState(newState);
+        emit Events.StateSet(msg.sender, prevState, newState, block.timestamp);
+        return prevState;
+    }
+
+    function whitelistProfileCreator(address profileCreator, bool whitelist) external {
+        StorageLib.profileCreatorWhitelisted()[profileCreator] = whitelist;
+        emit Events.ProfileCreatorWhitelisted(profileCreator, whitelist, block.timestamp);
+    }
+
+    function setTreasury(address newTreasury) internal {
+        if (newTreasury == address(0)) {
+            revert Errors.InitParamsInvalid();
+        }
+        Types.TreasuryData storage _treasuryData = StorageLib.getTreasuryData();
+
+        address prevTreasury = _treasuryData.treasury;
+        _treasuryData.treasury = newTreasury;
+
+        emit Events.TreasurySet(prevTreasury, newTreasury, block.timestamp);
+    }
+
+    function setTreasuryFee(uint16 newTreasuryFee) internal {
+        if (newTreasuryFee >= BPS_MAX / 2) {
+            revert Errors.InitParamsInvalid();
+        }
+        Types.TreasuryData storage _treasuryData = StorageLib.getTreasuryData();
+
+        uint16 prevTreasuryFee = _treasuryData.treasuryFeeBPS;
+        _treasuryData.treasuryFeeBPS = newTreasuryFee;
+
+        emit Events.TreasuryFeeSet(prevTreasuryFee, newTreasuryFee, block.timestamp);
+    }
+
+    function setProfileTokenURIContract(address profileTokenURIContract) external {
+        StorageLib.setProfileTokenURIContract(profileTokenURIContract);
+    }
+
+    function setFollowTokenURIContract(address followTokenURIContract) external {
+        StorageLib.setFollowTokenURIContract(followTokenURIContract);
+    }
+}

package/contracts/libraries/LegacyCollectLib.sol

@@ -0,0 +1,176 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.15;
+
+import {ValidationLib} from './ValidationLib.sol';
+import {Types} from './constants/Types.sol';
+import {Errors} from './constants/Errors.sol';
+import {Events} from './constants/Events.sol';
+import {ICollectNFT} from '../interfaces/ICollectNFT.sol';
+import {ILegacyCollectModule} from '../interfaces/ILegacyCollectModule.sol';
+import {Clones} from '@openzeppelin/contracts/proxy/Clones.sol';
+import {Strings} from '@openzeppelin/contracts/utils/Strings.sol';
+import {StorageLib} from './StorageLib.sol';
+import {FollowLib} from './FollowLib.sol';
+
+/**
+ * @title LegacyCollectLib
+ * @author Lens Protocol
+ * @notice Library containing the logic for legacy collect operation.
+ */
+library LegacyCollectLib {
+    using Strings for uint256;
+
+    /**
+     * @dev Emitted upon a successful legacy collect action.
+     *
+     * @param publicationCollectedProfileId The profile ID of the publication being collected.
+     * @param publicationCollectedId The publication ID of the publication being collected.
+     * @param collectorProfileId The profile ID of the profile that collected the publication.
+     * @param transactionExecutor The address of the account that executed the collect transaction.
+     * @param referrerProfileId The profile ID of the referrer, if any. Zero if no referrer.
+     * @param referrerPubId The publication ID of the referrer, if any. Zero if no referrer.
+     * @param collectModule The address of the collect module that was used to collect the publication.
+     * @param collectModuleData The data passed to the collect module's collect action. This is ABI-encoded and depends
+     * on the collect module chosen.
+     * @param tokenId The token ID of the collect NFT that was minted as a collect of the publication.
+     * @param timestamp The current block timestamp.
+     */
+    event CollectedLegacy(
+        uint256 indexed publicationCollectedProfileId,
+        uint256 indexed publicationCollectedId,
+        uint256 indexed collectorProfileId,
+        address transactionExecutor,
+        uint256 referrerProfileId,
+        uint256 referrerPubId,
+        address collectModule,
+        bytes collectModuleData,
+        uint256 tokenId,
+        uint256 timestamp
+    );
+
+    function collect(
+        Types.LegacyCollectParams calldata collectParams,
+        address transactionExecutor,
+        address collectorProfileOwner,
+        address collectNFTImpl
+    ) external returns (uint256) {
+        ValidationLib.validateNotBlocked({
+            profile: collectParams.collectorProfileId,
+            byProfile: collectParams.publicationCollectedProfileId
+        });
+
+        address collectModule;
+        uint256 tokenId;
+        address collectNFT;
+        {
+            Types.Publication storage _collectedPublication = StorageLib.getPublication(
+                collectParams.publicationCollectedProfileId,
+                collectParams.publicationCollectedId
+            );
+            // This is a legacy collect operation, so we get the collect module from the deprecated storage field.
+            collectModule = _collectedPublication.__DEPRECATED__collectModule;
+            if (collectModule == address(0)) {
+                // It doesn't have collect module, thus it cannot be collected (a mirror or non-existent).
+                revert Errors.CollectNotAllowed();
+            }
+
+            if (collectParams.referrerProfileId != 0 || collectParams.referrerPubId != 0) {
+                ValidationLib.validateLegacyCollectReferrer(
+                    collectParams.referrerProfileId,
+                    collectParams.referrerPubId,
+                    collectParams.publicationCollectedProfileId,
+                    collectParams.publicationCollectedId
+                );
+            }
+
+            collectNFT = _getOrDeployCollectNFT(
+                _collectedPublication,
+                collectParams.publicationCollectedProfileId,
+                collectParams.publicationCollectedId,
+                collectNFTImpl
+            );
+            tokenId = ICollectNFT(collectNFT).mint(collectorProfileOwner);
+        }
+
+        _prefillLegacyCollectFollowValidationHelper({
+            profileId: collectParams.publicationCollectedProfileId,
+            collectorProfileId: collectParams.collectorProfileId,
+            collector: transactionExecutor
+        });
+
+        ILegacyCollectModule(collectModule).processCollect({
+            // Legacy collect modules expect referrer profile ID to match the collected pub's author if no referrer set.
+            referrerProfileId: collectParams.referrerProfileId == 0
+                ? collectParams.publicationCollectedProfileId
+                : collectParams.referrerProfileId,
+            // Collect NFT is minted to the `collectorProfileOwner`. Some follow-based constraints are expected to be
+            // broken in legacy collect modules if the `transactionExecutor` does not match the `collectorProfileOwner`.
+            collector: transactionExecutor,
+            profileId: collectParams.publicationCollectedProfileId,
+            pubId: collectParams.publicationCollectedId,
+            data: collectParams.collectModuleData
+        });
+
+        emit CollectedLegacy({
+            publicationCollectedProfileId: collectParams.publicationCollectedProfileId,
+            publicationCollectedId: collectParams.publicationCollectedId,
+            collectorProfileId: collectParams.collectorProfileId,
+            transactionExecutor: transactionExecutor,
+            referrerProfileId: collectParams.referrerProfileId,
+            referrerPubId: collectParams.referrerPubId,
+            collectModule: collectModule,
+            collectModuleData: collectParams.collectModuleData,
+            tokenId: tokenId,
+            timestamp: block.timestamp
+        });
+
+        return tokenId;
+    }
+
+    function _getOrDeployCollectNFT(
+        Types.Publication storage _collectedPublication,
+        uint256 publicationCollectedProfileId,
+        uint256 publicationCollectedId,
+        address collectNFTImpl
+    ) private returns (address) {
+        address collectNFT = _collectedPublication.__DEPRECATED__collectNFT;
+        if (collectNFT == address(0)) {
+            collectNFT = _deployCollectNFT(publicationCollectedProfileId, publicationCollectedId, collectNFTImpl);
+            _collectedPublication.__DEPRECATED__collectNFT = collectNFT;
+        }
+        return collectNFT;
+    }
+
+    /**
+     * @notice Deploys the given profile's Collect NFT contract.
+     *
+     * @param profileId The token ID of the profile which Collect NFT should be deployed.
+     * @param pubId The publication ID of the publication being collected, which Collect NFT should be deployed.
+     * @param collectNFTImpl The address of the Collect NFT implementation that should be used for the deployment.
+     *
+     * @return address The address of the deployed Collect NFT contract.
+     */
+    function _deployCollectNFT(uint256 profileId, uint256 pubId, address collectNFTImpl) private returns (address) {
+        address collectNFT = Clones.clone(collectNFTImpl);
+
+        ICollectNFT(collectNFT).initialize(profileId, pubId);
+        emit Events.LegacyCollectNFTDeployed(profileId, pubId, collectNFT, block.timestamp);
+
+        return collectNFT;
+    }
+
+    function _prefillLegacyCollectFollowValidationHelper(
+        uint256 profileId,
+        uint256 collectorProfileId,
+        address collector
+    ) private {
+        // It's important to set it as zero if not following, as the storage could be dirty from a previous transaction.
+        StorageLib.legacyCollectFollowValidationHelper()[collector] = FollowLib.isFollowing({
+            followerProfileId: collectorProfileId,
+            followedProfileId: profileId
+        })
+            ? profileId
+            : 0;
+    }
+}