Demonstrações de código CLMM

Esta página foi traduzida automaticamente por IA. A versão em inglês é a fonte oficial.Ver versão em inglês →

Banner de versão. Todos os demos TypeScript visam @raydium-io/raydium-sdk-v2@0.2.64-alpha; foram executados pela última vez contra 0.2.42-alpha (2026-04) e suas assinaturas de chamada foram verificadas novamente contra a fonte 0.2.64-alpha em 2026-09-09, contra Solana mainnet-beta. O esqueleto Rust CPI no final visa raydium-clmm no branch chore/upgrade-anchor, Anchor 1.0.2, o mesmo pin da página CPMM, para que os dois possam conviver em um crate. master ainda fixa 0.32.1. Os IDs de programa vêm de reference/program-addresses via o SDK.

Configuração

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

Cada demo nesta página espelha um arquivo em raydium-sdk-V2-demo/src/clmm; o link do GitHub fica ao lado de cada seção. O bootstrap segue o config.ts.template do repositório de demo (fonte) — disableFeatureCheck: true é a configuração recomendada para qualquer integração não trivial:

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 quer
// ClmmConfigInfo, que precisa de um id PublicKey mais fundOwner/description — converter:
const clmmConfigs = await raydium.api.getClmmConfigs();
const picked = clmmConfigs.find((c) => c.index === 1)!;        // tier 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 tem 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 por ordem de 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
// nota: getPoolInfoFromRpc do CLMM retorna `rpcPoolInfo`, não `rpcData` (CPMM retorna)
const { poolInfo, poolKeys, rpcPoolInfo } = await raydium.clmm.getPoolInfoFromRpc(POOL_ID);

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

// Encaixe em ticks válidos para o tick_spacing deste pool.
// A classe é TickUtil (singular), e leva decimals + tickSpacing, 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 é async — aguarde.
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 arrays de tick o intervalo toca e os passa como contas. Não precisa agrupar nenhuma instrução init — não há instrução init-tick-array; OpenPosition* aloca um array de tick ausente por si só, à custa do pagador.

Aumentar liquidez em uma posição existente

Fonte: src/clmm/increaseLiquidity.ts

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

// Não há getPositionInfo — enumere 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,              // sem membro poolKeys nesta chamada
});

await execute({ sendAndConfirm: true });

Diminuir 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
    useSOLBalance: true,
    closePosition: false,
  },
  liquidity: positionAccount.liquidity.divn(2),   // reduzir pela metade
  amountMinA: new BN(0),
  amountMinB: new BN(0),
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

Para coletar apenas 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 — esta é a única forma de coletar qualquer um deles. Para fechar a posição inteiramente após zerar liquidez e taxas, passe ownerInfo: { closePosition: true } na chamada final de decreaseLiquidity. O SDK anexa ClosePosition e queima o NFT.

Posições de emissor restrito requerem um construtor de fechamento compatível. Essas posições têm uma conta de token NFT congelada. ClosePosition deve anexar o ID do pool da posição como a primeira conta restante para que CLMM possa descongelar a conta antes de queimá-la. O branch de fonte do programa não inclui uma mudança de SDK. Confirme que sua versão do SDK suporta explicitamente o caminho de fechamento congelado antes de ativar a criação de posição de emissor restrito.

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

// Programa CLMM: veja reference/program-addresses; fonte ecb1577;
// Solana mainnet-beta; última verificação 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 cada fechamento. CLMM o lê apenas quando positionNftAccount está congelada, o que mantém um caminho de 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 construtor MULTI-transação: `sequentially` é obrigatório
// e o resultado é `txIds`, não `txId`.
const { txIds } = await execute({ sequentially: true });

harvestAllRewards percorre cada posição em cada pool passado, agrupa as chamadas DecreaseLiquidity de liquidez zero que liquidam taxas e recompensas (mais qualquer UpdateRewardInfos), e as divide entre transações se necessário.

Swap

Fonte: src/clmm/swap.ts

Isto espelha `src/clmm/swap.ts`, que simula com `swapInternal` em vez de
`PoolUtils.computeAmountOutFormat`.

