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 →

Banner de versión. Todos los demostraciones de TypeScript apuntan a @raydium-io/raydium-sdk-v2@0.2.64-alpha; se ejecutaron por última vez contra 0.2.42-alpha (2026-04) y sus firmas de llamada se verificaron nuevamente contra la fuente 0.2.64-alpha el 2026-09-09, contra Solana mainnet-beta. El esqueleto de CPI en Rust al final apunta a raydium-clmm en master, que fija Anchor =0.32.1 — no el 1.0.2 que usa la página CPMM; los dos no pueden coexistir en un crate. Los ID 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 demostración en esta página refleja un archivo en raydium-sdk-V2-demo/src/clmm; el enlace de GitHub se encuentra 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

// getClmmConfigs() devuelve ApiClmmConfigInfo (id es una cadena). createPool requiere
// ClmmConfigInfo, que necesita un id de PublicKey más fundOwner/description — convertir:
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,   // 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 por 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` (CPMM sí)
const { poolInfo, poolKeys, rpcPoolInfo } = await raydium.clmm.getPoolInfoFromRpc(POOL_ID);

// 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.
// La clase es TickUtil (singular), y toma decimales + 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,
});

// Cuánto de cada token depositar.
const inputAmount = new BN(10_000_000);  // 0.01 SOL

// getLiquidityAmountOutFromAmountIn es asincrónica — espérala.
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é arrays de tick toca el rango y los pasa como cuentas. No necesita agrupar ninguna instrucción de inicialización — no hay instrucción de inicialización de array de tick; OpenPosition* asigna un array de tick faltante por sí solo, a expensas del pagador.

Aumentar liquidez en una posición existente

Fuente: src/clmm/increaseLiquidity.ts

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

// No hay getPositionInfo — enumera las posiciones de la billetera 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("posición no encontrada para esta billetera");

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

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,
  ownerInfo: {                       // requerido; closePosition vive aquí
    useSOLBalance: true,
    closePosition: false,
  },
  liquidity: positionAccount.liquidity.divn(2),   // reducir a la mitad
  amountMinA: new BN(0),
  amountMinB: new BN(0),
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

Para cobrar 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 — esta es la única forma de cobrar cualquiera de ellos. Para cerrar la posición completamente después de poner la liquidez y comisiones en cero, pasa ownerInfo: { closePosition: true } en la llamada final 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 quemarla. La rama de fuente del programa no incluye un cambio de SDK. Confirma que tu versión de 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

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 requerido
// y el resultado es `txIds`, no `txId`.
const { txIds } = await execute({ sequentially: true });

harvestAllRewards recorre cada posición en cada pool pasado, agrupa las llamadas DecreaseLiquidity de liquidez cero que liquidan comisiones y recompensas (más cualquier UpdateRewardInfos), y las divide entre transacciones si es necesario.

Swap

Fuente: src/clmm/swap.ts

Esto refleja `src/clmm/swap.ts`, que simula con `swapInternal` en lugar 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 salida exacta
  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 },   // requerido
  remainingAccounts: simulation.accounts,
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

La simulación recorre el mapa de tick fuera de la cadena con la misma lógica que el programa en la cadena y devuelve la cantidad de salida (amountCalculated) más la lista exacta de cuentas que el swap tocará (accounts). Siempre pasa los remainingAccounts que devuelve la simulación: muy pocos y el swap se revierte a mitad de camino con NotEnoughTickArrayAccount; los obsoletos simplemente desperdician cómputo.

PoolUtils.computeAmountOutFormat aún existe, pero necesita un ComputeClmmPoolInfo (el computePoolInfo de getPoolInfoFromRpc, no un objeto de pool de API) más dos argumentos requeridos más — tickarrayBitmapExtension y blockTimestamp — y no hay método raydium.clmm.fetchTickArrays (fetchTickArrays es una función libre; los ayudantes a nivel de módulo son PoolUtils.fetchMultiplePoolTickArrays y el tickData / tickArrays devueltos por getPoolInfoFromRpc).

Crear un pool CLMM personalizable

