Démonstrations de code CLMM

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

Banneau de version. Tous les démonstrations TypeScript ciblent @raydium-io/raydium-sdk-v2@0.2.64-alpha ; elles ont été exécutées pour la dernière fois contre 0.2.42-alpha (2026-04) et leurs signatures d’appel ont été revérifiées contre la source 0.2.64-alpha le 2026-09-09, sur Solana mainnet-beta. Le squelette CPI Rust à la fin cible raydium-clmm sur la branche chore/upgrade-anchor, Anchor 1.0.2, le même pin que la page CPMM, afin que les deux puissent coexister dans une même crate. master épingle toujours 0.32.1. Les ID de programme proviennent de reference/program-addresses via le SDK.

Configuration

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

Chaque démonstration sur cette page reflète un fichier dans raydium-sdk-V2-demo/src/clmm ; le lien GitHub se trouve à côté de chaque section. L’amorçage suit le config.ts.template du dépôt de démonstration (source) — disableFeatureCheck: true est le paramètre recommandé pour toute intégration non triviale :

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() retourne ApiClmmConfigInfo (id est une chaîne). createPool attend
// ClmmConfigInfo, qui a besoin d'un id PublicKey plus 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 par SOL
const { execute, extInfo } = await raydium.clmm.createPool({
  programId: CLMM_PROGRAM_ID,
  mint1:     mintA,
  mint2:     mintB,
  ammConfig,
  initialPrice,
  txVersion: TxVersion.V0,   // pas de `startTime` — CreateConcentratedPool n'a pas ce champ
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Pool:", extInfo.address.id, "tx:", txId);   // déjà une chaîne base58

Le SDK :

Trie mint1/mint2 par ordre d’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.
Paie les frais de création du pool définis par ammConfig.

Ouvrir une position dans une plage choisie

Source : src/clmm/createPosition.ts

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

const POOL_ID = "<POOL_ID>";   // chaîne base58
// note : getPoolInfoFromRpc de CLMM retourne `rpcPoolInfo`, pas `rpcData` (celui de CPMM le fait)
const { poolInfo, poolKeys, rpcPoolInfo } = await raydium.clmm.getPoolInfoFromRpc(POOL_ID);

// Choisir une plage de prix. Ici : ±10% du prix actuel.
const currentPrice = new Decimal(poolInfo.price);
const lowerPrice   = currentPrice.mul(0.9);
const upperPrice   = currentPrice.mul(1.1);

// Aligner sur les ticks valides pour le tick_spacing de ce pool.
// La classe est TickUtil (singulier), et elle prend des décimales + tickSpacing, pas 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,
});

// Combien de chaque token à déposer.
const inputAmount = new BN(10_000_000);  // 0.01 SOL

// getLiquidityAmountOutFromAmountIn est asynchrone — l'attendre.
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 ouverte, tx:", txId);

Le SDK calcule quels tick arrays la plage touche et les passe en tant que comptes. Il n’a pas besoin de regrouper une instruction init — il n’y a pas d’instruction init-tick-array ; OpenPosition* alloue un tick array manquant lui-même, aux frais du payeur.

Augmenter la liquidité sur une position existante

Source : src/clmm/increaseLiquidity.ts

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

// Il n'y a pas de getPositionInfo — énumérer les positions du portefeuille et en choisir une.
const allPositions = await raydium.clmm.getOwnerPositionInfo({
  programId: poolInfo.programId,
});
const positionAccount = allPositions.find((p) => p.nftMint.equals(positionNftMint));
if (!positionAccount) throw new Error("position non trouvée pour ce portefeuille");

const { execute } = await raydium.clmm.increasePositionFromBase({
  poolInfo,
  ownerPosition: positionAccount,
  ownerInfo: { useSOLBalance: true },   // requis
  base: "MintA",
  baseAmount: new BN(5_000_000),
  otherAmountMax: new BN(1_000_000_000),
  txVersion: TxVersion.V0,              // pas de membre poolKeys sur cet appel
});

