Rust CPI

Raydium programlarını başka bir Solana programından CPI aracılığıyla çağırma: hesap listesi oluşturma, imzalayan tohumları, kalan hesaplar ve CPMM, CLMM ve LaunchLab için hata yayılması. AMM v4 (Anchor crate yok) ve Farm v6 kendi bölümlerinde ele alınmıştır.

Bu sayfa yapay zekâ tarafından otomatik olarak çevrilmiştir. İngilizce sürüm esas alınır.

İngilizce sürümü görüntüle →

​

Hangi desen hangi programa uygulanır

Program	Anchor tabanlı	Crate	Nerede
CPMM	Evet	raydium-cp-swap (genel repo; Rust use yolu raydium_cp_swap)	Genel desen, çalışan örnek
CLMM	Evet	raydium-clmm (genel repo; Rust use yolu raydium_clmm)	Deseni uygulama: CLMM
LaunchLab	Evet	onaylanmış crate adı yok; program kaynağı kapalı, ancak zincir üstü IDL’nin iç meta veri tanımlayıcısı raydium_launchpad, ürün adı yerine teknik bir ad (Deseni uygulama: LaunchLab içindeki uyarıya bakın)	Deseni uygulama: LaunchLab
Farm v6	Onaylanmamış; genel IDL veya kaynak bulunamadı (Farm v6 içindeki uyarıya bakın)	yok	Farm v6
AMM v4	Hayır, Anchor’dan önceki dönem, CPI crate yok	yok	AMM v4

CPMM, CLMM veya LaunchLab entegre ediyorsanız, önce genel deseni okuyun, ardından hesap listesi ve farklılıklar için programınızın bölümüne gidin. Farm v6 ve AMM v4 bölümlerini bağımsız olarak okumaya değer kadar farklıdır.

​

Cargo bağımlılıkları

