Rust CPI

Вызов программ Raydium из другой программы Solana через CPI: построение списка аккаунтов, семена подписей, оставшиеся аккаунты и распространение ошибок для CPMM, CLMM и LaunchLab. AMM v4 (без крейта Anchor) и Farm v6 рассмотрены в отдельных разделах.

Эта страница переведена с помощью ИИ. За эталон принимается английская версия.

Открыть английскую версию →

CPI («cross-program invocation» — кросс-программный вызов) — это механизм, посредством которого одна программа Solana вызывает другую. Большинство программ Raydium поставляются с крейтами-обёртками Anchor CPI, которые делают место вызова похожим на типизированный вызов функции с структурами аккаунтов, имеющими проверенные имена полей и помощники cpi::<ix>(). На этой странице один раз документируется общий паттерн, затем описываются различия для каждой программы. Для работающих примеров на TypeScript см. страницу code-demos в главе каждого продукта.

​

Какой паттерн применяется к какой программе

Программа	На основе Anchor	Крейт	Где
CPMM	Да	raydium-cp-swap (публичный репозиторий; путь Rust use — raydium_cp_swap)	Общий паттерн, рабочий пример
CLMM	Да	raydium-clmm (публичный репозиторий; путь Rust use — raydium_clmm)	Применение паттерна: CLMM
LaunchLab	Да	имя крейта не подтверждено; исходный код программы закрыт, но идентификатор внутренних метаданных IDL в цепи — raydium_launchpad, техническое имя, а не название продукта (см. замечание в Применение паттерна: LaunchLab)	Применение паттерна: LaunchLab
Farm v6	Не подтверждено; публичный IDL или исходный код не найдены (см. предупреждение в Farm v6)	н/д	Farm v6
AMM v4	Нет, предшествует Anchor без крейта CPI	нет	AMM v4

Если вы интегрируете CPMM, CLMM или LaunchLab, сначала прочитайте общий паттерн, затем перейдите к разделу вашей программы для списка аккаунтов и любых различий. Farm v6 и AMM v4 достаточно отличаются, чтобы их разделы стоило читать отдельно.

​

Зависимости Cargo

