Crate rustywallet_batch 

rustywallet-batch

High-performance batch key and address generation for cryptocurrency wallets.

This crate provides efficient APIs for generating large batches of private keys and addresses with parallel processing, SIMD optimization, and memory-efficient streaming.

Features

• Batch Generation: Generate millions of keys and addresses efficiently
• Address Generation: Support for P2PKH, P2WPKH, and P2TR address types
• Parallel Processing: Utilize all CPU cores with rayon
• Memory Streaming: Process unlimited keys/addresses without memory exhaustion
• Incremental Scanning: Scan key ranges using EC point addition
• SIMD Optimization: Use SIMD instructions for faster processing
• Memory-Mapped Output: Write directly to files without buffering
• Resume Capability: Checkpoint and resume long-running operations
• Configurable: Flexible configuration for different use cases

Batch Address Generation

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

// Generate 1000 P2WPKH addresses in parallel
let generator = BatchAddressGenerator::new(BatchAddressType::P2WPKH, Network::BitcoinMainnet);
let addresses = generator.generate_vec(1000).unwrap();

println!("Generated {} addresses", addresses.len());

// Stream addresses for memory efficiency
for (key, addr) in generator.generate_stream(1_000_000).take(100) {
    println!("{}: {}", key.to_hex(), addr);
}

Quick Start

use rustywallet_batch::prelude::*;

// Generate 1000 keys in parallel
let keys = BatchGenerator::new()
    .count(1000)
    .parallel()
    .generate_vec()
    .unwrap();

println!("Generated {} keys", keys.len());

Streaming Large Batches

use rustywallet_batch::prelude::*;

// Stream keys without storing all in memory
let stream = BatchGenerator::new()
    .count(1_000_000)
    .generate()
    .unwrap();

for key in stream.take(100) {
    println!("{}", key.unwrap().to_hex());
}

Memory-Mapped File Output

use rustywallet_batch::mmap::{MmapBatchGenerator, OutputFormat};

// Generate keys directly to file
let count = MmapBatchGenerator::new("keys.txt", 1_000_000)
    .format(OutputFormat::Hex)
    .parallel(true)
    .generate()
    .unwrap();

println!("Generated {} keys to file", count);

Resumable Generation

use rustywallet_batch::checkpoint::ResumableBatchGenerator;

// Start or resume generation with checkpoints
let mut generator = ResumableBatchGenerator::new(
    "my-job",
    10_000_000,
    "keys.txt",
    "checkpoint.json",
);

generator.generate_with_progress(|progress| {
    println!("Progress: {:.1}%", progress);
}).unwrap();

SIMD Optimization

use rustywallet_batch::simd::SimdBatchProcessor;

// Check SIMD availability
println!("SIMD: {} ({})", 
    SimdBatchProcessor::is_available(),
    SimdBatchProcessor::feature_name()
);

// Generate with SIMD optimization
let processor = SimdBatchProcessor::new();
let keys = processor.parallel_generate(10_000);

Incremental Key Scanning

use rustywallet_batch::prelude::*;
use rustywallet_keys::prelude::PrivateKey;

// Scan from a base key
let base = PrivateKey::from_hex(
    "0000000000000000000000000000000000000000000000000000000000000001"
).unwrap();

let scanner = KeyScanner::new(base)
    .direction(ScanDirection::Forward);

for key in scanner.scan_range(10) {
    println!("{}", key.unwrap().to_hex());
}

Configuration Presets

use rustywallet_batch::prelude::*;

// Fast mode - maximum speed
let config = BatchConfig::fast();

// Balanced mode - good speed with reasonable memory
let config = BatchConfig::balanced();

// Memory efficient - minimal memory usage
let config = BatchConfig::memory_efficient();

Re-exports

pub use address::AddressStream;

pub use address::BatchAddressGenerator;

pub use address::BatchAddressType;

pub use checkpoint::Checkpoint;

pub use checkpoint::GenerationMode;

pub use checkpoint::ResumableBatchGenerator;

pub use config::BatchConfig;

pub use error::BatchError;

pub use fast_gen::FastKeyGenerator;

pub use fast_gen::IncrementalKeyGenerator;

pub use generator::BatchGenerator;

pub use mmap::MmapBatchGenerator;

pub use mmap::MmapWriter;

pub use mmap::OutputFormat;

pub use scanner::KeyScanner;

pub use scanner::ScanDirection;

pub use simd::SimdBatchProcessor;

pub use stream::KeyStream;

Modules

address

Batch address generation.

checkpoint

Checkpoint and resume support for batch generation.

config

Configuration types for batch key generation.

error

Error types for batch key generation operations.

fast_gen

Fast key generation using optimized RNG.

generator

Batch key generation.

mmap

Memory-mapped file output for batch key generation.

prelude

Convenient re-exports for common types.

scanner

Incremental key scanning using EC point addition.

simd

SIMD-optimized operations for batch key generation.

stream

Memory-efficient key streaming.