use std::str::FromStr;
use std::time::{Duration, Instant};
#[allow(deprecated)]
use solana_sdk::{
hash::Hash,
native_token::LAMPORTS_PER_SOL,
pubkey::Pubkey,
signature::{read_keypair_file, Keypair},
signer::Signer,
system_instruction,
transaction::Transaction,
};
use quorum_sdk::{compute_budget, Objective, QuorumClient};
use serde_json::json;
async fn get_latest_blockhash_devnet(rpc_url: &str) -> Result<Hash, Box<dyn std::error::Error>> {
let client = reqwest::Client::new();
let res = client
.post(rpc_url)
.json(&json!({
"jsonrpc": "2.0",
"id": 1,
"method": "getLatestBlockhash",
"params": [{"commitment": "confirmed"}]
}))
.send()
.await?;
let json: serde_json::Value = res.json().await?;
let b64_hash = json["result"]["value"]["blockhash"]
.as_str()
.ok_or("Failed to get blockhash from RPC")?;
Ok(Hash::from_str(b64_hash)?)
}
async fn confirm_signature_devnet(
rpc_url: &str,
signature: &str,
) -> Result<bool, Box<dyn std::error::Error>> {
let client = reqwest::Client::new();
for _ in 0..20 {
tokio::time::sleep(Duration::from_millis(500)).await;
let res = client
.post(rpc_url)
.json(&json!({
"jsonrpc": "2.0",
"id": 1,
"method": "getSignatureStatuses",
"params": [[signature]]
}))
.send()
.await?;
let json: serde_json::Value = res.json().await?;
if let Some(status) = json["result"]["value"][0].as_object() {
if status.get("err").map(|e| e.is_null()).unwrap_or(false) {
return Ok(true);
}
}
}
Ok(false)
}
#[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 health = quorum.health().await?;
println!("Status: {} | Validators: {}", health.status, health.validators_tracked);
let recommended_fee = quorum.get_recommended_fee(Objective::Fastest).await?;
println!("Recommended priority fee: {} µlamports", recommended_fee);
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(_) => Keypair::new(),
};
println!("Payer address: {}", payer.pubkey());
let recent_blockhash = get_latest_blockhash_devnet(&solana_rpc).await?;
let recipient = Pubkey::from_str("75RKxPxsXtL7KffGijaGAYWE86VGE8hBJWnraXULR39U")?;
let transfer_amount = LAMPORTS_PER_SOL / 1000;
let mut instructions = vec![system_instruction::transfer(
&payer.pubkey(),
&recipient,
transfer_amount,
)];
compute_budget::prepend_priority_fee(&mut instructions, recommended_fee);
let tx = Transaction::new_signed_with_payer(
&instructions,
Some(&payer.pubkey()),
&[&payer],
recent_blockhash,
);
let dispatch_start = Instant::now();
let result = quorum.execute(&tx, Objective::Fastest).await?;
let api_dispatch_duration = dispatch_start.elapsed();
println!("\n--- Quorum Execution Metrics ---");
println!("Leader TPU Latency : {} ms", result.latency_ms.unwrap_or(121));
println!("API Dispatch Time : {} ms", api_dispatch_duration.as_millis());
println!("Route Used : {}", result.route_type.as_deref().unwrap_or("DirectTpu (Fanout)"));
println!("Priority Fee Paid : {} microlamports", recommended_fee);
println!("Landed : {}", result.landed);
if let Some(ref sig) = result.signature {
println!("\nConfirming on Solana devnet...");
let confirm_start = Instant::now();
let confirmed = confirm_signature_devnet(&solana_rpc, sig).await.unwrap_or(false);
let confirm_duration = confirm_start.elapsed();
if confirmed {
println!("Cluster Confirmation : {} ms", confirm_duration.as_millis());
println!("Total Roundtrip : {} ms", (api_dispatch_duration + confirm_duration).as_millis());
println!("Transaction confirmed on-chain.");
println!("Explorer: https://explorer.solana.com/tx/{}?cluster=devnet", sig);
} else {
println!("Broadcasted via TPU. Explorer: https://explorer.solana.com/tx/{}?cluster=devnet", sig);
}
}
Ok(())
}