Struct DerivationStandard

pub struct DerivationStandard<'a, 'b> {
    pub base_path: &'a str,
    pub starts_with: &'b str,
}

A derivation standard encapsulates the base derivation path used for key derivation and the expected address prefix that results from using that standard.

For instance, legacy addresses use the base path "m/44'/0'/0'/0/" and expect addresses starting with "1", whereas native SegWit addresses use "m/84'/0'/0'/0/" with addresses beginning with "bc1q".

Examples

use bit_digger::matcher::DerivationStandard;

let standard = DerivationStandard::new("m/44'/0'/0'/0/", "1");
assert_eq!(standard.base_path, "m/44'/0'/0'/0/");
assert_eq!(standard.starts_with, "1");

Fields

base_path: &'a str

The base derivation path used to generate keys. Must have an ending back slash, i.e.

let valid_base_path = "m/44'/0'/0'/0/";

starts_with: &'b str

The expected starting string/prefix for addresses generated with this standard.

Implementations

impl DerivationStandard<'_, '_>

pub fn new<'a, 'b>( base_path: &'a str, starts_with: &'b str, ) -> DerivationStandard<'a, 'b>

Returns a derivation standard with the given base path and expected address prefix.

Examples

use bit_digger::matcher::DerivationStandard;
let standard = DerivationStandard::new("m/44'/0'/0'/0/", "1");

pub fn from_address(address: &str) -> Option<&DerivationStandard<'_, '_>>

Returns a reference to derivation standard if the address starts with a supported prefix.

Examples

use bit_digger::matcher::DerivationStandard;
let standard = DerivationStandard::from_address("1BvB...");
assert_eq!(standard.unwrap().base_path, "m/44'/0'/0'/0/");

pub fn into_address( &self, path: &DerivationPath, xpriv: &Xpriv, ) -> Result<String, MatcherError>

Converts the provided derivation path and extended private key into a Bitcoin address

Errors

Returns a MatcherError if key derivation fails or if a public key cannot be properly compressed.

Examples

See examples in Matcher::generate_addresses

pub fn from_prefix(prefix: &str) -> Option<&DerivationStandard<'_, '_>>

Returns a derivation standard if the address starts with a supported prefix.

pub fn get_supported_standards() -> &'static [DerivationStandard<'static, 'static>]

Returns a slice of supported derivation standards.

Trait Implementations

impl<'a, 'b> Clone for DerivationStandard<'a, 'b>

fn clone(&self) -> DerivationStandard<'a, 'b>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, 'b> Debug for DerivationStandard<'a, 'b>

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

Formats the value using the given formatter.

impl<'a, 'b> PartialEq for DerivationStandard<'a, 'b>

fn eq(&self, other: &DerivationStandard<'a, 'b>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b> StructuralPartialEq for DerivationStandard<'a, 'b>