Các ví dụ mã CPMM

Các ví dụ TypeScript từ đầu đến cuối cho mọi hoạt động CPMM — tạo pool, swap, gửi, rút, thu thập phí — cộng với một bộ khung CPI Rust tối thiểu.

Trang này được dịch tự động bằng AI. Phiên bản tiếng Anh là bản chính thức.

Xem bản tiếng Anh →

Biểu ngữ phiên bản. Tất cả các ví dụ TypeScript nhắm mục tiêu @raydium-io/raydium-sdk-v2@0.2.64-alpha; chúng được thực thi lần cuối cùng với 0.2.42-alpha (2026-04) và chữ ký gọi của chúng được kiểm tra lại với nguồn 0.2.64-alpha vào ngày 2026-09-09, trên Solana mainnet-beta. Bộ khung CPI Rust nhắm mục tiêu raydium-cp-swap trên master, Anchor 1.0.2. ID chương trình được lấy thông qua các hằng số từ reference/program-addresses.

​

Điều kiện tiên quyết

npm install @raydium-io/raydium-sdk-v2 @solana/web3.js @solana/spl-token bn.js decimal.js

Mỗi ví dụ trên trang này phản ánh một tệp trong raydium-sdk-V2-demo/src/cpmm; liên kết GitHub nằm bên cạnh mỗi phần. Bootstrap tuân theo config.ts.template của kho lưu trữ demo (nguồn):

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

Instance Raydium là facade của SDK — mỗi ví dụ dưới đây sử dụng nó. Raydium.load là async vì nó tải danh sách token theo mặc định; truyền disableLoadToken: true để bỏ qua lần tìm nạp đó. Kiểm tra tính năng khả dụng đã bị bỏ qua trừ khi bạn truyền disableFeatureCheck: false. Các cấu hình phí được tìm nạp một cách lười biếng khi sử dụng lần đầu tiên thông qua raydium.api.getCpmmConfigs().

​

Tạo một pool CPMM

Nguồn: 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";
// (Nếu bạn cần mọi PDA pool cùng một lúc, helper được xuất là `getCreatePoolKeys`.
//  Không có `getCpmmPdas`.)

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

// 1. Chọn một cấu hình phí. index=0 là tầng 0,25%.
const feeConfigs = await raydium.api.getCpmmConfigs();
const feeConfig  = feeConfigs.find((c) => c.index === 0)!;

// 2. Lấy siêu dữ liệu mint để SDK có thể xử lý các tiện ích mở rộng Token-2022.
const mintAInfo = await raydium.token.getTokenInfo(mintA);
const mintBInfo = await raydium.token.getTokenInfo(mintB);

// 3. Xây dựng giao dịch.
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 (giả sử 9 chữ số thập phân)
  mintBAmount:     new BN(   160_000_000),  // 160 USDC (tại 160/SOL)
  startTime:       new BN(0),               // mở ngay lập tức
  feeConfig,
  associatedOnly:  false,
  ownerInfo:       { useSOLBalance: true },
  txVersion:       TxVersion.V0,
});

const { txId } = await execute({ sendAndConfirm: true });
console.log("Pool được tạo tại", extInfo.address.poolId.toBase58());
console.log("Tx:", txId);

Một vài điều mà SDK xử lý một cách im lặng:

• Sắp xếp các mint theo thứ tự token0/token1 trước khi lấy PDA.
• Trả phí create_pool_fee một lần cho poolFeeAccount.
• Tạo các tài khoản token được liên kết của người gọi nếu bị thiếu.
• Chọn chương trình token phù hợp (SPL Token so với Token-2022) cho mỗi bên.

Sau khi xác nhận, bạn có thể tìm nạp trạng thái pool trực tiếp với:

// getPoolInfoFromRpc lấy một chuỗi base58 vị trí, không phải PublicKey và không phải một đối tượng.
const { poolKeys, poolInfo, rpcData } = await raydium.cpmm.getPoolInfoFromRpc(
  extInfo.address.poolId.toBase58(),
);

​

Swap (base-input)

Nguồn: src/cpmm/swap.ts

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

const POOL_ID = "<POOL_ID>";   // chuỗi base58

// 1. Tải trạng thái pool hiện tại trực tiếp từ RPC (không từ 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. Báo giá cục bộ. CurveCalculator phản ánh toán học trên chuỗi, bao gồm
//    phí chuyển Token-2022 ở cả hai bên. Tất cả tám đối số đều bắt buộc.
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,
);
// Các trường swapResult là inputAmount / outputAmount / tradeFee / protocolFee /
// fundFee / creatorFee / newInputVaultAmount / newOutputVaultAmount.
// Không có destinationAmountSwapped hoặc sourceAmountSwapped.