```ts
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 para saída exata
  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 },   // obrigatório
  remainingAccounts: simulation.accounts,
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

A simulação percorre o mapa de tick off-chain com a mesma lógica do programa on-chain e retorna a quantidade de saída (amountCalculated) mais a lista exata de contas que o swap tocará (accounts). Sempre passe o remainingAccounts que a simulação retorna: muito poucos e o swap reverte no meio da caminhada com NotEnoughTickArrayAccount; os obsoletos apenas desperdiçam computação.

PoolUtils.computeAmountOutFormat ainda existe, mas precisa de um ComputeClmmPoolInfo (o computePoolInfo de getPoolInfoFromRpc, não um objeto de pool de API) mais dois argumentos obrigatórios — tickarrayBitmapExtension e blockTimestamp — e não há método raydium.clmm.fetchTickArrays (fetchTickArrays é uma função livre; os helpers de nível de 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 os toggles de taxa dinâmica e taxa unilateral no momento da criação do pool. Leva a forma de createPool mais duas adições:

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 um tier de calibração

const { execute, extInfo } = await raydium.clmm.createCustomizablePool({
  programId: CLMM_PROGRAM_ID,
  mint1:     mintA,
  mint2:     mintB,
  ammConfig,
  initialPrice,
  // As duas adições:
  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 há flag enableDynamicFee e nenhum parâmetro dynamicFeeConfigId, e nenhum startTime. Fornecer dynamicFeeConfig é o que ativa taxas dinâmicas — omita e você obtém um pool de taxa estática, silenciosamente e sem erro. Note também que os membros do enum do SDK são TokenOnlyA / TokenOnlyB, enquanto o enum Rust on-chain os soletra Token0Only / Token1Only; os valores numéricos correspondem (FromInput = 0).

createPool continua funcionando para o caminho padrão de taxa, sem taxa dinâmica. Use createCustomizablePool sempre que precisar de qualquer um dos controles. Veja products/clmm/instructions para a lista de contas on-chain.

Ordens limitadas

Uma ordem limitada estaciona entrada do usuário em um único tick e é preenchida FIFO quando um swap cruza esse tick. As saídas são enviadas para o ATA do proprietário no momento da liquidação; o proprietário não precisa estar online para ser preenchido.

Abrir uma ordem limitada

Não há conta de configuração de ordem limitada por pool e nenhum helper `getClmmLimitOrderConfigs()` — as ordens são chaveadas por tick.

```ts
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 — 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("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, 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 o PDA LimitOrderState de (owner, nonce PDA, order nonce), incrementa o LimitOrderNonce por carteira, e insere a ordem na coorte FIFO naquele tick.

Aumentar / diminuir 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 adiciona isso sobre Increase
  txVersion: TxVersion.V0,
}).then((b) => b.execute({ sendAndConfirm: true }));

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

Liquidar uma ordem preenchida

// settleLimitOrder leva APENAS o 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 contra o rastreador de coorte, calcula a saída preenchida e a transfere para o ATA do proprietário. O proprietário pode chamar isso por si mesmo; limit_order_admin (um mantenedor operacional off-chain) também pode chamar em nome do proprietário — a saída ainda vai para o proprietário. Para fechar ordens totalmente liquidadas para recuperar aluguel, use closeLimitOrder (única) ou closeAllLimitOrder (lote). Para liquidar muitas de uma vez, settleAllLimitOrder empacota quantas chamadas SettleLimitOrder couberem em uma tx v0.

Listar ordens estacionadas de uma carteira (off-chain)

// Helper de API. Veja api-reference/temp-api-v1.
const active = await fetch(
  `https://temp-api-v1.raydium.io/limit-order/order/list?wallet=<sua-chave-pública-da-carteira>`,
).then((r) => r.json());

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

Esqueleto Rust CPI

