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

Merge pull request #96 from joe-hellomoon/feat/add-lunarlander-swqos

Browse Source 
# Conflicts:
#	Cargo.toml
#	src/constants/swqos.rs
#	src/swqos/lunarlander.rs
#	src/swqos/mod.rs
This commit is contained in:
0xfnzero
2026-07-12 17:55:32 +08:00
parent ca306172ca 70d1da0b13
commit 1c78b3cab2
6 changed files with 272 additions and 230 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/constants/swqos.rs
+27 -12
View File
@@ -447,19 +447,34 @@ pub const SWQOS_ENDPOINTS_SPEEDLANDING: [&str; 10] = [
"fra.speedlanding.trade:17778", // Default: 非地理区域；EU 枢纽
];
/// HelloMoon Lunar Lander: JSON-RPC sendTransaction, auth via ?api-key= query param.
/// 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.lunar-lander.hellomoon.io/send", // NewYork
"http://fra.lunar-lander.hellomoon.io/send", // Frankfurt
"http://ams.lunar-lander.hellomoon.io/send", // Amsterdam
"http://ams.lunar-lander.hellomoon.io/send", // Dublin -> Amsterdam
"http://ash.lunar-lander.hellomoon.io/send", // SLC -> Ashburn
"http://tyo.lunar-lander.hellomoon.io/send", // Tokyo
"http://tyo.lunar-lander.hellomoon.io/send", // Singapore -> Tokyo
"http://fra.lunar-lander.hellomoon.io/send", // London -> Frankfurt
"http://nyc.lunar-lander.hellomoon.io/send", // LosAngeles -> NYC
"http://lunar-lander.hellomoon.io/send", // Default
"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).
@@ -509,7 +524,6 @@ 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::*;
@@ -534,6 +548,7 @@ mod tests {
&SWQOS_ENDPOINTS_SPEEDLANDING,
&SWQOS_ENDPOINTS_HELIUS,
&SWQOS_ENDPOINTS_LUNARLANDER,
&SWQOS_ENDPOINTS_LUNARLANDER_QUIC,
&SWQOS_ENDPOINTS_SOLAMI,
];
src/swqos/lunarlander.rs
+191 -199
View File
@@ -1,34 +1,39 @@
//! HelloMoon Lunar Lander SWQOS client.
//!
//! High-performance transaction landing service with keep-alive ping.
//! Auth via `?api-key=` query parameter. Minimum tip: 0.001 SOL.
use crate::swqos::common::{
default_http_client_builder, poll_transaction_confirmation, serialize_transaction_and_encode,
};
use crate::swqos::common::{default_http_client_builder, poll_transaction_confirmation};
use rand::seq::IndexedRandom;
use reqwest::Client;
use serde_json::json;
use std::sync::atomic::{AtomicBool, Ordering};
use std::{sync::Arc, time::Instant};
use solana_transaction_status::UiTransactionEncoding;
use std::time::Duration;
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::LunarLanderQuicClient;
use tokio::sync::Mutex;
#[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<Mutex<LunarLanderQuicClient>>),
}
#[derive(Clone)]
pub struct LunarLanderClient {
pub endpoint: String,
pub api_key: String,
pub rpc_client: Arc<SolanaRpcClient>,
pub http_client: Client,
stop_ping: Arc<AtomicBool>,
backend: LunarLanderBackend,
}
#[async_trait::async_trait]
@@ -39,7 +44,7 @@ impl SwqosClientTrait for LunarLanderClient {
transaction: &VersionedTransaction,
wait_confirmation: bool,
) -> Result<()> {
self.send_transaction(trade_type, transaction, wait_confirmation).await
self.send_transaction_impl(trade_type, transaction, wait_confirmation).await
}
async fn send_transactions(
@@ -48,7 +53,10 @@ impl SwqosClientTrait for LunarLanderClient {
transactions: &Vec<VersionedTransaction>,
wait_confirmation: bool,
) -> Result<()> {
self.send_transactions(trade_type, transactions, wait_confirmation).await
for transaction in transactions {
self.send_transaction_impl(trade_type, transaction, wait_confirmation).await?;
}
Ok(())
}
fn get_tip_account(&self) -> Result<String> {
@@ -65,145 +73,184 @@ impl SwqosClientTrait for LunarLanderClient {
}
impl LunarLanderClient {
/// Derive the ping URL from the send endpoint by replacing the last path segment.
fn ping_url(endpoint: &str, api_key: &str) -> String {
// Find the last '/' that is part of the path (after "://")
let scheme_end = endpoint.find("://").map(|i| i + 3).unwrap_or(0);
let base = endpoint[scheme_end..]
.rfind('/')
.map(|i| &endpoint[..scheme_end + i])
.unwrap_or(endpoint);
format!("{}/ping?api-key={}", base, api_key)
}
/// Derive the send URL with the API key query parameter.
fn send_url(endpoint: &str, api_key: &str) -> String {
let separator = if endpoint.contains('?') { '&' } else { '?' };
format!("{}{}api-key={}", endpoint, separator, api_key)
}
pub fn new(rpc_url: String, endpoint: String, api_key: String) -> Self {
/// 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),
endpoint: endpoint.clone(),
api_key: api_key.clone(),
http_client: http_client.clone(),
stop_ping: stop_ping.clone(),
backend: LunarLanderBackend::Http {
endpoint,
auth_token,
http_client,
ping_handle,
stop_ping,
},
};
// 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.
/// GET /ping every 30s on the same TCP connection (recommended 30-45s by HelloMoon).
async fn start_ping_task(&self) {
let ping_url = Self::ping_url(&self.endpoint, &self.api_key);
let http_client = self.http_client.clone();
let stop_ping = self.stop_ping.clone();
tokio::spawn(async move {
// Immediate first ping to warm connection and reduce first-submit cold start latency
if let Ok(resp) =
http_client.get(&ping_url).timeout(Duration::from_millis(1500)).send().await
{
let status = resp.status();
let _ = resp.bytes().await;
if !status.is_success() && crate::common::sdk_log::sdk_log_enabled() {
eprintln!(" [lunarlander] ping failed with status: {}", status);
}
}
let mut interval = tokio::time::interval(Duration::from_secs(30));
loop {
interval.tick().await;
if stop_ping.load(Ordering::Relaxed) {
break;
}
match http_client.get(&ping_url).timeout(Duration::from_millis(1500)).send().await {
Ok(response) => {
let status = response.status();
let _ = response.bytes().await;
if !status.is_success() && crate::common::sdk_log::sdk_log_enabled() {
eprintln!(" [lunarlander] ping failed with status: {}", status);
}
}
Err(e) => {
if crate::common::sdk_log::sdk_log_enabled() {
eprintln!(" [lunarlander] ping request error: {:?}", e);
}
}
}
}
});
/// 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) -> Result<Self> {
let rpc_client = SolanaRpcClient::new(rpc_url);
let quic_client = LunarLanderQuicClient::connect(quic_endpoint, &api_key).await?;
Ok(Self {
rpc_client: Arc::new(rpc_client),
backend: LunarLanderBackend::Quic(Arc::new(Mutex::new(quic_client))),
})
}
pub async fn send_transaction(
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);
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 (content, signature) =
serialize_transaction_and_encode(transaction, UiTransactionEncoding::Base64)?;
let signature = transaction.signatures[0];
let body_bytes = bincode_serialize(transaction)
.map_err(|e| anyhow::anyhow!("LunarLander binary serialize failed: {}", e))?;
let request_body = serde_json::to_string(&json!({
"jsonrpc": "2.0",
"id": 1,
"method": "sendTransaction",
"params": [
content,
{ "encoding": "base64" }
]
}))?;
let url = Self::send_url(&self.endpoint, &self.api_key);
let response_text = self
.http_client
.post(&url)
.body(request_body)
.header("Content-Type", "application/json")
.header("Connection", "keep-alive")
.header("Keep-Alive", "timeout=30, max=1000")
.send()
.await?
.text()
.await?;
// Parse response
if let Ok(response_json) = serde_json::from_str::<serde_json::Value>(&response_text) {
if crate::common::sdk_log::sdk_log_enabled() {
if response_json.get("result").is_some() {
println!(" [lunarlander] {} submitted: {:?}", trade_type, start_time.elapsed());
} else if let Some(error) = response_json.get("error") {
eprintln!(" [lunarlander] {} submission failed: {:?}", trade_type, error);
match &self.backend {
LunarLanderBackend::Http { endpoint, auth_token, http_client, .. } => {
let url = format!("{}/send-bin", endpoint);
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) => {
let send_result = {
let client = quic.lock().await;
client.send_transaction(&body_bytes).await
};
if let Err(e) = send_result {
// Attempt reconnect on failure.
let mut client = quic.lock().await;
if let Err(re) = client.reconnect().await {
if crate::common::sdk_log::sdk_log_enabled() {
crate::common::sdk_log::log_swqos_submission_failed(
"LunarLander",
trade_type,
start_time.elapsed(),
format!("QUIC send failed: {}, reconnect failed: {}", e, re),
);
}
}
return Err(anyhow::anyhow!("LunarLander QUIC send failed: {}", e));
}
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() {
eprintln!(" [lunarlander] {} submission failed: {:?}", trade_type, response_text);
}
let start_time: Instant = Instant::now();
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!(
" [lunarlander] {} confirmation failed: {:?}",
" [{:width$}] {} confirmation failed: {:?}",
"LunarLander",
trade_type,
start_time.elapsed()
start_time.elapsed(),
width = crate::common::sdk_log::SWQOS_LABEL_WIDTH
);
}
return Err(e);
@@ -211,88 +258,33 @@ impl LunarLanderClient {
}
if wait_confirmation && crate::common::sdk_log::sdk_log_enabled() {
println!(" signature: {:?}", signature);
println!(" [lunarlander] {} confirmed: {:?}", trade_type, start_time.elapsed());
}
Ok(())
}
pub async fn send_transactions(
&self,
trade_type: TradeType,
transactions: &Vec<VersionedTransaction>,
wait_confirmation: bool,
) -> Result<()> {
for transaction in transactions {
self.send_transaction(trade_type, transaction, wait_confirmation).await?;
println!(
" [{:width$}] {} confirmed: {:?}",
"LunarLander",
trade_type,
start_time.elapsed(),
width = crate::common::sdk_log::SWQOS_LABEL_WIDTH
);
}
Ok(())
}
/// Stop the ping task
pub fn stop_ping_task(&self) {
self.stop_ping.store(true, Ordering::Relaxed);
}
}
impl Drop for LunarLanderClient {
fn drop(&mut self) {
// Stop ping task when client is dropped
self.stop_ping.store(true, Ordering::Relaxed);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_ping_url_default_endpoint() {
let url =
LunarLanderClient::ping_url("http://nyc.lunar-lander.hellomoon.io/send", "test-key");
assert_eq!(url, "http://nyc.lunar-lander.hellomoon.io/ping?api-key=test-key");
}
#[test]
fn test_ping_url_geolocated_endpoint() {
let url = LunarLanderClient::ping_url("http://lunar-lander.hellomoon.io/send", "test-key");
assert_eq!(url, "http://lunar-lander.hellomoon.io/ping?api-key=test-key");
}
#[test]
fn test_ping_url_custom_with_nested_path() {
let url = LunarLanderClient::ping_url("http://proxy.example.com/v2/lunar/send", "key123");
assert_eq!(url, "http://proxy.example.com/v2/lunar/ping?api-key=key123");
}
#[test]
fn test_ping_url_custom_pathless() {
// Custom URL with no path — should append /ping to the host
let url = LunarLanderClient::ping_url("http://proxy.example.com", "key123");
assert_eq!(url, "http://proxy.example.com/ping?api-key=key123");
}
#[test]
fn test_send_url_simple() {
let url =
LunarLanderClient::send_url("http://nyc.lunar-lander.hellomoon.io/send", "test-key");
assert_eq!(url, "http://nyc.lunar-lander.hellomoon.io/send?api-key=test-key");
}
#[test]
fn test_send_url_existing_query_params() {
let url = LunarLanderClient::send_url("http://proxy.example.com/send?foo=bar", "test-key");
assert_eq!(url, "http://proxy.example.com/send?foo=bar&api-key=test-key");
}
#[test]
fn test_tip_account_is_valid() {
// Verify the tip accounts array is non-empty and accounts parse as pubkeys
assert!(!LUNARLANDER_TIP_ACCOUNTS.is_empty());
for account in LUNARLANDER_TIP_ACCOUNTS {
// If these were invalid, the pubkey! macro would fail at compile time,
// but verify they are 32 bytes
assert_eq!(account.to_bytes().len(), 32);
match &self.backend {
LunarLanderBackend::Http { stop_ping, ping_handle, .. } => {
stop_ping.store(true, Ordering::Relaxed);
let ping_handle = ping_handle.clone();
tokio::spawn(async move {
let mut guard = ping_handle.lock().await;
if let Some(handle) = guard.as_ref() {
handle.abort();
}
*guard = None;
});
}
LunarLanderBackend::Quic(_) => {}
}
}
}
src/swqos/mod.rs
+37 -17
View File
@@ -34,14 +34,14 @@ 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_LUNARLANDER, 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_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::{
@@ -277,9 +277,10 @@ pub enum SwqosConfig {
Helius(String, SwqosRegion, Option<String>, Option<bool>),
/// Solami(api_key, region, custom_url)
Solami(String, SwqosRegion, Option<String>),
/// LunarLander(api_key, region, custom_url) - HelloMoon Lunar Lander
/// Minimum tip: 0.001 SOL
LunarLander(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 {
@@ -301,7 +302,7 @@ impl SwqosConfig {
SwqosConfig::Speedlanding(_, _, _) => SwqosType::Speedlanding,
SwqosConfig::Helius(_, _, _, _) => SwqosType::Helius,
SwqosConfig::Solami(_, _, _) => SwqosType::Solami,
SwqosConfig::LunarLander(_, _, _) => SwqosType::LunarLander,
SwqosConfig::LunarLander(_, _, _, _) => SwqosType::LunarLander,
}
}
@@ -365,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),
}
}
@@ -538,11 +547,22 @@ impl SwqosConfig {
SolamiClient::new(rpc_url.clone(), endpoint.to_string(), auth_token).await?;
Ok(Arc::new(solami_client))
}
SwqosConfig::LunarLander(api_key, region, url) => {
let endpoint = SwqosConfig::get_endpoint(SwqosType::LunarLander, region, url);
let lunarlander_client =
LunarLanderClient::new(rpc_url.clone(), endpoint.to_string(), api_key);
Ok(Arc::new(lunarlander_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)
.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);