quorum-sdk 0.1.0

Official Rust SDK for Quorum routing intelligence on Solana
Documentation
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(())
}