Struct BatchAddressGenerator 

pub struct BatchAddressGenerator { /* private fields */ }

Batch address generator for efficient address generation.

BatchAddressGenerator provides a high-performance API for generating large batches of addresses with parallel processing and streaming output.

Example

use rustywallet_batch::address::{BatchAddressGenerator, BatchAddressType};
use rustywallet_address::Network;

// Create generator for P2WPKH addresses on mainnet
let generator = BatchAddressGenerator::new(BatchAddressType::P2WPKH, Network::BitcoinMainnet);

// Generate 100 addresses as a vector
let addresses = generator.generate_vec(100).unwrap();
assert_eq!(addresses.len(), 100);

// Or stream addresses for memory efficiency
for (key, addr) in generator.generate_stream(1000).take(10) {
    println!("{}: {}", key.to_hex(), addr);
}

Implementations

impl BatchAddressGenerator

pub fn new(address_type: BatchAddressType, network: Network) -> Self

Create a new batch address generator.

Arguments

• address_type - The type of addresses to generate (P2PKH, P2WPKH, P2TR)
• network - The Bitcoin network (mainnet or testnet)

Example

use rustywallet_batch::address::{BatchAddressGenerator, BatchAddressType};
use rustywallet_address::Network;

let generator = BatchAddressGenerator::new(BatchAddressType::P2TR, Network::BitcoinMainnet);

pub fn parallel(self, enabled: bool) -> Self

Enable or disable parallel processing.

Parallel processing is enabled by default for better performance.

pub fn chunk_size(self, size: usize) -> Self

Set the chunk size for streaming operations.

Larger chunks improve throughput but use more memory. Default is 1000.

pub fn address_type(&self) -> BatchAddressType

Get the address type.

pub fn network(&self) -> Network

Get the network.

pub fn generate_stream(&self, count: usize) -> AddressStream

Generate addresses as a streaming iterator.

This method returns an iterator that generates key-address pairs on-demand, allowing processing of millions of addresses without memory exhaustion.

Arguments

• count - The number of addresses to generate

Example

use rustywallet_batch::address::{BatchAddressGenerator, BatchAddressType};
use rustywallet_address::Network;

let generator = BatchAddressGenerator::new(BatchAddressType::P2WPKH, Network::BitcoinMainnet);

// Stream 1 million addresses without storing all in memory
for (key, addr) in generator.generate_stream(1_000_000).take(100) {
    println!("{}", addr);
}

pub fn generate_vec( &self, count: usize, ) -> Result<Vec<(PrivateKey, String)>, BatchError>

Generate addresses and collect them into a vector.

This method generates all addresses and stores them in memory. For large batches, consider using generate_stream() for streaming.

Arguments

• count - The number of addresses to generate

Example

use rustywallet_batch::address::{BatchAddressGenerator, BatchAddressType};
use rustywallet_address::Network;

let generator = BatchAddressGenerator::new(BatchAddressType::P2PKH, Network::BitcoinMainnet);
let addresses = generator.generate_vec(1000).unwrap();

for (key, addr) in &addresses {
    assert!(addr.starts_with('1'));
}

Trait Implementations

impl Clone for BatchAddressGenerator

fn clone(&self) -> BatchAddressGenerator

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BatchAddressGenerator

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.