await execute({ sendAndConfirm: true });

Diminuer 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: {                       // requis ; closePosition vit ici
    useSOLBalance: true,
    closePosition: false,
  },
  liquidity: positionAccount.liquidity.divn(2),   // diviser par deux
  amountMinA: new BN(0),
  amountMinB: new BN(0),
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

Pour collecter uniquement les frais et récompenses, appelez decreaseLiquidity avec liquidity = new BN(0). L’effet secondaire de l’instruction est de régler token_fees_owed_{0,1} et reward_amount_owed et de les transférer — c’est la seule façon de collecter l’un ou l’autre. Pour fermer complètement la position après avoir annulé la liquidité et les frais, passez ownerInfo: { closePosition: true } sur l’appel decreaseLiquidity final. Le SDK ajoute ClosePosition et brûle le NFT.

Les positions d’émetteur restreint nécessitent un générateur de fermeture compatible. Ces positions ont un compte de token NFT gelé. ClosePosition doit ajouter l’ID du pool de la position en tant que premier compte restant afin que CLMM puisse dégeler le compte avant de brûler le NFT. La branche source du programme n’inclut pas de changement SDK. Confirmez que votre version SDK supporte explicitement le chemin de fermeture gelé avant d’activer la création de positions d’émetteur restreint.

Pour un client Anchor direct, gardez les comptes déclarés inchangés et ajoutez le pool :

// Programme CLMM : voir reference/program-addresses ; source ecb1577 ;
// Solana mainnet-beta ; dernière vérification 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 passer poolId à chaque fermeture. CLMM ne le lit que lorsque positionNftAccount est gelé, ce qui garde un chemin client compatible avec les anciennes et nouvelles positions.

Collecter la/les récompense(s)

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 est un générateur MULTI-transaction : `sequentially` est requis
// et le résultat est `txIds`, pas `txId`.
const { txIds } = await execute({ sequentially: true });

harvestAllRewards parcourt chaque position sur chaque pool passé, regroupe les appels DecreaseLiquidity à liquidité zéro qui règlent les frais et récompenses (plus tout UpdateRewardInfos), et les divise entre les transactions si nécessaire.

Swap

Source : src/clmm/swap.ts

