Function useUpdateProfileManagers

Update the profile manager configuration for the authenticated profile.

You MUST be authenticated via useLogin to use this hook.

NOTE This hook waits for the transaction to be mined and indexed before returning. This is due to the fact that until a Profile Manager configuration change is fully finalized, the enabled managers cannot yet sign transactions. In the case of disabling profile managers, it's very likely you'll want the rest of the application to not perform operations while the transaction is pending.

Example

const { execute, loading, error } = useUpdateProfileManagers();
Copy

Basic usage

Enable/disable the Lens Profile Manager. This allows to perform signless transaction through the Lens API.

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

const callback = async () => {
  const result = await execute({
    approveSignless: true, // or false to disable it
  });

  if (result.isFailure()) {
    toast.error(result.error.message);
  }
};
Copy

Add/remove managers

Add/remove an arbitrary address to the list of Profile managers for the authenticated Profile.

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

const callback = async () => {
  const result = await execute({
    add: ['0x1234567890123456789012345678901234567890', '0x1234567890123456789012345678901234567891'],
    remove: ['0x1234567890123456789012345678901234567892'],
  });
}
Copy

Failure scenarios

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

const callback = async () => {
  const result = await execute({
    approveSignless: true,
  });

  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 'WalletConnectionError':
        console.log('There was an error connecting to your wallet', error.message);
        break;

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

Self-funded approach

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

const callback = async () => {
  const result = await execute({
    approveSignless: true,
    sponsored: false, <-- this is the only change
  });

  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 callback = async () => {
  // sponsored attempt
  const sponsoredResult = await execute({
    approveSignless: true,
  });

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

          const selfFundedResult = await execute({
            approveSignless: true,
            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).