Demostraciones de código CLMM

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 →

Configuración

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

Cada demostración en esta página refleja un archivo en raydium-sdk-V2-demo/src/clmm; el enlace de GitHub aparece junto a cada sección. El arranque sigue el config.ts.template del repositorio de demostración (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);

// Elige un rango de precios. Aquí: ±10% del actual.
const currentPrice = new Decimal(poolInfo.price);
const lowerPrice   = currentPrice.mul(0.9);
const upperPrice   = currentPrice.mul(1.1);

// Ajusta a ticks válidos para el tick_spacing de este pool.
const { tick: tickLower } = TickUtils.getPriceAndTick({
  poolInfo, price: lowerPrice, baseIn: true,
});
const { tick: tickUpper } = TickUtils.getPriceAndTick({
  poolInfo, price: upperPrice, baseIn: true,
});

// Cuánto de cada token depositar.
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 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 });

Disminuir 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 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. Para cerrar completamente la posición después de poner la liquidez y las comisiones en cero, pasa closePosition: true en la última llamada a decreaseLiquidity. El SDK añade ClosePosition y quema el NFT.

Las posiciones de emisor restringido requieren un constructor de cierre compatible. Estas posiciones tienen una cuenta de token NFT congelada. ClosePosition debe añadir el ID del pool de la posición como la primera cuenta restante para que CLMM pueda descongelar la cuenta antes de quemar el NFT. La rama del código del programa no incluye un cambio en el SDK. Confirma que tu versión del SDK soporta explícitamente la ruta de cierre congelado antes de habilitar la creación de posiciones de emisor restringido.

Para un cliente Anchor directo, mantén las cuentas declaradas sin cambios y añade el pool:

// Programa CLMM: ver reference/program-addresses; fuente ecb1577;
// Solana mainnet-beta; última verificación 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();

Puedes pasar poolId en cada cierre. CLMM lo lee solo cuando positionNftAccount está congelada, lo que mantiene una ruta de cliente compatible con posiciones antiguas y nuevas.

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 en cada pool pasado, agrupa instrucciones CollectReward (y cualquier UpdateRewardInfos), y las divide entre 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 en cadena y devuelve:

la cantidad esperada,
la cantidad mínima después del slippage,
la lista de cuentas de array de ticks que el swap real tocará (remainingAccounts).

Siempre pasa remainingAccounts devuelto por la simulación: si pasas muy pocos, el swap se revierte a mitad del recorrido con TickArrayNotFound; si pasas unos obsoletos, se desperdicia cómputo.

Crear un pool CLMM personalizable

createCustomizablePool es el nuevo punto de entrada que expone los toggles de comisión dinámica y comisión unilateral en el momento de la creación del pool. Tiene la misma forma que createPool más tres adiciones:

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); // elige un nivel de calibración

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

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

createPool continúa funcionando para la ruta de comisión predeterminada, sin órdenes limitadas y sin comisión dinámica. Usa createCustomizablePool siempre que necesites cualquiera de los tres nuevos controles. Ver products/clmm/instructions para la lista de cuentas en cadena.

Órdenes limitadas

Una orden limitada estaciona la entrada del usuario en un único tick y se completa 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 ser completado.

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

// El precio límite DEBE ser cuantizado a tick_spacing.
const targetPrice = new Decimal(180);                              // vender SOL a 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,         // vendiendo 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 de (pool, owner, tick, nonce), incrementa el LimitOrderNonce por-(pool, owner), e inserta la orden en la cohorte FIFO en ese tick.

Aumentar / disminuir 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 eliminar de la porción no completada de la orden; la porción completada está bloqueada hasta la liquidación. Ambas instrucciones se revierten con InvalidOrderPhase si la orden ya ha sido completada totalmente.

Liquidar una orden completada

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 contra el rastreador de cohorte, calcula la salida completada y la transfiere al ATA del propietario. El propietario puede llamar a esto él mismo; limit_order_admin (un guardián operacional fuera de la cadena) también puede llamarlo en nombre del propietario — la salida aún va al propietario. Para cerrar órdenes completadas totalmente y recuperar alquiler, usa closeLimitOrder (individual) o closeAllLimitOrder (lote). Para liquidar muchas a la vez, settleAllLimitOrder empaqueta tantas llamadas SettleLimitOrder como quepan en una tx v0.

