feat(pumpswap): enhance flexible mint support and optimize performance

- Add base_mint/quote_mint parameters to PumpSwapParams for flexible trading pairs
- Implement pool reserves caching to reduce RPC calls and improve speed
- Refactor unified buy/sell instruction logic for different mint types
- Add volume accumulator PDA support and proper fee calculations
- Update pool discovery for both base and quote mint searches
- Bump version to 0.2.11

Breaking: PumpSwapParams now requires mint and reserves parameters

src/trading/common/utils.rs

@@ -14,8 +14,6 @@ pub async fn get_token_balance(
     payer: &Pubkey,
     mint: &Pubkey,
 ) -> Result<u64, anyhow::Error> {
-    println!("payer: {:?}", payer);
-    println!("mint: {:?}", mint);
     let ata = get_associated_token_address(payer, mint);
     let balance = rpc.get_token_account_balance(&ata).await?;
     let balance_u64 = balance

src/trading/core/params.rs

@@ -99,10 +99,38 @@ impl ProtocolParams for PumpFunParams {
     }
 }
 
-/// PumpSwap协议特定参数
+/// PumpSwap Protocol Specific Parameters
+///
+/// Parameters for configuring PumpSwap trading protocol, including liquidity pool information,
+/// token configuration, and transaction amounts.
+///
+/// **Performance Note**: If these parameters are not provided, the system will attempt to
+/// retrieve the relevant information from RPC, which will increase transaction time.
+/// For optimal performance, it is recommended to provide all necessary parameters in advance.
 #[derive(Clone)]
 pub struct PumpSwapParams {
+    /// Liquidity pool address
+    /// If None, it will be queried via RPC, which adds latency
     pub pool: Option<Pubkey>,
+
+    /// Base token mint address
+    /// The mint account address of the base token in the trading pair
+    /// If None, it will be queried via RPC, which adds latency
+    pub base_mint: Option<Pubkey>,
+
+    /// Quote token mint address
+    /// The mint account address of the quote token in the trading pair, usually SOL or USDC
+    /// If None, it will be queried via RPC, which adds latency
+    pub quote_mint: Option<Pubkey>,
+
+    /// Base token reserves in the pool
+    pub pool_base_token_reserves: Option<u64>,
+
+    /// Quote token reserves in the pool
+    pub pool_quote_token_reserves: Option<u64>,
+
+    /// Automatically handle WSOL wrapping
+    /// When true, automatically handles wrapping and unwrapping operations between SOL and WSOL
     pub auto_handle_wsol: bool,
 }
 
@@ -110,6 +138,10 @@ impl PumpSwapParams {
     pub fn default() -> Self {
         Self {
             pool: None,
+            base_mint: None,
+            quote_mint: None,
+            pool_base_token_reserves: None,
+            pool_quote_token_reserves: None,
             auto_handle_wsol: true,
         }
     }

src/trading/pumpswap/common.rs

@@ -8,26 +8,119 @@ pub async fn find_pool(rpc: &SolanaRpcClient, mint: &Pubkey) -> Result<Pubkey, a
     Ok(pool_address)
 }
 
