Locking liquidity / collecting fees

Lock LP tokens permanently using the Burn & Earn program and collect your share of trading fees via a Fee Key NFT.

---

How it works

When you lock LP tokens:

1. Your LP tokens are transferred to the Burn & Earn locker program — they cannot be withdrawn.

2. You receive a Fee Key NFT that represents your locked position.

3. The Fee Key NFT entitles you to claim trading fees that have accumulated in the pool.

How fee harvesting works under the hood

In a constant-product pool, fees aren't stored separately — they accumulate in the pool vaults, making each LP token worth more underlying tokens over time. The only way to extract that accrued value is to redeem (burn) LP tokens.

When you harvest from a locked position:

1. Your locked position holds, say, 1000 LP tokens.

2. Swaps occur, fees flow into the pool vaults, and each LP token appreciates in value.

3. You call harvestLockLp with an lpFeeAmount (e.g. 5 LP).

4. The locker program burns those 5 LP via a withdraw on the CPMM program.

5. You receive the proportional share of token A + token B to your wallet.

6. Your locked position now holds 995 LP tokens.

The LP balance does decrease with each harvest. However, the remaining 995 LP tokens are worth roughly what the original 1000 were before fees accumulated, because each LP token is now worth more. You are extracting the appreciation, not the principal.

The lpFeeAmount parameter controls how much LP to burn.

---

Locking LP tokens

Use raydium.cpmm.lockLp() to permanently lock LP tokens and receive a Fee Key NFT.

import {
  ApiV3PoolInfoStandardItemCpmm,
  CpmmKeys,
  DEVNET_PROGRAM_ID,
  TxVersion,
} from '@raydium-io/raydium-sdk-v2'
import { initSdk } from '../config'

const lockLiquidity = async () => {
  const raydium = await initSdk()
  const poolId = 'YOUR_POOL_ID'

  let poolInfo: ApiV3PoolInfoStandardItemCpmm
  let poolKeys: CpmmKeys | undefined

  if (raydium.cluster === 'mainnet') {
    const data = await raydium.api.fetchPoolById({ ids: poolId })
    poolInfo = data[0] as ApiV3PoolInfoStandardItemCpmm
  } else {
    const data = await raydium.cpmm.getPoolInfoFromRpc(poolId)
    poolInfo = data.poolInfo
    poolKeys = data.poolKeys
  }

  // Fetch wallet token accounts to get LP balance
  await raydium.account.fetchWalletTokenAccounts()
  const lpBalance = raydium.account.tokenAccounts.find(
    (a) => a.mint.toBase58() === poolInfo.lpMint.address
  )
  if (!lpBalance) throw new Error(`no LP balance for pool: ${poolId}`)

  const { execute, extInfo } = await raydium.cpmm.lockLp({
    // devnet: programId: DEVNET_PROGRAM_ID.LOCK_CPMM_PROGRAM
    // devnet: authProgram: DEVNET_PROGRAM_ID.LOCK_CPMM_AUTH
    // devnet: poolKeys
    poolInfo,
    lpAmount: lpBalance.amount,
    withMetadata: true,
    txVersion: TxVersion.V0,
  })

  const { txId } = await execute({ sendAndConfirm: true })
  console.log('lp locked', {
    txId: `https://explorer.solana.com/tx/${txId}`,
    nftMint: extInfo,
  })
}

lockLiquidity()

Lock parameters

Parameter	Type	Description
poolInfo	object	Pool info from API or RPC.
poolKeys	object	Pool keys. Required for devnet.
lpAmount	BN	Amount of LP tokens to lock, in smallest units.
withMetadata	boolean	If true, creates on-chain metadata for the Fee Key NFT.
programId	PublicKey	Locker program. Mainnet default is auto-resolved. Devnet: DEVNET_PROGRAM_ID.LOCK_CPMM_PROGRAM.
authProgram	PublicKey	Locker auth program. Devnet: DEVNET_PROGRAM_ID.LOCK_CPMM_AUTH.
txVersion	TxVersion	Transaction version.

Locking is permanent. Once locked, LP tokens cannot be withdrawn. Only the trading fees can be collected via the Fee Key NFT.

---

Collecting fees from locked liquidity

Use raydium.cpmm.harvestLockLp() to claim accumulated trading fees from a locked LP position using the Fee Key NFT mint address.