# Оба публичных крейта CPI Raydium закрепляют Anchor =1.0.2 на `master`,
# поэтому одна программа может зависеть от одного или обоих — см. таблицу ниже.
[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"] }
# ПРИМЕЧАНИЕ: если вы закрепите более старый `rev` до обновления Anchor 1.0 (CPMM 2026-09-09,
# CLMM 2026-09-30), этот rev закрепляет anchor-lang 0.32.1; используйте =0.32.1 и API
# CpiContext 0.3x — и только один из двух крейтов одновременно.
# LaunchLab: исходный код программы не является общедоступным (см. reference/program-addresses).
# Нет git-зависимости, на которую можно указать. Вместо этого сгенерируйте привязки CPI
# из опубликованного IDL. См. «Применение паттерна: LaunchLab» ниже.
# AMM v4 не имеет опубликованного крейта Anchor CPI; см. его собственный раздел.

Ключ зависимости должен точно совпадать с [package] name целевого репозитория, включая дефисы. Cargo не рассматривает raydium_cp_swap как эквивалент raydium-cp-swap при разрешении git-зависимости.

branch = "master" отслеживает последний опубликованный исходный код; закрепите конкретный rev = "<commit>", если вам нужна воспроизводимая сборка. Это рекомендуется после прототипирования, так как изменение макета аккаунта на master разломает вашу сборку без предупреждения.

Флаг функции cpi заставляет крейты компилироваться только в поверхность CPI (структуры аккаунтов + вызыватели), а не в полную программу, поэтому ваш бинарный файл остаётся маленьким.

anchor-lang / anchor-spl должны совпадать с тем, что закрепляет целевой крейт:

Крейт	Закрепляет anchor-lang / anchor-spl
raydium-cp-swap (master)	=1.0.2, из обновления 2026-09-09
raydium-clmm (master)	=1.0.2, из обновления 2026-09-30
Любой крейт на rev до его обновления	0.32.1

Берите оба крейта из одной линии Anchor. Обе ветки master закрепляют =1.0.2, поэтому одна программа может вызывать CPI в CPMM и CLMM из одного крейта. Смешивание линий ломает сборку: например, raydium-cp-swap на master с raydium-clmm, закреплённым на rev до его обновления Anchor 1.0. Cargo пришлось бы связать две несовместимые копии трейтов Anchor в один бинарный файл. Если вы застряли на смешанной паре, разделите программу на две или откажитесь от типизированного крейта CPI для одной стороны и вручную закодируйте эту инструкцию (паттерн, показанный для AMM v4, работает для любой программы).

Anchor 1.0 изменил две вещи, которые касаются каждого места вызова CPI. Если вы переносите рабочую интеграцию с 0.3x:

• CpiContext::new принимает Pubkey, а не AccountInfo. CpiContext::new(ctx.accounts.cpmm_program.to_account_info(), accts) становится CpiContext::new(*ctx.accounts.cpmm_program.key, accts). То же самое для new_with_signer. Поле структуры теперь program_id: Pubkey.
• Context имеет одну жизненную переменную, а не четыре. Context<'_, '_, 'info, 'info, MyProxySwap<'info>> становится Context<'info, MyProxySwap<'info>>.

На стороне клиента anchor-client’s RequestBuilder::instructions() теперь возвращает Vec<Instruction> вместо Result<Vec<Instruction>> (удалите ?), и CommitmentConfig переместился из solana-sdk — берите его из anchor_client вместо этого. spl-associated-token-account 8.0 переэкспортирует свои помощники из нового крейта spl-associated-token-account-interface. get_associated_token_address и ID по-прежнему доступны в корне крейта (spl_associated_token_account::{get_associated_token_address, ID}), но помощники адресов там устарели — предпочитайте зависеть от spl-associated-token-account-interface напрямую и импортировать spl_associated_token_account_interface::address::get_associated_token_address и spl_associated_token_account_interface::program::ID. Обратите внимание, что ::address и ::program — это модули крейта interface; spl_associated_token_account::address::… не разрешается.

Для работающих примеров CPI, которые подключают структуры аккаунтов от начала до конца, см. raydium-io/raydium-cpi-example (охватывает AMM v4, CPMM и CLMM). Его новейшая ветка — anchor-0.31.0 — ветки Anchor 1.x ещё нет, поэтому рассматривайте этот репозиторий как справочник для подключения структур аккаунтов, а не для закреплений версий, которые требует эта страница.

​

Общий паттерн Anchor CPI

В этом разделе рассматривается CPMM от начала до конца как практический пример: структура Accounts, CpiContext, cpi::<ix>(). CLMM следует идентичной структуре с другим списком аккаунтов и требованием remaining-accounts. LaunchLab использует ту же механику, но его список аккаунтов содержит несколько аккаунтов без эквивалентов в CPMM/CLMM (global_config, platform_config, event_authority, program), поэтому рассматривайте это как один паттерн, а не одну структуру. Обратитесь к разделу каждой программы, а не предполагайте, что список аккаунтов из этого примера переносится напрямую.

​

Построение списка аккаунтов

Каждый Raydium CPI требует структуру Accounts в вызывающей программе. Её поля — это те аккаунты, которые нужны вашей инструкции, с валидаторами на уровне полей; порядок их объявления не обязательно должен совпадать с порядком аккаунтов в самой инструкции Raydium, так как ваш IDL-сгенерированный клиент обращается к ним по имени, а не по позиции:

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 — это UncheckedAccount, потому что валидацию выполняет вызываемая программа (Raydium). Ваша вызывающая программа строго валидирует только аккаунты, которыми вы владеете, такие как пользовательские ATA и ваши собственные PDA. Комментарий /// CHECK: подавляет предупреждение Anchor об отсутствии проверок. Единственное исключение на стороне Raydium — это сам cpmm_program: это программа, которая вызывается, а не аккаунт данных, который Raydium валидирует внутри, поэтому он типизирован как Program<T> и получает автоматическую проверку адреса Anchor вместо ручной /// CHECK:. Эта в основном UncheckedAccount структура, где Raydium валидирует свои собственные аккаунты, одинакова для CLMM и LaunchLab. Этот пример предполагает, что оба mint’а — это классические SPL Token; если любой из них может быть Token-2022 mint, добавьте поле token_program_2022: Program<'info, anchor_spl::token_2022::Token2022> и передайте его как input_token_program/output_token_program этой стороны в вызове CPI ниже вместо token_program.

​

Построение вызова CPI

Anchor генерирует один помощник на инструкцию вместе со структурой CPI-аккаунтов (cpi::accounts::Swap, ниже обозначена как CpmmSwap). В отличие от вашей структуры MyProxySwap выше, имена и порядок полей этой структуры фиксированы IDL самого raydium-cp-swap и должны совпадать точно:

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; его список аргументов зеркалирует список аргументов инструкции Anchor. Каждая подтверждённая программа Raydium на основе Anchor (CPMM, CLMM, LaunchLab) генерирует свои помощники cpi::<ix>() одинаково, с именем функции, совпадающим с именем инструкции в snake_case. Распространяется ли это на Farm v6, неподтверждено; см. его раздел.

​

Signer seeds (PDA-подписанный CPI)

Когда ваша программа подписывает CPI от имени PDA (обычно для хранилищ, escrow и т. д.), используйте 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 должны совпадать с выводом PDA. Для любого аккаунта, переданного как authority (или аналогичная роль подписывающего), Solana runtime проверяет, что PDA подписывает через эти seeds.

​

Remaining accounts

Некоторые инструкции Raydium принимают remaining accounts — список переменной длины, добавляемый после фиксированных аккаунтов. Помощники CPI Anchor не проверяют типы remaining accounts; передавайте их через .with_remaining_accounts(...):

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

Порядок всегда имеет значение, так как программа-получатель перебирает remaining accounts в порядке, в котором вы их передаёте. Два подтверждённых порядка:

• CLMM SwapV2: tick arrays, упорядочены по направлению.
• Farm v6: пары (reward_vault, user_reward_ata), но только со второго потока вознаграждения и далее; см. Farm v6 для того, что показывает декодирование реальной транзакции.

​

Применение паттерна: CLMM

SwapV2 следует общему паттерну выше с другим списком аккаунтов и требованием remaining-accounts для tick arrays. Модуль #[program] крейта называется raydium_clmm, что также является его путём Rust use.

Структура CPI аккаунтов называется SwapSingleV2, а не SwapV2. SwapV2 — это имя инструкции на цепи.

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-array так же, как это делает SDK, через quote против текущего состояния пула, а не угадывайте фиксированное количество; swap, который превышает переданные вами массивы, откатывается с ошибкой TickArrayNotFound (см. products/clmm/instructions для полной таблицы аккаунтов и списка ошибок). Передавайте их в направлении обхода цены: первый массив в направлении swap первым.

​

Применение паттерна: LaunchLab

LaunchLab построен на Anchor и опубликован в IDL: raydium_launchpad/raydium_launchpad.json в публичном репозитории raydium-idl. Внутренний идентификатор метаданных этого IDL — raydium_launchpad, техническое имя базовой программы, а не альтернативное название продукта. В отличие от CPMM и CLMM, исходный код самой программы не является публичным (см. reference/program-addresses). Нет зависимости git = "..." для Cargo и нет исходного кода, чтобы подтвердить, какой был бы реальный путь Rust use в крейте.

Генерируйте привязки из опубликованного IDL, используя макрос Anchor declare_program!. Сохраните JSON IDL как idls/raydium_launchpad.json в вашем крейте (Cargo ищет директорию idls/ относительно CARGO_MANIFEST_DIR), затем declare_program!(raydium_launchpad); генерирует структуры raydium_launchpad::cpi::accounts::<Ix> и функции cpi::<ix>() прямо из IDL, без исходного кода программы. Имя сгенерированной структуры accounts всегда — имя инструкции в PascalCase (buy_exact_in → BuyExactIn), а имена полей совпадают с именами accounts в IDL ровно, тот же список accounts, что уже используется в MyProxyBuy ниже.

Форма CPI следует общему паттерну. Список accounts и аргументы ниже взяты из инструкции buy_exact_in в IDL на цепи, а не из 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(())
}

