Rust CPI

Memanggil program Raydium dari program Solana lain melalui CPI: konstruksi daftar akun, signer seeds, remaining accounts, dan propagasi error untuk CPMM, CLMM, dan LaunchLab. AMM v4 (tanpa crate Anchor) dan Farm v6 dibahas di bagian tersendiri.

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

Lihat versi bahasa Inggris →

CPI (“cross-program invocation”) adalah mekanisme yang memungkinkan satu program Solana memanggil program lain. Sebagian besar program Raydium dilengkapi dengan crate wrapper CPI Anchor yang membuat call site terlihat seperti pemanggilan fungsi yang diketik, dengan struct akun yang memiliki nama field yang divalidasi dan helper cpi::<ix>(). Halaman ini mendokumentasikan pola umum sekali, kemudian perbedaan per-program. Untuk TypeScript yang dapat dijalankan, lihat halaman code-demos di setiap bab produk.

​

Pola mana yang berlaku untuk program mana

Program	Berbasis Anchor	Crate	Di mana
CPMM	Ya	raydium-cp-swap (repo publik; path use Rust adalah raydium_cp_swap)	Pola umum, contoh yang dikerjakan
CLMM	Ya	raydium-clmm (repo publik; path use Rust adalah raydium_clmm)	Menerapkan pola: CLMM
LaunchLab	Ya	nama crate tidak dikonfirmasi; sumber program tertutup, tetapi identifier metadata internal IDL on-chain adalah raydium_launchpad, nama teknis bukan nama produk (lihat caveat di Menerapkan pola: LaunchLab)	Menerapkan pola: LaunchLab
Farm v6	Tidak dikonfirmasi; tidak ada IDL publik atau sumber yang ditemukan (lihat peringatan di Farm v6)	n/a	Farm v6
AMM v4	Tidak, mendahului Anchor tanpa crate CPI	tidak ada	AMM v4

Jika Anda mengintegrasikan CPMM, CLMM, atau LaunchLab, baca pola umum terlebih dahulu, kemudian lompat ke bagian program Anda untuk daftar akun dan perbedaan apa pun. Farm v6 dan AMM v4 cukup berbeda sehingga layak membaca bagian mereka secara mandiri.

​

Dependensi Cargo

# Kedua crate CPI publik Raydium menetapkan Anchor =1.0.2 di `master`,
# jadi satu program dapat bergantung pada salah satu atau keduanya — lihat tabel di bawah.
[dependencies]
anchor-lang     = "=1.0.2"
anchor-spl      = "=1.0.2"
raydium-cp-swap = { git = "https://github.com/raydium-io/raydium-cp-swap", branch = "master", features = ["cpi"] }
raydium-clmm    = { git = "https://github.com/raydium-io/raydium-clmm",    branch = "master", features = ["cpi"] }
# CATATAN: jika Anda menetapkan `rev` yang lebih lama dari sebelum upgrade Anchor 1.0 (CPMM 2026-09-09,
# CLMM 2026-09-30), rev tersebut menetapkan anchor-lang 0.32.1; gunakan =0.32.1 dan API CpiContext 0.3x
# — dan kemudian hanya salah satu dari dua crate pada satu waktu.
# LaunchLab: sumber program tidak tersedia untuk publik (lihat reference/program-addresses).
# Tidak ada dependensi git untuk ditunjuk. Hasilkan binding CPI dari IDL yang dipublikasikan
# sebagai gantinya. Lihat "Menerapkan pola: LaunchLab" di bawah.
# AMM v4 tidak memiliki crate CPI Anchor yang dipublikasikan; lihat bagian tersendirinya.

Kunci dependensi harus cocok dengan [package] name repo target dengan tepat, termasuk tanda hubung. Cargo tidak menganggap raydium_cp_swap setara dengan raydium-cp-swap saat menyelesaikan dependensi git.

branch = "master" melacak sumber terbaru yang dipublikasikan; tetapkan ke rev = "<commit>" tertentu jika Anda memerlukan build yang dapat direproduksi. Ini direkomendasikan setelah Anda melampaui prototyping, karena perubahan tata letak akun upstream di master akan memecahkan build Anda tanpa peringatan sebelumnya.

