add bloxroute

src/swqos/bloxroute.rs

@@ -0,0 +1,140 @@
+use crate::swqos::common::{poll_transaction_confirmation, serialize_transaction_and_encode, FormatBase64VersionedTransaction};
+use rand::seq::IndexedRandom;
+use reqwest::Client;
+use std::{sync::Arc, time::Instant};
+
+use std::time::Duration;
+use solana_transaction_status::UiTransactionEncoding;
+
+use anyhow::Result;
+use solana_sdk::transaction::VersionedTransaction;
+use crate::swqos::{SwqosType, TradeType};
+use crate::swqos::SwqosClientTrait;
+
+use crate::{common::SolanaRpcClient, constants::swqos::BLOX_TIP_ACCOUNTS};
+
+
+#[derive(Clone)]
+pub struct BloxrouteClient {
+    pub endpoint: String,
+    pub auth_token: String,
+    pub rpc_client: Arc<SolanaRpcClient>,
+    pub http_client: Client,
+}
+
+#[async_trait::async_trait]
+impl SwqosClientTrait for BloxrouteClient {
+    async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction) -> Result<()> {
+        self.send_transaction(trade_type, transaction).await
+    }
+
+    async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>) -> Result<()> {
+        self.send_transactions(trade_type, transactions).await
+    }
+
+    fn get_tip_account(&self) -> Result<String> {
+        let tip_account = *BLOX_TIP_ACCOUNTS.choose(&mut rand::rng()).or_else(|| BLOX_TIP_ACCOUNTS.first()).unwrap();
+        Ok(tip_account.to_string())
+    }
+
+    fn get_swqos_type(&self) -> SwqosType {
+        SwqosType::Bloxroute
+    }
+}
+
+impl BloxrouteClient {
+    pub fn new(rpc_url: String, endpoint: String, auth_token: String) -> Self {
+        let rpc_client = SolanaRpcClient::new(rpc_url);
+        let http_client = Client::builder()
+            .pool_idle_timeout(Duration::from_secs(60))
+            .pool_max_idle_per_host(64)
+            .tcp_keepalive(Some(Duration::from_secs(1200)))
+            .http2_keep_alive_interval(Duration::from_secs(15))
+            .timeout(Duration::from_secs(10))
+            .connect_timeout(Duration::from_secs(5))
+            .build()
+            .unwrap();
+        Self { rpc_client: Arc::new(rpc_client), endpoint, auth_token, http_client }
+    }
+
+    pub async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction) -> Result<()> {
+        let start_time = Instant::now();
+        let (content, signature) = serialize_transaction_and_encode(transaction, UiTransactionEncoding::Base64).await?;
+        println!(" 交易编码base64: {:?}", start_time.elapsed());
+
+        let body = serde_json::json!({
+            "transaction": {
+                "content": content,
+            },
+            "frontRunningProtection": false,
+            "useStakedRPCs": true,
+        });
+
+        let endpoint = format!("{}/api/v2/submit", self.endpoint);
+        let response_text = self.http_client.post(&endpoint)
+            .body(body.to_string())
+            .header("Content-Type", "application/json")
+            .header("Authorization", self.auth_token.clone())
+            .send()
+            .await?
+            .text()
+            .await?;
+
+        // 5. 用 `serde_json::from_str()` 解析 JSON，减少 `.json().await?` 额外等待
+        if let Ok(response_json) = serde_json::from_str::<serde_json::Value>(&response_text) {
+            if response_json.get("result").is_some() {
+                println!(" bloxroute{}提交: {:?}", trade_type, start_time.elapsed());
+            } else if let Some(_error) = response_json.get("error") {
+                eprintln!(" bloxroute{}提交失败: {:?}", trade_type, _error);
+            }
+        }
+
+        let start_time: Instant = Instant::now();
+        match poll_transaction_confirmation(&self.rpc_client, signature).await {
+            Ok(_) => (),
+            Err(_) => (),
+        }
+
+        println!(" bloxroute{}确认: {:?}", trade_type, start_time.elapsed());
+
+        Ok(())
+    }
+
+    pub async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>) -> Result<()> {
+        let start_time = Instant::now();
+        println!(" 交易编码base64: {:?}", start_time.elapsed());
+
+        let body = serde_json::json!({
+            "entries":  transactions
+                .iter()
+                .map(|tx| {
+                    serde_json::json!({
+                        "transaction": {
+                            "content": tx.to_base64_string(),
+                        },
+                    })
+                })
+                .collect::<Vec<_>>(),
+        });
+
+        let endpoint = format!("{}/api/v2/submit-batch", self.endpoint);
+        let response_text = self.http_client.post(&endpoint)
+            .body(body.to_string())
+            .header("Content-Type", "application/json")
+            .header("Authorization", self.auth_token.clone())
+            .send()
+            .await?
+            .text()
+            .await?;
+
+        if let Ok(response_json) = serde_json::from_str::<serde_json::Value>(&response_text) {
+            if response_json.get("result").is_some() {
+                println!(" bloxroute{}提交: {:?}", trade_type, start_time.elapsed());
+            } else if let Some(_error) = response_json.get("error") {
+                eprintln!(" bloxroute{}提交失败: {:?}", trade_type, _error);
+            }
+        }
+
+        Ok(())
+    }
+}