После выпуска целевая программа — CPMM или AMM v4 в зависимости от pool_state.migrate_type, который согласно products/launchlab/accounts.mdx устанавливается во время Initialize. Ваш список accounts для CPI должен быть подготовлен для обоих вариантов, или вам нужно сначала прочитать migrate_type из PoolState и разветвиться.

​

Распространение ошибок

Каждая программа Raydium на основе Anchor возвращает собственный enum ошибок; Anchor оборачивает их, поэтому вызывающая программа видит их как Err(ProgramError::Custom(code)). Для обработки конкретных ошибок:

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

Подставьте соответствующий тип ошибки для программы, которую вы вызываете (raydium_clmm::error::ErrorCode для CLMM и так далее). Номера кодов ошибок стабильны согласно политике IDL (sdk-api/anchor-idl), поэтому вы можете проверять конкретные коды, сравнивая с числовым значением. Полные таблицы ошибок: CPMM, CLMM, AMM v4, Farm v6 и LaunchLab.

​

Бюджет вычислений в составных CPI

Каждый CPI фрейм имеет накладные расходы, и собственное потребление CU вызываемой программы складывается с вашим, поэтому транзакция, которая вызывает Raydium изнутри вашей программы, требует явного бюджета вычислений вместо полагания на стандартный лимит 200k CU.

