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

Merge pull request #107 from 0xfnzero/codex/lunar-lander-integration

Browse Source 
feat(swqos): integrate Hello Moon Lunar Lander
This commit is contained in:
Wood
2026-07-12 18:03:57 +08:00
committed by GitHub
parent b09902c527 1d224770d8
commit 100156424c
6 changed files with 418 additions and 14 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Cargo.toml
+1
View File
@@ -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"
README.md
+11 -1
View File
@@ -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<SwqosConfig> = 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
README_CN.md
+11 -1
View File
@@ -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<SwqosConfig> = 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）
## 📁 项目结构
src/constants/swqos.rs
+47 -1
View File
@@ -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,
];
src/swqos/lunarlander.rs
+296
View File
@@ -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<tokio::sync::Mutex<Option<JoinHandle<()>>>>,
stop_ping: Arc<AtomicBool>,
},
Quic(Arc<LunarLanderQuicClient>),
}
#[derive(Clone)]
pub struct LunarLanderClient {
pub rpc_client: Arc<SolanaRpcClient>,
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<VersionedTransaction>,
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<String> {
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<Self> {
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);
}
}
src/swqos/mod.rs
+52 -11
View File
@@ -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<String>, Option<bool>),
/// Solami(api_key, region, custom_url)
Solami(String, SwqosRegion, Option<String>),
/// 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<String>, Option<SwqosTransport>),
}
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));