src/swqos/common.rs

@@ -14,59 +14,6 @@ use base64::engine::general_purpose::{self, STANDARD};
 use reqwest::Client;
 use solana_sdk::transaction::VersionedTransaction;
 
-// NewYork,
-// Frankfurt,
-// Amsterdam,
-// SLC,
-// Tokyo,
-// London,
-// LosAngeles,
-// Default,
-
-pub const SWQOS_ENDPOINTS_JITO: [&str; 8] = [
-    "https://ny.mainnet.block-engine.jito.wtf", 
-    "https://frankfurt.mainnet.block-engine.jito.wtf",
-    "https://ams.block-engine.jito.wtf",
-    "https://slc.mainnet.block-engine.jito.wtf",
-    "https://tokyo.mainnet.block-engine.jito.wtf",
-    "https://london.mainnet.block-engine.jito.wtf",
-    "https://ny.mainnet.block-engine.jito.wtf", 
-    "https://mainnet.block-engine.jito.wtf",
-];
-
-pub const SWQOS_ENDPOINTS_NEXTBLOCK: [&str; 8] = [
-    "http://ny.nextblock.io",
-    "http://fra.nextblock.io",
-    "http://slc.nextblock.io",
-    "http://slc.nextblock.io",
-    "http://tokyo.nextblock.io",  
-    "http://london.nextblock.io", 
-    "http://ny.nextblock.io",
-    "http://fra.nextblock.io",
-];
-
-pub const SWQOS_ENDPOINTS_ZERO_SLOT: [&str; 8] = [
-    "http://ny.0slot.trade",
-    "http://de.0slot.trade",
-    "http://ams.0slot.trade",
-    "http://ams.0slot.trade",
-    "http://jp.0slot.trade",
-    "http://jp.0slot.trade",
-    "http://la.0slot.trade",
-    "http://de.0slot.trade",
-];
-
-pub const SWQOS_ENDPOINTS_TEMPORAL: [&str; 8] = [
-    "http://ewr1.nozomi.temporal.xyz",
-    "http://fra2.nozomi.temporal.xyz",
-    "http://ams1.nozomi.temporal.xyz",
-    "http://ams1.nozomi.temporal.xyz",
-    "http://tyo1.nozomi.temporal.xyz",
-    "http://sgp1.nozomi.temporal.xyz",
-    "http://pit1.nozomi.temporal.xyz",
-    "http://fra2.nozomi.temporal.xyz",
-];
-
 pub trait FormatBase64VersionedTransaction {
     fn to_base64_string(&self) -> String;
 }

src/swqos/jito.rs

@@ -13,7 +13,7 @@ use solana_sdk::transaction::VersionedTransaction;
 use crate::swqos::{SwqosType, TradeType};
 use crate::swqos::SwqosClientTrait;
 
