refactor: remove solana-streamer-sdk dependency and migrate type definitions locally

This refactoring migrates protocol-related type definitions from solana-streamer-sdk to local modules:

- Add local type files: bonk_types.rs, pumpswap_types.rs, raydium_amm_v4_types.rs, raydium_cpmm_types.rs
- Add BorshDeserialize support for all types
- Refactor BondingCurveAccount to support Borsh deserialization
- Update import paths across all protocol utility modules (bonk, pumpfun, pumpswap, raydium)
- Refactor trade parameter construction methods from event objects to individual parameters for better flexibility
- Fix nonce_cache import path to use local SolanaRpcClient

src/instruction/utils/bonk.rs

@@ -1,9 +1,9 @@
-use crate::common::SolanaRpcClient;
+use crate::{
+    common::SolanaRpcClient,
+    instruction::utils::bonk_types::{pool_state_decode, PoolState},
+};
 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 {

src/instruction/utils/bonk_types.rs

@@ -0,0 +1,116 @@
+use borsh::BorshDeserialize;
+use serde::{Deserialize, Serialize};
+use solana_sdk::pubkey::Pubkey;
+
+#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)]
+pub enum TradeDirection {
+    #[default]
+    Buy,
+    Sell,
+}
+
+#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)]
+pub enum PoolStatus {
+    #[default]
+    Fund,
+    Migrate,
+    Trade,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)]
+pub struct MintParams {
+    pub decimals: u8,
+    pub name: String,
+    pub symbol: String,
+    pub uri: String,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)]
+pub struct VestingParams {
+    pub total_locked_amount: u64,
+    pub cliff_period: u64,
+    pub unlock_period: u64,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)]
+pub enum AmmFeeOn {
+    #[default]
+    QuoteToken,
+    BothToken,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)]
+pub struct ConstantCurve {
+    pub supply: u64,
+    pub total_base_sell: u64,
+    pub total_quote_fund_raising: u64,
+    pub migrate_type: u8,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)]
+pub struct FixedCurve {
+    pub supply: u64,
+    pub total_quote_fund_raising: u64,
+    pub migrate_type: u8,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)]
+pub struct LinearCurve {
+    pub supply: u64,
+    pub total_quote_fund_raising: u64,
+    pub migrate_type: u8,
+}
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)]
+pub enum CurveParams {
+    Constant { data: ConstantCurve },
+    Fixed { data: FixedCurve },
+    Linear { data: LinearCurve },
+}
+impl Default for CurveParams {
+    fn default() -> Self {
+        Self::Constant { data: ConstantCurve::default() }
+    }
+}
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)]
+pub struct VestingSchedule {
+    pub total_locked_amount: u64,
+    pub cliff_period: u64,
+    pub unlock_period: u64,
+    pub start_time: u64,
+    pub allocated_share_amount: u64,
+}
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)]
+pub struct PoolState {
+    pub epoch: u64,
+    pub auth_bump: u8,
+    pub status: u8,
+    pub base_decimals: u8,
+    pub quote_decimals: u8,
+    pub migrate_type: u8,
+    pub supply: u64,
+    pub total_base_sell: u64,
+    pub virtual_base: u64,
+    pub virtual_quote: u64,
+    pub real_base: u64,
+    pub real_quote: u64,
+    pub total_quote_fund_raising: u64,
+    pub quote_protocol_fee: u64,
+    pub platform_fee: u64,
+    pub migrate_fee: u64,
+    pub vesting_schedule: VestingSchedule,
+    pub global_config: Pubkey,
+    pub platform_config: Pubkey,
+    pub base_mint: Pubkey,
+    pub quote_mint: Pubkey,
+    pub base_vault: Pubkey,
+    pub quote_vault: Pubkey,
+    pub creator: Pubkey,
+    pub padding: [u64; 8],
+}
+pub const POOL_STATE_SIZE: usize = 8 + 1 * 5 + 8 * 10 + 32 * 7 + 8 * 8 + 8 * 5;
+pub fn pool_state_decode(data: &[u8]) -> Option<PoolState> {
+    if data.len() < POOL_STATE_SIZE {
+        return None;
+    }
+    borsh::from_slice::<PoolState>(&data[..POOL_STATE_SIZE]).ok()
+}

src/instruction/utils/mod.rs

@@ -3,3 +3,9 @@ pub mod pumpfun;
 pub mod pumpswap;
 pub mod raydium_amm_v4;
 pub mod raydium_cpmm;
