Help & Support

Account Funds

This guide explains how to manage your Lens Account funds.

The Lens Account is a smart wallet that allows you to manage funds for your collects, tips, and other transactions on Lens. By using the Lens Account funds, your wallet's exposure to the Lens app is minimized, which helps mitigate potential security threats.

Account Balances

A Lens Account can hold native GHO tokens (GRASS on testnet) and various ERC-20 tokens. This section explains how to fetch the balances for the authenticated account.

You MUST be authenticated as Account Owner or Account Manager of the Lens Account you intend to fetch balances for.

Use the fetchAccountBalances action to fetch a finite number of balances.

import { evmAddress } from "@lens-protocol/client";import { fetchAccountBalances } from "@lens-protocol/client/actions";
const result = await fetchAccountBalances(sessionClient, {  tokens: [evmAddress("0x1234…"), evmAddress("0x5678…")],});
if (result.isErr()) {  return console.error(result.error);}
// Array<Erc20Amount | NativeAmount | Erc20BalanceError | NativeBalanceError>const balances = result.value;

This response differs slightly from others by providing a localized error for each balance that couldn’t be fetched. This enables more graceful error handling, allowing you to display some balances even if others fail.

Example
for (let balance of balances) {  switch (balance.__typename) {    case "Erc20Amount":      console.log(`${balance.value} ${balance.asset.symbol}`);      break;
    case "NativeAmount":      console.log(`${balance.value} ${balance.asset.symbol}`);
    case "Erc20BalanceError":    case "NativeBalanceError":      console.error(balance.reason);  }}

Fiat On-Ramps

Integrate fiat on-ramps into your app to allow users to deposit funds into their Lens Account using a debit or credit card. This can be achieved with Thirdweb Pay.

The following procedure lays a foundation for integrating fiat on-ramps into your app.

Due to the absence of liquidity and swapping routes, this solution is fully testable only on the Lens Mainnet.

1

Get Your Client ID

First, log in to the thirdweb dashboard. Navigate to the Settings page and create an API key to get your Client ID.

2

Configure thirdweb SDK

Next, install the thirdweb SDK.

npm install thirdweb

And, wrap your app with the <ThirdwebProvider> component as follows.

App.tsx
import { ThirdwebProvider } from "thirdweb/react";
export default function App() {  return <ThirdwebProvider>{/* Your app code here */}</ThirdwebProvider>;}

3

Create a thirdweb Client

Create a thirdweb client using your Client ID.

thirdweb.ts
import { createThirdwebClient } from "thirdweb";
export const client = createThirdwebClient({  clientId: "<your_client_id>",});

4

The PayEmbed Widget

Finally, integrate the PayEmbed widget into your app to allow users to deposit funds using fiat on-ramps.

Thirdweb Pay integration on Mainnet will start working on Lens Chain soon after the mainnet launch.

