Ejemplos de código de CLMM

Ejemplos completos en TypeScript: crear un pool de CLMM, abrir una posición en un rango de precios elegido, ajustar la liquidez, hacer swaps y recolectar comisiones y recompensas.

Aviso de versión. Todas las demos en TypeScript usan @raydium-io/raydium-sdk-v2@0.2.64-alpha. Se ejecutaron por última vez con 0.2.42-alpha (2026-04) y sus firmas de llamada se revisaron de nuevo frente al código fuente de 0.2.64-alpha el 2026-09-09, en Solana mainnet-beta. El esqueleto de CPI en Rust que aparece al final apunta a raydium-clmm en master, con Anchor 1.0.2, la misma versión fijada que en la página de CPMM, de modo que ambas pueden convivir en un mismo crate. Los IDs de programa se obtienen del SDK a partir de reference/program-addresses.

​

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 replica un archivo de 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). Para cualquier integración no trivial, se recomienda 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;

​

Crear un pool de 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

// getClmmConfigs() devuelve ApiClmmConfigInfo (id es una cadena). createPool espera
// ClmmConfigInfo, que necesita un id de tipo PublicKey además de fundOwner/description; hay que convertirlo:
const clmmConfigs = await raydium.api.getClmmConfigs();
const picked = clmmConfigs.find((c) => c.index === 1)!;        // nivel 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,   // sin `startTime`: CreateConcentratedPool no tiene ese campo
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Pool:", extInfo.address.id, "tx:", txId);   // ya es una cadena base58

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 en ammConfig.

​

Abrir una posición en un rango elegido

Fuente: src/clmm/createPosition.ts

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

const POOL_ID = "<POOL_ID>";   // cadena base58
// nota: getPoolInfoFromRpc de CLMM devuelve `rpcPoolInfo`, no `rpcData` (como sí hace CPMM)
const { poolInfo, poolKeys, rpcPoolInfo } = await raydium.clmm.getPoolInfoFromRpc(POOL_ID);

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

// Ajusta los precios a ticks válidos para el tick_spacing de este pool.
// La clase es TickUtil (en singular) y recibe decimales y tickSpacing, no 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,
});

// Cantidad de cada token que se va a depositar.
const inputAmount = new BN(10_000_000);  // 0,01 SOL

// getLiquidityAmountOutFromAmountIn es asíncrona: hay que usar 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("Posición abierta, tx:", txId);

El SDK calcula qué tick arrays toca el rango y los pasa como cuentas. No necesita incluir ninguna instrucción de inicialización: no existe una instrucción de inicialización de tick arrays, ya que OpenPosition* crea por sí mismo el tick array que falte, con cargo al pagador.

​

Aumentar la liquidez de una posición existente

Fuente: src/clmm/increaseLiquidity.ts

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

// No existe getPositionInfo: enumera las posiciones de la cartera y elige una.
const allPositions = await raydium.clmm.getOwnerPositionInfo({
  programId: poolInfo.programId,
});
const positionAccount = allPositions.find((p) => p.nftMint.equals(positionNftMint));
if (!positionAccount) throw new Error("no se encontró la posición para esta cartera");

const { execute } = await raydium.clmm.increasePositionFromBase({
  poolInfo,
  ownerPosition: positionAccount,
  ownerInfo: { useSOLBalance: true },   // obligatorio
  base: "MintA",
  baseAmount: new BN(5_000_000),
  otherAmountMax: new BN(1_000_000_000),
  txVersion: TxVersion.V0,              // esta llamada no tiene el campo poolKeys
});

await execute({ sendAndConfirm: true });

​

Reducir la liquidez (y recolectar comisiones al mismo tiempo)

Fuente: src/clmm/decreaseLiquidity.ts y src/clmm/closePosition.ts