+
+// types
+pub mod bonk_types;
+pub mod pumpswap_types;
+pub mod raydium_amm_v4_types;
+pub mod raydium_cpmm_types;

src/instruction/utils/pumpfun.rs

@@ -1,7 +1,6 @@
-use crate::common::{global::GlobalAccount, SolanaRpcClient};
+use crate::common::{bonding_curve::BondingCurveAccount, global::GlobalAccount, SolanaRpcClient};
 use anyhow::anyhow;
 use solana_sdk::pubkey::Pubkey;
-use solana_streamer_sdk::streaming::event_parser::protocols::pumpfun::PumpFunTradeEvent;
 use std::{collections::HashMap, sync::Arc};
 use tokio::sync::RwLock;
 
@@ -216,13 +215,7 @@ pub fn get_user_volume_accumulator_pda(user: &Pubkey) -> Option<Pubkey> {
 pub async fn fetch_bonding_curve_account(
     rpc: &SolanaRpcClient,
     mint: &Pubkey,
-) -> Result<
-    (
-        Arc<solana_streamer_sdk::streaming::event_parser::protocols::pumpfun::types::BondingCurve>,
-        Pubkey,
-    ),
-    anyhow::Error,
-> {
+) -> Result<(Arc<BondingCurveAccount>, Pubkey), anyhow::Error> {
     let bonding_curve_pda: Pubkey =
         get_bonding_curve_pda(mint).ok_or(anyhow!("Bonding curve not found"))?;
 
@@ -231,26 +224,29 @@ pub async fn fetch_bonding_curve_account(
         return Err(anyhow!("Bonding curve not found"));
     }
 
-    let bonding_curve = solana_sdk::borsh1::try_from_slice_unchecked::<
-        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))?;
+    let bonding_curve =
+        solana_sdk::borsh1::try_from_slice_unchecked::<BondingCurveAccount>(&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 fn get_buy_price(amount: u64, trade_info: &PumpFunTradeEvent) -> u64 {
+pub fn get_buy_price(
+    amount: u64,
+    virtual_sol_reserves: u64,
+    virtual_token_reserves: u64,
+    real_token_reserves: u64,
+) -> 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 n: u128 = (virtual_sol_reserves as u128) * (virtual_token_reserves as u128);
+    let i: u128 = (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: u128 = (virtual_token_reserves as u128) - r;
     let s_u64 = s as u64;
 
-    s_u64.min(trade_info.real_token_reserves)
+    s_u64.min(real_token_reserves)
 }

src/instruction/utils/pumpswap.rs

@@ -3,11 +3,11 @@ use crate::{
         spl_associated_token_account::get_associated_token_address_with_program_id, SolanaRpcClient,
     },
     constants::TOKEN_PROGRAM,
+    instruction::utils::pumpswap_types::{pool_decode, Pool},
 };
 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 {

src/instruction/utils/pumpswap_types.rs

@@ -0,0 +1,26 @@
+use borsh::BorshDeserialize;
+use serde::{Deserialize, Serialize};
+use solana_sdk::pubkey::Pubkey;
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)]
+pub struct Pool {
+    pub pool_bump: u8,
+    pub index: u16,
+    pub creator: Pubkey,
+    pub base_mint: Pubkey,
+    pub quote_mint: Pubkey,
+    pub lp_mint: Pubkey,
+    pub pool_base_token_account: Pubkey,
+    pub pool_quote_token_account: Pubkey,
+    pub lp_supply: u64,
+    pub coin_creator: Pubkey,
+}
+
+pub const POOL_SIZE: usize = 1 + 2 + 32 * 6 + 8 + 32;
+
+pub fn pool_decode(data: &[u8]) -> Option<Pool> {
+    if data.len() < POOL_SIZE {
+        return None;
+    }
+    borsh::from_slice::<Pool>(&data[..POOL_SIZE]).ok()
+}

src/instruction/utils/raydium_amm_v4.rs

