feat: refactor to multi-protocol event streaming system

Major architectural refactor, upgrading from simple logging system to comprehensive multi-protocol Solana DEX event streaming system:

✨ New Features:
- Support for 5 DEX protocols: PumpFun, PumpSwap, Bonk, Raydium CPMM, Raydium CLMM
- Implement unified event interface (UnifiedEvent trait) and event factory pattern
- Add dual streaming support: Yellowstone gRPC and ShredStream
- Add Chinese documentation (README_CN.md)

🏗️ Architectural Improvements:
- Refactor event parsing system with modular design
- Implement protocol-specific parsers and event types
- Optimize dependency management, update Cargo.toml
- Remove legacy logging modules, clean up redundant code

📊 Statistics:
- Added 46 files, 4511 lines of code
- Removed 1381 lines of legacy code
- Net addition of 3130 lines of code

Tech Stack:
- Rust async/await for asynchronous processing
- Protocol Buffers support
- Multi-protocol event parsing
- High-performance event stream subscription

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

@@ -0,0 +1,35 @@
+use crate::impl_unified_event;
+use crate::streaming::event_parser::common::EventMetadata;
+use borsh::BorshDeserialize;
+use serde::{Deserialize, Serialize};
+use solana_sdk::pubkey::Pubkey;
+
+/// 交易
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)]
+pub struct RaydiumCpmmSwapEvent {
+    pub metadata: EventMetadata,
+    pub amount_in: u64,
+    pub minimum_amount_out: u64,
+    pub max_amount_in: u64,
+    pub amount_out: u64,
+    pub payer: Pubkey,
+    pub authority: Pubkey,
+    pub amm_config: Pubkey,
+    pub pool_state: Pubkey,
+    pub input_token_account: Pubkey,
+    pub output_token_account: Pubkey,
+    pub input_vault: Pubkey,
+    pub output_vault: Pubkey,
+    pub input_token_mint: Pubkey,
+    pub output_token_mint: Pubkey,
+    pub observation_state: Pubkey,
+}
+
+impl_unified_event!(RaydiumCpmmSwapEvent,);
+
+/// 事件鉴别器常量
+pub mod discriminators {
+    // 指令鉴别器
+    pub const SWAP_BASE_IN: &[u8] = &[143, 190, 90, 218, 196, 30, 51, 222];
+    pub const SWAP_BASE_OUT: &[u8] = &[55, 217, 98, 86, 163, 74, 180, 173];
+}

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

@@ -0,0 +1,5 @@
+pub mod events;
+pub mod parser;
+
+pub use events::*;
+pub use parser::RaydiumCpmmEventParser;

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