# Her iki genel Raydium CPI crate'i de `master` üzerinde Anchor =1.0.2'yi sabitlediğinden,
# bir program her ikisine de bağlı olabilir — aşağıdaki tabloya bakın.
[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"] }
# NOT: Anchor 1.0 yükseltmesinden önceki eski bir `rev` sabitleseniz (CPMM 2026-09-09,
# CLMM 2026-09-30), bu rev anchor-lang 0.32.1'i sabitledi; =0.32.1 ve 0.3x
# CpiContext API'sini kullanın — ve o zaman da aynı anda yalnızca iki crate'ten birini.
# LaunchLab: program kaynağı genel olarak kullanılamaz (bkz. reference/program-addresses).
# İşaret edecek git bağımlılığı yok. Bunun yerine yayınlanan IDL'den CPI bağlamaları oluşturun.
# Aşağıdaki "Deseni uygulama: LaunchLab" bölümüne bakın.
# AMM v4'ün yayınlanmış Anchor CPI crate'i yok; kendi bölümüne bakın.

Bağımlılık anahtarı hedef repo’nun [package] name ile tam olarak eşleşmelidir, tireleri de dahil olmak üzere. Cargo, bir git bağımlılığını çözerken raydium_cp_swap ile raydium-cp-swap arasında eşdeğer davranmaz.

branch = "master" en son yayınlanan kaynağı izler; yeniden üretilebilir bir derleme gerekiyorsa belirli bir rev = "<commit>" ile sabitleyin. Prototipleme aşamasını geçtikten sonra bu önerilir, çünkü master üzerinde bir yukarı akış hesap düzeni değişikliği aksi takdirde uyarı olmadan derlemenizi bozacaktır.

cpi özellik bayrağı, crate’lerin tam program yerine yalnızca CPI yüzeyine (hesap yapıları + çağırıcılar) derlemesini sağlar, böylece ikili dosyanız küçük kalır.

anchor-lang / anchor-spl hedef crate’in sabitlediği ile eşleşmelidir:

Crate	anchor-lang / anchor-spl sabitledi
raydium-cp-swap (master)	=1.0.2, 2026-09-09 yükseltmesinden
raydium-clmm (master)	=1.0.2, 2026-09-30 yükseltmesinden
Yükseltmesinden önceki bir rev ile herhangi bir crate	0.32.1

Her iki crate’i de aynı Anchor satırından alın. Her iki master dalı da =1.0.2 sabitlediğinden, bir program tek bir crate’ten CPMM ve CLMM’ye CPI yapabilir. Satırları karıştırmak derlemeyi bozar: örneğin, raydium-cp-swap master üzerinde ve raydium-clmm Anchor 1.0 yükseltmesinden önceki bir rev ile sabitlenmiş. Cargo, bir ikili dosyaya Anchor’ın özelliklerinin iki uyumsuz kopyasını bağlamak zorunda kalacaktır. Karışık bir çiftte sıkışıp kaldıysanız, programı ikiye bölün veya bir taraf için yazılı CPI crate’ini bırakın ve bu talimatı elle kodlayın (AMM v4 için gösterilen desen herhangi bir program için çalışır).

Anchor 1.0, her CPI çağrı sitesinin dokunduğu iki şeyi değiştirdi. Çalışan bir entegrasyonu 0.3x kapalı taşıyorsanız:

• CpiContext::new bir AccountInfo değil, bir Pubkey alır. CpiContext::new(ctx.accounts.cpmm_program.to_account_info(), accts) CpiContext::new(*ctx.accounts.cpmm_program.key, accts) olur. new_with_signer için de aynı. Yapı alanı artık program_id: Pubkey.
• Context dört değil, bir yaşam süresine sahiptir. Context<'_, '_, 'info, 'info, MyProxySwap<'info>> Context<'info, MyProxySwap<'info>> olur.

İstemci tarafında, anchor-client’ın RequestBuilder::instructions() artık Result<Vec<Instruction>> yerine Vec<Instruction> döndürür (? bırakın) ve CommitmentConfig solana-sdk dışına taşındı — bunun yerine anchor_client adresinden alın. spl-associated-token-account 8.0, yardımcılarını yeni spl-associated-token-account-interface crate’inden yeniden dışa aktarır. get_associated_token_address ve ID hala crate kökünde ulaşılabilir (spl_associated_token_account::{get_associated_token_address, ID}), ancak adres yardımcıları orada kullanımdan kaldırılmıştır — bunun yerine doğrudan spl-associated-token-account-interface bağımlılığını tercih edin ve spl_associated_token_account_interface::address::get_associated_token_address ve spl_associated_token_account_interface::program::ID içeri aktarın. ::address ve ::program arayüz crate’inin modülleri olduğunu unutmayın; spl_associated_token_account::address::… çözümlenmez.

Hesap yapılarını uçtan uca bağlayan çalışan CPI örnekleri için bkz. raydium-io/raydium-cpi-example (AMM v4, CPMM ve CLMM’yi kapsar). En yeni dalı anchor-0.31.0 — henüz Anchor 1.x dalı yok, bu nedenle bu repo’yu hesap yapısı bağlaması için referans olarak değerlendirin, bu sayfanın zorunlu kıldığı sürüm pinleri için değil.

​

Genel Anchor CPI deseni

Bu bölüm CPMM baştan sona adım adım açıklar: Accounts struct, CpiContext, cpi::<ix>(). CLMM aynı şekli izler, ancak farklı bir hesap listesi ve kalan hesaplar gereksinimi vardır. LaunchLab aynı mekanikleri takip eder, ancak hesap listesi CPMM/CLMM’de olmayan birkaç hesap içerir (global_config, platform_config, event_authority, program), bu nedenle bunu aynı desen olarak değil, aynı şekil olarak değerlendirin. Her programın kendi bölümüne bakın ve bu kılavuzun hesap listesinin doğrudan aktarılabileceğini varsaymayın.

​

Hesap listesi oluşturma

Her Raydium CPI, çağıran programda bir Accounts struct gerektirir. Alanları, sizin talimatınızın ihtiyaç duyduğu hesaplar ve alan düzeyinde doğrulayıcılardır; bunların bildirim sırası Raydium’un kendi talimat hesap sırasıyla eşleşmek zorunda değildir, çünkü kendi IDL tarafından oluşturulan istemciniz bunları konuma göre değil, ada göre adresler:

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>,
}