Ceci reflète `src/clmm/swap.ts`, qui simule avec `swapInternal` plutôt que
`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 pour 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 },   // requis
  remainingAccounts: simulation.accounts,
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

La simulation parcourt la carte des ticks hors chaîne avec la même logique que le programme on-chain et retourne le montant de sortie (amountCalculated) plus la liste exacte des comptes que le swap touchera (accounts). Passez toujours les remainingAccounts que la simulation retourne : trop peu et le swap revient en arrière au milieu de la marche avec NotEnoughTickArrayAccount ; les comptes obsolètes gaspillent simplement du calcul.

PoolUtils.computeAmountOutFormat existe toujours, mais il a besoin d’une ComputeClmmPoolInfo (le computePoolInfo de getPoolInfoFromRpc, pas un objet pool API) plus deux arguments supplémentaires requis — tickarrayBitmapExtension et blockTimestamp — et il n’y a pas de méthode raydium.clmm.fetchTickArrays (fetchTickArrays est une fonction libre ; les aides 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 bascules de frais dynamiques et de frais unilatéraux au moment de la création du pool. Il prend la forme de createPool plus deux ajouts :

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); // choisir un tier d'étalonnage

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

await execute({ sendAndConfirm: true });
console.log("Pool personnalisable:", extInfo.address.id);   // chaîne base58

Il n’y a pas de drapeau enableDynamicFee et pas de paramètre dynamicFeeConfigId, et pas de startTime. Fournir dynamicFeeConfig est ce qui active les frais dynamiques — l’omettre et vous obtenez un pool à frais statiques, silencieusement et sans erreur. Notez également que les membres de l’énumération SDK sont TokenOnlyA / TokenOnlyB, tandis que l’énumération Rust on-chain les épelle Token0Only / Token1Only ; les valeurs numériques correspondent (FromInput = 0).

createPool continue de fonctionner pour le chemin par défaut sans frais dynamiques. Utilisez createCustomizablePool chaque fois que vous avez besoin de l’un ou l’autre. Voir products/clmm/instructions pour la liste des comptes on-chain.

Ordres limités

Un ordre limité gare l’entrée utilisateur à un seul tick et est rempli FIFO lorsqu’un swap traverse ce tick. Les sorties sont poussées vers l’ATA du propriétaire au moment du règlement ; le propriétaire n’a pas besoin d’être en ligne pour être rempli.

Ouvrir un ordre limité

Il n'y a pas de compte de configuration d'ordre limité par pool et pas d'aide `getClmmLimitOrderConfigs()` — les ordres sont indexés par tick.

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

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

// Le prix limite DOIT être quantisé à tick_spacing — getOrderTick le fait.
const targetPrice = new Decimal(180);                              // vendre SOL à 180 USDC
const orderData = getOrderTick({
  baseIn: true,                                                    // vendre mintA
  mintADecimal: poolInfo.mintA.decimals,
  mintBDecimal: poolInfo.mintB.decimals,
  tickSpacing: poolInfo.config.tickSpacing,
  price: targetPrice,
});

// Un ordre de vente doit se situer au-dessus du tick actuel ; un ordre d'achat en dessous.
if (orderData.tick < rpcData.tickCurrent) throw new Error("le prix de vente doit être > prix actuel");

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,                           // optionnel, par défaut 0
  txVersion: TxVersion.V0,
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Ordre limité ouvert:", extInfo.limitOrder.toBase58(), "tx:", txId);

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

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

decreaseLimitOrder ne peut supprimer que de la portion non remplie de l’ordre ; la portion remplie est verrouillée jusqu’au règlement. Les deux instructions reviennent avec InvalidOrderPhase si l’ordre a déjà été entièrement rempli.

Régler un ordre rempli

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

settleLimitOrder lit le unfilled_ratio_x64 de l’ordre par rapport au suivi de la cohorte, calcule la sortie remplie, et la transfère à l’ATA du propriétaire. Le propriétaire peut appeler ceci lui-même ; limit_order_admin (un gardien opérationnel hors chaîne) peut également l’appeler au nom du propriétaire — la sortie va toujours au propriétaire. Pour fermer les ordres entièrement réglés afin de récupérer le loyer, utilisez closeLimitOrder (unique) ou closeAllLimitOrder (lot). Pour régler beaucoup à la fois, settleAllLimitOrder regroupe autant d’appels SettleLimitOrder que possible dans une tx v0.

Lister les ordres garés d’un portefeuille (hors chaîne)

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

Le point de terminaison des ordres actifs retourne les ordres non remplis et partiellement remplis dans une seule charge utile (totalAmount / filledAmount / pendingSettle distinguent les phases). Pour l’historique des ordres fermé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 spécifique, utilisez /limit-order/history/event/list-by-pda?pda=….

Squelette CPI Rust

// Cargo.toml — la branche importe : `master` épingle toujours anchor-lang 0.32.1.
// anchor-lang  = "=1.0.2"   // doit correspondre à ce que raydium-clmm épingle
// anchor-spl   = "=1.0.2"
// raydium-clmm = { git = "https://github.com/raydium-io/raydium-clmm",
//                  branch = "chore/upgrade-anchor", features = ["cpi"] }
//
// Même ligne Anchor que l'exemple CPMM dans products/cpmm/code-demos, afin que les deux
// crates CPI puissent être des dépendances d'un seul programme.

use anchor_lang::prelude::*;
use raydium_clmm::cpi;
use raydium_clmm::program::RaydiumClmm;
use raydium_clmm::cpi::accounts::SwapSingleV2;   // `SwapV2` est le nom de l'instruction,
                                                 // `SwapSingleV2` est la struct des comptes

#[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` porte les comptes tick_array et 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 prend la Pubkey du programme ici, pas son AccountInfo. Sur la
    // branche `master` 0.32, c'était `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, c’est le premier compte restant.

