Follow Module

Learn how to discover, utilize, and create new Follow Modules.

You can delve into the various Follow Modules available for the protocol. These modules are categorized into two types: known supported modules, which come with detailed information, and unknown supported modules, which provide basic contract information.

import { LensClient, development } from '@lens-protocol/client';
const client = new LensClient({  environment: development,});
const page = await client.modules.supportedFollowModules({  includeUnknown: true,  onlyVerified: true});

To use an Unknown Follow Module, you should be well-versed in the use of built-in Follow policies. If you need a refresher, refer to our guide here.

The following sections assume that you already know the address of the Unknown Follow Module you're interested in:

const followContract = "0x83E5aA2E3f46D3fad010d2cbC5F6Cb90Ec440aA5";

Often, you'll need the information contained in the Module Metadata to utilize the module.

In this section, we'll briefly show you how to do this. For more details, see Retrieve Module Metadata.

import { useLazyModuleMetadata } from "@lens-protocol/react-web";
// ...
const { execute } = useLazyModuleMetadata();
// ... in an async functionconst result = await execute({ implementation: followContract });
// handle retrieval errorsif (result.isFailure()) {  console.error(result.error.message);  return;}
const { metadata, sponsoredApproved, signlessApproved, verified } =  result.value;

First, you need to encode the initialization data for the Unknown Follow Module. This can be done using the initializeCalldataABI from the Module Metadata. The specifics of this data will depend on the chosen Unkown Follow Module.

import { encodeData, ModuleParam } from "@lens-protocol/react-web";
//...
const abi = JSON.parse(metadata.initializeCalldataABI) as ModuleParam[];const calldata = encodeData(abi, [  /* data according to Follow Module initialization spec */]);

Next, you'll use the sponsoredApproved flag to determine the appropriate transaction flow:

If the chosen Unknown Follow Module is sponsored approved, you can utilize the Sponsored Transaction flow to set it as the Profile Follow Module.

import {  FollowPolicyType,  useUpdateFollowPolicy,} from '@lens-protocol/react-web';
// ...
const { execute } = useUpdateFollowPolicy();
// ...
const result = await execute({  followPolicy: {    type: FollowPolicyType.UNKNOWN,    address: followContract,    data: calldata,  },});

Next, proceed as outlined in the Update Follow Policy section.

If the chosen Unknown Follow Module is not sponsored approved, you'll need to use a Self-Funded Transaction to set it as the Profile Follow Module.

import {  FollowPolicyType,  useUpdateFollowPolicy,} from '@lens-protocol/react-web';
// ...
const { execute } = useUpdateFollowPolicy();
// ...
const result = await execute({  followPolicy: {    type: FollowPolicyType.UNKNOWN,    address: followContract,    data: calldata,    sponsored: metadata.sponsoredApproved  },});
// continue with result as usual

To support an Unknown Follow Module, you first need to identify a Profile that is using such a module.

