feat: add Astralane

2025-09-07 15:22:06 +08:00
parent 6e04458659
commit df00d3f26a
7 changed files with 272 additions and 4 deletions
@@ -98,6 +98,17 @@ pub const BLOCKRAZOR_TIP_ACCOUNTS: &[Pubkey] = &[
    pubkey!("AP6qExwrbRgBAVaehg4b5xHENX815sMabtBzUzVB4v8S"),
 ];

+pub const ASTRALANE_TIP_ACCOUNTS: &[Pubkey] = &[
+    pubkey!("astrazznxsGUhWShqgNtAdfrzP2G83DzcWVJDxwV9bF"),
+    pubkey!("astra4uejePWneqNaJKuFFA8oonqCE1sqF6b45kDMZm"),
+    pubkey!("astra9xWY93QyfG6yM8zwsKsRodscjQ2uU2HKNL5prk"),
+    pubkey!("astraRVUuTHjpwEVvNBeQEgwYx9w9CFyfxjYoobCZhL"),
+    pubkey!("astraEJ2fEj8Xmy6KLG7B3VfbKfsHXhHrNdCQx7iGJK"),
+    pubkey!("astraubkDw81n4LuutzSQ8uzHCv4BhPVhfvTcYv8SKC"),
+    pubkey!("astraZW5GLFefxNPAatceHhYjfA1ciq9gvfEg2S47xk"),
+    pubkey!("astrawVNP4xDBKT7rAdxrLYiTSTdqtUr63fSMduivXK"),
+];
+
 // NewYork,
 // Frankfurt,
 // Amsterdam,
@@ -195,3 +206,14 @@ pub const SWQOS_ENDPOINTS_BLOCKRAZOR: [&str; 8] = [
    "http://frankfurt.solana.blockrazor.xyz:443/sendTransaction",
 ];

+pub const SWQOS_ENDPOINTS_ASTRALANE: [&str; 8] = [
+    "http://ny.gateway.astralane.io/iris",
+    "http://fr.gateway.astralane.io/iris",
+    "http://ams.gateway.astralane.io/iris",
+    "http://ny.gateway.astralane.io/iris",
+    "http://jp.gateway.astralane.io/iris",
+    "http://ny.gateway.astralane.io/iris",
+    "http://lax.gateway.astralane.io/iris",
+    "http://lim.gateway.astralane.io/iris",
+];
+
@@ -83,6 +83,7 @@ fn create_swqos_configs(rpc_url: &str) -> Vec<SwqosConfig> {
        SwqosConfig::Node1("your api_token".to_string(), SwqosRegion::Frankfurt, None),
        SwqosConfig::FlashBlock("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),
        SwqosConfig::Default(rpc_url.to_string()),
    ]
 }
