Merge commit 'd14f4870c56afd58b9f4c448eef20f4bef7ecfa2'

2025-08-21 21:33:01 +08:00
parent 5a9238a741 d14f4870c5
commit bc88c7137e
7 changed files with 299 additions and 22 deletions
@@ -68,6 +68,19 @@ pub const NODE1_TIP_ACCOUNTS: &[Pubkey] = &[
    pubkey!("node1YtWCoTwwVYTFLfS19zquRQzYX332hs1HEuRBjC"),
 ];

+pub const FLASHBLOCK_TIP_ACCOUNTS: &[Pubkey] = &[
+    pubkey!("FLaShB3iXXTWE1vu9wQsChUKq3HFtpMAhb8kAh1pf1wi"),
+    pubkey!("FLashhsorBmM9dLpuq6qATawcpqk1Y2aqaZfkd48iT3W"),
+    pubkey!("FLaSHJNm5dWYzEgnHJWWJP5ccu128Mu61NJLxUf7mUXU"),
+    pubkey!("FLaSHR4Vv7sttd6TyDF4yR1bJyAxRwWKbohDytEMu3wL"),
+    pubkey!("FLASHRzANfcAKDuQ3RXv9hbkBy4WVEKDzoAgxJ56DiE4"),
+    pubkey!("FLasHstqx11M8W56zrSEqkCyhMCCpr6ze6Mjdvqope5s"),
+    pubkey!("FLAShWTjcweNT4NSotpjpxAkwxUr2we3eXQGhpTVzRwy"),
+    pubkey!("FLasHXTqrbNvpWFB6grN47HGZfK6pze9HLNTgbukfPSk"),
+    pubkey!("FLAshyAyBcKb39KPxSzXcepiS8iDYUhDGwJcJDPX4g2B"),
+    pubkey!("FLAsHZTRcf3Dy1APaz6j74ebdMC6Xx4g6i9YxjyrDybR"),
+];
+
 // NewYork,
 // Frankfurt,
 // Amsterdam,
