use crate::{ constants::trade::trade::DEFAULT_SLIPPAGE, instruction::pumpswap_ix_data::{ encode_pumpswap_buy_exact_quote_in_ix_data, encode_pumpswap_buy_ix_data, encode_pumpswap_buy_two_args, encode_pumpswap_sell_ix_data, }, instruction::{ token_account_setup::{ push_close_wsol_if_needed, push_create_or_wrap_user_token_account, push_create_user_token_account, }, utils::pumpswap::{ accounts, fee_recipient_ata, get_mayhem_fee_recipient_random, get_pool_v2_pda, get_protocol_extra_fee_recipient_random, get_protocol_fee_recipient_random, get_user_volume_accumulator_pda, get_user_volume_accumulator_quote_ata, get_user_volume_accumulator_wsol_ata, }, }, trading::core::{ params::{PumpSwapParams, SwapParams}, traits::InstructionBuilder, }, utils::calc::pumpswap::{ buy_quote_input_internal_with_fees, sell_base_input_internal_with_fees, }, }; use anyhow::{anyhow, Result}; use solana_sdk::{ instruction::{AccountMeta, Instruction}, pubkey::Pubkey, signer::Signer, }; /// Instruction builder for PumpSwap protocol pub struct PumpSwapInstructionBuilder; #[async_trait::async_trait] impl InstructionBuilder for PumpSwapInstructionBuilder { async fn build_buy_instructions(&self, params: &SwapParams) -> Result> { // ======================================== // Parameter validation and basic data preparation // ======================================== let protocol_params = params .protocol_params .as_any() .downcast_ref::() .ok_or_else(|| anyhow!("Invalid protocol params for PumpSwap"))?; if params.input_amount.unwrap_or(0) == 0 { return Err(anyhow!("Amount cannot be zero")); } let pool = protocol_params.pool; let base_mint = protocol_params.base_mint; let quote_mint = protocol_params.quote_mint; let pool_base_token_reserves = protocol_params.pool_base_token_reserves; let pool_quote_token_reserves = protocol_params.pool_quote_token_reserves; let virtual_quote_reserves = protocol_params.virtual_quote_reserves; protocol_params.effective_quote_reserves()?; let params_coin_creator_vault_ata = protocol_params.coin_creator_vault_ata; let params_coin_creator_vault_authority = protocol_params.coin_creator_vault_authority; let create_input_ata = params.create_input_mint_ata; let close_wsol_ata = params.close_input_mint_ata; let base_token_program = protocol_params.base_token_program; let quote_token_program = protocol_params.quote_token_program; let pool_base_token_account = protocol_params.pool_base_token_account; let pool_quote_token_account = protocol_params.pool_quote_token_account; let is_wsol = (base_mint == crate::constants::WSOL_TOKEN_ACCOUNT && quote_mint != crate::constants::USDC_TOKEN_ACCOUNT) || (quote_mint == crate::constants::WSOL_TOKEN_ACCOUNT && base_mint != crate::constants::USDC_TOKEN_ACCOUNT); let is_usdc = (base_mint == crate::constants::USDC_TOKEN_ACCOUNT && quote_mint != crate::constants::WSOL_TOKEN_ACCOUNT) || (quote_mint == crate::constants::USDC_TOKEN_ACCOUNT && base_mint != crate::constants::WSOL_TOKEN_ACCOUNT); if !is_wsol && !is_usdc { return Err(anyhow!("Pool must contain WSOL or USDC")); } // ======================================== // Trade calculation and account address preparation // ======================================== let quote_is_wsol_or_usdc = quote_mint == crate::constants::WSOL_TOKEN_ACCOUNT || quote_mint == crate::constants::USDC_TOKEN_ACCOUNT; let input_stable_mint = if quote_is_wsol_or_usdc { quote_mint } else { base_mint }; let input_stable_token_program = if quote_is_wsol_or_usdc { quote_token_program } else { base_token_program }; let output_trade_mint = if quote_is_wsol_or_usdc { base_mint } else { quote_mint }; let output_trade_token_program = if quote_is_wsol_or_usdc { base_token_program } else { quote_token_program }; let fee_basis_points = protocol_params.fee_basis_points; let (token_amount, sol_amount) = if let Some(output_amount) = params.fixed_output_amount { (output_amount, params.input_amount.unwrap_or(0)) } else if quote_is_wsol_or_usdc { let result = buy_quote_input_internal_with_fees( params.input_amount.unwrap_or(0), params.slippage_basis_points.unwrap_or(DEFAULT_SLIPPAGE), pool_base_token_reserves, pool_quote_token_reserves, virtual_quote_reserves, &fee_basis_points, ) .map_err(anyhow::Error::msg)?; // base_amount_out, max_quote_amount_in (result.base, result.max_quote) } else { let result = sell_base_input_internal_with_fees( params.input_amount.unwrap_or(0), params.slippage_basis_points.unwrap_or(DEFAULT_SLIPPAGE), pool_base_token_reserves, pool_quote_token_reserves, virtual_quote_reserves, &fee_basis_points, ) .map_err(anyhow::Error::msg)?; // min_quote_amount_out, base_amount_in (result.min_quote, params.input_amount.unwrap_or(0)) }; let user_base_token_account = crate::common::fast_fn::get_associated_token_address_with_program_id_fast_use_seed( ¶ms.payer.pubkey(), &base_mint, &base_token_program, params.open_seed_optimize, ); let user_quote_token_account = crate::common::fast_fn::get_associated_token_address_with_program_id_fast_use_seed( ¶ms.payer.pubkey(), "e_mint, "e_token_program, params.open_seed_optimize, ); // Determine fee recipient based on mayhem mode (pump-public-docs: 10th = Mayhem fee recipient, 11th = WSOL ATA of Mayhem; use any one randomly) let is_mayhem_mode = protocol_params.is_mayhem_mode; let (fee_recipient, fee_recipient_meta) = if is_mayhem_mode { get_mayhem_fee_recipient_random() } else { let recipient = get_protocol_fee_recipient_random(); (recipient, AccountMeta::new_readonly(recipient, false)) }; let fee_recipient_ata = fee_recipient_ata(fee_recipient, quote_mint); // ======================================== // Build instructions // ======================================== let mut instructions = Vec::with_capacity(6); if create_input_ata { // Determine wrap amount based on instruction type: // - buy_exact_quote_in: program spends exactly input_amount, wrap input_amount // - buy: program may spend up to max_quote, wrap max_quote let wrap_amount = if quote_is_wsol_or_usdc && params.use_exact_sol_amount.unwrap_or(true) { params.input_amount.unwrap_or(0) } else { sol_amount }; push_create_or_wrap_user_token_account( &mut instructions, ¶ms.payer.pubkey(), &input_stable_mint, &input_stable_token_program, wrap_amount, params.open_seed_optimize, ); } if params.create_output_mint_ata { push_create_user_token_account( &mut instructions, ¶ms.payer.pubkey(), &output_trade_mint, &output_trade_token_program, params.open_seed_optimize, ); } // Create buy instruction let mut accounts = Vec::with_capacity(28); accounts.extend([ AccountMeta::new(pool, false), // pool_id AccountMeta::new(params.payer.pubkey(), true), // user (signer) accounts::GLOBAL_ACCOUNT_META, // global (readonly) AccountMeta::new_readonly(base_mint, false), // base_mint (readonly) AccountMeta::new_readonly(quote_mint, false), // quote_mint (readonly) AccountMeta::new(user_base_token_account, false), // user_base_token_account AccountMeta::new(user_quote_token_account, false), // user_quote_token_account AccountMeta::new(pool_base_token_account, false), // pool_base_token_account AccountMeta::new(pool_quote_token_account, false), // pool_quote_token_account fee_recipient_meta, // fee_recipient (readonly) AccountMeta::new(fee_recipient_ata, false), // fee_recipient_ata AccountMeta::new_readonly(base_token_program, false), // TOKEN_PROGRAM_ID (readonly) AccountMeta::new_readonly(quote_token_program, false), // TOKEN_PROGRAM_ID (readonly, duplicated as in JS) crate::constants::SYSTEM_PROGRAM_META, // System Program (readonly) accounts::ASSOCIATED_TOKEN_PROGRAM_META, // ASSOCIATED_TOKEN_PROGRAM_ID (readonly) accounts::EVENT_AUTHORITY_META, // event_authority (readonly) accounts::AMM_PROGRAM_META, // PUMP_AMM_PROGRAM_ID (readonly) AccountMeta::new(params_coin_creator_vault_ata, false), // coin_creator_vault_ata AccountMeta::new_readonly(params_coin_creator_vault_authority, false), // coin_creator_vault_authority (readonly) ]); if quote_is_wsol_or_usdc { accounts.push(accounts::GLOBAL_VOLUME_ACCUMULATOR_META); let uva = get_user_volume_accumulator_pda(¶ms.payer.pubkey()) .ok_or_else(|| anyhow!("user_volume_accumulator PDA derivation failed"))?; accounts.push(AccountMeta::new(uva, false)); } accounts.push(accounts::FEE_CONFIG_META); accounts.push(accounts::FEE_PROGRAM_META); // Cashback: remaining_accounts[0] = WSOL ATA of UserVolumeAccumulator (after named accounts per IDL) if protocol_params.is_cashback_coin { if let Some(wsol_ata) = get_user_volume_accumulator_wsol_ata(¶ms.payer.pubkey()) { accounts.push(AccountMeta::new(wsol_ata, false)); } } // `pool-v2` only when coin_creator ≠ default (@pump-fun/pump-swap-sdk remainingAccounts)； // 否则多出的一格会把 buyback pubkey 错位，触发 BuybackFeeRecipientNotAuthorized（6053）。 if protocol_params.coin_creator != Pubkey::default() { let pool_v2 = get_pool_v2_pda(&base_mint).ok_or_else(|| { anyhow!("pool_v2 PDA derivation failed for base_mint {}", base_mint) })?; accounts.push(AccountMeta::new_readonly(pool_v2, false)); } // Trailing accounts: GlobalConfig.buyback_fee_recipients 中任 pubkey + quote ATA（与 pump-swap-sdk 静态池对齐；轮换时需查链上）。 let protocol_extra = get_protocol_extra_fee_recipient_random(); accounts.push(AccountMeta::new_readonly(protocol_extra, false)); accounts.push(AccountMeta::new( crate::instruction::utils::pumpswap::fee_recipient_ata(protocol_extra, quote_mint), false, )); // buy / buy_exact_quote_in：栈上 `[u8;25]` + `new_with_bytes`，避免每笔 `Vec` 堆分配。 let track_volume: u8 = if protocol_params.is_cashback_coin { 1 } else { 0 }; if quote_is_wsol_or_usdc { let ix_data = if params.fixed_output_amount.is_some() { encode_pumpswap_buy_ix_data(token_amount, sol_amount, track_volume) } else if params.use_exact_sol_amount.unwrap_or(true) { let min_base_amount_out = crate::utils::calc::common::calculate_with_slippage_sell( token_amount, params.slippage_basis_points.unwrap_or(DEFAULT_SLIPPAGE), ); encode_pumpswap_buy_exact_quote_in_ix_data( params.input_amount.unwrap_or(0), min_base_amount_out, track_volume, ) } else { encode_pumpswap_buy_ix_data(token_amount, sol_amount, track_volume) }; instructions.push(Instruction::new_with_bytes( accounts::AMM_PROGRAM, &ix_data, accounts, )); } else { let ix_data = encode_pumpswap_sell_ix_data(sol_amount, token_amount); instructions.push(Instruction::new_with_bytes( accounts::AMM_PROGRAM, &ix_data, accounts, )); } if close_wsol_ata { push_close_wsol_if_needed( &mut instructions, ¶ms.payer.pubkey(), &input_stable_mint, ); } Ok(instructions) } async fn build_sell_instructions(&self, params: &SwapParams) -> Result> { // ======================================== // Parameter validation and basic data preparation // ======================================== let protocol_params = params .protocol_params .as_any() .downcast_ref::() .ok_or_else(|| anyhow!("Invalid protocol params for PumpSwap"))?; let pool = protocol_params.pool; let base_mint = protocol_params.base_mint; let quote_mint = protocol_params.quote_mint; let pool_base_token_reserves = protocol_params.pool_base_token_reserves; let pool_quote_token_reserves = protocol_params.pool_quote_token_reserves; let virtual_quote_reserves = protocol_params.virtual_quote_reserves; protocol_params.effective_quote_reserves()?; let pool_base_token_account = protocol_params.pool_base_token_account; let pool_quote_token_account = protocol_params.pool_quote_token_account; let params_coin_creator_vault_ata = protocol_params.coin_creator_vault_ata; let params_coin_creator_vault_authority = protocol_params.coin_creator_vault_authority; let create_output_ata = params.create_output_mint_ata; let close_wsol_ata = params.close_output_mint_ata; let base_token_program = protocol_params.base_token_program; let quote_token_program = protocol_params.quote_token_program; let is_wsol = (base_mint == crate::constants::WSOL_TOKEN_ACCOUNT && quote_mint != crate::constants::USDC_TOKEN_ACCOUNT) || (quote_mint == crate::constants::WSOL_TOKEN_ACCOUNT && base_mint != crate::constants::USDC_TOKEN_ACCOUNT); let is_usdc = (base_mint == crate::constants::USDC_TOKEN_ACCOUNT && quote_mint != crate::constants::WSOL_TOKEN_ACCOUNT) || (quote_mint == crate::constants::USDC_TOKEN_ACCOUNT && base_mint != crate::constants::WSOL_TOKEN_ACCOUNT); if !is_wsol && !is_usdc { return Err(anyhow!("Pool must contain WSOL or USDC")); } if params.input_amount.unwrap_or_default() == 0 { return Err(anyhow!("Token amount must be greater than zero")); } // ======================================== // Trade calculation and account address preparation // ======================================== let quote_is_wsol_or_usdc = quote_mint == crate::constants::WSOL_TOKEN_ACCOUNT || quote_mint == crate::constants::USDC_TOKEN_ACCOUNT; let output_stable_mint = if quote_is_wsol_or_usdc { quote_mint } else { base_mint }; let output_stable_token_program = if quote_is_wsol_or_usdc { quote_token_program } else { base_token_program }; let fee_basis_points = protocol_params.fee_basis_points; let (token_amount, sol_amount) = if let Some(output_amount) = params.fixed_output_amount { if quote_is_wsol_or_usdc && output_amount > pool_quote_token_reserves { return Err(anyhow!("Minimum quote output exceeds the real quote-vault balance")); } (params.input_amount.unwrap(), output_amount) } else if quote_is_wsol_or_usdc { let result = sell_base_input_internal_with_fees( params.input_amount.unwrap(), params.slippage_basis_points.unwrap_or(DEFAULT_SLIPPAGE), pool_base_token_reserves, pool_quote_token_reserves, virtual_quote_reserves, &fee_basis_points, ) .map_err(anyhow::Error::msg)?; // base_amount_in, min_quote_amount_out (params.input_amount.unwrap(), result.min_quote) } else { let result = buy_quote_input_internal_with_fees( params.input_amount.unwrap(), params.slippage_basis_points.unwrap_or(DEFAULT_SLIPPAGE), pool_base_token_reserves, pool_quote_token_reserves, virtual_quote_reserves, &fee_basis_points, ) .map_err(anyhow::Error::msg)?; // max_quote_amount_in, base_amount_out (result.max_quote, result.base) }; // Determine fee recipient based on mayhem mode (pump-public-docs: 10th = Mayhem fee recipient, 11th = WSOL ATA of Mayhem; use any one randomly) let is_mayhem_mode = protocol_params.is_mayhem_mode; let (fee_recipient, fee_recipient_meta) = if is_mayhem_mode { get_mayhem_fee_recipient_random() } else { let recipient = get_protocol_fee_recipient_random(); (recipient, AccountMeta::new_readonly(recipient, false)) }; let fee_recipient_ata = fee_recipient_ata(fee_recipient, quote_mint); let user_base_token_account = crate::common::fast_fn::get_associated_token_address_with_program_id_fast_use_seed( ¶ms.payer.pubkey(), &base_mint, &base_token_program, params.open_seed_optimize, ); let user_quote_token_account = crate::common::fast_fn::get_associated_token_address_with_program_id_fast_use_seed( ¶ms.payer.pubkey(), "e_mint, "e_token_program, params.open_seed_optimize, ); // ======================================== // Build instructions // ======================================== let mut instructions = Vec::with_capacity(4); if create_output_ata { push_create_user_token_account( &mut instructions, ¶ms.payer.pubkey(), &output_stable_mint, &output_stable_token_program, params.open_seed_optimize, ); } // Create sell instruction let mut accounts = Vec::with_capacity(28); accounts.extend([ AccountMeta::new(pool, false), // pool_id AccountMeta::new(params.payer.pubkey(), true), // user (signer) accounts::GLOBAL_ACCOUNT_META, // global (readonly) AccountMeta::new_readonly(base_mint, false), // mint (readonly) AccountMeta::new_readonly(quote_mint, false), // WSOL_TOKEN_ACCOUNT (readonly) AccountMeta::new(user_base_token_account, false), // user_base_token_account AccountMeta::new(user_quote_token_account, false), // user_quote_token_account AccountMeta::new(pool_base_token_account, false), // pool_base_token_account AccountMeta::new(pool_quote_token_account, false), // pool_quote_token_account fee_recipient_meta, // fee_recipient (readonly) AccountMeta::new(fee_recipient_ata, false), // fee_recipient_ata AccountMeta::new_readonly(base_token_program, false), // TOKEN_PROGRAM_ID (readonly) AccountMeta::new_readonly(quote_token_program, false), // TOKEN_PROGRAM_ID (readonly, duplicated as in JS) crate::constants::SYSTEM_PROGRAM_META, // System Program (readonly) accounts::ASSOCIATED_TOKEN_PROGRAM_META, // ASSOCIATED_TOKEN_PROGRAM_ID (readonly) accounts::EVENT_AUTHORITY_META, // event_authority (readonly) accounts::AMM_PROGRAM_META, // PUMP_AMM_PROGRAM_ID (readonly) AccountMeta::new(params_coin_creator_vault_ata, false), // coin_creator_vault_ata AccountMeta::new_readonly(params_coin_creator_vault_authority, false), // coin_creator_vault_authority (readonly) ]); if !quote_is_wsol_or_usdc { accounts.push(accounts::GLOBAL_VOLUME_ACCUMULATOR_META); let uva = get_user_volume_accumulator_pda(¶ms.payer.pubkey()) .ok_or_else(|| anyhow!("user_volume_accumulator PDA derivation failed"))?; accounts.push(AccountMeta::new(uva, false)); } accounts.push(accounts::FEE_CONFIG_META); accounts.push(accounts::FEE_PROGRAM_META); // Cashback sell: 官方 remainingAccounts = [accumulator 的 quote_mint ATA, accumulator PDA, poolV2]（用 quote_mint 非固定 WSOL） if protocol_params.is_cashback_coin { if let (Some(quote_ata), Some(accumulator)) = ( get_user_volume_accumulator_quote_ata( ¶ms.payer.pubkey(), "e_mint, "e_token_program, ), get_user_volume_accumulator_pda(¶ms.payer.pubkey()), ) { accounts.push(AccountMeta::new(quote_ata, false)); accounts.push(AccountMeta::new(accumulator, false)); } } if protocol_params.coin_creator != Pubkey::default() { let pool_v2 = get_pool_v2_pda(&base_mint).ok_or_else(|| { anyhow!("pool_v2 PDA derivation failed for base_mint {}", base_mint) })?; accounts.push(AccountMeta::new_readonly(pool_v2, false)); } let protocol_extra = get_protocol_extra_fee_recipient_random(); accounts.push(AccountMeta::new_readonly(protocol_extra, false)); accounts.push(AccountMeta::new( crate::instruction::utils::pumpswap::fee_recipient_ata(protocol_extra, quote_mint), false, )); // 栈数组 + `new_with_bytes`，避免 `data.to_vec()`。 let ix_data = if quote_is_wsol_or_usdc { encode_pumpswap_sell_ix_data(token_amount, sol_amount) } else { encode_pumpswap_buy_two_args(sol_amount, token_amount) }; instructions.push(Instruction::new_with_bytes(accounts::AMM_PROGRAM, &ix_data, accounts)); if close_wsol_ata { push_close_wsol_if_needed( &mut instructions, ¶ms.payer.pubkey(), &output_stable_mint, ); } if params.close_input_mint_ata { instructions.push(crate::common::spl_token::close_account( if quote_is_wsol_or_usdc { &base_token_program } else { "e_token_program }, if quote_is_wsol_or_usdc { &user_base_token_account } else { &user_quote_token_account }, ¶ms.payer.pubkey(), ¶ms.payer.pubkey(), &[¶ms.payer.pubkey()], )?); } Ok(instructions) } } /// Claim cashback for PumpSwap (AMM). Transfers WSOL from UserVolumeAccumulator's WSOL ATA to user's WSOL ATA. /// Caller should ensure user's WSOL ATA exists (e.g. create idempotent ATA instruction) before this instruction. pub fn claim_cashback_pumpswap_instruction( payer: &Pubkey, quote_mint: Pubkey, quote_token_program: Pubkey, ) -> Option { const CLAIM_CASHBACK_DISCRIMINATOR: [u8; 8] = [37, 58, 35, 126, 190, 53, 228, 197]; let user_volume_accumulator = get_user_volume_accumulator_pda(payer)?; let user_volume_accumulator_wsol_ata = get_user_volume_accumulator_wsol_ata(payer)?; let user_wsol_ata = crate::common::fast_fn::get_associated_token_address_with_program_id_fast( payer, "e_mint, "e_token_program, ); // IDL order: user, user_volume_accumulator, quote_mint, quote_token_program, // user_volume_accumulator_wsol_token_account, user_wsol_token_account, system_program, event_authority, program let accounts = vec![ AccountMeta::new(*payer, true), // user (signer, writable) AccountMeta::new(user_volume_accumulator, false), // user_volume_accumulator (writable) AccountMeta::new_readonly(quote_mint, false), AccountMeta::new_readonly(quote_token_program, false), AccountMeta::new(user_volume_accumulator_wsol_ata, false), // writable AccountMeta::new(user_wsol_ata, false), // writable crate::constants::SYSTEM_PROGRAM_META, accounts::EVENT_AUTHORITY_META, accounts::AMM_PROGRAM_META, ]; Some(solana_sdk::instruction::Instruction::new_with_bytes( accounts::AMM_PROGRAM, &CLAIM_CASHBACK_DISCRIMINATOR, accounts, )) } #[cfg(test)] mod tests { use super::*; use crate::{ common::GasFeeStrategy, swqos::TradeType, trading::core::params::{DexParamEnum, PumpSwapParams, SwapParams}, }; use solana_sdk::{pubkey::Pubkey, signature::Keypair}; use std::sync::Arc; fn pk(seed: u8) -> Pubkey { Pubkey::new_from_array([seed; 32]) } fn pumpswap_params() -> PumpSwapParams { PumpSwapParams::new( pk(1), pk(2), crate::constants::WSOL_TOKEN_ACCOUNT, pk(3), pk(4), 1_000_000_000, 2_000_000_000, 0, pk(5), accounts::DEFAULT_COIN_CREATOR_VAULT_AUTHORITY, crate::constants::TOKEN_PROGRAM, crate::constants::TOKEN_PROGRAM, accounts::PROTOCOL_FEE_RECIPIENT, Pubkey::default(), false, 0, ) } fn swap_params(trade_type: TradeType, fixed_output_amount: Option) -> SwapParams { let (input_mint, output_mint) = if trade_type == TradeType::Sell { (pk(2), crate::constants::WSOL_TOKEN_ACCOUNT) } else { (crate::constants::WSOL_TOKEN_ACCOUNT, pk(2)) }; SwapParams { rpc: None, payer: Arc::new(Keypair::new()), trade_type, input_mint, input_token_program: None, output_mint, output_token_program: None, input_amount: Some(100_000), slippage_basis_points: Some(100), address_lookup_table_accounts: Vec::new(), recent_blockhash: None, wait_tx_confirmed: false, protocol_params: DexParamEnum::PumpSwap(pumpswap_params()), open_seed_optimize: true, swqos_clients: Arc::new(Vec::new()), middleware_manager: None, durable_nonce: None, with_tip: false, create_input_mint_ata: false, close_input_mint_ata: false, create_output_mint_ata: false, close_output_mint_ata: false, fixed_output_amount, gas_fee_strategy: GasFeeStrategy::new(), simulate: true, log_enabled: false, wait_for_all_submits: false, use_dedicated_sender_threads: false, sender_thread_cores: None, max_sender_concurrency: 0, effective_core_ids: Arc::new(Vec::new()), check_min_tip: false, grpc_recv_us: None, use_exact_sol_amount: Some(true), } } #[tokio::test] async fn pumpswap_fixed_output_uses_buy_with_max_input_budget() { let instructions = PumpSwapInstructionBuilder .build_buy_instructions(&swap_params(TradeType::Buy, Some(42))) .await .unwrap(); let ix = instructions.last().unwrap(); assert_eq!(&ix.data[..8], crate::instruction::utils::pumpswap::BUY_DISCRIMINATOR); assert_eq!(u64::from_le_bytes(ix.data[8..16].try_into().unwrap()), 42); assert_eq!(u64::from_le_bytes(ix.data[16..24].try_into().unwrap()), 100_000); } #[tokio::test] async fn pumpswap_sell_fixed_output_uses_min_quote_directly() { let instructions = PumpSwapInstructionBuilder .build_sell_instructions(&swap_params(TradeType::Sell, Some(42))) .await .unwrap(); let ix = instructions.last().unwrap(); assert_eq!(&ix.data[..8], crate::instruction::utils::pumpswap::SELL_DISCRIMINATOR); assert_eq!(u64::from_le_bytes(ix.data[8..16].try_into().unwrap()), 100_000); assert_eq!(u64::from_le_bytes(ix.data[16..24].try_into().unwrap()), 42); } #[tokio::test] async fn pumpswap_sell_fixed_output_rejects_real_vault_overflow() { let mut params = swap_params(TradeType::Sell, Some(42)); let DexParamEnum::PumpSwap(protocol_params) = &mut params.protocol_params else { unreachable!(); }; protocol_params.pool_quote_token_reserves = 41; let error = PumpSwapInstructionBuilder.build_sell_instructions(¶ms).await.unwrap_err(); assert_eq!(error.to_string(), "Minimum quote output exceeds the real quote-vault balance"); } #[tokio::test] async fn pumpswap_sell_rejects_zero_input() { let mut params = swap_params(TradeType::Sell, None); params.input_amount = Some(0); let error = PumpSwapInstructionBuilder.build_sell_instructions(¶ms).await.unwrap_err(); assert_eq!(error.to_string(), "Token amount must be greater than zero"); } #[tokio::test] async fn pumpswap_usdc_buy_create_input_builds_usdc_ata() { let mut params = swap_params(TradeType::Buy, Some(42)); params.protocol_params = DexParamEnum::PumpSwap(PumpSwapParams::new( pk(1), pk(2), crate::constants::USDC_TOKEN_ACCOUNT, pk(3), pk(4), 1_000_000_000, 2_000_000_000, 0, pk(5), accounts::DEFAULT_COIN_CREATOR_VAULT_AUTHORITY, crate::constants::TOKEN_PROGRAM, crate::constants::TOKEN_PROGRAM, accounts::PROTOCOL_FEE_RECIPIENT, Pubkey::default(), false, 0, )); params.input_mint = crate::constants::USDC_TOKEN_ACCOUNT; params.create_input_mint_ata = true; params.open_seed_optimize = false; let instructions = PumpSwapInstructionBuilder.build_buy_instructions(¶ms).await.unwrap(); let create_ix = instructions.first().unwrap(); assert_eq!(create_ix.program_id, crate::constants::ASSOCIATED_TOKEN_PROGRAM_ID); assert_eq!(create_ix.accounts[3].pubkey, crate::constants::USDC_TOKEN_ACCOUNT); } #[tokio::test] async fn pumpswap_buy_uses_fee_basis_points_from_params_without_rpc() { let mut params = swap_params(TradeType::Buy, None); params.input_amount = Some(1_000_000); params.use_exact_sol_amount = Some(false); let mut protocol_params = pumpswap_params().with_fee_basis_points(20, 5, 75); protocol_params.virtual_quote_reserves = 500_000_000; params.protocol_params = DexParamEnum::PumpSwap(protocol_params); let instructions = PumpSwapInstructionBuilder.build_buy_instructions(¶ms).await.unwrap(); let ix = instructions.last().unwrap(); assert_eq!(&ix.data[..8], crate::instruction::utils::pumpswap::BUY_DISCRIMINATOR); let base_amount_out = u64::from_le_bytes(ix.data[8..16].try_into().unwrap()); let expected = crate::utils::calc::pumpswap::buy_quote_input_internal_with_fees( 1_000_000, 100, 1_000_000_000, 2_000_000_000, 500_000_000, &crate::instruction::utils::pumpswap::PumpSwapFeeBasisPoints::new(20, 5, 0), ) .unwrap(); assert_eq!(base_amount_out, expected.base); } #[tokio::test] async fn pumpswap_sell_prices_with_effective_quote_reserves() { let mut params = swap_params(TradeType::Sell, None); let mut protocol_params = pumpswap_params().with_fee_basis_points(20, 5, 0); protocol_params.virtual_quote_reserves = 500_000_000; params.protocol_params = DexParamEnum::PumpSwap(protocol_params); let instructions = PumpSwapInstructionBuilder.build_sell_instructions(¶ms).await.unwrap(); let ix = instructions.last().unwrap(); let min_quote_amount_out = u64::from_le_bytes(ix.data[16..24].try_into().unwrap()); let expected = crate::utils::calc::pumpswap::sell_base_input_internal_with_fees( 100_000, 100, 1_000_000_000, 2_000_000_000, 500_000_000, &crate::instruction::utils::pumpswap::PumpSwapFeeBasisPoints::new(20, 5, 0), ) .unwrap(); assert_eq!(min_quote_amount_out, expected.min_quote); } }