@@ -0,0 +1,225 @@
+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::ASTRALANE_TIP_ACCOUNTS};
+
+use tokio::task::JoinHandle;
+use std::sync::atomic::{AtomicBool, Ordering};
+
+#[derive(Clone)]
+pub struct AstralaneClient {
+    pub endpoint: String,
+    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]
+impl SwqosClientTrait for AstralaneClient {
+    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 = *ASTRALANE_TIP_ACCOUNTS.choose(&mut rand::rng()).or_else(|| ASTRALANE_TIP_ACCOUNTS.first()).unwrap();
+        Ok(tip_account.to_string())
+    }
+
+    fn get_swqos_type(&self) -> SwqosType {
+        SwqosType::Astralane
+    }
+}
+
+impl AstralaneClient {
+    pub fn new(rpc_url: String, endpoint: String, auth_token: String) -> Self {
+        let rpc_client = SolanaRpcClient::new(rpc_url);
+        let http_client = Client::builder()
+            // Due to ping mechanism, can extend connection pool idle timeout
+            .pool_idle_timeout(Duration::from_secs(300)) // 5 minutes, longer than ping interval
+            .pool_max_idle_per_host(32) // Reduce connections as they will be more stable
+            // TCP keepalive can be set longer as ping will actively maintain connections
+            .tcp_keepalive(Some(Duration::from_secs(300))) // 5 minutes
+            // HTTP/2 keepalive interval can be longer
+            .http2_keep_alive_interval(Duration::from_secs(30)) // 30 seconds
+            // Request timeout can be appropriately extended as connections are more stable
+            .timeout(Duration::from_secs(15)) // 15 seconds
+            .connect_timeout(Duration::from_secs(5))
+            .build()
+            .unwrap();
+        
+        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)),
+        };
+        
+        // Start ping task
+        let client_clone = client.clone();
+        tokio::spawn(async move {
+            client_clone.start_ping_task().await;
+        });
+        
+        client
+    }
+
+    /// Start periodic ping task to keep connections active
+    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)); // Ping every 60 seconds
+            
+            loop {
+                interval.tick().await;
+                
+                if stop_ping.load(Ordering::Relaxed) {
+                    break;
+                }
+                
+                // Send ping request
+                tokio::time::sleep(Duration::from_secs(5)).await;
+                if let Err(e) = Self::send_ping_request(&http_client, &endpoint, &auth_token).await {
+                    eprintln!("Astralane ping request failed: {}", e);
+                }
+            }
+        });
+        
+        // Update ping_handle - use Mutex to safely update
+        {
+            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);
+        }
+    }
+
+    /// Send ping request to /gethealth endpoint
+    async fn send_ping_request(http_client: &Client, endpoint: &str, auth_token: &str) -> Result<()> {
+        // Build ping URL by replacing /iris with /gethealth
+        let ping_url = if endpoint.ends_with("/iris") {
+            endpoint.replace("/iris", "/gethealth")
+        } else if endpoint.ends_with("/iris/") {
+            endpoint.replace("/iris/", "/gethealth")
+        } else if endpoint.ends_with('/') {
+            format!("{}gethealth", endpoint)
+        } else {
+            format!("{}/gethealth", endpoint)
+        };
+
+        // Send GET request to /gethealth endpoint with api_key header
+        let response = http_client.get(&ping_url)
+            .header("api_key", auth_token)
+            .send()
+            .await?;
+        
+        if response.status().is_success() {
+            // ping successful, connection remains active
+            // println!("send getHealth to keep connection alive");
+        } else {
+            eprintln!("Astralane ping request returned non-success status: {}", response.status());
+        }
+        
+        Ok(())
+    }
+
+    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!(" Transaction encoded to base64: {:?}", start_time.elapsed());
+
+        let request_body = serde_json::to_string(&json!({
+            "jsonrpc": "2.0",
+            "id": 1,
+            "method": "sendTransaction",
+            "params": [
+                content,
+                { "encoding": "base64", "skipPreflight": true },
+                { "mevProtect": false }
+            ]
+        }))?;
+
+        // Send request with api_key header (like your example)
+        let response_text = self.http_client.post(&self.endpoint)
+            .body(request_body)
+            .header("Content-Type", "application/json")
+            .header("api_key", &self.auth_token)
+            .send()
+            .await?
+            .text()
+            .await?;
+
+        // Parse JSON response
+        if let Ok(response_json) = serde_json::from_str::<serde_json::Value>(&response_text) {
+            if response_json.get("result").is_some() {
+                println!(" astralane {} submitted: {:?}", trade_type, start_time.elapsed());
+            } else if let Some(_error) = response_json.get("error") {
+                eprintln!(" astralane {} submission failed: {:?}", trade_type, _error);
+            }
+        } else {
+            eprintln!(" astralane {} submission failed: {:?}", trade_type, response_text);
+        }
+
+        let start_time: Instant = Instant::now();
+        match poll_transaction_confirmation(&self.rpc_client, signature).await {
+            Ok(_) => (),
+            Err(e) => {
+                println!(" signature: {:?}", signature);
+                println!(" astralane {} confirmation failed: {:?}", trade_type, start_time.elapsed());
+                return Err(e);
+            },
+        }
+        println!(" signature: {:?}", signature);
+        println!(" astralane {} confirmed: {:?}", 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(())
+    }
+}
+
+impl Drop for AstralaneClient {
+    fn drop(&mut self) {
+        // Ensure ping task stops when client is destroyed
+        self.stop_ping.store(true, Ordering::Relaxed);
+        
+        // Try to stop ping task immediately
+        // Use tokio::spawn to avoid blocking 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;
+        });
+    }
+}
@@ -8,6 +8,7 @@ pub mod bloxroute;
 pub mod node1;
 pub mod flashblock;
 pub mod blockrazor;
+pub mod astralane;

 use std::sync::Arc;

@@ -26,7 +27,8 @@ use crate::{
        SWQOS_ENDPOINTS_ZERO_SLOT, 
        SWQOS_ENDPOINTS_NODE1, 
        SWQOS_ENDPOINTS_FLASHBLOCK,
-        SWQOS_ENDPOINTS_BLOCKRAZOR
+        SWQOS_ENDPOINTS_BLOCKRAZOR,
+        SWQOS_ENDPOINTS_ASTRALANE
    }, 
    swqos::{
        bloxroute::BloxrouteClient, 
@@ -37,7 +39,8 @@ use crate::{
        zeroslot::ZeroSlotClient, 
        node1::Node1Client, 
        flashblock::FlashBlockClient,
-        blockrazor::BlockRazorClient
+        blockrazor::BlockRazorClient,
+        astralane::AstralaneClient
    }
 };

@@ -75,6 +78,7 @@ pub enum SwqosType {
    Node1,
    FlashBlock,
    BlockRazor,
+    Astralane,
    Default,
 }

@@ -111,6 +115,7 @@ pub enum SwqosConfig {
    Node1(String, SwqosRegion, Option<String>),
    FlashBlock(String, SwqosRegion, Option<String>),
    BlockRazor(String, SwqosRegion, Option<String>),
+    Astralane(String, SwqosRegion, Option<String>),
 }

 impl SwqosConfig {
@@ -128,6 +133,7 @@ impl SwqosConfig {
            SwqosType::Node1 => SWQOS_ENDPOINTS_NODE1[region as usize].to_string(),
            SwqosType::FlashBlock => SWQOS_ENDPOINTS_FLASHBLOCK[region as usize].to_string(),
            SwqosType::BlockRazor => SWQOS_ENDPOINTS_BLOCKRAZOR[region as usize].to_string(),
+            SwqosType::Astralane => SWQOS_ENDPOINTS_ASTRALANE[region as usize].to_string(),
            SwqosType::Default => "".to_string(),
        }
    }
@@ -206,6 +212,15 @@ impl SwqosConfig {
                );
                Arc::new(blockrazor_client)
            },
+            SwqosConfig::Astralane(auth_token, region, url) => {
+                let endpoint = SwqosConfig::get_endpoint(SwqosType::Astralane, region, url);
+                let astralane_client = AstralaneClient::new(
+                    rpc_url.clone(),
+                    endpoint.to_string(),
+                    auth_token
+                );
+                Arc::new(astralane_client)
+            },
            SwqosConfig::Default(endpoint) => {
                let rpc = SolanaRpcClient::new_with_commitment(
                    endpoint,