Измеренные, не оценённые значения. CPMM swap_base_input в mainnet потребляет ~23 000 CU в самой программе CPMM — выборка от 2026-09-09 по восьми живым свопам в пуле с высоким объёмом (22 721–23 052), прочитано из строки лога Program CPMMoo8… consumed N of M compute units. Для сравнения: AMM v4 swap ~26 000; CLMM swap ~41 000; CLMM swap_v2 ~48 000 (43 838–52 887), растёт с каждым пересечением тика.

Более ранняя версия этой страницы сообщала ~47 700 CU для CPI прокси-свопа. Это число было для всей транзакции (computeUnitsConsumed), что включает вашу собственную программу, CPI фрейм и любую настройку ATA — не стоимость вызываемой программы. Оба полезны, но это не одно и то же число, поэтому сравнивайте подобное с подобным. Измеряйте вашу собственную транзакцию вместо бюджетирования по любому из них.

CPI для CLMM и LaunchLab стоят дороже (CLMM в частности проходит дополнительные массивы тиков через remaining_accounts, добавляя CU за каждый массив), но только приведённое выше значение для CPMM — это измеренное значение. Всегда устанавливайте явный лимит ComputeBudgetProgram::set_compute_unit_limit(...) на основе вашего собственного измерения, а не числа, скопированного из документации, так как стандартный лимит 200k CU будет молча исчерпан, а затраты на инструкцию смещаются при обновлении программ.

​

AMM v4: ручное построение Instruction

AMM v4 предшествует Anchor и не имеет CPI крейта, что делает его единственной программой в этом документе, которая не следует общему паттерну выше. Постройте Instruction вручную:

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

Полный список accounts см. в products/amm-v4/code-demos.

​

Farm v6

Используйте TS SDK, если это вариант для вашей интеграции. raydium.farm.deposit(...) (см. products/farm-staking/code-demos) проверена реальными демонстрациями и не зависит от того, существует ли крейт Rust Anchor для этой программы.

Farm v6 не предлагает путь Anchor CPI. На crates.io нет крейта raydium_farm_v6, нет публичного исходного репозитория и нет IDL на цепи — программа не имеет ни устаревшего аккаунта anchor:idl, ни записи в Program Metadata программе (см. sdk-api/anchor-idl). Рассматривайте её как программу без Anchor и постройте её инструкции вручную, как ниже.

Если вам всё же нужен Rust CPI, например при составлении из другой программы на цепи, постройте Instruction вручную, так же как AMM v4: выведите реальный список accounts и дискриминаторы инструкций независимо, например декодируя макеты TypeScript SDK (raydium-sdk-V2’s farm модуль), декодируя реальные транзакции напрямую (см. ниже) или дампируя и дизассемблируя развёрнутую программу.

Для формы инструкции без аргументов, согласованной с вызовом harvest или claim, реальный порядок accounts — это фиксированный префикс (token_program, аккаунт состояния фермы, PDA органа-хранилища, первое хранилище вознаграждения этого PDA, второй PDA, вызывающий, и ATA вызывающего для первого mint вознаграждения), за которым следуют пары (reward_vault_i, user_reward_ata_i) в remaining_accounts для каждого потока вознаграждения после первого. Соглашение о парировании реально, но оно начинается только со второго потока вознаграждения: хранилище и ATA первого потока — это фиксированные accounts, не смежные друг с другом и вообще не являются частью remaining_accounts.

