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
2026-08-17 10:58:06 +00:00 · 2025-09-10 23:21:08 +08:00
parent 304c943d79
commit 5ea536bef6
13 changed files with 491 additions and 327 deletions
@@ -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),
    }