Exemplos 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 exemplos visam @raydium-io/raydium-sdk-v2@0.2.42-alpha contra Solana mainnet-beta, verificado em 2026-04. 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 exemplo 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 exemplos (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

const ammConfigs = await raydium.api.getClmmConfigs();
const ammConfig  = ammConfigs.find((c) => c.index === 1)!;        // 0.05% tier

const initialPrice = new Decimal(160);        // 160 USDC per SOL
const { execute, extInfo } = await raydium.clmm.createPool({
  programId: CLMM_PROGRAM_ID,
  mint1:     mintA,
  mint2:     mintB,
  ammConfig,
  initialPrice,
  startTime: new BN(0),
  txVersion: TxVersion.V0,
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Pool:", extInfo.address.id.toBase58(), "tx:", txId);

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, TickUtils } from "@raydium-io/raydium-sdk-v2";

const poolId = new PublicKey("<POOL_ID>");
const { poolInfo, poolKeys, rpcData } = await raydium.clmm.getPoolInfoFromRpc(poolId);

// Choose a price range. Here: ±10% of current.
const currentPrice = new Decimal(poolInfo.price);
const lowerPrice   = currentPrice.mul(0.9);
const upperPrice   = currentPrice.mul(1.1);

// Snap to valid ticks for this pool's tick_spacing.
const { tick: tickLower } = TickUtils.getPriceAndTick({
  poolInfo, price: lowerPrice, baseIn: true,
});
const { tick: tickUpper } = TickUtils.getPriceAndTick({
  poolInfo, price: upperPrice, baseIn: true,
});

// How much of each token to deposit.
const inputAmount = new BN(10_000_000);  // 0.01 SOL
const inputMint   = poolInfo.mintA.address;

const res = 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("Position opened, tx:", txId);

O SDK calcula automaticamente quais arrays de tick o intervalo toca e agrupa instruções InitTickArray se algum não estiver inicializado.

Aumentar liquidez em uma posição existente

Fonte: src/clmm/increaseLiquidity.ts

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

const positionAccount = await raydium.clmm.getPositionInfo({
  nftMint: positionNftMint,
});

const { execute } = await raydium.clmm.increasePositionFromBase({
  poolInfo,
  poolKeys,
  ownerPosition: positionAccount,
  base: "MintA",
  baseAmount: new BN(5_000_000),
  otherAmountMax: new BN(1_000_000_000),
  txVersion: TxVersion.V0,
});

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

await execute({ sendAndConfirm: true });

Para coletar apenas taxas, chame decreaseLiquidity com liquidity = new BN(0). O efeito colateral da instrução é liquidar tokens_fees_owed_{0,1} e transferi-los. Para fechar a posição inteiramente após zerar liquidez e taxas, passe 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 o CLMM possa descongelar a conta antes de queimar. O branch de fonte do programa não inclui uma mudança no 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:

// CLMM program: see reference/program-addresses; source ecb1577;
// Solana mainnet-beta; last verified 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. O CLMM o lê apenas quando positionNftAccount está congelado, o que mantém um caminho de cliente compatível com posições antigas e novas.

Coletar recompensa(s)

Fonte: src/clmm/harvestAllRewards.ts

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

await execute({ sendAndConfirm: true });

harvestAllRewards percorre cada posição em cada pool passado, agrupa instruções CollectReward (e qualquer UpdateRewardInfos), e as divide entre transações se necessário.

Swap

Fonte: src/clmm/swap.ts

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

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

const { minAmountOut, remainingAccounts, priceImpact } =
  PoolUtils.computeAmountOutFormat({
    poolInfo,
    tickArrayCache: await raydium.clmm.fetchTickArrays({ poolInfo }),
    amountIn,
    tokenOut: poolInfo.mintB,
    slippage,
    epochInfo: await raydium.fetchEpochInfo(),
  });

const { execute } = await raydium.clmm.swap({
  poolInfo,
  poolKeys,
  inputMint: new PublicKey(poolInfo.mintA.address),
  amountIn,
  amountOutMin: minAmountOut.amount,
  observationId: poolKeys.observationId,
  remainingAccounts,
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

computeAmountOutFormat percorre o mapa de ticks off-chain usando a mesma lógica do programa on-chain e retorna:

o valor esperado de saída,
o valor mínimo de saída após slippage,
a lista de contas de array de tick que o swap real tocará (remainingAccounts).

Sempre passe remainingAccounts retornado pela simulação: se você passar muito poucos, o swap reverte no meio da caminhada com TickArrayNotFound; se você passar desatualizados, computação desperdiçada.

Criar um pool CLMM personalizável

createCustomizablePool é o novo ponto de entrada que expõe os toggles de taxa dinâmica e taxa unilateral no momento da criação do pool. Tem a mesma forma que createPool mais três 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); // pick a calibration tier

const { execute, extInfo } = await raydium.clmm.createCustomizablePool({
  programId: CLMM_PROGRAM_ID,
  mint1:     mintA,
  mint2:     mintB,
  ammConfig,
  initialPrice,
  startTime: new BN(0),
  // New fields:
  collectFeeOn:        CollectFeeOn.Token1Only,   // 0 = FromInput, 1 = Token0Only, 2 = Token1Only
  enableDynamicFee:    true,
  dynamicFeeConfigId:  dynamicFeeConfig?.id,      // omit when enableDynamicFee is false
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });
console.log("Customizable pool:", extInfo.address.id.toBase58());

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

Ordens limitadas

Uma ordem limitada estaciona a entrada do usuário em um único tick e é preenchida FIFO quando um swap cruza esse tick. Os resultados são enviados 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

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

const limitConfigs = await raydium.api.getClmmLimitOrderConfigs(); // GET /main/clmm-limit-order-config
const limitConfig  = limitConfigs.find((c) => c.poolId === poolInfo.id);

// Limit price MUST be quantized to tick_spacing.
const targetPrice = new Decimal(180);                              // sell SOL at 180 USDC
const { tick: limitTick } = TickUtils.getPriceAndTick({
  poolInfo, price: targetPrice, baseIn: true,
});

const { execute } = await raydium.clmm.openLimitOrder({
  poolInfo,
  poolKeys,
  limitOrderConfig: limitConfig,
  inputMint: poolInfo.mintA.address,         // selling SOL
  inputAmount: new BN(50_000_000),           // 0.05 SOL
  tick: limitTick,
  txVersion: TxVersion.V0,
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Limit order opened, tx:", txId);

O SDK deriva o PDA LimitOrderState de (pool, owner, tick, nonce), incrementa o LimitOrderNonce por-(pool, owner), e insere a ordem na coorte FIFO naquele tick.

Aumentar / diminuir uma ordem aberta

await raydium.clmm.increaseLimitOrder({
  poolInfo,
  poolKeys,
  limitOrderId: <LIMIT_ORDER_PUBKEY>,
  addAmount: new BN(20_000_000),
  txVersion: TxVersion.V0,
}).then((b) => b.execute({ sendAndConfirm: true }));

await raydium.clmm.decreaseLimitOrder({
  poolInfo,
  poolKeys,
  limitOrderId: <LIMIT_ORDER_PUBKEY>,
  removeAmount: new BN(10_000_000),
  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 revertam com InvalidOrderPhase se a ordem já foi totalmente preenchida.

Liquidar uma ordem preenchida

await raydium.clmm.settleLimitOrder({
  poolInfo,
  poolKeys,
  limitOrderId: <LIMIT_ORDER_PUBKEY>,
  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)

// API helper. See 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 ordens não preenchidas e parcialmente preenchidas em um único payload (totalAmount / filledAmount / pendingSettle distinguem as fases). Para histórico de ordens fechadas 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

use anchor_lang::prelude::*;
use raydium_amm_v3::cpi;
use raydium_amm_v3::program::AmmV3;
use raydium_amm_v3::cpi::accounts::SwapV2;

#[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, AmmV3>,
    // `remaining_accounts` carries the tick_array and bitmap_extension accounts.
}

pub fn proxy_swap(
    ctx: Context<ProxyClmmSwap>,
    amount: u64,
    other_amount_threshold: u64,
    sqrt_price_limit_x64: u128,
    is_base_input: bool,
) -> Result<()> {
    let cpi_accounts = SwapV2 {
        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(),
    };
    let cpi_ctx = CpiContext::new(ctx.accounts.clmm_program.to_account_info(), 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, é a primeira conta restante.

Armadilhas comuns

Endpoints de tick fora do espaçamento → InvalidTickIndex. Sempre ajuste via TickUtils.getPriceAndTick.
Não há arrays de tick suficientes fornecidos em SwapV2 → TickArrayNotFound. Use computeAmountOutFormat para obter a lista completa.
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 custa uma transação. Agrupe via harvestAllRewards em muitas posições.
Fechar contas NFT você mesmo → ClosePosition queima o NFT e fecha seu ATA. Também fecha um mint NFT Token-2022; um mint SPL Token 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 → InvalidTickIndex. Sempre quantize via TickUtils.getPriceAndTick.
Chamar decreaseLimitOrder em uma ordem totalmente preenchida → InvalidOrderPhase. Use settleLimitOrder depois closeLimitOrder.
Esquecendo dynamicFeeConfigId enquanto passa enableDynamicFee: true → a reversão de CreateCustomizablePool é InvalidDynamicFeeConfigParams. Desative a taxa dinâmica ou escolha uma configuração de /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 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

Exemplos 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

Próximos passos

​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

​Próximos passos

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

Próximos passos