​

Тестирование потока CPI

Для локальной разработки требуется, чтобы программы Raydium были доступны в вашем локальном валидаторе. Есть три варианта:

1. anchor test с клонированием программы. Загружает развёрнутый на мейннете байт-код в локальный валидатор; см. раздел Клонирование программ в локальный валидатор ниже для конфигурации Anchor.toml и двух моментов, которые часто вызывают проблемы при тестировании создания пула.
2. Devnet. Raydium развёртывает большинство программ на devnet, но с другими ID программ, чем на мейннете для каждой программы (CPMM, CLMM, AMM v4, Stable AMM и LaunchLab имеют отдельные адреса на devnet; см. таблицу Devnet в reference/program-addresses). Farm v3/v5/v6 не всегда публикуются на devnet; текущую информацию можно найти в live API (https://api-v3-devnet.raydium.io/main/info). Если вы используете встроенные константы DEVNET_PROGRAM_ID из raydium_clmm (или эквивалент для других крейтов), не предполагайте, что ID мейннета также работает на devnet. Запустите anchor test --provider.cluster devnet для работы с актуальным кодом, когда у вас будут правильные адреса.
3. Локальное развёртывание. Клонируйте репозитории Raydium (CPMM, CLMM; исходный код LaunchLab недоступен для этого варианта) и выполните anchor deploy на локальный валидатор. Это добавляет накладные расходы на цикл тестирования, но позволяет модифицировать вызываемую программу для отладки.

Запустите с помощью anchor test, или сначала выполните anchor build, а затем anchor test --skip-build, если вы итерируете тестовый файл без изменения программы.

​

Клонирование программ в локальный валидатор

[test]
# Default (5s) isn't enough once you're cloning several accounts, since each is
# a sequential mainnet RPC round trip during validator startup.
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

Это работает по ID программы независимо от того, является ли исходный код программы открытым, поэтому LaunchLab клонируется так же, как CPMM и CLMM, даже если его исходный код недоступен. reference/program-addresses — это источник истины для каждого адреса здесь.

Клонирования программы недостаточно, если ваш тест также создаёт пул (вместо того чтобы выполнять своп против уже существующего). Инструкция initialize CPMM проверяет свои аккаунты amm_config и create_pool_fee против реальных данных в цепи, поэтому вам нужно клонировать и их, иначе initialize просто не сработает. Для CPMM конкретно: клонируйте уровень комиссии AmmConfig, который вам нужен (получите его адрес из GET https://api-v3.raydium.io/main/cpmm-config, индекс 0 — это уровень 0.25%) и аккаунт токена получателя комиссии, проверяемый по точному адресу, а не создаваемый на лету, поэтому он должен уже существовать.

Пул, который ваш тест только что создал, не может быть использован для своп в тот же момент. Инструкция initialize CPMM молча переопределяет запрошенный open_time, который не находится строго в будущем (if open_time <= block_timestamp { open_time = block_timestamp + 1 }), поэтому даже startTime: 0 («открыть немедленно», согласно SDK) оставляет реальный промежуток ≥1 секунды перед тем, как пул начнёт принимать своп. Тест, который создаёт пул и выполняет своп против него без задержки, столкнётся с ошибкой NotApproved. Короткого await (1–2 сек) между созданием пула и первым своп достаточно. Это специфично для тестирования; человек, выполняющий две отдельные команды вручную, обычно не заметит этого, так как ввод текста и запуск процесса уже занимают более одной секунды.

​

Ссылки

• products/cpmm/code-demos, products/clmm/code-demos, products/amm-v4/code-demos, products/farm-staking/code-demos, products/launchlab/code-demos: примеры CPI и TypeScript для каждого продукта.
• sdk-api/anchor-idl: получение IDL и регенерация клиента, включая путь IDL-codegen для LaunchLab.
• integration-guides/cpi-integration: высокоуровневые паттерны интеграции, такие как escrows, vaults и композиция агрегаторов.

Источники:

• raydium-cp-swap
• raydium-clmm
• raydium-idl: IDL LaunchLab (исходный код программы закрыт)
• Anchor CPI docs