import { base } from "thirdweb/chains";import { PayEmbed } from "thirdweb/react";
import { client } from "./thirdweb";
// …
<PayEmbed  client={client}  payOptions={{    mode: "direct_payment",    buyWithFiat: {      preferredProvider: "COINBASE",
      // enable/disable test mode      testMode: true,    },    buyWithCrypto: false,    paymentInfo: {      // amount of token to buy      amount: "5",
      // workaround for getting quotes working      chain: ethereum,
      // Lens Account address      sellerAddress: "0x1234…",      token: {        // Using GHO on Ethereum to get quotes working        address: "0x40d16fc0246ad3160ccc09b8d0d3a2cd28ae6c2f",
        // Making it look like GRASS token        name: "GHO",        symbol: "GHO",        icon: "https://explorer.lens.xyz/images/gho.png",      },    },    onPurchaseSuccess: (purchase) => {      console.log("Purchase success", purchase);    },  }}/>;

Use the paymentInfo.sellerAddress to specify the Lens Account address to top up. The integration suggested here is known as Commerce payment, hence the term seller for the address receiving the tokens.

Wallet Adapters

To prevent the need to reconnect the wallet when using the PayEmbed widget, you can utilize the wallet adapter for your chosen library.

import { createThirdwebClient } from "thirdweb";import { viemAdapter } from "thirdweb/adapters/viem";import { ethereum } from "thirdweb/chains";import { type Address, createWalletClient, custom } from "viem";
import { walletClient } from "./wallet";
export const thirdwebWallet = await viemAdapter.wallet.fromViem({  walletClient: walletClient,});
export const client = createThirdwebClient({  clientId: "<your_client_id>",});

If you encounter a TypeScript error while assigning the WalletClient instance to the thirdweb viem adapter, it is likely due to a version mismatch between the viem version you have installed and the version used in the thirdweb SDK.

Type Error
export const thirdwebWallet = await viemAdapter.wallet.fromViem({  walletClient: walletClient,});

To fix this, you can force the viem version in your package.json file according to the package manager you are using.

{  "dependencies": {    "thirdweb": "^5.89.0",    "viem": "^2.21.55"  },  "overrides": {    "viem": "^2.21.55"  }}

Then, run the following line before embedding the PayEmbed widget.

await thirdwebWallet.connect({ client });

And pass the thirdweb wallet to the PayEmbed widget.

import { thirdwebWallet } from "./thirdweb";
// …
<PayEmbed  activeWallet={thirdwebWallet}  client={client}  // …/>;

That's it—this will make the PayEmbed widget render without displaying a Connect button.

Deposit Funds

Account Owners and Account Managers can deposit funds into their Lens Accounts. To deposit funds, follow these steps.

You MUST be authenticated as the Account Owner or Account Manager to deposit funds into the authenticated Lens Account.

1

Prepare the Request

First, specify the amount to deposit.

Use the deposit action to prepate the transaction request.

import { bigDecimal } from "@lens-protocol/client";import { deposit } from "@lens-protocol/client/action";
const result = await deposit(sessionClient, {  native: bigDecimal(42.5),});

2

Handle Result

Then, handle the result using the adapter for the library of your choice:

import { handleOperationWith } from "@lens-protocol/client/viem";
// …
const result = await withdraw(sessionClient, {  // …}).andThen(handleOperationWith(walletClient));

Unlike most other transactions, there is no need to wait for the transaction to be indexed.

That's it—you can now use the funds in the Lens Account for collecting, tipping, and any other action or rule that requires funds.

Wrapped GHO

Lens Chain uses GHO as its native gas token on mainnet and GRASS on testnet. If you need Wrapped GHO (WGHO)—or Wrapped GRASS (WGRASS) on testnet—to collect a publication in this currency or to tip someone, you can wrap the GHO or GRASS held in your Lens Account.

Wrap GHO

To wrap tokens, follow these steps.

You MUST be authenticated as the Account Owner or Account Manager to be able to wrap GHO—or **GRASS on testnet—held in your Lens Account.

1

Prepare the Request

First, specify the amount to wrap.

Use the wrapTokens action to prepate the transaction request.

Wrap Tokens
import { bigDecimal } from "@lens-protocol/client";import { wrapTokens } from "@lens-protocol/client/action";
const result = await wrapTokens(sessionClient, {  amount: bigDecimal(42.5),});

2

Handle Result

Then, handle the result using the adapter for the library of your choice:

import { handleOperationWith } from "@lens-protocol/client/viem";
// …
const result = await await wrapTokens(sessionClient, {  amount: bigDecimal(42.5),}).andThen(handleOperationWith(walletClient));

Unlike most other transactions, there is no need to wait for the transaction to be indexed.

That's it—wrapped tokens are now in the Lens Account.

Unwrap GHO

To unwrap tokens, follow these steps.

You MUST be authenticated as the Account Owner or Account Manager to be able to unwrap WGHO or WGRASS held in your Lens Account.

1

Prepare the Request

First, specify the amount to unwrap.

Use the unwrapTokens action to prepare the transaction request.

Unwrap Tokens
import { bigDecimal } from "@lens-protocol/client";import { unwrapTokens } from "@lens-protocol/client/action";
const result = await unwrapTokens(sessionClient, {  amount: bigDecimal(42.5),});

2

Handle Result

Then, handle the result using the adapter for the library of your choice:

import { handleOperationWith } from "@lens-protocol/client/viem";
// …
const result = await unwrapTokens(sessionClient, {  // …}).andThen(handleOperationWith(walletClient));

Unlike most other transactions, there is no need to wait for the transaction to be indexed.

That's it—unwrapped tokens are now in the Lens Account.

Withdraw Funds

Account Owners can withdraw funds from their Lens Accounts. Account Managers can also withdraw funds from an account they manage, provided they have the canTransferTokens and/or canTransferNative permissions. See the Account Manager guide for more information.

To withdraw funds from a Lens Account, follow these steps.

You MUST be authenticated as the Account Owner or Account Manager with the necessary permissions of the Lens Account you intend to withdraw funds from.

1

Prepare the Request

First, specify the amount to withdraw and the destination address.

Use the withdraw action to prepate the transaction request.

import { bigDecimal } from "@lens-protocol/client";import { withdraw } from "@lens-protocol/client/action";
const result = await withdraw(sessionClient, {  native: bigDecimal(42.5),});

2

Handle Result

Then, handle the result using the adapter for the library of your choice:

import { handleOperationWith } from "@lens-protocol/client/viem";
// …
const result = await withdraw(sessionClient, {  // …}).andThen(handleOperationWith(walletClient));

Unlike most other transactions, there is no need to wait for the transaction to be indexed.

That's it—funds are now in the wallet address.

Previous
Account Actions
Next
Notifications