-// Calculate the amount of tokens to receive for a given SOL amount
-pub async fn get_buy_token_amount(
-    rpc: &SolanaRpcClient,
-    pool: &Pubkey,
+pub async fn get_token_amount(
+    quote_mint_is_wsol: bool,
+    pool_base_token_reserves: u64,
+    pool_quote_token_reserves: u64,
     sol_amount: u64,
+    lp_fee_basis_points: u64,
+    protocol_fee_basis_points: u64,
+    coin_creator_fee_basis_points: u64,
 ) -> Result<u64, anyhow::Error> {
-    let pool_data = pumpswap::pool::Pool::fetch(rpc, pool).await?;
-    pool_data.calculate_buy_amount(rpc, sol_amount).await
+    let product = pool_base_token_reserves as u128 * pool_quote_token_reserves as u128;
+    if quote_mint_is_wsol {
+        // base_amount_out
+        let mut sol_amount = sol_amount as u128;
+        sol_amount = sol_amount
+            .checked_mul(10000)
+            .unwrap()
+            .checked_div(
+                (10000
+                    + lp_fee_basis_points
+                    + protocol_fee_basis_points
+                    + coin_creator_fee_basis_points) as u128,
+            )
+            .unwrap()
+            .checked_sub(1)
+            .unwrap();
+        let new_quote_amount = pool_quote_token_reserves as u128 + sol_amount as u128;
+        let new_base_amount = product / new_quote_amount;
+        let token_amount = pool_base_token_reserves as u128 - new_base_amount;
+        return Ok(token_amount as u64);
+    } else {
+        // min_quote_amount_out
+        let new_base_amount = pool_base_token_reserves as u128 + sol_amount as u128;
+        let new_quote_amount = product / new_base_amount;
+        let token_amount = pool_quote_token_reserves as u128 - new_quote_amount;
+        let lp_fee = token_amount
+            .checked_mul(lp_fee_basis_points as u128)
+            .unwrap()
+            .checked_div(10000)
+            .unwrap();
+        let protocol_fee = token_amount
+            .checked_mul(protocol_fee_basis_points as u128)
+            .unwrap()
+            .checked_div(10000)
+            .unwrap();
+        let coin_creator_fee = token_amount
+            .checked_mul(coin_creator_fee_basis_points as u128)
+            .unwrap()
+            .checked_div(10000)
+            .unwrap();
+        let token_amount = token_amount.checked_sub(lp_fee).unwrap();
+        let token_amount = token_amount.checked_sub(protocol_fee).unwrap();
+        let token_amount = token_amount.checked_sub(coin_creator_fee).unwrap();
+        return Ok(token_amount as u64);
+    }
 }
 
-// Calculate the amount of SOL to receive for a given token amount
-pub async fn get_sell_sol_amount(
-    rpc: &SolanaRpcClient,
-    pool: &Pubkey,
+pub async fn get_wsol_amount(
+    quote_mint_is_wsol: bool,
+    pool_base_token_reserves: u64,
+    pool_quote_token_reserves: u64,
     token_amount: u64,
+    lp_fee_basis_points: u64,
+    protocol_fee_basis_points: u64,
+    coin_creator_fee_basis_points: u64,
 ) -> Result<u64, anyhow::Error> {
-    let pool_data = pumpswap::pool::Pool::fetch(rpc, pool).await?;
-    pool_data.calculate_sell_amount(rpc, token_amount).await
+    let product = pool_base_token_reserves as u128 * pool_quote_token_reserves as u128;
+    if !quote_mint_is_wsol {
+        // base_amount_out
+        let mut token_amount = token_amount as u128;
+        token_amount = token_amount
+            .checked_mul(10000)
+            .unwrap()
+            .checked_div(
+                (10000
+                    + lp_fee_basis_points
+                    + protocol_fee_basis_points
+                    + coin_creator_fee_basis_points) as u128,
+            )
+            .unwrap()
+            .checked_sub(1)
+            .unwrap();
+        let new_quote_amount = pool_quote_token_reserves as u128 + token_amount as u128;
+        let new_base_amount = product / new_quote_amount;
+        let wsol_amount = pool_base_token_reserves as u128 - new_base_amount;
+        Ok(wsol_amount as u64)
+    } else {
+        // min_quote_amount_out
+        let new_base_amount = pool_base_token_reserves as u128 + token_amount as u128;
+        let new_quote_amount = product / new_base_amount;
+        let token_amount = pool_quote_token_reserves as u128 - new_quote_amount;
+        let lp_fee = token_amount
+            .checked_mul(lp_fee_basis_points as u128)
+            .unwrap()
+            .checked_div(10000)
+            .unwrap();
+        let protocol_fee = token_amount
+            .checked_mul(protocol_fee_basis_points as u128)
+            .unwrap()
+            .checked_div(10000)
+            .unwrap();
+        let coin_creator_fee = token_amount
+            .checked_mul(coin_creator_fee_basis_points as u128)
+            .unwrap()
+            .checked_div(10000)
+            .unwrap();
+        let wsol_amount = token_amount.checked_sub(lp_fee).unwrap();
+        let wsol_amount = wsol_amount.checked_sub(protocol_fee).unwrap();
+        let wsol_amount = wsol_amount.checked_sub(coin_creator_fee).unwrap();
+        Ok(wsol_amount as u64)
+    }
 }
 
+
 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()],
@@ -36,13 +129,40 @@ pub(crate) fn coin_creator_vault_authority(coin_creator: Pubkey) -> Pubkey {
     pump_pool_authority
 }
 
-pub(crate) fn coin_creator_vault_ata(coin_creator: Pubkey) -> Pubkey {
+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,
-            &crate::constants::pumpswap::accounts::WSOL_TOKEN_ACCOUNT,
+            &quote_mint,
             &crate::constants::pumpswap::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,
+            &crate::constants::pumpswap::accounts::TOKEN_PROGRAM,
+        );
+    associated_token_fee_recipient
+}
+
+pub fn get_user_volume_accumulator_pda(user: &Pubkey) -> Option<Pubkey> {
+    let seeds: &[&[u8]; 2] = &[
+        &crate::constants::pumpswap::seeds::USER_VOLUME_ACCUMULATOR_SEED,
+        user.as_ref(),
+    ];
+    let program_id: &Pubkey = &&crate::constants::pumpswap::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] = &[&crate::constants::pumpswap::seeds::GLOBAL_VOLUME_ACCUMULATOR_SEED];
+    let program_id: &Pubkey = &&crate::constants::pumpswap::accounts::AMM_PROGRAM;
+    let pda: Option<(Pubkey, u8)> = Pubkey::try_find_program_address(seeds, program_id);
+    pda.map(|pubkey| pubkey.0)
+}