Pièges courants

Extrémités de tick hors espacement → TickAndSpacingNotMatch. Toujours aligner via TickUtil.getPriceAndTick (singulier TickUtil).
Pas assez de tick arrays fournis dans SwapV2 → NotEnoughTickArrayAccount. Prenez la liste de swapInternal(...).accounts.
Position pleine plage sans l’extension bitmap → le PDA d’extension doit être inscriptible ; le SDK gère cela automatiquement.
Confondre sqrt_price_x64 avec price → une confusion d’un facteur 2 ici est particulièrement douloureuse. En cas de doute, laissez le SDK le calculer à partir d’un prix lisible par l’homme.
Collecter les récompenses trop tôt → chaque collecte est un DecreaseLiquidity à liquidité zéro et coûte une transaction. Regroupez via harvestAllRewards sur plusieurs positions, et rappelez-vous que son execute a besoin de { sequentially: true }.
Fermer les comptes NFT vous-même → ClosePosition brûle le NFT et ferme son ATA. Il ferme également un mint NFT Token-2022 ; un mint SPL Token classique reste à zéro d’approvisionnement car ce programme ne peut pas fermer les mints. Ne fermez pas les comptes pris en charge séparément ou l’instruction reviendra.
Ouvrir un ordre limité à un tick non espacé → TickAndSpacingNotMatch. Toujours quantiser via l’aide getOrderTick exportée.
Appeler decreaseLimitOrder sur un ordre entièrement rempli → InvalidOrderPhase. Utilisez settleLimitOrder puis closeLimitOrder à la place.
S’attendre à un drapeau enableDynamicFee → il n’y en a pas. Omettre dynamicFeeConfig crée simplement un pool à frais statiques, silencieusement et sans erreur. Si vous vouliez des frais dynamiques, passez la PublicKey du compte de configuration, choisie dans /main/clmm-dynamic-config.

Où aller ensuite

sdk-api/typescript-sdk — surface SDK complète.
sdk-api/rest-api — points de terminaison de devis et de métadonnées de pool.
user-flows/create-clmm-pool — procédure pas à pas sans code.
integration-guides/aggregator — routage CLMM dans le cadre d’un chemin.

Sources :

Produits

Algorithmes

Démonstrations de code CLMM

Configuration

Créer un pool CLMM

Ouvrir une position dans une plage choisie

Augmenter la liquidité sur une position existante

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

Collecter la/les récompense(s)

Swap

Créer un pool CLMM personnalisable

Ordres limités

Ouvrir un ordre limité

Augmenter / diminuer un ordre ouvert

Régler un ordre rempli

Lister les ordres garés d’un portefeuille (hors chaîne)

Squelette CPI Rust

Pièges courants

Où aller ensuite

​Configuration

​Créer un pool CLMM

​Ouvrir une position dans une plage choisie

​Augmenter la liquidité sur une position existante

​Diminuer la liquidité (et collecter les frais en même temps)

​Collecter la/les récompense(s)

​Swap

​Créer un pool CLMM personnalisable

​Ordres limités

​Ouvrir un ordre limité

​Augmenter / diminuer un ordre ouvert

​Régler un ordre rempli

​Lister les ordres garés d’un portefeuille (hors chaîne)

​Squelette CPI Rust

​Pièges courants

​Où aller ensuite

Configuration

Créer un pool CLMM

Ouvrir une position dans une plage choisie

Augmenter la liquidité sur une position existante

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

Collecter la/les récompense(s)

Swap

Créer un pool CLMM personnalisable

Ordres limités

Ouvrir un ordre limité

Augmenter / diminuer un ordre ouvert

Régler un ordre rempli

Lister les ordres garés d’un portefeuille (hors chaîne)

Squelette CPI Rust

Pièges courants

Où aller ensuite