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
2026-08-13 00:48:05 +00:00 · 2025-07-19 23:46:42 +08:00
parent a7c9721877
commit 9e34a01874
46 changed files with 4511 additions and 1381 deletions
@@ -0,0 +1,113 @@
+use borsh::BorshDeserialize;
+use serde::{Deserialize, Serialize};
+use solana_sdk::pubkey::Pubkey;
+
+use crate::streaming::event_parser::common::EventMetadata;
+use crate::impl_unified_event;
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)]
+pub struct PumpFunCreateTokenEvent {
+    #[borsh(skip)]
+    pub metadata: EventMetadata,
+    pub name: String,
+    pub symbol: String,
+    pub uri: String,
+    pub mint: Pubkey,
+    pub bonding_curve: Pubkey,
+    pub user: Pubkey,
+    pub creator: Pubkey,
+    pub timestamp: i64,
+    pub virtual_token_reserves: u64,
+    pub virtual_sol_reserves: u64,
+    pub real_token_reserves: u64,
+    pub token_total_supply: u64,
+    #[borsh(skip)]
+    pub mint_authority: Pubkey,
+    #[borsh(skip)]
+    pub associated_bonding_curve: Pubkey,
+}
+
+impl_unified_event!(
+    PumpFunCreateTokenEvent,
+    mint,
+    bonding_curve,
+    user,
+    creator,
+    timestamp,
+    virtual_token_reserves,
+    virtual_sol_reserves,
+    real_token_reserves,
+    token_total_supply
+);
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, BorshDeserialize)]
+pub struct PumpFunTradeEvent {
+    #[borsh(skip)]
+    pub metadata: EventMetadata,
+    pub mint: Pubkey,
+    pub sol_amount: u64,
+    pub token_amount: u64,
+    pub is_buy: bool,
+    pub user: Pubkey,
+    pub timestamp: i64,
+    pub virtual_sol_reserves: u64,
+    pub virtual_token_reserves: u64,
+    pub real_sol_reserves: u64,
+    pub real_token_reserves: u64,
+    pub fee_recipient: Pubkey,
+    pub fee_basis_points: u64, 
+    pub fee: u64,
+    pub creator: Pubkey,
+    pub creator_fee_basis_points: u64,
+    pub creator_fee: u64,
+    #[borsh(skip)]
+    pub bonding_curve: Pubkey,
+    #[borsh(skip)]
+    pub associated_bonding_curve: Pubkey,
+    #[borsh(skip)]
+    pub associated_user: Pubkey,
+    #[borsh(skip)]
+    pub creator_vault: Pubkey,
+    #[borsh(skip)]
+    pub max_sol_cost: u64,
+    #[borsh(skip)]
+    pub min_sol_output: u64,
+    #[borsh(skip)]
+    pub amount: u64,
+    #[borsh(skip)]
+    pub is_bot: bool,
+    #[borsh(skip)]
+    pub is_dev_create_token_trade: bool, // 是否是dev创建token的交易
+}
+
+impl_unified_event!(
+    PumpFunTradeEvent,
+    mint,
+    sol_amount,
+    token_amount,
+    is_buy,
+    user,
+    timestamp,
+    virtual_sol_reserves,
+    virtual_token_reserves,
+    real_sol_reserves,
+    real_token_reserves,
+    fee_recipient,
+    fee_basis_points,
+    fee,
+    creator,
+    creator_fee_basis_points,
+    creator_fee
+);
+
+/// 事件鉴别器常量
+pub mod discriminators {
+    // 事件鉴别器
+    pub const CREATE_TOKEN_EVENT: &str = "0xe445a52e51cb9a1d1b72a94ddeeb6376";
+    pub const TRADE_EVENT: &str = "0xe445a52e51cb9a1dbddb7fd34ee661ee";
+
+    // 指令鉴别器
+    pub const CREATE_TOKEN_IX: &[u8] = &[24, 30, 200, 40, 5, 28, 7, 119];
+    pub const BUY_IX: &[u8] = &[102, 6, 61, 18, 1, 218, 235, 234];
+    pub const SELL_IX: &[u8] = &[51, 230, 133, 164, 1, 127, 131, 173];
+}
@@ -0,0 +1,5 @@
+pub mod events;
+pub mod parser;
+
+pub use events::*;
+pub use parser::PumpFunEventParser; 
@@ -0,0 +1,250 @@
+use solana_sdk::{instruction::CompiledInstruction, pubkey::Pubkey};
+use solana_transaction_status::UiCompiledInstruction;
+
+use crate::streaming::event_parser::{
+    common::{EventMetadata, EventType, ProtocolType},
+    core::traits::{EventParser, GenericEventParseConfig, GenericEventParser, UnifiedEvent},
+    protocols::pumpfun::{discriminators, PumpFunCreateTokenEvent, PumpFunTradeEvent},
+};
+
+/// PumpFun程序ID
+pub const PUMPFUN_PROGRAM_ID: Pubkey =
+    solana_sdk::pubkey!("6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P");
+
+/// PumpFun事件解析器
+pub struct PumpFunEventParser {
+    inner: GenericEventParser,
+}
+
+impl PumpFunEventParser {
+    pub fn new() -> Self {
+        // 配置所有事件类型
+        let configs = vec![
+            GenericEventParseConfig {
+                inner_instruction_discriminator: discriminators::CREATE_TOKEN_EVENT,
+                instruction_discriminator: discriminators::CREATE_TOKEN_IX,
+                event_type: EventType::PumpFunCreateToken,
+                inner_instruction_parser: Self::parse_create_token_inner_instruction,
+                instruction_parser: Self::parse_create_token_instruction,
+            },
+            GenericEventParseConfig {
+                inner_instruction_discriminator: discriminators::TRADE_EVENT,
+                instruction_discriminator: discriminators::BUY_IX,
+                event_type: EventType::PumpFunBuy,
+                inner_instruction_parser: Self::parse_trade_inner_instruction,
+                instruction_parser: Self::parse_buy_instruction,
+            },
+            GenericEventParseConfig {
+                inner_instruction_discriminator: discriminators::TRADE_EVENT,
+                instruction_discriminator: discriminators::SELL_IX,
+                event_type: EventType::PumpFunSell,
+                inner_instruction_parser: Self::parse_trade_inner_instruction,
+                instruction_parser: Self::parse_sell_instruction,
+            },
+        ];
+
+        let inner = GenericEventParser::new(PUMPFUN_PROGRAM_ID, ProtocolType::PumpFun, configs);
+
+        Self { inner }
+    }
+
+    /// 解析创建代币日志事件
+    fn parse_create_token_inner_instruction(
+        data: &[u8],
+        metadata: EventMetadata,
+    ) -> Option<Box<dyn UnifiedEvent>> {
+        if let Ok(event) = borsh::from_slice::<PumpFunCreateTokenEvent>(data) {
+            let mut metadata = metadata;
+            metadata.set_id(format!(
+                "{}-{}-{}-{}",
+                metadata.signature,
+                event.name,
+                event.symbol,
+                event.mint.to_string()
+            ));
+            Some(Box::new(PumpFunCreateTokenEvent {
+                metadata: metadata,
+                ..event
+            }))
+        } else {
+            None
+        }
+    }
+
+    /// 解析交易事件
+    fn parse_trade_inner_instruction(
+        data: &[u8],
+        metadata: EventMetadata,
+    ) -> Option<Box<dyn UnifiedEvent>> {
+        if let Ok(event) = borsh::from_slice::<PumpFunTradeEvent>(data) {
+            let mut metadata = metadata;
+            metadata.set_id(format!(
+                "{}-{}-{}-{}",
+                metadata.signature,
+                event.mint.to_string(),
+                event.user.to_string(),
+                event.is_buy.to_string()
+            ));
+            Some(Box::new(PumpFunTradeEvent {
+                metadata: metadata,
+                ..event
+            }))
+        } else {
+            None
+        }
+    }
+
+    /// 解析创建代币指令事件
+    fn parse_create_token_instruction(
+        data: &[u8],
+        accounts: &[Pubkey],
+        metadata: EventMetadata,
+    ) -> Option<Box<dyn UnifiedEvent>> {
+        if data.len() < 16 || accounts.len() < 11 {
+            return None;
+        }
+        let mut offset = 0;
+        let name_len = u32::from_le_bytes(data[offset..offset + 4].try_into().unwrap()) as usize;
+        offset += 4;
+        let name = String::from_utf8_lossy(&data[offset..offset + name_len]);
+        offset += name_len;
+        let symbol_len = u32::from_le_bytes(data[offset..offset + 4].try_into().unwrap()) as usize;
+        offset += 4;
+        let symbol = String::from_utf8_lossy(&data[offset..offset + symbol_len]);
+        offset += symbol_len;
+        let uri_len = u32::from_le_bytes(data[offset..offset + 4].try_into().unwrap()) as usize;
+        offset += 4;
+        let uri = String::from_utf8_lossy(&data[offset..offset + uri_len]);
+        offset += uri_len;
+        let creator = if offset + 32 <= data.len() {
+            Pubkey::new_from_array(data[offset..offset + 32].try_into().ok()?)
+        } else {
+            Pubkey::default()
+        };
+
+        let mut metadata = metadata;
+        metadata.set_id(format!(
+            "{}-{}-{}-{}",
+            metadata.signature,
+            name,
+            symbol,
+            accounts[0].to_string()
+        ));
+
+        Some(Box::new(PumpFunCreateTokenEvent {
+            metadata,
+            name: name.to_string(),
+            symbol: symbol.to_string(),
+            uri: uri.to_string(),
+            creator,
+            mint: accounts[0],
+            mint_authority: accounts[1],
+            bonding_curve: accounts[2],
+            associated_bonding_curve: accounts[3],
+            user: accounts[7],
+            ..Default::default()
+        }))
+    }
+
+    // 解析买入指令事件
+    fn parse_buy_instruction(
+        data: &[u8],
+        accounts: &[Pubkey],
+        metadata: EventMetadata,
+    ) -> Option<Box<dyn UnifiedEvent>> {
+        if data.len() < 16 || accounts.len() < 11 {
+            return None;
+        }
+        let amount = u64::from_le_bytes(data[0..8].try_into().unwrap());
+        let max_sol_cost = u64::from_le_bytes(data[8..16].try_into().unwrap());
+        let mut metadata = metadata;
+        metadata.set_id(format!(
+            "{}-{}-{}-{}",
+            metadata.signature,
+            accounts[2].to_string(),
+            accounts[6].to_string(),
+            true.to_string()
+        ));
+        Some(Box::new(PumpFunTradeEvent {
+            metadata,
+            fee_recipient: accounts[1],
+            mint: accounts[2],
+            bonding_curve: accounts[3],
+            associated_bonding_curve: accounts[4],
+            associated_user: accounts[5],
+            user: accounts[6],
+            creator_vault: accounts[8],
+            max_sol_cost,
+            amount,
+            is_buy: true,
+            ..Default::default()
+        }))
+    }
+
+    // 解析卖出指令事件
+    fn parse_sell_instruction(
+        data: &[u8],
+        accounts: &[Pubkey],
+        metadata: EventMetadata,
+    ) -> Option<Box<dyn UnifiedEvent>> {
+        if data.len() < 16 || accounts.len() < 11 {
+            return None;
+        }
+        let amount = u64::from_le_bytes(data[0..8].try_into().unwrap());
+        let min_sol_output = u64::from_le_bytes(data[8..16].try_into().unwrap());
+        let mut metadata = metadata;
+        metadata.set_id(format!(
+            "{}-{}-{}-{}",
+            metadata.signature,
+            accounts[2].to_string(),
+            accounts[6].to_string(),
+            false.to_string()
+        ));
+        Some(Box::new(PumpFunTradeEvent {
+            metadata,
+            fee_recipient: accounts[1],
+            mint: accounts[2],
+            bonding_curve: accounts[3],
+            associated_bonding_curve: accounts[4],
+            associated_user: accounts[5],
+            user: accounts[6],
+            creator_vault: accounts[8],
+            min_sol_output,
+            amount,
+            is_buy: false,
+            ..Default::default()
+        }))
+    }
+}
+
+#[async_trait::async_trait]
+impl EventParser for PumpFunEventParser {
+    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()
+    }
+}