@@ -80,7 +93,7 @@ pub const NODE1_TIP_ACCOUNTS: &[Pubkey] = &[
 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://amsterdam.mainnet.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",
@@ -91,7 +104,7 @@ pub const SWQOS_ENDPOINTS_JITO: [&str; 8] = [
 pub const SWQOS_ENDPOINTS_NEXTBLOCK: [&str; 8] = [
    "http://ny.nextblock.io",
    "http://fra.nextblock.io",
-    "http://slc.nextblock.io",
+    "http://fra.nextblock.io",
    "http://slc.nextblock.io",
    "http://tokyo.nextblock.io",  
    "http://london.nextblock.io", 
@@ -103,9 +116,9 @@ pub const SWQOS_ENDPOINTS_ZERO_SLOT: [&str; 8] = [
    "http://ny.0slot.trade",
    "http://de.0slot.trade",
    "http://ams.0slot.trade",
+    "http://ny.0slot.trade",
+    "http://jp.0slot.trade",
    "http://ams.0slot.trade",
-    "http://jp.0slot.trade",
-    "http://jp.0slot.trade",
    "http://la.0slot.trade",
    "http://de.0slot.trade",
 ];
@@ -114,7 +127,7 @@ 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://ewr1.nozomi.temporal.xyz",
    "http://tyo1.nozomi.temporal.xyz",
    "http://sgp1.nozomi.temporal.xyz",
    "http://pit1.nozomi.temporal.xyz",
@@ -125,7 +138,7 @@ pub const SWQOS_ENDPOINTS_BLOX: [&str; 8] = [
    "https://ny.solana.dex.blxrbdn.com",
    "https://germany.solana.dex.blxrbdn.com",
    "https://amsterdam.solana.dex.blxrbdn.com",
-    "https://amsterdam.solana.dex.blxrbdn.com",
+    "https://ny.solana.dex.blxrbdn.com",
    "https://tokyo.solana.dex.blxrbdn.com",
    "https://uk.solana.dex.blxrbdn.com",
    "https://la.solana.dex.blxrbdn.com",
@@ -133,13 +146,24 @@ pub const SWQOS_ENDPOINTS_BLOX: [&str; 8] = [
 ];

 pub const SWQOS_ENDPOINTS_NODE1: [&str; 8] = [
-    "https://ny.node1.me",
    "http://ny.node1.me",
-    "https://ams.node1.me",
-    "http://ams.node1.me",
-    "https://fra.node1.me",
    "http://fra.node1.me",
-    "https://fra.node1.me",
+    "http://ams.node1.me",
+    "http://ny.node1.me",
+    "http://fra.node1.me",
+    "http://ams.node1.me",
+    "http://ny.node1.me",
    "http://fra.node1.me",
 ];

+pub const SWQOS_ENDPOINTS_FLASHBLOCK: [&str; 8] = [
+    "http://ny.flashblock.trade",
+    "http://fra.flashblock.trade",
+    "http://ams.flashblock.trade",
+    "http://slc.flashblock.trade",
+    "http://singapore.flashblock.trade",
+    "http://london.flashblock.trade",
+    "http://ny.flashblock.trade",
+    "http://ny.flashblock.trade",
+];
+
@@ -81,6 +81,7 @@ fn create_swqos_configs(rpc_url: &str) -> Vec<SwqosConfig> {
        SwqosConfig::ZeroSlot("your api_token".to_string(), SwqosRegion::Frankfurt),
        SwqosConfig::Temporal("your api_token".to_string(), SwqosRegion::Frankfurt),
        SwqosConfig::Node1("your api_token".to_string(), SwqosRegion::Frankfurt),
+        SwqosConfig::FlashBlock("your api_token".to_string(), SwqosRegion::Frankfurt),
        SwqosConfig::Default(rpc_url.to_string()),
    ]
 }
@@ -0,0 +1,109 @@
+use crate::swqos::common::{poll_transaction_confirmation, serialize_transaction_and_encode};
+use rand::seq::IndexedRandom;
+use reqwest::Client;
+use serde_json::json;
+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::FLASHBLOCK_TIP_ACCOUNTS};
+
+
+#[derive(Clone)]
+pub struct FlashBlockClient {
+    pub endpoint: String,
+    pub auth_token: String,
+    pub rpc_client: Arc<SolanaRpcClient>,
+    pub http_client: Client,
+}
+
+#[async_trait::async_trait]
+impl SwqosClientTrait for FlashBlockClient {
+    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 = *FLASHBLOCK_TIP_ACCOUNTS.choose(&mut rand::rng()).or_else(|| FLASHBLOCK_TIP_ACCOUNTS.first()).unwrap();
+        Ok(tip_account.to_string())
+    }
+
+    fn get_swqos_type(&self) -> SwqosType {
+        SwqosType::FlashBlock
+    }
+}
+
+impl FlashBlockClient {
+    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());
+
+        // FlashBlock API格式
+        let request_body = serde_json::to_string(&json!({
+            "transactions": [content]
+        }))?;
+
+        let url = format!("{}/api/v2/submit-batch", self.endpoint);
+
+        // 发送请求到FlashBlock
+        let response_text = self.http_client.post(&url)
+            .body(request_body)
+            .header("Authorization", &self.auth_token)
+            .header("Content-Type", "application/json")
+            .send()
+            .await?
+            .text()
+            .await?;
+
+        // 解析响应
+        if let Ok(response_json) = serde_json::from_str::<serde_json::Value>(&response_text) {
+            if response_json.get("success").is_some() || response_json.get("result").is_some() {
+                println!(" FlashBlock{}提交: {:?}", trade_type, start_time.elapsed());
+            } else if let Some(_error) = response_json.get("error") {
+                eprintln!(" FlashBlock{}提交失败: {:?}", trade_type, _error);
+            }
+        }
+
+        let start_time: Instant = Instant::now();
+        match poll_transaction_confirmation(&self.rpc_client, signature).await {
+            Ok(_) => (),
+            Err(_) => (),
+        }
+
+        println!(" FlashBlock{}确认: {:?}", trade_type, start_time.elapsed());
+
+        Ok(())
+    }
+
+    pub async fn send_transactions(&self, trade_type: TradeType, transactions: &Vec<VersionedTransaction>) -> Result<()> {
+        for transaction in transactions {
+            self.send_transaction(trade_type, transaction).await?;
+        }
+        Ok(())
+    }
+}
@@ -6,6 +6,7 @@ pub mod zeroslot;
 pub mod temporal;
 pub mod bloxroute;
 pub mod node1;