@@ -1,10 +1,9 @@
+use crate::{
+    common::SolanaRpcClient,
+    instruction::utils::raydium_amm_v4_types::{amm_info_decode, AmmInfo},
+};
 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 {

src/instruction/utils/raydium_amm_v4_types.rs

@@ -0,0 +1,79 @@
+use borsh::BorshDeserialize;
+use serde::{Deserialize, Serialize};
+use solana_sdk::pubkey::Pubkey;
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)]
+pub struct Fees {
+    pub min_separate_numerator: u64,
+    pub min_separate_denominator: u64,
+    pub trade_fee_numerator: u64,
+    pub trade_fee_denominator: u64,
+    pub pnl_numerator: u64,
+    pub pnl_denominator: u64,
+    pub swap_fee_numerator: u64,
+    pub swap_fee_denominator: u64,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)]
+pub struct OutPutData {
+    pub need_take_pnl_coin: u64,
+    pub need_take_pnl_pc: u64,
+    pub total_pnl_pc: u64,
+    pub total_pnl_coin: u64,
+    pub pool_open_time: u64,
+    pub punish_pc_amount: u64,
+    pub punish_coin_amount: u64,
+    pub orderbook_to_init_time: u64,
+    pub swap_coin_in_amount: u128,
+    pub swap_pc_out_amount: u128,
+    pub swap_take_pc_fee: u64,
+    pub swap_pc_in_amount: u128,
+    pub swap_coin_out_amount: u128,
+    pub swap_take_coin_fee: u64,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)]
+pub struct AmmInfo {
+    pub status: u64,
+    pub nonce: u64,
+    pub order_num: u64,
+    pub depth: u64,
+    pub coin_decimals: u64,
+    pub pc_decimals: u64,
+    pub state: u64,
+    pub reset_flag: u64,
+    pub min_size: u64,
+    pub vol_max_cut_ratio: u64,
+    pub amount_wave: u64,
+    pub coin_lot_size: u64,
+    pub pc_lot_size: u64,
+    pub min_price_multiplier: u64,
+    pub max_price_multiplier: u64,
+    pub sys_decimal_value: u64,
+    pub fees: Fees,
+    pub out_put: OutPutData,
+    pub token_coin: Pubkey,
+    pub token_pc: Pubkey,
+    pub coin_mint: Pubkey,
+    pub pc_mint: Pubkey,
+    pub lp_mint: Pubkey,
+    pub open_orders: Pubkey,
+    pub market: Pubkey,
+    pub serum_dex: Pubkey,
+    pub target_orders: Pubkey,
+    pub withdraw_queue: Pubkey,
+    pub token_temp_lp: Pubkey,
+    pub amm_owner: Pubkey,
+    pub lp_amount: u64,
+    pub client_order_id: u64,
+    pub padding: [u64; 2],
+}
+
+pub const AMM_INFO_SIZE: usize = 752;
+
+pub fn amm_info_decode(data: &[u8]) -> Option<AmmInfo> {
+    if data.len() < AMM_INFO_SIZE {
+        return None;
+    }
+    borsh::from_slice::<AmmInfo>(&data[..AMM_INFO_SIZE]).ok()
+}

src/instruction/utils/raydium_cpmm.rs

@@ -1,9 +1,10 @@
-use crate::{common::SolanaRpcClient, trading::core::params::RaydiumCpmmParams};
+use crate::{
+    common::SolanaRpcClient,
+    instruction::utils::raydium_cpmm_types::{pool_state_decode, PoolState},
+    trading::core::params::RaydiumCpmmParams,
+};
 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 {

src/instruction/utils/raydium_cpmm_types.rs

@@ -0,0 +1,39 @@
+use borsh::BorshDeserialize;
+use serde::{Deserialize, Serialize};
+use solana_sdk::pubkey::Pubkey;
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)]
+pub struct PoolState {
+    pub amm_config: Pubkey,
+    pub pool_creator: Pubkey,
+    pub token0_vault: Pubkey,
+    pub token1_vault: Pubkey,
+    pub lp_mint: Pubkey,
+    pub token0_mint: Pubkey,
+    pub token1_mint: Pubkey,
+    pub token0_program: Pubkey,
+    pub token1_program: Pubkey,
+    pub observation_key: Pubkey,
+    pub auth_bump: u8,
+    pub status: u8,
+    pub lp_mint_decimals: u8,
+    pub mint0_decimals: u8,
+    pub mint1_decimals: u8,
+    pub lp_supply: u64,
+    pub protocol_fees_token0: u64,
+    pub protocol_fees_token1: u64,
+    pub fund_fees_token0: u64,
+    pub fund_fees_token1: u64,
+    pub open_time: u64,
+    pub recent_epoch: u64,
+    pub padding: [u64; 31],
+}
+
+pub const POOL_STATE_SIZE: usize = 629;
+
+pub fn pool_state_decode(data: &[u8]) -> Option<PoolState> {
+    if data.len() < POOL_STATE_SIZE {
+        return None;
+    }
+    borsh::from_slice::<PoolState>(&data[..POOL_STATE_SIZE]).ok()
+}