feat: refactor subscription API with multi-filter support

- Support multiple transaction/account filters as vectors
- Add Token2022 extended state parsing
- Add pumpswap pool monitoring example
- Enhance AccountFilter with memcmp filters

BREAKING CHANGE: API signature changes for subscription methods

src/streaming/event_parser/core/account_event_parser.rs

@@ -1,12 +1,3 @@
-use std::collections::HashMap;
-use std::sync::OnceLock;
-
-use serde::{Deserialize, Serialize};
-use solana_account_decoder::parse_nonce::parse_nonce;
-use solana_sdk::program_pack::Pack;
-use solana_sdk::pubkey::Pubkey;
-use spl_token::state::Account;
-
 use crate::impl_unified_event;
 use crate::streaming::common::SimdUtils;
 use crate::streaming::event_parser::common::filter::EventTypeFilter;
@@ -20,8 +11,17 @@ use crate::streaming::event_parser::protocols::raydium_clmm::parser::RAYDIUM_CLM
 use crate::streaming::event_parser::protocols::raydium_cpmm::parser::RAYDIUM_CPMM_PROGRAM_ID;
 use crate::streaming::event_parser::Protocol;
 use crate::streaming::grpc::AccountPretty;
-
-use spl_token::state::Mint;
+use serde::{Deserialize, Serialize};
+use solana_account_decoder::parse_nonce::parse_nonce;
+use solana_sdk::program_pack::Pack;
+use solana_sdk::pubkey::Pubkey;
+use spl_token::state::{Account, Mint};
+use spl_token_2022::{
+    extension::StateWithExtensions,
+    state::{Account as Account2022, Mint as Mint2022},
+};
+use std::collections::HashMap;
+use std::sync::OnceLock;
 
 /// 通用事件解析器配置
 #[derive(Debug, Clone)]
