refactor: reorganize code structure and optimize modular design

- Remove src/common/address_lookup.rs and tip_cache.rs to simplify common modules
- Move protocol-specific utility functions from trading/ to instruction/utils/
- Refactor utility functions for PumpFun, PumpSwap, Raydium AMM V4, and Raydium CPMM
- Consolidate constant definitions by inlining seeds and accounts modules into respective utility files
- Update all import paths to ensure code consistency
- Optimize trading parameter construction and executor logic
- Improve address lookup cache and nonce management mechanisms

src/instruction/utils/bonk.rs

@@ -0,0 +1,156 @@
+use crate::common::SolanaRpcClient;
+use anyhow::anyhow;
+use solana_sdk::pubkey::Pubkey;
+use solana_streamer_sdk::streaming::event_parser::protocols::bonk::{
+    pool_state_decode, types::PoolState,
+};
+
+/// Constants used as seeds for deriving PDAs (Program Derived Addresses)
+pub mod seeds {
+    pub const POOL_SEED: &[u8] = b"pool";
+    pub const POOL_VAULT_SEED: &[u8] = b"pool_vault";
+}
+
+/// Constants related to program accounts and authorities
+pub mod accounts {
+    use solana_sdk::{pubkey, pubkey::Pubkey};
+
+    pub const AUTHORITY: Pubkey = pubkey!("WLHv2UAZm6z4KyaaELi5pjdbJh6RESMva1Rnn8pJVVh");
+    pub const GLOBAL_CONFIG: Pubkey = pubkey!("6s1xP3hpbAfFoNtUNF8mfHsjr2Bd97JxFJRWLbL6aHuX");
+    pub const TOKEN_PROGRAM: Pubkey = spl_token::ID;
+    pub const EVENT_AUTHORITY: Pubkey = pubkey!("2DPAtwB8L12vrMRExbLuyGnC7n2J5LNoZQSejeQGpwkr");
+    pub const WSOL_TOKEN_ACCOUNT: Pubkey = pubkey!("So11111111111111111111111111111111111111112");
+    pub const BONK: Pubkey = pubkey!("LanMV9sAd7wArD4vJFi2qDdfnVhFxYSUg6eADduJ3uj");
+    pub const SYSTEM_PROGRAM: Pubkey = solana_sdk::system_program::ID;
+
+    pub const PLATFORM_FEE_RATE: u128 = 100; // 1%
+    pub const PROTOCOL_FEE_RATE: u128 = 25; // 0.25%
+    pub const SHARE_FEE_RATE: u128 = 0; // 0%
+}
+
+pub const BUY_EXECT_IN_DISCRIMINATOR: [u8; 8] = [250, 234, 13, 123, 213, 156, 19, 236];
+pub const SELL_EXECT_IN_DISCRIMINATOR: [u8; 8] = [149, 39, 222, 155, 211, 124, 152, 26];
+
+pub async fn fetch_pool_state(
+    rpc: &SolanaRpcClient,
+    pool_address: &Pubkey,
+) -> Result<PoolState, anyhow::Error> {
+    let account = rpc.get_account(pool_address).await?;
+    if account.owner != accounts::BONK {
+        return Err(anyhow!("Account is not owned by Bonk program"));
+    }
+    let pool_state = pool_state_decode(&account.data[8..])
+        .ok_or_else(|| anyhow!("Failed to decode pool state"))?;
+    Ok(pool_state)
+}
+
+pub fn get_amount_in_net(
+    amount_in: u64,
+    protocol_fee_rate: u128,
+    platform_fee_rate: u128,
+    share_fee_rate: u128,
+) -> u64 {
+    let amount_in_u128 = amount_in as u128;
+    let protocol_fee = (amount_in_u128 * protocol_fee_rate / 10000) as u128;
+    let platform_fee = (amount_in_u128 * platform_fee_rate / 10000) as u128;
+    let share_fee = (amount_in_u128 * share_fee_rate / 10000) as u128;
+    amount_in_u128
+        .checked_sub(protocol_fee)
+        .unwrap()
+        .checked_sub(platform_fee)
+        .unwrap()
+        .checked_sub(share_fee)
+        .unwrap() as u64
+}
+
+pub fn get_amount_in(
+    amount_out: u64,
+    protocol_fee_rate: u128,
+    platform_fee_rate: u128,
+    share_fee_rate: u128,
+    virtual_base: u128,
+    virtual_quote: u128,
+    real_base: u128,
+    real_quote: u128,
+    slippage_basis_points: u128,
+) -> u64 {
+    let amount_out_u128 = amount_out as u128;
+
+    // 考虑滑点，实际需要的输出金额更高
+    let amount_out_with_slippage = amount_out_u128 * 10000 / (10000 - slippage_basis_points);
+
+    let input_reserve = virtual_quote.checked_add(real_quote).unwrap();
+    let output_reserve = virtual_base.checked_sub(real_base).unwrap();
+
+    // 根据 AMM 公式反推: amount_in_net = (amount_out * input_reserve) / (output_reserve - amount_out)
+    let numerator = amount_out_with_slippage.checked_mul(input_reserve).unwrap();
+    let denominator = output_reserve.checked_sub(amount_out_with_slippage).unwrap();
+    let amount_in_net = numerator.checked_div(denominator).unwrap();
+
+    // 计算总费用率
+    let total_fee_rate = protocol_fee_rate + platform_fee_rate + share_fee_rate;
+
+    let amount_in = amount_in_net * 10000 / (10000 - total_fee_rate);
+
+    amount_in as u64
+}
+
+pub fn get_amount_out(
+    amount_in: u64,
+    protocol_fee_rate: u128,
+    platform_fee_rate: u128,
+    share_fee_rate: u128,
+    virtual_base: u128,
+    virtual_quote: u128,
+    real_base: u128,
+    real_quote: u128,
+    slippage_basis_points: u128,
+) -> u64 {
+    let amount_in_u128 = amount_in as u128;
+    let protocol_fee = (amount_in_u128 * protocol_fee_rate / 10000) as u128;
+    let platform_fee = (amount_in_u128 * platform_fee_rate / 10000) as u128;
+    let share_fee = (amount_in_u128 * share_fee_rate / 10000) as u128;
+    let amount_in_net = amount_in_u128
+        .checked_sub(protocol_fee)
+        .unwrap()
+        .checked_sub(platform_fee)
+        .unwrap()
+        .checked_sub(share_fee)
+        .unwrap();
+    let input_reserve = virtual_quote.checked_add(real_quote).unwrap();
+    let output_reserve = virtual_base.checked_sub(real_base).unwrap();
+    let numerator = amount_in_net.checked_mul(output_reserve).unwrap();
+    let denominator = input_reserve.checked_add(amount_in_net).unwrap();
+    let mut amount_out = numerator.checked_div(denominator).unwrap();
+
+    amount_out = amount_out - (amount_out * slippage_basis_points) / 10000;
+    amount_out as u64
+}
+
+pub fn get_pool_pda(base_mint: &Pubkey, quote_mint: &Pubkey) -> Option<Pubkey> {
+    let seeds: &[&[u8]; 3] = &[seeds::POOL_SEED, base_mint.as_ref(), quote_mint.as_ref()];
+    let program_id: &Pubkey = &accounts::BONK;
+    let pda: Option<(Pubkey, u8)> = Pubkey::try_find_program_address(seeds, program_id);
+    pda.map(|pubkey| pubkey.0)
+}
+
+pub fn get_vault_pda(pool_state: &Pubkey, mint: &Pubkey) -> Option<Pubkey> {
+    let seeds: &[&[u8]; 3] = &[seeds::POOL_VAULT_SEED, pool_state.as_ref(), mint.as_ref()];
+    let program_id: &Pubkey = &accounts::BONK;
+    let pda: Option<(Pubkey, u8)> = Pubkey::try_find_program_address(seeds, program_id);
+    pda.map(|pubkey| pubkey.0)
+}
+
+pub fn get_platform_associated_account(platform_config: &Pubkey) -> Option<Pubkey> {
+    let seeds: &[&[u8]; 2] = &[platform_config.as_ref(), accounts::WSOL_TOKEN_ACCOUNT.as_ref()];
+    let program_id: &Pubkey = &accounts::BONK;
+    let pda: Option<(Pubkey, u8)> = Pubkey::try_find_program_address(seeds, program_id);
+    pda.map(|pubkey| pubkey.0)
+}
+
+pub fn get_creator_associated_account(creator: &Pubkey) -> Option<Pubkey> {
+    let seeds: &[&[u8]; 2] = &[creator.as_ref(), accounts::WSOL_TOKEN_ACCOUNT.as_ref()];
+    let program_id: &Pubkey = &accounts::BONK;
+    let pda: Option<(Pubkey, u8)> = Pubkey::try_find_program_address(seeds, program_id);
+    pda.map(|pubkey| pubkey.0)
+}

