feat: optimize RPC polling and remove data size limit

Significantly reduce RPC pressure and fix MaxLoadedAccountsDataSizeExceeded errors.

Major improvements:
1. Add wait_confirmation parameter to all swqos clients
   - Skip polling entirely when wait_transaction_confirmed=false (100% RPC reduction)
   - Optimize getTransaction calls to only execute on errors or after 10s (50% reduction)
   - Update all 13 swqos client implementations

2. Remove LoadedAccountsDataSize instruction and data_size_limit parameter
   - Eliminate MaxLoadedAccountsDataSizeExceeded errors reported by users
   - Clean up gas_fee_strategy, params, and transaction builder
   - Simplify compute budget instruction generation

Results:
- Single channel: 30 RPC calls → 0-15 calls (50-100% reduction)
- Multi-channel (3x): 90 RPC calls → 0-45 calls (50-100% reduction)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

src/common/gas_fee_strategy.rs

@@ -21,7 +21,6 @@ pub struct GasFeeStrategyValue {
     pub cu_limit: u32,
     pub cu_price: u64,
     pub tip: f64,
-    pub data_size_limit: u32,
 }
 
 #[derive(Clone)]
@@ -45,8 +44,6 @@ impl GasFeeStrategy {
         sell_cu_price: u64,
         buy_tip: f64,
         sell_tip: f64,
-        buy_data_size_limit: u32,
-        sell_data_size_limit: u32,
     ) {
         for swqos_type in SwqosType::values() {
             if swqos_type.eq(&SwqosType::Default) {
@@ -59,7 +56,6 @@ impl GasFeeStrategy {
                 buy_cu_limit,
                 buy_cu_price,
                 buy_tip,
-                buy_data_size_limit,
             );
             self.set(
                 swqos_type,
@@ -68,7 +64,6 @@ impl GasFeeStrategy {
                 sell_cu_limit,
                 sell_cu_price,
                 sell_tip,
-                sell_data_size_limit,
             );
         }
         self.set(
@@ -78,7 +73,6 @@ impl GasFeeStrategy {
             buy_cu_limit,
             buy_cu_price,
             0.0,
-            buy_data_size_limit,
         );
         self.set(
             SwqosType::Default,
@@ -87,7 +81,6 @@ impl GasFeeStrategy {
             sell_cu_limit,
             sell_cu_price,
             0.0,
-            sell_data_size_limit,
         );
     }
 
@@ -102,7 +95,6 @@ impl GasFeeStrategy {
         high_cu_price: u64,
         low_tip: f64,
         high_tip: f64,
-        data_size_limit: u32,
     ) {
         for swqos_type in swqos_types {
             self.del(*swqos_type, trade_type, GasFeeStrategyType::Normal);
@@ -113,7 +105,6 @@ impl GasFeeStrategy {
                 cu_limit,
                 high_cu_price,
                 low_tip,
-                data_size_limit,
             );
             self.set(
                 *swqos_type,
@@ -122,7 +113,6 @@ impl GasFeeStrategy {
                 cu_limit,
                 low_cu_price,
                 high_tip,
-                data_size_limit,
             );
         }
     }
@@ -138,7 +128,6 @@ impl GasFeeStrategy {
         high_cu_price: u64,
         low_tip: f64,
         high_tip: f64,
-        data_size_limit: u32,
     ) {
         if swqos_type.eq(&SwqosType::Default) {
             return;
@@ -151,7 +140,6 @@ impl GasFeeStrategy {
             cu_limit,
             high_cu_price,
             low_tip,
-            data_size_limit,
         );
         self.set(
             swqos_type,
@@ -160,7 +148,6 @@ impl GasFeeStrategy {
             cu_limit,
             low_cu_price,
             high_tip,
-            data_size_limit,
         );
     }
 
@@ -173,8 +160,6 @@ impl GasFeeStrategy {
         cu_price: u64,
         buy_tip: f64,
         sell_tip: f64,
-        buy_data_size_limit: u32,
-        sell_data_size_limit: u32,
     ) {
         for swqos_type in swqos_types {
             self.del_all(*swqos_type, TradeType::Buy);
@@ -186,7 +171,6 @@ impl GasFeeStrategy {
                 cu_limit,
                 cu_price,
                 buy_tip,
-                buy_data_size_limit,
             );
             self.set(
                 *swqos_type,
@@ -195,7 +179,6 @@ impl GasFeeStrategy {
                 cu_limit,
                 cu_price,
                 sell_tip,
-                sell_data_size_limit,
             );
         }
     }
@@ -207,8 +190,6 @@ impl GasFeeStrategy {
         cu_price: u64,
         buy_tip: f64,
         sell_tip: f64,
-        buy_data_size_limit: u32,
-        sell_data_size_limit: u32,
     ) {
         self.del_all(swqos_type, TradeType::Buy);
         self.del_all(swqos_type, TradeType::Sell);
@@ -219,7 +200,6 @@ impl GasFeeStrategy {
             cu_limit,
             cu_price,
             buy_tip,
-            buy_data_size_limit,
         );
         self.set(
             swqos_type,
@@ -228,7 +208,6 @@ impl GasFeeStrategy {
             cu_limit,
             cu_price,
             sell_tip,
-            sell_data_size_limit,
         );
     }
 
@@ -240,7 +219,6 @@ impl GasFeeStrategy {
         cu_limit: u32,
         cu_price: u64,
         tip: f64,
-        data_size_limit: u32,
     ) {
         if strategy_type == GasFeeStrategyType::Normal {
             self.del(swqos_type, trade_type, GasFeeStrategyType::HighTipLowCuPrice);
@@ -252,7 +230,7 @@ impl GasFeeStrategy {
             let mut new_map = (**current_map).clone();
             new_map.insert(
                 (swqos_type, trade_type, strategy_type),
-                GasFeeStrategyValue { cu_limit, cu_price, tip, data_size_limit },
+                GasFeeStrategyValue { cu_limit, cu_price, tip },
             );
             Arc::new(new_map)
         });

src/lib.rs

@@ -405,12 +405,6 @@ impl TradingClient {
             slippage_basis_points: params.slippage_basis_points,
             address_lookup_table_account: params.address_lookup_table_account,
             recent_blockhash: params.recent_blockhash,
-            data_size_limit: params
-                .gas_fee_strategy
-                .get_strategies(TradeType::Buy)
-                .get(0)
-                .map(|(_, _, v)| v.data_size_limit)
-                .unwrap_or(256 * 1024),
             wait_transaction_confirmed: params.wait_transaction_confirmed,
             protocol_params: protocol_params.clone(),
             open_seed_optimize: self.use_seed_optimize, // 使用全局seed优化配置
@@ -527,12 +521,6 @@ impl TradingClient {
             swqos_clients: self.swqos_clients.clone(),
             middleware_manager: self.middleware_manager.clone(),
             durable_nonce: params.durable_nonce,
-            data_size_limit: params
-                .gas_fee_strategy
-                .get_strategies(TradeType::Sell)
-                .get(0)
-                .map(|(_, _, v)| v.data_size_limit)
-                .unwrap_or(0),
             create_input_mint_ata: false,
             close_input_mint_ata: params.close_mint_token_ata,
             create_output_mint_ata: params.create_output_token_ata,

src/swqos/astralane.rs

@@ -29,12 +29,12 @@ pub struct AstralaneClient {
 
 #[async_trait::async_trait]
 impl SwqosClientTrait for AstralaneClient {
-    async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction) -> Result<()> {
-        self.send_transaction(trade_type, transaction).await
+    async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction, wait_confirmation: bool) -> Result<()> {
+        self.send_transaction(trade_type, transaction, wait_confirmation).await
     }
 
-    async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>) -> Result<()> {
-        self.send_transactions(trade_type, transactions).await
+    async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>, wait_confirmation: bool) -> Result<()> {
+        self.send_transactions(trade_type, transactions, wait_confirmation).await
     }
 
     fn get_tip_account(&self) -> Result<String> {
@@ -146,7 +146,7 @@ impl AstralaneClient {
         Ok(())
     }
 
-    pub async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction) -> Result<()> {
+    pub async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction, wait_confirmation: bool) -> Result<()> {
         let start_time = Instant::now();
         let (content, signature) = serialize_transaction_and_encode(transaction, UiTransactionEncoding::Base64).await?;
 
@@ -183,7 +183,7 @@ impl AstralaneClient {
         }
 
         let start_time: Instant = Instant::now();
-        match poll_transaction_confirmation(&self.rpc_client, signature).await {
+        match poll_transaction_confirmation(&self.rpc_client, signature, wait_confirmation).await {
             Ok(_) => (),
             Err(e) => {
                 println!(" signature: {:?}", signature);
@@ -191,15 +191,17 @@ impl AstralaneClient {
                 return Err(e);
             },
         }
-        println!(" signature: {:?}", signature);
-        println!(" [astralane] {} confirmed: {:?}", trade_type, start_time.elapsed());
+        if wait_confirmation {
+            println!(" signature: {:?}", signature);
+            println!(" [astralane] {} confirmed: {:?}", trade_type, start_time.elapsed());
+        }
 
         Ok(())
     }
 
-    pub async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>) -> Result<()> {
+    pub async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>, wait_confirmation: bool) -> Result<()> {
         for transaction in transactions {
-            self.send_transaction(trade_type, transaction).await?;
+            self.send_transaction(trade_type, transaction, wait_confirmation).await?;
         }
         Ok(())
     }

src/swqos/blockrazor.rs

@@ -29,12 +29,12 @@ pub struct BlockRazorClient {
 
 #[async_trait::async_trait]
 impl SwqosClientTrait for BlockRazorClient {
-    async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction) -> Result<()> {
-        self.send_transaction(trade_type, transaction).await
+    async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction, wait_confirmation: bool) -> Result<()> {
+        self.send_transaction(trade_type, transaction, wait_confirmation).await
     }
 
-    async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>) -> Result<()> {
-        self.send_transactions(trade_type, transactions).await
+    async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>, wait_confirmation: bool) -> Result<()> {
+        self.send_transactions(trade_type, transactions, wait_confirmation).await
     }
 
     fn get_tip_account(&self) -> Result<String> {
@@ -153,7 +153,7 @@ impl BlockRazorClient {
         Ok(())
     }
 
-    pub async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction) -> Result<()> {
+    pub async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction, wait_confirmation: bool) -> Result<()> {
         let start_time = Instant::now();
         let (content, signature) = serialize_transaction_and_encode(transaction, UiTransactionEncoding::Base64).await?;
 
@@ -185,7 +185,7 @@ impl BlockRazorClient {
         }
 
         let start_time: Instant = Instant::now();
-        match poll_transaction_confirmation(&self.rpc_client, signature).await {
+        match poll_transaction_confirmation(&self.rpc_client, signature, wait_confirmation).await {
             Ok(_) => (),
             Err(e) => {
                 println!(" signature: {:?}", signature);
@@ -193,15 +193,17 @@ impl BlockRazorClient {
                 return Err(e);
             },
         }
-        println!(" signature: {:?}", signature);
-        println!(" [blockrazor] {} confirmed: {:?}", trade_type, start_time.elapsed());
+        if wait_confirmation {
+            println!(" signature: {:?}", signature);
+            println!(" [blockrazor] {} confirmed: {:?}", trade_type, start_time.elapsed());
+        }
 
         Ok(())
     }
 
-    pub async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>) -> Result<()> {
+    pub async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>, wait_confirmation: bool) -> Result<()> {
         for transaction in transactions {
-            self.send_transaction(trade_type, transaction).await?;
+            self.send_transaction(trade_type, transaction, wait_confirmation).await?;
         }
         Ok(())
     }

src/swqos/bloxroute.rs

@@ -24,12 +24,12 @@ pub struct BloxrouteClient {
 
 #[async_trait::async_trait]
 impl SwqosClientTrait for BloxrouteClient {
-    async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction) -> Result<()> {
-        self.send_transaction(trade_type, transaction).await
+    async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction, wait_confirmation: bool) -> Result<()> {
+        self.send_transaction(trade_type, transaction, wait_confirmation).await
     }
 
-    async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>) -> Result<()> {
-        self.send_transactions(trade_type, transactions).await
+    async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>, wait_confirmation: bool) -> Result<()> {
+        self.send_transactions(trade_type, transactions, wait_confirmation).await
     }
 
     fn get_tip_account(&self) -> Result<String> {
@@ -61,7 +61,7 @@ impl BloxrouteClient {
         Self { rpc_client: Arc::new(rpc_client), endpoint, auth_token, http_client }
     }
 
-    pub async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction) -> Result<()> {
+    pub async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction, wait_confirmation: bool) -> Result<()> {
         let start_time = Instant::now();
         let (content, signature) = serialize_transaction_and_encode(transaction, UiTransactionEncoding::Base64).await?;
 
@@ -95,7 +95,7 @@ impl BloxrouteClient {
         }
 
         let start_time: Instant = Instant::now();
-        match poll_transaction_confirmation(&self.rpc_client, signature).await {
+        match poll_transaction_confirmation(&self.rpc_client, signature, wait_confirmation).await {
             Ok(_) => (),
             Err(e) => {
                 println!(" signature: {:?}", signature);
@@ -103,13 +103,15 @@ impl BloxrouteClient {
                 return Err(e);
             },
         }
-        println!(" signature: {:?}", signature);
-        println!(" [bloxroute] {} confirmed: {:?}", trade_type, start_time.elapsed());
+        if wait_confirmation {
+            println!(" signature: {:?}", signature);
+            println!(" [bloxroute] {} confirmed: {:?}", trade_type, start_time.elapsed());
+        }
 
         Ok(())
     }
 
-    pub async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>) -> Result<()> {
+    pub async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>, wait_confirmation: bool) -> Result<()> {
         let start_time = Instant::now();
 
         let body = serde_json::json!({

src/swqos/common.rs

@@ -56,16 +56,25 @@ impl FormatBase64VersionedTransaction for VersionedTransaction {
 pub async fn poll_transaction_confirmation(
     rpc: &SolanaRpcClient,
     txt_sig: Signature,
+    wait_confirmation: bool,
 ) -> Result<Signature> {
+    // 如果不需要等待确认，立即返回签名
+    if !wait_confirmation {
+        return Ok(txt_sig);
+    }
+
     let timeout: Duration = Duration::from_secs(15); // 🔧 增加到15秒，避免网络拥堵时超时
     let interval: Duration = Duration::from_millis(1000);
     let start: Instant = Instant::now();
+    let mut poll_count = 0u32;
 
     loop {
         if start.elapsed() >= timeout {
             return Err(anyhow::anyhow!("Transaction {}'s confirmation timed out", txt_sig));
         }
 
+        poll_count += 1;
+
         let status = rpc.get_signature_statuses(&[txt_sig]).await?;
         match status.value[0].clone() {
             Some(status) => {
@@ -77,8 +86,27 @@ pub async fn poll_transaction_confirmation(
                 {
                     return Ok(txt_sig);
                 }
+                // 如果 getSignatureStatuses 返回了错误，立即获取详细信息
+                if status.err.is_some() {
+                    // 直接跳转到获取交易详情
+                }
             }
-            None => {}
+            None => {
+                // 交易还未上链，继续等待，不调用 getTransaction
+                sleep(interval).await;
+                continue;
+            }
+        }
+
+        // 优化：只在以下情况调用 getTransaction
+        // 1. getSignatureStatuses 返回了错误
+        // 2. 或者已经轮询了较长时间（超过10次，即10秒）
+        let should_get_transaction = status.value[0].as_ref().map(|s| s.err.is_some()).unwrap_or(false)
+            || poll_count >= 10;
+
+        if !should_get_transaction {
+            sleep(interval).await;
+            continue;
         }
 
         let tx_details = match rpc

src/swqos/flashblock.rs

@@ -25,12 +25,12 @@ pub struct FlashBlockClient {
 
 #[async_trait::async_trait]
 impl SwqosClientTrait for FlashBlockClient {
-    async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction) -> Result<()> {
-        self.send_transaction(trade_type, transaction).await
+    async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction, wait_confirmation: bool) -> Result<()> {
+        self.send_transaction(trade_type, transaction, wait_confirmation).await
     }
 
-    async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>) -> Result<()> {
-        self.send_transactions(trade_type, transactions).await
+    async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>, wait_confirmation: bool) -> Result<()> {
+        self.send_transactions(trade_type, transactions, wait_confirmation).await
     }
 
     fn get_tip_account(&self) -> Result<String> {
@@ -62,7 +62,7 @@ impl FlashBlockClient {
         Self { rpc_client: Arc::new(rpc_client), endpoint, auth_token, http_client }
     }
 
-    pub async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction) -> Result<()> {
+    pub async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction, wait_confirmation: bool) -> Result<()> {
         let start_time = Instant::now();
         let (content, signature) = serialize_transaction_and_encode(transaction, UiTransactionEncoding::Base64).await?;
 
@@ -97,7 +97,7 @@ impl FlashBlockClient {
         }
 
         let start_time: Instant = Instant::now();
-        match poll_transaction_confirmation(&self.rpc_client, signature).await {
+        match poll_transaction_confirmation(&self.rpc_client, signature, wait_confirmation).await {
             Ok(_) => (),
             Err(e) => {
                 println!(" signature: {:?}", signature);
@@ -105,15 +105,17 @@ impl FlashBlockClient {
                 return Err(e);
             },
         }
-        println!(" signature: {:?}", signature);
-        println!(" [FlashBlock] {} confirmed: {:?}", trade_type, start_time.elapsed());
+        if wait_confirmation {
+            println!(" signature: {:?}", signature);
+            println!(" [FlashBlock] {} confirmed: {:?}", trade_type, start_time.elapsed());
+        }
 
         Ok(())
     }
 
-    pub async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>) -> Result<()> {
+    pub async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>, wait_confirmation: bool) -> Result<()> {
         for transaction in transactions {
-            self.send_transaction(trade_type, transaction).await?;
+            self.send_transaction(trade_type, transaction, wait_confirmation).await?;
         }
         Ok(())
     }

src/swqos/jito.rs

@@ -25,12 +25,12 @@ pub struct JitoClient {
 
 #[async_trait::async_trait]
 impl SwqosClientTrait for JitoClient {
-    async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction) -> Result<()> {
-        self.send_transaction(trade_type, transaction).await
+    async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction, wait_confirmation: bool) -> Result<()> {
+        self.send_transaction_impl(trade_type, transaction, wait_confirmation).await
     }
 
-    async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>) -> Result<()> {
-        self.send_transactions(trade_type, transactions).await
+    async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>, wait_confirmation: bool) -> Result<()> {
+        self.send_transactions_impl(trade_type, transactions, wait_confirmation).await
     }
 
     fn get_tip_account(&self) -> Result<String> {
@@ -65,13 +65,13 @@ impl JitoClient {
         Self { rpc_client: Arc::new(rpc_client), endpoint, auth_token, http_client }
     }
 
-    pub async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction) -> Result<()> {
+    pub async fn send_transaction_impl(&self, trade_type: TradeType, transaction: &VersionedTransaction, wait_confirmation: bool) -> Result<()> {
         let start_time = Instant::now();
         let (content, signature) = serialize_transaction_and_encode(transaction, UiTransactionEncoding::Base64).await?;
 
         let request_body = serde_json::to_string(&json!({
             "id": 1,
-            "jsonrpc": "2.0", 
+            "jsonrpc": "2.0",
             "method": "sendTransaction",
             "params": [
                 content,
@@ -111,7 +111,7 @@ impl JitoClient {
         }
 
         let start_time: Instant = Instant::now();
-        match poll_transaction_confirmation(&self.rpc_client, signature).await {
+        match poll_transaction_confirmation(&self.rpc_client, signature, wait_confirmation).await {
             Ok(_) => (),
             Err(e) => {
                 println!(" signature: {:?}", signature);
@@ -119,13 +119,15 @@ impl JitoClient {
                 return Err(e);
             },
         }
-        println!(" signature: {:?}", signature);
-        println!(" [jito] {} confirmed: {:?}", trade_type, start_time.elapsed());
+        if wait_confirmation {
+            println!(" signature: {:?}", signature);
+            println!(" [jito] {} confirmed: {:?}", trade_type, start_time.elapsed());
+        }
 
         Ok(())
     }
 
-    pub async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>) -> Result<()> {
+    pub async fn send_transactions_impl(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>, _wait_confirmation: bool) -> Result<()> {
         let start_time = Instant::now();
         let txs_base64 = transactions.iter().map(|tx| tx.to_base64_string()).collect::<Vec<String>>();
         let body = serde_json::json!({

src/swqos/lightspeed.rs

@@ -24,12 +24,12 @@ pub struct LightspeedClient {
 
 #[async_trait::async_trait]
 impl SwqosClientTrait for LightspeedClient {
-    async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction) -> Result<()> {
-        self.send_transaction(trade_type, transaction).await
+    async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction, wait_confirmation: bool) -> Result<()> {
+        self.send_transaction(trade_type, transaction, wait_confirmation).await
     }
 
-    async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>) -> Result<()> {
-        self.send_transactions(trade_type, transactions).await
+    async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>, wait_confirmation: bool) -> Result<()> {
+        self.send_transactions(trade_type, transactions, wait_confirmation).await
     }
 
     fn get_tip_account(&self) -> Result<String> {
@@ -63,7 +63,7 @@ impl LightspeedClient {
         Self { rpc_client: Arc::new(rpc_client), endpoint, auth_token, http_client }
     }
 
-    pub async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction) -> Result<()> {
+    pub async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction, wait_confirmation: bool) -> Result<()> {
         let start_time = Instant::now();
         let (content, signature) = serialize_transaction_and_encode(transaction, UiTransactionEncoding::Base64).await?;
 
@@ -102,7 +102,7 @@ impl LightspeedClient {
         }
 
         let start_time: Instant = Instant::now();
-        match poll_transaction_confirmation(&self.rpc_client, signature).await {
+        match poll_transaction_confirmation(&self.rpc_client, signature, wait_confirmation).await {
             Ok(_) => (),
             Err(e) => {
                 println!(" signature: {:?}", signature);
@@ -110,15 +110,17 @@ impl LightspeedClient {
                 return Err(e);
             },
         }
-        println!(" signature: {:?}", signature);
-        println!(" [lightspeed] {} confirmed: {:?}", trade_type, start_time.elapsed());
+        if wait_confirmation {
+            println!(" signature: {:?}", signature);
+            println!(" [lightspeed] {} confirmed: {:?}", trade_type, start_time.elapsed());
+        }
 
         Ok(())
     }
 
-    pub async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>) -> Result<()> {
+    pub async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>, wait_confirmation: bool) -> Result<()> {
         for transaction in transactions {
-            self.send_transaction(trade_type, transaction).await?;
+            self.send_transaction(trade_type, transaction, wait_confirmation).await?;
         }
         Ok(())
     }

src/swqos/mod.rs

@@ -126,8 +126,8 @@ pub type SwqosClient = dyn SwqosClientTrait + Send + Sync + 'static;
 
 #[async_trait::async_trait]
 pub trait SwqosClientTrait {
-    async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction) -> Result<()>;
-    async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>) -> Result<()>;
+    async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction, wait_confirmation: bool) -> Result<()>;
+    async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>, wait_confirmation: bool) -> Result<()>;
     fn get_tip_account(&self) -> Result<String>;
     fn get_swqos_type(&self) -> SwqosType;
 }

src/swqos/nextblock.rs

@@ -24,12 +24,12 @@ pub struct NextBlockClient {
 
 #[async_trait::async_trait]
 impl SwqosClientTrait for NextBlockClient {
-    async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction) -> Result<()> {
-        self.send_transaction(trade_type, transaction).await
+    async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction, wait_confirmation: bool) -> Result<()> {
+        self.send_transaction(trade_type, transaction, wait_confirmation).await
     }
 
-    async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>) -> Result<()> {
-        self.send_transactions(trade_type, transactions).await
+    async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>, wait_confirmation: bool) -> Result<()> {
+        self.send_transactions(trade_type, transactions, wait_confirmation).await
     }
 
     fn get_tip_account(&self) -> Result<String> {
@@ -67,7 +67,7 @@ impl NextBlockClient {
         Self { rpc_client: Arc::new(rpc_client), endpoint, auth_token, http_client }
     }
 
-    pub async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction) -> Result<()> {
+    pub async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction, wait_confirmation: bool) -> Result<()> {
         let start_time = Instant::now();
         let (content, signature) = serialize_transaction_and_encode(transaction, UiTransactionEncoding::Base64).await?;
 
@@ -98,7 +98,7 @@ impl NextBlockClient {
         }
 
         let start_time: Instant = Instant::now();
-        match poll_transaction_confirmation(&self.rpc_client, signature).await {
+        match poll_transaction_confirmation(&self.rpc_client, signature, wait_confirmation).await {
             Ok(_) => (),
             Err(e) => {
                 println!(" signature: {:?}", signature);
@@ -106,15 +106,17 @@ impl NextBlockClient {
                 return Err(e);
             },
         }
-        println!(" signature: {:?}", signature);
-        println!(" [nextblock] {} confirmed: {:?}", trade_type, start_time.elapsed());
+        if wait_confirmation {
+            println!(" signature: {:?}", signature);
+            println!(" [nextblock] {} confirmed: {:?}", trade_type, start_time.elapsed());
+        }
 
         Ok(())
     }
 
-    pub async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>) -> Result<()> {
+    pub async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>, wait_confirmation: bool) -> Result<()> {
         for transaction in transactions {
-            self.send_transaction(trade_type, transaction).await?;
+            self.send_transaction(trade_type, transaction, wait_confirmation).await?;
         }
         Ok(())
     }

src/swqos/node1.rs

@@ -29,12 +29,12 @@ pub struct Node1Client {
 
 #[async_trait::async_trait]
 impl SwqosClientTrait for Node1Client {
-    async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction) -> Result<()> {
-        self.send_transaction(trade_type, transaction).await
+    async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction, wait_confirmation: bool) -> Result<()> {
+        self.send_transaction(trade_type, transaction, wait_confirmation).await
     }
 
-    async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>) -> Result<()> {
-        self.send_transactions(trade_type, transactions).await
+    async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>, wait_confirmation: bool) -> Result<()> {
+        self.send_transactions(trade_type, transactions, wait_confirmation).await
     }
 
     fn get_tip_account(&self) -> Result<String> {
@@ -140,7 +140,7 @@ impl Node1Client {
         Ok(())
     }
 
-    pub async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction) -> Result<()> {
+    pub async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction, wait_confirmation: bool) -> Result<()> {
         let start_time = Instant::now();
         let (content, signature) = serialize_transaction_and_encode(transaction, UiTransactionEncoding::Base64).await?;
 
@@ -176,7 +176,7 @@ impl Node1Client {
         }
 
         let start_time: Instant = Instant::now();
-        match poll_transaction_confirmation(&self.rpc_client, signature).await {
+        match poll_transaction_confirmation(&self.rpc_client, signature, wait_confirmation).await {
             Ok(_) => (),
             Err(e) => {
                 println!(" signature: {:?}", signature);
@@ -184,15 +184,17 @@ impl Node1Client {
                 return Err(e);
             },
         }
-        println!(" signature: {:?}", signature);
-        println!(" [node1] {} confirmed: {:?}", trade_type, start_time.elapsed());
+        if wait_confirmation {
+            println!(" signature: {:?}", signature);
+            println!(" [node1] {} confirmed: {:?}", trade_type, start_time.elapsed());
+        }
 
         Ok(())
     }
 
-    pub async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>) -> Result<()> {
+    pub async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>, wait_confirmation: bool) -> Result<()> {
         for transaction in transactions {
-            self.send_transaction(trade_type, transaction).await?;
+            self.send_transaction(trade_type, transaction, wait_confirmation).await?;
         }
         Ok(())
     }

src/swqos/solana_rpc.rs

@@ -23,6 +23,7 @@ impl SwqosClientTrait for SolRpcClient {
         &self,
         trade_type: TradeType,
         transaction: &VersionedTransaction,
+        wait_confirmation: bool,
     ) -> Result<()> {
         let signature = self
             .rpc_client
@@ -39,7 +40,7 @@ impl SwqosClientTrait for SolRpcClient {
             .await?;
 
         let start_time = Instant::now();
-        match poll_transaction_confirmation(&self.rpc_client, signature).await {
+        match poll_transaction_confirmation(&self.rpc_client, signature, wait_confirmation).await {
             Ok(_) => (),
             Err(e) => {
                 println!(" signature: {:?}", signature);
@@ -47,8 +48,10 @@ impl SwqosClientTrait for SolRpcClient {
                 return Err(e);
             }
         }
-        println!(" signature: {:?}", signature);
-        println!(" [rpc] {} confirmed: {:?}", trade_type, start_time.elapsed());
+        if wait_confirmation {
+            println!(" signature: {:?}", signature);
+            println!(" [rpc] {} confirmed: {:?}", trade_type, start_time.elapsed());
+        }
 
         Ok(())
     }
@@ -57,9 +60,10 @@ impl SwqosClientTrait for SolRpcClient {
         &self,
         trade_type: TradeType,
         transactions: &Vec<VersionedTransaction>,
+        wait_confirmation: bool,
     ) -> Result<()> {
         for transaction in transactions {
-            self.send_transaction(trade_type, transaction).await?;
+            self.send_transaction(trade_type, transaction, wait_confirmation).await?;
         }
         Ok(())
     }

src/swqos/soyas.rs

@@ -102,6 +102,7 @@ impl SwqosClientTrait for SoyasClient {
         &self,
         trade_type: TradeType,
         transaction: &VersionedTransaction,
+        wait_confirmation: bool,
     ) -> Result<()> {
         let signature = transaction.get_signature();
         let serialized_tx = bincode::serialize(transaction)?;
@@ -115,7 +116,7 @@ impl SwqosClientTrait for SoyasClient {
         Self::try_send_bytes(&connection, &serialized_tx).await?;
 
         let start_time: Instant = Instant::now();
-        match poll_transaction_confirmation(&self.rpc_client, *signature).await {
+        match poll_transaction_confirmation(&self.rpc_client, *signature, wait_confirmation).await {
             Ok(_) => (),
             Err(e) => {
                 println!(" signature: {:?}", signature);
@@ -123,8 +124,10 @@ impl SwqosClientTrait for SoyasClient {
                 return Err(e);
             }
         }
-        println!(" signature: {:?}", signature);
-        println!(" [soyas] {} confirmed: {:?}", trade_type, start_time.elapsed());
+        if wait_confirmation {
+            println!(" signature: {:?}", signature);
+            println!(" [soyas] {} confirmed: {:?}", trade_type, start_time.elapsed());
+        }
         Ok(())
     }
 
@@ -132,9 +135,10 @@ impl SwqosClientTrait for SoyasClient {
         &self,
         trade_type: TradeType,
         transactions: &Vec<VersionedTransaction>,
+        wait_confirmation: bool,
     ) -> Result<()> {
         for transaction in transactions {
-            self.send_transaction(trade_type, transaction).await?;
+            self.send_transaction(trade_type, transaction, wait_confirmation).await?;
         }
         Ok(())
     }

src/swqos/stellium.rs

@@ -27,12 +27,12 @@ pub struct StelliumClient {
 
 #[async_trait::async_trait]
 impl SwqosClientTrait for StelliumClient {
-    async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction) -> Result<()> {
-        self.send_transaction(trade_type, transaction).await
+    async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction, wait_confirmation: bool) -> Result<()> {
+        self.send_transaction(trade_type, transaction, wait_confirmation).await
     }
 
-    async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>) -> Result<()> {
-        self.send_transactions(trade_type, transactions).await
+    async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>, wait_confirmation: bool) -> Result<()> {
+        self.send_transactions(trade_type, transactions, wait_confirmation).await
     }
 
     fn get_tip_account(&self) -> Result<String> {
@@ -114,7 +114,7 @@ impl StelliumClient {
         });
     }
 
-    pub async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction) -> Result<()> {
+    pub async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction, wait_confirmation: bool) -> Result<()> {
         let start_time = Instant::now();
         let (content, signature) = serialize_transaction_and_encode(transaction, UiTransactionEncoding::Base64).await?;
 
@@ -155,7 +155,7 @@ impl StelliumClient {
         }
 
         let start_time: Instant = Instant::now();
-        match poll_transaction_confirmation(&self.rpc_client, signature).await {
+        match poll_transaction_confirmation(&self.rpc_client, signature, wait_confirmation).await {
             Ok(_) => (),
             Err(e) => {
                 println!(" signature: {:?}", signature);
@@ -163,15 +163,17 @@ impl StelliumClient {
                 return Err(e);
             },
         }
-        println!(" signature: {:?}", signature);
-        println!(" [Stellium] {} confirmed: {:?}", trade_type, start_time.elapsed());
+        if wait_confirmation {
+            println!(" signature: {:?}", signature);
+            println!(" [Stellium] {} confirmed: {:?}", trade_type, start_time.elapsed());
+        }
 
         Ok(())
     }
 
-    pub async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>) -> Result<()> {
+    pub async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>, wait_confirmation: bool) -> Result<()> {
         for transaction in transactions {
-            self.send_transaction(trade_type, transaction).await?;
+            self.send_transaction(trade_type, transaction, wait_confirmation).await?;
         }
         Ok(())
     }

src/swqos/temporal.rs

@@ -44,12 +44,12 @@ pub struct TemporalClient {
 
 #[async_trait::async_trait]
 impl SwqosClientTrait for TemporalClient {
-    async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction) -> Result<()> {
-        self.send_transaction(trade_type, transaction).await
+    async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction, wait_confirmation: bool) -> Result<()> {
+        self.send_transaction(trade_type, transaction, wait_confirmation).await
     }
 
-    async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>) -> Result<()> {
-        self.send_transactions(trade_type, transactions).await
+    async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>, wait_confirmation: bool) -> Result<()> {
+        self.send_transactions(trade_type, transactions, wait_confirmation).await
     }
 
     fn get_tip_account(&self) -> Result<String> {
@@ -166,7 +166,7 @@ impl TemporalClient {
         Ok(())
     }
 
-    pub async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction) -> Result<()> {
+    pub async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction, wait_confirmation: bool) -> Result<()> {
         let start_time = Instant::now();
         let (content, signature) = serialize_transaction_and_encode(transaction, UiTransactionEncoding::Base64).await?;
 
@@ -205,7 +205,7 @@ impl TemporalClient {
         }
 
         let start_time: Instant = Instant::now();
-        match poll_transaction_confirmation(&self.rpc_client, signature).await {
+        match poll_transaction_confirmation(&self.rpc_client, signature, wait_confirmation).await {
             Ok(_) => (),
             Err(e) => {
                 println!(" signature: {:?}", signature);
@@ -213,15 +213,17 @@ impl TemporalClient {
                 return Err(e);
             },
         }
-        println!(" signature: {:?}", signature);
-        println!(" [nozomi] {} confirmed: {:?}", trade_type, start_time.elapsed());
+        if wait_confirmation {
+            println!(" signature: {:?}", signature);
+            println!(" [nozomi] {} confirmed: {:?}", trade_type, start_time.elapsed());
+        }
 
         Ok(())
     }
 
-    pub async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>) -> Result<()> {
+    pub async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>, wait_confirmation: bool) -> Result<()> {
         for transaction in transactions {
-            self.send_transaction(trade_type, transaction).await?;
+            self.send_transaction(trade_type, transaction, wait_confirmation).await?;
         }
         Ok(())
     }

src/swqos/zeroslot.rs

@@ -25,12 +25,12 @@ pub struct ZeroSlotClient {
 
 #[async_trait::async_trait]
 impl SwqosClientTrait for ZeroSlotClient {
-    async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction) -> Result<()> {
-        self.send_transaction(trade_type, transaction).await
+    async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction, wait_confirmation: bool) -> Result<()> {
+        self.send_transaction(trade_type, transaction, wait_confirmation).await
     }
 
-    async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>) -> Result<()> {
-        self.send_transactions(trade_type, transactions).await
+    async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>, wait_confirmation: bool) -> Result<()> {
+        self.send_transactions(trade_type, transactions, wait_confirmation).await
     }
 
     fn get_tip_account(&self) -> Result<String> {
@@ -62,7 +62,7 @@ impl ZeroSlotClient {
         Self { rpc_client: Arc::new(rpc_client), endpoint, auth_token, http_client }
     }
 
-    pub async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction) -> Result<()> {
+    pub async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction, wait_confirmation: bool) -> Result<()> {
         let start_time = Instant::now();
         let (content, signature) = serialize_transaction_and_encode(transaction, UiTransactionEncoding::Base64).await?;
 
@@ -102,7 +102,7 @@ impl ZeroSlotClient {
         }
 
         let start_time: Instant = Instant::now();
-        match poll_transaction_confirmation(&self.rpc_client, signature).await {
+        match poll_transaction_confirmation(&self.rpc_client, signature, wait_confirmation).await {
             Ok(_) => (),
             Err(e) => {
                 println!(" signature: {:?}", signature);
@@ -110,15 +110,17 @@ impl ZeroSlotClient {
                 return Err(e);
             },
         }
-        println!(" signature: {:?}", signature);
-        println!(" [0slot] {} confirmed: {:?}", trade_type, start_time.elapsed());
+        if wait_confirmation {
+            println!(" signature: {:?}", signature);
+            println!(" [0slot] {} confirmed: {:?}", trade_type, start_time.elapsed());
+        }
 
         Ok(())
     }
 
-    pub async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>) -> Result<()> {
+    pub async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>, wait_confirmation: bool) -> Result<()> {
         for transaction in transactions {
-            self.send_transaction(trade_type, transaction).await?;
+            self.send_transaction(trade_type, transaction, wait_confirmation).await?;
         }
         Ok(())
     }

src/trading/common/compute_budget_manager.rs

@@ -7,30 +7,24 @@ use solana_compute_budget_interface::ComputeBudgetInstruction;
 /// Cache key containing all parameters for compute budget instructions
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 struct ComputeBudgetCacheKey {
-    data_size_limit: u32,
     unit_price: u64,
     unit_limit: u32,
-    is_buy: bool,
 }
 
 /// Global cache storing compute budget instructions
 /// Uses DashMap for high-performance lock-free concurrent access
-static COMPUTE_BUDGET_CACHE: Lazy<DashMap<ComputeBudgetCacheKey, SmallVec<[Instruction; 3]>>> =
+static COMPUTE_BUDGET_CACHE: Lazy<DashMap<ComputeBudgetCacheKey, SmallVec<[Instruction; 2]>>> =
     Lazy::new(|| DashMap::new());
 
 #[inline(always)]
 pub fn compute_budget_instructions(
     unit_price: u64,
     unit_limit: u32,
-    data_size_limit: u32,
-    is_buy: bool,
-) -> SmallVec<[Instruction; 3]> {
+) -> SmallVec<[Instruction; 2]> {
     // Create cache key
     let cache_key = ComputeBudgetCacheKey {
-        data_size_limit,
         unit_price: unit_price,
         unit_limit: unit_limit,
-        is_buy,
     };
 
     // Try to get from cache first
@@ -39,12 +33,7 @@ pub fn compute_budget_instructions(
     }
 
     // Cache miss, generate new instructions
-    let mut insts = SmallVec::<[Instruction; 3]>::new();
-
-    // Only add data_size_limit instruction if > 0 and is_buy
-    if is_buy && data_size_limit > 0 {
-        insts.push(ComputeBudgetInstruction::set_loaded_accounts_data_size_limit(data_size_limit));
-    }
+    let mut insts = SmallVec::<[Instruction; 2]>::new();
 
     // Only add compute unit price instruction if > 0
     if unit_price > 0 {

src/trading/common/transaction_builder.rs

@@ -24,7 +24,6 @@ pub async fn build_transaction(
     business_instructions: Vec<Instruction>,
     address_lookup_table_account: Option<AddressLookupTableAccount>,
     recent_blockhash: Option<Hash>,
-    data_size_limit: u32,
     middleware_manager: Option<Arc<MiddlewareManager>>,
     protocol_name: &str,
     is_buy: bool,
@@ -57,8 +56,6 @@ pub async fn build_transaction(
     instructions.extend(compute_budget_instructions(
         unit_price,
         unit_limit,
-        data_size_limit,
-        is_buy,
     ));
 
     // Add business instructions

src/trading/core/async_executor.rs

@@ -200,7 +200,6 @@ pub async fn execute_parallel(
     address_lookup_table_account: Option<AddressLookupTableAccount>,
     recent_blockhash: Option<Hash>,
     durable_nonce: Option<DurableNonceInfo>,
-    data_size_limit: u32,
     middleware_manager: Option<Arc<MiddlewareManager>>,
     protocol_name: &'static str,
     is_buy: bool,
@@ -320,7 +319,6 @@ pub async fn execute_parallel(
                 instructions.as_ref().clone(),
                 address_lookup_table_account,
                 recent_blockhash,
-                data_size_limit,
                 middleware_manager,
                 protocol_name,
                 is_buy,
@@ -354,6 +352,7 @@ pub async fn execute_parallel(
                 .send_transaction(
                     if is_buy { TradeType::Buy } else { TradeType::Sell },
                     &transaction,
+                    wait_transaction_confirmed,
                 )
                 .await
             {

src/trading/core/executor.rs

@@ -89,7 +89,6 @@ impl TradeExecutor for GenericTradeExecutor {
                 params.address_lookup_table_account,
                 params.recent_blockhash,
                 params.durable_nonce,
-                if is_buy { params.data_size_limit } else { 0 },
                 params.middleware_manager,
                 self.protocol_name,
                 is_buy,
@@ -139,7 +138,6 @@ impl TradeExecutor for GenericTradeExecutor {
             params.address_lookup_table_account,
             params.recent_blockhash,
             params.durable_nonce,
-            if is_buy { params.data_size_limit } else { 0 },
             params.middleware_manager,
             self.protocol_name,
             is_buy,
@@ -184,7 +182,6 @@ async fn simulate_transaction(
     address_lookup_table_account: Option<AddressLookupTableAccount>,
     recent_blockhash: Option<Hash>,
     durable_nonce: Option<DurableNonceInfo>,
-    data_size_limit: u32,
     middleware_manager: Option<Arc<MiddlewareManager>>,
     protocol_name: &'static str,
     is_buy: bool,
@@ -221,7 +218,6 @@ async fn simulate_transaction(
         instructions,
         address_lookup_table_account,
         recent_blockhash,
-        data_size_limit,
         middleware_manager,
         protocol_name,
         is_buy,

src/trading/core/params.rs

@@ -53,7 +53,6 @@ pub struct SwapParams {
     pub slippage_basis_points: Option<u64>,
     pub address_lookup_table_account: Option<AddressLookupTableAccount>,
     pub recent_blockhash: Option<Hash>,
-    pub data_size_limit: u32,
     pub wait_transaction_confirmed: bool,
     pub protocol_params: DexParamEnum,
     pub open_seed_optimize: bool,