@@ -295,6 +295,7 @@ impl AccountEventParser {
         let lamports = account.lamports;
         let owner = account.owner;
         let rent_epoch = account.rent_epoch;
+        // Spl Token Mint
         if account.data.len() >= Mint::LEN {
             if let Ok(mint) = Mint::unpack_from_slice(&account.data) {
                 let mut event = TokenInfoEvent {
@@ -312,7 +313,32 @@ impl AccountEventParser {
                 return Some(Box::new(event));
             }
         }
-        let amount = Account::unpack(&account.data).ok().map(|info| info.amount);
+        // Spl Token2022 Mint
+        if account.data.len() >= Account2022::LEN {
+            if let Ok(mint) = StateWithExtensions::<Mint2022>::unpack(&account.data) {
+                let mut event = TokenInfoEvent {
+                    metadata,
+                    pubkey,
+                    executable,
+                    lamports,
+                    owner,
+                    rent_epoch,
+                    supply: mint.base.supply,
+                    decimals: mint.base.decimals,
+                };
+                let recv_delta = elapsed_micros_since(account.recv_us);
+                event.set_handle_us(recv_delta);
+                return Some(Box::new(event));
+            }
+        }
+        let amount = if account.owner == spl_token_2022::ID {
+            StateWithExtensions::<Account2022>::unpack(&account.data)
+                .ok()
+                .map(|info| info.base.amount)
+        } else {
+            Account::unpack(&account.data).ok().map(|info| info.amount)
+        };
+
         let mut event = TokenAccountEvent {
             metadata,
             pubkey,

src/streaming/grpc/subscription.rs

@@ -13,6 +13,8 @@ use super::types::TransactionsFilterMap;
 use crate::common::AnyResult;
 use crate::streaming::common::StreamClientConfig as ClientConfig;
 use crate::streaming::event_parser::common::filter::EventTypeFilter;
+use crate::streaming::yellowstone_grpc::AccountFilter;
+use crate::streaming::yellowstone_grpc::TransactionFilter;
 
 /// Subscription manager
 #[derive(Clone)]
@@ -51,15 +53,14 @@ impl SubscriptionManager {
         impl Stream<Item = Result<SubscribeUpdate, Status>>,
         SubscribeRequest,
     )> {
-        let blocks_meta = if event_type_filter.is_some()
-            && event_type_filter.unwrap().include_block_event()
-        {
-            hashmap! { "".to_owned() => SubscribeRequestFilterBlocksMeta {} }
-        } else if event_type_filter.is_none() {
-            hashmap! { "".to_owned() => SubscribeRequestFilterBlocksMeta {} }
-        } else {
-            hashmap! {}
-        };
+        let blocks_meta =
+            if event_type_filter.is_some() && event_type_filter.unwrap().include_block_event() {
+                hashmap! { "".to_owned() => SubscribeRequestFilterBlocksMeta {} }
+            } else if event_type_filter.is_none() {
+                hashmap! { "".to_owned() => SubscribeRequestFilterBlocksMeta {} }
+            } else {
+                hashmap! {}
+            };
         let subscribe_request = SubscribeRequest {
             accounts: accounts.unwrap_or_default(),
             transactions: transactions.unwrap_or_default(),
@@ -79,56 +80,53 @@ impl SubscriptionManager {
     /// Create account subscription request and return stream
     pub fn subscribe_with_account_request(
         &self,
-        account: Vec<String>,
-        owner: Vec<String>,
+        account_filter: Vec<AccountFilter>,
         event_type_filter: Option<&EventTypeFilter>,
     ) -> Option<AccountsFilterMap> {
-        if account.len() == 0 && owner.len() == 0 {
+        if event_type_filter.is_some() && !event_type_filter.unwrap().include_account_event() {
             return None;
         }
-        if event_type_filter.is_some()
-            && !event_type_filter.unwrap().include_account_event()
-        {
+        if account_filter.len() == 0 {
             return None;
         }
         let mut accounts = HashMap::new();
-        accounts.insert(
-            "".to_owned(),
-            SubscribeRequestFilterAccounts {
-                account: account,
-                owner: owner,
-                filters: vec![],
-                nonempty_txn_signature: None,
-            },
-        );
+        for af in account_filter {
+            accounts.insert(
+                "".to_owned(),
+                SubscribeRequestFilterAccounts {
+                    account: af.account,
+                    owner: af.owner,
+                    filters: af.filters,
+                    nonempty_txn_signature: None,
+                },
+            );
+        }
         Some(accounts)
     }
 
     /// Generate subscription request filter
     pub fn get_subscribe_request_filter(
         &self,
-        account_include: Vec<String>,
-        account_exclude: Vec<String>,
-        account_required: Vec<String>,
+        transaction_filter: Vec<TransactionFilter>,
         event_type_filter: Option<&EventTypeFilter>,
     ) -> Option<TransactionsFilterMap> {
-        if event_type_filter.is_some()
-            && !event_type_filter.unwrap().include_transaction_event()
-        {
+        if event_type_filter.is_some() && !event_type_filter.unwrap().include_transaction_event() {
             return None;
         }
         let mut transactions = HashMap::new();
-        transactions.insert(
-            "client".to_string(),
-            SubscribeRequestFilterTransactions {
-                vote: Some(false),
-                failed: Some(false),
-                signature: None,
-                account_include,
-                account_exclude,
-                account_required,
-            },
-        );
+        for tf in transaction_filter {
+            transactions.insert(
+                "client".to_string(),
+                SubscribeRequestFilterTransactions {
+                    vote: Some(false),
+                    failed: Some(false),
+                    signature: None,
+                    account_include: tf.account_include,
+                    account_exclude: tf.account_exclude,
+                    account_required: tf.account_required,
+                },
+            );
+        }
         Some(transactions)
     }
 

src/streaming/yellowstone_grpc.rs

@@ -4,10 +4,8 @@ use crate::streaming::common::{
 };
 use crate::streaming::event_parser::common::filter::EventTypeFilter;
 use crate::streaming::event_parser::{Protocol, UnifiedEvent};
-use crate::streaming::grpc::{
-    EventPretty, SubscriptionManager,
-};
 use crate::streaming::grpc::pool::factory;
+use crate::streaming::grpc::{EventPretty, SubscriptionManager};
 use anyhow::anyhow;
 use chrono::Local;
 use futures::channel::mpsc;
@@ -18,7 +16,9 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::{Arc, RwLock};
 use tokio::sync::Mutex;
 use yellowstone_grpc_proto::geyser::subscribe_update::UpdateOneof;
-use yellowstone_grpc_proto::geyser::{CommitmentLevel, SubscribeRequest, SubscribeRequestPing};
+use yellowstone_grpc_proto::geyser::{
+    CommitmentLevel, SubscribeRequest, SubscribeRequestFilterAccountsFilter, SubscribeRequestPing,
+};
 
 /// 交易过滤器
 #[derive(Debug, Clone)]
@@ -33,6 +33,7 @@ pub struct TransactionFilter {
 pub struct AccountFilter {
     pub account: Vec<String>,
     pub owner: Vec<String>,
+    pub filters: Vec<SubscribeRequestFilterAccountsFilter>,
 }
 
 pub struct YellowstoneGrpc {
@@ -48,6 +49,8 @@ pub struct YellowstoneGrpc {
     pub active_subscription: Arc<AtomicBool>,
     pub control_tx: Arc<tokio::sync::Mutex<Option<mpsc::Sender<SubscribeRequest>>>>,
     pub current_request: Arc<tokio::sync::RwLock<Option<SubscribeRequest>>>,
+
+    pub event_type_filter: Arc<tokio::sync::RwLock<Option<EventTypeFilter>>>,
 }
 
 impl YellowstoneGrpc {
@@ -86,6 +89,7 @@ impl YellowstoneGrpc {
             active_subscription: Arc::new(AtomicBool::new(false)),
             control_tx: Arc::new(tokio::sync::Mutex::new(None)),
             current_request: Arc::new(tokio::sync::RwLock::new(None)),
+            event_type_filter: Arc::new(tokio::sync::RwLock::new(None)),
         })
     }
 
@@ -107,7 +111,6 @@ impl YellowstoneGrpc {
         Self::new_with_config(endpoint, x_token, StreamClientConfig::low_latency())
     }
 
-
     /// 获取配置
     pub fn get_config(&self) -> &StreamClientConfig {
         &self.config
@@ -161,8 +164,8 @@ impl YellowstoneGrpc {
         &self,
         protocols: Vec<Protocol>,
         bot_wallet: Option<Pubkey>,
-        transaction_filter: TransactionFilter,
-        account_filter: AccountFilter,
+        transaction_filter: Vec<TransactionFilter>,
+        account_filter: Vec<AccountFilter>,
         event_type_filter: Option<EventTypeFilter>,
         commitment: Option<CommitmentLevel>,
         callback: F,
@@ -170,6 +173,7 @@ impl YellowstoneGrpc {
     where
         F: Fn(Box<dyn UnifiedEvent>) + Send + Sync + 'static,
     {
+        *self.event_type_filter.write().await = event_type_filter.clone();
         if self
             .active_subscription
             .compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed)
@@ -184,17 +188,12 @@ impl YellowstoneGrpc {
             metrics_handle = self.metrics_manager.start_auto_monitoring().await;
         }
 
-        let transactions = self.subscription_manager.get_subscribe_request_filter(
-            transaction_filter.account_include,
-            transaction_filter.account_exclude,
-            transaction_filter.account_required,
-            event_type_filter.as_ref(),
-        );
-        let accounts = self.subscription_manager.subscribe_with_account_request(
-            account_filter.account,
-            account_filter.owner,
-            event_type_filter.as_ref(),
-        );
+        let transactions = self
+            .subscription_manager
+            .get_subscribe_request_filter(transaction_filter, event_type_filter.as_ref());
+        let accounts = self
+            .subscription_manager
+            .subscribe_with_account_request(account_filter, event_type_filter.as_ref());
 
         // 订阅事件
         let (mut subscribe_tx, mut stream, subscribe_request) = self
@@ -322,8 +321,8 @@ impl YellowstoneGrpc {
     /// Returns `AnyResult<()>` on success, error on failure
     pub async fn update_subscription(
         &self,
-        transaction_filter: TransactionFilter,
-        account_filter: AccountFilter,
+        transaction_filter: Vec<TransactionFilter>,
+        account_filter: Vec<AccountFilter>,
     ) -> AnyResult<()> {
         let mut control_sender = {
             let control_guard = self.control_tx.lock().await;
@@ -349,16 +348,17 @@ impl YellowstoneGrpc {
         request.transactions = self
             .subscription_manager
             .get_subscribe_request_filter(
-                transaction_filter.account_include,
-                transaction_filter.account_exclude,
-                transaction_filter.account_required,
-                None,
+                transaction_filter,
+                self.event_type_filter.read().await.as_ref(),
             )
             .unwrap_or_default();
 
         request.accounts = self
             .subscription_manager
-            .subscribe_with_account_request(account_filter.account, account_filter.owner, None)
+            .subscribe_with_account_request(
+                account_filter,
+                self.event_type_filter.read().await.as_ref(),
+            )
             .unwrap_or_default();
 
         control_sender
@@ -386,6 +386,7 @@ impl Clone for YellowstoneGrpc {
             subscription_handle: self.subscription_handle.clone(), // 共享同一个 Arc<Mutex<>>
             active_subscription: self.active_subscription.clone(),
             control_tx: self.control_tx.clone(),
+            event_type_filter: self.event_type_filter.clone(),
             current_request: self.current_request.clone(),
         }
     }

src/streaming/yellowstone_sub_system.rs

@@ -1,6 +1,9 @@
 use crate::{
     common::AnyResult,
-    streaming::{grpc::pool::factory, grpc::EventPretty, yellowstone_grpc::YellowstoneGrpc},
+    streaming::{
+        grpc::{pool::factory, EventPretty},
+        yellowstone_grpc::{TransactionFilter, YellowstoneGrpc},
+    },
 };
 use futures::{SinkExt, StreamExt};
 use log::error;
@@ -39,12 +42,9 @@ impl YellowstoneGrpc {
         let addrs = vec![SYSTEM_PROGRAM_ID.to_string()];
         let account_include = account_include.unwrap_or_default();
         let account_exclude = account_exclude.unwrap_or_default();
-        let transactions = self.subscription_manager.get_subscribe_request_filter(
-            account_include,
-            account_exclude,
-            addrs,
-            None,
-        );
+        let tx_filter =
+            vec![TransactionFilter { account_include, account_exclude, account_required: addrs }];
+        let transactions = self.subscription_manager.get_subscribe_request_filter(tx_filter, None);
         let (mut subscribe_tx, mut stream, _) = self
             .subscription_manager
             .subscribe_with_request(transactions, None, None, None)