Listar órdenes estacionadas de una billetera (fuera de la cadena)

// Ayudante de API. Ver 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 órdenes no completadas y parcialmente completadas en un solo payload (totalAmount / filledAmount / pendingSettle distinguen las fases). Para el historial de órdenes cerradas usa /limit-order/history/order/list-by-user?wallet=… (por billetera, paginado por nextPageId); para el registro de eventos completo de una orden específica usa /limit-order/history/event/list-by-pda?pda=….

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

Orden de 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 comunes

Endpoints de tick fuera de espaciado → InvalidTickIndex. Siempre ajusta mediante TickUtils.getPriceAndTick.
No hay suficientes arrays de ticks suministrados en SwapV2 → TickArrayNotFound. Usa computeAmountOutFormat para obtener la lista completa.
Posición de rango completo sin la extensión de bitmap → el PDA de extensión debe ser escribible; el SDK lo maneja automáticamente.
Confundir sqrt_price_x64 con price → una confusión de factor-2 aquí es particularmente dolorosa. Cuando tengas dudas, deja que el SDK lo calcule a partir de un precio legible por humanos.
Cobrar recompensas demasiado ávidamente → cada cobro cuesta una transacción. Agrupa mediante harvestAllRewards en muchas posiciones.
Cerrar cuentas NFT tú mismo → ClosePosition quema el NFT y cierra su ATA. También cierra un mint NFT de Token-2022; un mint SPL Token clásico permanece en suministro cero porque ese programa no puede cerrar mints. No cierres cuentas soportadas por separado o la instrucción se revertirá.
Abrir una orden limitada en un tick no espaciado → InvalidTickIndex. Siempre cuantiza mediante TickUtils.getPriceAndTick.
Llamar a decreaseLimitOrder en una orden completada totalmente → InvalidOrderPhase. Usa settleLimitOrder luego closeLimitOrder en su lugar.
Olvidar dynamicFeeConfigId mientras pasas enableDynamicFee: true → la reversión de CreateCustomizablePool es InvalidDynamicFeeConfigParams. O desactiva la comisión dinámica, o elige una configuración de /main/clmm-dynamic-config.

Dónde ir a continuación

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

Fuentes:

Productos

Algoritmos

Demostraciones de código CLMM

Configuración

Crear un pool CLMM

Abrir una posición en un rango elegido

Aumentar liquidez en una posición existente

Disminuir liquidez (y cobrar comisiones al mismo tiempo)

Cobrar recompensa(s)

Swap

Crear un pool CLMM personalizable

Órdenes limitadas

Abrir una orden limitada

Aumentar / disminuir una orden abierta

Liquidar una orden completada

Listar órdenes estacionadas de una billetera (fuera de la cadena)

Esqueleto de Rust CPI

Errores comunes

Dónde ir a continuación

​Configuración

​Crear un pool CLMM

​Abrir una posición en un rango elegido

​Aumentar liquidez en una posición existente

​Disminuir liquidez (y cobrar comisiones al mismo tiempo)

​Cobrar recompensa(s)

​Swap

​Crear un pool CLMM personalizable

​Órdenes limitadas

​Abrir una orden limitada

​Aumentar / disminuir una orden abierta

​Liquidar una orden completada

​Listar órdenes estacionadas de una billetera (fuera de la cadena)

​Esqueleto de Rust CPI

​Errores comunes

​Dónde ir a continuación

Configuración

Crear un pool CLMM

Abrir una posición en un rango elegido

Aumentar liquidez en una posición existente

Disminuir liquidez (y cobrar comisiones al mismo tiempo)

Cobrar recompensa(s)

Swap

Crear un pool CLMM personalizable

Órdenes limitadas

Abrir una orden limitada

Aumentar / disminuir una orden abierta

Liquidar una orden completada

Listar órdenes estacionadas de una billetera (fuera de la cadena)

Esqueleto de Rust CPI

Errores comunes

Dónde ir a continuación