Struct HeliusStream 

pub struct HeliusStream { /* private fields */ }

A resilient Helius WebSocket client.

Subscribes to Solana account updates and tracks health (gaps, staleness, reconnect attempts). Synchronous; if you need async, wrap calls in tokio::task::spawn_blocking.

Implementations

impl HeliusStream

pub fn connect(config: StreamConfig) -> Result<Self, StreamError>

Open a WebSocket connection to the configured endpoint.

Examples found in repository

examples/basic_stream.rs (line 21)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // No logger init — keeps example dependency-free.
    // The crate uses `log` facade; to see internal logs, add env_logger
    // (or any log backend) to your binary's Cargo.toml and init here.

    let api_key = std::env::var("HELIUS_API_KEY")
        .map_err(|_| "set HELIUS_API_KEY in environment")?;

    let config = StreamConfig::mainnet(api_key);
    let mut stream = HeliusStream::connect(config)?;

    println!("[INIT] subscribing to USDC mint");
    stream.subscribe_account_b58(USDC_MINT)?;

    let mut received = 0;
    while let Some(update) = stream.next_update() {
        received += 1;
        println!(
            "[UPDATE] slot={} lamports={} data_bytes={} safe={} gap_rate={:.3}",
            update.slot,
            update.lamports,
            update.data.len(),
            stream.is_safe_for_simulation(),
            stream.health().gap_rate(),
        );
        if received >= 10 {
            println!("[DONE] received 10 updates, exiting");
            break;
        }
    }
    Ok(())
}

pub fn subscribe_account(&mut self, pubkey: Pubkey) -> Result<(), StreamError>

Subscribe to account updates for a 32-byte pubkey.

pub fn subscribe_account_b58( &mut self, addr: &str, ) -> Result<Pubkey, StreamError>

Convenience: subscribe by base58 string.

Examples found in repository

examples/basic_stream.rs (line 24)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // No logger init — keeps example dependency-free.
    // The crate uses `log` facade; to see internal logs, add env_logger
    // (or any log backend) to your binary's Cargo.toml and init here.

    let api_key = std::env::var("HELIUS_API_KEY")
        .map_err(|_| "set HELIUS_API_KEY in environment")?;

    let config = StreamConfig::mainnet(api_key);
    let mut stream = HeliusStream::connect(config)?;

    println!("[INIT] subscribing to USDC mint");
    stream.subscribe_account_b58(USDC_MINT)?;

    let mut received = 0;
    while let Some(update) = stream.next_update() {
        received += 1;
        println!(
            "[UPDATE] slot={} lamports={} data_bytes={} safe={} gap_rate={:.3}",
            update.slot,
            update.lamports,
            update.data.len(),
            stream.is_safe_for_simulation(),
            stream.health().gap_rate(),
        );
        if received >= 10 {
            println!("[DONE] received 10 updates, exiting");
            break;
        }
    }
    Ok(())
}

pub fn next_update(&mut self) -> Option<AccountUpdate>

Block until the next account update arrives, or return None on close.

Examples found in repository

examples/basic_stream.rs (line 27)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // No logger init — keeps example dependency-free.
    // The crate uses `log` facade; to see internal logs, add env_logger
    // (or any log backend) to your binary's Cargo.toml and init here.

    let api_key = std::env::var("HELIUS_API_KEY")
        .map_err(|_| "set HELIUS_API_KEY in environment")?;

    let config = StreamConfig::mainnet(api_key);
    let mut stream = HeliusStream::connect(config)?;

    println!("[INIT] subscribing to USDC mint");
    stream.subscribe_account_b58(USDC_MINT)?;

    let mut received = 0;
    while let Some(update) = stream.next_update() {
        received += 1;
        println!(
            "[UPDATE] slot={} lamports={} data_bytes={} safe={} gap_rate={:.3}",
            update.slot,
            update.lamports,
            update.data.len(),
            stream.is_safe_for_simulation(),
            stream.health().gap_rate(),
        );
        if received >= 10 {
            println!("[DONE] received 10 updates, exiting");
            break;
        }
    }
    Ok(())
}

pub fn check_staleness(&mut self)

Re-check freshness and update internal state if the stream went stale.

pub fn is_safe_for_simulation(&self) -> bool

True if state is Connected or mildly Degraded (≤2 slot gap). Use this as a circuit breaker before acting on data.

Examples found in repository

examples/basic_stream.rs (line 34)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // No logger init — keeps example dependency-free.
    // The crate uses `log` facade; to see internal logs, add env_logger
    // (or any log backend) to your binary's Cargo.toml and init here.

    let api_key = std::env::var("HELIUS_API_KEY")
        .map_err(|_| "set HELIUS_API_KEY in environment")?;

    let config = StreamConfig::mainnet(api_key);
    let mut stream = HeliusStream::connect(config)?;

    println!("[INIT] subscribing to USDC mint");
    stream.subscribe_account_b58(USDC_MINT)?;

    let mut received = 0;
    while let Some(update) = stream.next_update() {
        received += 1;
        println!(
            "[UPDATE] slot={} lamports={} data_bytes={} safe={} gap_rate={:.3}",
            update.slot,
            update.lamports,
            update.data.len(),
            stream.is_safe_for_simulation(),
            stream.health().gap_rate(),
        );
        if received >= 10 {
            println!("[DONE] received 10 updates, exiting");
            break;
        }
    }
    Ok(())
}

pub fn state(&self) -> &StreamState

pub fn health(&self) -> &StreamHealth

Examples found in repository

examples/basic_stream.rs (line 35)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // No logger init — keeps example dependency-free.
    // The crate uses `log` facade; to see internal logs, add env_logger
    // (or any log backend) to your binary's Cargo.toml and init here.

    let api_key = std::env::var("HELIUS_API_KEY")
        .map_err(|_| "set HELIUS_API_KEY in environment")?;

    let config = StreamConfig::mainnet(api_key);
    let mut stream = HeliusStream::connect(config)?;

    println!("[INIT] subscribing to USDC mint");
    stream.subscribe_account_b58(USDC_MINT)?;

    let mut received = 0;
    while let Some(update) = stream.next_update() {
        received += 1;
        println!(
            "[UPDATE] slot={} lamports={} data_bytes={} safe={} gap_rate={:.3}",
            update.slot,
            update.lamports,
            update.data.len(),
            stream.is_safe_for_simulation(),
            stream.health().gap_rate(),
        );
        if received >= 10 {
            println!("[DONE] received 10 updates, exiting");
            break;
        }
    }
    Ok(())
}

pub fn reconnect_policy_mut(&mut self) -> &mut ReconnectPolicy

pub fn subscription_count(&self) -> usize

pub fn pending_count(&self) -> usize