import {  FollowPolicyType,  resolveFollowPolicy,} from "@lens-protocol/react-web";
// ...
const followPolicy = resolveFollowPolicy(profile);
if (   // is an UnknownFollowPolicy  followPolicy.type === FollowPolicyType.UNKNOWN &&
  // it's implemented by the Follow Module we are interested in  followPolicy.contractAddress === followContract) {  // then followPolicy contains details about the Unknown Follow Module used}

Next, using the ABIs obtained from the Module Metadata, you can decode initializeCalldata and initializeResultData as follows:

import { decodeData, ModuleParam } from "@lens-protocol/react-web";
// decode init dataconst initData = decodeData(  JSON.parse(metadata.initializeCalldataABI) as ModuleParam[],  settings.initializeCalldata);
// decode init result, if presentconst initResult = decodeData(  JSON.parse(metadata.initializeResultDataABI) as ModuleParam[],  settings.initializeResultData);

You can now use the decoded data to tailor the user experience of your application. The specifics of this data will depend on the chosen Unknown Follow Module.

To follow such a profile, you need to encode the processing data using the metadata.processCalldataABI ABI.

import { encodeData, ModuleParam } from "@lens-protocol/react-web";
//...
const abi = JSON.parse(metadata.initializeCalldataABI) as ModuleParam[];const calldata = encodeData(abi, [  /* data according to Follow Module initialization spec */]);

The sponsoredApproved attribute of the module will now determine the transaction flow:

If the chosen Unknown Follow Module is approved for sponsorship, you can use the Sponsored Transaction flow to set it as the Profile Follow Module.

import { useFollow } from '@lens-protocol/react-web';
// ...const { execute } = useFollow();
// ...
const result = await execute({  profile,  data: calldata});

Next, proceed as outlined in the Follow section.

If the chosen Unknown Follow Module is not approved for sponsorship, you'll need to use a Self-Funded Transaction to set it as the Profile Follow Module.

import {  FollowPolicyType,  resolveFollowPolicy,  useFollow,} from '@lens-protocol/react-web';
// ...
const { execute } = useFollow();
// ...
const followPolicy = resolveFollowPolicy(profile);
// ...
const result = await execute({  profile,  data: calldata  sponsored: followPolicy.sponsoredApproved});
// continue with result as usual

We will use a hypothetical Follow Module as an example to illustrate the process of creating a custom Follow Module. This Follow Module allows users to follow the Profile using it, provided they include a secret code.

After reading this guide, see Registering a Module to learn how to register your module in the protocol.

Make sure you have a copy of the Lens Protocol repository and your environment is set up correctly. For guidance, refer to our setup guide.

Next, create a new file named SecretCodeFollowModule.sol in the contracts/modules/follow directory. This file will house the code for our new module.

pragma solidity 0.8.19;
import { IFollowModule } from 'contracts/interfaces/IFollowModule.sol';import { HubRestricted } from 'contracts/base/HubRestricted.sol';

contract SecretCodeFollowModule is HubRestricted, IFollowModule {  constructor(address hub) HubRestricted(hub) {}
  function initializeFollowModule(    uint256 profileId,    address transactionExecutor,    bytes calldata data  )    external    override    onlyHub    returns (bytes memory) {    // your implementation goes here  }
  function processFollow(    uint256 followerProfileId,    uint256 followerTokenId    address transactionExecutor,    uint256 targetProfileId,    bytes calldata data  ) external override {    // your implementation goes here  }}

The IFollowModule interface consists of two functions, each with a specific purpose:

Here's how this module will function:

To meet the above criteria, we need some additional features. Firstly, we need a place to store the passcodes. Secondly, we need a method for profile owners to set these passcodes during initialization. Lastly, we need a way to verify that users attempting to follow have provided the correct passcode.

Let's add a new mapping called _passcodeByProfile above our constructor. This will store the passcodes. We'll also create a new error, PasscodeInvalid(), which we'll throw when users provide the wrong passcode:

...contract SecretCodeFollowModule is HubRestricted, IFollowModule {    error PasscodeInvalid();
    mapping(uint256 => uint256) internal _passcodeByProfile;
    constructor...

The mapping we just created will use profile IDs as keys and their respective passcodes as values. It's quite straightforward! Now, let's construct our initialization mechanism using the initializeFollowModule() function:

...function initializeFollowModule(  uint256 profileId,  address transactionExecutor,  bytes calldata data)  external  override  onlyHub  returns (bytes memory){  uint256 passcode = abi.decode(data, (uint256));  _passcodeByProfile[profileId] = passcode;  return data;}...

To clarify, we first decode the passcode from the arbitrary data (provided by the profile owner), then we assign it as the profile's passcode.

You might be curious about why this function returns a bytes memory parameter. Essentially, this represents any data that alters the state and should be emitted by an event. In our case, we'll simply pass the original data because it includes the passcode, which we're using to change the state.

We're almost there! The final step is to ensure that users provide the correct passcode when attempting to follow. As this function does not modify the state but merely reads from it, we can also restrict its visibility to view:

...function processFollow(  uint256 followerProfileId,  uint256 followerTokenId  address transactionExecutor,  uint256 targetProfileId,  bytes calldata data) external view override {  uint256 passcode = abi.decode(data, (uint256));  if (passcode != _passcodeByProfile[profileId]) {    revert PasscodeInvalid();  }}...

To recap, the first line of our function decodes the passcode from the arbitrary data (provided by the user attempting to follow). The second line halts the execution if the provided passcode is incorrect.

There's no need to designate this function as onlyHub because it doesn't alter any state.

Congratulations! You've successfully created your own follow module. Let's review the complete SecretCodeFollowModule.sol file:

pragma solidity 0.8.19;
import {IFollowModule} from 'contracts/interfaces/IFollowModule.sol';import {HubRestricted} from 'contracts/base/HubRestricted.sol';
contract SecretCodeFollowModule is HubRestricted, IFollowModule {  error PasscodeInvalid();
  mapping(uint256 => uint256) internal _passcodeByProfile;
  constructor(address hub) HubRestricted(hub) {}
  function initializeFollowModule(    uint256 profileId,    address transactionExecutor,    bytes calldata data  )    external    override    onlyHub    returns (bytes memory)  {    uint256 passcode = abi.decode(data, (uint256));    _passcodeByProfile[profileId] = passcode;    return data;  }
  function processFollow(    uint256 followerProfileId,    uint256 followerTokenId    address transactionExecutor,    uint256 targetProfileId,    bytes calldata data  ) external view override {    uint256 passcode = abi.decode(data, (uint256));    if (passcode != _passcodeByProfile[profileId]) {      revert PasscodeInvalid();    }  }}