Raydium tarafındaki hesapların çoğu UncheckedAccount olarak yazılır, çünkü çağrılan taraf (Raydium) doğrulamaya sahiptir. Çağıran programınız yalnızca sizin sahip olduğunuz hesapları, örneğin kullanıcı ATA’larını ve kendi PDA’larınızı kesin olarak doğrular. /// CHECK: doc-yorumu, Anchor’un eksik kontroller hakkındaki uyarısını bastırır. Raydium tarafındaki tek istisna cpmm_program kendisidir: Raydium’un dahili olarak doğruladığı bir veri hesabı yerine çağrılan program olduğundan, Program<T> olarak yazılır ve manuel bir /// CHECK: yerine Anchor’un otomatik adres kontrolünü alır. Bu çoğunlukla UncheckedAccount şekli, Raydium’un kendi hesaplarını doğruladığı yer, CLMM ve LaunchLab için de aynıdır. Bu örnek her iki mint’in de klasik SPL Token olduğunu varsayar; her iki taraf da Token-2022 mint olabilirse, bir token_program_2022: Program<'info, anchor_spl::token_2022::Token2022> alanı ekleyin ve aşağıdaki CPI çağrısında token_program yerine o tarafın input_token_program/output_token_program olarak geçirin.

​

CPI çağrısı oluşturma

Anchor, talimat başına bir yardımcı oluşturur ve bir CPI-hesaplar struct’ı (cpi::accounts::Swap, aşağıda CpmmSwap olarak takma ad). Yukarıdaki kendi MyProxySwap struct’ınızdan farklı olarak, bu struct’ın alan adları ve sırası raydium-cp-swap’ın kendi IDL’si tarafından sabitlenir ve tam olarak eşleşmesi gerekir:

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 IDL’den oluşturulur; argüman listesi Anchor talimatının argüman listesini yansıtır. Onaylanan her Anchor tabanlı Raydium programı (CPMM, CLMM, LaunchLab) cpi::<ix>() yardımcılarını aynı şekilde oluşturur; işlev adı talimat adıyla snake_case’de eşleşir. Bunun Farm v6’ya kadar uzanıp uzanmadığı onaylanmamıştır; kendi bölümüne bakın.

​

İmzalayan tohumlar (PDA tarafından imzalanan CPI)

Programınız bir PDA adına CPI’yi imzaladığında (vault’lar, escrow’lar vb. için yaygındır), CpiContext::new_with_signer kullanın:

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)?;

İmzalayan tohumlar PDA’nın türetilmesiyle eşleşmelidir. authority (veya benzer imzalayan rol) olarak geçirilen herhangi bir hesap için, Solana çalışma zamanı PDA’nın bu tohumlar aracılığıyla imzaladığını kontrol eder.

​

Kalan hesaplar

Bazı Raydium talimatları kalan hesaplar alır; sabit hesaplardan sonra eklenen değişken uzunlukta bir liste. Anchor’un CPI yardımcıları kalan hesapları tür kontrol etmez; bunları .with_remaining_accounts(...) aracılığıyla geçirin:

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

Sıra her zaman önemlidir, çünkü alıcı program kalan hesapları geçtiğiniz sırada yineler. İki onaylanan sıralama:

• CLMM SwapV2: tick dizileri, yönsel olarak sıralanmış.
• Farm v6: (reward_vault, user_reward_ata) çiftleri, ancak yalnızca ikinci ödül akışından itibaren; gerçek bir işlemin kodunu çözmek ne gösterdiğini görmek için Farm v6 bölümüne bakın.

​

Deseni uygulama: CLMM

SwapV2 yukarıdaki genel deseni takip eder, ancak farklı bir hesap listesi ve tick dizileri için kalan hesaplar gereksinimi vardır. Crate’in #[program] modülü raydium_clmm olarak adlandırılır; bu aynı zamanda Rust use yoludur.

CPI hesapları struct’ı SwapV2 değil SwapSingleV2 olarak adlandırılır. SwapV2 zincir üstü talimat adıdır.

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.
}