// 3. Xây dựng và gửi. Truyền `slippage` ở đây là cách áp dụng giới hạn —
//    không cần số học minimum-out thủ công.
const { execute } = await raydium.cpmm.swap({
  poolInfo,
  poolKeys,
  inputAmount: amountIn,
  swapResult,
  slippage,
  baseIn,
  txVersion: TxVersion.V0,
});

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

Lưu ý: SDK luôn tìm nạp lại trạng thái pool từ RPC bên trong getPoolInfoFromRpc. Không báo giá từ api-v3.raydium.io cho một giao dịch mà bạn sắp ký — một báo giá cũ một khối có thể trượt vào ExceededSlippage tại thời điểm hạ cánh.

​

Swap (base-output)

Nguồn: src/cpmm/swapBaseOut.ts

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

const baseIn = false; // false → mintB là bên đầu vào
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 là đầu vào cần thiết; không có sourceAmountSwapped.

const { execute } = await raydium.cpmm.swap({
  poolInfo,
  poolKeys,
  inputAmount: new BN(0),   // không sử dụng khi fixedOut — số tiền đến từ swapResult
  fixedOut:    true,
  swapResult,               // bắt buộc, và nó mang theo số tiền đầu ra mục tiêu
  baseIn,
  slippage,
  txVersion:   TxVersion.V0,
});

await execute({ sendAndConfirm: true });

​

Gửi thanh khoản

Nguồn: src/cpmm/deposit.ts

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

// addLiquidity được điều khiển bởi một số tiền INPUT, không phải một số tiền 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);   // một Percent, không phải một số

const { execute } = await raydium.cpmm.addLiquidity({
  poolInfo,
  poolKeys,
  inputAmount,
  baseIn: true,           // inputAmount được tính bằng mintA
  slippage,
  txVersion: TxVersion.V0,
});

await execute({ sendAndConfirm: true });

SDK lấy số tiền được ghép nối từ dự trữ hiện tại của pool, tăng mỗi bên theo slippage cho các đối số maximum_* của hướng dẫn, và xây dựng các tạo ATA nếu cần thiết. raydium.cpmm.computePairAmount({ ... }) trả về các số giống nhau nếu bạn muốn chúng để xem trước UI.

​

Rút thanh khoản

Nguồn: src/cpmm/withdraw.ts

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

const lpAmount = new BN(100_000);           // LP để đốt
const slippage = new Percent(1, 100);       // một Percent, không phải một số

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

await execute({ sendAndConfirm: true });

​

Thu thập phí protocol/fund/creator

Nguồn: src/cpmm/collectCreatorFee.ts, src/cpmm/collectAllCreatorFee.ts

Thu thập protocol và fund vẫn được kiểm soát bởi quyền hạn. Phí creator có hai cách: CollectCreatorFee được ký bởi creator, và CollectCreatorFeePermissionless có thể được gọi bởi bất kỳ người trả phí nào nhưng chỉ có thể chuyển đến các ATA chính thức của creator. Phiên bản 0.2.64-alpha cung cấp các builder ở cấp module cho cả hai cách của creator:

// creator-signed
const { execute } = await raydium.cpmm.collectCreatorFees({
  poolInfo,
  poolKeys,
  txVersion: TxVersion.V0,
});

// permissionless — bất kỳ người trả phí nào; tiền thu được chuyển đến các ATA chính thức của creator
const { execute } = await raydium.cpmm.collectCreatorFeesPermissionless({
  poolInfo,
  poolKeys,
  txVersion: TxVersion.V0,
});

// nhiều pool cùng lúc, creator-signed
await raydium.cpmm.collectMultiCreatorFees({ poolInfoList, txVersion: TxVersion.V0 });

Cả hai instruction creator đã thay đổi danh sách tài khoản trong bản nâng cấp chương trình ngày 2026-09-19. Mỗi cái hiện nhận một PDA creator_fee_share tại ["creator_fee_share", creator, ammConfig], và cái permissionless cũng nhận amm_config — cả hai được thêm vào sau system_program thay vì được chèn vào, vì vậy các tài khoản đã có giữ nguyên vị trí của chúng. Một builder được ghim vào phiên bản SDK trước bản nâng cấp sẽ phát ra danh sách ngắn hơn và giao dịch bị từ chối vì thiếu tài khoản. Hãy kiểm tra rằng phiên bản bạn cài đặt có chứa các tài khoản mới trước khi sử dụng các helper này với chương trình đã nâng cấp, và làm mới IDL nếu bạn tạo client từ nó.

Truyền PDA là bắt buộc ngay cả khi nó chưa bao giờ được tạo — hãy dẫn xuất nó và truyền nó; chương trình sẽ quay lại AmmConfig.creator_fee_share_rate khi tài khoản trống.