@@ -0,0 +1,159 @@
+use solana_sdk::{instruction::CompiledInstruction, pubkey::Pubkey};
+use solana_transaction_status::UiCompiledInstruction;
+
+use crate::streaming::event_parser::{
+    common::{read_u64_le, EventMetadata, EventType, ProtocolType},
+    core::traits::{EventParser, GenericEventParseConfig, GenericEventParser, UnifiedEvent},
+    protocols::raydium_cpmm::{discriminators, RaydiumCpmmSwapEvent},
+};
+
+/// Raydium CPMM程序ID
+pub const RAYDIUM_CPMM_PROGRAM_ID: Pubkey =
+    solana_sdk::pubkey!("CPMMoo8L3F4NbTegBCKVNunggL7H1ZpdTHKxQB5qKP1C");
+
+/// Raydium CPMM事件解析器
+pub struct RaydiumCpmmEventParser {
+    inner: GenericEventParser,
+}
+
+impl RaydiumCpmmEventParser {
+    pub fn new() -> Self {
+        // 配置所有事件类型
+        let configs = vec![
+            GenericEventParseConfig {
+                inner_instruction_discriminator: "",
+                instruction_discriminator: discriminators::SWAP_BASE_IN,
+                event_type: EventType::RaydiumCpmmSwapBaseInput,
+                inner_instruction_parser: Self::parse_trade_inner_instruction,
+                instruction_parser: Self::parse_swap_base_input_instruction,
+            },
+            GenericEventParseConfig {
+                inner_instruction_discriminator: "",
+                instruction_discriminator: discriminators::SWAP_BASE_OUT,
+                event_type: EventType::RaydiumCpmmSwapBaseOutput,
+                inner_instruction_parser: Self::parse_trade_inner_instruction,
+                instruction_parser: Self::parse_swap_base_output_instruction,
+            },
+        ];
+
+        let inner =
+            GenericEventParser::new(RAYDIUM_CPMM_PROGRAM_ID, ProtocolType::RaydiumCpmm, configs);
+
+        Self { inner }
+    }
+
+    /// 解析交易事件
+    fn parse_trade_inner_instruction(
+        _data: &[u8],
+        _metadata: EventMetadata,
+    ) -> Option<Box<dyn UnifiedEvent>> {
+        None
+    }
+
+    /// 解析买入指令事件
+    fn parse_swap_base_input_instruction(
+        data: &[u8],
+        accounts: &[Pubkey],
+        metadata: EventMetadata,
+    ) -> Option<Box<dyn UnifiedEvent>> {
+        if data.len() < 16 || accounts.len() < 13 {
+            return None;
+        }
+
+        let amount_in = read_u64_le(data, 0)?;
+        let minimum_amount_out = read_u64_le(data, 8)?;
+
+        let mut metadata = metadata;
+        metadata.set_id(format!(
+            "{}-{}-{}-{}",
+            metadata.signature, accounts[3], accounts[10], accounts[11]
+        ));
+
+        Some(Box::new(RaydiumCpmmSwapEvent {
+            metadata,
+            amount_in,
+            minimum_amount_out,
+            payer: accounts[0],
+            authority: accounts[1],
+            amm_config: accounts[2],
+            pool_state: accounts[3],
+            input_token_account: accounts[4],
+            output_token_account: accounts[5],
+            input_vault: accounts[6],
+            output_vault: accounts[7],
+            input_token_mint: accounts[10],
+            output_token_mint: accounts[11],
+            observation_state: accounts[12],
+            ..Default::default()
+        }))
+    }
+
+    fn parse_swap_base_output_instruction(
+        data: &[u8],
+        accounts: &[Pubkey],
+        metadata: EventMetadata,
+    ) -> Option<Box<dyn UnifiedEvent>> {
+        if data.len() < 16 || accounts.len() < 13 {
+            return None;
+        }
+
+        let max_amount_in = read_u64_le(data, 0)?;
+        let amount_out = read_u64_le(data, 8)?;
+
+        let mut metadata = metadata;
+        metadata.set_id(format!(
+            "{}-{}-{}-{}",
+            metadata.signature, accounts[3], accounts[10], accounts[11]
+        ));
+
+        Some(Box::new(RaydiumCpmmSwapEvent {
+            metadata,
+            max_amount_in,
+            amount_out,
+            payer: accounts[0],
+            authority: accounts[1],
+            amm_config: accounts[2],
+            pool_state: accounts[3],
+            input_token_account: accounts[4],
+            output_token_account: accounts[5],
+            input_vault: accounts[6],
+            output_vault: accounts[7],
+            input_token_mint: accounts[10],
+            output_token_mint: accounts[11],
+            observation_state: accounts[12],
+            ..Default::default()
+        }))
+    }
+}
+
+#[async_trait::async_trait]
+impl EventParser for RaydiumCpmmEventParser {
+    fn parse_events_from_inner_instruction(
+        &self,
+        inner_instruction: &UiCompiledInstruction,
+        signature: &str,
+        slot: u64,
+    ) -> Vec<Box<dyn UnifiedEvent>> {
+        self.inner
+            .parse_events_from_inner_instruction(inner_instruction, signature, slot)
+    }
+
+    fn parse_events_from_instruction(
+        &self,
+        instruction: &CompiledInstruction,
+        accounts: &[Pubkey],
+        signature: &str,
+        slot: u64,
+    ) -> Vec<Box<dyn UnifiedEvent>> {
+        self.inner
+            .parse_events_from_instruction(instruction, accounts, signature, slot)
+    }
+
+    fn should_handle(&self, program_id: &Pubkey) -> bool {
+        self.inner.should_handle(program_id)
+    }
+
+    fn supported_program_ids(&self) -> Vec<Pubkey> {
+        self.inner.supported_program_ids()
+    }
+}