chore: release v3.5.6

Made-with: Cursor

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sol-trade-sdk"
-version = "3.5.4"
+version = "3.5.6"
 edition = "2021"
 authors = [
     "William <byteblock6@gmail.com>",
@@ -20,6 +20,8 @@ members = [
     "examples/shared_infrastructure",
     "examples/middleware_system",
     "examples/pumpswap_trading",
+    "examples/pumpfun_copy_trading",
+    "examples/pumpfun_sniper_trading",
     "examples/bonk_sniper_trading",
     "examples/bonk_copy_trading",
     "examples/raydium_cpmm_trading",
@@ -43,23 +45,23 @@ perf-trace = []  # 性能追踪特性，生产环境应禁用以获得最佳性
 
 [dependencies]
 solana-sdk = "3.0.0"
-solana-client = "3.0.8"
+solana-client = "3.1.9"
 solana-program = "3.0.0"
-solana-rpc-client = "3.0.8"
-solana-rpc-client-api = "3.0.8"
-solana-transaction-status = "3.0.8"
-solana-account-decoder = "3.0.8"
+solana-rpc-client = "3.1.9"
+solana-rpc-client-api = "3.1.9"
+solana-transaction-status = "3.1.9"
+solana-account-decoder = "3.1.9"
 solana-hash = "3.0.0"
-solana-entry = "3.0.8"
-solana-rpc-client-nonce-utils = "3.0.8"
-solana-perf = "3.0.8"
-solana-metrics = "3.0.8"
-solana-nonce = "3.0.0"
-solana-address-lookup-table-interface = "3.0.0"
+solana-entry = "3.1.9"
+solana-rpc-client-nonce-utils = "3.1.9"
+solana-perf = "3.1.9"
+solana-metrics = "3.1.9"
+solana-nonce = "3.1.0"
+solana-address-lookup-table-interface = "3.0.1"
 solana-compute-budget-interface = "3.0.0"
-solana-commitment-config = { version = "3.0.0", features = ["serde"] }
-solana-transaction-status-client-types = "3.0.0"
-solana-tls-utils = "3.0.8"
+solana-commitment-config = { version = "3.1.1", features = ["serde"] }
+solana-transaction-status-client-types = "3.1.9"
+solana-tls-utils = "3.1.9"
 
 borsh = { version = "1.5.3", features = ["derive"] }
 isahc = "1.7.2"

README.md

@@ -89,14 +89,14 @@ Add the dependency to your `Cargo.toml`:
 
 ```toml
 # Add to your Cargo.toml
-sol-trade-sdk = { path = "./sol-trade-sdk", version = "3.5.4" }
+sol-trade-sdk = { path = "./sol-trade-sdk", version = "3.5.6" }
 ```
 
 ### Use crates.io
 
 ```toml
 # Add to your Cargo.toml
-sol-trade-sdk = "3.5.4"
+sol-trade-sdk = "3.5.6"
 ```
 
 ## 🛠️ Usage Examples

README_CN.md

@@ -89,14 +89,14 @@ git clone https://github.com/0xfnzero/sol-trade-sdk
 
 ```toml
 # 添加到您的 Cargo.toml
-sol-trade-sdk = { path = "./sol-trade-sdk", version = "3.5.4" }
+sol-trade-sdk = { path = "./sol-trade-sdk", version = "3.5.6" }
 ```
 
 ### 使用 crates.io
 
 ```toml
 # 添加到您的 Cargo.toml
-sol-trade-sdk = "3.5.4"
+sol-trade-sdk = "3.5.6"
 ```
 
 ## 🛠️ 使用示例

examples/address_lookup/Cargo.toml

@@ -5,9 +5,7 @@ edition = "2021"
 
 [dependencies]
 sol-trade-sdk = { path = "../.." }
-solana-streamer-sdk = "0.5.0"
+sol-parser-sdk = "0.2.2"
 solana-sdk = "3.0.0"
-solana-address-lookup-table-interface = "3.0.0"
 solana-commitment-config = { version = "3.0.0", features = ["serde"] }
 tokio = { version = "1", features = ["full"] }
-anyhow = "1.0.94"

examples/address_lookup/src/main.rs

@@ -1,5 +1,18 @@
+use std::{
+    str::FromStr,
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    },
+};
+
+use sol_parser_sdk::grpc::{
+    AccountFilter, ClientConfig, EventType, EventTypeFilter, OrderMode, Protocol,
+    TransactionFilter, YellowstoneGrpc,
+};
+use sol_parser_sdk::DexEvent;
 use sol_trade_sdk::common::address_lookup::fetch_address_lookup_table_account;
-use sol_trade_sdk::common::{gas_fee_strategy, GasFeeStrategy, TradeConfig};
+use sol_trade_sdk::common::{GasFeeStrategy, TradeConfig};
 use sol_trade_sdk::{
     common::AnyResult,
     swqos::SwqosConfig,
@@ -9,95 +22,82 @@ use sol_trade_sdk::{
 use solana_commitment_config::CommitmentConfig;
 use solana_sdk::pubkey::Pubkey;
 use solana_sdk::signature::Keypair;
-use solana_streamer_sdk::match_event;
-use solana_streamer_sdk::streaming::event_parser::common::filter::EventTypeFilter;
-use solana_streamer_sdk::streaming::event_parser::common::EventType;
-use solana_streamer_sdk::streaming::event_parser::protocols::pumpfun::parser::PUMPFUN_PROGRAM_ID;
-use solana_streamer_sdk::streaming::event_parser::protocols::pumpfun::PumpFunTradeEvent;
-use solana_streamer_sdk::streaming::event_parser::{Protocol, UnifiedEvent};
-use solana_streamer_sdk::streaming::yellowstone_grpc::{AccountFilter, TransactionFilter};
-use solana_streamer_sdk::streaming::YellowstoneGrpc;
-use std::{
-    str::FromStr,
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        Arc,
-    },
-};
 
-// Global static flag to ensure transaction is executed only once
 static ALREADY_EXECUTED: AtomicBool = AtomicBool::new(false);
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    println!("Subscribing to GRPC events...");
+    println!("Subscribing to GRPC events (sol-parser-sdk, is_cashback_coin from event)...");
 
-    let grpc = YellowstoneGrpc::new(
-        "https://solana-yellowstone-grpc.publicnode.com:443".to_string(),
-        None,
-    )?;
-
-    let callback = create_event_callback();
-    let protocols = vec![Protocol::PumpFun];
-    // Filter accounts
-    let account_include = vec![
-        PUMPFUN_PROGRAM_ID.to_string(), // Listen to pumpfun program ID
-    ];
-    let account_exclude = vec![];
-    let account_required = vec![];
-
-    // Listen to transaction data
-    let transaction_filter = TransactionFilter {
-        account_include: account_include.clone(),
-        account_exclude,
-        account_required,
+    let config = ClientConfig {
+        enable_metrics: false,
+        connection_timeout_ms: 10000,
+        request_timeout_ms: 30000,
+        enable_tls: true,
+        order_mode: OrderMode::Unordered,
+        ..Default::default()
     };
 
-    // Listen to account data belonging to owner programs -> account event monitoring
-    let account_filter = AccountFilter { account: vec![], owner: vec![], filters: vec![] };
+    let grpc_endpoint = std::env::var("GRPC_ENDPOINT")
+        .unwrap_or_else(|_| "https://solana-yellowstone-grpc.publicnode.com:443".to_string());
+    let grpc = YellowstoneGrpc::new_with_config(
+        grpc_endpoint,
+        std::env::var("GRPC_AUTH_TOKEN").ok(),
+        config,
+    )?;
 
-    // listen to specific event type
-    let event_type_filter =
-        EventTypeFilter { include: vec![EventType::PumpFunBuy, EventType::PumpFunSell] };
+    let protocols = vec![Protocol::PumpFun];
+    let transaction_filter = TransactionFilter::for_protocols(&protocols);
+    let account_filter = AccountFilter::for_protocols(&protocols);
+    let event_filter = EventTypeFilter::include_only(vec![
+        EventType::PumpFunBuy,
+        EventType::PumpFunSell,
+        EventType::PumpFunBuyExactSolIn,
+        EventType::PumpFunTrade,
+    ]);
 
-    grpc.subscribe_events_immediate(
-        protocols,
-        None,
-        vec![transaction_filter],
-        vec![account_filter],
-        Some(event_type_filter),
-        None,
-        callback,
-    )
-    .await?;
+    let queue = grpc
+        .subscribe_dex_events(vec![transaction_filter], vec![account_filter], Some(event_filter))
+        .await?;
+
+    loop {
+        if let Some(event) = queue.pop() {
+            let run = match &event {
+                DexEvent::PumpFunBuy(e) | DexEvent::PumpFunSell(e) | DexEvent::PumpFunBuyExactSolIn(e) => {
+                    if !ALREADY_EXECUTED.swap(true, Ordering::SeqCst) {
+                        Some(e.clone())
+                    } else {
+                        None
+                    }
+                }
+                DexEvent::PumpFunTrade(e) => {
+                    if !ALREADY_EXECUTED.swap(true, Ordering::SeqCst) {
+                        Some(e.clone())
+                    } else {
+                        None
+                    }
+                }
+                _ => None,
+            };
+            if let Some(e) = run {
+                tokio::spawn(async move {
+                    if let Err(err) = pumpfun_copy_trade_with_grpc(e).await {
+                        eprintln!("Error in copy trade: {:?}", err);
+                        std::process::exit(1);
+                    }
+                    std::process::exit(0);
+                });
+                break;
+            }
+        } else {
+            tokio::time::sleep(tokio::time::Duration::from_millis(5)).await;
+        }
+    }
 
     tokio::signal::ctrl_c().await?;
-
     Ok(())
 }
 
-/// Create an event callback function that handles different types of events
-fn create_event_callback() -> impl Fn(Box<dyn UnifiedEvent>) {
-    |event: Box<dyn UnifiedEvent>| {
-        match_event!(event, {
-            PumpFunTradeEvent => |e: PumpFunTradeEvent| {
-                // Test code, only test one transaction
-                if !ALREADY_EXECUTED.swap(true, Ordering::SeqCst) {
-                    let event_clone = e.clone();
-                    tokio::spawn(async move {
-                        if let Err(err) = pumpfun_copy_trade_with_grpc(event_clone).await {
-                            eprintln!("Error in copy trade: {:?}", err);
-                            std::process::exit(0);
-                        }
-                    });
-                }
-            },
-        });
-    }
-}
-
-/// Create SolanaTrade client
-/// Initializes a new SolanaTrade client with configuration
 async fn create_solana_trade_client() -> AnyResult<SolanaTrade> {
     println!("🚀 Initializing SolanaTrade client...");
     let payer = Keypair::from_base58_string("use_your_payer_keypair_here");
@@ -110,9 +110,10 @@ async fn create_solana_trade_client() -> AnyResult<SolanaTrade> {
     Ok(solana_trade)
 }
 
-/// PumpFun sniper trade
-/// This function demonstrates how to snipe a new token from a PumpFun trade event
-async fn pumpfun_copy_trade_with_grpc(trade_info: PumpFunTradeEvent) -> AnyResult<()> {
+/// PumpFun copy trade: use is_cashback_coin from gRPC event (sol-parser-sdk)
+async fn pumpfun_copy_trade_with_grpc(
+    trade_info: sol_parser_sdk::core::events::PumpFunTradeEvent,
+) -> AnyResult<()> {
     println!("Testing PumpFun trading...");
 
     let client = create_solana_trade_client().await?;
@@ -127,15 +128,13 @@ async fn pumpfun_copy_trade_with_grpc(trade_info: PumpFunTradeEvent) -> AnyResul
     let gas_fee_strategy = GasFeeStrategy::new();
     gas_fee_strategy.set_global_fee_strategy(150000, 150000, 500000, 500000, 0.001, 0.001);
 
-    // Buy tokens
-    println!("Buying tokens from PumpFun...");
-    let buy_sol_amount = 100_000;
+    // is_cashback_coin from gRPC event (sol-parser-sdk parses it from trade event)
     let buy_params = sol_trade_sdk::TradeBuyParams {
         dex_type: DexType::PumpFun,
         input_token_type: sol_trade_sdk::TradeTokenType::SOL,
         mint: mint_pubkey,
-        input_token_amount: buy_sol_amount,
-        slippage_basis_points: slippage_basis_points,
+        input_token_amount: 100_000,
+        slippage_basis_points,
         recent_blockhash: Some(recent_blockhash),
         extension_params: DexParamEnum::PumpFun(PumpFunParams::from_trade(
             trade_info.bonding_curve,
@@ -150,21 +149,21 @@ async fn pumpfun_copy_trade_with_grpc(trade_info: PumpFunTradeEvent) -> AnyResul
             None,
             trade_info.fee_recipient,
             trade_info.token_program,
-            false, // is_cashback_coin: set from event/parser when available
+            trade_info.is_cashback_coin,
         )),
-        address_lookup_table_account: address_lookup_table_account,
+        address_lookup_table_account,
         wait_transaction_confirmed: true,
         create_input_token_ata: false,
         close_input_token_ata: false,
         create_mint_ata: true,
         durable_nonce: None,
         fixed_output_token_amount: None,
-        gas_fee_strategy: gas_fee_strategy,
+        gas_fee_strategy,
         simulate: false,
         use_exact_sol_amount: None,
+        grpc_recv_us: None,
     };
     client.buy(buy_params).await?;
 
-    // Exit program
     std::process::exit(0);
 }

examples/bonk_copy_trading/src/main.rs

@@ -176,6 +176,7 @@ async fn bonk_copy_trade_with_grpc(trade_info: BonkTradeEvent) -> AnyResult<()>
         gas_fee_strategy: gas_fee_strategy.clone(),
         simulate: false,
         use_exact_sol_amount: None,
+        grpc_recv_us: None,
     };
     client.buy(buy_params).await?;
 
@@ -226,6 +227,7 @@ async fn bonk_copy_trade_with_grpc(trade_info: BonkTradeEvent) -> AnyResult<()>
         fixed_output_token_amount: None,
         gas_fee_strategy: gas_fee_strategy,
         simulate: false,
+        grpc_recv_us: None,
     };
     client.sell(sell_params).await?;
 

examples/bonk_sniper_trading/src/main.rs

@@ -144,6 +144,7 @@ async fn bonk_sniper_trade_with_shreds(trade_info: BonkTradeEvent) -> AnyResult<
         gas_fee_strategy: gas_fee_strategy.clone(),
         simulate: false,
         use_exact_sol_amount: None,
+        grpc_recv_us: None,
     };
     client.buy(buy_params).await?;
 
@@ -187,6 +188,7 @@ async fn bonk_sniper_trade_with_shreds(trade_info: BonkTradeEvent) -> AnyResult<
         fixed_output_token_amount: None,
         gas_fee_strategy: gas_fee_strategy,
         simulate: false,
+        grpc_recv_us: None,
     };
     client.sell(sell_params).await?;
 

