Demos de código CLMM - Raydium Docs

Esta página fue traducida automáticamente por IA. La versión en inglés es la fuente autorizada.Ver versión en inglés →

Nota de versión. Todos los demos apuntan a @raydium-io/raydium-sdk-v2@0.2.42-alpha contra Solana mainnet-beta, verificado en 2026-04. Los IDs de programa provienen de reference/program-addresses a través del SDK.

Configuración

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

Cada demo de esta página refleja un archivo en raydium-sdk-V2-demo/src/clmm; el enlace a GitHub aparece junto a cada sección. La inicialización sigue el config.ts.template del repositorio de demos (fuente) — disableFeatureCheck: true es la configuración recomendada para cualquier integración no 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;

Crear un pool CLMM

Fuente: 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);

El SDK:

Ordena mint1/mint2 por orden de bytes antes de la derivación.
Calcula sqrt_price_x64 = floor(sqrt(initialPrice × 10^(dB−dA)) × 2^64).
Crea las cuentas observation y tick_array_bitmap_extension.
Paga la comisión de creación del pool definida por ammConfig.

Abrir una posición en un rango elegido

Fuente: 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);

El SDK calcula automáticamente qué arrays de ticks toca el rango e incluye instrucciones InitTickArray si alguno no está inicializado.

Aumentar la liquidez en una posición existente

Fuente: 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 });

Reducir liquidez (y cobrar comisiones al mismo tiempo)

Fuente: src/clmm/decreaseLiquidity.ts y 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 cobrar solo las comisiones, llama a decreaseLiquidity con liquidity = new BN(0). El efecto secundario de la instrucción es liquidar tokens_fees_owed_{0,1} y transferirlos al destino correspondiente. Para cerrar la posición por completo después de vaciar la liquidez y las comisiones, pasa closePosition: true en la última llamada a decreaseLiquidity. El SDK agrega ClosePosition y quema el NFT.

Cobrar recompensa(s)

Fuente: 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 recorre cada posición de cada pool que se le pasa, agrupa las instrucciones CollectReward (y los UpdateRewardInfos necesarios), y las distribuye en varias transacciones si es necesario.

Swap

Fuente: 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 recorre el mapa de ticks fuera de la cadena usando la misma lógica que el programa on-chain y devuelve:

la cantidad esperada de salida,
la cantidad mínima de salida tras el slippage,
la lista de cuentas de arrays de ticks que tocará el swap real (remainingAccounts).

Pasa siempre el remainingAccounts que devuelve la simulación: si pasas muy pocos, el swap revierte a mitad de la ejecución con TickArrayNotFound; si pasas cuentas desactualizadas, malgastas cómputo.

Crear un pool CLMM personalizable

createCustomizablePool es el nuevo punto de entrada que expone los controles de comisión dinámica y comisión unilateral en el momento de creación del pool. Acepta la misma estructura que createPool más tres campos adicionales:

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 sigue funcionando para el camino de comisión por defecto, sin órdenes limitadas ni comisión dinámica. Usa createCustomizablePool cuando necesites cualquiera de los tres nuevos controles. Consulta products/clmm/instructions para ver la lista de cuentas on-chain.

Órdenes limitadas

Una orden limitada estaciona el input del usuario en un único tick y se ejecuta en orden FIFO cuando un swap cruza ese tick. Los resultados se envían al ATA del propietario en el momento de la liquidación; el propietario no necesita estar en línea para que se ejecute la orden.

Abrir una orden 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);

El SDK deriva el PDA LimitOrderState a partir de (pool, owner, tick, nonce), incrementa el LimitOrderNonce por (pool, owner) y agrega la orden a la cola FIFO en ese tick.

Aumentar / reducir una orden abierta

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 solo puede retirar de la parte no ejecutada de la orden; la parte ya ejecutada queda bloqueada hasta la liquidación. Ambas instrucciones revierten con InvalidOrderPhase si la orden ya se ha llenado por completo.

Liquidar una orden ejecutada

await raydium.clmm.settleLimitOrder({
  poolInfo,
  poolKeys,
  limitOrderId: <LIMIT_ORDER_PUBKEY>,
  txVersion: TxVersion.V0,
}).then((b) => b.execute({ sendAndConfirm: true }));

