Exemples de code CLMM

Exemples TypeScript de bout en bout : créer un pool CLMM, ouvrir une position dans une plage de prix choisie, ajuster la liquidité, effectuer un swap et collecter les frais et les récompenses.

Cette page est traduite automatiquement par IA. La version anglaise fait foi.

Voir la version anglaise →

​

Configuration

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

Chaque exemple de cette page reprend un fichier du dépôt raydium-sdk-V2-demo/src/clmm ; le lien GitHub figure à côté de chaque section. L’initialisation suit le fichier config.ts.template du dépôt de démonstration (source). Pour toute intégration non triviale, nous recommandons de définir 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;

​

Créer un pool CLMM

Source : 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() returns ApiClmmConfigInfo (id is a string). createPool wants
// ClmmConfigInfo, which needs a PublicKey id plus fundOwner/description — convert:
const clmmConfigs = await raydium.api.getClmmConfigs();
const picked = clmmConfigs.find((c) => c.index === 1)!;        // 0.05% tier
const ammConfig = { ...picked, id: new PublicKey(picked.id), fundOwner: "", description: "" };

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,
  txVersion: TxVersion.V0,   // no `startTime` — CreateConcentratedPool has no such field
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Pool:", extInfo.address.id, "tx:", txId);   // already a base58 string

Le SDK :

• Trie mint1 et mint2 selon l’ordre des octets avant la dérivation.
• Calcule sqrt_price_x64 = floor(sqrt(initialPrice × 10^(dB−dA)) × 2^64).
• Crée les comptes observation et tick_array_bitmap_extension.
• Acquitte les frais de création de pool définis par ammConfig.

​

Ouvrir une position dans une plage de prix choisie

Source : src/clmm/createPosition.ts

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

const POOL_ID = "<POOL_ID>";   // base58 string
// note: CLMM's getPoolInfoFromRpc returns `rpcPoolInfo`, not `rpcData` (CPMM's does)
const { poolInfo, poolKeys, rpcPoolInfo } = await raydium.clmm.getPoolInfoFromRpc(POOL_ID);

// 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.
// The class is TickUtil (singular), and it takes decimals + tickSpacing, not 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,
});

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

// getLiquidityAmountOutFromAmountIn is async — await it.
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("Position opened, tx:", txId);

Le SDK calcule les tick arrays couverts par la plage et les transmet comme comptes. Il n’a pas besoin d’inclure d’instruction d’initialisation : il n’existe pas d’instruction d’initialisation de tick array. OpenPosition* alloue lui-même un tick array manquant, aux frais du payeur.

​

Augmenter la liquidité d’une position existante

Source : src/clmm/increaseLiquidity.ts

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

// There is no getPositionInfo — enumerate the wallet's positions and pick one.
const allPositions = await raydium.clmm.getOwnerPositionInfo({
  programId: poolInfo.programId,
});
const positionAccount = allPositions.find((p) => p.nftMint.equals(positionNftMint));
if (!positionAccount) throw new Error("position not found for this wallet");

const { execute } = await raydium.clmm.increasePositionFromBase({
  poolInfo,
  ownerPosition: positionAccount,
  ownerInfo: { useSOLBalance: true },   // required
  base: "MintA",
  baseAmount: new BN(5_000_000),
  otherAmountMax: new BN(1_000_000_000),
  txVersion: TxVersion.V0,              // no poolKeys member on this call
});

await execute({ sendAndConfirm: true });

​

Réduire la liquidité (et collecter les frais en même temps)

Source : src/clmm/decreaseLiquidity.ts et src/clmm/closePosition.ts