Tick dizisi listesini SDK’nın yaptığı gibi, sabit bir sayı tahmin etmek yerine geçerli pool durumuna karşı bir alıntı aracılığıyla hesaplayın; geçtiğiniz dizileri aşan bir swap TickArrayNotFound ile geri döner (tam hesap tablosu ve hata listesi için products/clmm/instructions bölümüne bakın). Bunları fiyat yürüyüşünün yönünde geçirin: swap yönündeki ilk dizi ilk olarak.

​

Deseni Uygulamak: LaunchLab

LaunchLab, Anchor tabanlı ve IDL yayınlıdır: raydium_launchpad/raydium_launchpad.json genel raydium-idl deposunda. Bu IDL’nin iç meta veri tanımlayıcısı raydium_launchpad’dır; bu, ürünün alternatif bir adı değil, temel programın teknik adıdır. CPMM ve CLMM’den farklı olarak, programın kendi kaynağı herkese açık değildir (bkz. reference/program-addresses). Cargo’ya işaret edecek bir git = "..." bağımlılığı yoktur ve gerçek bir crate’in Rust use yolunun ne olacağını doğrulamak için kaynak yoktur.

Yayınlanan IDL’den Anchor’ın declare_program! makrosu kullanarak bağlamalar oluşturun. IDL JSON’ını crate’inizde idls/raydium_launchpad.json olarak kaydedin (Cargo, CARGO_MANIFEST_DIR’e göre bir idls/ dizini arar), ardından declare_program!(raydium_launchpad); IDL’den doğrudan raydium_launchpad::cpi::accounts::<Ix> struct’larını ve cpi::<ix>() fonksiyonlarını oluşturur; program kaynağı gerekmez. Oluşturulan accounts-struct adı her zaman instruction adının PascalCase’idir (buy_exact_in → BuyExactIn), ve alan adları IDL’nin account adlarıyla tam olarak eşleşir; aşağıdaki MyProxyBuy’da zaten kullanılan aynı account listesi.

CPI şekli genel deseni izler. Aşağıdaki account listesi ve argümanlar, products/launchlab/instructions.mdx’den değil, zincir üstü IDL’nin buy_exact_in instruction’ından gelir:

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(())
}

Mezuniyet sonrasında, hedef program pool_state.migrate_type’a bağlı olarak CPMM veya AMM v4’tür; products/launchlab/accounts.mdx bunun Initialize zamanında ayarlandığını söyler. CPI account listeniz her ikisine de hazırlanmalı veya önce migrate_type’ı PoolState’ten okumalı ve dallanmalısınız.

​

Hata yayılması

Her Anchor tabanlı Raydium programı kendi hata enum’ını döndürür; Anchor bunları sarmaladığı için, çağıran programınız bunları Err(ProgramError::Custom(code)) olarak görür. Belirli hataları işlemek için:

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

Çağırdığınız program için ilgili hata türünü değiştirin (raydium_clmm::error::ErrorCode CLMM için, vb.). Hata kodu numaraları IDL politikasına göre kararlıdır (sdk-api/anchor-idl), bu nedenle sayısal değerle karşılaştırarak belirli kodlara karşı test edebilirsiniz. Tam hata tabloları: CPMM, CLMM, AMM v4, Farm v6 ve LaunchLab.

​

Bileşik CPI’larda işlem bütçesi

Her CPI frame’inin ek yükü vardır ve çağrılanın kendi CU tüketimi sizinkinin üstüne yığılır; bu nedenle programınızın içinden Raydium’a çağrı yapan bir işlem, 200k CU varsayılanına güvenmek yerine açık bir işlem bütçesine ihtiyaç duyar.

Ölçülen, tahmin edilmeyen. Mainnet’te bir CPMM swap_base_input, CPMM programının kendisinde ~23.000 CU tüketir — 2026-09-09’da yüksek hacimli bir havuzda sekiz canlı swap’ta örneklenmiş (22.721–23.052), Program CPMMoo8… consumed N of M compute units günlük satırından okunmuştur. Karşılaştırma için: AMM v4 swap ~26.000; CLMM swap ~41.000; CLMM swap_v2 ~48.000 (43.838–52.887), her tick geçişiyle artar.

