Demo kode CPMM

Contoh TypeScript end-to-end untuk setiap operasi CPMM — buat pool, swap, deposit, withdraw, kumpulkan biaya — plus skeleton CPI Rust minimal.

Halaman ini diterjemahkan secara otomatis oleh AI. Versi bahasa Inggris adalah acuan resmi.

Lihat versi bahasa Inggris →

Spanduk versi. Semua demo TypeScript menargetkan @raydium-io/raydium-sdk-v2@0.2.64-alpha; terakhir dijalankan terhadap 0.2.42-alpha (2026-04) dan tanda tangan panggilan mereka diperiksa ulang terhadap sumber 0.2.64-alpha pada 2026-09-09, terhadap Solana mainnet-beta. Skeleton CPI Rust menargetkan raydium-cp-swap di master, Anchor 1.0.2. ID program ditarik melalui konstanta dari reference/program-addresses.

​

Prasyarat

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

Setiap demo di halaman ini mencerminkan file di raydium-sdk-V2-demo/src/cpmm; tautan GitHub berada di sebelah setiap bagian. Bootstrap mengikuti config.ts.template repo demo (sumber):

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 adalah facade SDK — setiap demo di bawah menggunakannya. Raydium.load bersifat async karena memuat daftar token secara default; teruskan disableLoadToken: true untuk melewati pengambilan tersebut. Pemeriksaan fitur ketersediaan sudah dilewati kecuali Anda melewati disableFeatureCheck: false. Konfigurasi biaya diambil secara lazy pada penggunaan pertama melalui raydium.api.getCpmmConfigs().

​

Buat pool CPMM

Sumber: 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";
// (Jika Anda memerlukan setiap PDA pool sekaligus, helper yang diekspor adalah `getCreatePoolKeys`.
//  Tidak ada `getCpmmPdas`.)

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

// 1. Pilih konfigurasi biaya. index=0 adalah tier 0,25%.
const feeConfigs = await raydium.api.getCpmmConfigs();
const feeConfig  = feeConfigs.find((c) => c.index === 0)!;

// 2. Tarik metadata mint sehingga SDK dapat menangani ekstensi Token-2022.
const mintAInfo = await raydium.token.getTokenInfo(mintA);
const mintBInfo = await raydium.token.getTokenInfo(mintB);

// 3. Bangun transaksi.
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 (asumsikan 9 desimal)
  mintBAmount:     new BN(   160_000_000),  // 160 USDC (pada 160/SOL)
  startTime:       new BN(0),               // buka segera
  feeConfig,
  associatedOnly:  false,
  ownerInfo:       { useSOLBalance: true },
  txVersion:       TxVersion.V0,
});

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

Beberapa hal yang SDK tangani secara diam-diam:

• Mengurutkan mint ke dalam urutan token0/token1 sebelum menurunkan PDA.
• Membayar create_pool_fee sekali ke poolFeeAccount.
• Membuat akun token terkait pemanggil jika hilang.
• Memilih program token yang tepat (SPL Token vs Token-2022) per sisi.

Setelah konfirmasi Anda dapat mengambil status pool langsung dengan:

// getPoolInfoFromRpc mengambil string base58 posisional, bukan PublicKey dan bukan objek.
const { poolKeys, poolInfo, rpcData } = await raydium.cpmm.getPoolInfoFromRpc(
  extInfo.address.poolId.toBase58(),
);

​

Swap (base-input)

Sumber: src/cpmm/swap.ts

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

const POOL_ID = "<POOL_ID>";   // string base58

// 1. Muat status pool saat ini langsung dari RPC (bukan dari 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. Kutip secara lokal. CurveCalculator mencerminkan matematika on-chain, termasuk
//    biaya transfer Token-2022 di kedua sisi. Semua delapan argumen diperlukan.
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,
);
// Bidang swapResult adalah inputAmount / outputAmount / tradeFee / protocolFee /
// fundFee / creatorFee / newInputVaultAmount / newOutputVaultAmount.
// Tidak ada destinationAmountSwapped atau sourceAmountSwapped.

