Démonstrations de code CPMM

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.42-alpha sur Solana mainnet-beta, vérifiées en avril 2026. Le squelette CPI Rust cible raydium-cp-swap sur la branche master, Anchor 0.30.x. 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 correspond à un fichier dans raydium-sdk-V2-demo/src/cpmm ; le lien GitHub se trouve à côté de chaque section. L’initialisation suit le fichier 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. Elle récupère paresseusement les listes de tokens et les configurations de frais depuis api-v3.raydium.io ; vous pouvez l’initialiser avec vos propres données dans les environnements hors ligne.

Créer un pool CPMM

Source : src/cpmm/createCpmmPool.ts

import { PublicKey } from "@solana/web3.js";
import BN from "bn.js";
import { getCpmmPdas, CREATE_CPMM_POOL_PROGRAM, CREATE_CPMM_POOL_FEE_ACC }
  from "@raydium-io/raydium-sdk-v2";

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 gère 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) de chaque côté.

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

const { poolKeys, poolInfo, rpcData } = await raydium.cpmm.getPoolInfoFromRpc(
  extInfo.address.poolId,
);

Swap (base-input)

Source : src/cpmm/swap.ts

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

const poolId = new PublicKey("<POOL_ID>");

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

const inputMint  = new PublicKey(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. Le CurveCalculator du SDK reflète les mathématiques on-chain,
//    y compris les frais de transfert Token-2022 de chaque côté.
const baseIn = inputMint.equals(new PublicKey(poolInfo.mintA.address));
const swapResult = CurveCalculator.swap(
  amountIn,
  baseIn ? rpcData.baseReserve : rpcData.quoteReserve,
  baseIn ? rpcData.quoteReserve : rpcData.baseReserve,
  rpcData.configInfo!.tradeFeeRate,
);
const minimumAmountOut =
  swapResult.destinationAmountSwapped.muln(1 - slippage * 100).divn(100);

// 3. Construisez et envoyez.
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 à partir de api-v3.raydium.io pour une transaction que vous êtes sur le point de signer — une cotation qui a un bloc de retard peut glisser dans ExceededSlippage au moment du débarquement.

Swap (base-output)

Source : src/cpmm/swapBaseOut.ts

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

const baseIn = false; // B est l'entrée, A est la sortie ? dépend de votre direction
const swapResult = CurveCalculator.swapBaseOutput(
  amountOutWanted,
  rpcData.baseReserve,
  rpcData.quoteReserve,
  rpcData.configInfo!.tradeFeeRate,
);
const maxAmountIn = swapResult.sourceAmountSwapped.muln(1 + slippage * 100).divn(100);

const { execute } = await raydium.cpmm.swap({
  poolInfo,
  poolKeys,
  inputAmount: maxAmountIn,
  fixedOut:    true,
  amountOut:   amountOutWanted,
  baseIn,
  slippage,
  txVersion:   TxVersion.V0,
});

await execute({ sendAndConfirm: true });

Déposer de la liquidité

Source : src/cpmm/deposit.ts

const lpAmount = new BN(100_000);           // montant de mint LP souhaité
const slippage = 0.01;

const { execute } = await raydium.cpmm.addLiquidity({
  poolInfo,
  poolKeys,
  lpAmount,
  slippage,
  baseIn: true,           // cotez du côté mintA
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

Le SDK convertit lpAmount en needed_token_0 et needed_token_1 en utilisant les réserves actuelles du pool, augmente chacun de 1 + slippage pour les arguments maximum_* de l’instruction, et construit les créations d’ATA si nécessaire.

Retirer de la liquidité

Source : src/cpmm/withdraw.ts

const lpAmount = new BN(100_000);           // LP à brûler
const slippage = 0.01;

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 de protocole et de fonds reste contrôlée par l’autorité. Les frais de créateur ont deux chemins : le CollectCreatorFee signé par le créateur existant, et le CollectCreatorFeePermissionless additif, que n’importe quel payeur peut invoquer mais qui ne peut transférer que vers les ATA canoniques du créateur. Le SDK épinglé expose les constructeurs bruts existants :

import {
  makeCollectProtocolFeeInstruction,
  makeCollectFundFeeInstruction,
  makeCollectCreatorFeeInstruction,
} from "@raydium-io/raydium-sdk-v2";

// Les PDA et l'autorité ont été définis à la création du pool ; voir reference/program-addresses
// pour les graines canoniques. Le SDK expose des assistants si vous préférez.

@raydium-io/raydium-sdk-v2@0.2.42-alpha n’expose pas encore de constructeur pour CollectCreatorFeePermissionless. Jusqu’à ce qu’une version du SDK l’ajoute, construisez à partir de l’IDL CPMM mis à jour ou invoquez le programme directement. Ne réutilisez pas makeCollectCreatorFeeInstruction : la nouvelle instruction a un discriminateur différent et remplace les positions du signataire créateur / amm_config par des comptes payer et creator distincts sans signature.

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

const pool = await raydium.cpmm.getRpcPoolInfo(poolId);
console.log("Frais de protocole accumulés token0 :", pool.protocolFeesToken0.toString());
console.log("Frais de protocole accumulés token1 :", pool.protocolFeesToken1.toString());

Squelette CPI Rust

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

// Cargo.toml
// raydium-cp-swap = { git = "https://github.com/raydium-io/raydium-cp-swap" }
// anchor-spl       = "0.30"

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(),
    };
    let cpi_ctx = CpiContext::new(
        ctx.accounts.cpmm_program.to_account_info(),
        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-fort au nom des déposants), remplacez CpiContext::new par CpiContext::new_with_signer et passez vos graines.

Pièges courants

Une courte liste de contrôle avant d’ouvrir un ticket d’assistance :

Mints triés. Si votre PDA poolState dérivé ne correspond pas au pool on-chain, vous avez probablement oublié de trier les mints.
Cotation 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 tokens. Le coffre-fort 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-fort 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 cotation 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 :

Produits

Algorithmes

Démonstrations de code CPMM

Prérequis

Créer un pool CPMM

Swap (base-input)

Swap (base-output)

Déposer de la liquidité

Retirer de la liquidité

Collecter les frais de protocole/fonds/créateur

Squelette CPI Rust

Pièges courants

Où aller ensuite

​Prérequis

​Créer un pool CPMM

​Swap (base-input)

​Swap (base-output)

​Déposer de la liquidité

​Retirer de la liquidité

​Collecter les frais de protocole/fonds/créateur

​Squelette CPI Rust

​Pièges courants

​Où aller ensuite

Prérequis

Créer un pool CPMM

Swap (base-input)

Swap (base-output)

Déposer de la liquidité

Retirer de la liquidité

Collecter les frais de protocole/fonds/créateur

Squelette CPI Rust

Pièges courants

Où aller ensuite