diff --git a/Cargo.toml b/Cargo.toml index 3bb3734..b1f94b1 100755 --- a/Cargo.toml +++ b/Cargo.toml @@ -112,6 +112,7 @@ sha2 = "0.10" tonic-prost = "0.14.2" # 须含 runtime-tokio，否则 quinn::Endpoint::client 报 no async runtime found，QUIC（Speedlanding/Soyas）无法初始化 quinn = { version = "0.11", default-features = false, features = ["rustls", "runtime-tokio"] } +lunar-lander-quic-client = "0.4" rcgen = "0.13" uuid = "1.11" diff --git a/README.md b/README.md index b6e8000..bbfbbaa 100644 --- a/README.md +++ b/README.md @@ -104,7 +104,7 @@ This release refreshes PumpFun native-SOL quote handling so SOL/WSOL sentinels p 4. **Raydium CPMM Trading**: Support for Raydium CPMM (Concentrated Pool Market Maker) trading operations 5. **Raydium AMM V4 Trading**: Support for Raydium AMM V4 (Automated Market Maker) trading operations 6. **Meteora DAMM V2 Trading**: Support for Meteora DAMM V2 (Dynamic AMM) trading operations -7. **Multiple MEV Protection**: Support for Jito, Nextblock, ZeroSlot, Temporal, Bloxroute, FlashBlock, BlockRazor, Node1, Astralane and other services +7. **Multiple MEV Protection**: Support for Jito, Nextblock, ZeroSlot, Temporal, Bloxroute, FlashBlock, BlockRazor, Node1, Astralane, LunarLander and other services 8. **Concurrent Trading**: Submit through every configured SWQoS provider plus the default RPC lane; the first accepted result can return early while slower routes continue submitting 9. **Unified Trading Interface**: Use unified trading protocol enums for trading operations 10. **Middleware System**: Support for custom instruction middleware to modify, add, or remove instructions before transaction execution @@ -161,6 +161,14 @@ let swqos_configs: Vec = vec![ // Astralane: 4th param = AstralaneTransport — Binary (default), Plain (/iris), or Quic SwqosConfig::Astralane("your_astralane_api_key".to_string(), SwqosRegion::Frankfurt, None, None), // Binary HTTP /irisb SwqosConfig::SpeedLanding("your api_token".to_string(), SwqosRegion::Frankfurt, None), + // Lunar Lander: 4th param None = binary HTTP; Some(SwqosTransport::Quic) = QUIC + SwqosConfig::LunarLander("your_hellomoon_api_key".to_string(), SwqosRegion::Frankfurt, None, None), + SwqosConfig::LunarLander( + "your_hellomoon_api_key".to_string(), + SwqosRegion::Frankfurt, + None, + Some(SwqosTransport::Quic), + ), ]; // Create TradeConfig instance let trade_config = TradeConfig::builder(rpc_url, swqos_configs, commitment) @@ -508,6 +516,8 @@ You can apply for a key through the official website: [Community Website](https: - **BlockRazor**: High-speed transaction execution with API key authentication - **Astralane**: Blockchain network acceleration (Binary/Plain HTTP and QUIC) - **SpeedLanding**: High-speed transaction execution with API key authentication +- **Node1**: High-speed transaction execution with API key authentication +- **LunarLander**: HelloMoon transaction landing service (minimum tip: 0.001 SOL) ## 📁 Project Structure diff --git a/README_CN.md b/README_CN.md index eb5d3b0..09b156b 100755 --- a/README_CN.md +++ b/README_CN.md @@ -104,7 +104,7 @@ 4. **Raydium CPMM 交易**: 支持 Raydium CPMM (Concentrated Pool Market Maker) 的交易操作 5. **Raydium AMM V4 交易**: 支持 Raydium AMM V4 (Automated Market Maker) 的交易操作 6. **Meteora DAMM V2 交易**: 支持 Meteora DAMM V2 (Dynamic AMM) 的交易操作 -7. **多种 MEV 保护**: 支持 Jito、Temporal、FlashBlock、BlockRazor、Astralane、SpeedLanding 等服务 +7. **多种 MEV 保护**: 支持 Jito、Nextblock、ZeroSlot、Temporal、Bloxroute、FlashBlock、BlockRazor、Node1、Astralane、SpeedLanding、LunarLander 等服务 8. **并发交易**: 所有已配置的 SWQoS 通道和默认 RPC 通道都会发出提交；首个成功只影响返回，较慢通道会继续提交 9. **统一交易接口**: 使用统一的交易协议枚举进行交易操作 10. **中间件系统**: 支持自定义指令中间件，可在交易执行前对指令进行修改、添加或移除 @@ -161,6 +161,14 @@ let swqos_configs: Vec = vec![ // Astralane：第4个参数为 AstralaneTransport — Binary（默认）、Plain（/iris）或 Quic SwqosConfig::Astralane("your_astralane_api_key".to_string(), SwqosRegion::Frankfurt, None, None), // Binary /irisb SwqosConfig::SpeedLanding("your api_token".to_string(), SwqosRegion::Frankfurt, None), + // Lunar Lander：第4个参数 None 为 binary HTTP；Some(SwqosTransport::Quic) 为 QUIC + SwqosConfig::LunarLander("your_hellomoon_api_key".to_string(), SwqosRegion::Frankfurt, None, None), + SwqosConfig::LunarLander( + "your_hellomoon_api_key".to_string(), + SwqosRegion::Frankfurt, + None, + Some(SwqosTransport::Quic), + ), ]; // 创建 TradeConfig 实例 let trade_config = TradeConfig::builder(rpc_url, swqos_configs, commitment) @@ -505,6 +513,8 @@ legacy SOL 事件里如果 `quote_mint` 是默认值或 Solscan SOL，并且 quo - **BlockRazor**: 高速交易执行，支持 API 密钥认证 - **Astralane**: 区块链网络加速（Binary/Plain HTTP 与 QUIC） - **SpeedLanding**: 高速交易执行，支持 API 密钥认证 +- **Node1**: 高速交易执行，支持 API 密钥认证 +- **LunarLander**: HelloMoon 交易着陆服务（最低小费：0.001 SOL） ## 📁 项目结构 diff --git a/src/constants/swqos.rs b/src/constants/swqos.rs index e7eba5d..c667d30 100755 --- a/src/constants/swqos.rs +++ b/src/constants/swqos.rs @@ -184,6 +184,20 @@ pub const SOLAMI_TIP_ACCOUNTS: &[Pubkey] = &[ pubkey!("uiuaQsxA47JybQAVN4FTfYuoEDkMiXV1r591Aewbeam"), ]; +// LunarLander (HelloMoon) tip accounts +pub const LUNARLANDER_TIP_ACCOUNTS: &[Pubkey] = &[ + pubkey!("moon17L6BgxXRX5uHKudAmqVF96xia9h8ygcmG2sL3F"), + pubkey!("moon26Sek222Md7ZydcAGxoKG832DK36CkLrS3PQY4c"), + pubkey!("moon7fwyajcVstMoBnVy7UBcTx87SBtNoGGAaH2Cb8V"), + pubkey!("moonBtH9HvLHjLqi9ivyrMVKgFUsSfrz9BwQ9khhn1u"), + pubkey!("moonCJg8476LNFLptX1qrK8PdRsA1HD1R6XWyu9MB93"), + pubkey!("moonF2sz7qwAtdETnrgxNbjonnhGGjd6r4W4UC9284s"), + pubkey!("moonKfftMiGSak3cezvhEqvkPSzwrmQxQHXuspC96yj"), + pubkey!("moonQBUKBpkifLcTd78bfxxt4PYLwmJ5admLW6cBBs8"), + pubkey!("moonXwpKwoVkMegt5Bc776cSW793X1irL5hHV1vJ3JA"), + pubkey!("moonZ6u9E2fgk6eWd82621eLPHt9zuJuYECXAYjMY1C"), +]; + // `SwqosRegion` 与下列各 `SWQOS_ENDPOINTS_*` 下标严格对应（共 10 项）： // 0 NewYork, 1 Frankfurt, 2 Amsterdam, 3 Dublin, 4 SLC, 5 Tokyo, 6 Singapore, 7 London, 8 LosAngeles, 9 Default。 // @@ -433,6 +447,36 @@ pub const SWQOS_ENDPOINTS_SPEEDLANDING: [&str; 10] = [ "fra.speedlanding.trade:17778", // Default: 非地理区域；EU 枢纽 ]; +/// Lunar Lander HTTP endpoints. Binary tx via POST /send-bin with x-api-key header. +/// `SwqosRegion` order; regions without a dedicated published PoP use the nearest available host. +pub const SWQOS_ENDPOINTS_LUNARLANDER: [&str; 10] = [ + "http://nyc-1.prod.lunar-lander.hellomoon.io", + "http://fra-1.prod.lunar-lander.hellomoon.io", + "http://ams-1.prod.lunar-lander.hellomoon.io", + "http://ams-1.prod.lunar-lander.hellomoon.io", // Dublin -> Amsterdam + "http://ash-2.prod.lunar-lander.hellomoon.io", // SLC -> Ashburn + "http://tyo-1.prod.lunar-lander.hellomoon.io", + "http://tyo-1.prod.lunar-lander.hellomoon.io", // Singapore -> Tokyo + "http://fra-1.prod.lunar-lander.hellomoon.io", // London -> Frankfurt + "http://nyc-1.prod.lunar-lander.hellomoon.io", // LosAngeles -> NYC + "http://nyc-1.prod.lunar-lander.hellomoon.io", // Default -> NYC +]; + +/// Lunar Lander QUIC endpoints (direct, port 16888). Auth via client cert CN = API key. +/// ALPN: b"lunar-lander-tpu". Fire-and-forget unidirectional streams. +pub const SWQOS_ENDPOINTS_LUNARLANDER_QUIC: [&str; 10] = [ + "nyc-1.prod.lunar-lander.hellomoon.io:16888", + "fra-1.prod.lunar-lander.hellomoon.io:16888", + "ams-1.prod.lunar-lander.hellomoon.io:16888", + "ams-1.prod.lunar-lander.hellomoon.io:16888", // Dublin -> Amsterdam + "ash-2.prod.lunar-lander.hellomoon.io:16888", // SLC -> Ashburn + "tyo-1.prod.lunar-lander.hellomoon.io:16888", + "tyo-1.prod.lunar-lander.hellomoon.io:16888", // Singapore -> Tokyo + "fra-1.prod.lunar-lander.hellomoon.io:16888", // London -> Frankfurt + "nyc-1.prod.lunar-lander.hellomoon.io:16888", // LosAngeles -> NYC + "nyc-1.prod.lunar-lander.hellomoon.io:16888", // Default -> NYC +]; + /// Helius Sender: POST /fast, dual routing to validators and Jito. API key optional (custom TPS only). pub const SWQOS_ENDPOINTS_HELIUS: [&str; 10] = [ "http://ewr-sender.helius-rpc.com/fast", @@ -477,9 +521,9 @@ pub const SWQOS_MIN_TIP_SPEEDLANDING: f64 = 0.001; // Speedlanding requires mini /// 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; pub const SWQOS_MIN_TIP_SOLAMI: f64 = 0.0001; +pub const SWQOS_MIN_TIP_LUNARLANDER: f64 = 0.001; // LunarLander 最低小费 0.001 SOL /// Helius Sender with swqos_only: minimum 0.000005 SOL (much lower tip allowed). pub const SWQOS_MIN_TIP_HELIUS_SWQOS_ONLY: f64 = 0.000005; - #[cfg(test)] mod tests { use super::*; @@ -503,6 +547,8 @@ mod tests { &SWQOS_ENDPOINTS_SOYAS, &SWQOS_ENDPOINTS_SPEEDLANDING, &SWQOS_ENDPOINTS_HELIUS, + &SWQOS_ENDPOINTS_LUNARLANDER, + &SWQOS_ENDPOINTS_LUNARLANDER_QUIC, &SWQOS_ENDPOINTS_SOLAMI, ]; diff --git a/src/swqos/lunarlander.rs b/src/swqos/lunarlander.rs new file mode 100644 index 0000000..a198c2e --- /dev/null +++ b/src/swqos/lunarlander.rs @@ -0,0 +1,296 @@ +use crate::swqos::common::{default_http_client_builder, poll_transaction_confirmation}; +use rand::seq::IndexedRandom; +use reqwest::Client; +use std::{sync::Arc, time::Instant}; + +use crate::swqos::SwqosClientTrait; +use crate::swqos::{SwqosType, TradeType}; +use anyhow::Result; +use bincode::serialize as bincode_serialize; +use solana_sdk::transaction::VersionedTransaction; +use std::time::Duration; + +use crate::{common::SolanaRpcClient, constants::swqos::LUNARLANDER_TIP_ACCOUNTS}; + +use std::sync::atomic::{AtomicBool, Ordering}; +use tokio::task::JoinHandle; + +use lunar_lander_quic_client::{ClientOptions, LunarLanderQuicClient}; + +#[derive(Clone)] +pub enum LunarLanderBackend { + Http { + endpoint: String, + auth_token: String, + http_client: Client, + ping_handle: Arc>>>, + stop_ping: Arc, + }, + Quic(Arc), +} + +#[derive(Clone)] +pub struct LunarLanderClient { + pub rpc_client: Arc, + backend: LunarLanderBackend, +} + +#[async_trait::async_trait] +impl SwqosClientTrait for LunarLanderClient { + async fn send_transaction( + &self, + trade_type: TradeType, + transaction: &VersionedTransaction, + wait_confirmation: bool, + ) -> Result<()> { + self.send_transaction_impl(trade_type, transaction, wait_confirmation).await + } + + async fn send_transactions( + &self, + trade_type: TradeType, + transactions: &Vec, + wait_confirmation: bool, + ) -> Result<()> { + for transaction in transactions { + self.send_transaction_impl(trade_type, transaction, wait_confirmation).await?; + } + Ok(()) + } + + fn get_tip_account(&self) -> Result { + let tip_account = *LUNARLANDER_TIP_ACCOUNTS + .choose(&mut rand::rng()) + .or_else(|| LUNARLANDER_TIP_ACCOUNTS.first()) + .unwrap(); + Ok(tip_account.to_string()) + } + + fn get_swqos_type(&self) -> SwqosType { + SwqosType::LunarLander + } +} + +impl LunarLanderClient { + /// Create an HTTP binary client (POST /send-bin with bincode body). + pub fn new(rpc_url: String, endpoint: String, auth_token: String) -> Self { + let rpc_client = SolanaRpcClient::new(rpc_url); + let http_client = default_http_client_builder().build().unwrap(); + let ping_handle = Arc::new(tokio::sync::Mutex::new(None)); + let stop_ping = Arc::new(AtomicBool::new(false)); + + let client = Self { + rpc_client: Arc::new(rpc_client), + backend: LunarLanderBackend::Http { + endpoint, + auth_token, + http_client, + ping_handle, + stop_ping, + }, + }; + let client_clone = client.clone(); + tokio::spawn(async move { + client_clone.start_ping_task().await; + }); + client + } + + /// Create a QUIC client (port 16888, cert CN = api_key, fire-and-forget unidirectional streams). + pub async fn new_quic( + rpc_url: String, + quic_endpoint: &str, + api_key: String, + mev_protection: bool, + ) -> Result { + let rpc_client = SolanaRpcClient::new(rpc_url); + let quic_client = LunarLanderQuicClient::connect_with_options( + quic_endpoint, + api_key, + quic_client_options(mev_protection), + ) + .await?; + Ok(Self { + rpc_client: Arc::new(rpc_client), + backend: LunarLanderBackend::Quic(Arc::new(quic_client)), + }) + } + + async fn start_ping_task(&self) { + match &self.backend { + LunarLanderBackend::Http { + endpoint, + auth_token, + http_client, + ping_handle, + stop_ping, + } => { + let endpoint = endpoint.clone(); + let auth_token = auth_token.clone(); + let http_client = http_client.clone(); + let ping_handle = ping_handle.clone(); + let stop_ping = stop_ping.clone(); + let handle = tokio::spawn(async move { + // Immediate first ping to warm connection. + let _ = Self::send_ping_request(&http_client, &endpoint, &auth_token).await; + let mut interval = tokio::time::interval(Duration::from_secs(30)); + loop { + interval.tick().await; + if stop_ping.load(Ordering::Relaxed) { + break; + } + if let Err(e) = + Self::send_ping_request(&http_client, &endpoint, &auth_token).await + { + if crate::common::sdk_log::sdk_log_enabled() { + eprintln!("LunarLander ping request failed: {}", e); + } + } + } + }); + let mut guard = ping_handle.lock().await; + if let Some(old) = guard.as_ref() { + old.abort(); + } + *guard = Some(handle); + } + LunarLanderBackend::Quic(_) => {} + } + } + + /// GET {endpoint}/ping for HTTP keepalive. + async fn send_ping_request( + http_client: &Client, + endpoint: &str, + auth_token: &str, + ) -> Result<()> { + let url = format!("{}/ping", endpoint.trim_end_matches('/')); + let response = http_client + .get(&url) + .header("x-api-key", auth_token) + .timeout(Duration::from_millis(1500)) + .send() + .await?; + let _ = response.bytes().await; + Ok(()) + } + + async fn send_transaction_impl( + &self, + trade_type: TradeType, + transaction: &VersionedTransaction, + wait_confirmation: bool, + ) -> Result<()> { + let start_time = Instant::now(); + let signature = *transaction + .signatures + .first() + .ok_or_else(|| anyhow::anyhow!("LunarLander transaction has no signature"))?; + let body_bytes = bincode_serialize(transaction) + .map_err(|e| anyhow::anyhow!("LunarLander binary serialize failed: {}", e))?; + + match &self.backend { + LunarLanderBackend::Http { endpoint, auth_token, http_client, .. } => { + let url = format!("{}/send-bin", endpoint.trim_end_matches('/')); + let response = http_client + .post(&url) + .header("x-api-key", auth_token) + .header("Content-Type", "application/octet-stream") + .body(body_bytes) + .send() + .await?; + let status = response.status(); + let _ = response.bytes().await; + if status.is_success() { + if crate::common::sdk_log::sdk_log_enabled() { + crate::common::sdk_log::log_swqos_submitted( + "LunarLander", + trade_type, + start_time.elapsed(), + ); + } + } else { + if crate::common::sdk_log::sdk_log_enabled() { + crate::common::sdk_log::log_swqos_submission_failed( + "LunarLander", + trade_type, + start_time.elapsed(), + format!("status {}", status), + ); + } + return Err(anyhow::anyhow!("LunarLander sendTransaction failed: {}", status)); + } + } + LunarLanderBackend::Quic(quic) => { + quic.send_transaction(&body_bytes).await?; + if crate::common::sdk_log::sdk_log_enabled() { + crate::common::sdk_log::log_swqos_submitted( + "LunarLander", + trade_type, + start_time.elapsed(), + ); + } + } + } + + let start_time = Instant::now(); + match poll_transaction_confirmation(&self.rpc_client, signature, wait_confirmation).await { + Ok(_) => (), + Err(e) => { + if crate::common::sdk_log::sdk_log_enabled() { + println!(" signature: {:?}", signature); + println!( + " [{:width$}] {} confirmation failed: {:?}", + "LunarLander", + trade_type, + start_time.elapsed(), + width = crate::common::sdk_log::SWQOS_LABEL_WIDTH + ); + } + return Err(e); + } + } + if wait_confirmation && crate::common::sdk_log::sdk_log_enabled() { + println!(" signature: {:?}", signature); + println!( + " [{:width$}] {} confirmed: {:?}", + "LunarLander", + trade_type, + start_time.elapsed(), + width = crate::common::sdk_log::SWQOS_LABEL_WIDTH + ); + } + Ok(()) + } +} + +impl Drop for LunarLanderClient { + fn drop(&mut self) { + match &self.backend { + LunarLanderBackend::Http { stop_ping, ping_handle, .. } => { + stop_ping.store(true, Ordering::Relaxed); + if let Ok(mut guard) = ping_handle.try_lock() { + if let Some(handle) = guard.take() { + handle.abort(); + } + } + } + LunarLanderBackend::Quic(_) => {} + } + } +} + +fn quic_client_options(mev_protection: bool) -> ClientOptions { + ClientOptions { mev_protect: mev_protection, ..ClientOptions::default() } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn quic_options_follow_sdk_mev_protection() { + assert!(!quic_client_options(false).mev_protect); + assert!(quic_client_options(true).mev_protect); + } +} diff --git a/src/swqos/mod.rs b/src/swqos/mod.rs index a6e3ad4..ea71863 100755 --- a/src/swqos/mod.rs +++ b/src/swqos/mod.rs @@ -7,6 +7,7 @@ pub mod flashblock; pub mod helius; pub mod jito; pub mod lightspeed; +pub mod lunarlander; pub mod nextblock; pub mod node1; pub mod node1_quic; @@ -33,22 +34,23 @@ use crate::{ SWQOS_ENDPOINTS_ASTRALANE_QUIC, SWQOS_ENDPOINTS_ASTRALANE_QUIC_MEV, SWQOS_ENDPOINTS_BLOCKRAZOR, SWQOS_ENDPOINTS_BLOCKRAZOR_GRPC, SWQOS_ENDPOINTS_BLOX, SWQOS_ENDPOINTS_FLASHBLOCK, SWQOS_ENDPOINTS_HELIUS, SWQOS_ENDPOINTS_JITO, - SWQOS_ENDPOINTS_NEXTBLOCK, SWQOS_ENDPOINTS_NODE1, SWQOS_ENDPOINTS_NODE1_QUIC, - SWQOS_ENDPOINTS_SOLAMI, SWQOS_ENDPOINTS_SOYAS, SWQOS_ENDPOINTS_SPEEDLANDING, - SWQOS_ENDPOINTS_STELLIUM, SWQOS_ENDPOINTS_TEMPORAL, SWQOS_ENDPOINTS_ZERO_SLOT, - SWQOS_MIN_TIP_ASTRALANE, SWQOS_MIN_TIP_BLOCKRAZOR, SWQOS_MIN_TIP_BLOXROUTE, - SWQOS_MIN_TIP_DEFAULT, SWQOS_MIN_TIP_FLASHBLOCK, SWQOS_MIN_TIP_HELIUS, SWQOS_MIN_TIP_JITO, - SWQOS_MIN_TIP_LIGHTSPEED, SWQOS_MIN_TIP_NEXTBLOCK, SWQOS_MIN_TIP_NODE1, - SWQOS_MIN_TIP_SOLAMI, SWQOS_MIN_TIP_SOYAS, SWQOS_MIN_TIP_SPEEDLANDING, + SWQOS_ENDPOINTS_LUNARLANDER, SWQOS_ENDPOINTS_LUNARLANDER_QUIC, SWQOS_ENDPOINTS_NEXTBLOCK, + SWQOS_ENDPOINTS_NODE1, SWQOS_ENDPOINTS_NODE1_QUIC, SWQOS_ENDPOINTS_SOLAMI, + SWQOS_ENDPOINTS_SOYAS, SWQOS_ENDPOINTS_SPEEDLANDING, SWQOS_ENDPOINTS_STELLIUM, + SWQOS_ENDPOINTS_TEMPORAL, SWQOS_ENDPOINTS_ZERO_SLOT, SWQOS_MIN_TIP_ASTRALANE, + SWQOS_MIN_TIP_BLOCKRAZOR, SWQOS_MIN_TIP_BLOXROUTE, SWQOS_MIN_TIP_DEFAULT, + SWQOS_MIN_TIP_FLASHBLOCK, SWQOS_MIN_TIP_HELIUS, SWQOS_MIN_TIP_JITO, + SWQOS_MIN_TIP_LIGHTSPEED, SWQOS_MIN_TIP_LUNARLANDER, SWQOS_MIN_TIP_NEXTBLOCK, + SWQOS_MIN_TIP_NODE1, SWQOS_MIN_TIP_SOLAMI, SWQOS_MIN_TIP_SOYAS, SWQOS_MIN_TIP_SPEEDLANDING, SWQOS_MIN_TIP_STELLIUM, SWQOS_MIN_TIP_TEMPORAL, SWQOS_MIN_TIP_ZERO_SLOT, }, swqos::{ astralane::AstralaneClient, blockrazor::BlockRazorClient, bloxroute::BloxrouteClient, flashblock::FlashBlockClient, helius::HeliusClient, jito::JitoClient, - lightspeed::LightspeedClient, nextblock::NextBlockClient, node1::Node1Client, - node1_quic::Node1QuicClient, solami::SolamiClient, solana_rpc::SolRpcClient, - soyas::SoyasClient, speedlanding::SpeedlandingClient, stellium::StelliumClient, - temporal::TemporalClient, zeroslot::ZeroSlotClient, + lightspeed::LightspeedClient, lunarlander::LunarLanderClient, nextblock::NextBlockClient, + node1::Node1Client, node1_quic::Node1QuicClient, solami::SolamiClient, + solana_rpc::SolRpcClient, soyas::SoyasClient, speedlanding::SpeedlandingClient, + stellium::StelliumClient, temporal::TemporalClient, zeroslot::ZeroSlotClient, }, }; @@ -123,6 +125,7 @@ pub enum SwqosType { Speedlanding, Helius, Solami, + LunarLander, Default, } @@ -146,6 +149,7 @@ impl SwqosType { Self::Speedlanding => "Speedlanding", Self::Helius => "Helius", Self::Solami => "Solami", + Self::LunarLander => "LunarLander", Self::Default => "Default", } } @@ -167,6 +171,7 @@ impl SwqosType { Self::Speedlanding, Self::Helius, Self::Solami, + Self::LunarLander, Self::Default, ] } @@ -209,6 +214,7 @@ pub trait SwqosClientTrait { SwqosType::Speedlanding => SWQOS_MIN_TIP_SPEEDLANDING, SwqosType::Helius => SWQOS_MIN_TIP_HELIUS, SwqosType::Solami => SWQOS_MIN_TIP_SOLAMI, + SwqosType::LunarLander => SWQOS_MIN_TIP_LUNARLANDER, SwqosType::Default => SWQOS_MIN_TIP_DEFAULT, } } @@ -271,6 +277,10 @@ pub enum SwqosConfig { Helius(String, SwqosRegion, Option, Option), /// Solami(api_key, region, custom_url) Solami(String, SwqosRegion, Option), + /// Lunar Lander (HelloMoon): binary tx via HTTP POST /send-bin or QUIC (port 16888). + /// (api_key, region, custom_url, transport). transport=None => HTTP; Some(Quic) => QUIC. + /// Minimum tip: 0.001 SOL. Apply for API key: https://docs.hellomoon.io/reference/lunar-lander + LunarLander(String, SwqosRegion, Option, Option), } impl SwqosConfig { @@ -292,6 +302,7 @@ impl SwqosConfig { SwqosConfig::Speedlanding(_, _, _) => SwqosType::Speedlanding, SwqosConfig::Helius(_, _, _, _) => SwqosType::Helius, SwqosConfig::Solami(_, _, _) => SwqosType::Solami, + SwqosConfig::LunarLander(_, _, _, _) => SwqosType::LunarLander, } } @@ -321,6 +332,7 @@ impl SwqosConfig { SwqosType::Speedlanding => SWQOS_ENDPOINTS_SPEEDLANDING[region as usize].to_string(), SwqosType::Helius => SWQOS_ENDPOINTS_HELIUS[region as usize].to_string(), SwqosType::Solami => SWQOS_ENDPOINTS_SOLAMI[region as usize].to_string(), + SwqosType::LunarLander => SWQOS_ENDPOINTS_LUNARLANDER[region as usize].to_string(), SwqosType::Default => "".to_string(), } } @@ -354,6 +366,14 @@ impl SwqosConfig { SWQOS_ENDPOINTS_NODE1[region as usize].to_string() } } + SwqosType::LunarLander => { + let use_quic = transport.map_or(false, |t| t == SwqosTransport::Quic); + if use_quic { + SWQOS_ENDPOINTS_LUNARLANDER_QUIC[region as usize].to_string() + } else { + SWQOS_ENDPOINTS_LUNARLANDER[region as usize].to_string() + } + } _ => Self::get_endpoint(swqos_type, region, None), } } @@ -527,6 +547,27 @@ impl SwqosConfig { SolamiClient::new(rpc_url.clone(), endpoint.to_string(), auth_token).await?; Ok(Arc::new(solami_client)) } + SwqosConfig::LunarLander(api_key, region, url, transport) => { + let use_quic = transport.map_or(false, |t| t == SwqosTransport::Quic); + if use_quic { + let quic_endpoint = url.unwrap_or_else(|| { + SWQOS_ENDPOINTS_LUNARLANDER_QUIC[region as usize].to_string() + }); + let lunarlander_client = LunarLanderClient::new_quic( + rpc_url.clone(), + &quic_endpoint, + api_key, + mev_protection, + ) + .await?; + Ok(Arc::new(lunarlander_client)) + } else { + let endpoint = SwqosConfig::get_endpoint(SwqosType::LunarLander, region, url); + let lunarlander_client = + LunarLanderClient::new(rpc_url.clone(), endpoint, api_key); + Ok(Arc::new(lunarlander_client)) + } + } SwqosConfig::Default(endpoint) => { let rpc = SolanaRpcClient::new_with_commitment(endpoint, commitment); let rpc_client = SolRpcClient::new(Arc::new(rpc));