feat: Add account event parser and protocol type definitions

- Add account event parser (account_event_parser.rs) for account-level event handling
- Introduce type definitions for pumpfun, pumpswap, raydium_amm_v4, raydium_clmm, raydium_cpmm protocols
- Enhance event processor to support account event processing alongside transactions
- Improve subscription system with separate transaction and account filters
- Optimize parser configuration using Option types for cleaner code structure
- Update examples and documentation to reflect new capabilities

Changes include:
- 6 new types.rs files for protocol-specific data structures
- Updated event processor for account, transaction, and block meta events
- Refactored subscription manager with account filtering support
- Enhanced metrics and batch processing logic

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

@@ -3,6 +3,7 @@ use crate::streaming::event_parser::common::EventMetadata;
 use crate::streaming::event_parser::protocols::bonk::types::{
     CurveParams, MintParams, PoolStatus, TradeDirection, VestingParams,
 };
+use crate::streaming::event_parser::protocols::bonk::{GlobalConfig, PlatformConfig, PoolState};
 use borsh::BorshDeserialize;
 use serde::{Deserialize, Serialize};
 use solana_sdk::pubkey::Pubkey;
@@ -231,6 +232,45 @@ pub struct BonkMigrateToCpswapEvent {
 // Macro to generate UnifiedEvent implementation, specifying the fields to be merged
 impl_unified_event!(BonkMigrateToCpswapEvent,);
 
+/// 池状态
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct BonkPoolStateAccountEvent {
+    pub metadata: EventMetadata,
+    pub pubkey: String,
+    pub executable: bool,
+    pub lamports: u64,
+    pub owner: String,
+    pub rent_epoch: u64,
+    pub pool_state: PoolState,
+}
+impl_unified_event!(BonkPoolStateAccountEvent,);
+
+/// 全局配置
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct BonkGlobalConfigAccountEvent {
+    pub metadata: EventMetadata,
+    pub pubkey: String,
+    pub executable: bool,
+    pub lamports: u64,
+    pub owner: String,
+    pub rent_epoch: u64,
+    pub global_config: GlobalConfig,
+}
+impl_unified_event!(BonkGlobalConfigAccountEvent,);
+
+/// 平台配置
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+pub struct BonkPlatformConfigAccountEvent {
+    pub metadata: EventMetadata,
+    pub pubkey: String,
+    pub executable: bool,
+    pub lamports: u64,
+    pub owner: String,
+    pub rent_epoch: u64,
+    pub platform_config: PlatformConfig,
+}
+impl_unified_event!(BonkPlatformConfigAccountEvent,);
+
 /// Event discriminator constants
 pub mod discriminators {
     // Event discriminators
@@ -245,4 +285,9 @@ pub mod discriminators {
     pub const INITIALIZE: &[u8] = &[175, 175, 109, 31, 13, 152, 155, 237];
     pub const MIGRATE_TO_AMM: &[u8] = &[207, 82, 192, 145, 254, 207, 145, 223];
     pub const MIGRATE_TO_CP_SWAP: &[u8] = &[136, 92, 200, 103, 28, 218, 144, 140];
+
+    // 账户鉴别器
+    pub const POOL_STATE_ACCOUNT: &[u8] = &[247, 237, 227, 245, 215, 195, 222, 70];
+    pub const GLOBAL_CONFIG_ACCOUNT: &[u8] = &[149, 8, 156, 202, 160, 252, 176, 217];
+    pub const PLATFORM_CONFIG_ACCOUNT: &[u8] = &[160, 78, 128, 0, 248, 83, 230, 160];
 }

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

@@ -39,8 +39,8 @@ impl BonkEventParser {
                 inner_instruction_discriminator: discriminators::TRADE_EVENT,
                 instruction_discriminator: discriminators::BUY_EXACT_IN,
                 event_type: EventType::BonkBuyExactIn,
-                inner_instruction_parser: Self::parse_trade_inner_instruction,
-                instruction_parser: Self::parse_buy_exact_in_instruction,
+                inner_instruction_parser: Some(Self::parse_trade_inner_instruction),
+                instruction_parser: Some(Self::parse_buy_exact_in_instruction),
             },
             GenericEventParseConfig {
                 program_id: BONK_PROGRAM_ID,
@@ -48,8 +48,8 @@ impl BonkEventParser {
                 inner_instruction_discriminator: discriminators::TRADE_EVENT,
                 instruction_discriminator: discriminators::BUY_EXACT_OUT,
                 event_type: EventType::BonkBuyExactOut,
-                inner_instruction_parser: Self::parse_trade_inner_instruction,
-                instruction_parser: Self::parse_buy_exact_out_instruction,
+                inner_instruction_parser: Some(Self::parse_trade_inner_instruction),
+                instruction_parser: Some(Self::parse_buy_exact_out_instruction),
             },
             GenericEventParseConfig {
                 program_id: BONK_PROGRAM_ID,
@@ -57,8 +57,8 @@ impl BonkEventParser {
                 inner_instruction_discriminator: discriminators::TRADE_EVENT,
                 instruction_discriminator: discriminators::SELL_EXACT_IN,
                 event_type: EventType::BonkSellExactIn,
-                inner_instruction_parser: Self::parse_trade_inner_instruction,
-                instruction_parser: Self::parse_sell_exact_in_instruction,
+                inner_instruction_parser: Some(Self::parse_trade_inner_instruction),
+                instruction_parser: Some(Self::parse_sell_exact_in_instruction),
             },
             GenericEventParseConfig {
                 program_id: BONK_PROGRAM_ID,
@@ -66,8 +66,8 @@ impl BonkEventParser {
                 inner_instruction_discriminator: discriminators::TRADE_EVENT,
                 instruction_discriminator: discriminators::SELL_EXACT_OUT,
                 event_type: EventType::BonkSellExactOut,
-                inner_instruction_parser: Self::parse_trade_inner_instruction,
-                instruction_parser: Self::parse_sell_exact_out_instruction,
+                inner_instruction_parser: Some(Self::parse_trade_inner_instruction),
+                instruction_parser: Some(Self::parse_sell_exact_out_instruction),
             },
             GenericEventParseConfig {
                 program_id: BONK_PROGRAM_ID,
@@ -75,8 +75,8 @@ impl BonkEventParser {
                 inner_instruction_discriminator: discriminators::POOL_CREATE_EVENT,
                 instruction_discriminator: discriminators::INITIALIZE,
                 event_type: EventType::BonkInitialize,
-                inner_instruction_parser: Self::parse_pool_create_inner_instruction,
-                instruction_parser: Self::parse_initialize_instruction,
+                inner_instruction_parser: Some(Self::parse_pool_create_inner_instruction),
+                instruction_parser: Some(Self::parse_initialize_instruction),
             },
             GenericEventParseConfig {
                 program_id: BONK_PROGRAM_ID,
@@ -84,8 +84,8 @@ impl BonkEventParser {
                 inner_instruction_discriminator: "",
                 instruction_discriminator: discriminators::MIGRATE_TO_AMM,
                 event_type: EventType::BonkMigrateToAmm,
-                inner_instruction_parser: Self::parse_migrate_to_amm_inner_instruction,
-                instruction_parser: Self::parse_migrate_to_amm_instruction,
+                inner_instruction_parser: None,
+                instruction_parser: Some(Self::parse_migrate_to_amm_instruction),
             },
             GenericEventParseConfig {
                 program_id: BONK_PROGRAM_ID,
@@ -93,8 +93,8 @@ impl BonkEventParser {
                 inner_instruction_discriminator: "",
                 instruction_discriminator: discriminators::MIGRATE_TO_CP_SWAP,
                 event_type: EventType::BonkMigrateToCpswap,
-                inner_instruction_parser: Self::parse_migrate_to_cpswap_inner_instruction,
-                instruction_parser: Self::parse_migrate_to_cpswap_instruction,
+                inner_instruction_parser: None,
+                instruction_parser: Some(Self::parse_migrate_to_cpswap_instruction),
             },
         ];
 
@@ -117,22 +117,6 @@ impl BonkEventParser {
         }
     }
 
-    /// Parse migrate to AMM event
-    fn parse_migrate_to_amm_inner_instruction(
-        _data: &[u8],
-        _metadata: EventMetadata,
-    ) -> Option<Box<dyn UnifiedEvent>> {
-        None
-    }
-
-    /// Parse migrate to CP Swap event
-    fn parse_migrate_to_cpswap_inner_instruction(
-        _data: &[u8],
-        _metadata: EventMetadata,
-    ) -> Option<Box<dyn UnifiedEvent>> {
-        None
-    }
-
     /// Parse trade event
     fn parse_trade_inner_instruction(
         data: &[u8],

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

@@ -1,5 +1,15 @@
 use borsh::BorshDeserialize;
 use serde::{Deserialize, Serialize};
+use solana_sdk::pubkey::Pubkey;
+
+use crate::streaming::{
+    event_parser::{
+        common::EventMetadata,
+        protocols::bonk::{BonkGlobalConfigAccountEvent, BonkPlatformConfigAccountEvent, BonkPoolStateAccountEvent},
+        UnifiedEvent,
+    },
+    grpc::AccountPretty,
+};
 
 #[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)]
 pub enum TradeDirection {
@@ -62,8 +72,165 @@ pub enum CurveParams {
 
 impl Default for CurveParams {
     fn default() -> Self {
-        Self::Constant {
-            data: ConstantCurve::default(),
-        }
+        Self::Constant { data: ConstantCurve::default() }
+    }
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)]
+pub struct VestingSchedule {
+    pub total_locked_amount: u64,
+    pub cliff_period: u64,
+    pub unlock_period: u64,
+    pub start_time: u64,
+    pub allocated_share_amount: u64,
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)]
+pub struct PoolState {
+    pub epoch: u64,
+    pub auth_bump: u8,
+    pub status: u8,
+    pub base_decimals: u8,
+    pub quote_decimals: u8,
+    pub migrate_type: u8,
+    pub supply: u64,
+    pub total_base_sell: u64,
+    pub virtual_base: u64,
+    pub virtual_quote: u64,
+    pub real_base: u64,
+    pub real_quote: u64,
+    pub total_quote_fund_raising: u64,
+    pub quote_protocol_fee: u64,
+    pub platform_fee: u64,
+    pub migrate_fee: u64,
+    pub vesting_schedule: VestingSchedule,
+    pub global_config: Pubkey,
+    pub platform_config: Pubkey,
+    pub base_mint: Pubkey,
+    pub quote_mint: Pubkey,
+    pub base_vault: Pubkey,
+    pub quote_vault: Pubkey,
+    pub creator: Pubkey,
+    pub padding: [u64; 8],
+}
+
+pub const POOL_STATE_SIZE: usize = 8 + 1 * 5 + 8 * 10 + 32 * 7 + 8 * 8 + 8 * 5;
+
+pub fn pool_state_decode(data: &[u8]) -> Option<PoolState> {
+    if data.len() < POOL_STATE_SIZE {
+        return None;
+    }
+    borsh::from_slice::<PoolState>(&data).ok()
+}
+
+pub fn pool_state_parser(
+    account: &AccountPretty,
+    metadata: EventMetadata,
+) -> Option<Box<dyn UnifiedEvent>> {
+    if let Some(pool_state) = pool_state_decode(&account.data[8..POOL_STATE_SIZE + 8]) {
+        Some(Box::new(BonkPoolStateAccountEvent {
+            metadata,
+            pubkey: account.pubkey.to_string(),
+            executable: account.executable,
+            lamports: account.lamports,
+            owner: account.owner.to_string(),
+            rent_epoch: account.rent_epoch,
+            pool_state,
+        }))
+    } else {
+        None
+    }
+}
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)]
+pub struct GlobalConfig {
+    pub epoch: u64,
+    pub curve_type: u8,
+    pub index: u16,
+    pub migrate_fee: u64,
+    pub trade_fee_rate: u64,
+    pub max_share_fee_rate: u64,
+    pub min_base_supply: u64,
+    pub max_lock_rate: u64,
+    pub min_base_sell_rate: u64,
+    pub min_base_migrate_rate: u64,
+    pub min_quote_fund_raising: u64,
+    pub quote_mint: Pubkey,
+    pub protocol_fee_owner: Pubkey,
+    pub migrate_fee_owner: Pubkey,
+    pub migrate_to_amm_wallet: Pubkey,
+    pub migrate_to_cpswap_wallet: Pubkey,
+    pub padding: [u64; 16],
+}
+
+pub const GLOBAL_CONFIG_SIZE: usize = 8 + 1 + 2 + 8 * 8 + 32 * 5 + 8 * 16;
+
+pub fn global_config_decode(data: &[u8]) -> Option<GlobalConfig> {
+    if data.len() < GLOBAL_CONFIG_SIZE {
+        return None;
+    }
+    borsh::from_slice::<GlobalConfig>(&data).ok()
+}
+
+pub fn global_config_parser(
+    account: &AccountPretty,
+    metadata: EventMetadata,
+) -> Option<Box<dyn UnifiedEvent>> {
+    if let Some(global_config) = global_config_decode(&account.data[8..GLOBAL_CONFIG_SIZE + 8]) {
+        Some(Box::new(BonkGlobalConfigAccountEvent {
+            metadata,
+            pubkey: account.pubkey.to_string(),
+            executable: account.executable,
+            lamports: account.lamports,
+            owner: account.owner.to_string(),
+            rent_epoch: account.rent_epoch,
+            global_config,
+        }))
+    } else {
+        None
+    }
+}
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)]
+pub struct PlatformConfig {
+    pub epoch: u64,
+    pub platform_fee_wallet: Pubkey,
+    pub platform_nft_wallet: Pubkey,
+    pub platform_scale: u64,
+    pub creator_scale: u64,
+    pub burn_scale: u64,
+    pub fee_rate: u64,
+    pub name: Vec<u8>,
+    pub web: Vec<u8>,
+    pub img: Vec<u8>,
+    pub padding: Vec<u8>,
+}
+
+pub const PLATFORM_CONFIG_SIZE: usize = 8 + 32 * 2 + 8 * 4 + 8 * 64 + 8 * 256 + 8 * 256 + 8 * 256;
+
+pub fn platform_config_decode(data: &[u8]) -> Option<PlatformConfig> {
+    if data.len() < PLATFORM_CONFIG_SIZE {
+        return None;
+    }
+    borsh::from_slice::<PlatformConfig>(&data).ok()
+}
+
+pub fn platform_config_parser(
+    account: &AccountPretty,
+    metadata: EventMetadata,
+) -> Option<Box<dyn UnifiedEvent>> {
+    if let Some(platform_config) =
+        platform_config_decode(&account.data[8..PLATFORM_CONFIG_SIZE + 8])
+    {
+        Some(Box::new(BonkPlatformConfigAccountEvent {
+            metadata,
+            pubkey: account.pubkey.to_string(),
+            executable: account.executable,
+            lamports: account.lamports,
+            owner: account.owner.to_string(),
+            rent_epoch: account.rent_epoch,
+            platform_config,
+        }))
+    } else {
+        None
     }
 }