// 3. Bangun dan kirim. Melewati `slippage` di sini adalah yang menerapkan batas —
//    tidak perlu aritmatika minimum-out manual.
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);

Catatan: SDK selalu mengambil ulang status pool dari RPC di dalam getPoolInfoFromRpc. Jangan kutip dari api-v3.raydium.io untuk transaksi yang akan Anda tandatangani — kutipan yang sudah usang satu blok dapat tergelincir ke ExceededSlippage saat waktu pendaratan.

​

Swap (base-output)

Sumber: src/cpmm/swapBaseOut.ts

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

const baseIn = false; // false → mintB adalah sisi input
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 adalah input yang diperlukan; tidak ada sourceAmountSwapped.

const { execute } = await raydium.cpmm.swap({
  poolInfo,
  poolKeys,
  inputAmount: new BN(0),   // tidak digunakan saat fixedOut — jumlah berasal dari swapResult
  fixedOut:    true,
  swapResult,               // diperlukan, dan membawa jumlah output target
  baseIn,
  slippage,
  txVersion:   TxVersion.V0,
});

await execute({ sendAndConfirm: true });

​

Deposit likuiditas

Sumber: src/cpmm/deposit.ts

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

// addLiquidity didorong oleh jumlah INPUT, bukan jumlah 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);   // Percent, bukan angka

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

await execute({ sendAndConfirm: true });

SDK menurunkan jumlah berpasangan dari cadangan pool saat ini, menaikkan setiap sisi dengan slippage untuk argumen maximum_* instruksi, dan membangun kreasi ATA jika diperlukan. raydium.cpmm.computePairAmount({ ... }) mengembalikan angka yang sama jika Anda menginginkannya untuk pratinjau UI.

​

Withdraw likuiditas

Sumber: src/cpmm/withdraw.ts

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

const lpAmount = new BN(100_000);           // LP untuk dibakar
const slippage = new Percent(1, 100);       // Percent, bukan angka

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

await execute({ sendAndConfirm: true });

​

Kumpulkan biaya protokol/dana/kreator

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

Pengumpulan protokol dan dana tetap dibatasi oleh otoritas. Biaya kreator memiliki dua jalur: CollectCreatorFee yang ditandatangani kreator, dan CollectCreatorFeePermissionless yang aditif, yang dapat dipanggil oleh pembayar mana pun tetapi hanya dapat mentransfer ke ATA kanonik kreator. 0.2.64-alpha dilengkapi dengan builder tingkat modul untuk kedua jalur kreator:

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

// permissionless — any payer; proceeds go to the creator's canonical ATAs
const { execute } = await raydium.cpmm.collectCreatorFeesPermissionless({
  poolInfo,
  poolKeys,
  txVersion: TxVersion.V0,
});

// several pools at once, creator-signed
await raydium.cpmm.collectMultiCreatorFees({ poolInfoList, txVersion: TxVersion.V0 });

Kedua instruksi kreator mengubah daftar akun mereka dalam upgrade program 2026-09-19. Masing-masing sekarang mengambil PDA creator_fee_share di ["creator_fee_share", creator, ammConfig], dan yang permissionless juga mengambil amm_config — keduanya ditambahkan setelah system_program daripada disisipkan, sehingga akun yang sudah ada tetap mempertahankan posisi mereka. Builder yang dikunci ke rilis SDK sebelum upgrade memancarkan daftar yang lebih pendek dan transaksi ditolak karena akun yang hilang. Pastikan versi yang Anda instal membawa akun baru sebelum menggunakan helper ini terhadap program yang diupgrade, dan segarkan IDL jika Anda membuat klien darinya.

Melewatkan PDA adalah wajib bahkan ketika belum pernah dibuat — turunkan dan lewatkan; program kembali ke AmmConfig.creator_fee_share_rate ketika akun kosong.