-use crate::{common::SolanaRpcClient, constants::pumpfun::accounts::JITO_TIP_ACCOUNTS};
+use crate::{common::SolanaRpcClient, constants::swqos::JITO_TIP_ACCOUNTS};
 
 
 pub struct JitoClient {

src/swqos/mod.rs

@@ -4,13 +4,14 @@ pub mod jito;
 pub mod nextblock;
 pub mod zeroslot;
 pub mod temporal;
+pub mod bloxroute;
 
 use solana_sdk::transaction::VersionedTransaction;
 use tokio::sync::RwLock;
 
 use anyhow::Result;
 
-use crate::swqos::common::{SWQOS_ENDPOINTS_JITO, SWQOS_ENDPOINTS_NEXTBLOCK, SWQOS_ENDPOINTS_TEMPORAL, SWQOS_ENDPOINTS_ZERO_SLOT};
+use crate::constants::swqos::{SWQOS_ENDPOINTS_BLOX, SWQOS_ENDPOINTS_JITO, SWQOS_ENDPOINTS_NEXTBLOCK, SWQOS_ENDPOINTS_TEMPORAL, SWQOS_ENDPOINTS_ZERO_SLOT};
 
 lazy_static::lazy_static! {
     static ref TIP_ACCOUNT_CACHE: RwLock<Vec<String>> = RwLock::new(Vec::new());
@@ -42,6 +43,7 @@ pub enum SwqosType {
     NextBlock,
     ZeroSlot,
     Temporal,
+    Bloxroute,
     Rpc,
 }
 
@@ -82,6 +84,7 @@ impl SwqosConfig {
             SwqosType::NextBlock => SWQOS_ENDPOINTS_NEXTBLOCK[region as usize].to_string(),
             SwqosType::ZeroSlot => SWQOS_ENDPOINTS_ZERO_SLOT[region as usize].to_string(),
             SwqosType::Temporal => SWQOS_ENDPOINTS_TEMPORAL[region as usize].to_string(),
+            SwqosType::Bloxroute => SWQOS_ENDPOINTS_BLOX[region as usize].to_string(),
             SwqosType::Rpc => "".to_string(),
         });
 

src/swqos/nextblock.rs

@@ -12,7 +12,7 @@ use solana_sdk::transaction::VersionedTransaction;
 use crate::swqos::{SwqosType, TradeType};
 use crate::swqos::SwqosClientTrait;
 
-use crate::{common::SolanaRpcClient, constants::pumpfun::accounts::NEXTBLOCK_TIP_ACCOUNTS};
+use crate::{common::SolanaRpcClient, constants::swqos::NEXTBLOCK_TIP_ACCOUNTS};
 
 #[derive(Clone)]
 pub struct NextBlockClient {

src/swqos/temporal.rs

@@ -15,7 +15,7 @@ use solana_sdk::transaction::VersionedTransaction;
 use crate::swqos::{SwqosType, TradeType};
 use crate::swqos::SwqosClientTrait;
 
-use crate::{common::SolanaRpcClient, constants::pumpfun::accounts::NOZOMI_TIP_ACCOUNTS};
+use crate::{common::SolanaRpcClient, constants::swqos::NOZOMI_TIP_ACCOUNTS};
 
 
 #[derive(Clone)]

src/swqos/zeroslot.rs

@@ -8,12 +8,11 @@ use std::time::Duration;
 use solana_transaction_status::UiTransactionEncoding;
 
 use anyhow::Result;
-use solana_sdk::signature::Signature;
 use solana_sdk::transaction::VersionedTransaction;
 use crate::swqos::{SwqosType, TradeType};
 use crate::swqos::SwqosClientTrait;
 
-use crate::{common::SolanaRpcClient, constants::pumpfun::accounts::ZEROSLOT_TIP_ACCOUNTS};
+use crate::{common::SolanaRpcClient, constants::swqos::ZEROSLOT_TIP_ACCOUNTS};
 
 
 #[derive(Clone)]