Flag fitur cpi membuat crate dikompilasi ke hanya permukaan CPI (struct akun + invoker) daripada program lengkap, sehingga binary Anda tetap kecil.

anchor-lang / anchor-spl harus cocok dengan apa yang ditetapkan crate target:

Crate	Menetapkan anchor-lang / anchor-spl
raydium-cp-swap (master)	=1.0.2, dari upgrade 2026-09-09
raydium-clmm (master)	=1.0.2, dari upgrade 2026-09-30
Salah satu crate di rev sebelum upgrade-nya	0.32.1

Ambil kedua crate dari baris Anchor yang sama. Kedua branch master menetapkan =1.0.2, jadi satu program dapat CPI ke CPMM dan CLMM dari satu crate. Mencampur baris memecahkan build: misalnya, raydium-cp-swap di master dengan raydium-clmm ditetapkan ke rev dari sebelum upgrade Anchor 1.0-nya. Cargo harus menautkan dua salinan trait Anchor yang tidak kompatibel ke dalam satu binary. Jika Anda terjebak pada pasangan campuran, pisahkan program menjadi dua, atau lepaskan crate CPI yang diketik untuk satu sisi dan encode manual instruksi itu (pola yang ditunjukkan untuk AMM v4 bekerja untuk program apa pun).

Anchor 1.0 mengubah dua hal yang setiap call site CPI sentuh. Jika Anda memindahkan integrasi yang berfungsi dari 0.3x:

• CpiContext::new mengambil Pubkey, bukan AccountInfo. CpiContext::new(ctx.accounts.cpmm_program.to_account_info(), accts) menjadi CpiContext::new(*ctx.accounts.cpmm_program.key, accts). Sama untuk new_with_signer. Field struct sekarang program_id: Pubkey.
• Context memiliki satu lifetime, bukan empat. Context<'_, '_, 'info, 'info, MyProxySwap<'info>> menjadi Context<'info, MyProxySwap<'info>>.

Di sisi klien, RequestBuilder::instructions() milik anchor-client sekarang mengembalikan Vec<Instruction> daripada Result<Vec<Instruction>> (lepaskan ?), dan CommitmentConfig pindah dari solana-sdk — ambil dari anchor_client sebagai gantinya. spl-associated-token-account 8.0 me-re-export helper-nya dari crate spl-associated-token-account-interface yang baru. get_associated_token_address dan ID masih dapat dijangkau di root crate (spl_associated_token_account::{get_associated_token_address, ID}), tetapi helper alamat sudah usang di sana — lebih suka bergantung pada spl-associated-token-account-interface secara langsung dan mengimpor spl_associated_token_account_interface::address::get_associated_token_address dan spl_associated_token_account_interface::program::ID. Perhatikan ::address dan ::program adalah modul dari crate interface; spl_associated_token_account::address::… tidak terselesaikan.

Untuk contoh CPI yang berfungsi yang menghubungkan struct akun end-to-end, lihat raydium-io/raydium-cpi-example (mencakup AMM v4, CPMM, dan CLMM). Branch terbarunya adalah anchor-0.31.0 — belum ada branch Anchor 1.x, jadi perlakukan repo itu sebagai referensi untuk wiring struct akun, bukan untuk pin versi yang halaman ini wajibkan.

​

Pola CPI Anchor umum

Bagian ini menjelaskan CPMM dari awal hingga akhir sebagai contoh kerja: struct Accounts, CpiContext, cpi::<ix>(). CLMM mengikuti bentuk yang identik, dengan daftar akun berbeda dan persyaratan remaining-accounts. LaunchLab mengikuti mekanika yang sama tetapi daftar akunnya membawa beberapa akun tanpa padanan CPMM/CLMM (global_config, platform_config, event_authority, program), jadi perlakukan sebagai pola yang sama, bukan bentuk yang sama. Lihat bagian masing-masing program daripada mengasumsikan daftar akun walkthrough ini berlaku langsung.

​

Konstruksi daftar akun

Setiap CPI Raydium memerlukan struct Accounts dalam program pemanggil. Bidangnya adalah akun apa pun yang Anda butuhkan untuk instruksi Anda, dengan validator tingkat bidang; urutan deklarasi mereka tidak harus cocok dengan urutan akun instruksi Raydium sendiri, karena klien yang dihasilkan IDL Anda menanganinya berdasarkan nama, bukan posisi:

use anchor_lang::prelude::*;
use anchor_spl::token::{Token, TokenAccount, Mint};

#[derive(Accounts)]
pub struct MyProxySwap<'info> {
    #[account(mut)]
    pub user: Signer<'info>,

    /// CHECK: validated by CPMM
    #[account(mut)]
    pub pool_state: UncheckedAccount<'info>,

    /// CHECK: ditto
    pub amm_config: UncheckedAccount<'info>,

    /// CHECK: ditto
    pub pool_authority: UncheckedAccount<'info>,

    #[account(mut)]
    pub input_vault: Account<'info, TokenAccount>,
    #[account(mut)]
    pub output_vault: Account<'info, TokenAccount>,

    pub input_mint: Account<'info, Mint>,
    pub output_mint: Account<'info, Mint>,

    #[account(mut)]
    pub user_input_ata:  Account<'info, TokenAccount>,
    #[account(mut)]
    pub user_output_ata: Account<'info, TokenAccount>,

    /// Typed as `Program<RaydiumCpSwap>` rather than `UncheckedAccount`: this account
    /// is the program being invoked, not Raydium-owned data, so Anchor's `Program<T>`
    /// wrapper checks its address automatically instead of leaving that check to the
    /// callee.
    pub cpmm_program: Program<'info, raydium_cp_swap::program::RaydiumCpSwap>,
    pub token_program: Program<'info, Token>,
    /// CHECK: observation PDA
    #[account(mut)]
    pub observation_state: UncheckedAccount<'info>,
}

Sebagian besar akun sisi Raydium adalah UncheckedAccount karena penerima (Raydium) memiliki validasi. Program pemanggil Anda hanya benar-benar memvalidasi akun yang Anda miliki, seperti ATA pengguna dan PDA Anda sendiri. Komentar doc /// CHECK: menekan peringatan Anchor tentang pemeriksaan yang hilang. Satu-satunya pengecualian sisi Raydium adalah cpmm_program itu sendiri: ini adalah program yang dipanggil daripada akun data yang divalidasi Raydium secara internal, jadi diketik Program<T> dan mendapat pemeriksaan alamat otomatis Anchor daripada /// CHECK: manual. Bentuk ini—sebagian besar UncheckedAccount, di mana Raydium memvalidasi akunnya sendiri—sama untuk CLMM dan LaunchLab. Contoh ini mengasumsikan kedua mint adalah Token SPL klasik; jika salah satu sisi dapat berupa mint Token-2022, tambahkan bidang token_program_2022: Program<'info, anchor_spl::token_2022::Token2022> dan teruskan sebagai input_token_program/output_token_program sisi itu dalam panggilan CPI di bawah daripada token_program.

​

Membangun panggilan CPI

Anchor menghasilkan satu helper per instruksi, bersama dengan struct akun CPI (cpi::accounts::Swap, dialiaskan CpmmSwap di bawah). Tidak seperti struct MyProxySwap Anda di atas, nama dan urutan bidang ini ditetapkan oleh IDL raydium-cp-swap sendiri dan harus cocok persis:

use raydium_cp_swap::cpi::{self, accounts::Swap as CpmmSwap};

pub fn my_proxy_swap(
    ctx: Context<MyProxySwap>,
    amount_in: u64,
    minimum_amount_out: u64,
) -> Result<()> {
    let cpi_accounts = CpmmSwap {
        // `payer` is YOUR signer — it must own `input_token_account`.
        payer:                ctx.accounts.user.to_account_info(),
        // `authority` is CPMM's OWN vault PDA at seeds [b"vault_and_lp_mint_auth_seed"],
        // which CPMM signs with itself. Passing your signer here fails the
        // seeds constraint (`ConstraintSeeds`) before any transfer runs.
        authority:            ctx.accounts.pool_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.user_input_ata.to_account_info(),
        output_token_account: ctx.accounts.user_output_ata.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.token_program.to_account_info(),
        output_token_program: ctx.accounts.token_program.to_account_info(),
        input_token_mint:     ctx.accounts.input_mint.to_account_info(),
        output_token_mint:    ctx.accounts.output_mint.to_account_info(),
        observation_state:    ctx.accounts.observation_state.to_account_info(),
    };
    // Anchor 1.0: the first argument is the program's Pubkey, 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)?;
    Ok(())
}