const { execute } = await raydium.clmm.decreaseLiquidity({
  poolInfo,
  poolKeys,
  ownerPosition: positionAccount,
  ownerInfo: {                       // required; closePosition lives in here
    useSOLBalance: true,
    closePosition: false,
  },
  liquidity: positionAccount.liquidity.divn(2),   // halve
  amountMinA: new BN(0),
  amountMinB: new BN(0),
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

Pour collecter uniquement les frais et les récompenses, appelez decreaseLiquidity avec liquidity = new BN(0). Cette instruction règle les montants token_fees_owed_{0,1} et reward_amount_owed, puis les transfère : c’est le seul moyen de collecter l’un ou l’autre.

Pour fermer entièrement la position après avoir ramené la liquidité et les frais à zéro, passez ownerInfo: { closePosition: true } lors du dernier appel à decreaseLiquidity. Le SDK ajoute l’instruction ClosePosition et brûle le NFT.

Les positions à émetteur restreint nécessitent un constructeur de fermeture compatible. Ces positions disposent d’un compte de jetons NFT gelé. ClosePosition doit ajouter l’identifiant du pool de la position comme premier compte restant, afin que CLMM puisse dégeler le compte avant de le brûler. La branche du code source du programme ne contient aucune modification du SDK. Vérifiez que votre version du SDK prend explicitement en charge le chemin de fermeture pour les comptes gelés avant d’activer la création de positions à émetteur restreint.

Pour un client Anchor direct, conservez les comptes déclarés tels quels et ajoutez le 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();

Vous pouvez transmettre poolId à chaque fermeture. CLMM ne le lit que lorsque positionNftAccount est gelé, ce qui permet à un même chemin client de fonctionner avec les anciennes comme avec les nouvelles positions.

​

Collecter la ou les récompenses

Source : 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 is a MULTI-transaction builder: `sequentially` is required
// and the result is `txIds`, not `txId`.
const { txIds } = await execute({ sequentially: true });

harvestAllRewards parcourt chaque position de chaque pool transmis, regroupe les appels DecreaseLiquidity à liquidité nulle qui règlent les frais et les récompenses (ainsi que les éventuels UpdateRewardInfos), puis les répartit si nécessaire entre plusieurs transactions.

​

Swap

Source : src/clmm/swap.ts

Ce code reprend src/clmm/swap.ts, qui effectue la simulation avec swapInternal plutôt qu’avec 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 simulation parcourt la tick map hors chaîne avec la même logique que le programme on-chain, et renvoie le montant de sortie (amountCalculated) ainsi que la liste exacte des comptes que le swap va utiliser (accounts).

Transmettez toujours les remainingAccounts renvoyés par la simulation : s’il en manque, le swap échoue en cours de parcours avec NotEnoughTickArrayAccount ; s’il y en a de périmés, vous ne faites que consommer du compute inutilement.

PoolUtils.computeAmountOutFormat existe toujours, mais il requiert un ComputeClmmPoolInfo (le computePoolInfo retourné par getPoolInfoFromRpc, et non un objet pool issu de l’API), ainsi que deux arguments obligatoires supplémentaires : tickarrayBitmapExtension et blockTimestamp. Il n’existe pas non plus de méthode raydium.clmm.fetchTickArrays (fetchTickArrays est une fonction libre ; les helpers au niveau du module sont PoolUtils.fetchMultiplePoolTickArrays et les tickData / tickArrays retournés par getPoolInfoFromRpc).

​

Créer un pool CLMM personnalisable

createCustomizablePool est le point d’entrée qui expose les options de frais dynamiques et de frais à un seul côté au moment de la création du pool. Il reprend la signature de createPool avec deux paramètres supplémentaires :

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,
  // The two additions:
  collectFeeOn:      CollectFeeOn.TokenOnlyB,   // FromInput | TokenOnlyA | TokenOnlyB
  dynamicFeeConfig:  new PublicKey(dynamicFeeConfig!.id),
  txVersion: TxVersion.V0,
});

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

