AMM v4 code demos

Version banner. All demos target @raydium-io/raydium-sdk-v2@0.2.64-alpha against Solana mainnet-beta, verified 2026-09-09 — every builder name, parameter name and parameter type below was checked against that release’s source and against raydium-sdk-V2-demo/src/amm. Program ID: 675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8 (see reference/program-addresses).Two traps that bite most first integrations: computeAmountOut’s slippage is a plain number (0.005 = 0.5%), not a Percent; and liquidity.swap requires inputMint as a base58 string.

New-pool creation is not shown here. The Raydium UI no longer offers AMM v4 pool creation — new pairs default to CPMM. The AMM v4 program itself still accepts Initialize2 on-chain; it just isn’t the recommended path. The demos below cover the live-pool operations every integrator still needs: swap, deposit, withdraw.

Setup

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

Fetch a pool by 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 for AMM v4
console.log("Market:", poolKeys.marketId);       // already a base58 string

poolKeys is the struct the instruction builders consume. It carries every AMM v4 account in the order the program expects, plus the legacy market fields that the current program accepts positionally but no longer reads.

Swap (base-in)

import BN from "bn.js";

const amountIn = new BN(1_000_000);            // 1 USDC (6-decimal quote)
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);

The SDK routes AMM v4 swaps through the V2 entrypoints, which do not carry the OpenBook accounts. (After the 2026-07 upgrade, the market accounts are no longer validated even on the legacy v1 path.)

Swap (base-out)

const amountOut = new BN(1_000_000_000);       // 1 SOL (9-decimal base)
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 });

Add liquidity

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" tells the SDK you supplied the exact amountInA and that amountInB should be at most maxAnotherAmount. The pro-rata math runs off the vault balances minus accrued PnL — there is no longer any on-book component to settle first.

Remove liquidity

const lpAmount = new BN(50_000);               // LP to burn

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

await execute({ sendAndConfirm: true });

Slippage mins protect against the pool’s state shifting between your pre-quote and the land time.

Compute-unit / priority fee tuning

Since the OpenBook removal an AMM v4 swap no longer validates any market state, so a V1 SwapBaseIn is markedly cheaper than it used to be — and SwapBaseInV2 (8 accounts, no market placeholders) is cheaper still. Measure your own path rather than budgeting off historical figures, and always pass an explicit compute-unit limit:

const { execute, transaction } = await raydium.liquidity.swap({
  /* ...params... */
  computeBudgetConfig: {
    units: 400_000,
    microLamports: 50_000,       // priority fee per CU
  },
});

If you omit computeBudgetConfig, the SDK may still use its own default; inspect the returned transaction to confirm. See integration-guides/priority-fee-tuning.

Direct Rust CPI

If you must CPI into AMM v4 from your own Anchor program, you will need to model SwapBaseIn’s account list verbatim. A minimal sketch:

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<()> {
    // Instruction discriminator for SwapBaseIn is 9 on 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 does not ship an Anchor crate for CPI. The sketch above uses a manually-constructed Instruction.

The CPI sketch above uses the legacy v1 SwapBaseIn layout (tag 9, 17 accounts) for reading/reproducing existing transactions. Since the 2026-07 upgrade the market accounts are accepted but ignored. For new code, prefer SwapBaseInV2 / SwapBaseOutV2 (tags 16 / 17), which drop the market accounts (and amm_open_orders) entirely — pass only 8 accounts: token_program, amm, amm_authority, the two pool vaults, the two user token accounts, and user_owner.

Pitfalls

Wrong account count on v1 swaps. The legacy SwapBaseIn / SwapBaseOut still require the full 17-account (or 18-account) list — a mismatched count reverts with WrongAccountsNumber. The market accounts’ contents are no longer validated, but you must still occupy their slots. Prefer the V2 entrypoints to avoid this.
Reading raw vault balances. Reserves are now vault-only; subtract accrued PnL (need_take_pnl_*). The SDK quote or api-v3.raydium.io/pools/info/ids handles this for you.
Calling removed instructions. MonitorStep, MigrateToOpenBook, WithdrawSrm, SimulateInfo, AdminCancelOrders, and legacy Initialize / PreInitialize now revert. Use Initialize2 for pool creation; there is no crank to call.
Token-2022 mints. Not supported. An AMM v4 pool cannot be created against a Token-2022 mint; any Token-2022 pair should be on CPMM or CLMM.

Where to go next

products/amm-v4/instructions — the instruction-level surface behind these demos.
user-flows/migrate-amm-v4-to-cpmm — if you are an LP considering migration.
integration-guides/priority-fee-tuning — priority-fee sizing for heavy AMM v4 swaps.

Sources:

Products

Algorithms

Setup

Fetch a pool by id

Swap (base-in)

Swap (base-out)

Add liquidity

Remove liquidity

Compute-unit / priority fee tuning

Direct Rust CPI

Pitfalls

Where to go next

​Setup

​Fetch a pool by id

​Swap (base-in)

​Swap (base-out)

​Add liquidity

​Remove liquidity

​Compute-unit / priority fee tuning

​Direct Rust CPI

​Pitfalls

​Where to go next

Setup

Fetch a pool by id

Swap (base-in)

Swap (base-out)

Add liquidity

Remove liquidity

Compute-unit / priority fee tuning

Direct Rust CPI

Pitfalls

Where to go next