+pub mod flashblock;

 use std::sync::Arc;

@@ -14,7 +15,28 @@ use tokio::sync::RwLock;

 use anyhow::Result;

-use crate::{common::SolanaRpcClient, constants::swqos::{SWQOS_ENDPOINTS_BLOX, SWQOS_ENDPOINTS_JITO, SWQOS_ENDPOINTS_NEXTBLOCK, SWQOS_ENDPOINTS_TEMPORAL, SWQOS_ENDPOINTS_ZERO_SLOT, SWQOS_ENDPOINTS_NODE1}, swqos::{bloxroute::BloxrouteClient, jito::JitoClient, nextblock::NextBlockClient, solana_rpc::SolRpcClient, temporal::TemporalClient, zeroslot::ZeroSlotClient, node1::Node1Client}};
+use crate::{
+    common::SolanaRpcClient, 
+    constants::swqos::{
+        SWQOS_ENDPOINTS_BLOX, 
+        SWQOS_ENDPOINTS_JITO, 
+        SWQOS_ENDPOINTS_NEXTBLOCK, 
+        SWQOS_ENDPOINTS_TEMPORAL, 
+        SWQOS_ENDPOINTS_ZERO_SLOT, 
+        SWQOS_ENDPOINTS_NODE1, 
+        SWQOS_ENDPOINTS_FLASHBLOCK
+    }, 
+    swqos::{
+        bloxroute::BloxrouteClient, 
+        jito::JitoClient, 
+        nextblock::NextBlockClient, 
+        solana_rpc::SolRpcClient, 
+        temporal::TemporalClient, 
+        zeroslot::ZeroSlotClient, 
+        node1::Node1Client, 
+        flashblock::FlashBlockClient
+    }
+};

 lazy_static::lazy_static! {
    static ref TIP_ACCOUNT_CACHE: RwLock<Vec<String>> = RwLock::new(Vec::new());
@@ -48,6 +70,7 @@ pub enum SwqosType {
    Temporal,
    Bloxroute,
    Node1,
+    FlashBlock,
    Default,
 }

@@ -82,6 +105,7 @@ pub enum SwqosConfig {
    Temporal(String, SwqosRegion),
    ZeroSlot(String, SwqosRegion),
    Node1(String, SwqosRegion),
+    FlashBlock(String, SwqosRegion),
 }

 impl SwqosConfig {
@@ -93,6 +117,7 @@ impl SwqosConfig {
            SwqosType::Temporal => SWQOS_ENDPOINTS_TEMPORAL[region as usize].to_string(),
            SwqosType::Bloxroute => SWQOS_ENDPOINTS_BLOX[region as usize].to_string(),
            SwqosType::Node1 => SWQOS_ENDPOINTS_NODE1[region as usize].to_string(),
+            SwqosType::FlashBlock => SWQOS_ENDPOINTS_FLASHBLOCK[region as usize].to_string(),
            SwqosType::Default => "".to_string(),
        }
    }
@@ -153,6 +178,15 @@ impl SwqosConfig {
                );
                Arc::new(node1_client)
            },