Il n’existe ni paramètre enableDynamicFee, ni paramètre dynamicFeeConfigId, ni paramètre startTime. Fournir dynamicFeeConfig est ce qui active les frais dynamiques : si vous l’omettez, vous obtenez un pool à frais statiques, sans aucune erreur. Notez également que les membres de l’énumération du SDK s’appellent TokenOnlyA / TokenOnlyB, alors que l’énumération Rust on-chain les nomme Token0Only / Token1Only. Les valeurs numériques correspondent (FromInput = 0).

createPool continue de fonctionner pour le chemin à frais par défaut, sans frais dynamiques. Utilisez createCustomizablePool dès que vous avez besoin de l’une de ces options. Consultez products/clmm/instructions pour la liste des comptes on-chain.

​

Ordres limites

Un ordre limite immobilise les fonds de l’utilisateur sur un tick unique, puis est exécuté selon la règle FIFO lorsqu’un swap franchit ce tick. Les montants obtenus sont envoyés vers l’ATA du propriétaire au moment du règlement ; le propriétaire n’a pas besoin d’être en ligne pour que l’ordre soit exécuté.

​

Ouvrir un ordre limite

Il n’existe ni configuration d’ordre limite par pool, ni helper getClmmLimitOrderConfigs() : les ordres sont identifiés par tick.

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

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

// Limit price MUST be quantized to tick_spacing — getOrderTick does that.
const targetPrice = new Decimal(180);                              // sell SOL at 180 USDC
const orderData = getOrderTick({
  baseIn: true,                                                    // selling mintA
  mintADecimal: poolInfo.mintA.decimals,
  mintBDecimal: poolInfo.mintB.decimals,
  tickSpacing: poolInfo.config.tickSpacing,
  price: targetPrice,
});

// A sell order must sit above the current tick; a buy order below it.
if (orderData.tick < rpcData.tickCurrent) throw new Error("sell price must be > current price");

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,                           // optional, defaults to 0
  txVersion: TxVersion.V0,
});

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

Le SDK dérive le PDA LimitOrderState à partir de (owner, nonce PDA, order nonce), incrémente le LimitOrderNonce propre au portefeuille, et insère l’ordre dans la cohorte FIFO correspondant à ce tick.

​

Augmenter / réduire un ordre ouvert

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,                 // optionnel ; DecreaseLimitOrder l'ajoute par rapport à Increase
  txVersion: TxVersion.V0,
}).then((b) => b.execute({ sendAndConfirm: true }));

decreaseLimitOrder ne peut retirer que la partie non exécutée de l’ordre ; la partie exécutée reste bloquée jusqu’au règlement. Les deux instructions échouent avec InvalidOrderPhase si l’ordre a déjà été entièrement exécuté.

​

Régler un ordre exécuté

// settleLimitOrder prend UNIQUEMENT le PDA de l'ordre — ni poolInfo, ni poolKeys.
await raydium.clmm.settleLimitOrder({
  limitOrder,
  txVersion: TxVersion.V0,
}).then((b) => b.execute({ sendAndConfirm: true }));

settleLimitOrder lit unfilled_ratio_x64 de l’ordre par rapport au suivi de la cohorte, calcule le montant exécuté et le transfère vers l’ATA du propriétaire. Le propriétaire peut appeler cette instruction lui-même ; limit_order_admin (un keeper opérationnel hors chaîne) peut aussi l’appeler pour le compte du propriétaire, le montant restant dans tous les cas destiné au propriétaire.

Pour fermer les ordres entièrement réglés et récupérer le loyer, utilisez closeLimitOrder (unitaire) ou closeAllLimitOrder (par lot). Pour régler plusieurs ordres à la fois, settleAllLimitOrder regroupe autant d’appels SettleLimitOrder que possible dans une transaction v0.

​

Lister les ordres en attente d’un portefeuille (hors chaîne)

// Helper de l'API. Voir 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());

