Real-Time Streams

let config = Config::builder()
    .api_key("sk_live_...")
    .leader_hints(true)
    .stream_tip_instructions(true)
    .stream_priority_fees(true)
    .stream_latest_blockhash(true)
    .stream_latest_slot(true)
    .build()?;

let mut rx = client.subscribe_leader_hints().await?;

while let Some(hint) = rx.recv().await {
    println!("Slot {}: leader={}", hint.slot, hint.leader_pubkey);
    println!("  Preferred region: {}", hint.preferred_region);
    println!("  Backup regions: {:?}", hint.backup_regions);
    println!("  Confidence: {}%", hint.confidence);
    println!("  TPU RTT: {}ms", hint.metadata.tpu_rtt_ms);
    println!("  Region score: {:.2}", hint.metadata.region_score);
    if let Some(rtt_map) = &hint.metadata.region_rtt_ms {
        for (region, rtt) in rtt_map {
            println!("    {}: {}ms", region, rtt);
        }
    }
}

await client.subscribeLeaderHints();

client.on("leaderHint", (hint) => {
    console.log(`Slot ${hint.slot}: leader=${hint.leaderPubkey}`);
    console.log(`  Preferred region: ${hint.preferredRegion}`);
    console.log(`  Backup regions: ${hint.backupRegions}`);
    console.log(`  Confidence: ${hint.confidence}%`);
    console.log(`  TPU RTT: ${hint.metadata.tpuRttMs}ms`);
    if (hint.metadata.regionRttMs) {
        for (const [region, rtt] of Object.entries(hint.metadata.regionRttMs)) {
            console.log(`    ${region}: ${rtt}ms`);
        }
    }
});

await client.subscribe_leader_hints()

@client.on("leader_hint")
async def on_leader_hint(hint):
    print(f"Slot {hint.slot}: leader={hint.leader_pubkey}")
    print(f"  Preferred region: {hint.preferred_region}")
    print(f"  Confidence: {hint.confidence}%")
    print(f"  TPU RTT: {hint.metadata.tpu_rtt_ms}ms")

let mut rx = client.subscribe_tip_instructions().await?;

while let Some(tip) = rx.recv().await {
    println!("Sender: {} ({})", tip.sender_name, tip.sender);
    println!("  Tip wallet: {}", tip.tip_wallet_address);
    println!("  Tip amount: {} SOL ({})", tip.tip_amount_sol, tip.tip_tier);
    println!("  Expected latency: {}ms", tip.expected_latency_ms);
    println!("  Confidence: {}%", tip.confidence);
    println!("  Valid until slot: {}", tip.valid_until_slot);
    for alt in &tip.alternative_senders {
        println!("  Alt: {} — {} SOL, confidence {}%",
            alt.sender, alt.tip_amount_sol, alt.confidence);
    }
}

await client.subscribeTipInstructions();

client.on("tipInstruction", (tip) => {
    console.log(`Sender: ${tip.senderName} (${tip.sender})`);
    console.log(`  Tip: ${tip.tipAmountSol} SOL (${tip.tipTier})`);
    console.log(`  Latency: ${tip.expectedLatencyMs}ms, confidence: ${tip.confidence}%`);
    for (const alt of tip.alternativeSenders) {
        console.log(`  Alt: ${alt.sender} — ${alt.tipAmountSol} SOL`);
    }
});

await client.subscribe_tip_instructions()

@client.on("tip_instruction")
async def on_tip(tip):
    print(f"Sender: {tip.sender_name} — {tip.tip_amount_sol} SOL ({tip.tip_tier})")
    print(f"  Latency: {tip.expected_latency_ms}ms, confidence: {tip.confidence}%")

if let Some(tip) = client.get_latest_tip() {
    println!("Latest tip: {} SOL via {}", tip.tip_amount_sol, tip.sender_name);
}

const tip = client.getLatestTip();
if (tip) console.log(`Latest tip: ${tip.tipAmountSol} SOL via ${tip.senderName}`);

tip = client.get_latest_tip()
if tip:
    print(f"Latest tip: {tip.tip_amount_sol} SOL via {tip.sender_name}")

let mut rx = client.subscribe_priority_fees().await?;

while let Some(fee) = rx.recv().await {
    println!("{} — {} micro-lamports/CU (limit: {})",
        fee.speed, fee.compute_unit_price, fee.compute_unit_limit);
    println!("  Est. cost: {} SOL", fee.estimated_cost_sol);
    println!("  Landing probability: {}%", fee.landing_probability);
    println!("  Congestion: {}", fee.network_congestion);
    println!("  Success rate: {:.1}%", fee.recent_success_rate * 100.0);
}

await client.subscribePriorityFees();

client.on("priorityFee", (fee) => {
    console.log(`${fee.speed} — ${fee.computeUnitPrice} micro-lamports/CU`);
    console.log(`  Est. cost: ${fee.estimatedCostSol} SOL`);
    console.log(`  Landing probability: ${fee.landingProbability}%`);
});

let mut rx = client.subscribe_latest_blockhash().await?;
while let Some(bh) = rx.recv().await {
    println!("Blockhash: {} (valid until height {})",
        bh.blockhash, bh.last_valid_block_height);
}

let mut rx = client.subscribe_latest_slot().await?;
while let Some(slot) = rx.recv().await {
    println!("Slot: {}", slot.slot);
}