Struct Client 

pub struct Client { /* private fields */ }

Generalized Electrum client that supports multiple backends. Can re-instantiate client_type if connections drops

Implementations

impl Client

pub fn new(url: &str) -> Result<Self, Error>

Default constructor supporting multiple backends by providing a prefix

Supported prefixes are:

• tcp:// for a TCP plaintext client.
• ssl:// for an SSL-encrypted client. The server certificate will be verified.
• ws:// for a WebSocket client (requires use-websocket feature).
• wss:// for a secure WebSocket client (requires use-websocket and a rustls feature).

If no prefix is specified, then tcp:// is assumed.

See Client::from_config for more configuration options

Examples found in repository

examples/plaintext.rs (line 4)

fn main() {
    let client = Client::new("tcp://electrum.blockstream.info:50001").unwrap();
    let res = client.ping();
    println!("{:#?}", res);
}

examples/ssl.rs (line 4)

fn main() {
    let client = Client::new("ssl://electrum.blockstream.info:50002").unwrap();
    let res = client.ping();
    println!("{:#?}", res);
}

examples/websocket.rs (line 15)

fn main() {
    // Test WSS (secure WebSocket)
    // You can override the server with environment variables:
    //   WSS_SERVER=wss://your-server:port cargo run --example websocket --features use-websocket
    let wss_server =
        std::env::var("WSS_SERVER").unwrap_or_else(|_| "wss://rostrum.riften.net:443".to_string());

    println!("Testing WSS connection to {}...", wss_server);
    match Client::new(&wss_server) {
        Ok(client) => {
            println!("Connected to WSS server!");
            match client.ping() {
                Ok(()) => println!("WSS ping successful!"),
                Err(e) => println!("WSS ping failed: {:?}", e),
            }
        }
        Err(e) => println!("WSS connection failed: {:?}", e),
    }

    // Test WS (plaintext WebSocket)
    let ws_server = std::env::var("WS_SERVER")
        .unwrap_or_else(|_| "ws://rostrum.cauldron.quest:50003".to_string());

    println!("\nTesting WS connection to {}...", ws_server);
    match Client::new(&ws_server) {
        Ok(client) => {
            println!("Connected to WS server!");
            match client.ping() {
                Ok(()) => println!("WS ping successful!"),
                Err(e) => println!("WS ping failed: {:?}", e),
            }
        }
        Err(e) => println!("WS connection failed: {:?}", e),
    }
}

examples/batch_headers.rs (line 12)

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 from_config(url: &str, config: Config) -> Result<Self, Error>

Generic constructor that supports multiple backends and allows configuration through the Config

Examples found in repository

examples/tor.rs (line 9)

fn main() {
    // NOTE: This assumes Tor is running localy, with an unauthenticated Socks5 listening at
    // localhost:9050
    let proxy = Socks5Config::new("127.0.0.1:9050");
    let config = ConfigBuilder::new().socks5(Some(proxy)).build();

    let client = Client::from_config("tcp://explorernuoc63nb.onion:110", config.clone()).unwrap();
    let res = client.ping();
    println!("{:#?}", res);

    // works both with onion v2/v3 (if your Tor supports them)
    let client = Client::from_config(
        "tcp://explorerzydxu5ecjrkwceayqybizmpjjznk5izmitf2modhcusuqlid.onion:110",
        config,
    )
    .unwrap();
    let res = client.ping();
    println!("{:#?}", res);
}

Trait Implementations

impl ElectrumApi for Client

fn raw_call( &self, method_name: &str, params: impl IntoIterator<Item = Param>, ) -> Result<Value, Error>

Executes the requested API call returning the raw answer.

fn batch_call(&self, batch: &Batch) -> Result<Vec<Value>, Error>

Execute a queue of calls stored in a Batch struct. Returns Ok() only if all of the calls are successful. The order of the JSON Values returned reflects the order in which the calls were made on the Batch struct.

fn ping(&self) -> Result<(), Error>

Pings the server. This method can also be used as a “dummy” call to trigger the processing of incoming block header or script notifications.