cpi::swap_base_input dihasilkan dari IDL; daftar argumennya mencerminkan daftar argumen instruksi Anchor. Setiap program Raydium berbasis Anchor yang dikonfirmasi (CPMM, CLMM, LaunchLab) menghasilkan helper cpi::<ix>() dengan cara yang sama, dengan nama fungsi cocok dengan nama instruksi dalam snake_case. Apakah ini berlaku untuk Farm v6 belum dikonfirmasi; lihat bagiannya.

​

Signer seeds (CPI yang ditandatangani PDA)

Ketika program Anda menandatangani CPI atas nama PDA (umum untuk vault, escrow, dll.), gunakan CpiContext::new_with_signer:

let bump         = ctx.accounts.my_authority_bump;
let signer_seeds: &[&[&[u8]]] = &[&[b"my_authority", &[bump]]];

let cpi_ctx = CpiContext::new_with_signer(
    *ctx.accounts.cpmm_program.key,
    cpi_accounts,
    signer_seeds,
);

cpi::swap_base_input(cpi_ctx, amount_in, minimum_amount_out)?;

Signer seeds harus cocok dengan derivasi PDA. Untuk akun apa pun yang dilewatkan sebagai authority (atau peran signer serupa), runtime Solana memeriksa bahwa PDA menandatangani melalui seed ini.

​

Remaining accounts

Beberapa instruksi Raydium mengambil remaining accounts, daftar panjang variabel yang ditambahkan setelah akun tetap. Helper CPI Anchor tidak melakukan type-check remaining accounts; teruskan melalui .with_remaining_accounts(...):

let cpi_ctx = CpiContext::new(program_id, accounts)
    .with_remaining_accounts(ctx.remaining_accounts.to_vec());

Urutan selalu penting, karena program penerima mengulangi remaining accounts dalam urutan yang Anda teruskan. Dua urutan yang dikonfirmasi:

• CLMM SwapV2: tick arrays, diurutkan secara direktif.
• Farm v6: pasangan (reward_vault, user_reward_ata), tetapi hanya dari aliran reward kedua ke depan; lihat Farm v6 untuk apa yang ditunjukkan dekoding transaksi nyata.

​

Menerapkan pola: CLMM

SwapV2 mengikuti pola umum di atas dengan daftar akun berbeda dan persyaratan remaining-accounts untuk tick arrays. Modul #[program] crate bernama raydium_clmm, yang juga merupakan jalur use Rust-nya.

Struct akun CPI bernama SwapSingleV2, bukan SwapV2. SwapV2 adalah nama instruksi on-chain.

use raydium_clmm::cpi::{self, accounts::SwapSingleV2 as ClmmSwap};

#[derive(Accounts)]
pub struct MyProxyClmmSwap<'info> {
    #[account(mut)]
    pub payer: Signer<'info>,

    /// CHECK: validated by CLMM
    pub amm_config: UncheckedAccount<'info>,
    /// CHECK: ditto
    #[account(mut)]
    pub pool_state: UncheckedAccount<'info>,

    #[account(mut)]
    pub input_token_account: Account<'info, TokenAccount>,
    #[account(mut)]
    pub output_token_account: Account<'info, TokenAccount>,
    #[account(mut)]
    pub input_vault: Account<'info, TokenAccount>,
    #[account(mut)]
    pub output_vault: Account<'info, TokenAccount>,

    /// CHECK: observation PDA
    #[account(mut)]
    pub observation_state: UncheckedAccount<'info>,

    pub token_program: Program<'info, Token>,
    pub token_program_2022: Program<'info, anchor_spl::token_2022::Token2022>,
    /// CHECK: SPL memo program, required for some Token-2022 paths
    pub memo_program: UncheckedAccount<'info>,

    pub input_vault_mint: Account<'info, Mint>,
    pub output_vault_mint: Account<'info, Mint>,

    /// Typed as `Program<T>` rather than `UncheckedAccount`, same reason as CPMM's
    /// `cpmm_program` in the general pattern above: it's the invoked program, and
    /// `Program<T>` checks its address automatically.
    pub clmm_program: Program<'info, raydium_clmm::program::RaydiumClmm>,
    // remaining_accounts: tick_array_bitmap_extension (if the walk needs it), then
    // as many tick_array accounts as the swap's expected price range spans.
}

