Démonstrations de code CLMM

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

Bannière 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 Rust CPI à la fin cible raydium-clmm sur master, qui épingle Anchor =0.32.1 — pas le 1.0.2 utilisé par la page CPMM ; les deux ne peuvent pas coexister dans une même crate. 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 de 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 de 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 le lit uniquement quand 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 sortant (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 assistants 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, 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 limites

Un ordre limite gare l’entrée utilisateur à un seul tick et est rempli FIFO quand 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 limite

Il n'y a pas de compte de configuration d'ordre limite par pool et pas d'assistant `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 limite 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 aussi 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)

// Assistant 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 Rust CPI

// Cargo.toml — CLMM est toujours sur Anchor 0.32, donc il ne peut pas partager une crate avec
// l'exemple CPMM dans products/cpmm/code-demos (qui épingle =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` 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(
    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 prend l'AccountInfo du programme ici. NE CHANGEZ PAS ceci en
    // Pubkey — c'est la forme Anchor 1.0, que CLMM n'utilise pas.
    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)
}

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. Alignez toujours 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 → l’extension PDA 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 aussi 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 limite à un tick non espacé → TickAndSpacingNotMatch. Quantisez toujours via l’assistant getOrderTick exporté.
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 limites

Ouvrir un ordre limite

Augmenter / diminuer un ordre ouvert

Régler un ordre rempli

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

Squelette Rust CPI

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 limites

​Ouvrir un ordre limite

​Augmenter / diminuer un ordre ouvert

​Régler un ordre rempli

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

​Squelette Rust CPI

​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 limites

Ouvrir un ordre limite

Augmenter / diminuer un ordre ouvert

Régler un ordre rempli

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

Squelette Rust CPI

Pièges courants

Où aller ensuite