Démonstrations de code CPMM

Exemples TypeScript complets pour chaque opération CPMM — créer un pool, échanger, déposer, retirer, collecter les frais — plus un squelette CPI Rust minimal.

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 cible raydium-cp-swap sur master, Anchor 1.0.2. Les ID de programme sont extraits via des constantes de reference/program-addresses.

​

Prérequis

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/cpmm ; 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) :

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",
});

L’instance Raydium est la façade du SDK — chaque démonstration ci-dessous l’utilise. Raydium.load est asynchrone car elle charge la liste des tokens par défaut ; passez disableLoadToken: true pour ignorer cette récupération. La vérification de disponibilité des fonctionnalités est déjà ignorée sauf si vous passez disableFeatureCheck: false. Les configurations de frais sont récupérées de manière différée à la première utilisation via raydium.api.getCpmmConfigs().

​

Créer un pool CPMM

Source : src/cpmm/createCpmmPool.ts

import { PublicKey } from "@solana/web3.js";
import BN from "bn.js";
import { CREATE_CPMM_POOL_PROGRAM, CREATE_CPMM_POOL_FEE_ACC }
  from "@raydium-io/raydium-sdk-v2";
// (Si vous avez besoin de chaque PDA de pool à la fois, l'assistant exporté est `getCreatePoolKeys`.
//  Il n'y a pas de `getCpmmPdas`.)

const mintA = new PublicKey("So11111111111111111111111111111111111111112"); // wSOL
const mintB = new PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"); // USDC

// 1. Choisissez une configuration de frais. index=0 est le palier 0,25 %.
const feeConfigs = await raydium.api.getCpmmConfigs();
const feeConfig  = feeConfigs.find((c) => c.index === 0)!;

// 2. Récupérez les métadonnées du mint pour que le SDK puisse gérer les extensions Token-2022.
const mintAInfo = await raydium.token.getTokenInfo(mintA);
const mintBInfo = await raydium.token.getTokenInfo(mintB);