Hitung daftar tick-array dengan cara yang sama seperti SDK, melalui quote terhadap state pool saat ini, daripada menebak jumlah tetap; swap yang melampaui array yang Anda teruskan akan kembali dengan TickArrayNotFound (lihat products/clmm/instructions untuk tabel akun lengkap dan daftar error). Teruskan dalam arah price walk: array pertama dalam arah swap terlebih dahulu.

​

Menerapkan pola: LaunchLab

LaunchLab berbasis Anchor dan menerbitkan IDL: raydium_launchpad/raydium_launchpad.json di repo publik raydium-idl. Pengenal metadata internal IDL tersebut adalah raydium_launchpad, nama teknis untuk program yang mendasarinya, bukan nama alternatif untuk produk. Tidak seperti CPMM dan CLMM, kode sumber program itu sendiri tidak tersedia untuk publik (lihat reference/program-addresses). Tidak ada dependensi git = "..." untuk menunjuk Cargo, dan tidak ada sumber untuk mengonfirmasi apa yang sebenarnya menjadi path use Rust dalam crate.

Hasilkan binding dari IDL yang dipublikasikan menggunakan macro declare_program! milik Anchor. Simpan JSON IDL sebagai idls/raydium_launchpad.json di crate Anda (Cargo mencari direktori idls/ relatif terhadap CARGO_MANIFEST_DIR), kemudian declare_program!(raydium_launchpad); menghasilkan struct raydium_launchpad::cpi::accounts::<Ix> dan fungsi cpi::<ix>() langsung dari IDL, tanpa memerlukan sumber program. Nama struct accounts yang dihasilkan selalu nama instruksi dalam PascalCase (buy_exact_in → BuyExactIn), dan nama field cocok dengan nama account di IDL secara persis, daftar account yang sama yang sudah digunakan di MyProxyBuy di bawah.

Bentuk CPI mengikuti pola umum. Daftar account dan argumen di bawah berasal dari instruksi buy_exact_in IDL on-chain, bukan dari products/launchlab/instructions.mdx:

use anchor_lang::prelude::*;
use anchor_spl::token::{Token, TokenAccount, Mint};
use raydium_launchpad::cpi::{self, accounts::BuyExactIn};

#[derive(Accounts)]
pub struct MyProxyBuy<'info> {
    #[account(mut)]
    pub payer: Signer<'info>,

    /// CHECK: PDA, seeds = [b"vault_auth_seed"], validated by the program
    pub authority: UncheckedAccount<'info>,

    /// CHECK: validated by the program
    pub global_config: UncheckedAccount<'info>,
    /// CHECK: validated by the program
    pub platform_config: UncheckedAccount<'info>,

    /// CHECK: validated by the program
    #[account(mut)]
    pub pool_state: UncheckedAccount<'info>,

    #[account(mut)]
    pub user_base_token: Account<'info, TokenAccount>,
    #[account(mut)]
    pub user_quote_token: Account<'info, TokenAccount>,
    #[account(mut)]
    pub base_vault: Account<'info, TokenAccount>,
    #[account(mut)]
    pub quote_vault: Account<'info, TokenAccount>,

    pub base_token_mint: Account<'info, Mint>,
    pub quote_token_mint: Account<'info, Mint>,

    /// CHECK: base mint's token program (SPL Token or Token-2022, depending on the mint)
    pub base_token_program: UncheckedAccount<'info>,
    /// Typed as `Program<Token>` rather than `UncheckedAccount`: the IDL fixes this to
    /// classic SPL Token specifically (unlike base_token_program above), so Anchor's
    /// built-in address check on `Program<Token>` is sufficient on its own.
    pub quote_token_program: Program<'info, Token>,

    /// CHECK: PDA, seeds = [b"__event_authority"], required by the program's emit_cpi! pattern
    pub event_authority: UncheckedAccount<'info>,
    /// CHECK: the program's own account, required alongside event_authority
    pub program: UncheckedAccount<'info>,
}