Kedua instruksi kreator memiliki discriminator dan tata letak akun yang berbeda — yang permissionless menggantikan penandatangan kreator dengan payer terpisah dan creator yang tidak menandatangani. Gunakan builder yang cocok daripada menukar akun secara manual di yang lain.

Tidak ada builder biaya protokol atau dana dalam SDK (makeCollectProtocolFeeInstruction dan makeCollectFundFeeInstruction tidak ada dengan nama apa pun) — itu adalah jalur admin, begitu juga CreateCreatorFeeShare / CloseCreatorFeeShare, yang juga tidak memiliki builder. Builder instruksi tingkat rendah yang ada adalah collectCpFeeInstruction, makeCollectCreatorFeeInstruction dan collectCreatorFeePermissionlessInInstruction.

Off-chain Anda dapat membaca biaya yang terkumpul langsung dari 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());
// The CpmmPoolInfoLayout fields are protocolFeesMintA/B, fundFeesMintA/B and
// creatorFeesMintA/B — there are no ...Token0/...Token1 fields.
//
// creatorFeesMintA/B is the *gross* accrual. The creator receives it minus the
// protocol share resolved at collection time; protocolFeesMintA/B receives that
// share, so it also grows on creator-fee collections, not only on swaps.
// See products/cpmm/fees#protocol-share-of-the-creator-fee.

​

Kerangka CPI Rust

Jika Anda ingin memanggil CPMM dari program Anchor Anda sendiri — misalnya, vault yang melakukan swap atas nama deposan Anda — konteks CPI terlihat seperti ini. Urutan akun mengikuti products/cpmm/instructions.

// Cargo.toml — `master` pins 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"   // must match what raydium-cp-swap pins
// anchor-spl       = "=1.0.2"
//
// The `cpi` feature is required — the `raydium_cp_swap::cpi` module only exists
// under it. The CLMM sample in products/clmm/code-demos pins the same
// =1.0.2 on its own `master`, so the two can share a program.

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 takes the program's Pubkey here, not its AccountInfo.
    let cpi_ctx = CpiContext::new(
        *ctx.accounts.cpmm_program.key,
        cpi_accounts,
    );
    cpi::swap_base_input(cpi_ctx, amount_in, minimum_amount_out)
}

Jika CPI Anda menandatangani sebagai PDA (misalnya, Anda mengelola vault atas nama deposan), tukar CpiContext::new dengan CpiContext::new_with_signer dan lewatkan seed Anda.

​

Jebakan umum

Daftar periksa singkat sebelum membuka tiket dukungan:

• Mint yang diurutkan. Jika PDA poolState yang Anda turunkan tidak cocok dengan pool on-chain, Anda mungkin lupa mengurutkan mint.
• Kutipan API yang ketinggalan zaman. Jangan pernah meneruskan nilai cadangan dari api-v3.raydium.io ke CurveCalculator.swap. Ambil dari RPC.
• Program token yang salah. Vault mint Token-2022 dimiliki oleh program Token-2022, bukan SPL Token. Selalu gunakan bidang token_0_program / token_1_program pool.
• Slippage yang kurang denominasi untuk mint biaya transfer. Jika salah satu sisi pool adalah mint biaya transfer Token-2022, minimum_amount_out Anda harus denominasi dalam apa yang benar-benar diterima pengguna, bukan dalam apa yang dikirim vault.
• NotApproved pada swap. Periksa PoolState.status — admin mungkin telah menjeda swap di pool itu. Lihat products/cpmm/instructions untuk bitmask status.

​

Ke mana selanjutnya

• sdk-api/typescript-sdk — referensi SDK lengkap.
• sdk-api/rest-api — endpoint kutipan dan metadata pool.
• user-flows/create-cpmm-pool — panduan non-kode alur yang sama.
• integration-guides/aggregator — jika Anda merutekan CPMM sebagai bagian dari jalur multi-hop.

Sumber:

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