import { PublicKey } from '@solana/web3.js'
import BN from 'bn.js'

const harvestLockLiquidity = async () => {
  const raydium = await initSdk()
  const poolId = 'YOUR_POOL_ID'

  let poolInfo: ApiV3PoolInfoStandardItemCpmm
  let poolKeys: CpmmKeys | undefined

  if (raydium.cluster === 'mainnet') {
    const data = await raydium.api.fetchPoolById({ ids: poolId })
    poolInfo = data[0] as ApiV3PoolInfoStandardItemCpmm
  } else {
    const data = await raydium.cpmm.getPoolInfoFromRpc(poolId)
    poolInfo = data.poolInfo
    poolKeys = data.poolKeys
  }

  const { execute } = await raydium.cpmm.harvestLockLp({
    // devnet: programId: DEVNET_PROGRAM_ID.LOCK_CPMM_PROGRAM
    // devnet: authProgram: DEVNET_PROGRAM_ID.LOCK_CPMM_AUTH
    // devnet: poolKeys
    poolInfo,
    nftMint: new PublicKey('YOUR_FEE_KEY_NFT_MINT'),
    lpFeeAmount: new BN(99999999),
    txVersion: TxVersion.V0,
    // closeWsol: false, // default true — set false to keep wSOL account
  })

  const { txId } = await execute({ sendAndConfirm: true })
  console.log('fees harvested', { txId: `https://explorer.solana.com/tx/${txId}` })
}

harvestLockLiquidity()

Harvest parameters

Parameter	Type	Description
poolInfo	object	Pool info from API or RPC.
poolKeys	object	Pool keys. Required for devnet.
nftMint	PublicKey	Mint address of the Fee Key NFT received when locking.
lpFeeAmount	BN	Amount of LP tokens to burn from the locked position. This is how you extract accumulated fee value — see "How fee harvesting works" above.
closeWsol	boolean	Default true. Closes wSOL account and returns native SOL. Set false to keep wSOL.
txVersion	TxVersion	Transaction version.

---

Collecting creator fees

Creator fees are a separate per-swap fee paid to the pool creator. They are only available on pools created via the permissioned path (createPoolWithPermission), which requires a Permission PDA from the Raydium admin. Pools created with the standard createPool() have creator fees disabled at the program level — see Creating a pool for details.

If your pool was created with permission and the fee config includes a non-zero creator_fee_rate, you can collect the accumulated creator fees.

Single pool

const collectCreatorFee = async () => {
  const raydium = await initSdk()
  // ... fetch poolInfo and poolKeys

  const { execute } = await raydium.cpmm.collectCreatorFees({
    poolInfo,
    poolKeys,
    txVersion: TxVersion.V0,
  })

  const { txId } = await execute({ sendAndConfirm: true })
  console.log('creator fees collected', { txId: `https://explorer.solana.com/tx/${txId}` })
}

Multiple pools at once

import {
  CREATE_CPMM_POOL_PROGRAM,
  DEVNET_PROGRAM_ID,
} from '@raydium-io/raydium-sdk-v2'

const collectAllCreatorFees = async () => {
  const raydium = await initSdk()
  const isDevnet = raydium.cluster === 'devnet'

  const host = isDevnet
    ? 'https://temp-api-v1-devnet.raydium.io'
    : 'https://temp-api-v1.raydium.io'

  // Fetch all pools where the connected wallet has pending creator fees
  const res = await fetch(
    `${host}/cp-creator-fee?wallet=${raydium.ownerPubKey.toBase58()}`
  )
  const { data } = await res.json()

  const poolsWithFees = data.filter(
    (d: any) => d.fee.amountA !== '0' || d.fee.amountB !== '0'
  )

  if (!poolsWithFees.length) {
    console.log('no pending creator fees')
    return
  }

  const { execute } = await raydium.cpmm.collectMultiCreatorFees({
    poolInfoList: poolsWithFees.map((d: any) => d.poolInfo),
    programId: isDevnet
      ? DEVNET_PROGRAM_ID.CREATE_CPMM_POOL_PROGRAM
      : CREATE_CPMM_POOL_PROGRAM,
    txVersion: TxVersion.V0,
  })

  const sentInfo = await execute({ sequentially: true })
  console.log('creator fees collected', sentInfo)
}