pub fn my_proxy_buy(
    ctx: Context<MyProxyBuy>,
    amount_in: u64,
    minimum_amount_out: u64,
    share_fee_rate: u64,
) -> Result<()> {
    let cpi_accounts = BuyExactIn {
        payer:               ctx.accounts.payer.to_account_info(),
        authority:           ctx.accounts.authority.to_account_info(),
        global_config:       ctx.accounts.global_config.to_account_info(),
        platform_config:     ctx.accounts.platform_config.to_account_info(),
        pool_state:          ctx.accounts.pool_state.to_account_info(),
        user_base_token:     ctx.accounts.user_base_token.to_account_info(),
        user_quote_token:    ctx.accounts.user_quote_token.to_account_info(),
        base_vault:          ctx.accounts.base_vault.to_account_info(),
        quote_vault:         ctx.accounts.quote_vault.to_account_info(),
        base_token_mint:     ctx.accounts.base_token_mint.to_account_info(),
        quote_token_mint:    ctx.accounts.quote_token_mint.to_account_info(),
        base_token_program:  ctx.accounts.base_token_program.to_account_info(),
        quote_token_program: ctx.accounts.quote_token_program.to_account_info(),
        event_authority:     ctx.accounts.event_authority.to_account_info(),
        program:             ctx.accounts.program.to_account_info(),
    };
    // `program` doubles as the CPI target here: LaunchLab's own account is both one of
    // its instruction's required accounts (for its emit_cpi! pattern) and the program
    // CpiContext::new invokes.
    let cpi_ctx = CpiContext::new(
        *ctx.accounts.program.key,
        cpi_accounts,
    );

    cpi::buy_exact_in(cpi_ctx, amount_in, minimum_amount_out, share_fee_rate)?;
    Ok(())
}

Setelah lulus, program target adalah CPMM atau AMM v4 tergantung pada pool_state.migrate_type, yang menurut products/launchlab/accounts.mdx diatur pada waktu Initialize. Daftar account CPI Anda harus disiapkan untuk keduanya, atau Anda perlu membaca migrate_type dari PoolState terlebih dahulu dan membuat cabang.

​

Propagasi error

Setiap program Raydium berbasis Anchor mengembalikan enum error-nya sendiri; Anchor membungkusnya, sehingga program pemanggil Anda melihatnya sebagai Err(ProgramError::Custom(code)). Untuk menangani error spesifik:

use raydium_cp_swap::error::ErrorCode as CpmmErr;

match cpi::swap_base_input(cpi_ctx, amount_in, minimum_amount_out) {
    Ok(_) => Ok(()),
    Err(e) => {
        msg!("CPMM swap failed: {:?}", e);
        // Re-raise, or convert to your own error type.
        Err(e)
    }
}

Tukarkan dengan tipe error yang relevan untuk program yang Anda panggil (raydium_clmm::error::ErrorCode untuk CLMM, dan seterusnya). Nomor kode error stabil sesuai kebijakan IDL (sdk-api/anchor-idl), sehingga Anda dapat menguji kode spesifik dengan membandingkan nilai numerik. Tabel error lengkap: CPMM, CLMM, AMM v4, Farm v6, dan LaunchLab.

​

Compute budget dalam CPI yang disusun

Setiap frame CPI memiliki overhead, dan konsumsi CU callee sendiri bertumpuk di atas milik Anda, jadi transaksi yang memanggil Raydium dari dalam program Anda memerlukan compute budget eksplisit daripada mengandalkan default 200k CU.

Diukur, bukan diperkirakan. CPMM swap_base_input di mainnet mengonsumsi ~23.000 CU dalam program CPMM itu sendiri — sampel 2026-09-09 di delapan swap langsung pada pool volume tinggi (22.721–23.052), dibaca dari baris log Program CPMMoo8… consumed N of M compute units. Untuk perbandingan: AMM v4 swap ~26.000; CLMM swap ~41.000; CLMM swap_v2 ~48.000 (43.838–52.887), meningkat dengan setiap tick crossing.

Revisi sebelumnya dari halaman ini melaporkan ~47.700 CU untuk proxy-swap CPI. Angka tersebut adalah seluruh transaksi (computeUnitsConsumed), yang mencakup program pemanggil sendiri, frame CPI dan setup ATA apa pun — bukan biaya callee. Keduanya berguna, tetapi mereka bukan angka yang sama, jadi bandingkan yang sejenis. Ukur transaksi Anda sendiri daripada memperkirakan dari salah satu.

