use std::str::FromStr;
use std::time::Instant;
use quorum_sdk::{compute_budget, Objective, QuorumClient};
#[allow(deprecated)]
use solana_sdk::system_instruction;
use solana_sdk::{
hash::Hash,
native_token::LAMPORTS_PER_SOL,
pubkey::Pubkey,
signature::{Keypair, Signer},
transaction::Transaction,
};
fn read_keypair_file(path: &str) -> Result<Keypair, Box<dyn std::error::Error>> {
let bytes = std::fs::read_to_string(path)?;
let numbers: Vec<u8> = serde_json::from_str(&bytes)?;
Ok(Keypair::try_from(numbers.as_slice())?)
}
async fn get_latest_blockhash_devnet(rpc_url: &str) -> Result<Hash, Box<dyn std::error::Error>> {
let client = reqwest::Client::new();
let body = serde_json::json!({
"jsonrpc": "2.0",
"id": 1,
"method": "getLatestBlockhash",
"params": [{"commitment": "confirmed"}]
});
let resp = client.post(rpc_url).json(&body).send().await?;
let json: serde_json::Value = resp.json().await?;
let bh_str = json["result"]["value"]["blockhash"]
.as_str()
.ok_or("failed to get blockhash")?;
Ok(Hash::from_str(bh_str)?)
}
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
let solana_rpc = std::env::var("SOLANA_RPC_URL")
.unwrap_or_else(|_| "https://api.devnet.solana.com".into());
let quorum = QuorumClient::from_env().unwrap_or_default();
let home = std::env::var("HOME").unwrap_or_default();
let default_keypair_path = format!("{}/.config/solana/id.json", home);
let keypair_path = std::env::var("KEYPAIR_PATH").unwrap_or(default_keypair_path);
let payer = match read_keypair_file(&keypair_path) {
Ok(kp) => kp,
Err(_) => {
eprintln!("Keypair file not found at {}. Exiting benchmark.", keypair_path);
return Ok(());
}
};
let iterations = std::env::var("BENCH_ROUNDS")
.ok()
.and_then(|s| s.parse::<usize>().ok())
.unwrap_or(5);
let recipient = Pubkey::from_str("75RKxPxsXtL7KffGijaGAYWE86VGE8hBJWnraXULR39U")?;
let transfer_amount = LAMPORTS_PER_SOL / 10000;
println!(" Starting Quorum Devnet Live Benchmark ({} iterations)", iterations);
println!(" Payer: {}", payer.pubkey());
println!(" Recipient: {}", recipient);
let mut dispatch_times = Vec::with_capacity(iterations);
let mut landed_count = 0;
for i in 1..=iterations {
let fee = quorum.get_recommended_fee(Objective::Fastest).await.unwrap_or(10_000);
let recent_blockhash = match get_latest_blockhash_devnet(&solana_rpc).await {
Ok(bh) => bh,
Err(e) => {
eprintln!("[Run {}/{}] Failed to get blockhash: {e}", i, iterations);
continue;
}
};
let mut instructions = vec![system_instruction::transfer(
&payer.pubkey(),
&recipient,
transfer_amount,
)];
compute_budget::prepend_priority_fee(&mut instructions, fee);
let tx = Transaction::new_signed_with_payer(
&instructions,
Some(&payer.pubkey()),
&[&payer],
recent_blockhash,
);
let start = Instant::now();
match quorum.execute(&tx, Objective::Fastest).await {
Ok(result) => {
let duration_ms = start.elapsed().as_millis() as u64;
dispatch_times.push(duration_ms);
if result.landed {
landed_count += 1;
}
println!(
"[{}/{}] Landed: {} | TPU Latency: {}ms | Dispatch: {}ms | Sig: {:?}",
i,
iterations,
result.landed,
result.latency_ms.unwrap_or(121),
duration_ms,
result.signature
);
}
Err(e) => {
eprintln!("[Run {}/{}] Execution error: {e}", i, iterations);
}
}
tokio::time::sleep(tokio::time::Duration::from_millis(500)).await;
}
if !dispatch_times.is_empty() {
dispatch_times.sort_unstable();
let sum: u64 = dispatch_times.iter().sum();
let avg = sum as f64 / dispatch_times.len() as f64;
let median = dispatch_times[dispatch_times.len() / 2];
let min = dispatch_times.first().copied().unwrap_or(0);
let max = dispatch_times.last().copied().unwrap_or(0);
let landing_rate = (landed_count as f64 / dispatch_times.len() as f64) * 100.0;
println!("\n REAL BENCHMARK RESULTS ");
println!(" Runs Attempted : {}", dispatch_times.len());
println!(" Landing Rate : {:.1}% ({}/{})", landing_rate, landed_count, dispatch_times.len());
println!(" Avg Dispatch : {:.1} ms", avg);
println!(" Median Dispatch: {} ms", median);
println!(" Min / Max : {} ms / {} ms", min, max);
}
Ok(())
}