Démonstrations de code AMM v4

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

Bannière de version. Tous les exemples ciblent @raydium-io/raydium-sdk-v2@0.2.64-alpha sur Solana mainnet-beta, vérifiés le 2026-09-09 — chaque nom de constructeur, nom de paramètre et type de paramètre ci-dessous a été contrôlé par rapport aux sources de cette version et à raydium-sdk-V2-demo/src/amm. ID du programme : 675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8 (voir reference/program-addresses).Deux pièges qui touchent la plupart des premières intégrations : le slippage de computeAmountOut est un nombre simple (0.005 = 0.5%), pas un Percent ; et liquidity.swap exige inputMint sous forme de chaîne base58.La création de nouveaux pools n’est pas montrée ici. L’interface Raydium n’offre plus la création de pools AMM v4 — les nouvelles paires utilisent par défaut CPMM. Le programme AMM v4 lui-même accepte toujours Initialize2 on-chain ; ce n’est simplement pas le chemin recommandé. Les démonstrations ci-dessous couvrent les opérations sur pool actif dont chaque intégrateur a encore besoin : swap, dépôt, retrait.

La création de nouveaux pools n’est pas montrée ici. L’interface Raydium n’offre plus la création de pools AMM v4 — les nouvelles paires utilisent par défaut CPMM. Le programme AMM v4 lui-même accepte toujours Initialize2 on-chain ; ce n’est simplement pas le chemin recommandé. Les exemples ci-dessous couvrent les opérations sur pools actifs que chaque intégrateur doit connaître : swap, dépôt, retrait.

Configuration

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

Récupérer un pool par ID

import { PublicKey } from "@solana/web3.js";

// `liquidity.getPoolInfoFromRpc` takes the pool id as a base58 STRING, not a PublicKey.
const poolId = "58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2"; // SOL-USDC, see reference/program-addresses

const data = await raydium.liquidity.getPoolInfoFromRpc({ poolId });
const { poolInfo, poolKeys, poolRpcData } = data;

console.log("Pair:", poolInfo.mintA.symbol, "/", poolInfo.mintB.symbol);
console.log("Version:", poolInfo.version);       // 4 pour AMM v4
console.log("Market:", poolKeys.marketId);       // already a base58 string

poolKeys est la structure que les constructeurs d’instructions consomment. Elle contient tous les comptes AMM v4 dans l’ordre attendu par le programme, plus les champs de marché hérités que le programme actuel accepte positionnellement mais ne lit plus.

Swap (base-in)

import BN from "bn.js";

const amountIn = new BN(1_000_000);            // 1 USDC (quote à 6 décimales)
const inputMint = new PublicKey(poolInfo.mintB.address);  // USDC
const slippage  = 0.005;

const computed = raydium.liquidity.computeAmountOut({
  poolInfo,
  amountIn,
  mintIn: inputMint,
  mintOut: new PublicKey(poolInfo.mintA.address),
  slippage,
});