// 3. Construisez la transaction.
const { execute, extInfo } = await raydium.cpmm.createPool({
  programId:       CREATE_CPMM_POOL_PROGRAM,
  poolFeeAccount:  CREATE_CPMM_POOL_FEE_ACC,
  mintA:           mintAInfo,
  mintB:           mintBInfo,
  mintAAmount:     new BN(1_000_000_000),   // 1 SOL (en supposant 9 décimales)
  mintBAmount:     new BN(   160_000_000),  // 160 USDC (à 160/SOL)
  startTime:       new BN(0),               // ouvert immédiatement
  feeConfig,
  associatedOnly:  false,
  ownerInfo:       { useSOLBalance: true },
  txVersion:       TxVersion.V0,
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Pool créé à", extInfo.address.poolId.toBase58());
console.log("Tx :", txId);

Quelques éléments que le SDK gère silencieusement :

• Tri des mints dans l’ordre token0/token1 avant de dériver le PDA.
• Paiement des frais uniques create_pool_fee à poolFeeAccount.
• Création des comptes de tokens associés de l’appelant s’ils manquent.
• Choix du bon programme de tokens (SPL Token vs Token-2022) par côté.

Après confirmation, vous pouvez récupérer l’état du pool en direct avec :

// getPoolInfoFromRpc prend une chaîne base58 positionnelle, pas une PublicKey ni un objet.
const { poolKeys, poolInfo, rpcData } = await raydium.cpmm.getPoolInfoFromRpc(
  extInfo.address.poolId.toBase58(),
);

​

Swap (entrée de base)

Source : src/cpmm/swap.ts

import { CurveCalculator, FeeOn } from "@raydium-io/raydium-sdk-v2";

const POOL_ID = "<POOL_ID>";   // chaîne base58

// 1. Chargez l'état actuel du pool directement depuis un RPC (pas depuis l'API).
const { poolInfo, poolKeys, rpcData } = await raydium.cpmm.getPoolInfoFromRpc(POOL_ID);

const inputMint  = poolInfo.mintA.address;                // swap A → B
const amountIn   = new BN(100_000_000);                   // 0,1 SOL
const slippage   = 0.005;                                 // 0,5 %

// 2. Cotez localement. CurveCalculator reflète les mathématiques on-chain, y compris
//    les frais de transfert Token-2022 de chaque côté. Les huit arguments sont tous requis.
const baseIn = inputMint === poolInfo.mintA.address;
const swapResult = CurveCalculator.swapBaseInput(
  amountIn,
  baseIn ? rpcData.baseReserve : rpcData.quoteReserve,
  baseIn ? rpcData.quoteReserve : rpcData.baseReserve,
  rpcData.configInfo!.tradeFeeRate,
  rpcData.configInfo!.creatorFeeRate,
  rpcData.configInfo!.protocolFeeRate,
  rpcData.configInfo!.fundFeeRate,
  rpcData.feeOn === FeeOn.BothToken || rpcData.feeOn === FeeOn.OnlyTokenB,
);
// Les champs swapResult sont inputAmount / outputAmount / tradeFee / protocolFee /
// fundFee / creatorFee / newInputVaultAmount / newOutputVaultAmount.
// Il n'y a pas de destinationAmountSwapped ni sourceAmountSwapped.

// 3. Construisez et envoyez. Passer `slippage` ici est ce qui applique la limite —
//    aucune arithmétique manuelle de minimum-out n'est nécessaire.
const { execute } = await raydium.cpmm.swap({
  poolInfo,
  poolKeys,
  inputAmount: amountIn,
  swapResult,
  slippage,
  baseIn,
  txVersion: TxVersion.V0,
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Tx de swap :", txId);

Remarque : le SDK récupère toujours l’état du pool depuis un RPC à l’intérieur de getPoolInfoFromRpc. Ne cotez pas hors de api-v3.raydium.io pour une transaction que vous êtes sur le point de signer — une cotation qui est d’un bloc obsolète peut glisser dans ExceededSlippage au moment de l’atterrissage.

​

Swap (sortie de base)

Source : src/cpmm/swapBaseOut.ts

const amountOutWanted = new BN(15_000_000);        // 15 USDC
const slippage        = 0.005;

const baseIn = false; // false → mintB est le côté d'entrée
const swapResult = CurveCalculator.swapBaseOutput(
  amountOutWanted,
  baseIn ? rpcData.baseReserve : rpcData.quoteReserve,
  baseIn ? rpcData.quoteReserve : rpcData.baseReserve,
  rpcData.configInfo!.tradeFeeRate,
  rpcData.configInfo!.creatorFeeRate,
  rpcData.configInfo!.protocolFeeRate,
  rpcData.configInfo!.fundFeeRate,
  rpcData.feeOn === FeeOn.BothToken || rpcData.feeOn === FeeOn.OnlyTokenB,
);
// swapResult.inputAmount est l'entrée requise ; il n'y a pas de sourceAmountSwapped.

const { execute } = await raydium.cpmm.swap({
  poolInfo,
  poolKeys,
  inputAmount: new BN(0),   // inutilisé quand fixedOut — le montant provient de swapResult
  fixedOut:    true,
  swapResult,               // requis, et il porte le montant de sortie cible
  baseIn,
  slippage,
  txVersion:   TxVersion.V0,
});

await execute({ sendAndConfirm: true });

​

Déposer de la liquidité

Source : src/cpmm/deposit.ts

import { Percent } from "@raydium-io/raydium-sdk-v2";
import Decimal from "decimal.js";

// addLiquidity est piloté par un montant INPUT, pas un montant LP.
const uiInputAmount = "0.0001";
const inputAmount = new BN(
  new Decimal(uiInputAmount).mul(10 ** poolInfo.mintA.decimals).toFixed(0),
);
const slippage = new Percent(1, 100);   // un Percent, pas un nombre

const { execute } = await raydium.cpmm.addLiquidity({
  poolInfo,
  poolKeys,
  inputAmount,
  baseIn: true,           // inputAmount est libellé en mintA
  slippage,
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

Le SDK dérive le montant appairé à partir des réserves actuelles du pool, augmente chaque côté du slippage pour les arguments maximum_* de l’instruction, et construit les créations d’ATA si nécessaire. raydium.cpmm.computePairAmount({ ... }) retourne les mêmes nombres si vous les voulez pour un aperçu d’interface utilisateur.

​

Retirer de la liquidité

Source : src/cpmm/withdraw.ts

import { Percent } from "@raydium-io/raydium-sdk-v2";

const lpAmount = new BN(100_000);           // LP à brûler
const slippage = new Percent(1, 100);       // un Percent, pas un nombre

const { execute } = await raydium.cpmm.withdrawLiquidity({
  poolInfo,
  poolKeys,
  lpAmount,
  slippage,
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

​

Collecter les frais de protocole/fonds/créateur

Source : src/cpmm/collectCreatorFee.ts, src/cpmm/collectAllCreatorFee.ts

La collecte des frais de protocole et de fonds reste soumise à une autorité. Les frais de créateur suivent deux chemins : le CollectCreatorFee signé par le créateur, et le CollectCreatorFeePermissionless additif, que n’importe quel payeur peut invoquer mais qui ne peut transférer que vers les ATAs canoniques du créateur. La version 0.2.64-alpha fournit des builders au niveau du module pour les deux chemins du créateur :

// signé par le créateur
const { execute } = await raydium.cpmm.collectCreatorFees({
  poolInfo,
  poolKeys,
  txVersion: TxVersion.V0,
});

// sans permission — n'importe quel payeur ; les revenus vont aux ATAs canoniques du créateur
const { execute } = await raydium.cpmm.collectCreatorFeesPermissionless({
  poolInfo,
  poolKeys,
  txVersion: TxVersion.V0,
});

// plusieurs pools à la fois, signé par le créateur
await raydium.cpmm.collectMultiCreatorFees({ poolInfoList, txVersion: TxVersion.V0 });

Les deux instructions de créateur ont changé leurs listes de comptes lors de la mise à jour du programme du 2026-09-19. Chacune prend désormais une PDA creator_fee_share à ["creator_fee_share", creator, ammConfig], et celle sans permission prend également amm_config — tous deux ajoutés après system_program plutôt qu’insérés, de sorte que les comptes qui étaient déjà là conservent leurs positions. Un builder épinglé à une version du SDK antérieure à la mise à jour émet la liste plus courte et la transaction est rejetée pour comptes manquants. Vérifiez que la version que vous installez contient les nouveaux comptes avant d’utiliser ces helpers avec le programme mis à jour, et actualisez l’IDL si vous générez des clients à partir de celui-ci.

Passer la PDA est obligatoire même quand elle n’a jamais été créée — dérivez-la et passez-la ; le programme revient à AmmConfig.creator_fee_share_rate quand le compte est vide.

Les deux instructions de créateur ont des discriminateurs et des dispositions de comptes différents — celle sans permission remplace le signataire créateur par un payer séparé et un creator non-signataire. Utilisez le builder correspondant plutôt que d’échanger manuellement les comptes sur l’autre.

Il n’y a pas de builder pour les frais de protocole ou de fonds dans le SDK (makeCollectProtocolFeeInstruction et makeCollectFundFeeInstruction n’existent sous aucun nom) — ce sont des chemins d’administration, tout comme CreateCreatorFeeShare / CloseCreatorFeeShare, qui n’ont pas non plus de builder. Les builders d’instructions bas niveau qui existent sont collectCpFeeInstruction, makeCollectCreatorFeeInstruction et collectCreatorFeePermissionlessInInstruction.

Hors chaîne, vous pouvez lire les frais accumulés directement depuis PoolState :

const pool = await raydium.cpmm.getRpcPoolInfo(POOL_ID);   // chaîne base58
console.log("Frais de protocole accumulés mintA :", pool.protocolFeesMintA.toString());
console.log("Frais de protocole accumulés mintB :", pool.protocolFeesMintB.toString());
// Les champs CpmmPoolInfoLayout sont protocolFeesMintA/B, fundFeesMintA/B et
// creatorFeesMintA/B — il n'y a pas de champs ...Token0/...Token1.
//
// creatorFeesMintA/B est l'accumulation *brute*. Le créateur la reçoit moins la
// part du protocole résolue au moment de la collecte ; protocolFeesMintA/B reçoit cette
// part, elle augmente donc aussi lors des collectes de frais de créateur, pas seulement lors des swaps.
// Voir products/cpmm/fees#protocol-share-of-the-creator-fee.

​

Squelette Rust CPI

Si vous voulez invoquer CPMM depuis votre propre programme Anchor — par exemple, un coffre qui effectue des swaps au nom de ses déposants — le contexte CPI ressemble à ceci. L’ordre des comptes suit products/cpmm/instructions.

// Cargo.toml — `master` épingle anchor-lang =1.0.2.
// raydium-cp-swap = { git = "https://github.com/raydium-io/raydium-cp-swap",
//                     branch = "master", features = ["cpi"] }
// anchor-lang      = "=1.0.2"   // doit correspondre à ce que raydium-cp-swap épingle
// anchor-spl       = "=1.0.2"
//
// La fonctionnalité `cpi` est requise — le module `raydium_cp_swap::cpi` n'existe
// que sous elle. L'exemple CLMM dans products/clmm/code-demos épingle le même
// =1.0.2 sur son propre `master`, donc les deux peuvent partager un programme.

use anchor_lang::prelude::*;
use anchor_spl::token_interface::{TokenAccount, TokenInterface, Mint};
use raydium_cp_swap::cpi::accounts::Swap;
use raydium_cp_swap::cpi;
use raydium_cp_swap::program::RaydiumCpSwap;

#[derive(Accounts)]
pub struct ProxySwap<'info> {
    #[account(mut)]
    pub payer: Signer<'info>,

    /// CHECK: validé par le programme CPMM
    pub authority:     UncheckedAccount<'info>,
    /// CHECK:
    pub amm_config:    UncheckedAccount<'info>,
    #[account(mut)]
    /// CHECK:
    pub pool_state:    UncheckedAccount<'info>,

    #[account(mut)]
    pub input_token_account:  InterfaceAccount<'info, TokenAccount>,
    #[account(mut)]
    pub output_token_account: InterfaceAccount<'info, TokenAccount>,

    #[account(mut)]
    pub input_vault:  InterfaceAccount<'info, TokenAccount>,
    #[account(mut)]
    pub output_vault: InterfaceAccount<'info, TokenAccount>,

    pub input_token_program:  Interface<'info, TokenInterface>,
    pub output_token_program: Interface<'info, TokenInterface>,

    pub input_token_mint:  InterfaceAccount<'info, Mint>,
    pub output_token_mint: InterfaceAccount<'info, Mint>,

    #[account(mut)]
    /// CHECK: tampon circulaire
    pub observation_state: UncheckedAccount<'info>,

    pub cpmm_program: Program<'info, RaydiumCpSwap>,
}

pub fn proxy_swap_base_input(
    ctx: Context<ProxySwap>,
    amount_in: u64,
    minimum_amount_out: u64,
) -> Result<()> {
    let cpi_accounts = Swap {
        payer:                ctx.accounts.payer.to_account_info(),
        authority:            ctx.accounts.authority.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(),
        input_token_program:  ctx.accounts.input_token_program.to_account_info(),
        output_token_program: ctx.accounts.output_token_program.to_account_info(),
        input_token_mint:     ctx.accounts.input_token_mint.to_account_info(),
        output_token_mint:    ctx.accounts.output_token_mint.to_account_info(),
        observation_state:    ctx.accounts.observation_state.to_account_info(),
    };
    // Anchor 1.0 prend la Pubkey du programme ici, pas son AccountInfo.
    let cpi_ctx = CpiContext::new(
        *ctx.accounts.cpmm_program.key,
        cpi_accounts,
    );
    cpi::swap_base_input(cpi_ctx, amount_in, minimum_amount_out)
}

Si votre CPI signe en tant que PDA (par exemple, vous gérez un coffre au nom des déposants), remplacez CpiContext::new par CpiContext::new_with_signer et passez vos seeds.

​

Pièges courants

Une courte liste de vérification avant d’ouvrir un ticket de support :

• Mints triés. Si votre PDA poolState dérivée ne correspond pas au pool en chaîne, vous avez probablement oublié de trier les mints.
• Devis API obsolète. Ne passez jamais une valeur de réserve de api-v3.raydium.io dans CurveCalculator.swap. Récupérez depuis un RPC.
• Mauvais programme de token. Le coffre d’un mint Token-2022 est détenu par le programme Token-2022, pas par SPL Token. Utilisez toujours les champs token_0_program / token_1_program du pool.
• Slippage sous-dénominé pour les mints avec frais de transfert. Si l’un ou l’autre côté du pool est un mint Token-2022 avec frais de transfert, votre minimum_amount_out doit être dénominé en ce que l’utilisateur reçoit réellement, pas en ce que le coffre envoie.
• NotApproved sur un swap. Vérifiez PoolState.status — l’administrateur peut avoir mis en pause les swaps sur ce pool. Voir products/cpmm/instructions pour le masque de statut.

​

Où aller ensuite

• sdk-api/typescript-sdk — référence complète du SDK.
• sdk-api/rest-api — points de terminaison de devis et de métadonnées de pool.
• user-flows/create-cpmm-pool — la procédure pas à pas sans code du même flux.
• integration-guides/aggregator — si vous routez CPMM dans le cadre d’un chemin multi-sauts.

Sources :

• Raydium SDK v2 — @raydium-io/raydium-sdk-v2
• Raydium SDK v2 démos — raydium-sdk-v2-demo
• raydium-io/raydium-cp-swap