Exemplos de código CLMM

Exemplos completos em TypeScript: criar um pool CLMM, abrir uma posição em um intervalo de preço escolhido, ajustar a liquidez, fazer swap e coletar taxas e recompensas.

Banner de versão. Todas as demos em TypeScript têm como alvo @raydium-io/raydium-sdk-v2@0.2.64-alpha; elas foram executadas pela última vez com 0.2.42-alpha (2026-04), e as assinaturas de chamada foram verificadas novamente contra o código-fonte de 0.2.64-alpha em 2026-09-09, na mainnet-beta da Solana. O esqueleto de CPI em Rust no final tem como alvo raydium-clmm na branch master, com Anchor 1.0.2, a mesma versão fixada da página do CPMM, para que as duas possam coexistir no mesmo crate. Os IDs dos programas vêm de reference/program-addresses por meio do SDK.

​

Configuração

npm install @raydium-io/raydium-sdk-v2 @solana/web3.js @solana/spl-token bn.js decimal.js

Cada demo desta página espelha um arquivo em raydium-sdk-V2-demo/src/clmm; o link do GitHub fica ao lado de cada seção. A inicialização segue o config.ts.template do repositório de demos (fonte). Para qualquer integração não trivial, recomenda-se disableFeatureCheck: true:

import { Connection, Keypair, clusterApiUrl } from "@solana/web3.js";
import { Raydium, TxVersion } from "@raydium-io/raydium-sdk-v2";
import fs from "node:fs";

const connection = new Connection(process.env.RPC_URL ?? clusterApiUrl("mainnet-beta"));
const owner = Keypair.fromSecretKey(
  new Uint8Array(JSON.parse(fs.readFileSync(process.env.KEYPAIR!, "utf8"))),
);
const raydium = await Raydium.load({
  owner,
  connection,
  cluster: "mainnet",
  disableFeatureCheck: true,
  blockhashCommitment: "finalized",
});
export const txVersion = TxVersion.V0;

​

Criar um pool CLMM

Fonte: src/clmm/createPool.ts

import { PublicKey } from "@solana/web3.js";
import { CLMM_PROGRAM_ID } from "@raydium-io/raydium-sdk-v2";
import BN from "bn.js";
import Decimal from "decimal.js";

const mintA = await raydium.token.getTokenInfo(
  new PublicKey("So11111111111111111111111111111111111111112"));   // wSOL