const { execute } = await raydium.liquidity.swap({
  poolInfo,
  poolKeys,
  amountIn,
  amountOut: computed.minAmountOut,
  fixedSide: "in",
  inputMint: poolInfo.mintB.address,   // a base58 STRING, and it is required
  txVersion: TxVersion.V0,
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Swap tx:", txId);

Le SDK achemine les swaps AMM v4 via les points d’entrée V2, qui ne contiennent pas les comptes OpenBook. (Après la mise à jour de 2026-07, les comptes de marché ne sont plus validés même sur le chemin v1 hérité.)

Swap (base-out)

const amountOut = new BN(1_000_000_000);       // 1 SOL (base à 9 décimales)
const slippage  = 0.005;

const computed = raydium.liquidity.computeAmountIn({
  poolInfo,
  amountOut,
  mintOut: new PublicKey(poolInfo.mintA.address),
  mintIn: new PublicKey(poolInfo.mintB.address),
  slippage,
});

const { execute } = await raydium.liquidity.swap({
  poolInfo,
  poolKeys,
  amountIn: computed.maxAmountIn,
  amountOut,
  fixedSide: "out",
  inputMint: poolInfo.mintB.address,   // base58 string, not a PublicKey
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

Ajouter de la liquidité

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

const amountARaw = new BN(100_000_000);        // 0.1 SOL, in base units

// computePairAmount takes a UI-decimal string (or Decimal) and a Percent —
// not a BN and not a number — and it is synchronous.
const { anotherAmount, maxAnotherAmount, minAnotherAmount } =
  raydium.liquidity.computePairAmount({
    poolInfo,
    amount: "0.1",
    baseIn: true,
    slippage: new Percent(1, 100),
  });

// addLiquidity takes THREE TokenAmounts; otherAmountMin is required.
const { execute } = await raydium.liquidity.addLiquidity({
  poolInfo,
  poolKeys,
  amountInA: new TokenAmount(toToken(poolInfo.mintA), amountARaw),
  amountInB: maxAnotherAmount,
  otherAmountMin: minAnotherAmount,
  fixedSide: "a",
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

fixedSide: "a" indique au SDK que vous avez fourni l’amountInA exact et que amountInB doit être au maximum maxAnotherAmount. Le calcul au prorata s’appuie sur les soldes des vaults moins le PnL accumulé — il n’y a plus aucune composante on-book à régler d’abord.

Retirer de la liquidité

const lpAmount = new BN(50_000);               // LP à brûler

const { execute } = await raydium.liquidity.removeLiquidity({
  poolInfo,
  poolKeys,
  lpAmount,
  baseAmountMin: new BN(0),
  quoteAmountMin: new BN(0),
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

Les minimums de slippage protègent contre les changements d’état du pool entre votre pré-quote et le moment de l’exécution.

Ajustement des unités de calcul et des frais de priorité

Depuis la suppression d’OpenBook, un swap AMM v4 ne valide plus aucun état de marché, de sorte qu’un SwapBaseIn V1 est nettement moins coûteux qu’auparavant — et SwapBaseInV2 (8 comptes, sans espaces réservés de marché) l’est encore moins. Mesurez votre propre chemin plutôt que de budgétiser d’après des chiffres historiques, et passez toujours une limite explicite d’unités de calcul :

const { execute, transaction } = await raydium.liquidity.swap({
  /* ...params... */
  computeBudgetConfig: {
    units: 400_000,
    microLamports: 50_000,       // frais de priorité par CU
  },
});

Si vous omettez computeBudgetConfig, le SDK peut toujours utiliser sa propre valeur par défaut ; inspectez la transaction retournée pour confirmer. Voir integration-guides/priority-fee-tuning.

CPI Rust direct

Si vous devez faire un CPI dans AMM v4 depuis votre propre programme Anchor, vous devrez modéliser la liste de comptes de SwapBaseIn exactement. Un esquisse minimale :

use anchor_lang::prelude::*;
use anchor_lang::solana_program::program::invoke_signed;
use anchor_lang::solana_program::instruction::Instruction;

const AMM_V4_PROGRAM_ID: Pubkey = pubkey!("675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8");

#[derive(Accounts)]
pub struct ProxyAmmV4Swap<'info> {
    /// CHECK:
    pub token_program: UncheckedAccount<'info>,
    #[account(mut)] /// CHECK:
    pub amm:          UncheckedAccount<'info>,
    /// CHECK:
    pub amm_authority: UncheckedAccount<'info>,
    #[account(mut)] /// CHECK:
    pub amm_open_orders: UncheckedAccount<'info>,
    #[account(mut)] /// CHECK:
    pub amm_target_orders: UncheckedAccount<'info>,
    #[account(mut)] /// CHECK:
    pub pool_coin_token_account: UncheckedAccount<'info>,
    #[account(mut)] /// CHECK:
    pub pool_pc_token_account: UncheckedAccount<'info>,
    /// CHECK:
    pub market_program: UncheckedAccount<'info>,
    #[account(mut)] /// CHECK:
    pub market: UncheckedAccount<'info>,
    #[account(mut)] /// CHECK:
    pub market_bids: UncheckedAccount<'info>,
    #[account(mut)] /// CHECK:
    pub market_asks: UncheckedAccount<'info>,
    #[account(mut)] /// CHECK:
    pub market_event_queue: UncheckedAccount<'info>,
    #[account(mut)] /// CHECK:
    pub market_coin_vault: UncheckedAccount<'info>,
    #[account(mut)] /// CHECK:
    pub market_pc_vault: UncheckedAccount<'info>,
    /// CHECK:
    pub market_vault_signer: UncheckedAccount<'info>,
    #[account(mut)] /// CHECK:
    pub user_source: UncheckedAccount<'info>,
    #[account(mut)] /// CHECK:
    pub user_dest: UncheckedAccount<'info>,
    pub user_owner: Signer<'info>,
}

pub fn proxy_swap(
    ctx: Context<ProxyAmmV4Swap>,
    amount_in: u64,
    minimum_amount_out: u64,
) -> Result<()> {
    // Le discriminateur d'instruction pour SwapBaseIn est 9 sur AMM v4.
    let mut data = vec![9u8];
    data.extend_from_slice(&amount_in.to_le_bytes());
    data.extend_from_slice(&minimum_amount_out.to_le_bytes());

    let ix = Instruction {
        program_id: AMM_V4_PROGRAM_ID,
        accounts: vec![
            AccountMeta::new_readonly(ctx.accounts.token_program.key(), false),
            AccountMeta::new(ctx.accounts.amm.key(), false),
            AccountMeta::new_readonly(ctx.accounts.amm_authority.key(), false),
            AccountMeta::new(ctx.accounts.amm_open_orders.key(), false),
            AccountMeta::new(ctx.accounts.amm_target_orders.key(), false),
            AccountMeta::new(ctx.accounts.pool_coin_token_account.key(), false),
            AccountMeta::new(ctx.accounts.pool_pc_token_account.key(), false),
            AccountMeta::new_readonly(ctx.accounts.market_program.key(), false),
            AccountMeta::new(ctx.accounts.market.key(), false),
            AccountMeta::new(ctx.accounts.market_bids.key(), false),
            AccountMeta::new(ctx.accounts.market_asks.key(), false),
            AccountMeta::new(ctx.accounts.market_event_queue.key(), false),
            AccountMeta::new(ctx.accounts.market_coin_vault.key(), false),
            AccountMeta::new(ctx.accounts.market_pc_vault.key(), false),
            AccountMeta::new_readonly(ctx.accounts.market_vault_signer.key(), false),
            AccountMeta::new(ctx.accounts.user_source.key(), false),
            AccountMeta::new(ctx.accounts.user_dest.key(), false),
            AccountMeta::new_readonly(ctx.accounts.user_owner.key(), true),
        ],
        data,
    };
    invoke_signed(&ix, &ctx.accounts.to_account_infos(), &[])?;
    Ok(())
}

AMM v4 ne fournit pas de caisse Anchor pour CPI. L’esquisse ci-dessus utilise une Instruction construite manuellement.

L’esquisse CPI ci-dessus utilise la disposition héritée v1 SwapBaseIn (tag 9, 17 comptes) pour lire/reproduire les transactions existantes. Depuis la mise à jour de 2026-07, les comptes de marché sont acceptés mais ignorés. Pour le nouveau code, préférez SwapBaseInV2 / SwapBaseOutV2 (tags 16 / 17), qui suppriment les comptes de marché (et amm_open_orders) entièrement — passez seulement 8 comptes : token_program, amm, amm_authority, les deux coffres du pool, les deux comptes de tokens utilisateur, et user_owner.

Pièges

Mauvais nombre de comptes sur les swaps v1. Les anciens SwapBaseIn / SwapBaseOut nécessitent toujours la liste complète de 17 comptes (ou 18 comptes) — un nombre mal assorti revient avec WrongAccountsNumber. Le contenu des comptes de marché n’est plus validé, mais vous devez toujours occuper leurs emplacements. Préférez les points d’entrée V2 pour éviter cela.
Lecture des soldes bruts des coffres. Les réserves sont maintenant réservées aux coffres ; soustrayez le PnL accumulé (need_take_pnl_*). Le devis du SDK ou api-v3.raydium.io/pools/info/ids gère cela pour vous.
Appel d’instructions supprimées. MonitorStep, MigrateToOpenBook, WithdrawSrm, SimulateInfo, AdminCancelOrders, et les anciens Initialize / PreInitialize reviennent maintenant. Utilisez Initialize2 pour la création de pools ; il n’y a pas de crank à appeler.
Mints Token-2022. Non supportés. Un pool AMM v4 ne peut pas être créé contre un mint Token-2022 ; toute paire Token-2022 doit être sur CPMM ou CLMM.

Où aller ensuite

products/amm-v4/instructions — la surface au niveau des instructions derrière ces exemples.
user-flows/migrate-amm-v4-to-cpmm — si vous êtes un LP envisageant une migration.
integration-guides/priority-fee-tuning — dimensionnement des frais de priorité pour les swaps AMM v4 lourds.

Sources :

Produits

Algorithmes

Démonstrations de code AMM v4

Configuration

Récupérer un pool par ID

Swap (base-in)

Swap (base-out)

Ajouter de la liquidité

Retirer de la liquidité

Ajustement des unités de calcul et des frais de priorité

CPI Rust direct

Pièges

Où aller ensuite

​Configuration

​Récupérer un pool par ID

​Swap (base-in)

​Swap (base-out)

​Ajouter de la liquidité

​Retirer de la liquidité

​Ajustement des unités de calcul et des frais de priorité

​CPI Rust direct

​Pièges

​Où aller ensuite

Configuration

Récupérer un pool par ID

Swap (base-in)

Swap (base-out)

Ajouter de la liquidité

Retirer de la liquidité

Ajustement des unités de calcul et des frais de priorité

CPI Rust direct

Pièges

Où aller ensuite