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

examples/dynamic_subscription.rs

@@ -1,11 +1,13 @@
 use anyhow::Result;
-use solana_streamer_sdk::streaming::yellowstone_grpc::{AccountFilter, TransactionFilter, YellowstoneGrpc};
-use solana_streamer_sdk::streaming::event_parser::Protocol;
+use solana_sdk::signature::{Keypair, Signer};
 use solana_streamer_sdk::streaming::event_parser::common::filter::EventTypeFilter;
 use solana_streamer_sdk::streaming::event_parser::common::types::EventType;
-use solana_sdk::signature::{Keypair, Signer};
-use std::sync::{Arc, Mutex};
+use solana_streamer_sdk::streaming::event_parser::Protocol;
+use solana_streamer_sdk::streaming::yellowstone_grpc::{
+    AccountFilter, TransactionFilter, YellowstoneGrpc,
+};
 use std::sync::atomic::{AtomicU64, Ordering};
+use std::sync::{Arc, Mutex};
 use std::time::{Duration, Instant};
 use tokio::time::sleep;
 
@@ -20,27 +22,28 @@ const MONITORING_DURATION_SECS: u64 = 10;
 #[tokio::main]
 async fn main() -> Result<()> {
     env_logger::init();
-    
+
     println!("Connecting to Yellowstone gRPC at {}", GRPC_ENDPOINT);
-    let client = Arc::new(YellowstoneGrpc::new(
-        GRPC_ENDPOINT.to_string(),
-        API_KEY.map(|s| s.to_string())
-    )?);
+    let client =
+        Arc::new(YellowstoneGrpc::new(GRPC_ENDPOINT.to_string(), API_KEY.map(|s| s.to_string()))?);
 
     let event_counter = Arc::new(AtomicU64::new(0));
     let counter = event_counter.clone();
-    
-    let callback = move |event: Box<dyn solana_streamer_sdk::streaming::event_parser::UnifiedEvent>| {
-        let count = counter.fetch_add(1, Ordering::Relaxed);
-        
-        let protocol = match event.event_type() {
-            EventType::PumpFunBuy | EventType::PumpFunSell => "PumpFun",
-            EventType::RaydiumCpmmSwapBaseInput | EventType::RaydiumCpmmSwapBaseOutput => "RaydiumCpmm",
-            _ => "Unknown"
+
+    let callback =
+        move |event: Box<dyn solana_streamer_sdk::streaming::event_parser::UnifiedEvent>| {
+            let count = counter.fetch_add(1, Ordering::Relaxed);
+
+            let protocol = match event.event_type() {
+                EventType::PumpFunBuy | EventType::PumpFunSell => "PumpFun",
+                EventType::RaydiumCpmmSwapBaseInput | EventType::RaydiumCpmmSwapBaseOutput => {
+                    "RaydiumCpmm"
+                }
+                _ => "Unknown",
+            };
+
+            println!("Event #{}: {:11} - {:.8}...", count + 1, protocol, event.signature());
         };
-        
-        println!("Event #{}: {:11} - {:.8}...", count + 1, protocol, event.signature());
-    };
 
     println!("\n=== Phase 1: PumpFun only ===");
     let pumpfun_filter = TransactionFilter {
@@ -48,11 +51,8 @@ async fn main() -> Result<()> {
         account_exclude: vec![],
         account_required: vec![],
     };
-    
-    let account_filter = AccountFilter {
-        account: vec![],
-        owner: vec![],
-    };
+
+    let account_filter = AccountFilter { account: vec![], owner: vec![], filters: vec![] };
     let trade_event_filter = EventTypeFilter {
         include: vec![
             EventType::PumpFunBuy,
@@ -62,46 +62,52 @@ async fn main() -> Result<()> {
         ],
     };
 
-    if let Err(e) = client.subscribe_events_immediate(
-        vec![Protocol::PumpFun, Protocol::RaydiumCpmm],
-        None,
-        pumpfun_filter,
-        account_filter,
-        Some(trade_event_filter),
-        None,
-        callback,
-    ).await {
+    if let Err(e) = client
+        .subscribe_events_immediate(
+            vec![Protocol::PumpFun, Protocol::RaydiumCpmm],
+            None,
+            vec![pumpfun_filter],
+            vec![account_filter],
+            Some(trade_event_filter),
+            None,
+            callback,
+        )
+        .await
+    {
         println!("Failed to create subscription: {}", e);
         return Ok(());
     }
 
-    println!("Subscribed to PumpFun transactions with trade event filters, monitoring for {}s...", MONITORING_DURATION_SECS);
+    println!(
+        "Subscribed to PumpFun transactions with trade event filters, monitoring for {}s...",
+        MONITORING_DURATION_SECS
+    );
     sleep(Duration::from_secs(MONITORING_DURATION_SECS)).await;
     let phase1_count = event_counter.load(Ordering::Relaxed);
     println!("Phase 1: {} events", phase1_count);
 
     println!("\n=== Phase 2: PumpFun + RaydiumCpmm ===");
     let multi_protocol_filter = TransactionFilter {
-        account_include: vec![
-            PUMPFUN_PROGRAM_ID.to_string(),
-            RAYDIUM_CPMM_PROGRAM_ID.to_string(),
-        ],
+        account_include: vec![PUMPFUN_PROGRAM_ID.to_string(), RAYDIUM_CPMM_PROGRAM_ID.to_string()],
         account_exclude: vec![],
         account_required: vec![],
     };
 
-    if let Err(e) = client.update_subscription(
-        multi_protocol_filter,
-        AccountFilter {
-            account: vec![],
-            owner: vec![],
-        },
-    ).await {
+    if let Err(e) = client
+        .update_subscription(
+            vec![multi_protocol_filter],
+            vec![AccountFilter { account: vec![], owner: vec![], filters: vec![] }],
+        )
+        .await
+    {
         println!("Failed to update subscription: {}", e);
         return Ok(());
     }
 
-    println!("Updated to PumpFun + RaydiumCpmm transactions, monitoring for {}s...", MONITORING_DURATION_SECS);
+    println!(
+        "Updated to PumpFun + RaydiumCpmm transactions, monitoring for {}s...",
+        MONITORING_DURATION_SECS
+    );
     sleep(Duration::from_secs(MONITORING_DURATION_SECS)).await;
     let phase2_count = event_counter.load(Ordering::Relaxed);
     println!("Phase 2: {} events", phase2_count - phase1_count);
@@ -113,19 +119,22 @@ async fn main() -> Result<()> {
         account_required: vec![],
     };
 
-    if let Err(e) = client.update_subscription(
-        raydium_cpmm_filter,
-        AccountFilter {
-            account: vec![],
-            owner: vec![],
-        },
-    ).await {
+    if let Err(e) = client
+        .update_subscription(
+            vec![raydium_cpmm_filter],
+            vec![AccountFilter { account: vec![], owner: vec![], filters: vec![] }],
+        )
+        .await
+    {
         println!("Failed to update subscription: {}", e);
         return Ok(());
     }
 
     sleep(Duration::from_secs(MONITORING_DURATION_SECS)).await;
-    println!("Updated to RaydiumCpmm transactions only, monitoring for {}s...", MONITORING_DURATION_SECS);
+    println!(
+        "Updated to RaydiumCpmm transactions only, monitoring for {}s...",
+        MONITORING_DURATION_SECS
+    );
     let phase3_count = event_counter.load(Ordering::Relaxed);
     println!("Phase 3: {} events", phase3_count - phase2_count);
 
@@ -136,19 +145,22 @@ async fn main() -> Result<()> {
         account_required: vec![],
     };
 
-    if let Err(e) = client.update_subscription(
-        pumpfun_only_filter,
-        AccountFilter {
-            account: vec![],
-            owner: vec![],
-        },
-    ).await {
+    if let Err(e) = client
+        .update_subscription(
+            vec![pumpfun_only_filter],
+            vec![AccountFilter { account: vec![], owner: vec![], filters: vec![] }],
+        )
+        .await
+    {
         println!("Failed to update subscription: {}", e);
         return Ok(());
     }
 
     sleep(Duration::from_secs(MONITORING_DURATION_SECS)).await;
-    println!("Updated to PumpFun transactions only, monitoring for {}s...", MONITORING_DURATION_SECS);
+    println!(
+        "Updated to PumpFun transactions only, monitoring for {}s...",
+        MONITORING_DURATION_SECS
+    );
     let phase4_count = event_counter.load(Ordering::Relaxed);
     println!("Phase 4: {} events", phase4_count - phase3_count);
 
@@ -158,46 +170,46 @@ async fn main() -> Result<()> {
         account_exclude: vec![],
         account_required: vec![],
     };
-    
-    if let Err(e) = client.update_subscription(
-        empty_filter,
-        AccountFilter {
-            account: vec![],
-            owner: vec![],
-        },
-    ).await {
+
+    if let Err(e) = client
+        .update_subscription(
+            vec![empty_filter],
+            vec![AccountFilter { account: vec![], owner: vec![], filters: vec![] }],
+        )
+        .await
+    {
         println!("Failed to update subscription: {}", e);
         return Ok(());
     }
-    
+
     sleep(Duration::from_secs(MONITORING_DURATION_SECS)).await;
-    println!("Updated to all transactions (no filters), monitoring for {}s...", MONITORING_DURATION_SECS);
+    println!(
+        "Updated to all transactions (no filters), monitoring for {}s...",
+        MONITORING_DURATION_SECS
+    );
     let phase5_count = event_counter.load(Ordering::Relaxed);
     println!("Phase 5: {} events", phase5_count - phase4_count);
 
     println!("\n=== Phase 6: Silence ===");
-    
+
     let random_keypair_1 = Keypair::new();
     let random_keypair_2 = Keypair::new();
     let random_pubkey_1 = random_keypair_1.pubkey();
     let random_pubkey_2 = random_keypair_2.pubkey();
-    
+
     let silence_filter = TransactionFilter {
         account_include: vec![],
         account_exclude: vec![],
-        account_required: vec![
-            random_pubkey_1.to_string(),
-            random_pubkey_2.to_string(),
-        ],
+        account_required: vec![random_pubkey_1.to_string(), random_pubkey_2.to_string()],
     };
 
-    if let Err(e) = client.update_subscription(
-        silence_filter,
-        AccountFilter {
-            account: vec![],
-            owner: vec![],
-        },
-    ).await {
+    if let Err(e) = client
+        .update_subscription(
+            vec![silence_filter],
+            vec![AccountFilter { account: vec![], owner: vec![], filters: vec![] }],
+        )
+        .await
+    {
         println!("Failed to update subscription: {}", e);
         return Ok(());
     }
@@ -222,44 +234,46 @@ async fn main() -> Result<()> {
 
     let final_count = event_counter.load(Ordering::Relaxed);
     let events_during_silence = final_count - before_silence;
-    
+
     if events_during_silence == 0 {
         println!("Phase 6: 0 events (immediate filter application)");
     } else if let Ok(last_time) = last_event_time.lock() {
         let propagation_time = last_time.duration_since(start_time);
-        println!("Phase 6: {} events during propagation, filter took {}ms", 
-                 events_during_silence, propagation_time.as_millis());
+        println!(
+            "Phase 6: {} events during propagation, filter took {}ms",
+            events_during_silence,
+            propagation_time.as_millis()
+        );
     }
 
     println!("\n=== Phase 7: Shutdown ===");
-    
-    let shutdown_client = Arc::new(YellowstoneGrpc::new(
-        GRPC_ENDPOINT.to_string(),
-        API_KEY.map(|s| s.to_string())
-    )?);
-    
+
+    let shutdown_client =
+        Arc::new(YellowstoneGrpc::new(GRPC_ENDPOINT.to_string(), API_KEY.map(|s| s.to_string()))?);
+
     let shutdown_event_counter = Arc::new(AtomicU64::new(0));
     let shutdown_counter = shutdown_event_counter.clone();
-    let shutdown_callback = move |_event: Box<dyn solana_streamer_sdk::streaming::event_parser::UnifiedEvent>| {
-        shutdown_counter.fetch_add(1, Ordering::Relaxed);
-    };
+    let shutdown_callback =
+        move |_event: Box<dyn solana_streamer_sdk::streaming::event_parser::UnifiedEvent>| {
+            shutdown_counter.fetch_add(1, Ordering::Relaxed);
+        };
 
-    if let Err(e) = shutdown_client.subscribe_events_immediate(
-        vec![Protocol::PumpFun, Protocol::RaydiumCpmm],
-        None,
-        TransactionFilter {
-            account_include: vec![],
-            account_exclude: vec![],
-            account_required: vec![],
-        },
-        AccountFilter {
-            account: vec![],
-            owner: vec![],
-        },
-        None,
-        None,
-        shutdown_callback,
-    ).await {
+    if let Err(e) = shutdown_client
+        .subscribe_events_immediate(
+            vec![Protocol::PumpFun, Protocol::RaydiumCpmm],
+            None,
+            vec![TransactionFilter {
+                account_include: vec![],
+                account_exclude: vec![],
+                account_required: vec![],
+            }],
+            vec![AccountFilter { account: vec![], owner: vec![], filters: vec![] }],
+            None,
+            None,
+            shutdown_callback,
+        )
+        .await
+    {
         println!("Failed to subscribe shutdown client: {}", e);
         return Ok(());
     }
@@ -278,7 +292,7 @@ async fn main() -> Result<()> {
     if during_stop > 0 {
         println!("  {} events received during stop()", during_stop);
     }
-    
+
     let last_event_time = Arc::new(Mutex::new(stop_time));
     let last_event_time_clone = last_event_time.clone();
     let mut last_count = post_stop_count;
@@ -296,167 +310,169 @@ async fn main() -> Result<()> {
 
     let final_count = shutdown_event_counter.load(Ordering::Relaxed);
     let after_stop = final_count - post_stop_count;
-    
+
     if after_stop == 0 {
         println!("Phase 7: Clean shutdown - no events after stop()");
     } else if let Ok(last_time) = last_event_time.lock() {
         let post_stop_duration = last_time.duration_since(stop_time);
         let silence_duration = Instant::now().duration_since(*last_time);
-        println!("Phase 7: {} events arrived up to {}ms after stop(), then silent for {}ms", 
-                 after_stop, post_stop_duration.as_millis(), silence_duration.as_millis());
+        println!(
+            "Phase 7: {} events arrived up to {}ms after stop(), then silent for {}ms",
+            after_stop,
+            post_stop_duration.as_millis(),
+            silence_duration.as_millis()
+        );
     }
 
     println!("\n=== Subscription enforcement ===");
 
-    let test_callback = |_event: Box<dyn solana_streamer_sdk::streaming::event_parser::UnifiedEvent>| {};
+    let test_callback =
+        |_event: Box<dyn solana_streamer_sdk::streaming::event_parser::UnifiedEvent>| {};
 
-    match client.subscribe_events_immediate(
-        vec![Protocol::RaydiumCpmm],
-        None,
-        TransactionFilter {
-            account_include: vec![RAYDIUM_CPMM_PROGRAM_ID.to_string()],
-            account_exclude: vec![],
-            account_required: vec![],
-        },
-        AccountFilter {
-            account: vec![],
-            owner: vec![],
-        },
-        None,
-        None,
-        test_callback,
-    ).await {
+    match client
+        .subscribe_events_immediate(
+            vec![Protocol::RaydiumCpmm],
+            None,
+            vec![TransactionFilter {
+                account_include: vec![RAYDIUM_CPMM_PROGRAM_ID.to_string()],
+                account_exclude: vec![],
+                account_required: vec![],
+            }],
+            vec![AccountFilter { account: vec![], owner: vec![], filters: vec![] }],
+            None,
+            None,
+            test_callback,
+        )
+        .await
+    {
         Ok(_) => println!("ERROR: Same client created second subscription"),
         Err(e) if e.to_string().contains("Already subscribed") => {
             println!("✓ Single subscription enforcement working");
-        },
+        }
         Err(e) => println!("Unexpected error: {}", e),
     }
 
-    let client2 = Arc::new(YellowstoneGrpc::new(
-        GRPC_ENDPOINT.to_string(),
-        API_KEY.map(|s| s.to_string())
-    )?);
+    let client2 =
+        Arc::new(YellowstoneGrpc::new(GRPC_ENDPOINT.to_string(), API_KEY.map(|s| s.to_string()))?);
 
     let client2_counter = Arc::new(AtomicU64::new(0));
     let counter2 = client2_counter.clone();
-    let client2_callback = move |_event: Box<dyn solana_streamer_sdk::streaming::event_parser::UnifiedEvent>| {
-        counter2.fetch_add(1, Ordering::Relaxed);
-    };
+    let client2_callback =
+        move |_event: Box<dyn solana_streamer_sdk::streaming::event_parser::UnifiedEvent>| {
+            counter2.fetch_add(1, Ordering::Relaxed);
+        };
 
-    match client2.subscribe_events_immediate(
-        vec![Protocol::RaydiumCpmm],
-        None,
-        TransactionFilter {
-            account_include: vec![RAYDIUM_CPMM_PROGRAM_ID.to_string()],
-            account_exclude: vec![],
-            account_required: vec![],
-        },
-        AccountFilter {
-            account: vec![],
-            owner: vec![],
-        },
-        None,
-        None,
-        client2_callback,
-    ).await {
+    match client2
+        .subscribe_events_immediate(
+            vec![Protocol::RaydiumCpmm],
+            None,
+            vec![TransactionFilter {
+                account_include: vec![RAYDIUM_CPMM_PROGRAM_ID.to_string()],
+                account_exclude: vec![],
+                account_required: vec![],
+            }],
+            vec![AccountFilter { account: vec![], owner: vec![], filters: vec![] }],
+            None,
+            None,
+            client2_callback,
+        )
+        .await
+    {
         Ok(_) => {
             sleep(Duration::from_millis(500)).await;
             let count = client2_counter.load(Ordering::Relaxed);
             println!("✓ Second client: {} events", count);
             client2.stop().await;
-        },
+        }
         Err(e) => println!("ERROR: Second client failed: {}", e),
     }
 
     println!("\n=== Advanced subscription enforcement ===");
-    
-    let test_callback_advanced = |_event: Box<dyn solana_streamer_sdk::streaming::event_parser::UnifiedEvent>| {};
 
-    let client3 = Arc::new(YellowstoneGrpc::new(
-        GRPC_ENDPOINT.to_string(),
-        API_KEY.map(|s| s.to_string())
-    )?);
+    let test_callback_advanced =
+        |_event: Box<dyn solana_streamer_sdk::streaming::event_parser::UnifiedEvent>| {};
+
+    let client3 =
+        Arc::new(YellowstoneGrpc::new(GRPC_ENDPOINT.to_string(), API_KEY.map(|s| s.to_string()))?);
 
     // First subscription should succeed
-    match client3.subscribe_events_immediate(
-        vec![Protocol::RaydiumCpmm],
-        None,
-        TransactionFilter {
-            account_include: vec![RAYDIUM_CPMM_PROGRAM_ID.to_string()],
-            account_exclude: vec![],
-            account_required: vec![],
-        },
-        AccountFilter {
-            account: vec![],
-            owner: vec![],
-        },
-        None,
-        None,
-        test_callback_advanced,
-    ).await {
+    match client3
+        .subscribe_events_immediate(
+            vec![Protocol::RaydiumCpmm],
+            None,
+            vec![TransactionFilter {
+                account_include: vec![RAYDIUM_CPMM_PROGRAM_ID.to_string()],
+                account_exclude: vec![],
+                account_required: vec![],
+            }],
+            vec![AccountFilter { account: vec![], owner: vec![], filters: vec![] }],
+            None,
+            None,
+            test_callback_advanced,
+        )
+        .await
+    {
         Ok(_) => {
             // Second subscription attempt on same client should fail
-            match client3.subscribe_events_immediate(
-                vec![Protocol::RaydiumCpmm],
-                None,
-                TransactionFilter {
-                    account_include: vec![RAYDIUM_CPMM_PROGRAM_ID.to_string()],
-                    account_exclude: vec![],
-                    account_required: vec![],
-                },
-                AccountFilter {
-                    account: vec![],
-                    owner: vec![],
-                },
-                None,
-                None,
-                |_| {},
-            ).await {
+            match client3
+                .subscribe_events_immediate(
+                    vec![Protocol::RaydiumCpmm],
+                    None,
+                    vec![TransactionFilter {
+                        account_include: vec![RAYDIUM_CPMM_PROGRAM_ID.to_string()],
+                        account_exclude: vec![],
+                        account_required: vec![],
+                    }],
+                    vec![AccountFilter { account: vec![], owner: vec![], filters: vec![] }],
+                    None,
+                    None,
+                    |_| {},
+                )
+                .await
+            {
                 Ok(_) => println!("ERROR: Same client created second advanced subscription"),
                 Err(e) if e.to_string().contains("Already subscribed") => {
                     println!("✓ Advanced single subscription enforcement working");
-                },
+                }
                 Err(e) => println!("Unexpected error: {}", e),
             }
-        },
+        }
         Err(e) => println!("ERROR: First advanced subscription failed: {}", e),
     }
 
     // Test that a second client can subscribe using advanced method
-    let client4 = Arc::new(YellowstoneGrpc::new(
-        GRPC_ENDPOINT.to_string(),
-        API_KEY.map(|s| s.to_string())
-    )?);
+    let client4 =
+        Arc::new(YellowstoneGrpc::new(GRPC_ENDPOINT.to_string(), API_KEY.map(|s| s.to_string()))?);
 
     let client4_counter = Arc::new(AtomicU64::new(0));
     let counter4 = client4_counter.clone();
-    let client4_callback = move |_event: Box<dyn solana_streamer_sdk::streaming::event_parser::UnifiedEvent>| {
-        counter4.fetch_add(1, Ordering::Relaxed);
-    };
+    let client4_callback =
+        move |_event: Box<dyn solana_streamer_sdk::streaming::event_parser::UnifiedEvent>| {
+            counter4.fetch_add(1, Ordering::Relaxed);
+        };
 
-    match client4.subscribe_events_immediate(
-        vec![Protocol::RaydiumCpmm],
-        None,
-        TransactionFilter {
-            account_include: vec![RAYDIUM_CPMM_PROGRAM_ID.to_string()],
-            account_exclude: vec![],
-            account_required: vec![],
-        },
-        AccountFilter {
-            account: vec![],
-            owner: vec![],
-        },
-        None,
-        None,
-        client4_callback,
-    ).await {
+    match client4
+        .subscribe_events_immediate(
+            vec![Protocol::RaydiumCpmm],
+            None,
+            vec![TransactionFilter {
+                account_include: vec![RAYDIUM_CPMM_PROGRAM_ID.to_string()],
+                account_exclude: vec![],
+                account_required: vec![],
+            }],
+            vec![AccountFilter { account: vec![], owner: vec![], filters: vec![] }],
+            None,
+            None,
+            client4_callback,
+        )
+        .await
+    {
         Ok(_) => {
             sleep(Duration::from_millis(500)).await;
             let count = client4_counter.load(Ordering::Relaxed);
             println!("✓ Second client (advanced): {} events", count);
             client4.stop().await;
-        },
+        }
         Err(e) => println!("ERROR: Second client (advanced) failed: {}", e),
     }
 

examples/grpc_example.rs

@@ -3,7 +3,7 @@ use solana_streamer_sdk::{
     streaming::{
         event_parser::{
             common::EventType,
-            core::account_event_parser::{TokenInfoEvent, NonceAccountEvent, TokenAccountEvent},
+            core::account_event_parser::{NonceAccountEvent, TokenAccountEvent, TokenInfoEvent},
             protocols::{
                 bonk::{
                     parser::BONK_PROGRAM_ID, BonkGlobalConfigAccountEvent, BonkMigrateToAmmEvent,
@@ -105,7 +105,7 @@ async fn test_grpc() -> Result<(), Box<dyn std::error::Error>> {
     };
 
     // Listen to account data belonging to owner programs -> account event monitoring
-    let account_filter = AccountFilter { account: vec![], owner: account_include.clone() };
+    let account_filter = AccountFilter { account: vec![], owner: account_include.clone(), filters: vec![] };
 
     // Event filtering
     // No event filtering, includes all events
@@ -121,8 +121,8 @@ async fn test_grpc() -> Result<(), Box<dyn std::error::Error>> {
     grpc.subscribe_events_immediate(
         protocols,
         None,
-        transaction_filter,
-        account_filter,
+        vec![transaction_filter],
+        vec![account_filter],
         event_type_filter,
         None,
         callback,

examples/nonce_listen_example.rs

@@ -42,7 +42,8 @@ async fn test_grpc() -> Result<(), Box<dyn std::error::Error>> {
 
     let nonce_account = "use_your_nonce_account_here".to_string();
     // Listen to account data belonging to owner programs -> account event monitoring
-    let account_filter = AccountFilter { account: vec![nonce_account], owner: vec![] };
+    let account_filter =
+        AccountFilter { account: vec![nonce_account], owner: vec![], filters: vec![] };
 
     // Event filtering
     let event_type_filter = Some(EventTypeFilter { include: vec![EventType::NonceAccount] });
@@ -53,8 +54,8 @@ async fn test_grpc() -> Result<(), Box<dyn std::error::Error>> {
     grpc.subscribe_events_immediate(
         protocols,
         None,
-        transaction_filter,
-        account_filter,
+        vec![transaction_filter],
+        vec![account_filter],
         event_type_filter,
         None,
         callback,

examples/pumpswap_pool_account_listen_example.rs

@@ -0,0 +1,119 @@
+use std::str::FromStr;
+
+use solana_sdk::pubkey::Pubkey;
+use solana_streamer_sdk::{
+    match_event,
+    streaming::{
+        event_parser::{
+            common::{filter::EventTypeFilter, EventType},
+            core::account_event_parser::TokenAccountEvent,
+            UnifiedEvent,
+        },
+        grpc::ClientConfig,
+        yellowstone_grpc::{AccountFilter, TransactionFilter},
+        YellowstoneGrpc,
+    },
+};
+use yellowstone_grpc_proto::geyser::{
+    subscribe_request_filter_accounts_filter::Filter,
+    subscribe_request_filter_accounts_filter_memcmp::Data, SubscribeRequestFilterAccountsFilter,
+    SubscribeRequestFilterAccountsFilterMemcmp,
+};
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    println!("Starting Yellowstone gRPC Streamer...");
+    test_grpc().await?;
+    Ok(())
+}
+
+async fn test_grpc() -> Result<(), Box<dyn std::error::Error>> {
+    println!("Subscribing to Yellowstone gRPC events...");
+    // Create low-latency configuration
+    let mut config: ClientConfig = ClientConfig::low_latency();
+    // Enable performance monitoring, has performance overhead, disabled by default
+    config.enable_metrics = true;
+    let grpc = YellowstoneGrpc::new_with_config(
+        "https://solana-yellowstone-grpc.publicnode.com:443".to_string(),
+        None,
+        config,
+    )?;
+    println!("GRPC client created successfully");
+    let callback = create_event_callback();
+    // Will try to parse corresponding protocol events from transactions
+    let protocols = vec![];
+    println!("Protocols to monitor: {:?}", protocols);
+    // Filter accounts
+    let account_include = vec![];
+    let account_exclude = vec![];
+    let account_required = vec![];
+
+    // Listen to transaction data
+    let transaction_filter =
+        TransactionFilter { account_include, account_exclude, account_required };
+
+    // Pump.fun AMM (PUMP-USDC) Market
+    let pump_usdc = Pubkey::from_str("2uF4Xh61rDwxnG9woyxsVQP7zuA6kLFpb3NvnRQeoiSd").unwrap();
+    let wsol_deepseekai = Pubkey::from_str("BJAjivuMVANjpRWtrRfcxzGhnMSywBN19Sa4jAzWxXDx").unwrap();
+
+    // Listen to account data belonging to owner programs -> account event monitoring
+    let pump_usdc_account_filter = AccountFilter {
+        account: vec![],
+        owner: vec![],
+        filters: vec![SubscribeRequestFilterAccountsFilter {
+            filter: Some(Filter::Memcmp(SubscribeRequestFilterAccountsFilterMemcmp {
+                offset: 32,
+                data: Some(Data::Bytes(pump_usdc.to_bytes().to_vec())),
+            })),
+        }],
+    };
+    let wsol_deepseekai_account_filter = AccountFilter {
+        account: vec![],
+        owner: vec![],
+        filters: vec![SubscribeRequestFilterAccountsFilter {
+            filter: Some(Filter::Memcmp(SubscribeRequestFilterAccountsFilterMemcmp {
+                offset: 32,
+                data: Some(Data::Bytes(wsol_deepseekai.to_bytes().to_vec())),
+            })),
+        }],
+    };
+
+    // Event filtering
+    let event_type_filter = Some(EventTypeFilter { include: vec![EventType::TokenAccount] });
+
+    println!("Starting to listen for events, press Ctrl+C to stop...");
+    println!("Starting subscription...");
+
+    grpc.subscribe_events_immediate(
+        protocols.clone(),
+        None,
+        vec![transaction_filter.clone()],
+        vec![pump_usdc_account_filter.clone(), wsol_deepseekai_account_filter.clone()],
+        event_type_filter.clone(),
+        None,
+        callback,
+    )
+    .await?;
+
+    // 支持 stop 方法，测试代码 -  异步1000秒之后停止
+    let grpc_clone = grpc.clone();
+    tokio::spawn(async move {
+        tokio::time::sleep(std::time::Duration::from_secs(1000)).await;
+        grpc_clone.stop().await;
+    });
+
+    println!("Waiting for Ctrl+C to stop...");
+    tokio::signal::ctrl_c().await?;
+
+    Ok(())
+}
+
+fn create_event_callback() -> impl Fn(Box<dyn UnifiedEvent>) {
+    |event: Box<dyn UnifiedEvent>| {
+        match_event!(event, {
+            TokenAccountEvent => |e: TokenAccountEvent| {
+                println!("TokenAccount: {:?} amount: {:?}", e.pubkey, e.amount);
+            },
+        });
+    }
+}

examples/token_balance_listen_example.rs

@@ -43,7 +43,8 @@ async fn test_grpc() -> Result<(), Box<dyn std::error::Error>> {
     let account_to_listen = "use_your_token_account_here".to_string();
 
     // Listen to account data belonging to owner programs -> account event monitoring
-    let account_filter = AccountFilter { account: vec![account_to_listen], owner: vec![] };
+    let account_filter =
+        AccountFilter { account: vec![account_to_listen], owner: vec![], filters: vec![] };
 
     // Event filtering
     let event_type_filter = Some(EventTypeFilter { include: vec![EventType::TokenAccount] });
@@ -54,8 +55,8 @@ async fn test_grpc() -> Result<(), Box<dyn std::error::Error>> {
     grpc.subscribe_events_immediate(
         protocols.clone(),
         None,
-        transaction_filter.clone(),
-        account_filter.clone(),
+        vec![transaction_filter.clone()],
+        vec![account_filter.clone()],
         event_type_filter.clone(),
         None,
         callback,

examples/token_decimals_listen_example.rs

@@ -47,7 +47,8 @@ async fn test_grpc() -> Result<(), Box<dyn std::error::Error>> {
     let account_to_listen = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v".to_string();
 
     // Listen to account data belonging to owner programs -> account event monitoring
-    let account_filter = AccountFilter { account: vec![account_to_listen], owner: vec![] };
+    let account_filter =
+        AccountFilter { account: vec![account_to_listen], owner: vec![], filters: vec![] };
 
     // Event filtering
     let event_type_filter = Some(EventTypeFilter { include: vec![EventType::TokenAccount] });
@@ -58,8 +59,8 @@ async fn test_grpc() -> Result<(), Box<dyn std::error::Error>> {
     grpc.subscribe_events_immediate(
         protocols.clone(),
         None,
-        transaction_filter.clone(),
-        account_filter.clone(),
+        vec![transaction_filter.clone()],
+        vec![account_filter.clone()],
         event_type_filter.clone(),
         None,
         callback,