const mintB = await raydium.token.getTokenInfo(
  new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"));   // USDC

// getClmmConfigs() retorna ApiClmmConfigInfo (id é uma string). createPool espera
// ClmmConfigInfo, que exige um id do tipo PublicKey e fundOwner/description — faça a conversão:
const clmmConfigs = await raydium.api.getClmmConfigs();
const picked = clmmConfigs.find((c) => c.index === 1)!;        // faixa de 0,05%
const ammConfig = { ...picked, id: new PublicKey(picked.id), fundOwner: "", description: "" };

const initialPrice = new Decimal(160);        // 160 USDC por SOL
const { execute, extInfo } = await raydium.clmm.createPool({
  programId: CLMM_PROGRAM_ID,
  mint1:     mintA,
  mint2:     mintB,
  ammConfig,
  initialPrice,
  txVersion: TxVersion.V0,   // sem `startTime` — CreateConcentratedPool não possui esse campo
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Pool:", extInfo.address.id, "tx:", txId);   // já é uma string base58

O SDK:

• Ordena mint1/mint2 pela ordem dos bytes antes da derivação.
• Calcula sqrt_price_x64 = floor(sqrt(initialPrice × 10^(dB−dA)) × 2^64).
• Cria as contas observation e tick_array_bitmap_extension.
• Paga a taxa de criação do pool definida por ammConfig.

​

Abrir uma posição em um intervalo escolhido

Fonte: src/clmm/createPosition.ts

import { PoolUtils, TickUtil } from "@raydium-io/raydium-sdk-v2";

const POOL_ID = "<POOL_ID>";   // string base58
// observação: getPoolInfoFromRpc do CLMM retorna `rpcPoolInfo`, e não `rpcData` (como o do CPMM)
const { poolInfo, poolKeys, rpcPoolInfo } = await raydium.clmm.getPoolInfoFromRpc(POOL_ID);

// Escolha um intervalo de preço. Aqui: ±10% do preço atual.
const currentPrice = new Decimal(poolInfo.price);
const lowerPrice   = currentPrice.mul(0.9);
const upperPrice   = currentPrice.mul(1.1);

// Ajuste para ticks válidos para o tick_spacing deste pool.
// A classe é TickUtil (no singular), e recebe decimais + tickSpacing, e não poolInfo.
const { tick: tickLower } = TickUtil.getPriceAndTick({
  price: lowerPrice,
  mintADecimals: poolInfo.mintA.decimals,
  mintBDecimals: poolInfo.mintB.decimals,
  zeroForOne: true,
  tickSpacing: poolInfo.config.tickSpacing,
});
const { tick: tickUpper } = TickUtil.getPriceAndTick({
  price: upperPrice,
  mintADecimals: poolInfo.mintA.decimals,
  mintBDecimals: poolInfo.mintB.decimals,
  zeroForOne: true,
  tickSpacing: poolInfo.config.tickSpacing,
});

// Quanto de cada token depositar.
const inputAmount = new BN(10_000_000);  // 0,01 SOL

// getLiquidityAmountOutFromAmountIn é assíncrona — use await.
const res = await PoolUtils.getLiquidityAmountOutFromAmountIn({
  poolInfo,
  slippage: 0.01,
  inputA: true,
  tickUpper,
  tickLower,
  amount: inputAmount,
  add: true,
  amountHasFee: true,
  epochInfo: await raydium.fetchEpochInfo(),
});

const { execute } = await raydium.clmm.openPositionFromBase({
  poolInfo,
  poolKeys,
  tickUpper,
  tickLower,
  base: "MintA",
  ownerInfo: { useSOLBalance: true },
  baseAmount: inputAmount,
  otherAmountMax: res.amountSlippageB.amount,
  txVersion: TxVersion.V0,
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Posição aberta, tx:", txId);

O SDK calcula quais tick arrays o intervalo atinge e os passa como contas. Não é necessário incluir nenhuma instrução de inicialização — não existe instrução de init-tick-array; OpenPosition* aloca sozinha um tick array que esteja faltando, às custas do pagador.

​

Aumentar a liquidez de uma posição existente

Fonte: src/clmm/increaseLiquidity.ts

const positionNftMint = new PublicKey("<POSITION_NFT_MINT>");

// Não existe getPositionInfo — liste as posições da carteira e escolha uma.
const allPositions = await raydium.clmm.getOwnerPositionInfo({
  programId: poolInfo.programId,
});
const positionAccount = allPositions.find((p) => p.nftMint.equals(positionNftMint));
if (!positionAccount) throw new Error("posição não encontrada para esta carteira");

const { execute } = await raydium.clmm.increasePositionFromBase({
  poolInfo,
  ownerPosition: positionAccount,
  ownerInfo: { useSOLBalance: true },   // obrigatório
  base: "MintA",
  baseAmount: new BN(5_000_000),
  otherAmountMax: new BN(1_000_000_000),
  txVersion: TxVersion.V0,              // esta chamada não tem o campo poolKeys
});

await execute({ sendAndConfirm: true });

​

Reduzir a liquidez (e coletar taxas ao mesmo tempo)

Fonte: src/clmm/decreaseLiquidity.ts e src/clmm/closePosition.ts

const { execute } = await raydium.clmm.decreaseLiquidity({
  poolInfo,
  poolKeys,
  ownerPosition: positionAccount,
  ownerInfo: {                       // obrigatório; closePosition fica aqui dentro
    useSOLBalance: true,
    closePosition: false,
  },
  liquidity: positionAccount.liquidity.divn(2),   // reduz pela metade
  amountMinA: new BN(0),
  amountMinB: new BN(0),
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

Para coletar somente taxas e recompensas, chame decreaseLiquidity com liquidity = new BN(0). O efeito colateral da instrução é liquidar token_fees_owed_{0,1} e reward_amount_owed e transferi-los para fora — esta é a única forma de coletar qualquer um dos dois.

Para fechar a posição por completo depois de zerar a liquidez e as taxas, passe ownerInfo: { closePosition: true } na última chamada de decreaseLiquidity. O SDK adiciona ClosePosition e queima o NFT.

Posições de emissor restrito exigem um builder de fechamento compatível. Essas posições têm uma conta de token NFT congelada. ClosePosition deve anexar o ID do pool de posição como a primeira conta remanescente, para que a CLMM possa descongelar a conta antes de queimá-la. O branch do código-fonte do programa não inclui nenhuma alteração no SDK. Confirme que a sua versão do SDK oferece suporte explícito ao caminho de fechamento de conta congelada antes de habilitar a criação de posições de emissor restrito.

Para um cliente Anchor direto, mantenha as contas declaradas inalteradas e anexe o pool:

// Programa CLMM: veja reference/program-addresses; código-fonte ecb1577;
// mainnet-beta da Solana; última verificação em 2026-08-13.
await program.methods
  .closePosition()
  .accounts({
    nftOwner,
    positionNftMint,
    positionNftAccount,
    personalPosition,
    systemProgram: SystemProgram.programId,
    tokenProgram: positionNftTokenProgram,
  })
  .remainingAccounts([
    { pubkey: poolId, isWritable: false, isSigner: false },
  ])
  .rpc();

Você pode passar poolId em todo fechamento. A CLMM só o lê quando positionNftAccount estiver congelada, o que mantém um único caminho no cliente compatível com posições antigas e novas.

​

Coletar recompensa(s)

Fonte: src/clmm/harvestAllRewards.ts

import { CLMM_PROGRAM_ID } from "@raydium-io/raydium-sdk-v2";

const { execute } = await raydium.clmm.harvestAllRewards({
  ownerInfo: { useSOLBalance: true },
  allPoolInfo: { [poolInfo.id]: poolInfo },
  allPositions: { [poolInfo.id]: [positionAccount] },
  programId: CLMM_PROGRAM_ID,
  txVersion: TxVersion.V0,
});

// harvestAllRewards é um builder de MÚLTIPLAS transações: `sequentially` é obrigatório
// e o resultado é `txIds`, e não `txId`.
const { txIds } = await execute({ sequentially: true });

harvestAllRewards percorre cada posição de cada pool recebido, agrupa as chamadas DecreaseLiquidity de liquidez zero que liquidam taxas e recompensas (além de eventuais UpdateRewardInfos) e as divide entre transações quando necessário.

​

Swap

Fonte: src/clmm/swap.ts

Este exemplo espelha src/clmm/swap.ts, que simula a operação com swapInternal em vez de PoolUtils.computeAmountOutFormat.

import {
  swapInternal,
  getPdaExBitmapAccount,
  TickArrayBitmapExtensionLayout,
  CLMM_PROGRAM_ID,
} from "@raydium-io/raydium-sdk-v2";

const amountIn   = new BN(10_000_000);
const zeroForOne = true;             // swap A (SOL) → B (USDC)

const poolIdPub = new PublicKey(poolInfo.id);
const { rpcData, tickArrays, configInfo } =
  await raydium.clmm.getSwapPoolInfo(poolInfo.id, zeroForOne);

const exBitmap = getPdaExBitmapAccount(CLMM_PROGRAM_ID, poolIdPub).publicKey;
const exBitmapInfo = await raydium.connection.getAccountInfo(exBitmap);

const simulation = swapInternal({
  programId: CLMM_PROGRAM_ID,
  poolId: poolIdPub,
  poolInfo: rpcData,
  tickArrays,
  configInfo,
  tickarrayBitmapExtension: TickArrayBitmapExtensionLayout.decode(exBitmapInfo!.data),
  amountSpecified: amountIn,
  sqrtPriceLimitX64: new BN(0),
  zeroForOne,
  isBaseInput: true,               // false for exact-output
  blockTimestamp: Math.floor(Date.now() / 1000),
  includeExtraTickArrays: true,
});

const { execute } = await raydium.clmm.swap({
  poolInfo,
  poolKeys,
  inputMint: poolInfo.mintA.address,
  amountIn,
  amountOutMin: simulation.amountCalculated,
  observationId: rpcData.observationId,
  ownerInfo: { useSOLBalance: true },   // required
  remainingAccounts: simulation.accounts,
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

A simulação percorre o mapa de ticks off-chain, com a mesma lógica do programa on-chain, e retorna o valor de saída (amountCalculated) junto com a lista exata de contas que a swap vai acessar (accounts).

Sempre passe o remainingAccounts retornado pela simulação: se faltarem contas, a swap é revertida no meio do percurso com NotEnoughTickArrayAccount; se forem contas desatualizadas, você só desperdiça compute.

PoolUtils.computeAmountOutFormat ainda existe, mas exige um ComputeClmmPoolInfo (o computePoolInfo retornado por getPoolInfoFromRpc, e não um objeto de pool da API), além de dois argumentos obrigatórios a mais — tickarrayBitmapExtension e blockTimestamp. Além disso, não existe o método raydium.clmm.fetchTickArrays (fetchTickArrays é uma função independente; os auxiliares no nível do módulo são PoolUtils.fetchMultiplePoolTickArrays e o tickData / tickArrays retornados por getPoolInfoFromRpc).

​

Criar um pool CLMM personalizável

createCustomizablePool é o ponto de entrada que expõe as opções de taxa dinâmica e de taxa de lado único no momento da criação do pool. Ele recebe a mesma estrutura de createPool, com dois campos adicionais:

import { CLMM_PROGRAM_ID, CollectFeeOn } from "@raydium-io/raydium-sdk-v2";

const dynamicFeeConfigs = await raydium.api.getClmmDynamicConfigs();    // GET /main/clmm-dynamic-config
const dynamicFeeConfig  = dynamicFeeConfigs.find((c) => c.index === 0); // escolha uma faixa de calibração

const { execute, extInfo } = await raydium.clmm.createCustomizablePool({
  programId: CLMM_PROGRAM_ID,
  mint1:     mintA,
  mint2:     mintB,
  ammConfig,
  initialPrice,
  // Os dois campos adicionais:
  collectFeeOn:      CollectFeeOn.TokenOnlyB,   // FromInput | TokenOnlyA | TokenOnlyB
  dynamicFeeConfig:  new PublicKey(dynamicFeeConfig!.id),
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });
console.log("Pool personalizável:", extInfo.address.id);   // string base58

Não existe um parâmetro enableDynamicFee, nem dynamicFeeConfigId, nem startTime. Fornecer dynamicFeeConfig é o que habilita as taxas dinâmicas — se você omiti-lo, obtém um pool com taxa estática, sem nenhum erro. Observe também que os membros do enum no SDK são TokenOnlyA / TokenOnlyB, enquanto o enum Rust on-chain os escreve como Token0Only / Token1Only; os valores numéricos são os mesmos (FromInput = 0).

createPool continua funcionando para o caminho de taxa padrão, sem taxa dinâmica. Use createCustomizablePool sempre que precisar de qualquer uma dessas opções. Para a lista de contas on-chain, consulte /pt/products/clmm/instructions.

​

Ordens limitadas

Uma ordem limitada deposita o valor do usuário em um único tick e é preenchida em FIFO quando uma swap atravessa esse tick. Os valores de saída são enviados para o ATA do dono no momento da liquidação; o dono não precisa estar online para que a ordem seja preenchida.

​

Abrir uma ordem limitada

Não existe uma conta de configuração de ordens limitadas por pool, nem um auxiliar getClmmLimitOrderConfigs() — as ordens são identificadas pelo tick.

import {
  getOrderTick,
  getPdaExBitmapAccount,
  CLMM_PROGRAM_ID,
} from "@raydium-io/raydium-sdk-v2";

const { poolInfo, rpcData } = await raydium.clmm.getSimplePoolInfo(POOL_ID);

// O preço limite DEVE ser quantizado para tick_spacing — o getOrderTick faz isso.
const targetPrice = new Decimal(180);                              // vender SOL a 180 USDC
const orderData = getOrderTick({
  baseIn: true,                                                    // vendendo mintA
  mintADecimal: poolInfo.mintA.decimals,
  mintBDecimal: poolInfo.mintB.decimals,
  tickSpacing: poolInfo.config.tickSpacing,
  price: targetPrice,
});

// Uma ordem de venda deve ficar acima do tick atual; uma ordem de compra, abaixo.
if (orderData.tick < rpcData.tickCurrent) throw new Error("o preço de venda deve ser > preço atual");

const { execute, extInfo } = await raydium.clmm.openLimitOrder({
  poolInfo,
  baseIn: true,
  orderTick: orderData.tick,
  amount: new BN(50_000_000),                // 0,05 SOL
  tickArrayBitmap: getPdaExBitmapAccount(
    CLMM_PROGRAM_ID,
    new PublicKey(poolInfo.id),
  ).publicKey,
  // noneIndex: 0,                           // opcional, o padrão é 0
  txVersion: TxVersion.V0,
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Ordem limitada aberta:", extInfo.limitOrder.toBase58(), "tx:", txId);

O SDK deriva a PDA de LimitOrderState a partir de (owner, nonce PDA, order nonce), incrementa o LimitOrderNonce da carteira e insere a ordem na coorte FIFO daquele tick.

​

Aumentar / reduzir uma ordem aberta

const limitOrder = new PublicKey("<LIMIT_ORDER_PDA>");

await raydium.clmm.increaseLimitOrder({
  poolInfo,
  limitOrder,
  amount: new BN(20_000_000),
  txVersion: TxVersion.V0,
}).then((b) => b.execute({ sendAndConfirm: true }));

await raydium.clmm.decreaseLimitOrder({
  poolInfo,
  limitOrder,
  amount: new BN(10_000_000),
  slippage: 100,                 // opcional; DecreaseLimitOrder acrescenta isto ao Increase
  txVersion: TxVersion.V0,
}).then((b) => b.execute({ sendAndConfirm: true }));

decreaseLimitOrder só pode remover a parte não preenchida da ordem; a parte preenchida fica bloqueada até a liquidação. Ambas as instruções são revertidas com InvalidOrderPhase se a ordem já tiver sido totalmente preenchida.

​

Liquidar uma ordem preenchida

// settleLimitOrder recebe APENAS a PDA da ordem — sem poolInfo, sem poolKeys.
await raydium.clmm.settleLimitOrder({
  limitOrder,
  txVersion: TxVersion.V0,
}).then((b) => b.execute({ sendAndConfirm: true }));

settleLimitOrder lê o unfilled_ratio_x64 da ordem em relação ao rastreador da coorte, calcula a saída preenchida e a transfere para o ATA do dono. O próprio dono pode chamar essa função; o limit_order_admin (um keeper operacional off-chain) também pode chamá-la em nome do dono — a saída continua indo para o dono.

Para fechar ordens totalmente liquidadas e recuperar o rent, use closeLimitOrder (uma por vez) ou closeAllLimitOrder (em lote). Para liquidar várias ordens de uma vez, settleAllLimitOrder agrupa quantas chamadas de SettleLimitOrder couberem em uma transação v0.

​

Listar as ordens ativas de uma carteira (off-chain)

// Auxiliar da API. Consulte api-reference/temp-api-v1.
const active = await fetch(
  `https://temp-api-v1.raydium.io/limit-order/order/list?wallet=<your-wallet-pubkey>`,
).then((r) => r.json());

O endpoint de ordens ativas retorna, em um único payload, ordens não preenchidas e parcialmente preenchidas (totalAmount / filledAmount / pendingSettle distinguem as fases). Para o histórico de ordens fechadas, use /limit-order/history/order/list-by-user?wallet=… (por carteira, paginado por nextPageId); para o log completo de eventos de uma ordem específica, use /limit-order/history/event/list-by-pda?pda=….

​

Esqueleto de CPI em Rust

// Cargo.toml — `master` fixa anchor-lang =1.0.2.
// anchor-lang  = "=1.0.2"   // deve corresponder ao que o raydium-clmm fixa
// anchor-spl   = "=1.0.2"
// raydium-clmm = { git = "https://github.com/raydium-io/raydium-clmm",
//                  branch = "master", features = ["cpi"] }
//
// Mesma linha do Anchor do exemplo CPMM em products/cpmm/code-demos, então os dois
// crates de CPI podem ser dependências de um único programa.

use anchor_lang::prelude::*;
use raydium_clmm::cpi;
use raydium_clmm::program::RaydiumClmm;
use raydium_clmm::cpi::accounts::SwapSingleV2;   // `SwapV2` é o nome da instrução,
                                                 // `SwapSingleV2` é a struct de contas

#[derive(Accounts)]
pub struct ProxyClmmSwap<'info> {
    #[account(mut)]
    pub payer: Signer<'info>,
    /// CHECK:
    pub amm_config: UncheckedAccount<'info>,
    #[account(mut)]
    /// CHECK:
    pub pool_state: UncheckedAccount<'info>,
    #[account(mut)]
    /// CHECK:
    pub input_token_account: UncheckedAccount<'info>,
    #[account(mut)]
    /// CHECK:
    pub output_token_account: UncheckedAccount<'info>,
    #[account(mut)]
    /// CHECK:
    pub input_vault: UncheckedAccount<'info>,
    #[account(mut)]
    /// CHECK:
    pub output_vault: UncheckedAccount<'info>,
    #[account(mut)]
    /// CHECK:
    pub observation_state: UncheckedAccount<'info>,
    /// CHECK:
    pub token_program: UncheckedAccount<'info>,
    /// CHECK:
    pub token_program_2022: UncheckedAccount<'info>,
    /// CHECK:
    pub memo_program: UncheckedAccount<'info>,
    /// CHECK:
    pub input_vault_mint: UncheckedAccount<'info>,
    /// CHECK:
    pub output_vault_mint: UncheckedAccount<'info>,
    pub clmm_program: Program<'info, RaydiumClmm>,
    // `remaining_accounts` carrega as contas de tick_array e de bitmap_extension.
}

pub fn proxy_swap<'info>(
    ctx: Context<'info, ProxyClmmSwap<'info>>,
    amount: u64,
    other_amount_threshold: u64,
    sqrt_price_limit_x64: u128,
    is_base_input: bool,
) -> Result<()> {
    let cpi_accounts = SwapSingleV2 {
        payer:                 ctx.accounts.payer.to_account_info(),
        amm_config:            ctx.accounts.amm_config.to_account_info(),
        pool_state:            ctx.accounts.pool_state.to_account_info(),
        input_token_account:   ctx.accounts.input_token_account.to_account_info(),
        output_token_account:  ctx.accounts.output_token_account.to_account_info(),
        input_vault:           ctx.accounts.input_vault.to_account_info(),
        output_vault:          ctx.accounts.output_vault.to_account_info(),
        observation_state:     ctx.accounts.observation_state.to_account_info(),
        token_program:         ctx.accounts.token_program.to_account_info(),
        token_program_2022:    ctx.accounts.token_program_2022.to_account_info(),
        memo_program:          ctx.accounts.memo_program.to_account_info(),
        input_vault_mint:      ctx.accounts.input_vault_mint.to_account_info(),
        output_vault_mint:     ctx.accounts.output_vault_mint.to_account_info(),
    };
    // No Anchor 1.0 é passada aqui a Pubkey do programa, não o seu AccountInfo. Na
    // branch `master` 0.32, isso era `ctx.accounts.clmm_program.to_account_info()`.
    let cpi_ctx = CpiContext::new(*ctx.accounts.clmm_program.key, cpi_accounts)
        .with_remaining_accounts(ctx.remaining_accounts.to_vec());
    cpi::swap_v2(cpi_ctx, amount, other_amount_threshold, sqrt_price_limit_x64, is_base_input)
}

Ordem das contas restantes (remaining accounts) para SwapV2:

[tick_array_bitmap_extension?, tick_array_0, tick_array_1, …]

Se a swap nunca precisar da extensão, omita-a; caso contrário, ela é a primeira conta restante.

​

Armadilhas comuns

• Extremos de tick fora do espaçamento → TickAndSpacingNotMatch. Sempre ajuste os valores com TickUtil.getPriceAndTick (no singular, TickUtil).
• Não fornecer tick arrays suficientes no SwapV2 → NotEnoughTickArrayAccount. Obtenha a lista a partir de swapInternal(...).accounts.
• Posição de faixa total sem a extensão do bitmap → a PDA da extensão precisa ser gravável; o SDK faz isso automaticamente.
• Confundir sqrt_price_x64 com price → um erro de fator 2 aqui é especialmente problemático. Na dúvida, deixe o SDK calcular o valor a partir de um preço legível.
• Coletar recompensas com frequência excessiva → cada coleta é um DecreaseLiquidity com liquidez zero e custa uma transação. Agrupe as coletas com harvestAllRewards em várias posições e lembre-se de que o execute dela precisa de { sequentially: true }.
• Fechar as contas de NFT manualmente → ClosePosition queima o NFT e fecha seu ATA. Ele também fecha um mint de NFT Token-2022; já um mint do SPL Token clássico permanece com supply zero, pois esse programa não consegue fechar mints. Não feche as contas suportadas separadamente, ou a instrução será revertida.
• Abrir uma ordem limite em um tick fora do espaçamento → TickAndSpacingNotMatch. Sempre quantize o valor com o helper exportado getOrderTick.
• Chamar decreaseLimitOrder em uma ordem totalmente preenchida → InvalidOrderPhase. Use settleLimitOrder e, em seguida, closeLimitOrder.
• Esperar uma flag enableDynamicFee → ela não existe. Omitir dynamicFeeConfig simplesmente cria um pool de taxa estática, sem aviso e sem erro. Se você quiser taxas dinâmicas, passe o PublicKey da conta de configuração, escolhido em /pt/main/clmm-dynamic-config.

​

Próximos passos

• sdk-api/typescript-sdk — superfície completa do SDK.
• sdk-api/rest-api — endpoints de cotação e metadados de pools.
• user-flows/create-clmm-pool — passo a passo sem código.
• integration-guides/aggregator — roteamento de CLMM como parte de um caminho de swap.

Fontes:

• Raydium SDK v2
• Raydium SDK v2 demos
• raydium-io/raydium-clmm