examples/cli_trading/src/main.rs

@@ -635,6 +635,7 @@ async fn handle_buy_pumpfun(
         gas_fee_strategy: gas_fee_strategy,
         simulate: false,
         use_exact_sol_amount: None,
+        grpc_recv_us: None,
     };
     match client.buy(buy_params).await {
         Ok((_, signature, _)) => {
@@ -690,6 +691,7 @@ async fn handle_buy_pumpswap(
         gas_fee_strategy: gas_fee_strategy,
         simulate: false,
         use_exact_sol_amount: None,
+        grpc_recv_us: None,
     };
     match client.buy(buy_params).await {
         Ok((_, signature, _)) => {
@@ -744,6 +746,7 @@ async fn handle_buy_bonk(
         gas_fee_strategy: gas_fee_strategy,
         simulate: false,
         use_exact_sol_amount: None,
+        grpc_recv_us: None,
     };
     match client.buy(buy_params).await {
         Ok((_, signature, _)) => {
@@ -802,6 +805,7 @@ async fn handle_buy_raydium_v4(
         gas_fee_strategy: gas_fee_strategy,
         simulate: false,
         use_exact_sol_amount: None,
+        grpc_recv_us: None,
     };
     match client.buy(buy_params).await {
         Ok((_, signature, _)) => {
@@ -860,6 +864,7 @@ async fn handle_buy_raydium_cpmm(
         gas_fee_strategy: gas_fee_strategy,
         simulate: false,
         use_exact_sol_amount: None,
+        grpc_recv_us: None,
     };
     match client.buy(buy_params).await {
         Ok((_, signature, _)) => {
@@ -1028,6 +1033,7 @@ async fn handle_sell_pumpfun(
         fixed_output_token_amount: None,
         gas_fee_strategy: gas_fee_strategy,
         simulate: false,
+        grpc_recv_us: None,
     };
 
     match client.sell(sell_params).await {
@@ -1086,6 +1092,7 @@ async fn handle_sell_pumpswap(
         fixed_output_token_amount: None,
         gas_fee_strategy: gas_fee_strategy,
         simulate: false,
+        grpc_recv_us: None,
     };
     match client.sell(sell_params).await {
         Ok((_, signature, _)) => {
@@ -1143,6 +1150,7 @@ async fn handle_sell_bonk(
         fixed_output_token_amount: None,
         gas_fee_strategy: gas_fee_strategy,
         simulate: false,
+        grpc_recv_us: None,
     };
     match client.sell(sell_params).await {
         Ok((_, signature, _)) => {
@@ -1203,6 +1211,7 @@ async fn handle_sell_raydium_v4(
         fixed_output_token_amount: None,
         gas_fee_strategy: gas_fee_strategy,
         simulate: false,
+        grpc_recv_us: None,
     };
     match client.sell(sell_params).await {
         Ok((_, signature, _)) => {
@@ -1263,6 +1272,7 @@ async fn handle_sell_raydium_cpmm(
         fixed_output_token_amount: None,
         gas_fee_strategy: gas_fee_strategy,
         simulate: false,
+        grpc_recv_us: None,
     };
     match client.sell(sell_params).await {
         Ok((_, signature, _)) => {

examples/meteora_damm_v2_direct_trading/src/main.rs

@@ -44,6 +44,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         gas_fee_strategy: gas_fee_strategy.clone(),
         simulate: false,
         use_exact_sol_amount: None,
+        grpc_recv_us: None,
     };
     client.buy(buy_params).await?;
 
@@ -77,6 +78,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         fixed_output_token_amount: Some(1),
         gas_fee_strategy: gas_fee_strategy,
         simulate: false,
+        grpc_recv_us: None,
     };
     client.sell(sell_params).await?;
 

examples/middleware_system/src/main.rs

@@ -1,9 +1,9 @@
 use anyhow::Result;
 use sol_trade_sdk::{
     common::{AnyResult, TradeConfig},
-    swqos::{SwqosConfig, SwqosRegion},
+    swqos::SwqosConfig,
     trading::{
-        core::params::{PumpSwapParams, DexParamEnum}, factory::DexType, middleware::builtin::LoggingMiddleware,
+        core::params::{PumpSwapParams, DexParamEnum}, factory::DexType,
         InstructionMiddleware, MiddlewareManager,
     },
     SolanaTrade, TradeTokenType,
@@ -30,8 +30,8 @@ impl InstructionMiddleware for CustomMiddleware {
     fn process_protocol_instructions(
         &self,
         protocol_instructions: Vec<Instruction>,
-        protocol_name: String,
-        is_buy: bool,
+        _protocol_name: String,
+        _is_buy: bool,
     ) -> Result<Vec<Instruction>> {
         // do anything you want here
         // you can modify the instructions here
@@ -41,8 +41,8 @@ impl InstructionMiddleware for CustomMiddleware {
     fn process_full_instructions(
         &self,
         full_instructions: Vec<Instruction>,
-        protocol_name: String,
-        is_buy: bool,
+        _protocol_name: String,
+        _is_buy: bool,
     ) -> Result<Vec<Instruction>> {
         // do anything you want here
         // you can modify the instructions here
@@ -103,6 +103,7 @@ async fn test_middleware() -> AnyResult<()> {
         gas_fee_strategy: gas_fee_strategy,
         simulate: false,
         use_exact_sol_amount: None,
+        grpc_recv_us: None,
     };
     client.buy(buy_params).await?;
     println!("tip: This transaction will not succeed because we're using a test account. You can modify the code to initialize the payer with your own private key");

examples/nonce_cache/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 sol-trade-sdk = { path = "../.." }
-solana-streamer-sdk = "0.5.0"
+sol-parser-sdk = "0.2.2"
 solana-sdk = "3.0.0"
 solana-commitment-config = { version = "3.0.0", features = ["serde"] }
 spl-associated-token-account = "7.0.0"

examples/nonce_cache/src/main.rs

@@ -6,6 +6,11 @@ use std::{
     },
 };
 
+use sol_parser_sdk::grpc::{
+    AccountFilter, ClientConfig, EventType, EventTypeFilter, OrderMode, Protocol,
+    TransactionFilter, YellowstoneGrpc,
+};
+use sol_parser_sdk::DexEvent;
 use sol_trade_sdk::common::{nonce_cache::fetch_nonce_info, TradeConfig};
 use sol_trade_sdk::TradeTokenType;
 use sol_trade_sdk::{
@@ -16,88 +21,82 @@ use sol_trade_sdk::{
 };
 use solana_commitment_config::CommitmentConfig;
 use solana_sdk::{pubkey::Pubkey, signature::Keypair};
-use solana_streamer_sdk::match_event;
-use solana_streamer_sdk::streaming::event_parser::common::filter::EventTypeFilter;
-use solana_streamer_sdk::streaming::event_parser::common::EventType;
-use solana_streamer_sdk::streaming::event_parser::protocols::pumpfun::parser::PUMPFUN_PROGRAM_ID;
-use solana_streamer_sdk::streaming::event_parser::protocols::pumpfun::PumpFunTradeEvent;
-use solana_streamer_sdk::streaming::event_parser::{Protocol, UnifiedEvent};
-use solana_streamer_sdk::streaming::yellowstone_grpc::{AccountFilter, TransactionFilter};
-use solana_streamer_sdk::streaming::YellowstoneGrpc;
 
-// Global static flag to ensure transaction is executed only once
 static ALREADY_EXECUTED: AtomicBool = AtomicBool::new(false);
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    println!("Subscribing to GRPC events...");
+    println!("Subscribing to GRPC events (sol-parser-sdk, is_cashback_coin from event)...");
 
-    let grpc = YellowstoneGrpc::new(
-        "https://solana-yellowstone-grpc.publicnode.com:443".to_string(),
-        None,
-    )?;
-
-    let callback = create_event_callback();
-    let protocols = vec![Protocol::PumpFun];
-    // Filter accounts
-    let account_include = vec![
-        PUMPFUN_PROGRAM_ID.to_string(), // Listen to pumpfun program ID
-    ];
-    let account_exclude = vec![];
-    let account_required = vec![];
-
-    // Listen to transaction data
-    let transaction_filter = TransactionFilter {
-        account_include: account_include.clone(),
-        account_exclude,
-        account_required,
+    let config = ClientConfig {
+        enable_metrics: false,
+        connection_timeout_ms: 10000,
+        request_timeout_ms: 30000,
+        enable_tls: true,
+        order_mode: OrderMode::Unordered,
+        ..Default::default()
     };
 
-    // Listen to account data belonging to owner programs -> account event monitoring
-    let account_filter = AccountFilter { account: vec![], owner: vec![], filters: vec![] };
+    let grpc_endpoint = std::env::var("GRPC_ENDPOINT")
+        .unwrap_or_else(|_| "https://solana-yellowstone-grpc.publicnode.com:443".to_string());
+    let grpc = YellowstoneGrpc::new_with_config(
+        grpc_endpoint,
+        std::env::var("GRPC_AUTH_TOKEN").ok(),
+        config,
+    )?;
 
-    // listen to specific event type
-    let event_type_filter =
-        EventTypeFilter { include: vec![EventType::PumpFunBuy, EventType::PumpFunSell] };
+    let protocols = vec![Protocol::PumpFun];
+    let transaction_filter = TransactionFilter::for_protocols(&protocols);
+    let account_filter = AccountFilter::for_protocols(&protocols);
+    let event_filter = EventTypeFilter::include_only(vec![
+        EventType::PumpFunBuy,
+        EventType::PumpFunSell,
+        EventType::PumpFunBuyExactSolIn,
+        EventType::PumpFunTrade,
+    ]);
 
-    grpc.subscribe_events_immediate(
-        protocols,
-        None,
-        vec![transaction_filter],
-        vec![account_filter],
-        Some(event_type_filter),
-        None,
-        callback,
-    )
-    .await?;
+    let queue = grpc
+        .subscribe_dex_events(vec![transaction_filter], vec![account_filter], Some(event_filter))
+        .await?;
+
+    loop {
+        if let Some(event) = queue.pop() {
+            let run = match &event {
+                DexEvent::PumpFunBuy(e) | DexEvent::PumpFunSell(e) | DexEvent::PumpFunBuyExactSolIn(e) => {
+                    if !ALREADY_EXECUTED.swap(true, Ordering::SeqCst) {
+                        Some(e.clone())
+                    } else {
+                        None
+                    }
+                }
+                DexEvent::PumpFunTrade(e) => {
+                    if !ALREADY_EXECUTED.swap(true, Ordering::SeqCst) {
+                        Some(e.clone())
+                    } else {
+                        None
+                    }
+                }
+                _ => None,
+            };
+            if let Some(e) = run {
+                tokio::spawn(async move {
+                    if let Err(err) = pumpfun_copy_trade_with_grpc(e).await {
+                        eprintln!("Error in copy trade: {:?}", err);
+                        std::process::exit(1);
+                    }
+                    std::process::exit(0);
+                });
+                break;
+            }
+        } else {
+            tokio::time::sleep(tokio::time::Duration::from_millis(5)).await;
+        }
+    }
 
     tokio::signal::ctrl_c().await?;
-
     Ok(())
 }
 
-/// Create an event callback function that handles different types of events
-fn create_event_callback() -> impl Fn(Box<dyn UnifiedEvent>) {
-    |event: Box<dyn UnifiedEvent>| {
-        match_event!(event, {
-            PumpFunTradeEvent => |e: PumpFunTradeEvent| {
-                // Test code, only test one transaction
-                if !ALREADY_EXECUTED.swap(true, Ordering::SeqCst) {
-                    let event_clone = e.clone();
-                    tokio::spawn(async move {
-                        if let Err(err) = pumpfun_copy_trade_with_grpc(event_clone).await {
-                            eprintln!("Error in copy trade: {:?}", err);
-                            std::process::exit(0);
-                        }
-                    });
-                }
-            },
-        });
-    }
-}
-
-/// Create SolanaTrade client
-/// Initializes a new SolanaTrade client with configuration
 async fn create_solana_trade_client() -> AnyResult<SolanaTrade> {
     println!("🚀 Initializing SolanaTrade client...");
     let payer = Keypair::from_base58_string("use_your_payer_keypair_here");
@@ -110,9 +109,10 @@ async fn create_solana_trade_client() -> AnyResult<SolanaTrade> {
     Ok(solana_trade)
 }
 
-/// PumpFun sniper trade
-/// This function demonstrates how to snipe a new token from a PumpFun trade event
-async fn pumpfun_copy_trade_with_grpc(trade_info: PumpFunTradeEvent) -> AnyResult<()> {
+/// PumpFun copy trade: use is_cashback_coin from gRPC event (sol-parser-sdk)
+async fn pumpfun_copy_trade_with_grpc(
+    trade_info: sol_parser_sdk::core::events::PumpFunTradeEvent,
+) -> AnyResult<()> {
     println!("Testing PumpFun trading...");
 
     let client = create_solana_trade_client().await?;
@@ -120,22 +120,19 @@ async fn pumpfun_copy_trade_with_grpc(trade_info: PumpFunTradeEvent) -> AnyResul
     let slippage_basis_points = Some(100);
     let recent_blockhash = client.infrastructure.rpc.get_latest_blockhash().await?;
 
-    // Setup nonce cache
     let nonce_account_str = Pubkey::from_str("use_your_nonce_account_here")?;
     let durable_nonce = fetch_nonce_info(&client.infrastructure.rpc, nonce_account_str).await;
 
     let gas_fee_strategy = sol_trade_sdk::common::GasFeeStrategy::new();
     gas_fee_strategy.set_global_fee_strategy(150000, 150000, 500000, 500000, 0.001, 0.001);
 
-    // Buy tokens
-    println!("Buying tokens from PumpFun...");
-    let buy_sol_amount = 100_000;
+    // is_cashback_coin from gRPC event (sol-parser-sdk parses it from trade event)
     let buy_params = sol_trade_sdk::TradeBuyParams {
         dex_type: DexType::PumpFun,
         input_token_type: TradeTokenType::SOL,
         mint: mint_pubkey,
-        input_token_amount: buy_sol_amount,
-        slippage_basis_points: slippage_basis_points,
+        input_token_amount: 100_000,
+        slippage_basis_points,
         recent_blockhash: Some(recent_blockhash),
         extension_params: DexParamEnum::PumpFun(PumpFunParams::from_trade(
             trade_info.bonding_curve,
@@ -150,21 +147,21 @@ async fn pumpfun_copy_trade_with_grpc(trade_info: PumpFunTradeEvent) -> AnyResul
             None,
             trade_info.fee_recipient,
             trade_info.token_program,
-            false, // is_cashback_coin: set from event/parser when available
+            trade_info.is_cashback_coin,
         )),
         address_lookup_table_account: None,
         wait_transaction_confirmed: true,
         create_input_token_ata: false,
         close_input_token_ata: false,
         create_mint_ata: true,
-        durable_nonce: durable_nonce,
+        durable_nonce,
         fixed_output_token_amount: None,
-        gas_fee_strategy: gas_fee_strategy,
+        gas_fee_strategy: gas_fee_strategy.clone(),
         simulate: false,
         use_exact_sol_amount: None,
+        grpc_recv_us: None,
     };
     client.buy(buy_params).await?;
 
-    // Exit program
     std::process::exit(0);
 }

examples/pumpfun_copy_trading/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 sol-trade-sdk = { path = "../.." }
-sol-parser-sdk = { path = "../../../sol-parser-sdk" }
+sol-parser-sdk = "0.2.2"
 solana-sdk = "3.0.0"
 solana-commitment-config = { version = "3.0.0", features = ["serde"] }
 tokio = { version = "1", features = ["full"] }

examples/pumpfun_copy_trading/src/main.rs

@@ -27,7 +27,6 @@ static ALREADY_EXECUTED: AtomicBool = AtomicBool::new(false);
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let _ = rustls::crypto::ring::default_provider().install_default();
     println!("PumpFun 跟单示例（sol-parser-sdk gRPC）...");
 
     let config = ClientConfig {
@@ -155,6 +154,7 @@ async fn pumpfun_copy_trade(
         gas_fee_strategy: gas_fee_strategy.clone(),
         simulate: false,
         use_exact_sol_amount: None,
+        grpc_recv_us: None,
     };
     client.buy(buy_params).await?;
 
@@ -202,6 +202,7 @@ async fn pumpfun_copy_trade(
         fixed_output_token_amount: None,
         gas_fee_strategy,
         simulate: false,
+        grpc_recv_us: None,
     };
     client.sell(sell_params).await?;
 

examples/pumpfun_sniper_trading/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2021"
 
 [dependencies]
 sol-trade-sdk = { path = "../.." }
-sol-parser-sdk = { path = "../../../sol-parser-sdk" }
+sol-parser-sdk = "0.2.2"
 solana-sdk = "3.0.0"
 solana-commitment-config = { version = "3.0.0", features = ["serde"] }
 tokio = { version = "1", features = ["full"] }

examples/pumpfun_sniper_trading/src/main.rs

@@ -27,7 +27,6 @@ static ALREADY_EXECUTED: AtomicBool = AtomicBool::new(false);
 
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let _ = rustls::crypto::ring::default_provider().install_default();
     println!("PumpFun 狙击示例（sol-parser-sdk gRPC）...");
 
     let config = ClientConfig {
@@ -147,6 +146,7 @@ async fn pumpfun_sniper_trade(
         gas_fee_strategy: gas_fee_strategy.clone(),
         simulate: false,
         use_exact_sol_amount: None,
+        grpc_recv_us: None,
     };
     client.buy(buy_params).await?;
 
@@ -188,6 +188,7 @@ async fn pumpfun_sniper_trade(
         fixed_output_token_amount: None,
         gas_fee_strategy,
         simulate: false,
+        grpc_recv_us: None,
     };
     client.sell(sell_params).await?;
 

examples/pumpswap_direct_trading/src/main.rs

@@ -44,6 +44,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         gas_fee_strategy: gas_fee_strategy.clone(),
         simulate: false,
         use_exact_sol_amount: None,
+        grpc_recv_us: None,
     };
     client.buy(buy_params).await?;
 
@@ -72,6 +73,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         create_output_token_ata: true,
         close_output_token_ata: true,
         close_mint_token_ata: false,
+        grpc_recv_us: None,
         durable_nonce: None,
         fixed_output_token_amount: None,
         gas_fee_strategy: gas_fee_strategy,

examples/pumpswap_trading/src/main.rs

@@ -1,6 +1,7 @@
 use sol_trade_sdk::common::fast_fn::get_associated_token_address_with_program_id_fast_use_seed;
 use sol_trade_sdk::common::TradeConfig;
 use sol_trade_sdk::TradeTokenType;
+use sol_trade_sdk::instruction::utils::pumpswap::fetch_pool;
 use sol_trade_sdk::{
     common::AnyResult,
     swqos::SwqosConfig,
@@ -136,7 +137,9 @@ async fn create_solana_trade_client() -> AnyResult<SolanaTrade> {
 }
 
 async fn pumpswap_trade_with_grpc_buy_event(trade_info: PumpSwapBuyEvent) -> AnyResult<()> {
-    let params = PumpSwapParams::new(
+    let client = create_solana_trade_client().await?;
+    let pool_data = fetch_pool(&client.infrastructure.rpc, &trade_info.pool).await?;
+    let params = PumpSwapParams::from_trade(
         trade_info.pool,
         trade_info.base_mint,
         trade_info.quote_mint,
@@ -149,6 +152,7 @@ async fn pumpswap_trade_with_grpc_buy_event(trade_info: PumpSwapBuyEvent) -> Any
         trade_info.base_token_program,
         trade_info.quote_token_program,
         trade_info.protocol_fee_recipient,
+        pool_data.is_cashback_coin,
     );
     let mint = if trade_info.base_mint == sol_trade_sdk::constants::USDC_TOKEN_ACCOUNT
         || trade_info.base_mint == sol_trade_sdk::constants::WSOL_TOKEN_ACCOUNT
@@ -157,12 +161,14 @@ async fn pumpswap_trade_with_grpc_buy_event(trade_info: PumpSwapBuyEvent) -> Any
     } else {
         trade_info.base_mint
     };
-    pumpswap_trade_with_grpc(mint, params).await?;
+    pumpswap_trade_with_grpc(&client, mint, params).await?;
     Ok(())
 }
 
 async fn pumpswap_trade_with_grpc_sell_event(trade_info: PumpSwapSellEvent) -> AnyResult<()> {
-    let params = PumpSwapParams::new(
+    let client = create_solana_trade_client().await?;
+    let pool_data = fetch_pool(&client.infrastructure.rpc, &trade_info.pool).await?;
+    let params = PumpSwapParams::from_trade(
         trade_info.pool,
         trade_info.base_mint,
         trade_info.quote_mint,
@@ -175,6 +181,7 @@ async fn pumpswap_trade_with_grpc_sell_event(trade_info: PumpSwapSellEvent) -> A
         trade_info.base_token_program,
         trade_info.quote_token_program,
         trade_info.protocol_fee_recipient,
+        pool_data.is_cashback_coin,
     );
     let mint = if trade_info.base_mint == sol_trade_sdk::constants::USDC_TOKEN_ACCOUNT
         || trade_info.base_mint == sol_trade_sdk::constants::WSOL_TOKEN_ACCOUNT
@@ -183,14 +190,16 @@ async fn pumpswap_trade_with_grpc_sell_event(trade_info: PumpSwapSellEvent) -> A
     } else {
         trade_info.base_mint
     };
-    pumpswap_trade_with_grpc(mint, params).await?;
+    pumpswap_trade_with_grpc(&client, mint, params).await?;
     Ok(())
 }
 
-async fn pumpswap_trade_with_grpc(mint_pubkey: Pubkey, params: PumpSwapParams) -> AnyResult<()> {
+async fn pumpswap_trade_with_grpc(
+    client: &SolanaTrade,
+    mint_pubkey: Pubkey,
+    params: PumpSwapParams,
+) -> AnyResult<()> {
     println!("Testing PumpSwap trading...");
-
-    let client = create_solana_trade_client().await?;
     let slippage_basis_points = Some(500);
     let recent_blockhash = client.infrastructure.rpc.get_latest_blockhash().await?;
 
@@ -221,6 +230,7 @@ async fn pumpswap_trade_with_grpc(mint_pubkey: Pubkey, params: PumpSwapParams) -
         gas_fee_strategy: gas_fee_strategy.clone(),
         simulate: false,
         use_exact_sol_amount: None,
+        grpc_recv_us: None,
     };
     client.buy(buy_params).await?;
 
@@ -255,6 +265,7 @@ async fn pumpswap_trade_with_grpc(mint_pubkey: Pubkey, params: PumpSwapParams) -
         fixed_output_token_amount: None,
         gas_fee_strategy: gas_fee_strategy,
         simulate: false,
+        grpc_recv_us: None,
     };
     client.sell(sell_params).await?;
 

examples/raydium_amm_v4_trading/src/main.rs

@@ -174,6 +174,7 @@ async fn raydium_amm_v4_copy_trade_with_grpc(trade_info: RaydiumAmmV4SwapEvent)
         gas_fee_strategy: gas_fee_strategy.clone(),
         simulate: false,
         use_exact_sol_amount: None,
+        grpc_recv_us: None,
     };
     client.buy(buy_params).await?;
 
@@ -212,6 +213,7 @@ async fn raydium_amm_v4_copy_trade_with_grpc(trade_info: RaydiumAmmV4SwapEvent)
         fixed_output_token_amount: None,
         gas_fee_strategy: gas_fee_strategy,
         simulate: false,
+        grpc_recv_us: None,
     };
     client.sell(sell_params).await?;
 

examples/raydium_cpmm_trading/src/main.rs

@@ -159,6 +159,7 @@ async fn raydium_cpmm_copy_trade_with_grpc(trade_info: RaydiumCpmmSwapEvent) ->
         gas_fee_strategy: gas_fee_strategy.clone(),
         simulate: false,
         use_exact_sol_amount: None,
+        grpc_recv_us: None,
     };
     client.buy(buy_params).await?;
 
@@ -194,6 +195,7 @@ async fn raydium_cpmm_copy_trade_with_grpc(trade_info: RaydiumCpmmSwapEvent) ->
         fixed_output_token_amount: None,
         gas_fee_strategy: gas_fee_strategy,
         simulate: false,
+        grpc_recv_us: None,
     };
     client.sell(sell_params).await?;
 

examples/seed_trading/src/main.rs

@@ -47,6 +47,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         gas_fee_strategy: gas_fee_strategy.clone(),
         simulate: false,
         use_exact_sol_amount: None,
+        grpc_recv_us: None,
     };
     client.buy(buy_params).await?;
 
@@ -87,6 +88,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         fixed_output_token_amount: None,
         gas_fee_strategy: gas_fee_strategy,
         simulate: false,
+        grpc_recv_us: None,
     };
     client.sell(sell_params).await?;
 

examples/shared_infrastructure/src/main.rs

@@ -31,6 +31,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         SwqosConfig::Default(rpc_url.clone()),
         SwqosConfig::Jito("your_uuid".to_string(), SwqosRegion::Frankfurt, None),
         SwqosConfig::Bloxroute("your_api_token".to_string(), SwqosRegion::Frankfurt, None),
+        SwqosConfig::Helius("".to_string(), SwqosRegion::Default, None, Some(true)),
     ];
 
     // Step 1: Create shared infrastructure (expensive, do once)

examples/trading_client/src/main.rs

@@ -49,6 +49,8 @@ async fn create_trading_client_simple() -> AnyResult<TradingClient> {
         SwqosConfig::Node1("your_api_token".to_string(), SwqosRegion::Frankfurt, None),
         SwqosConfig::BlockRazor("your_api_token".to_string(), SwqosRegion::Frankfurt, None),
         SwqosConfig::Astralane("your_api_token".to_string(), SwqosRegion::Frankfurt, None),
+        // Helius Sender: 4th param swqos_only Some(true) => min tip 0.000005 SOL; None => 0.0002 SOL
+        SwqosConfig::Helius("".to_string(), SwqosRegion::Default, None, Some(true)),
     ];
 
     // Optional: Customize WSOL ATA and Seed optimization settings

src/common/types.rs

@@ -76,6 +76,8 @@ pub struct TradeConfig {
     pub use_core_affinity: bool,
     /// Whether to output all SDK logs (timing, SWQOS submit/confirm, WSOL, blacklist, etc.). Default true.
     pub log_enabled: bool,
+    /// Whether to check minimum tip per SWQOS provider (filter out configs below min). Default false to save latency.
+    pub check_min_tip: bool,
 }
 
 impl TradeConfig {
@@ -96,6 +98,7 @@ impl TradeConfig {
             use_seed_optimize: true,           // default: use seed optimization
             use_core_affinity: true,           // default: pin parallel submit tasks to cores
             log_enabled: true,                 // default: enable all SDK logs
+            check_min_tip: false,              // default: skip min tip check to reduce latency
         }
     }
 
@@ -109,6 +112,12 @@ impl TradeConfig {
         self.use_seed_optimize = use_seed_optimize;
         self
     }
+
+    /// Set whether to check minimum tip per SWQOS (filter out configs below min). Default false for lower latency.
+    pub fn with_check_min_tip(mut self, check_min_tip: bool) -> Self {
+        self.check_min_tip = check_min_tip;
+        self
+    }
 }
 
 pub type SolanaRpcClient = solana_client::nonblocking::rpc_client::RpcClient;

src/constants/swqos.rs

@@ -13,6 +13,20 @@ pub const JITO_TIP_ACCOUNTS: &[Pubkey] = &[
     pubkey!("3AVi9Tg9Uo68tJfuvoKvqKNWKkC5wPdSSdeBnizKZ6jT"),
 ];
 
+/// Helius Sender tip accounts (fee recipient addresses).
+pub const HELIUS_TIP_ACCOUNTS: &[Pubkey] = &[
+    pubkey!("4ACfpUFoaSD9bfPdeu6DBt89gB6ENTeHBXCAi87NhDEE"),
+    pubkey!("D2L6yPZ2FmmmTKPgzaMKdhu6EWZcTpLy1Vhx8uvZe7NZ"),
+    pubkey!("9bnz4RShgq1hAnLnZbP8kbgBg1kEmcJBYQq3gQbmnSta"),
+    pubkey!("5VY91ws6B2hMmBFRsXkoAAdsPHBJwRfBht4DXox3xkwn"),
+    pubkey!("2nyhqdwKcJZR2vcqCyrYsaPVdAnFoJjiksCXJ7hfEYgD"),
+    pubkey!("2q5pghRs6arqVjRvT5gfgWfWcHWmw1ZuCzphgd5KfWGJ"),
+    pubkey!("wyvPkWjVZz1M8fHQnMMCDTQDbkManefNNhweYk5WkcF"),
+    pubkey!("3KCKozbAaF75qEU33jtzozcJ29yJuaLJTy2jFdzUY8bT"),
+    pubkey!("4vieeGHPYPG2MmyPRcYjdiDmmhN3ww7hsFNap8pVN3Ey"),
+    pubkey!("4TQLFNWK8AovT1gFvda5jfw2oJeRMKEmw7aH6MGBJ3or"),
+];
+
 pub const NEXTBLOCK_TIP_ACCOUNTS: &[Pubkey] = &[
     pubkey!("NextbLoCkVtMGcV47JzewQdvBpLqT9TxQFozQkN98pE"),
     pubkey!("NexTbLoCkWykbLuB1NkjXgFWkX9oAtcoagQegygXXA2"),
@@ -286,6 +300,19 @@ pub const SWQOS_ENDPOINTS_SPEEDLANDING: [&str; 8] = [
     "fra.speedlanding.trade:17778",
 ];
 
+/// Helius Sender: POST /fast, dual routing to validators and Jito. API key optional (custom TPS only).
+/// Region order: NewYork(EWR), Frankfurt, Amsterdam, SLC, Tokyo, London, LosAngeles(SG), Default(Global).
+pub const SWQOS_ENDPOINTS_HELIUS: [&str; 8] = [
+    "http://ewr-sender.helius-rpc.com/fast",
+    "http://fra-sender.helius-rpc.com/fast",
+    "http://ams-sender.helius-rpc.com/fast",
+    "http://slc-sender.helius-rpc.com/fast",
+    "http://tyo-sender.helius-rpc.com/fast",
+    "http://lon-sender.helius-rpc.com/fast",
+    "http://sg-sender.helius-rpc.com/fast",
+    "https://sender.helius-rpc.com/fast",
+];
+
 pub const SWQOS_MIN_TIP_DEFAULT: f64 = 0.00001; // 其它SWQOS默认最低小费
 pub const SWQOS_MIN_TIP_JITO: f64 = 0.00001;
 pub const SWQOS_MIN_TIP_NEXTBLOCK: f64 = 0.001;
@@ -300,3 +327,7 @@ pub const SWQOS_MIN_TIP_STELLIUM: f64 = 0.0001; // Stellium requires minimum 0.0
 pub const SWQOS_MIN_TIP_LIGHTSPEED: f64 = 0.0001; // Lightspeed requires minimum 0.001 SOL tip
 pub const SWQOS_MIN_TIP_SOYAS: f64 = 0.001; // Soyas requires minimum 0.001 SOL tip
 pub const SWQOS_MIN_TIP_SPEEDLANDING: f64 = 0.001; // Speedlanding requires minimum 0.001 SOL tip
+/// Helius Sender: 0.0002 SOL when not swqos_only; use SWQOS_MIN_TIP_HELIUS_SWQOS_ONLY when swqos_only=true.
+pub const SWQOS_MIN_TIP_HELIUS: f64 = 0.0002;
+/// Helius Sender with swqos_only: minimum 0.000005 SOL (much lower tip allowed).
+pub const SWQOS_MIN_TIP_HELIUS_SWQOS_ONLY: f64 = 0.000005;

src/lib.rs

@@ -157,6 +157,8 @@ pub struct TradingClient {
     pub use_core_affinity: bool,
     /// Whether to output all SDK logs (from TradeConfig.log_enabled).
     pub log_enabled: bool,
+    /// Whether to check minimum tip per SWQOS (from TradeConfig.check_min_tip). Default false for lower latency.
+    pub check_min_tip: bool,
 }
 
 static INSTANCE: Mutex<Option<Arc<TradingClient>>> = Mutex::new(None);
@@ -173,6 +175,7 @@ impl Clone for TradingClient {
             use_seed_optimize: self.use_seed_optimize,
             use_core_affinity: self.use_core_affinity,
             log_enabled: self.log_enabled,
+            check_min_tip: self.check_min_tip,
         }
     }
 }
@@ -301,6 +304,7 @@ impl TradingClient {
             use_seed_optimize,
             use_core_affinity: true,
             log_enabled: true,
+            check_min_tip: false,
         }
     }
 
@@ -340,6 +344,7 @@ impl TradingClient {
             use_seed_optimize,
             use_core_affinity: true,
             log_enabled: true,
+            check_min_tip: false,
         }
     }
 
@@ -503,6 +508,7 @@ impl TradingClient {
             use_seed_optimize: trade_config.use_seed_optimize,
             use_core_affinity: trade_config.use_core_affinity,
             log_enabled: trade_config.log_enabled,
+            check_min_tip: trade_config.check_min_tip,
         };
 
         let mut current = INSTANCE.lock();
@@ -636,6 +642,7 @@ impl TradingClient {
             simulate: params.simulate,
             log_enabled: self.log_enabled,
             use_core_affinity: self.use_core_affinity,
+            check_min_tip: self.check_min_tip,
             grpc_recv_us: params.grpc_recv_us,
             use_exact_sol_amount: params.use_exact_sol_amount,
         };
@@ -732,6 +739,7 @@ impl TradingClient {
             simulate: params.simulate,
             log_enabled: self.log_enabled,
             use_core_affinity: self.use_core_affinity,
+            check_min_tip: self.check_min_tip,
             grpc_recv_us: params.grpc_recv_us,
             use_exact_sol_amount: None,
         };

src/swqos/helius.rs

@@ -0,0 +1,220 @@
+//! Helius Sender SWQOS client.
+//!
+//! Ultra-low latency transaction submission with dual routing to validators and Jito.
+//! All transactions must include tips, priority fees, and skip preflight.
+//! - Without swqos_only: minimum tip 0.0002 SOL.
+//! - With swqos_only=true: minimum tip 0.000005 SOL (much lower, benefit of Helius).
+//! API: POST {endpoint}/fast with JSON-RPC sendTransaction.
+//! Optional query: api-key (custom TPS only), swqos_only (SWQOS-only routing, lower min tip).
+
+use crate::swqos::common::{
+    default_http_client_builder, poll_transaction_confirmation, serialize_transaction_and_encode,
+};
+use anyhow::Result;
+use rand::seq::IndexedRandom;
+use reqwest::Client;
+use serde_json::json;
+use solana_sdk::transaction::VersionedTransaction;
+use solana_transaction_status::UiTransactionEncoding;
+use std::sync::Arc;
+use std::time::Instant;
+
+use crate::common::SolanaRpcClient;
+use crate::constants::swqos::{HELIUS_TIP_ACCOUNTS, SWQOS_MIN_TIP_HELIUS, SWQOS_MIN_TIP_HELIUS_SWQOS_ONLY};
+use crate::swqos::{SwqosClientTrait, SwqosType, TradeType};
+
+#[derive(Clone)]
+pub struct HeliusClient {
+    /// Cached full URL with query params (auth/swqos_only) to avoid per-request allocation.
+    pub submit_url: String,
+    pub rpc_client: Arc<SolanaRpcClient>,
+    pub http_client: Client,
+    /// When true, min_tip_sol() returns 0.000005; else 0.0002.
+    swqos_only: bool,
+}
+
+impl HeliusClient {
+    pub fn new(
+        rpc_url: String,
+        endpoint: String,
+        api_key: Option<String>,
+        swqos_only: bool,
+    ) -> Self {
+        let rpc_client = SolanaRpcClient::new(rpc_url);
+        let http_client = default_http_client_builder().build().unwrap();
+        let submit_url = Self::build_submit_url(&endpoint, api_key.as_deref(), swqos_only);
+        Self {
+            submit_url,
+            rpc_client: Arc::new(rpc_client),
+            http_client,
+            swqos_only,
+        }
+    }
+
+    /// Build URL once at construction; no per-request allocation.
+    #[inline]
+    fn build_submit_url(endpoint: &str, api_key: Option<&str>, swqos_only: bool) -> String {
+        let mut url = endpoint.to_string();
+        let mut has_query = endpoint.contains('?');
+        if let Some(key) = api_key {
+            if !key.is_empty() {
+                url.push_str(if has_query { "&" } else { "?" });
+                url.push_str("api-key=");
+                url.push_str(key);
+                has_query = true;
+            }
+        }
+        if swqos_only {
+            url.push_str(if has_query { "&" } else { "?" });
+            url.push_str("swqos_only=true");
+        }
+        url
+    }
+
+    pub async fn send_transaction(
+        &self,
+        trade_type: TradeType,
+        transaction: &VersionedTransaction,
+        wait_confirmation: bool,
+    ) -> Result<()> {
+        let start_time = Instant::now();
+        let (content, signature) =
+            serialize_transaction_and_encode(transaction, UiTransactionEncoding::Base64)?;
+
+        let request_body = serde_json::to_string(&json!({
+            "jsonrpc": "2.0",
+            "id": "1",
+            "method": "sendTransaction",
+            "params": [
+                content,
+                {
+                    "encoding": "base64",
+                    "skipPreflight": true,
+                    "maxRetries": 0
+                }
+            ]
+        }))?;
+
+        let response = self
+            .http_client
+            .post(&self.submit_url)
+            .body(request_body)
+            .header("Content-Type", "application/json")
+            .send()
+            .await?;
+
+        let status = response.status();
+        let response_text = response.text().await?;
+
+        if !status.is_success() {
+            if crate::common::sdk_log::sdk_log_enabled() {
+                eprintln!(
+                    " [helius] {} submission failed status={} body={}",
+                    trade_type, status, response_text
+                );
+            }
+            return Err(anyhow::anyhow!(
+                "Helius Sender failed: status={} body={}",
+                status,
+                response_text
+            ));
+        }
+
+        if let Ok(response_json) = serde_json::from_str::<serde_json::Value>(&response_text) {
+            if response_json.get("error").is_some() {
+                let err_msg = response_json["error"]
+                    .get("message")
+                    .and_then(|v| v.as_str())
+                    .unwrap_or("unknown");
+                if crate::common::sdk_log::sdk_log_enabled() {
+                    eprintln!(" [helius] {} submission error: {}", trade_type, err_msg);
+                }
+                return Err(anyhow::anyhow!("Helius Sender error: {}", err_msg));
+            }
+            if response_json.get("result").is_some() && crate::common::sdk_log::sdk_log_enabled() {
+                println!(
+                    " [helius] {} submitted: {:?}",
+                    trade_type,
+                    start_time.elapsed()
+                );
+            }
+        } else if crate::common::sdk_log::sdk_log_enabled() {
+            eprintln!(
+                " [helius] {} submission failed: {:?}",
+                trade_type, response_text
+            );
+        }
+
+        match poll_transaction_confirmation(&self.rpc_client, signature, wait_confirmation).await {
+            Ok(_) => (),
+            Err(e) => {
+                if crate::common::sdk_log::sdk_log_enabled() {
+                    eprintln!(
+                        " [helius] {} confirmation failed: {:?}",
+                        trade_type,
+                        start_time.elapsed()
+                    );
+                }
+                return Err(e);
+            }
+        }
+        if wait_confirmation && crate::common::sdk_log::sdk_log_enabled() {
+            println!(
+                " signature: {:?}",
+                signature
+            );
+            println!(
+                " [helius] {} confirmed: {:?}",
+                trade_type,
+                start_time.elapsed()
+            );
+        }
+        Ok(())
+    }
+}
+
+#[async_trait::async_trait]
+impl SwqosClientTrait for HeliusClient {
+    async fn send_transaction(
+        &self,
+        trade_type: TradeType,
+        transaction: &VersionedTransaction,
+        wait_confirmation: bool,
+    ) -> Result<()> {
+        HeliusClient::send_transaction(self, trade_type, transaction, wait_confirmation).await
+    }
+
+    async fn send_transactions(
+        &self,
+        trade_type: TradeType,
+        transactions: &Vec<VersionedTransaction>,
+        wait_confirmation: bool,
+    ) -> Result<()> {
+        for transaction in transactions {
+            self.send_transaction(trade_type, transaction, wait_confirmation)
+                .await?;
+        }
+        Ok(())
+    }
+
+    fn get_tip_account(&self) -> Result<String> {
+        let tip_account = *HELIUS_TIP_ACCOUNTS
+            .choose(&mut rand::rng())
+            .or_else(|| HELIUS_TIP_ACCOUNTS.first())
+            .unwrap();
+        Ok(tip_account.to_string())
+    }
+
+    fn get_swqos_type(&self) -> SwqosType {
+        SwqosType::Helius
+    }
+
+    #[inline(always)]
+    fn min_tip_sol(&self) -> f64 {
+        if self.swqos_only {
+            SWQOS_MIN_TIP_HELIUS_SWQOS_ONLY
+        } else {
+            SWQOS_MIN_TIP_HELIUS
+        }
+    }
+}

src/swqos/mod.rs

@@ -14,6 +14,7 @@ pub mod stellium;
 pub mod lightspeed;
 pub mod soyas;
 pub mod speedlanding;
+pub mod helius;
 
 use std::sync::Arc;
 
@@ -37,7 +38,23 @@ use crate::{
         SWQOS_ENDPOINTS_ASTRALANE,
         SWQOS_ENDPOINTS_STELLIUM,
         SWQOS_ENDPOINTS_SOYAS,
-        SWQOS_ENDPOINTS_SPEEDLANDING
+        SWQOS_ENDPOINTS_SPEEDLANDING,
+        SWQOS_ENDPOINTS_HELIUS,
+        SWQOS_MIN_TIP_DEFAULT,
+        SWQOS_MIN_TIP_JITO,
+        SWQOS_MIN_TIP_NEXTBLOCK,
+        SWQOS_MIN_TIP_ZERO_SLOT,
+        SWQOS_MIN_TIP_TEMPORAL,
+        SWQOS_MIN_TIP_BLOXROUTE,
+        SWQOS_MIN_TIP_NODE1,
+        SWQOS_MIN_TIP_FLASHBLOCK,
+        SWQOS_MIN_TIP_BLOCKRAZOR,
+        SWQOS_MIN_TIP_ASTRALANE,
+        SWQOS_MIN_TIP_STELLIUM,
+        SWQOS_MIN_TIP_LIGHTSPEED,
+        SWQOS_MIN_TIP_SOYAS,
+        SWQOS_MIN_TIP_SPEEDLANDING,
+        SWQOS_MIN_TIP_HELIUS,
     },
     swqos::{
         bloxroute::BloxrouteClient,
@@ -54,6 +71,7 @@ use crate::{
         lightspeed::LightspeedClient,
         soyas::SoyasClient,
         speedlanding::SpeedlandingClient,
+        helius::HeliusClient,
     }
 };
 
@@ -103,6 +121,7 @@ pub enum SwqosType {
     Lightspeed,
     Soyas,
     Speedlanding,
+    Helius,
     Default,
 }
 
@@ -121,6 +140,8 @@ impl SwqosType {
             Self::Stellium,
             Self::Lightspeed,
             Self::Soyas,
+            Self::Speedlanding,
+            Self::Helius,
             Self::Default,
         ]
     }
@@ -134,6 +155,27 @@ pub trait SwqosClientTrait {
     async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>, wait_confirmation: bool) -> Result<()>;
     fn get_tip_account(&self) -> Result<String>;
     fn get_swqos_type(&self) -> SwqosType;
+    /// Minimum tip in SOL required by this provider. Helius returns lower value when swqos_only is true.
+    #[inline]
+    fn min_tip_sol(&self) -> f64 {
+        match self.get_swqos_type() {
+            SwqosType::Jito => SWQOS_MIN_TIP_JITO,
+            SwqosType::NextBlock => SWQOS_MIN_TIP_NEXTBLOCK,
+            SwqosType::ZeroSlot => SWQOS_MIN_TIP_ZERO_SLOT,
+            SwqosType::Temporal => SWQOS_MIN_TIP_TEMPORAL,
+            SwqosType::Bloxroute => SWQOS_MIN_TIP_BLOXROUTE,
+            SwqosType::Node1 => SWQOS_MIN_TIP_NODE1,
+            SwqosType::FlashBlock => SWQOS_MIN_TIP_FLASHBLOCK,
+            SwqosType::BlockRazor => SWQOS_MIN_TIP_BLOCKRAZOR,
+            SwqosType::Astralane => SWQOS_MIN_TIP_ASTRALANE,
+            SwqosType::Stellium => SWQOS_MIN_TIP_STELLIUM,
+            SwqosType::Lightspeed => SWQOS_MIN_TIP_LIGHTSPEED,
+            SwqosType::Soyas => SWQOS_MIN_TIP_SOYAS,
+            SwqosType::Speedlanding => SWQOS_MIN_TIP_SPEEDLANDING,
+            SwqosType::Helius => SWQOS_MIN_TIP_HELIUS,
+            SwqosType::Default => SWQOS_MIN_TIP_DEFAULT,
+        }
+    }
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
@@ -180,6 +222,9 @@ pub enum SwqosConfig {
     /// To apply for an API key, please contact -> https://t.me/speedlanding_bot?start=0xzero
     /// Minimum tip: 0.001 SOL
     Speedlanding(String, SwqosRegion, Option<String>),
+    /// Helius Sender: dual routing to validators and Jito. API key optional (custom TPS only).
+    /// (api_key, region, custom_url, swqos_only). swqos_only: None => false (min tip 0.0002 SOL); Some(true) => SWQOS-only (min tip 0.000005 SOL, much lower).
+    Helius(String, SwqosRegion, Option<String>, Option<bool>),
 }
 
 impl SwqosConfig {
@@ -199,6 +244,7 @@ impl SwqosConfig {
             SwqosConfig::Lightspeed(_, _, _) => SwqosType::Lightspeed,
             SwqosConfig::Soyas(_, _, _) => SwqosType::Soyas,
             SwqosConfig::Speedlanding(_, _, _) => SwqosType::Speedlanding,
+            SwqosConfig::Helius(_, _, _, _) => SwqosType::Helius,
         }
     }
 
@@ -226,6 +272,7 @@ impl SwqosConfig {
             SwqosType::Lightspeed => "".to_string(), // Lightspeed requires custom URL with api_key
             SwqosType::Soyas => SWQOS_ENDPOINTS_SOYAS[region as usize].to_string(),
             SwqosType::Speedlanding => SWQOS_ENDPOINTS_SPEEDLANDING[region as usize].to_string(),
+            SwqosType::Helius => SWQOS_ENDPOINTS_HELIUS[region as usize].to_string(),
             SwqosType::Default => "".to_string(),
         }
     }
@@ -349,6 +396,18 @@ impl SwqosConfig {
                 ).await?;
                 Ok(Arc::new(speedlanding_client))
             },
+            SwqosConfig::Helius(api_key, region, url, swqos_only) => {
+                let swqos_only = swqos_only.unwrap_or(false);
+                let endpoint = SwqosConfig::get_endpoint(SwqosType::Helius, region, url.clone());
+                let api_key_opt = if api_key.is_empty() { None } else { Some(api_key.clone()) };
+                let helius_client = HeliusClient::new(
+                    rpc_url.clone(),
+                    endpoint,
+                    api_key_opt,
+                    swqos_only,
+                );
+                Ok(Arc::new(helius_client))
+            },
             SwqosConfig::Default(endpoint) => {
                 let rpc = SolanaRpcClient::new_with_commitment(
                     endpoint,

src/trading/core/async_executor.rs

@@ -15,22 +15,6 @@ use crate::{
     common::{GasFeeStrategy, SolanaRpcClient},
     swqos::{SwqosClient, SwqosType, TradeType},
     trading::{common::build_transaction, MiddlewareManager},
-    constants::swqos::{
-        SWQOS_MIN_TIP_DEFAULT,
-        SWQOS_MIN_TIP_JITO,
-        SWQOS_MIN_TIP_NEXTBLOCK,
-        SWQOS_MIN_TIP_ZERO_SLOT,
-        SWQOS_MIN_TIP_TEMPORAL,
-        SWQOS_MIN_TIP_BLOXROUTE,
-        SWQOS_MIN_TIP_NODE1,
-        SWQOS_MIN_TIP_FLASHBLOCK,
-        SWQOS_MIN_TIP_BLOCKRAZOR,
-        SWQOS_MIN_TIP_ASTRALANE,
-        SWQOS_MIN_TIP_STELLIUM,
-        SWQOS_MIN_TIP_LIGHTSPEED,
-        SWQOS_MIN_TIP_SOYAS,
-        SWQOS_MIN_TIP_SPEEDLANDING
-    },
 };
 
 #[repr(align(64))]
@@ -220,6 +204,7 @@ pub async fn execute_parallel(
     with_tip: bool,
     gas_fee_strategy: GasFeeStrategy,
     use_core_affinity: bool,
+    check_min_tip: bool,
 ) -> Result<(bool, Vec<Signature>, Option<anyhow::Error>)> {
     let _exec_start = Instant::now();
 
@@ -247,33 +232,23 @@ pub async fn execute_parallel(
             with_tip || matches!(swqos_client.get_swqos_type(), SwqosType::Default)
         })
         .flat_map(|(i, swqos_client)| {
+            let swqos_type = swqos_client.get_swqos_type();
             let gas_fee_strategy_configs = gas_fee_strategy.get_strategies(if is_buy {
                 TradeType::Buy
             } else {
                 TradeType::Sell
             });
+            let check_tip = with_tip && !matches!(swqos_type, SwqosType::Default) && check_min_tip;
+            let min_tip = if check_tip {
+                swqos_client.min_tip_sol()
+            } else {
+                0.0
+            };
             gas_fee_strategy_configs
                 .into_iter()
-                .filter(|config| config.0.eq(&swqos_client.get_swqos_type()))
-                .filter(|config| {
-                    // When tip required and not Default, filter by provider minimum tip
-                    if with_tip && !matches!(config.0, SwqosType::Default) {
-                        let min_tip = match config.0 {
-                            SwqosType::Jito => SWQOS_MIN_TIP_JITO,
-                            SwqosType::NextBlock => SWQOS_MIN_TIP_NEXTBLOCK,
-                            SwqosType::ZeroSlot => SWQOS_MIN_TIP_ZERO_SLOT,
-                            SwqosType::Temporal => SWQOS_MIN_TIP_TEMPORAL,
-                            SwqosType::Bloxroute => SWQOS_MIN_TIP_BLOXROUTE,
-                            SwqosType::Node1 => SWQOS_MIN_TIP_NODE1,
-                            SwqosType::FlashBlock => SWQOS_MIN_TIP_FLASHBLOCK,
-                            SwqosType::BlockRazor => SWQOS_MIN_TIP_BLOCKRAZOR,
-                            SwqosType::Astralane => SWQOS_MIN_TIP_ASTRALANE,
-                            SwqosType::Stellium => SWQOS_MIN_TIP_STELLIUM,
-                            SwqosType::Lightspeed => SWQOS_MIN_TIP_LIGHTSPEED,
-                            SwqosType::Soyas => SWQOS_MIN_TIP_SOYAS,
-                            SwqosType::Speedlanding => SWQOS_MIN_TIP_SPEEDLANDING,
-                            SwqosType::Default => SWQOS_MIN_TIP_DEFAULT,
-                        };
+                .filter(move |config| config.0 == swqos_type)
+                .filter(move |config| {
+                    if check_tip {
                         if config.2.tip < min_tip && crate::common::sdk_log::sdk_log_enabled() {
                             println!(
                                 "⚠️ Config filtered: {:?} tip {} is below minimum required {}",

src/trading/core/executor.rs

@@ -129,6 +129,7 @@ impl TradeExecutor for GenericTradeExecutor {
             if is_buy { true } else { params.with_tip },
             params.gas_fee_strategy,
             params.use_core_affinity,
+            params.check_min_tip,
         )
         .await;
         let send_elapsed = send_start.map(|s| s.elapsed()).unwrap_or(Duration::ZERO);

src/trading/core/params.rs

@@ -71,6 +71,8 @@ pub struct SwapParams {
     pub log_enabled: bool,
     /// Whether to pin parallel submit tasks to cores (from TradeConfig.use_core_affinity).
     pub use_core_affinity: bool,
+    /// Whether to check minimum tip per SWQOS (from TradeConfig.check_min_tip). When false, skip filter for lower latency.
+    pub check_min_tip: bool,
     /// Optional event receive time in microseconds (same scale as sol-parser-sdk clock::now_micros). Used as timing start when log_enabled.
     pub grpc_recv_us: Option<i64>,
     /// Use exact SOL amount instructions (buy_exact_sol_in for PumpFun, buy_exact_quote_in for PumpSwap).
@@ -276,6 +278,7 @@ impl PumpSwapParams {
         base_token_program: Pubkey,
         quote_token_program: Pubkey,
         fee_recipient: Pubkey,
+        is_cashback_coin: bool,
     ) -> Self {
         let is_mayhem_mode = fee_recipient == MAYHEM_FEE_RECIPIENT_SWAP;
         Self {
@@ -291,10 +294,51 @@ impl PumpSwapParams {
             base_token_program,
             quote_token_program,
             is_mayhem_mode,
-            is_cashback_coin: false,
+            is_cashback_coin,
         }
     }
 
+    /// Fast-path constructor for building PumpSwap parameters directly from decoded
+    /// trade/event data and the accompanying instruction accounts, avoiding RPC
+    /// lookups and associated latency. Token program IDs should be sourced from
+    /// the instruction accounts themselves to respect Token Program vs Token-2022
+    /// differences.
+    ///
+    /// When building from event/parser (e.g. sol-parser-sdk), pass `is_cashback_coin`
+    /// from the event so that buy/sell instructions include the correct remaining
+    /// accounts for cashback.
+    pub fn from_trade(
+        pool: Pubkey,
+        base_mint: Pubkey,
+        quote_mint: Pubkey,
+        pool_base_token_account: Pubkey,
+        pool_quote_token_account: Pubkey,
+        pool_base_token_reserves: u64,
+        pool_quote_token_reserves: u64,
+        coin_creator_vault_ata: Pubkey,
+        coin_creator_vault_authority: Pubkey,
+        base_token_program: Pubkey,
+        quote_token_program: Pubkey,
+        fee_recipient: Pubkey,
+        is_cashback_coin: bool,
+    ) -> Self {
+        Self::new(
+            pool,
+            base_mint,
+            quote_mint,
+            pool_base_token_account,
+            pool_quote_token_account,
+            pool_base_token_reserves,
+            pool_quote_token_reserves,
+            coin_creator_vault_ata,
+            coin_creator_vault_authority,
+            base_token_program,
+            quote_token_program,
+            fee_recipient,
+            is_cashback_coin,
+        )
+    }
+
     pub async fn from_mint_by_rpc(
         rpc: &SolanaRpcClient,
         mint: &Pubkey,