// Cargo.toml — o branch importa: `master` ainda fixa anchor-lang 0.32.1.
// anchor-lang  = "=1.0.2"   // deve corresponder ao que raydium-clmm fixa
// anchor-spl   = "=1.0.2"
// raydium-clmm = { git = "https://github.com/raydium-io/raydium-clmm",
//                  branch = "chore/upgrade-anchor", features = ["cpi"] }
//
// Mesma linha Anchor que a amostra CPMM em products/cpmm/code-demos, para que ambos
// crates CPI possam ser dependências de um 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 tick_array e 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(),
    };
    // Anchor 1.0 leva a Pubkey do programa aqui, não sua AccountInfo. No
    // branch `master` 0.32 isto 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 de conta restante para SwapV2:

[tick_array_bitmap_extension?, tick_array_0, tick_array_1, …]

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

Armadilhas comuns

Endpoints de tick fora do espaçamento → TickAndSpacingNotMatch. Sempre encaixe via TickUtil.getPriceAndTick (singular TickUtil).
Não há arrays de tick suficientes fornecidos em SwapV2 → NotEnoughTickArrayAccount. Pegue a lista de swapInternal(...).accounts.
Posição de intervalo completo sem a extensão de bitmap → o PDA de extensão deve ser gravável; o SDK lida com isso automaticamente.
Confundir sqrt_price_x64 com price → uma confusão de fator-2 aqui é particularmente dolorosa. Em caso de dúvida, deixe o SDK calculá-lo a partir de um preço legível por humanos.
Coletar recompensas muito cedo → cada coleta é um DecreaseLiquidity de liquidez zero e custa uma transação. Agrupe via harvestAllRewards em muitas posições, e lembre-se que seu execute precisa de { sequentially: true }.
Fechar contas NFT você mesmo → ClosePosition queima o NFT e fecha seu ATA. Também fecha um mint de NFT Token-2022; um mint de Token SPL clássico permanece com suprimento zero porque esse programa não pode fechar mints. Não feche contas suportadas separadamente ou a instrução reverterá.
Abrir uma ordem limitada em um tick não espaçado → TickAndSpacingNotMatch. Sempre quantize via o helper getOrderTick exportado.
Chamar decreaseLimitOrder em uma ordem totalmente preenchida → InvalidOrderPhase. Use settleLimitOrder depois closeLimitOrder.
Esperando uma flag enableDynamicFee → não há nenhuma. Omitir dynamicFeeConfig simplesmente cria um pool de taxa estática, silenciosamente e sem erro. Se você queria taxas dinâmicas, passe a PublicKey da conta de configuração, escolhida de /main/clmm-dynamic-config.

Para onde ir a seguir

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

Fontes:

Products

Algorithms

Demonstrações de código CLMM

Configuração

Criar um pool CLMM

Abrir uma posição em um intervalo escolhido

Aumentar liquidez em uma posição existente

Diminuir liquidez (e coletar taxas ao mesmo tempo)

Coletar recompensa(s)

Swap

Criar um pool CLMM personalizável

Ordens limitadas

Abrir uma ordem limitada

Aumentar / diminuir uma ordem aberta

Liquidar uma ordem preenchida

Listar ordens estacionadas de uma carteira (off-chain)

Esqueleto Rust CPI

Armadilhas comuns

Para onde ir a seguir

​Configuração

​Criar um pool CLMM

​Abrir uma posição em um intervalo escolhido

​Aumentar liquidez em uma posição existente

​Diminuir liquidez (e coletar taxas ao mesmo tempo)

​Coletar recompensa(s)

​Swap

​Criar um pool CLMM personalizável

​Ordens limitadas

​Abrir uma ordem limitada

​Aumentar / diminuir uma ordem aberta

​Liquidar uma ordem preenchida

​Listar ordens estacionadas de uma carteira (off-chain)

​Esqueleto Rust CPI

​Armadilhas comuns

​Para onde ir a seguir

Configuração

Criar um pool CLMM

Abrir uma posição em um intervalo escolhido

Aumentar liquidez em uma posição existente

Diminuir liquidez (e coletar taxas ao mesmo tempo)

Coletar recompensa(s)

Swap

Criar um pool CLMM personalizável

Ordens limitadas

Abrir uma ordem limitada

Aumentar / diminuir uma ordem aberta

Liquidar uma ordem preenchida

Listar ordens estacionadas de uma carteira (off-chain)

Esqueleto Rust CPI

Armadilhas comuns

Para onde ir a seguir