feat: upgrade to v3.3.4 with improved error handling and transaction details

- Add TradeError struct with code, message, and instruction fields
- Enhance poll_transaction_confirmation to extract detailed error info from logs
- Change buy/sell return type from Option<anyhow::Error> to Option<TradeError>
- Add solana-transaction-status-client-types dependency
- Remove unused parallel.rs module

src/swqos/common.rs

@@ -1,18 +1,44 @@
+use crate::common::types::SolanaRpcClient;
+use anyhow::Result;
+use base64::engine::general_purpose::{self, STANDARD};
+use base64::Engine;
 use bincode::serialize;
+use reqwest::Client;
+use serde_json;
 use serde_json::json;
 use solana_client::rpc_client::SerializableTransaction;
+use solana_client::rpc_config::RpcTransactionConfig;
 use solana_sdk::signature::Signature;
-use solana_sdk::transaction::Transaction;
+use solana_sdk::transaction::VersionedTransaction;
+use solana_sdk::transaction::{Transaction, TransactionError};
 use solana_transaction_status::{TransactionConfirmationStatus, UiTransactionEncoding};
 use std::str::FromStr;
 use std::time::{Duration, Instant};
 use tokio::time::sleep;
-use crate::common::types::SolanaRpcClient;
-use anyhow::Result;
-use base64::Engine;
-use base64::engine::general_purpose::{self, STANDARD};
-use reqwest::Client;
-use solana_sdk::transaction::VersionedTransaction;
+
+#[derive(Debug, Clone)]
+pub struct TradeError {
+    pub code: u32,
+    pub message: String,
+    pub instruction: Option<u8>,
+}
+
+impl std::fmt::Display for TradeError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.message)
+    }
+}
+
+impl std::error::Error for TradeError {}
+
+impl From<anyhow::Error> for TradeError {
+    fn from(e: anyhow::Error) -> Self {
+        if let Some(te) = e.downcast_ref::<TradeError>() {
+            return te.clone();
+        }
+        TradeError { code: 500, message: format!("{}", e), instruction: None }
+    }
+}
 
 // 使用高性能序列化
 
@@ -27,8 +53,11 @@ impl FormatBase64VersionedTransaction for VersionedTransaction {
     }
 }
 
-pub async fn poll_transaction_confirmation(rpc: &SolanaRpcClient, txt_sig: Signature) -> Result<Signature> {
-    let timeout: Duration = Duration::from_secs(15);  // 🔧 增加到15秒，避免网络拥堵时超时
+pub async fn poll_transaction_confirmation(
+    rpc: &SolanaRpcClient,
+    txt_sig: Signature,
+) -> Result<Signature> {
+    let timeout: Duration = Duration::from_secs(15); // 🔧 增加到15秒，避免网络拥堵时超时
     let interval: Duration = Duration::from_millis(1000);
     let start: Instant = Instant::now();
 
@@ -38,21 +67,80 @@ pub async fn poll_transaction_confirmation(rpc: &SolanaRpcClient, txt_sig: Signa
         }
 
         let status = rpc.get_signature_statuses(&[txt_sig]).await?;
-
         match status.value[0].clone() {
             Some(status) => {
                 if status.err.is_none()
-                    && (status.confirmation_status == Some(TransactionConfirmationStatus::Confirmed)
-                        || status.confirmation_status == Some(TransactionConfirmationStatus::Finalized))
+                    && (status.confirmation_status
+                        == Some(TransactionConfirmationStatus::Confirmed)
+                        || status.confirmation_status
+                            == Some(TransactionConfirmationStatus::Finalized))
                 {
                     return Ok(txt_sig);
                 }
-                if status.err.is_some() {
-                    return Err(anyhow::anyhow!(status.err.unwrap()));
-                }
             }
-            None => {
+            None => {}
+        }
+
+        let tx_details = match rpc
+            .get_transaction_with_config(
+                &txt_sig,
+                RpcTransactionConfig {
+                    encoding: Some(UiTransactionEncoding::JsonParsed),
+                    max_supported_transaction_version: Some(0),
+                    commitment: Some(solana_commitment_config::CommitmentConfig::confirmed()),
+                },
+            )
+            .await
+        {
+            Ok(details) => details,
+            Err(_) => {
+                // 交易可能还未上链，继续等待
                 sleep(interval).await;
+                continue;
+            }
+        };
+
+        let meta = tx_details.transaction.meta;
+        if meta.is_none() {
+            sleep(interval).await;
+        } else {
+            let meta = meta.unwrap();
+            if meta.err.is_none() {
+                return Ok(txt_sig);
+            } else {
+                // 从 log_messages 中提取错误信息
+                let mut error_msg = String::new();
+                if let solana_transaction_status::option_serializer::OptionSerializer::Some(logs) =
+                    &meta.log_messages
+                {
+                    for log in logs {
+                        if let Some(idx) = log.find("Error Message: ") {
+                            error_msg = log[idx + 15..].trim_end_matches('.').to_string();
+                            break;
+                        }
+                    }
+                }
+
+                let ui_err = meta.err.unwrap();
+                let tx_err: TransactionError =
+                    serde_json::from_value(serde_json::to_value(&ui_err)?)?;
+                let mut code = 500;
+                let mut index = None;
+                match &tx_err {
+                    TransactionError::InstructionError(i, i_error) => {
+                        match i_error {
+                            solana_sdk::instruction::InstructionError::Custom(c) => code = *c,
+                            _ => {}
+                        }
+                        index = Some(*i);
+                    }
+                    _ => {}
+                }
+                return Err(anyhow::Error::new(TradeError {
+                    code: code,
+                    message: format!("{} {:?}", tx_err, error_msg),
+                    instruction: index,
+                }));
             }
         }
     }