Hai instruction creator có các discriminator và account layout khác nhau — cái permissionless thay thế người ký creator bằng một payer riêng biệt và một creator không ký. Hãy sử dụng builder phù hợp thay vì trao đổi tài khoản thủ công trên cái kia.

Không có builder phí protocol hoặc fund trong SDK (makeCollectProtocolFeeInstruction và makeCollectFundFeeInstruction không tồn tại dưới bất kỳ tên nào) — đó là các đường dẫn admin, cũng như CreateCreatorFeeShare / CloseCreatorFeeShare, cũng không có builder. Các builder instruction cấp thấp thực sự tồn tại là collectCpFeeInstruction, makeCollectCreatorFeeInstruction và collectCreatorFeePermissionlessInInstruction.

Off-chain, bạn có thể đọc phí tích lũy trực tiếp từ PoolState:

const pool = await raydium.cpmm.getRpcPoolInfo(POOL_ID);   // base58 string
console.log("Accrued protocol fee mintA:", pool.protocolFeesMintA.toString());
console.log("Accrued protocol fee mintB:", pool.protocolFeesMintB.toString());
// Các trường CpmmPoolInfoLayout là protocolFeesMintA/B, fundFeesMintA/B và
// creatorFeesMintA/B — không có trường ...Token0/...Token1 nào.
//
// creatorFeesMintA/B là tích lũy *brutto*. Creator nhận được nó trừ đi phần chia sẻ
// protocol được giải quyết tại thời điểm thu thập; protocolFeesMintA/B nhận được phần
// đó, vì vậy nó cũng tăng lên khi thu thập phí creator, không chỉ khi swap.
// Xem products/cpmm/fees#protocol-share-of-the-creator-fee.

​

Bộ xương CPI Rust

Nếu bạn muốn gọi CPMM từ chương trình Anchor của riêng mình — ví dụ, một vault thực hiện swap thay mặt cho những người gửi tiền của nó — ngữ cảnh CPI trông như thế này. Thứ tự tài khoản tuân theo products/cpmm/instructions.

// Cargo.toml — `master` ghim 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"   // phải khớp với những gì raydium-cp-swap ghim
// anchor-spl       = "=1.0.2"
//
// Tính năng `cpi` là bắt buộc — mô-đun `raydium_cp_swap::cpi` chỉ tồn tại
// dưới nó. Mẫu CLMM trong products/clmm/code-demos ghim cùng
// =1.0.2 trên `master` của riêng nó, vì vậy hai cái có thể chia sẻ một chương trình.

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: validated by the CPMM program
    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: ring buffer
    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 nhận Pubkey của chương trình ở đây, không phải AccountInfo của nó.
    let cpi_ctx = CpiContext::new(
        *ctx.accounts.cpmm_program.key,
        cpi_accounts,
    );
    cpi::swap_base_input(cpi_ctx, amount_in, minimum_amount_out)
}

Nếu CPI của bạn ký như một PDA (ví dụ, bạn quản lý một vault thay mặt cho những người gửi tiền), hãy hoán đổi CpiContext::new với CpiContext::new_with_signer và truyền các seed của bạn.

​

Những lỗi thường gặp

Một danh sách kiểm tra ngắn trước khi mở một vé hỗ trợ:

• Sorted mints. Nếu poolState PDA dẫn xuất của bạn không khớp với pool trên chuỗi, bạn có thể đã quên sắp xếp các mint.
• Stale API quote. Không bao giờ truyền giá trị reserve từ api-v3.raydium.io vào CurveCalculator.swap. Hãy lấy từ một RPC.
• Wrong token program. Vault của một mint Token-2022 được sở hữu bởi chương trình Token-2022, không phải bởi SPL Token. Luôn sử dụng các trường token_0_program / token_1_program của pool.
• Slippage under-denominated for transfer-fee mints. Nếu một trong hai bên của pool là một mint Token-2022 transfer-fee, minimum_amount_out của bạn phải được tính bằng những gì người dùng thực sự nhận được, không phải những gì vault gửi.
• NotApproved on a swap. Kiểm tra PoolState.status — admin có thể đã tạm dừng swap trên pool đó. Xem products/cpmm/instructions để biết bitmask trạng thái.

​

Bước tiếp theo

• sdk-api/typescript-sdk — tham chiếu SDK đầy đủ.
• sdk-api/rest-api — các endpoint quote và pool-metadata.
• user-flows/create-cpmm-pool — hướng dẫn không có mã của cùng một luồng.
• integration-guides/aggregator — nếu bạn đang định tuyến CPMM như một phần của đường dẫn multi-hop.

Nguồn:

• Raydium SDK v2 — @raydium-io/raydium-sdk-v2
• Raydium SDK v2 demos — raydium-sdk-v2-demo
• raydium-io/raydium-cp-swap