src/trading/pumpswap/pool.rs

@@ -14,6 +14,7 @@ pub struct Pool {
     pub pool_base_token_account: Pubkey,
     pub pool_quote_token_account: Pubkey,
     pub lp_supply: u64,
+    pub coin_creator: Pubkey,
 }
 
 impl Pool {
@@ -63,6 +64,15 @@ impl Pool {
             data[195], data[196], data[197], data[198], data[199], data[200], data[201], data[202],
         ]);
 
+        let mut coin_creator = Pubkey::default();
+        if data.len() >= 203 + 32 {
+            coin_creator = Pubkey::new_from_array(
+                data[203..203 + 32]
+                    .try_into()
+                    .map_err(|e| anyhow!("Failed to convert coin_creator: {:?}", e))?,
+            );
+        }
+
         Ok(Self {
             pool_bump,
             index,
@@ -73,6 +83,7 @@ impl Pool {
             pool_base_token_account,
             pool_quote_token_account,
             lp_supply,
+            coin_creator,
         })
     }
 
@@ -89,18 +100,17 @@ impl Pool {
         Self::from_bytes(&account.data)
     }
 
-    pub async fn find_by_mint(
+    pub async fn find_by_base_mint(
         rpc: &SolanaRpcClient,
-        mint: &Pubkey,
+        base_mint: &Pubkey,
     ) -> Result<(Pubkey, Self), 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, &mint.to_bytes()),
+                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 {
@@ -112,26 +122,73 @@ impl Pool {
             with_context: None,
             sort_results: None,
         };
-
         let program_id = crate::constants::pumpswap::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 {}", mint));
+            return Err(anyhow!("No pool found for mint {}", base_mint));
         }
-
         let mut pools: Vec<_> = accounts
             .into_iter()
             .filter_map(|(addr, acc)| Self::from_bytes(&acc.data).map(|pool| (addr, pool)).ok())
             .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, Self), 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 = crate::constants::pumpswap::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)| Self::from_bytes(&acc.data).map(|pool| (addr, pool)).ok())
+            .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, Self), anyhow::Error> {
+        if let Ok((address, pool)) = Self::find_by_base_mint(rpc, mint).await {
+            return Ok((address, pool));
+        }
+        if let Ok((address, pool)) = Self::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(
         &self,
         rpc: &SolanaRpcClient,