settleLimitOrder lee el unfilled_ratio_x64 de la orden frente al rastreador de la cola, calcula el output ejecutado y lo transfiere al ATA del propietario. El propietario puede llamarlo él mismo; limit_order_admin (un keeper operacional fuera de la cadena) también puede llamarlo en nombre del propietario — el output siempre va al propietario. Para cerrar órdenes completamente liquidadas y recuperar el rent, usa closeLimitOrder (individual) o closeAllLimitOrder (por lotes). Para liquidar varias a la vez, settleAllLimitOrder empaqueta tantas llamadas SettleLimitOrder como quepan en una transacción v0.

Consultar las órdenes activas de una wallet (fuera de la cadena)

// 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());

El endpoint de órdenes activas devuelve en un solo payload tanto las órdenes no ejecutadas como las parcialmente ejecutadas (totalAmount / filledAmount / pendingSettle distinguen las fases). Para el historial de órdenes cerradas usa /limit-order/history/order/list-by-user?wallet=… (por wallet, paginado con nextPageId); para el registro completo de eventos de una orden concreta usa /limit-order/history/event/list-by-pda?pda=….

Esqueleto CPI en Rust

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)
}

Orden de las cuentas restantes para SwapV2:

[tick_array_bitmap_extension?, tick_array_0, tick_array_1, …]

Si el swap nunca necesita la extensión, omítela; de lo contrario es la primera cuenta restante.

Errores frecuentes

Ticks de extremo con espaciado incorrecto → InvalidTickIndex. Usa siempre TickUtils.getPriceAndTick para ajustar al tick válido.
Arrays de ticks insuficientes en SwapV2 → TickArrayNotFound. Usa computeAmountOutFormat para obtener la lista completa.
Posición de rango completo sin la extensión del bitmap → el PDA de extensión debe ser escribible; el SDK lo gestiona automáticamente.
Confundir sqrt_price_x64 con price → el error de factor 2 que esto provoca es especialmente difícil de depurar. Si tienes dudas, deja que el SDK lo calcule a partir de un precio legible.
Cobrar recompensas con demasiada frecuencia → cada cobro consume una transacción. Usa harvestAllRewards para agrupar varias posiciones en un solo lote.
Quemar el NFT mientras el mint todavía tiene rent pendiente → ClosePosition también cierra el mint del NFT y el ATA; no los cierres por separado o el programa revertirá.
Abrir una orden limitada en un tick sin el espaciado correcto → InvalidTickIndex. Cuantiza siempre con TickUtils.getPriceAndTick.
Llamar a decreaseLimitOrder sobre una orden completamente ejecutada → InvalidOrderPhase. Usa settleLimitOrder y luego closeLimitOrder.
Olvidar dynamicFeeConfigId al pasar enableDynamicFee: true → CreateCustomizablePool revertirá con InvalidDynamicFeeConfigParams. Desactiva la comisión dinámica o elige una configuración desde /main/clmm-dynamic-config.

Próximos pasos

sdk-api/typescript-sdk — superficie completa del SDK.
sdk-api/rest-api — endpoints de cotización y metadatos de pools.
user-flows/create-clmm-pool — guía sin código.
integration-guides/aggregator — enrutamiento de CLMM como parte de una ruta.

Fuentes:

​Configuración

​Crear un pool CLMM

​Abrir una posición en un rango elegido

​Aumentar la liquidez en una posición existente

​Reducir liquidez (y cobrar comisiones al mismo tiempo)

​Cobrar recompensa(s)

​Swap

​Crear un pool CLMM personalizable

​Órdenes limitadas

​Abrir una orden limitada

​Aumentar / reducir una orden abierta

​Liquidar una orden ejecutada

​Consultar las órdenes activas de una wallet (fuera de la cadena)

​Esqueleto CPI en Rust

​Errores frecuentes

​Próximos pasos

Configuración

Crear un pool CLMM

Abrir una posición en un rango elegido

Aumentar la liquidez en una posición existente

Reducir liquidez (y cobrar comisiones al mismo tiempo)

Cobrar recompensa(s)

Swap

Crear un pool CLMM personalizable

Órdenes limitadas

Abrir una orden limitada

Aumentar / reducir una orden abierta

Liquidar una orden ejecutada

Consultar las órdenes activas de una wallet (fuera de la cadena)

Esqueleto CPI en Rust

Errores frecuentes

Próximos pasos