L’endpoint des ordres actifs renvoie dans une même réponse les ordres non exécutés et partiellement exécutés (totalAmount / filledAmount / pendingSettle permettent de distinguer les phases). Pour l’historique des ordres clôturés, utilisez /limit-order/history/order/list-by-user?wallet=… (par portefeuille, paginé par nextPageId) ; pour le journal complet des événements d’un ordre donné, utilisez /limit-order/history/event/list-by-pda?pda=….

​

Squelette de CPI en Rust

// Cargo.toml — `master` pins anchor-lang =1.0.2.
// anchor-lang  = "=1.0.2"   // must match what raydium-clmm pins
// anchor-spl   = "=1.0.2"
// raydium-clmm = { git = "https://github.com/raydium-io/raydium-clmm",
//                  branch = "master", features = ["cpi"] }
//
// Same Anchor line as the CPMM sample in products/cpmm/code-demos, so both
// CPI crates can be dependencies of one program.

use anchor_lang::prelude::*;
use raydium_clmm::cpi;
use raydium_clmm::program::RaydiumClmm;
use raydium_clmm::cpi::accounts::SwapSingleV2;   // `SwapV2` is the instruction name,
                                                 // `SwapSingleV2` is the accounts struct

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

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 takes the program's Pubkey here, not its AccountInfo. On the
    // 0.32 `master` branch this was `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)
}

Ordre des comptes restants pour SwapV2 :

[tick_array_bitmap_extension?, tick_array_0, tick_array_1, …]

Si le swap n’a jamais besoin de l’extension, omettez-la ; sinon, elle occupe la première position parmi les comptes restants.

​

Pièges courants

• Bornes de tick mal alignées → TickAndSpacingNotMatch. Alignez toujours les valeurs avec TickUtil.getPriceAndTick (au singulier, TickUtil).
• Nombre insuffisant de tick arrays fournis dans SwapV2 → NotEnoughTickArrayAccount. Récupérez la liste depuis swapInternal(...).accounts.
• Position pleine largeur sans l’extension de bitmap → le PDA de l’extension doit être accessible en écriture. Le SDK s’en charge automatiquement.
• Confondre sqrt_price_x64 avec price → une erreur de facteur 2 est ici particulièrement pénible. En cas de doute, laissez le SDK calculer la valeur à partir d’un prix lisible.
• Réclamer les récompenses trop souvent → chaque collecte est un DecreaseLiquidity à liquidité nulle et coûte une transaction. Regroupez les opérations avec harvestAllRewards sur plusieurs positions, et n’oubliez pas que son execute nécessite { sequentially: true }.
• Fermer soi-même les comptes NFT → ClosePosition brûle le NFT et ferme son ATA. Il ferme aussi un mint NFT Token-2022 ; un mint SPL Token classique reste en circulation à zéro, car ce programme ne peut pas fermer les mints. Ne fermez pas séparément les comptes pris en charge, sinon l’instruction échouera.
• Ouvrir un ordre limite sur un tick non aligné → TickAndSpacingNotMatch. Quantifiez toujours la valeur avec le helper exporté getOrderTick.
• Appeler decreaseLimitOrder sur un ordre entièrement exécuté → InvalidOrderPhase. Utilisez plutôt settleLimitOrder, puis closeLimitOrder.
• Chercher un indicateur enableDynamicFee → il n’existe pas. Omettre dynamicFeeConfig crée simplement un pool à frais statiques, sans aucune erreur ni avertissement. Si vous souhaitez des frais dynamiques, passez le PublicKey du compte de configuration, récupéré depuis /main/clmm-dynamic-config.

​

Où aller ensuite

• sdk-api/typescript-sdk : la surface complète du SDK.
• sdk-api/rest-api : les endpoints de devis et de métadonnées des pools.
• user-flows/create-clmm-pool : le parcours pas à pas, sans code.
• integration-guides/aggregator : router le CLMM dans le cadre d’un chemin de swap.

Sources :

• Raydium SDK v2
• Démos du Raydium SDK v2
• raydium-io/raydium-clmm