const { execute } = await raydium.clmm.decreaseLiquidity({
  poolInfo,
  poolKeys,
  ownerPosition: positionAccount,
  ownerInfo: {                       // obligatorio; closePosition va dentro de este objeto
    useSOLBalance: true,
    closePosition: false,
  },
  liquidity: positionAccount.liquidity.divn(2),   // reduce a la mitad
  amountMinA: new BN(0),
  amountMinB: new BN(0),
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

Para recolectar solo comisiones y recompensas, llama a decreaseLiquidity con liquidity = new BN(0). El efecto secundario de la instrucción es liquidar token_fees_owed_{0,1} y reward_amount_owed y transferirlos fuera del pool. Es la única forma de recolectar cualquiera de los dos.

Para cerrar la posición por completo, una vez que la liquidez y las comisiones estén a cero, pasa ownerInfo: { 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 primera cuenta restante, para que CLMM pueda descongelar la cuenta antes de quemarla. La rama del código fuente del programa no incluye ningún cambio en el SDK. Antes de habilitar la creación de posiciones de emisor restringido, confirma que tu versión del SDK admite explícitamente la ruta de cierre con cuenta congelada.

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

// Programa de CLMM: consulta reference/program-addresses; fuente ecb1577;
// Solana mainnet-beta; última verificación el 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 todos los cierres. CLMM solo lo lee cuando positionNftAccount está congelada, lo que permite que una misma ruta de cliente sea compatible con posiciones antiguas y nuevas.

​

Recolectar recompensas

Fuente: 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 es un constructor de MÚLTIPLES transacciones: `sequentially` es obligatorio
// y el resultado es `txIds`, no `txId`.
const { txIds } = await execute({ sequentially: true });

harvestAllRewards recorre todas las posiciones de todos los pools que se le pasan, agrupa las llamadas DecreaseLiquidity de liquidez cero que liquidan comisiones y recompensas (además de cualquier UpdateRewardInfos) y, si hace falta, las reparte en varias transacciones.

​

Swap

Fuente: src/clmm/swap.ts

Esto replica src/clmm/swap.ts, que simula con swapInternal en lugar 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 });

La simulación recorre el mapa de ticks fuera de la cadena (off-chain) con la misma lógica que el programa on-chain y devuelve la cantidad de salida (amountCalculated) junto con la lista exacta de cuentas que tocará el swap (accounts).

Pase siempre los remainingAccounts que devuelve la simulación: si faltan, el swap revierte a mitad del recorrido con NotEnoughTickArrayAccount; si sobran o están desactualizados, solo desperdician cómputo.

PoolUtils.computeAmountOutFormat sigue existiendo, pero necesita un ComputeClmmPoolInfo (el computePoolInfo devuelto por getPoolInfoFromRpc, no un objeto de pool de la API) y dos argumentos obligatorios más: tickarrayBitmapExtension y blockTimestamp. Además, no existe el método raydium.clmm.fetchTickArrays (fetchTickArrays es una función independiente; los helpers a nivel de módulo son PoolUtils.fetchMultiplePoolTickArrays y los tickData / tickArrays que devuelve getPoolInfoFromRpc).

​

Crear un pool CLMM personalizable

createCustomizablePool es el punto de entrada que expone los interruptores de comisión dinámica y de comisión de un solo lado en el momento de crear el pool. Recibe la misma forma que createPool más dos parámetros 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); // elige un nivel de calibración

const { execute, extInfo } = await raydium.clmm.createCustomizablePool({
  programId: CLMM_PROGRAM_ID,
  mint1:     mintA,
  mint2:     mintB,
  ammConfig,
  initialPrice,
  // Los dos parámetros adicionales:
  collectFeeOn:      CollectFeeOn.TokenOnlyB,   // FromInput | TokenOnlyA | TokenOnlyB
  dynamicFeeConfig:  new PublicKey(dynamicFeeConfig!.id),
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });
console.log("Pool personalizable:", extInfo.address.id);   // cadena base58

No existen los parámetros enableDynamicFee, dynamicFeeConfigId ni startTime. Pasar dynamicFeeConfig es lo que activa las comisiones dinámicas: si lo omite, obtendrá un pool con comisión estática, sin ningún error. Tenga en cuenta además que los miembros del enum del SDK son TokenOnlyA / TokenOnlyB, mientras que el enum de Rust on-chain los nombra Token0Only / Token1Only; los valores numéricos coinciden (FromInput = 0).

createPool sigue funcionando para el camino de comisión por defecto, sin comisión dinámica. Use createCustomizablePool cuando necesite cualquiera de estos dos ajustes. Consulte products/clmm/instructions para ver la lista de cuentas on-chain.

​

Órdenes límite

Una orden límite deposita el importe del usuario en un único tick y se ejecuta por orden FIFO cuando un swap cruza ese tick. Los importes resultantes se envían al ATA del propietario en el momento de la liquidación; el propietario no necesita estar conectado para que se ejecute.

​

Abrir una orden límite

No existe una cuenta de configuración de órdenes límite por pool ni un helper getClmmLimitOrderConfigs(): las órdenes se identifican por tick.

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

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

// El precio límite DEBE cuantizarse a tick_spacing: getOrderTick se encarga de ello.
const targetPrice = new Decimal(180);                              // vender SOL a 180 USDC
const orderData = getOrderTick({
  baseIn: true,                                                    // vendiendo mintA
  mintADecimal: poolInfo.mintA.decimals,
  mintBDecimal: poolInfo.mintB.decimals,
  tickSpacing: poolInfo.config.tickSpacing,
  price: targetPrice,
});

// Una orden de venta debe estar por encima del tick actual; una de compra, por debajo.
if (orderData.tick < rpcData.tickCurrent) throw new Error("el precio de venta debe ser > precio actual");

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, por defecto 0
  txVersion: TxVersion.V0,
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Orden límite abierta:", extInfo.limitOrder.toBase58(), "tx:", txId);

El SDK deriva la PDA de LimitOrderState a partir de (owner, nonce PDA, order nonce), incrementa el LimitOrderNonce de la wallet e inserta la orden en la cohorte FIFO de ese tick.

​

