perf: Refactor event processing system for better performance

examples/parse_tx_events.rs.bak

@@ -1,8 +1,13 @@
 use anyhow::Result;
 use solana_sdk::commitment_config::CommitmentConfig;
+use solana_sdk::message::v0::LoadedAddresses;
 use solana_streamer_sdk::streaming::event_parser::{
     protocols::MutilEventParser, EventParser, Protocol,
 };
+use solana_transaction_status::{
+    option_serializer::OptionSerializer, TransactionStatusMeta, TransactionWithStatusMeta,
+    VersionedTransactionWithStatusMeta,
+};
 use std::str::FromStr;
 use std::sync::Arc;
 
@@ -10,7 +15,7 @@ use std::sync::Arc;
 #[tokio::main]
 async fn main() -> Result<()> {
     let signatures = vec![
-        "42agNk1heHabNAVRzEKqQEt5adGkQzRYf9M1Q81uBJPCCHyP4cyCA1RNkgxXrtEAWeeGcytyh2TsnkBDgqnHeq4z",
+        "5cnxDiHzUTUutMwnTCsvnMhyL9jEQsRWimmWU1gKxpQBngDaGTkou1YbGhUJhAhmTgvu49PYMmFQbbR38wdZDxJF",
     ];
     // Validate signature format
     let mut valid_signatures = Vec::new();
@@ -52,7 +57,7 @@ async fn get_single_transaction_details(signature_str: &str) -> Result<()> {
         .get_transaction_with_config(
             &signature,
             solana_client::rpc_config::RpcTransactionConfig {
-                encoding: Some(UiTransactionEncoding::Binary),
+                encoding: Some(UiTransactionEncoding::Base64),
                 commitment: Some(CommitmentConfig::confirmed()),
                 max_supported_transaction_version: Some(0),
             },
@@ -99,21 +104,85 @@ async fn get_single_transaction_details(signature_str: &str) -> Result<()> {
             ];
             let parser: Arc<dyn EventParser> = Arc::new(MutilEventParser::new(protocols, None));
             let start_time = std::time::Instant::now();
+
+            // 从 EncodedTransaction 获取 VersionedTransaction
+            let versioned_tx = match transaction.transaction.transaction.decode() {
+                Some(tx) => tx,
+                None => {
+                    println!("Failed to decode transaction");
+                    return Ok(());
+                }
+            };
+
+            // 创建 TransactionWithStatusMeta
+            let tx = TransactionWithStatusMeta::Complete(VersionedTransactionWithStatusMeta {
+                transaction: versioned_tx,
+                meta: TransactionStatusMeta {
+                    status: Ok(()),
+                    fee: transaction.transaction.meta.as_ref().map_or(0, |m| m.fee),
+                    pre_balances: transaction
+                        .transaction
+                        .meta
+                        .as_ref()
+                        .map_or(vec![], |m| m.pre_balances.clone()),
+                    post_balances: transaction
+                        .transaction
+                        .meta
+                        .as_ref()
+                        .map_or(vec![], |m| m.post_balances.clone()),
+                    inner_instructions: transaction.transaction.meta.as_ref().and_then(|m| {
+                        if let OptionSerializer::Some(inner_instructions) = &m.inner_instructions {
+                            // 手动将每个UiInnerInstructions转换为InnerInstructions
+                            Some(inner_instructions.iter().map(|ui_inner| {
+                                solana_transaction_status::InnerInstructions {
+                                    index: ui_inner.index,
+                                    instructions: ui_inner.instructions.iter().map(|ui_inst| {
+                                        solana_transaction_status::InnerInstruction {
+                                            instruction: solana_sdk::instruction::Instruction {
+                                                program_id: solana_sdk::pubkey::Pubkey::new_from_array([0; 32]),
+                                                accounts: vec![],
+                                                data: vec![],
+                                            },
+                                            stack_height: None,
+                                        }
+                                    }).collect(),
+                                }
+                            }).collect())
+                        } else {
+                            None
+                        }
+                    }),
+                    log_messages: transaction.transaction.meta.as_ref().and_then(|m| {
+                        if let OptionSerializer::Some(logs) = &m.log_messages {
+                            Some(logs.clone())
+                        } else {
+                            None
+                        }
+                    }),
+                    pre_token_balances: None,
+                    post_token_balances: None,
+                    rewards: None,
+                    loaded_addresses: LoadedAddresses::default(),
+                    return_data: None,
+                    compute_units_consumed: None,
+                    cost_units: None,
+                },
+            });
+
+            // TransactionWithStatusMeta
             let events = parser
                 .parse_transaction(
-                    transaction.transaction.clone(),
+                    tx,
                     &signature.to_string(),
                     Some(transaction.slot),
                     None,
-                    0,
+                    chrono::Utc::now().timestamp_micros(),
                     None,
                 )
                 .await
                 .unwrap_or_else(|_e| vec![]);
 
-            let end_time = std::time::Instant::now();
-            let duration = end_time.duration_since(start_time);
-            println!("Parsing time: {:?}", duration);
+            println!("Parsing time: {:?}", start_time.elapsed());
             for event in events {
                 println!("{:?}\n", event);
             }