Struct KeyScanner 

pub struct KeyScanner { /* private fields */ }

Incremental key scanner using EC point addition.

KeyScanner efficiently generates sequential keys by adding or subtracting a constant value from a base key, which is faster than generating random keys.

Example

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

let base = PrivateKey::from_hex(
    "0000000000000000000000000000000000000000000000000000000000000001"
).unwrap();

// Scan forward from base key
let scanner = KeyScanner::new(base.clone())
    .direction(ScanDirection::Forward);

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

// Scan backward
let scanner = KeyScanner::new(base)
    .direction(ScanDirection::Backward);

Implementations

impl KeyScanner

pub fn new(base_key: PrivateKey) -> Self

Create a new key scanner starting from the given base key.

pub fn direction(self, direction: ScanDirection) -> Self

Set the scanning direction.

pub fn step(self, step: u64) -> Self

Set the step size for each increment/decrement.

pub fn scan_range(self, count: usize) -> KeyStream

Scan a range of keys starting from the base key.

Returns a KeyStream that yields keys incrementally.

pub fn scan_until<F>(self, predicate: F) -> KeyStream

where F: Fn(&PrivateKey) -> bool + Send + 'static,

Scan keys until a predicate returns true.

Returns a KeyStream that yields keys until the predicate matches.

Trait Implementations

impl Clone for KeyScanner

fn clone(&self) -> KeyScanner

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KeyScanner

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

Formats the value using the given formatter.