quorum-sdk 0.1.0

Official Rust SDK for Quorum routing intelligence on Solana
Documentation
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; // 0.0001 SOL


    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(())
}