+            SwqosConfig::FlashBlock(auth_token, region) => {
+                let endpoint = SwqosConfig::get_endpoint(SwqosType::FlashBlock, region);
+                let flashblock_client = FlashBlockClient::new(
+                    rpc_url.clone(),
+                    endpoint.to_string(),
+                    auth_token
+                );
+                Arc::new(flashblock_client)
+            },
            SwqosConfig::Default(endpoint) => {
                let rpc = SolanaRpcClient::new_with_commitment(
                    endpoint,
@@ -14,6 +14,8 @@ use crate::swqos::SwqosClientTrait;

 use crate::{common::SolanaRpcClient, constants::swqos::NODE1_TIP_ACCOUNTS};

+use tokio::task::JoinHandle;
+use std::sync::atomic::{AtomicBool, Ordering};

 #[derive(Clone)]
 pub struct Node1Client {
@@ -21,6 +23,8 @@ pub struct Node1Client {
    pub auth_token: String,
    pub rpc_client: Arc<SolanaRpcClient>,
    pub http_client: Client,
+    pub ping_handle: Arc<tokio::sync::Mutex<Option<JoinHandle<()>>>>,
+    pub stop_ping: Arc<AtomicBool>,
 }

 #[async_trait::async_trait]
@@ -47,15 +51,93 @@ impl Node1Client {
    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))
+            // 由于有 ping 机制，可以延长连接池空闲超时
+            .pool_idle_timeout(Duration::from_secs(300)) // 5分钟，比 ping 间隔更长
+            .pool_max_idle_per_host(32) // 减少连接数，因为连接会更稳定
+            // TCP keepalive 可以设置得更长，因为 ping 会主动保持连接
+            .tcp_keepalive(Some(Duration::from_secs(300))) // 5分钟
+            // HTTP/2 keepalive 间隔可以更长
+            .http2_keep_alive_interval(Duration::from_secs(30)) // 30秒
+            // 请求超时可以适当延长，因为连接更稳定
+            .timeout(Duration::from_secs(15)) // 15秒
            .connect_timeout(Duration::from_secs(5))
            .build()
            .unwrap();
-        Self { rpc_client: Arc::new(rpc_client), endpoint, auth_token, http_client }
+        
+        let client = Self { 
+            rpc_client: Arc::new(rpc_client), 
+            endpoint, 
+            auth_token, 
+            http_client,
+            ping_handle: Arc::new(tokio::sync::Mutex::new(None)),
+            stop_ping: Arc::new(AtomicBool::new(false)),
+        };
+        
+        // 启动 ping 任务
+        let client_clone = client.clone();
+        tokio::spawn(async move {
+            client_clone.start_ping_task().await;
+        });
+        
+        client
+    }
+
+    /// 启动定期 ping 任务以保持连接活跃
+    async fn start_ping_task(&self) {
+        let endpoint = self.endpoint.clone();
+        let auth_token = self.auth_token.clone();
+        let http_client = self.http_client.clone();
+        let stop_ping = self.stop_ping.clone();
+        
+        let handle = tokio::spawn(async move {
+            let mut interval = tokio::time::interval(Duration::from_secs(60)); // 每60秒ping一次
+            
+            loop {
+                interval.tick().await;
+                
+                if stop_ping.load(Ordering::Relaxed) {
+                    break;
+                }
+                
+                // 发送 ping 请求
+                if let Err(e) = Self::send_ping_request(&http_client, &endpoint, &auth_token).await {
+                    eprintln!("Node1 ping 请求失败: {}", e);
+                }
+            }
+        });
+        
+        // 更新 ping_handle - 使用 Mutex 来安全地更新
+        {
+            let mut ping_guard = self.ping_handle.lock().await;
+            if let Some(old_handle) = ping_guard.as_ref() {
+                old_handle.abort();
+            }
+            *ping_guard = Some(handle);
+        }
+    }
+
+    /// 发送 ping 请求到 /ping 端点
+    async fn send_ping_request(http_client: &Client, endpoint: &str, _auth_token: &str) -> Result<()> {
+        // 构建 ping URL
+        let ping_url = if endpoint.ends_with('/') {
+            format!("{}ping", endpoint)
+        } else {
+            format!("{}/ping", endpoint)
+        };
+
+        // 发送 GET 请求到 /ping 端点（不需要 api-key）
+        let response = http_client.get(&ping_url)
+            .send()
+            .await?;
+        
+        if response.status().is_success() {
+            // ping 成功，连接保持活跃
+            // 可以选择性地记录日志，但为了减少噪音，这里不打印
+        } else {
+            eprintln!("Node1 ping 请求返回非成功状态: {}", response.status());
+        }
+        
+        Ok(())
    }

    pub async fn send_transaction(&self, trade_type: TradeType, transaction: &VersionedTransaction) -> Result<()> {
@@ -110,3 +192,21 @@ impl Node1Client {
        Ok(())
    }
 }
+
+impl Drop for Node1Client {
+    fn drop(&mut self) {
+        // 确保在客户端被销毁时停止 ping 任务
+        self.stop_ping.store(true, Ordering::Relaxed);
+        
+        // 尝试立即停止 ping 任务
+        // 使用 tokio::spawn 来避免阻塞 Drop
+        let ping_handle = self.ping_handle.clone();
+        tokio::spawn(async move {
+            let mut ping_guard = ping_handle.lock().await;
+            if let Some(handle) = ping_guard.as_ref() {
+                handle.abort();
+            }
+            *ping_guard = None;
+        });
+    }
+}