Aumentar / reducir una orden abierta

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 lo añade sobre Increase
  txVersion: TxVersion.V0,
}).then((b) => b.execute({ sendAndConfirm: true }));

decreaseLimitOrder solo puede retirar importe de la parte no ejecutada de la orden; la parte ejecutada queda bloqueada hasta la liquidación. Ambas instrucciones revierten con InvalidOrderPhase si la orden ya se ha ejecutado por completo.

​

Liquidar una orden ejecutada

// settleLimitOrder recibe ÚNICAMENTE la PDA de la orden: sin poolInfo, sin poolKeys.
await raydium.clmm.settleLimitOrder({
  limitOrder,
  txVersion: TxVersion.V0,
}).then((b) => b.execute({ sendAndConfirm: true }));

settleLimitOrder lee unfilled_ratio_x64 de la orden frente al rastreador de la cohorte, calcula el importe ejecutado y lo transfiere al ATA del propietario. El propietario puede invocarlo él mismo; limit_order_admin (un keeper operativo off-chain) también puede hacerlo en nombre del propietario, y el importe seguirá yendo al propietario.

Para cerrar órdenes totalmente liquidadas y recuperar la renta, use closeLimitOrder (individual) o closeAllLimitOrder (por lotes). Para liquidar muchas a la vez, settleAllLimitOrder agrupa en una transacción v0 todas las llamadas SettleLimitOrder que quepan.

​

Listar las órdenes activas de una wallet (off-chain)

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

El endpoint de órdenes activas devuelve en una misma respuesta las órdenes sin ejecutar y las parcialmente ejecutadas (totalAmount / filledAmount / pendingSettle distinguen las fases). Para el historial de órdenes cerradas use /limit-order/history/order/list-by-user?wallet=… (por wallet, paginado con nextPageId); para el registro completo de eventos de una orden concreta use /limit-order/history/event/list-by-pda?pda=….

​

Esqueleto de CPI en Rust

// Cargo.toml — `master` fija anchor-lang =1.0.2.
// anchor-lang  = "=1.0.2"   // debe coincidir con lo que fija raydium-clmm
// anchor-spl   = "=1.0.2"
// raydium-clmm = { git = "https://github.com/raydium-io/raydium-clmm",
//                  branch = "master", features = ["cpi"] }
//
// La misma línea de Anchor que el ejemplo CPMM de products/cpmm/code-demos, de modo que
// ambos crates CPI puedan ser dependencias de un mismo programa.

use anchor_lang::prelude::*;
use raydium_clmm::cpi;
use raydium_clmm::program::RaydiumClmm;
use raydium_clmm::cpi::accounts::SwapSingleV2;   // `SwapV2` es el nombre de la instrucción,
                                                 // `SwapSingleV2` es el struct de cuentas

#[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` contiene las cuentas tick_array y 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 recibe aquí la Pubkey del programa, no su AccountInfo. En la rama
    // `master` de 0.32 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)
}

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ítala; en caso contrario, es la primera cuenta restante.

​

Errores comunes

• Extremos de tick que no coinciden con el espaciado → TickAndSpacingNotMatch. Ajuste siempre los valores con TickUtil.getPriceAndTick (TickUtil en singular).
• No se proporcionan suficientes tick arrays en SwapV2 → NotEnoughTickArrayAccount. Tome la lista de swapInternal(...).accounts.
• Posición de rango completo sin la extensión de bitmap → la PDA de la extensión debe ser escribible. El SDK se encarga de esto automáticamente.
• Confundir sqrt_price_x64 con price → una confusión de factor 2 en este punto resulta especialmente costosa. En caso de duda, deje que el SDK calcule el valor a partir de un precio legible.
• Recolectar recompensas con demasiada frecuencia → cada recolección es un DecreaseLiquidity con liquidez cero y cuesta una transacción. Agrúpelas con harvestAllRewards para varias posiciones, y recuerde que su execute necesita { sequentially: true }.
• Cerrar por su cuenta las cuentas de NFT → ClosePosition quema el NFT y cierra su ATA. También cierra el mint de un NFT de Token-2022; un mint de SPL Token clásico permanece con supply cero, porque ese programa no puede cerrar mints. No cierre por separado las cuentas admitidas, o la instrucción fallará.
• Abrir una orden límite en un tick que no respeta el espaciado → TickAndSpacingNotMatch. Cuantifique siempre el valor con el helper exportado getOrderTick.
• Llamar a decreaseLimitOrder sobre una orden totalmente ejecutada → InvalidOrderPhase. Use settleLimitOrder y después closeLimitOrder.
• Esperar un flag enableDynamicFee → no existe. Si omite dynamicFeeConfig, simplemente se crea un pool de comisión estática, sin aviso ni error. Si quiere comisiones dinámicas, pase el PublicKey de la cuenta de configuración, tomado de /main/clmm-dynamic-config.

​

Próximos pasos

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

Fuentes:

• Raydium SDK v2
• Demos de Raydium SDK v2
• raydium-io/raydium-clmm