gavindiaz/sol-trade-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: Helius Sender SWQOS support and global check_min_tip option

Browse Source 
- Add Helius Sender client (helius.rs) with dual routing and swqos_only mode
- Helius min tip: 0.0002 SOL default, 0.000005 SOL when swqos_only=true
- Add TradeConfig.check_min_tip (default false) to skip min-tip validation for lower latency
- Thread check_min_tip through SwapParams and execute_parallel; only call min_tip_sol when enabled
- Add SWQOS_ENDPOINTS_HELIUS and HELIUS_TIP_ACCOUNTS in constants
- Extend SwqosConfig/SwqosType for Helius; add Helius to get_endpoint and get_swqos_client
- Update trading_client, shared_infrastructure and middleware_system examples

Made-with: Cursor
This commit is contained in:
Wood
2026-02-27 15:00:13 +08:00
parent 82438479d3
commit 0cd276d6cb
11 changed files with 351 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/swqos/helius.rs
+220
View File
@@ -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
+60 -1
View File
@@ -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,