src/instruction/utils/mod.rs

@@ -0,0 +1,5 @@
+pub mod bonk;
+pub mod pumpfun;
+pub mod pumpswap;
+pub mod raydium_amm_v4;
+pub mod raydium_cpmm;

src/instruction/utils/pumpfun.rs

@@ -0,0 +1,259 @@
+use crate::solana_streamer_sdk::streaming::event_parser::protocols::pumpfun::PumpFunTradeEvent;
+use crate::{
+    common::{bonding_curve::BondingCurveAccount, global::GlobalAccount, SolanaRpcClient},
+    constants::{self, trade::trade::DEFAULT_SLIPPAGE},
+};
+use anyhow::anyhow;
+use solana_sdk::pubkey::Pubkey;
+use std::{collections::HashMap, sync::Arc};
+use tokio::sync::RwLock;
+
+/// Constants used as seeds for deriving PDAs (Program Derived Addresses)
+pub mod seeds {
+    /// Seed for the global state PDA
+    pub const GLOBAL_SEED: &[u8] = b"global";
+
+    /// Seed for the mint authority PDA
+    pub const MINT_AUTHORITY_SEED: &[u8] = b"mint-authority";
+
+    /// Seed for bonding curve PDAs
+    pub const BONDING_CURVE_SEED: &[u8] = b"bonding-curve";
+
+    /// Seed for creator vault PDAs
+    pub const CREATOR_VAULT_SEED: &[u8] = b"creator-vault";
+
+    /// Seed for metadata PDAs
+    pub const METADATA_SEED: &[u8] = b"metadata";
+
+    /// Seed for user volume accumulator PDAs
+    pub const USER_VOLUME_ACCUMULATOR_SEED: &[u8] = b"user_volume_accumulator";
+
+    /// Seed for global volume accumulator PDAs
+    pub const GLOBAL_VOLUME_ACCUMULATOR_SEED: &[u8] = b"global_volume_accumulator";
+
+    pub const FEE_CONFIG_SEED: &[u8] = b"fee_config";
+}
+
+pub mod global_constants {
+    use solana_sdk::{pubkey, pubkey::Pubkey};
+
+    pub const INITIAL_VIRTUAL_TOKEN_RESERVES: u64 = 1_073_000_000_000_000;
+
+    pub const INITIAL_VIRTUAL_SOL_RESERVES: u64 = 30_000_000_000;
+
+    pub const INITIAL_REAL_TOKEN_RESERVES: u64 = 793_100_000_000_000;
+
+    pub const TOKEN_TOTAL_SUPPLY: u64 = 1_000_000_000_000_000;
+
+    pub const FEE_BASIS_POINTS: u64 = 95;
+
+    pub const ENABLE_MIGRATE: bool = false;
+
+    pub const POOL_MIGRATION_FEE: u64 = 15_000_001;
+
+    pub const CREATOR_FEE: u64 = 5;
+
+    pub const SCALE: u64 = 1_000_000; // 10^6 for token decimals
+
+    pub const LAMPORTS_PER_SOL: u64 = 1_000_000_000; // 10^9 for solana lamports
+
+    pub const COMPLETION_LAMPORTS: u64 = 85 * LAMPORTS_PER_SOL; // ~ 85 SOL
+
+    /// Public key for the fee recipient
+    pub const FEE_RECIPIENT: Pubkey = pubkey!("62qc2CNXwrYqQScmEdiZFFAnJR262PxWEuNQtxfafNgV");
+
+    /// Public key for the global PDA
+    pub const GLOBAL_ACCOUNT: Pubkey = pubkey!("4wTV1YmiEkRvAtNtsSGPtUrqRYQMe5SKy2uB4Jjaxnjf");
+
+    /// Public key for the authority
+    pub const AUTHORITY: Pubkey = pubkey!("FFWtrEQ4B4PKQoVuHYzZq8FabGkVatYzDpEVHsK5rrhF");
+
+    /// Public key for the withdraw authority
+    pub const WITHDRAW_AUTHORITY: Pubkey = pubkey!("39azUYFWPz3VHgKCf3VChUwbpURdCHRxjWVowf5jUJjg");
+
+    pub const PUMPFUN_AMM_FEE_1: Pubkey = pubkey!("7VtfL8fvgNfhz17qKRMjzQEXgbdpnHHHQRh54R9jP2RJ"); // Pump.fun AMM: Protocol Fee 1
+    pub const PUMPFUN_AMM_FEE_2: Pubkey = pubkey!("7hTckgnGnLQR6sdH7YkqFTAA7VwTfYFaZ6EhEsU3saCX"); // Pump.fun AMM: Protocol Fee 2
+    pub const PUMPFUN_AMM_FEE_3: Pubkey = pubkey!("9rPYyANsfQZw3DnDmKE3YCQF5E8oD89UXoHn9JFEhJUz"); // Pump.fun AMM: Protocol Fee 3
+    pub const PUMPFUN_AMM_FEE_4: Pubkey = pubkey!("AVmoTthdrX6tKt4nDjco2D775W2YK3sDhxPcMmzUAmTY"); // Pump.fun AMM: Protocol Fee 4
+    pub const PUMPFUN_AMM_FEE_5: Pubkey = pubkey!("CebN5WGQ4jvEPvsVU4EoHEpgzq1VV7AbicfhtW4xC9iM"); // Pump.fun AMM: Protocol Fee 5
+    pub const PUMPFUN_AMM_FEE_6: Pubkey = pubkey!("FWsW1xNtWscwNmKv6wVsU1iTzRN6wmmk3MjxRP5tT7hz"); // Pump.fun AMM: Protocol Fee 6
+    pub const PUMPFUN_AMM_FEE_7: Pubkey = pubkey!("G5UZAVbAf46s7cKWoyKu8kYTip9DGTpbLZ2qa9Aq69dP");
+    // Pump.fun AMM: Protocol Fee 7
+}
+
+/// Constants related to program accounts and authorities
+pub mod accounts {
+    use solana_sdk::{pubkey, pubkey::Pubkey};
+
+    /// Public key for the Pump.fun program
+    pub const PUMPFUN: Pubkey = pubkey!("6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P");
+
+    /// Public key for the MPL Token Metadata program
+    pub const MPL_TOKEN_METADATA: Pubkey = pubkey!("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
+
+    /// Authority for program events
+    pub const EVENT_AUTHORITY: Pubkey = pubkey!("Ce6TQqeHC9p8KetsN6JsjHK7UTZk7nasjjnr7XxXp9F1");
+
+    /// System Program ID
+    pub const SYSTEM_PROGRAM: Pubkey = pubkey!("11111111111111111111111111111111");
+
+    /// Token Program ID
+    pub const TOKEN_PROGRAM: Pubkey = spl_token::ID;
+
+    /// Associated Token Program ID
+    pub const ASSOCIATED_TOKEN_PROGRAM: Pubkey =
+        pubkey!("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
+
+    /// Rent Sysvar ID
+    pub const RENT: Pubkey = pubkey!("SysvarRent111111111111111111111111111111111");
+
+    pub const AMM_PROGRAM: Pubkey = pubkey!("675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8");
+
+    pub const FEE_PROGRAM: Pubkey = pubkey!("pfeeUxB6jkeY1Hxd7CsFCAjcbHA9rWtchMGdZ6VojVZ");
+}
+
+pub struct Symbol;
+
+impl Symbol {
+    pub const SOLANA: &'static str = "solana";
+}
+
+lazy_static::lazy_static! {
+    static ref ACCOUNT_CACHE: RwLock<HashMap<Pubkey, Arc<GlobalAccount>>> = RwLock::new(HashMap::new());
+}
+
+#[inline]
+pub fn get_global_pda() -> Pubkey {
+    static GLOBAL_PDA: once_cell::sync::Lazy<Pubkey> = once_cell::sync::Lazy::new(|| {
+        Pubkey::find_program_address(&[seeds::GLOBAL_SEED], &accounts::PUMPFUN).0
+    });
+    *GLOBAL_PDA
+}
+
+#[inline]
+pub fn get_mint_authority_pda() -> Pubkey {
+    static MINT_AUTHORITY_PDA: once_cell::sync::Lazy<Pubkey> = once_cell::sync::Lazy::new(|| {
+        Pubkey::find_program_address(&[seeds::MINT_AUTHORITY_SEED], &accounts::PUMPFUN).0
+    });
+    *MINT_AUTHORITY_PDA
+}
+
+#[inline]
+pub fn get_bonding_curve_pda(mint: &Pubkey) -> Option<Pubkey> {
+    let seeds: &[&[u8]; 2] = &[seeds::BONDING_CURVE_SEED, mint.as_ref()];
+    let program_id: &Pubkey = &accounts::PUMPFUN;
+    let pda: Option<(Pubkey, u8)> = Pubkey::try_find_program_address(seeds, program_id);
+    pda.map(|pubkey| pubkey.0)
+}
+
+#[inline]
+pub fn get_creator_vault_pda(creator: &Pubkey) -> Option<Pubkey> {
+    let seeds: &[&[u8]; 2] = &[seeds::CREATOR_VAULT_SEED, creator.as_ref()];
+    let program_id: &Pubkey = &accounts::PUMPFUN;
+    let pda: Option<(Pubkey, u8)> = Pubkey::try_find_program_address(seeds, program_id);
+    pda.map(|pubkey| pubkey.0)
+}
+
+#[inline]
+pub fn get_user_volume_accumulator_pda(user: &Pubkey) -> Option<Pubkey> {
+    let seeds: &[&[u8]; 2] = &[seeds::USER_VOLUME_ACCUMULATOR_SEED, user.as_ref()];
+    let program_id: &Pubkey = &accounts::PUMPFUN;
+    let pda: Option<(Pubkey, u8)> = Pubkey::try_find_program_address(seeds, program_id);
+    pda.map(|pubkey| pubkey.0)
+}
+
+#[inline]
+pub fn get_global_volume_accumulator_pda() -> Option<Pubkey> {
+    let seeds: &[&[u8]; 1] = &[seeds::GLOBAL_VOLUME_ACCUMULATOR_SEED];
+    let program_id: &Pubkey = &accounts::PUMPFUN;
+    let pda: Option<(Pubkey, u8)> = Pubkey::try_find_program_address(seeds, program_id);
+    pda.map(|pubkey| pubkey.0)
+}
+
+#[inline]
+pub fn get_fee_config_pda() -> Option<Pubkey> {
+    let seeds: &[&[u8]; 2] = &[seeds::FEE_CONFIG_SEED, accounts::PUMPFUN.as_ref()];
+    let program_id: &Pubkey = &accounts::FEE_PROGRAM;
+    let pda: Option<(Pubkey, u8)> = Pubkey::try_find_program_address(seeds, program_id);
+    pda.map(|pubkey| pubkey.0)
+}
+
+#[inline]
+pub fn get_metadata_pda(mint: &Pubkey) -> Pubkey {
+    Pubkey::find_program_address(
+        &[seeds::METADATA_SEED, accounts::MPL_TOKEN_METADATA.as_ref(), mint.as_ref()],
+        &accounts::MPL_TOKEN_METADATA,
+    )
+    .0
+}
+
+#[inline]
+pub async fn get_global_account(/*rpc: &SolanaRpcClient*/
+) -> Result<Arc<GlobalAccount>, anyhow::Error> {
+    let global_account = GlobalAccount::new();
+    let global_account = Arc::new(global_account);
+    Ok(global_account)
+}
+
+#[inline]
+pub async fn get_initial_buy_price(
+    global_account: &Arc<GlobalAccount>,
+    amount_sol: u64,
+) -> Result<u64, anyhow::Error> {
+    let buy_amount = global_account.get_initial_buy_price(amount_sol);
+    Ok(buy_amount)
+}
+
+#[inline]
+pub async fn fetch_bonding_curve_account(
+    rpc: &SolanaRpcClient,
+    mint: &Pubkey,
+) -> Result<(Arc<crate::solana_streamer_sdk::streaming::event_parser::protocols::pumpfun::types::BondingCurve>, Pubkey), anyhow::Error>{
+    let bonding_curve_pda: Pubkey =
+        get_bonding_curve_pda(mint).ok_or(anyhow!("Bonding curve not found"))?;
+
+    let account = rpc.get_account(&bonding_curve_pda).await?;
+    if account.data.is_empty() {
+        return Err(anyhow!("Bonding curve not found"));
+    }
+
+    let bonding_curve = solana_sdk::borsh1::try_from_slice_unchecked::<crate::solana_streamer_sdk::streaming::event_parser::protocols::pumpfun::types::BondingCurve>(&account.data[8..])
+        .map_err(|e| anyhow::anyhow!("Failed to deserialize bonding curve account: {}", e))?;
+
+    Ok((Arc::new(bonding_curve), bonding_curve_pda))
+}
+
+#[inline]
+pub async fn init_bonding_curve_account(
+    mint: &Pubkey,
+    dev_buy_token: u64,
+    dev_sol_cost: u64,
+    creator: Pubkey,
+) -> Result<Arc<BondingCurveAccount>, anyhow::Error> {
+    let bonding_curve =
+        BondingCurveAccount::from_dev_trade(mint, dev_buy_token, dev_sol_cost, creator);
+    let bonding_curve = Arc::new(bonding_curve);
+    Ok(bonding_curve)
+}
+
+#[inline]
+pub fn get_buy_amount_with_slippage(amount_sol: u64, slippage_basis_points: Option<u64>) -> u64 {
+    let slippage = slippage_basis_points.unwrap_or(DEFAULT_SLIPPAGE);
+    amount_sol + (amount_sol * slippage / 10000)
+}
+
+#[inline]
+pub fn get_buy_price(amount: u64, trade_info: &PumpFunTradeEvent) -> u64 {
+    if amount == 0 {
+        return 0;
+    }
+
+    let n: u128 =
+        (trade_info.virtual_sol_reserves as u128) * (trade_info.virtual_token_reserves as u128);
+    let i: u128 = (trade_info.virtual_sol_reserves as u128) + (amount as u128);
+    let r: u128 = n / i + 1;
+    let s: u128 = (trade_info.virtual_token_reserves as u128) - r;
+    let s_u64 = s as u64;
+
+    s_u64.min(trade_info.real_token_reserves)
+}

src/instruction/utils/pumpswap.rs

@@ -0,0 +1,235 @@
+use crate::{common::SolanaRpcClient, constants};
+use anyhow::anyhow;
+use solana_account_decoder::UiAccountEncoding;
+use solana_sdk::pubkey::Pubkey;
+use solana_streamer_sdk::streaming::event_parser::protocols::pumpswap::types::{pool_decode, Pool};
+
+/// Constants used as seeds for deriving PDAs (Program Derived Addresses)
+pub mod seeds {
+    /// Seed for the global state PDA
+    pub const GLOBAL_SEED: &[u8] = b"global";
+
+    /// Seed for the mint authority PDA
+    pub const MINT_AUTHORITY_SEED: &[u8] = b"mint-authority";
+
+    /// Seed for bonding curve PDAs
+    pub const BONDING_CURVE_SEED: &[u8] = b"bonding-curve";
+
+    /// Seed for metadata PDAs
+    pub const METADATA_SEED: &[u8] = b"metadata";
+
+    pub const USER_VOLUME_ACCUMULATOR_SEED: &[u8] = b"user_volume_accumulator";
+    pub const GLOBAL_VOLUME_ACCUMULATOR_SEED: &[u8] = b"global_volume_accumulator";
+    pub const FEE_CONFIG_SEED: &[u8] = b"fee_config";
+}
+
+/// Constants related to program accounts and authorities
+pub mod accounts {
+    use solana_sdk::{pubkey, pubkey::Pubkey};
+
+    /// Public key for the fee recipient
+    pub const FEE_RECIPIENT: Pubkey = pubkey!("62qc2CNXwrYqQScmEdiZFFAnJR262PxWEuNQtxfafNgV");
+
+    /// Public key for the global PDA
+    pub const GLOBAL_ACCOUNT: Pubkey = pubkey!("ADyA8hdefvWN2dbGGWFotbzWxrAvLW83WG6QCVXvJKqw");
+
+    /// Authority for program events
+    pub const EVENT_AUTHORITY: Pubkey = pubkey!("GS4CU59F31iL7aR2Q8zVS8DRrcRnXX1yjQ66TqNVQnaR");
+
+    pub const WSOL_TOKEN_ACCOUNT: Pubkey = pubkey!("So11111111111111111111111111111111111111112");
+
+    /// System Program ID
+    pub const SYSTEM_PROGRAM: Pubkey = pubkey!("11111111111111111111111111111111");
+
+    /// Token Program ID
+    pub const TOKEN_PROGRAM: Pubkey = spl_token::ID;
+
+    /// Associated Token Program ID
+    pub const ASSOCIATED_TOKEN_PROGRAM: Pubkey =
+        pubkey!("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
+
+    // PumpSwap 协议费用接收者
+    pub const PROTOCOL_FEE_RECIPIENT: Pubkey =
+        pubkey!("62qc2CNXwrYqQScmEdiZFFAnJR262PxWEuNQtxfafNgV");
+
+    /// Rent Sysvar ID
+    pub const RENT: Pubkey = pubkey!("SysvarRent111111111111111111111111111111111");
+
+    pub const AMM_PROGRAM: Pubkey = pubkey!("pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA");
+
+    pub const LP_FEE_BASIS_POINTS: u64 = 20;
+    pub const PROTOCOL_FEE_BASIS_POINTS: u64 = 5;
+    pub const COIN_CREATOR_FEE_BASIS_POINTS: u64 = 5;
+
+    pub const FEE_PROGRAM: Pubkey = pubkey!("pfeeUxB6jkeY1Hxd7CsFCAjcbHA9rWtchMGdZ6VojVZ");
+}
+
+pub const BUY_DISCRIMINATOR: [u8; 8] = [102, 6, 61, 18, 1, 218, 235, 234];
+pub const SELL_DISCRIMINATOR: [u8; 8] = [51, 230, 133, 164, 1, 127, 131, 173];
+
+// Find a pool for a specific mint
+pub async fn find_pool(rpc: &SolanaRpcClient, mint: &Pubkey) -> Result<Pubkey, anyhow::Error> {
+    let (pool_address, _) = find_by_mint(rpc, mint).await?;
+    Ok(pool_address)
+}
+
+pub(crate) fn coin_creator_vault_authority(coin_creator: Pubkey) -> Pubkey {
+    let (pump_pool_authority, _) = Pubkey::find_program_address(
+        &[b"creator_vault", &coin_creator.to_bytes()],
+        &accounts::AMM_PROGRAM,
+    );
+    pump_pool_authority
+}
+
+pub(crate) fn coin_creator_vault_ata(coin_creator: Pubkey, quote_mint: Pubkey) -> Pubkey {
+    let creator_vault_authority = coin_creator_vault_authority(coin_creator);
+    let associated_token_creator_vault_authority =
+        spl_associated_token_account::get_associated_token_address_with_program_id(
+            &creator_vault_authority,
+            &quote_mint,
+            &accounts::TOKEN_PROGRAM,
+        );
+    associated_token_creator_vault_authority
+}
+
+pub(crate) fn fee_recipient_ata(fee_recipient: Pubkey, quote_mint: Pubkey) -> Pubkey {
+    let associated_token_fee_recipient =
+        spl_associated_token_account::get_associated_token_address_with_program_id(
+            &fee_recipient,
+            &quote_mint,
+            &accounts::TOKEN_PROGRAM,
+        );
+    associated_token_fee_recipient
+}
+
+pub fn get_user_volume_accumulator_pda(user: &Pubkey) -> Option<Pubkey> {
+    let seeds: &[&[u8]; 2] = &[&seeds::USER_VOLUME_ACCUMULATOR_SEED, user.as_ref()];
+    let program_id: &Pubkey = &&accounts::AMM_PROGRAM;
+    let pda: Option<(Pubkey, u8)> = Pubkey::try_find_program_address(seeds, program_id);
+    pda.map(|pubkey| pubkey.0)
+}
+
+pub fn get_global_volume_accumulator_pda() -> Option<Pubkey> {
+    let seeds: &[&[u8]; 1] = &[&seeds::GLOBAL_VOLUME_ACCUMULATOR_SEED];
+    let program_id: &Pubkey = &&accounts::AMM_PROGRAM;
+    let pda: Option<(Pubkey, u8)> = Pubkey::try_find_program_address(seeds, program_id);
+    pda.map(|pubkey| pubkey.0)
+}
+
+pub async fn fetch_pool(
+    rpc: &SolanaRpcClient,
+    pool_address: &Pubkey,
+) -> Result<Pool, anyhow::Error> {
+    let account = rpc.get_account(pool_address).await?;
+    if account.owner != accounts::AMM_PROGRAM {
+        return Err(anyhow!("Account is not owned by PumpSwap program"));
+    }
+    let pool = pool_decode(&account.data[8..]).ok_or_else(|| anyhow!("Failed to decode pool"))?;
+    Ok(pool)
+}
+
+pub async fn find_by_base_mint(
+    rpc: &SolanaRpcClient,
+    base_mint: &Pubkey,
+) -> Result<(Pubkey, Pool), anyhow::Error> {
+    // 使用getProgramAccounts查找给定mint的池子
+    let filters = vec![
+        // solana_rpc_client_api::filter::RpcFilterType::DataSize(211), // Pool账户的大小
+        solana_rpc_client_api::filter::RpcFilterType::Memcmp(
+            solana_client::rpc_filter::Memcmp::new_base58_encoded(43, &base_mint.to_bytes()),
+        ),
+    ];
+    let config = solana_rpc_client_api::config::RpcProgramAccountsConfig {
+        filters: Some(filters),
+        account_config: solana_rpc_client_api::config::RpcAccountInfoConfig {
+            encoding: Some(UiAccountEncoding::Base64),
+            data_slice: None,
+            commitment: None,
+            min_context_slot: None,
+        },
+        with_context: None,
+        sort_results: None,
+    };
+    let program_id = accounts::AMM_PROGRAM;
+    let accounts = rpc.get_program_accounts_with_config(&program_id, config).await?;
+    if accounts.is_empty() {
+        return Err(anyhow!("No pool found for mint {}", base_mint));
+    }
+    let mut pools: Vec<_> = accounts
+        .into_iter()
+        .filter_map(|(addr, acc)| pool_decode(&acc.data).map(|pool| (addr, pool)))
+        .collect();
+    pools.sort_by(|a, b| b.1.lp_supply.cmp(&a.1.lp_supply));
+    let (address, pool) = pools[0].clone();
+    Ok((address, pool))
+}
+
+pub async fn find_by_quote_mint(
+    rpc: &SolanaRpcClient,
+    quote_mint: &Pubkey,
+) -> Result<(Pubkey, Pool), anyhow::Error> {
+    // 使用getProgramAccounts查找给定mint的池子
+    let filters = vec![
+        // solana_rpc_client_api::filter::RpcFilterType::DataSize(211), // Pool账户的大小
+        solana_rpc_client_api::filter::RpcFilterType::Memcmp(
+            solana_client::rpc_filter::Memcmp::new_base58_encoded(75, &quote_mint.to_bytes()),
+        ),
+    ];
+    let config = solana_rpc_client_api::config::RpcProgramAccountsConfig {
+        filters: Some(filters),
+        account_config: solana_rpc_client_api::config::RpcAccountInfoConfig {
+            encoding: Some(UiAccountEncoding::Base64),
+            data_slice: None,
+            commitment: None,
+            min_context_slot: None,
+        },
+        with_context: None,
+        sort_results: None,
+    };
+    let program_id = accounts::AMM_PROGRAM;
+    let accounts = rpc.get_program_accounts_with_config(&program_id, config).await?;
+    if accounts.is_empty() {
+        return Err(anyhow!("No pool found for mint {}", quote_mint));
+    }
+    let mut pools: Vec<_> = accounts
+        .into_iter()
+        .filter_map(|(addr, acc)| pool_decode(&acc.data).map(|pool| (addr, pool)))
+        .collect();
+    pools.sort_by(|a, b| b.1.lp_supply.cmp(&a.1.lp_supply));
+    let (address, pool) = pools[0].clone();
+    Ok((address, pool))
+}
+
+pub async fn find_by_mint(
+    rpc: &SolanaRpcClient,
+    mint: &Pubkey,
+) -> Result<(Pubkey, Pool), anyhow::Error> {
+    if let Ok((address, pool)) = find_by_base_mint(rpc, mint).await {
+        return Ok((address, pool));
+    }
+    if let Ok((address, pool)) = find_by_quote_mint(rpc, mint).await {
+        return Ok((address, pool));
+    }
+    Err(anyhow!("No pool found for mint {}", mint))
+}
+
+pub async fn get_token_balances(
+    pool: &Pool,
+    rpc: &SolanaRpcClient,
+) -> Result<(u64, u64), anyhow::Error> {
+    let base_balance = rpc.get_token_account_balance(&pool.pool_base_token_account).await?;
+    let quote_balance = rpc.get_token_account_balance(&pool.pool_quote_token_account).await?;
+
+    let base_amount = base_balance.amount.parse::<u64>().map_err(|e| anyhow!(e))?;
+    let quote_amount = quote_balance.amount.parse::<u64>().map_err(|e| anyhow!(e))?;
+
+    Ok((base_amount, quote_amount))
+}
+
+#[inline]
+pub fn get_fee_config_pda() -> Option<Pubkey> {
+    let seeds: &[&[u8]; 2] = &[seeds::FEE_CONFIG_SEED, accounts::AMM_PROGRAM.as_ref()];
+    let program_id: &Pubkey = &accounts::FEE_PROGRAM;
+    let pda: Option<(Pubkey, u8)> = Pubkey::try_find_program_address(seeds, program_id);
+    pda.map(|pubkey| pubkey.0)
+}

src/instruction/utils/raydium_amm_v4.rs

@@ -0,0 +1,36 @@
+use anyhow::anyhow;
+use solana_sdk::pubkey::Pubkey;
+use solana_streamer_sdk::streaming::event_parser::protocols::raydium_amm_v4::types::{
+    amm_info_decode, AmmInfo,
+};
+
+use crate::common::SolanaRpcClient;
+
+/// Constants used as seeds for deriving PDAs (Program Derived Addresses)
+pub mod seeds {
+    pub const POOL_SEED: &[u8] = b"pool";
+}
+
+/// Constants related to program accounts and authorities
+pub mod accounts {
+    use solana_sdk::{pubkey, pubkey::Pubkey};
+    pub const AUTHORITY: Pubkey = pubkey!("5Q544fKrFoe6tsEbD7S8EmxGTJYAKtTVhAW5Q5pge4j1");
+    pub const TOKEN_PROGRAM: Pubkey = spl_token::ID;
+    pub const WSOL_TOKEN_ACCOUNT: Pubkey = pubkey!("So11111111111111111111111111111111111111112");
+    pub const RAYDIUM_AMM_V4: Pubkey = pubkey!("675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8");
+
+    pub const TRADE_FEE_NUMERATOR: u64 = 25;
+    pub const TRADE_FEE_DENOMINATOR: u64 = 10000;
+    pub const SWAP_FEE_NUMERATOR: u64 = 25;
+    pub const SWAP_FEE_DENOMINATOR: u64 = 10000;
+}
+
+pub const SWAP_BASE_IN_DISCRIMINATOR: &[u8] = &[9];
+pub const SWAP_BASE_OUT_DISCRIMINATOR: &[u8] = &[11];
+
+pub async fn fetch_amm_info(rpc: &SolanaRpcClient, amm: Pubkey) -> Result<AmmInfo, anyhow::Error> {
+    let amm_info = rpc.get_account_data(&amm).await?;
+    let amm_info =
+        amm_info_decode(&amm_info).ok_or_else(|| anyhow!("Failed to decode amm info"))?;
+    Ok(amm_info)
+}

src/instruction/utils/raydium_cpmm.rs

@@ -0,0 +1,112 @@
+use crate::common::SolanaRpcClient;
+use anyhow::anyhow;
+use solana_sdk::pubkey::Pubkey;
+use solana_streamer_sdk::streaming::event_parser::protocols::raydium_cpmm::types::{
+    pool_state_decode, PoolState,
+};
+
+/// Constants used as seeds for deriving PDAs (Program Derived Addresses)
+pub mod seeds {
+    pub const POOL_SEED: &[u8] = b"pool";
+    pub const POOL_VAULT_SEED: &[u8] = b"pool_vault";
+    pub const OBSERVATION_STATE_SEED: &[u8] = b"observation";
+}
+
+/// Constants related to program accounts and authorities
+pub mod accounts {
+    use solana_sdk::{pubkey, pubkey::Pubkey};
+    pub const AUTHORITY: Pubkey = pubkey!("GpMZbSM2GgvTKHJirzeGfMFoaZ8UR2X7F4v8vHTvxFbL");
+    pub const AMM_CONFIG: Pubkey = pubkey!("D4FPEruKEHrG5TenZ2mpDGEfu1iUvTiqBxvpU8HLBvC2");
+    pub const TOKEN_PROGRAM: Pubkey = spl_token::ID;
+    pub const WSOL_TOKEN_ACCOUNT: Pubkey = pubkey!("So11111111111111111111111111111111111111112");
+    pub const RAYDIUM_CPMM: Pubkey = pubkey!("CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C");
+
+    pub const FEE_RATE_DENOMINATOR_VALUE: u128 = 1_000_000;
+    pub const TRADE_FEE_RATE: u64 = 2500;
+    pub const CREATOR_FEE_RATE: u64 = 0;
+    pub const PROTOCOL_FEE_RATE: u64 = 120000;
+    pub const FUND_FEE_RATE: u64 = 40000;
+}
+
+pub const SWAP_BASE_IN_DISCRIMINATOR: &[u8] = &[143, 190, 90, 218, 196, 30, 51, 222];
+pub const SWAP_BASE_OUT_DISCRIMINATOR: &[u8] = &[55, 217, 98, 86, 163, 74, 180, 173];
+
+pub async fn fetch_pool_state(
+    rpc: &SolanaRpcClient,
+    pool_address: &Pubkey,
+) -> Result<PoolState, anyhow::Error> {
+    let account = rpc.get_account(pool_address).await?;
+    if account.owner != accounts::RAYDIUM_CPMM {
+        return Err(anyhow!("Account is not owned by Raydium Cpmm program"));
+    }
+    let pool_state = pool_state_decode(&account.data[8..])
+        .ok_or_else(|| anyhow!("Failed to decode pool state"))?;
+    Ok(pool_state)
+}
+
+pub fn get_pool_pda(amm_config: &Pubkey, mint1: &Pubkey, mint2: &Pubkey) -> Option<Pubkey> {
+    let seeds: &[&[u8]; 4] =
+        &[seeds::POOL_SEED, amm_config.as_ref(), mint1.as_ref(), mint2.as_ref()];
+    let program_id: &Pubkey = &accounts::RAYDIUM_CPMM;
+    let pda: Option<(Pubkey, u8)> = Pubkey::try_find_program_address(seeds, program_id);
+    pda.map(|pubkey| pubkey.0)
+}
+
+pub fn get_vault_pda(pool_state: &Pubkey, mint: &Pubkey) -> Option<Pubkey> {
+    let seeds: &[&[u8]; 3] = &[seeds::POOL_VAULT_SEED, pool_state.as_ref(), mint.as_ref()];
+    let program_id: &Pubkey = &accounts::RAYDIUM_CPMM;
+    let pda: Option<(Pubkey, u8)> = Pubkey::try_find_program_address(seeds, program_id);
+    pda.map(|pubkey| pubkey.0)
+}
+
+pub fn get_observation_state_pda(pool_state: &Pubkey) -> Option<Pubkey> {
+    let seeds: &[&[u8]; 2] = &[seeds::OBSERVATION_STATE_SEED, pool_state.as_ref()];
+    let program_id: &Pubkey = &accounts::RAYDIUM_CPMM;
+    let pda: Option<(Pubkey, u8)> = Pubkey::try_find_program_address(seeds, program_id);
+    pda.map(|pubkey| pubkey.0)
+}
+
+/// 获取池子中两个代币的余额
+///
+/// # 返回值
+/// 返回 token0_balance, token1_balance
+pub async fn get_pool_token_balances(
+    rpc: &SolanaRpcClient,
+    pool_state: &Pubkey,
+    token0_mint: &Pubkey,
+    token1_mint: &Pubkey,
+) -> Result<(u64, u64), anyhow::Error> {
+    let token0_vault = get_vault_pda(pool_state, token0_mint).unwrap();
+    let token0_balance = rpc.get_token_account_balance(&token0_vault).await?;
+    let token1_vault = get_vault_pda(pool_state, token1_mint).unwrap();
+    let token1_balance = rpc.get_token_account_balance(&token1_vault).await?;
+
+    // 解析余额字符串为 u64
+    let token0_amount =
+        token0_balance.amount.parse::<u64>().map_err(|e| anyhow!("解析 token0 余额失败: {}", e))?;
+
+    let token1_amount =
+        token1_balance.amount.parse::<u64>().map_err(|e| anyhow!("解析 token1 余额失败: {}", e))?;
+
+    Ok((token0_amount, token1_amount))
+}
+
+/// 计算代币价格 (token1/token0)
+///
+/// # 返回值
+/// 返回 token1 相对于 token0 的价格
+pub async fn calculate_price(
+    token0_amount: u64,
+    token1_amount: u64,
+    mint0_decimals: u8,
+    mint1_decimals: u8,
+) -> Result<f64, anyhow::Error> {
+    if token0_amount == 0 {
+        return Err(anyhow!("Token0 余额为零，无法计算价格"));
+    }
+    // 考虑小数位精度
+    let token0_adjusted = token0_amount as f64 / 10_f64.powi(mint0_decimals as i32);
+    let token1_adjusted = token1_amount as f64 / 10_f64.powi(mint1_decimals as i32);
+    let price = token1_adjusted / token0_adjusted;
+    Ok(price)
+}