Bu sayfanın önceki bir revizyonu, bir proxy-swap CPI için ~47.700 CU bildirmiştir. Bu rakam tüm işlem (computeUnitsConsumed) idi; bu, çağıranın kendi programını, CPI frame’ini ve herhangi bir ATA kurulumunu içerir — çağrılanın maliyeti değil. Her ikisi de yararlıdır, ancak bunlar aynı sayı değildir, bu nedenle benzer olanları karşılaştırın. Belgelendirmeden kopyalanan bir sayıya göre bütçe yapmak yerine kendi işleminizi ölçün.

CLMM ve LaunchLab CPI’ları daha pahalıdır (CLMM özellikle remaining_accounts aracılığıyla ek tick dizilerini yürür, dizi başına CU ekler), ancak yukarıdaki yalnızca CPMM rakamı ölçülen bir değerdir. Her zaman belgelendirmeden kopyalanan bir sayıya değil, kendi ölçümünüzden boyutlandırılmış açık bir ComputeBudgetProgram::set_compute_unit_limit(...) instruction’ı ayarlayın; çünkü varsayılan 200k CU sınırı sessizce tükenecek ve programlar yükseltildikçe instruction başına maliyetler değişecektir.

​

AMM v4: manuel Instruction oluşturma

AMM v4, Anchor’dan önce gelir ve CPI crate’i yoktur; bu, bu belgedeki genel deseni izlemeyen tek programdır. Instruction’ı elle oluşturun:

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)?;

Tam account listesi için products/amm-v4/code-demos bölümüne bakın.

​

Farm v6

Entegrasyonunuz için bu bir seçenek ise TS SDK’yı kullanın. raydium.farm.deposit(...) (bkz. products/farm-staking/code-demos) gerçek demolar tarafından uygulanır ve bu program için bir Rust Anchor crate’inin var olup olmadığına bağlı değildir.

Farm v6, Anchor CPI yolu sunmaz. crates.io’da raydium_farm_v6 crate’i yoktur, genel kaynak deposu yoktur ve zincir üstü IDL yoktur — programın ne eski bir anchor:idl hesabı ne de Program Metadata programında bir girişi vardır (bkz. sdk-api/anchor-idl). Bunu Anchor olmayan bir program olarak değerlendirin ve instruction’larını aşağıdaki gibi elle oluşturun.

Yine de Rust CPI’ya ihtiyacınız varsa, örneğin başka bir zincir üstü programdan oluştururken, Instruction’ı elle oluşturun; AMM v4 ile aynı şekilde: gerçek account listesini ve instruction discriminator’larını bağımsız olarak türetin; örneğin SDK’nın TypeScript düzenlerini (raydium-sdk-V2’nin farm modülü) çözerek, gerçek işlemleri doğrudan çözerek (aşağıya bakın) veya dağıtılan programı dökerek ve disassemble ederek.

Sıfır argümanlı instruction şekli için, bir harvest veya claim çağrısıyla tutarlı olan, gerçek account sırası sabit bir önek (token_program, farm’ın state hesabı, bir vault-authority PDA, bu PDA’nın ilk reward vault’u, ikinci bir PDA, çağıran ve çağıranın bu ilk reward mint’i için ATA’sı) ve ardından ilk sonrası her reward akışı için remaining_accounts’ta (reward_vault_i, user_reward_ata_i) çiftleridir. Eşleştirme kuralı gerçektir, ancak yalnızca ikinci reward akışında başlar: ilk akışın vault’u ve ATA’sı sabit hesaplardır, birbirinin yanında değildir ve remaining_accounts’ın hiç parçası değildir.

​

CPI akışını test etme

Yerel geliştirme için Raydium programlarının test validatörünüzde mevcut olması gerekir. Üç seçeneğiniz vardır:

1. anchor test program klonlaması ile. Dağıtılmış mainnet bytecode’unu yerel validatörünüze çeker; aşağıdaki Programları yerel validatöre klonlama bölümünde Anchor.toml yapılandırması ve özellikle pool oluşturma testlerini zor yapan iki şeyi görebilirsiniz.
2. Devnet. Raydium çoğu programı devnet’e dağıtır, ancak mainnet’ten farklı program ID’leri ile (CPMM, CLMM, AMM v4, Stable AMM ve LaunchLab’ın her birinin ayrı bir devnet adresi vardır; reference/program-addresses içindeki Devnet tablosuna bakınız). Farm v3/v5/v6 devnet’te güvenilir şekilde yayınlanmaz; canlı API (https://api-v3-devnet.raydium.io/main/info) mevcut durumu gösterir. raydium_clmm’nin paketlenmiş DEVNET_PROGRAM_ID sabitlerini (veya diğer crate’ler için eşdeğerini) kullanıyorsanız, mainnet ID’sinin devnet’te de çalışacağını varsaymayınız. Doğru adreslere sahip olduktan sonra canlı kodu çalıştırmak için anchor test --provider.cluster devnet komutunu çalıştırınız.
3. Yerel dağıtım. Raydium depolarını klonlayınız (CPMM, CLMM; LaunchLab’ın kaynağı bu seçenek için mevcut değildir) ve yerel validatöre anchor deploy yapınız. Test döngüsü yükü ekler ancak hata ayıklama için çağrılan programı değiştirmenize izin verir.

anchor test ile çalıştırınız veya programı değiştirmiyorsanız önce anchor build yapınız ve test dosyasında yineleme yaparken anchor test --skip-build komutunu çalıştırınız.

​

Programları yerel validatöre klonlama

[test]
# Varsayılan (5s) birkaç hesabı klonladığınızda yeterli değildir, çünkü her biri
# validatör başlatma sırasında sıralı bir mainnet RPC gidiş-dönüşüdür.
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

Bu, programın kaynağı herkese açık olup olmadığına bakılmaksızın program ID’sine göre çalışır; bu nedenle LaunchLab, kaynağı mevcut olmasa da CPMM ve CLMM ile aynı şekilde klonlanır. reference/program-addresses buradaki her adres için gerçek kaynaktır.

Programı klonlamak, testiniz aynı zamanda bir pool oluşturuyorsa yeterli değildir (zaten var olan bir havuza karşı işlem yapmak yerine). CPMM’nin initialize talimatı, amm_config ve create_pool_fee hesaplarını gerçek zincir üstü verilerine karşı doğrular; bu nedenle bunları da klonlamanız gerekir, aksi takdirde initialize tamamen başarısız olur. CPMM için özellikle: istediğiniz ücret seviyesi AmmConfig’ini klonlayınız (adresini GET https://api-v3.raydium.io/main/cpmm-config adresinden alınız, indeks 0 %0,25 seviyesidir) ve ücret alıcı token hesabını, tam adres tarafından doğrulanmış, anında oluşturulmamış, bu nedenle zaten var olması gerekir.

Testinizin yeni oluşturduğu bir pool aynı anda takas edilemez. CPMM’nin initialize talimatı, kesinlikle gelecekte olmayan istenen open_time’ı sessizce geçersiz kılar (if open_time <= block_timestamp { open_time = block_timestamp + 1 }), bu nedenle startTime: 0 (“hemen aç,” SDK’ya göre) bile pool takas kabul etmeden önce gerçek ≥1 saniyelik bir boşluk bırakır. Bir pool oluşturan ve sıfır gecikmeyle ona karşı işlem yapan bir test NotApproved hatasına çarpar. Pool oluşturma ile ilk takas arasında kısa bir await (1–2s) yeterlidir. Bu test’e özgüdür; bir insan iki ayrı manuel komut çalıştırırsa normalde fark etmez, çünkü yazma ve işlem başlatma zaten bir saniyeden fazla zaman alır.

​

İşaretçiler

• products/cpmm/code-demos, products/clmm/code-demos, products/amm-v4/code-demos, products/farm-staking/code-demos, products/launchlab/code-demos: ürüne özgü CPI ve TypeScript örnekleri.
• sdk-api/anchor-idl: IDL alımı ve istemci yeniden oluşturma, LaunchLab için IDL-codegen yolu dahil.
• integration-guides/cpi-integration: emanet, kasa ve toplayıcı bileşimi gibi daha yüksek seviye entegrasyon desenleri.

Kaynaklar:

• raydium-cp-swap
• raydium-clmm
• raydium-idl: LaunchLab IDL (program kaynağının kendisi kapalıdır)
• Anchor CPI docs