feat(api): Upgrade to v0.1.5 with improved event subscription API

This update includes the following improvements:
- Version upgraded to 0.1.5
- Added subscribe_events_v2 API with more granular account filtering
- Marked original subscribe_events API as deprecated
- Fixed bug

src/streaming/event_parser/common/mod.rs

@@ -50,6 +50,10 @@ macro_rules! impl_unified_event {
             fn set_transfer_datas(&mut self, transfer_datas: Vec<$crate::streaming::event_parser::common::types::TransferData>) {
                 self.metadata.transfer_datas = transfer_datas;
             }
+
+            fn index(&self) -> String {
+                self.metadata.index.clone()
+            }
         }
     };
 }

src/streaming/event_parser/common/types.rs

@@ -162,6 +162,7 @@ pub struct EventMetadata {
     pub event_type: EventType,
     pub program_id: Pubkey,
     pub transfer_datas: Vec<TransferData>,
+    pub index: String,
 }
 
 impl EventMetadata {
@@ -174,6 +175,7 @@ impl EventMetadata {
         protocol: ProtocolType,
         event_type: EventType,
         program_id: Pubkey,
+        index: String,
     ) -> Self {
         Self {
             id,
@@ -186,6 +188,7 @@ impl EventMetadata {
             event_type,
             program_id,
             transfer_datas: vec![],
+            index,
         }
     }
     pub fn set_id(&mut self, id: String) {

src/streaming/event_parser/core/traits.rs

@@ -52,6 +52,8 @@ pub trait UnifiedEvent: Debug + Send + Sync {
     }
 
     fn set_transfer_datas(&mut self, transfer_datas: Vec<TransferData>);
+
+    fn index(&self) -> String;
 }
 
 /// 事件解析器trait - 定义了事件解析的核心方法
@@ -64,6 +66,7 @@ pub trait EventParser: Send + Sync {
         signature: &str,
         slot: u64,
         block_time: Option<Timestamp>,
+        index: String,
     ) -> Vec<Box<dyn UnifiedEvent>>;
 
     /// 从指令中解析事件数据
@@ -74,6 +77,7 @@ pub trait EventParser: Send + Sync {
         signature: &str,
         slot: u64,
         block_time: Option<Timestamp>,
+        index: String,
     ) -> Vec<Box<dyn UnifiedEvent>>;
 
     /// 从VersionedTransaction中解析指令事件的通用方法
@@ -106,7 +110,14 @@ pub trait EventParser: Send + Sync {
                             }
                         }
                         if let Ok(mut events) = self
-                            .parse_instruction(instruction, &accounts, signature, slot, block_time)
+                            .parse_instruction(
+                                instruction,
+                                &accounts,
+                                signature,
+                                slot,
+                                block_time,
+                                format!("{}", index),
+                            )
                             .await
                         {
                             if events.len() > 0 {
@@ -231,6 +242,7 @@ pub trait EventParser: Send + Sync {
                                     signature,
                                     slot,
                                     block_time,
+                                    format!("{}.{}", inner_instruction.index, index),
                                 )
                                 .await
                             {
@@ -249,7 +261,13 @@ pub trait EventParser: Send + Sync {
                                 }
                             }
                             if let Ok(mut events) = self
-                                .parse_inner_instruction(compiled, signature, slot, block_time)
+                                .parse_inner_instruction(
+                                    compiled,
+                                    signature,
+                                    slot,
+                                    block_time,
+                                    format!("{}.{}", inner_instruction.index, index),
+                                )
                                 .await
                             {
                                 if events.len() > 0 {
@@ -276,11 +294,28 @@ pub trait EventParser: Send + Sync {
         if instruction_events.len() > 0 && inner_instruction_events.len() > 0 {
             for instruction_event in &mut instruction_events {
                 for inner_instruction_event in &inner_instruction_events {
-                    if instruction_event.id() == inner_instruction_event.id()
-                        && instruction_event.event_type() == inner_instruction_event.event_type()
-                    {
-                        instruction_event.merge(inner_instruction_event.clone_boxed());
-                        break;
+                    if instruction_event.id() == inner_instruction_event.id() {
+                        let i_index = instruction_event.index();
+                        let in_index = inner_instruction_event.index();
+                        if !i_index.contains(".") && in_index.contains(".") {
+                            let in_index_parent_index = in_index.split(".").nth(0).unwrap();
+                            if in_index_parent_index == i_index {
+                                instruction_event.merge(inner_instruction_event.clone_boxed());
+                                break;
+                            }
+                        } else if i_index.contains(".") && in_index.contains(".") {
+                            // 嵌套指令
+                            let i_index_parent_index = i_index.split(".").nth(0).unwrap();
+                            let in_index_parent_index = in_index.split(".").nth(0).unwrap();
+                            if i_index_parent_index == in_index_parent_index {
+                                let i_index_child_index = i_index.split(".").nth(1).unwrap();
+                                let in_index_child_index = in_index.split(".").nth(1).unwrap();
+                                if in_index_child_index > i_index_child_index {
+                                    instruction_event.merge(inner_instruction_event.clone_boxed());
+                                    break;
+                                }
+                            }
+                        }
                     }
                 }
             }
@@ -329,10 +364,16 @@ pub trait EventParser: Send + Sync {
         signature: &str,
         slot: Option<u64>,
         block_time: Option<Timestamp>,
+        index: String,
     ) -> Result<Vec<Box<dyn UnifiedEvent>>> {
         let slot = slot.unwrap_or(0);
-        let events =
-            self.parse_events_from_inner_instruction(instruction, signature, slot, block_time);
+        let events = self.parse_events_from_inner_instruction(
+            instruction,
+            signature,
+            slot,
+            block_time,
+            index,
+        );
         Ok(events)
     }
 
@@ -343,10 +384,17 @@ pub trait EventParser: Send + Sync {
         signature: &str,
         slot: Option<u64>,
         block_time: Option<Timestamp>,
+        index: String,
     ) -> Result<Vec<Box<dyn UnifiedEvent>>> {
         let slot = slot.unwrap_or(0);
-        let events =
-            self.parse_events_from_instruction(instruction, accounts, signature, slot, block_time);
+        let events = self.parse_events_from_instruction(
+            instruction,
+            accounts,
+            signature,
+            slot,
+            block_time,
+            index,
+        );
         Ok(events)
     }
 
@@ -427,6 +475,7 @@ impl GenericEventParser {
         signature: &str,
         slot: u64,
         block_time: Option<Timestamp>,
+        index: String,
     ) -> Option<Box<dyn UnifiedEvent>> {
         let timestamp = block_time.unwrap_or(Timestamp {
             seconds: 0,
@@ -442,6 +491,7 @@ impl GenericEventParser {
             self.protocol_type.clone(),
             config.event_type.clone(),
             self.program_id,
+            index,
         );
         (config.inner_instruction_parser)(data, metadata)
     }
@@ -455,6 +505,7 @@ impl GenericEventParser {
         signature: &str,
         slot: u64,
         block_time: Option<Timestamp>,
+        index: String,
     ) -> Option<Box<dyn UnifiedEvent>> {
         let timestamp = block_time.unwrap_or(Timestamp {
             seconds: 0,
@@ -470,6 +521,7 @@ impl GenericEventParser {
             self.protocol_type.clone(),
             config.event_type.clone(),
             self.program_id,
+            index,
         );
         (config.instruction_parser)(data, account_pubkeys, metadata)
     }
@@ -484,6 +536,7 @@ impl EventParser for GenericEventParser {
         signature: &str,
         slot: u64,
         block_time: Option<Timestamp>,
+        index: String,
     ) -> Vec<Box<dyn UnifiedEvent>> {
         let inner_instruction_data = inner_instruction.data.clone();
         let inner_instruction_data_decoded =
@@ -498,9 +551,14 @@ impl EventParser for GenericEventParser {
         for (disc, configs) in &self.inner_instruction_configs {
             if discriminator_matches(&inner_instruction_data_decoded_str, disc) {
                 for config in configs {
-                    if let Some(event) = self
-                        .parse_inner_instruction_event(config, data, signature, slot, block_time)
-                    {
+                    if let Some(event) = self.parse_inner_instruction_event(
+                        config,
+                        data,
+                        signature,
+                        slot,
+                        block_time,
+                        index.clone(),
+                    ) {
                         events.push(event);
                     }
                 }
@@ -517,6 +575,7 @@ impl EventParser for GenericEventParser {
         signature: &str,
         slot: u64,
         block_time: Option<Timestamp>,
+        index: String,
     ) -> Vec<Box<dyn UnifiedEvent>> {
         let program_id = accounts[instruction.program_id_index as usize];
         if !self.should_handle(&program_id) {
@@ -548,6 +607,7 @@ impl EventParser for GenericEventParser {
                         signature,
                         slot,
                         block_time,
+                        index.clone(),
                     ) {
                         events.push(event);
                     }

src/streaming/event_parser/protocols/bonk/parser.rs

@@ -421,9 +421,15 @@ impl EventParser for BonkEventParser {
         signature: &str,
         slot: u64,
         block_time: Option<Timestamp>,
+        index: String,
     ) -> Vec<Box<dyn UnifiedEvent>> {
-        self.inner
-            .parse_events_from_inner_instruction(inner_instruction, signature, slot, block_time)
+        self.inner.parse_events_from_inner_instruction(
+            inner_instruction,
+            signature,
+            slot,
+            block_time,
+            index,
+        )
     }
 
     fn parse_events_from_instruction(
@@ -433,9 +439,16 @@ impl EventParser for BonkEventParser {
         signature: &str,
         slot: u64,
         block_time: Option<Timestamp>,
+        index: String,
     ) -> Vec<Box<dyn UnifiedEvent>> {
-        self.inner
-            .parse_events_from_instruction(instruction, accounts, signature, slot, block_time)
+        self.inner.parse_events_from_instruction(
+            instruction,
+            accounts,
+            signature,
+            slot,
+            block_time,
+            index,
+        )
     }
 
     fn should_handle(&self, program_id: &Pubkey) -> bool {

src/streaming/event_parser/protocols/pumpfun/parser.rs

@@ -226,9 +226,15 @@ impl EventParser for PumpFunEventParser {
         signature: &str,
         slot: u64,
         block_time: Option<Timestamp>,
+        index: String,
     ) -> Vec<Box<dyn UnifiedEvent>> {
-        self.inner
-            .parse_events_from_inner_instruction(inner_instruction, signature, slot, block_time)
+        self.inner.parse_events_from_inner_instruction(
+            inner_instruction,
+            signature,
+            slot,
+            block_time,
+            index,
+        )
     }
 
     fn parse_events_from_instruction(
@@ -238,9 +244,16 @@ impl EventParser for PumpFunEventParser {
         signature: &str,
         slot: u64,
         block_time: Option<Timestamp>,
+        index: String,
     ) -> Vec<Box<dyn UnifiedEvent>> {
-        self.inner
-            .parse_events_from_instruction(instruction, accounts, signature, slot, block_time)
+        self.inner.parse_events_from_instruction(
+            instruction,
+            accounts,
+            signature,
+            slot,
+            block_time,
+            index,
+        )
     }
 
     fn should_handle(&self, program_id: &Pubkey) -> bool {

src/streaming/event_parser/protocols/pumpswap/parser.rs

@@ -3,7 +3,7 @@ use solana_sdk::{instruction::CompiledInstruction, pubkey::Pubkey};
 use solana_transaction_status::UiCompiledInstruction;
 
 use crate::streaming::event_parser::{
-    common::{EventMetadata, EventType, ProtocolType, read_u64_le},
+    common::{read_u64_le, EventMetadata, EventType, ProtocolType},
     core::traits::{EventParser, GenericEventParseConfig, GenericEventParser, UnifiedEvent},
     protocols::pumpswap::{
         discriminators, PumpSwapBuyEvent, PumpSwapCreatePoolEvent, PumpSwapDepositEvent,
@@ -67,7 +67,10 @@ impl PumpSwapEventParser {
     }
 
     /// 解析买入日志事件
-    fn parse_buy_inner_instruction(data: &[u8], metadata: EventMetadata) -> Option<Box<dyn UnifiedEvent>> {
+    fn parse_buy_inner_instruction(
+        data: &[u8],
+        metadata: EventMetadata,
+    ) -> Option<Box<dyn UnifiedEvent>> {
         if let Ok(event) = borsh::from_slice::<PumpSwapBuyEvent>(data) {
             let mut metadata = metadata;
             metadata.set_id(format!(
@@ -84,7 +87,10 @@ impl PumpSwapEventParser {
     }
 
     /// 解析卖出日志事件
-    fn parse_sell_inner_instruction(data: &[u8], metadata: EventMetadata) -> Option<Box<dyn UnifiedEvent>> {
+    fn parse_sell_inner_instruction(
+        data: &[u8],
+        metadata: EventMetadata,
+    ) -> Option<Box<dyn UnifiedEvent>> {
         if let Ok(event) = borsh::from_slice::<PumpSwapSellEvent>(data) {
             let mut metadata = metadata;
             metadata.set_id(format!(
@@ -121,7 +127,10 @@ impl PumpSwapEventParser {
     }
 
     /// 解析存款日志事件
-    fn parse_deposit_inner_instruction(data: &[u8], metadata: EventMetadata) -> Option<Box<dyn UnifiedEvent>> {
+    fn parse_deposit_inner_instruction(
+        data: &[u8],
+        metadata: EventMetadata,
+    ) -> Option<Box<dyn UnifiedEvent>> {
         if let Ok(event) = borsh::from_slice::<PumpSwapDepositEvent>(data) {
             let mut metadata = metadata;
             metadata.set_id(format!(
@@ -138,7 +147,10 @@ impl PumpSwapEventParser {
     }
 
     /// 解析提款日志事件
-    fn parse_withdraw_inner_instruction(data: &[u8], metadata: EventMetadata) -> Option<Box<dyn UnifiedEvent>> {
+    fn parse_withdraw_inner_instruction(
+        data: &[u8],
+        metadata: EventMetadata,
+    ) -> Option<Box<dyn UnifiedEvent>> {
         if let Ok(event) = borsh::from_slice::<PumpSwapWithdrawEvent>(data) {
             let mut metadata = metadata;
             metadata.set_id(format!(
@@ -362,9 +374,15 @@ impl EventParser for PumpSwapEventParser {
         signature: &str,
         slot: u64,
         block_time: Option<Timestamp>,
+        index: String,
     ) -> Vec<Box<dyn UnifiedEvent>> {
-        self.inner
-            .parse_events_from_inner_instruction(inner_instruction, signature, slot, block_time)
+        self.inner.parse_events_from_inner_instruction(
+            inner_instruction,
+            signature,
+            slot,
+            block_time,
+            index,
+        )
     }
 
     fn parse_events_from_instruction(
@@ -374,9 +392,16 @@ impl EventParser for PumpSwapEventParser {
         signature: &str,
         slot: u64,
         block_time: Option<Timestamp>,
+        index: String,
     ) -> Vec<Box<dyn UnifiedEvent>> {
-        self.inner
-            .parse_events_from_instruction(instruction, accounts, signature, slot, block_time)
+        self.inner.parse_events_from_instruction(
+            instruction,
+            accounts,
+            signature,
+            slot,
+            block_time,
+            index,
+        )
     }
 
     fn should_handle(&self, program_id: &Pubkey) -> bool {

src/streaming/event_parser/protocols/raydium_clmm/parser.rs

@@ -146,9 +146,15 @@ impl EventParser for RaydiumClmmEventParser {
         signature: &str,
         slot: u64,
         block_time: Option<Timestamp>,
+        index: String,
     ) -> Vec<Box<dyn UnifiedEvent>> {
-        self.inner
-            .parse_events_from_inner_instruction(inner_instruction, signature, slot, block_time)
+        self.inner.parse_events_from_inner_instruction(
+            inner_instruction,
+            signature,
+            slot,
+            block_time,
+            index,
+        )
     }
 
     fn parse_events_from_instruction(
@@ -158,9 +164,16 @@ impl EventParser for RaydiumClmmEventParser {
         signature: &str,
         slot: u64,
         block_time: Option<Timestamp>,
+        index: String,
     ) -> Vec<Box<dyn UnifiedEvent>> {
-        self.inner
-            .parse_events_from_instruction(instruction, accounts, signature, slot, block_time)
+        self.inner.parse_events_from_instruction(
+            instruction,
+            accounts,
+            signature,
+            slot,
+            block_time,
+            index,
+        )
     }
 
     fn should_handle(&self, program_id: &Pubkey) -> bool {

src/streaming/event_parser/protocols/raydium_cpmm/parser.rs

@@ -135,9 +135,15 @@ impl EventParser for RaydiumCpmmEventParser {
         signature: &str,
         slot: u64,
         block_time: Option<Timestamp>,
+        index: String,
     ) -> Vec<Box<dyn UnifiedEvent>> {
-        self.inner
-            .parse_events_from_inner_instruction(inner_instruction, signature, slot, block_time)
+        self.inner.parse_events_from_inner_instruction(
+            inner_instruction,
+            signature,
+            slot,
+            block_time,
+            index,
+        )
     }
 
     fn parse_events_from_instruction(
@@ -147,9 +153,16 @@ impl EventParser for RaydiumCpmmEventParser {
         signature: &str,
         slot: u64,
         block_time: Option<Timestamp>,
+        index: String,
     ) -> Vec<Box<dyn UnifiedEvent>> {
-        self.inner
-            .parse_events_from_instruction(instruction, accounts, signature, slot, block_time)
+        self.inner.parse_events_from_instruction(
+            instruction,
+            accounts,
+            signature,
+            slot,
+            block_time,
+            index,
+        )
     }
 
     fn should_handle(&self, program_id: &Pubkey) -> bool {