refactor: unify event parsing API with callback ownership transfer

examples/parse_tx_events.rs

@@ -36,8 +36,9 @@ async fn main() -> Result<()> {
 
 /// Get details of a single transaction
 async fn get_single_transaction_details(signature_str: &str) -> Result<()> {
-    use solana_sdk::signature::Signature;
-    use solana_transaction_status::UiTransactionEncoding;
+    use solana_sdk::{signature::Signature, pubkey::Pubkey, message::compiled_instruction::CompiledInstruction};
+    use solana_transaction_status::{UiTransactionEncoding, InnerInstruction, InnerInstructions, UiInstruction};
+    use prost_types::Timestamp;
 
     let signature = Signature::from_str(signature_str)?;
 
@@ -88,6 +89,96 @@ async fn get_single_transaction_details(signature_str: &str) -> Result<()> {
                     }
                 }
             }
+
+            // Parse the transaction and extract necessary data
+            let versioned_tx = match transaction.transaction.transaction.decode() {
+                Some(tx) => tx,
+                None => {
+                    println!("Failed to decode transaction");
+                    return Ok(());
+                }
+            };
+
+            // Convert inner instructions from meta
+            let mut inner_instructions_vec: Vec<InnerInstructions> = Vec::new();
+            if let Some(meta) = &transaction.transaction.meta {
+                if let solana_transaction_status::option_serializer::OptionSerializer::Some(
+                    ui_inner_insts,
+                ) = &meta.inner_instructions
+                {
+                    for ui_inner in ui_inner_insts {
+                        let mut converted_instructions = Vec::new();
+
+                        for ui_instruction in &ui_inner.instructions {
+                            if let UiInstruction::Compiled(ui_compiled) = ui_instruction {
+                                if let Ok(data) = solana_sdk::bs58::decode(&ui_compiled.data).into_vec() {
+                                    let compiled_instruction = CompiledInstruction {
+                                        program_id_index: ui_compiled.program_id_index,
+                                        accounts: ui_compiled.accounts.to_vec(),
+                                        data,
+                                    };
+
+                                    let inner_instruction = InnerInstruction {
+                                        instruction: compiled_instruction,
+                                        stack_height: ui_compiled.stack_height,
+                                    };
+
+                                    converted_instructions.push(inner_instruction);
+                                }
+                            }
+                        }
+
+                        let inner_instructions = InnerInstructions {
+                            index: ui_inner.index,
+                            instructions: converted_instructions,
+                        };
+
+                        inner_instructions_vec.push(inner_instructions);
+                    }
+                }
+            }
+
+            // Extract address table lookups
+            let meta = transaction.transaction.meta;
+            let mut address_table_lookups: Vec<Pubkey> = vec![];
+            if let Some(meta) = meta {
+                if let solana_transaction_status::option_serializer::OptionSerializer::Some(
+                    loaded_addresses,
+                ) = &meta.loaded_addresses
+                {
+                    address_table_lookups
+                        .reserve(loaded_addresses.writable.len() + loaded_addresses.readonly.len());
+                    address_table_lookups.extend(
+                        loaded_addresses
+                            .writable
+                            .iter()
+                            .filter_map(|s| s.parse::<Pubkey>().ok())
+                            .chain(
+                                loaded_addresses
+                                    .readonly
+                                    .iter()
+                                    .filter_map(|s| s.parse::<Pubkey>().ok()),
+                            ),
+                    );
+                }
+            }
+
+            // Build complete accounts list
+            let mut accounts = Vec::with_capacity(
+                versioned_tx.message.static_account_keys().len() + address_table_lookups.len(),
+            );
+            accounts.extend_from_slice(versioned_tx.message.static_account_keys());
+            accounts.extend(address_table_lookups);
+
+            let slot = transaction.slot;
+            let block_time = transaction.block_time.map(|t| Timestamp { seconds: t as i64, nanos: 0 });
+            let recv_us = std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_micros() as i64;
+            let bot_wallet = None;
+            let transaction_index = None;
+
             let protocols = vec![
                 Protocol::Bonk,
                 Protocol::RaydiumClmm,
@@ -96,14 +187,26 @@ async fn get_single_transaction_details(signature_str: &str) -> Result<()> {
                 Protocol::RaydiumCpmm,
                 Protocol::RaydiumAmmV4,
             ];
-            EventParser::parse_encoded_confirmed_transaction_with_status_meta(
+
+            // Create callback
+            let callback = Arc::new(move |event: DexEvent| {
+                println!("{:?}\n", event);
+            });
+
+            // Call parse_instruction_events_from_versioned_transaction
+            EventParser::parse_instruction_events_from_versioned_transaction(
                 &protocols,
                 None,
+                &versioned_tx,
                 signature,
-                transaction,
-                Arc::new(move |event: &DexEvent| {
-                    println!("{:?}\n", event);
-                }),
+                Some(slot),
+                block_time,
+                recv_us,
+                &accounts,
+                &inner_instructions_vec,
+                bot_wallet,
+                transaction_index,
+                callback,
             )
             .await?;
         }