Function useFollow

useFollow allows you to follow another Profile.

You MUST be authenticated via useLogin to use this hook.

Example

const { execute: follow, error, loading } = useFollow();
Copy

Follow a profile

Given you have an instance of a Profile from fetched data, you can follow with:

const { execute, error, loading } = useFollow();

const follow = async (profile: Profile) => {
  const result = await execute({ profile });

  // ...
}
Copy

Failure scenarios

You can handle possible failure scenarios by checking the result value.

const follow = async (profile: Profile) => {
  const result = await execute({ profile });

  if (result.isFailure()) {
    switch (result.error.name) {
      case 'BroadcastingError':
        console.log('There was an error broadcasting the transaction', error.message);
        break;

      case 'PendingSigningRequestError':
        console.log(
          'There is a pending signing request in your wallet. ' +
            'Approve it or discard it and try again.'
        );
        break;

      case 'InsufficientAllowanceError':
        const requestedAmount = result.error.requestedAmount;
        console.log(
          'You must approve the contract to spend at least: '+
            `${requestedAmount.asset.symbol} ${requestedAmount.toSignificantDigits(6)}`
        );
        break;

      case 'InsufficientFundsError':
        const requestedAmount = result.error.requestedAmount;
        console.log(
          'You do not have enough funds to pay for this follow fee: '+
            `${requestedAmount.asset.symbol} ${requestedAmount.toSignificantDigits(6)}`
        );
        break;

      case 'WalletConnectionError':
        console.log('There was an error connecting to your wallet', error.message);
        break;

      case 'PrematureFollowError':
        console.log('There is a pending unfollow request for this profile.');
        break;

      case 'UserRejectedError':
        // the user decided to not sign, usually this is silently ignored by UIs
        break;
    }
    return;
  }
}
Copy

Wait for completion

You can always wait the operation to be fully processed and indexed by Lens API.

const follow = async (profile: Profile) => {
  const result = await execute({ profile });

  if (result.isFailure()) {
    // handle failure scenarios
    return;
  }

  // this might take a while depending on the congestion of the network
  const completion = await result.value.waitForCompletion();

  if (completion.isFailure()) {
    console.log('There was an processing the transaction', completion.error.message);
    return;
  }

  console.log('Follow executed successfully');
};
Copy

Self-funded approach

It just takes a single parameter to disable the sponsorship of the transaction gas costs.

const follow = async (profile: Profile) => {
  const result = await execute({
    profile,
    sponsored: false
  });

  if (result.isFailure()) {
    switch (result.error.name) {
      case 'InsufficientGasError':
        console.log('You do not have enough funds to pay for the transaction gas cost.');
        break;

      // ...
    }
    return;
  }

  // ...
}
Copy

In this example you can also see a new error type: InsufficientGasError. This error happens only with self-funded transactions and it means that the wallet does not have enough funds to pay for the transaction gas costs.

Self-funded fallback

If for some reason the Lens API cannot sponsor the transaction, the hook will fail with a BroadcastingError with one of the following reasons:

• BroadcastingErrorReason.NOT_SPONSORED - the profile is not sponsored
• BroadcastingErrorReason.RATE_LIMITED - the profile reached the rate limit
• BroadcastingErrorReason.APP_NOT_ALLOWED - the app is not whitelisted for gasless transactions

In those cases you can retry the transaction as self-funded like in the following example:

const follow = async (profile: Profile) => {
  const sponsoredResult = await execute({ profile });

  if (sponsoredResult.isFailure()) {
    switch (sponsoredResult.error.name) {
      case 'BroadcastingError':
        if ([BroadcastingErrorReason.NOT_SPONSORED, BroadcastingErrorReason.RATE_LIMITED].includes(sponsoredResult.error.reason)) {

          const selfFundedResult = await execute({ profile, sponsored: false });

          // continue with selfFundedResult as in the previous example
        }
        break;

     // ...
  }
}
Copy

In this example we omitted BroadcastingErrorReason.APP_NOT_ALLOWED as it's not normally a problem per-se. It just requires the app to apply for whitelisting. See https://docs.lens.xyz/docs/gasless-and-signless#whitelisting-your-app.

You can still include it in your fallback logic if you want to. For example to unblock testing your app from a domain that is not the whitelisted one (e.g. localhost).