Struct Batch 

pub struct Batch { /* private fields */ }

Helper structure that caches all the requests before they are actually sent to the server.

Calls on this function are stored and run when batch_call is run on a Client.

This structure can be used to make multiple different calls in one single run. For batch calls of the same type, there are shorthands methods defined on the Client, like batch_script_get_balance to ask the server for the balance of multiple scripts with a single request.

Implementations

impl Batch

pub fn raw(&mut self, method: String, params: Vec<Param>)

Add a raw request to the batch queue

Examples found in repository

examples/batch_headers.rs (lines 33-36)

fn main() {
    let server = std::env::var("ELECTRUM_SERVER")
        .unwrap_or_else(|_| "wss://rostrum.riften.net:443".to_string());

    println!("Connecting to {}...", server);
    let client = match Client::new(&server) {
        Ok(c) => c,
        Err(e) => {
            eprintln!("Connection failed: {:?}", e);
            return;
        }
    };

    println!("Connected! Testing ping...");
    if let Err(e) = client.ping() {
        eprintln!("Ping failed: {:?}", e);
        return;
    }
    println!("Ping successful!");

    // Create a batch request for multiple block headers
    let mut batch = Batch::default();

    // Request headers for blocks 0, 1, 2, 3, 4
    let heights = [0, 1, 2, 3, 4];
    for height in &heights {
        batch.raw(
            "blockchain.block.header".to_string(),
            vec![Param::Usize(*height)],
        );
    }

    println!("\nBatch requesting {} headers...", heights.len());

    match client.batch_call(&batch) {
        Ok(results) => {
            println!("Got {} results:", results.len());
            for (i, (height, result)) in heights.iter().zip(results.iter()).enumerate() {
                let header_hex = result.as_str().unwrap_or("<not a string>");
                // Show first 32 chars of header hex
                let preview = if header_hex.len() > 64 {
                    format!("{}...", &header_hex[..64])
                } else {
                    header_hex.to_string()
                };
                println!("  [{}] Block {}: {}", i, height, preview);
            }
        }
        Err(e) => {
            eprintln!("Batch call failed: {:?}", e);
        }
    }
}

pub fn iter(&self) -> BatchIter<'_>

Returns an iterator on the batch

Trait Implementations

impl Default for Batch

fn default() -> Batch

Returns the “default value” for a type.

impl IntoIterator for Batch

type Item = (String, Vec<Param>)

The type of the elements being iterated over.

type IntoIter = IntoIter<<Batch as IntoIterator>::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.