createCustomizablePool es el punto de entrada que expone los toggles de comisión dinámica y comisión de un solo lado en el momento de la creación del pool. Toma la forma de createPool más dos 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 tier de calibración

const { execute, extInfo } = await raydium.clmm.createCustomizablePool({
  programId: CLMM_PROGRAM_ID,
  mint1:     mintA,
  mint2:     mintB,
  ammConfig,
  initialPrice,
  // Las dos adiciones:
  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 hay bandera enableDynamicFee ni parámetro dynamicFeeConfigId, y no hay startTime. Suministrar dynamicFeeConfig es lo que habilita comisiones dinámicas — omítelo y obtendrás un pool de comisión estática, sin error. Ten en cuenta también que los miembros del enum del SDK son TokenOnlyA / TokenOnlyB, mientras que el enum Rust en la cadena los deletrea Token0Only / Token1Only; los valores numéricos coinciden (FromInput = 0).

createPool continúa funcionando para la ruta de comisión predeterminada, sin comisión dinámica. Usa createCustomizablePool siempre que necesites cualquiera de los dos controles. Ver products/clmm/instructions para la lista de cuentas en la 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. Las salidas 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

No hay cuenta de configuración de orden limitada por pool y no hay ayudante `getClmmLimitOrderConfigs()` — las órdenes se clave por tick.

```ts
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 ser cuantizado a tick_spacing — getOrderTick hace eso.
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 orden 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 limitada abierta:", extInfo.limitOrder.toBase58(), "tx:", txId);

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

Aumentar / disminuir 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 añade esto sobre Increase
  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

// settleLimitOrder toma SOLO el PDA de la orden — sin poolInfo, sin poolKeys.
await raydium.clmm.settleLimitOrder({
  limitOrder,
  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 por sí 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 para recuperar renta, 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=<tu-pubkey-billetera>`,
).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 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 CPI en Rust

// Cargo.toml — CLMM aún está en Anchor 0.32, por lo que no puede compartir un crate con
// la muestra CPMM en products/cpmm/code-demos (que fija =1.0.2).
// anchor-lang  = "=0.32.1"
// anchor-spl   = "=0.32.1"
// raydium-clmm = { git = "https://github.com/raydium-io/raydium-clmm",
//                  branch = "master", features = ["cpi"] }

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 la estructura 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` lleva las cuentas tick_array y bitmap_extension.
}

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 = 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 0.32 toma el AccountInfo del programa aquí. NO cambies esto a un
    // Pubkey — esa es la forma de Anchor 1.0, que CLMM no usa.
    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 cuenta restante 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 → TickAndSpacingNotMatch. Siempre ajusta vía TickUtil.getPriceAndTick (singular TickUtil).
No hay suficientes arrays de tick suministrados en SwapV2 → NotEnoughTickArrayAccount. Toma la lista de swapInternal(...).accounts.
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 dudes, deja que el SDK lo calcule desde un precio legible por humanos.
Cobrar recompensas demasiado ansiosamente → cada cobro es un DecreaseLiquidity de liquidez cero y cuesta una transacción. Agrupa vía harvestAllRewards entre muchas posiciones, y recuerda que su execute necesita { sequentially: true }.
Cerrar cuentas NFT por ti mismo → ClosePosition quema el NFT y cierra su ATA. También cierra un mint de NFT Token-2022; un mint de Token SPL 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 → TickAndSpacingNotMatch. Siempre cuantiza vía el ayudante exportado getOrderTick.
Llamar a decreaseLimitOrder en una orden completada totalmente → InvalidOrderPhase. Usa settleLimitOrder luego closeLimitOrder en su lugar.
Esperando una bandera enableDynamicFee → no hay ninguna. Omitir dynamicFeeConfig simplemente crea un pool de comisión estática, silenciosamente y sin error. Si querías comisiones dinámicas, pasa el PublicKey de la cuenta de configuración, elegido 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 CPI en Rust

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 CPI en Rust

​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 CPI en Rust

Errores comunes

Dónde ir a continuación