CLMM dan LaunchLab CPI lebih mahal (CLMM khususnya berjalan melalui tick array tambahan via remaining_accounts, menambah CU per array), tetapi hanya angka CPMM di atas yang merupakan nilai terukur. Selalu atur instruksi ComputeBudgetProgram::set_compute_unit_limit(...) eksplisit yang diukur dari pengukuran Anda sendiri, bukan angka yang disalin dari dokumentasi, karena batas default 200k CU akan diam-diam habis dan biaya per-instruksi bergeser saat program diupgrade.

​

AMM v4: konstruksi Instruction manual

AMM v4 mendahului Anchor dan tidak memiliki crate CPI, menjadikannya satu-satunya program dalam dokumen ini yang tidak mengikuti pola umum di atas. Bangun Instruction secara manual:

use anchor_lang::prelude::*;
use anchor_lang::solana_program::program::invoke_signed;
use anchor_lang::solana_program::instruction::{Instruction, AccountMeta};

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

// SwapBaseIn discriminator is 9.
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(token_program_id, false),
        AccountMeta::new(amm_id, false),
        AccountMeta::new_readonly(amm_authority, false),
        // ... remaining accounts per products/amm-v4/instructions ...
    ],
    data,
};
invoke_signed(&ix, &account_infos, signer_seeds)?;

Lihat products/amm-v4/code-demos untuk daftar account lengkap.

​

Farm v6

Gunakan TS SDK jika itu pilihan untuk integrasi Anda. raydium.farm.deposit(...) (lihat products/farm-staking/code-demos) dilatih oleh demo nyata dan tidak bergantung pada apakah crate Anchor ada untuk program ini.

Farm v6 tidak menawarkan path CPI Anchor. Tidak ada crate raydium_farm_v6 di crates.io, tidak ada repository sumber publik, dan tidak ada IDL on-chain — program tidak memiliki akun anchor:idl legacy maupun entri dalam Program Metadata program (lihat sdk-api/anchor-idl). Perlakukan sebagai program non-Anchor dan bangun instruksinya secara manual, seperti di bawah.

Jika Anda tetap memerlukan Rust CPI, misalnya menyusun dari program on-chain lain, bangun Instruction secara manual, dengan cara yang sama seperti AMM v4: turunkan daftar account nyata dan discriminator instruksi secara independen, misalnya dengan mendekode layout TypeScript SDK (raydium-sdk-V2’s farm module), mendekode transaksi nyata secara langsung (lihat di bawah), atau dump dan disassemble program yang di-deploy.

Untuk bentuk instruksi zero-argument yang konsisten dengan harvest atau claim call, urutan account nyata adalah prefix tetap (token_program, akun state farm, PDA vault-authority, vault reward pertama PDA tersebut, PDA kedua, pemanggil, dan ATA pemanggil untuk mint reward pertama), diikuti oleh pasangan (reward_vault_i, user_reward_ata_i) di remaining_accounts untuk setiap reward stream setelah yang pertama. Konvensi pairing itu nyata, tetapi hanya dimulai pada reward stream kedua: vault dan ATA stream pertama adalah account tetap, bukan berdekatan satu sama lain, dan bukan bagian dari remaining_accounts sama sekali.

​

Menguji alur CPI

Pengembangan lokal memerlukan program Raydium tersedia di validator pengujian Anda. Tiga pilihan:

1. anchor test dengan program clone. Menarik bytecode mainnet yang sudah di-deploy ke validator lokal Anda; lihat Cloning programs into a local validator di bawah untuk konfigurasi Anchor.toml dan dua hal yang sering menyebabkan masalah pada tes pembuatan pool.
2. Devnet. Raydium men-deploy sebagian besar program ke devnet, tetapi dengan program ID yang berbeda dari mainnet untuk setiap program (CPMM, CLMM, AMM v4, Stable AMM, dan LaunchLab masing-masing memiliki alamat devnet yang berbeda; lihat tabel Devnet di reference/program-addresses). Farm v3/v5/v6 tidak secara konsisten dipublikasikan di devnet; API langsung (https://api-v3-devnet.raydium.io/main/info) menunjukkan gambaran terkini. Jika Anda menggunakan konstanta DEVNET_PROGRAM_ID bawaan raydium_clmm (atau yang setara untuk crate lain), jangan asumsikan ID mainnet juga berfungsi di devnet. Jalankan anchor test --provider.cluster devnet untuk menjalankan kode langsung setelah Anda memiliki alamat yang benar.
3. Local deploy. Clone repo Raydium (CPMM, CLMM; sumber LaunchLab tidak tersedia untuk opsi ini) dan anchor deploy ke validator lokal. Menambah overhead siklus pengujian tetapi memungkinkan Anda memodifikasi callee untuk debugging.

Jalankan dengan anchor test, atau anchor build terlebih dahulu dan anchor test --skip-build setelahnya jika Anda melakukan iterasi pada file pengujian tanpa mengubah program.

​

Cloning programs into a local validator

[test]
# Default (5s) tidak cukup setelah Anda melakukan clone beberapa akun, karena masing-masing
# adalah perjalanan RPC mainnet sekuensial selama startup validator.
startup_wait = 60000

[test.validator]
url = "https://api.mainnet-beta.solana.com"

[[test.validator.clone]]
address = "CAMMCzo5YL8w4VFF8KVHrK22GGUsp5VTaW7grrKgrWqK"  # CLMM

[[test.validator.clone]]
address = "CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C"  # CPMM

[[test.validator.clone]]
address = "LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj"   # LaunchLab

[[test.validator.clone]]
address = "FarmqiPv5eAj3j1GMdMCMUGXqPUvmquZtMy86QH6rzhG"  # Farm v6

Ini berfungsi berdasarkan program ID terlepas dari apakah sumber program bersifat publik, jadi LaunchLab melakukan clone dengan cara yang sama seperti CPMM dan CLMM meskipun sumbernya tidak tersedia. reference/program-addresses adalah sumber kebenaran untuk setiap alamat di sini.

Melakukan clone program tidak cukup jika tes Anda juga membuat pool (bukan hanya melakukan swap terhadap pool yang sudah ada). Instruksi initialize CPMM memvalidasi akun amm_config dan create_pool_fee terhadap data on-chain yang sebenarnya, jadi Anda perlu melakukan clone untuk keduanya juga, atau initialize akan gagal total. Untuk CPMM khususnya: clone AmmConfig tier biaya yang Anda inginkan (ambil alamatnya dari GET https://api-v3.raydium.io/main/cpmm-config, indeks 0 adalah tier 0,25%) dan akun token penerima biaya, divalidasi berdasarkan alamat yang tepat, bukan dibuat dengan cepat, jadi harus sudah ada.

Pool yang baru saja dibuat tes Anda tidak dapat ditukar dalam sekejap. initialize CPMM secara diam-diam menimpa open_time yang diminta yang tidak ketat di masa depan (if open_time <= block_timestamp { open_time = block_timestamp + 1 }), jadi bahkan startTime: 0 (“buka segera,” menurut SDK) meninggalkan celah nyata ≥1 detik sebelum pool menerima swap. Tes yang membuat pool dan melakukan swap terhadapnya tanpa penundaan akan mengalami NotApproved. Penundaan singkat await (1–2 detik) antara pembuatan pool dan swap pertama sudah cukup. Ini khusus untuk pengujian; manusia yang menjalankan dua perintah manual terpisah biasanya tidak akan memperhatikan, karena pengetikan dan startup proses sudah memakan lebih dari satu detik.

​

Penunjuk

• products/cpmm/code-demos, products/clmm/code-demos, products/amm-v4/code-demos, products/farm-staking/code-demos, products/launchlab/code-demos: contoh CPI dan TypeScript khusus produk.
• sdk-api/anchor-idl: pengambilan IDL dan regenerasi klien, termasuk jalur IDL-codegen untuk LaunchLab.
• integration-guides/cpi-integration: pola integrasi tingkat lebih tinggi seperti escrow, vault, dan komposisi agregator.

Sumber:

• raydium-cp-swap
• raydium-clmm
• raydium-idl: IDL LaunchLab (sumber program itu sendiri tertutup)
• Anchor CPI docs