Struct HDKey

pub struct HDKey {
    pub master_seed: Seed,
    pub derivation_path: HDPath,
    pub derivation_purpose: HDPurpose,
    pub chain_code: [u8; 32],
    pub depth: u8,
    pub parent_fingerprint: [u8; 4],
    pub extended_private_key: Option<ExtendedPrivateKey>,
    pub extended_public_key: Option<ExtendedPublicKey>,
    pub child_index: u32,
    pub network: HDNetworkType,
}

Represents a master or a derived child HD (Hierarchical Deterministic) key.

The HDKey struct contains detailed information about a master node or derived child node HD key and provides methods to create and derive HD keys.

HDKey follows the BIP32 scheme: https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki HDKey also follows the purpose scheme described in BIP43: https://github.com/bitcoin/bips/blob/master/bip-0043.mediawiki The HDPurpose enum supports the following purpose types: BIP32, BIP44, BIP49, and BIP84.

Fields

master_seed: Seed

The seed used to create the master node

derivation_path: HDPath

The derivation path of the HDKey

derivation_purpose: HDPurpose

The derivation purpose associated with the HDKey

chain_code: [u8; 32]

The chain code

depth: u8

The depth used

parent_fingerprint: [u8; 4]

The fingerprint of the parent key

extended_private_key: Option<ExtendedPrivateKey>

The extended private key

extended_public_key: Option<ExtendedPublicKey>

The extended public key

child_index: u32

The child index value

network: HDNetworkType

The network type

Implementations

impl HDKey

pub fn new_master( seed: Seed, network_type: HDNetworkType, ) -> Result<HDKey, Error>

Create new master node for a HD wallet based on a seed

Follows the method described in BIP32: https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki to convert the seed to the master node extended private and public keys Multiple purpose types can be derived from the master node using the HDPurpose type

If this function encounters an error, it will return an Error type. this can happen if the seed is invalid or an error is encountered when specifying the extended private key and extended public key

pub fn new( seed: Seed, network_type: HDNetworkType, derivation_path: &str, ) -> Result<HDKey, Error>

Returns a new HDKey from a seed (Seed), network type (HDNetworkType) and derivation path string.

The HDKey returned will be the child key derived from the master node specified from the seed using the derivation path.

Returns an Error with further details if the seed is invalid or the derivation path is invalid

pub fn derive(&self, derivation_path: &str) -> Result<HDKey, Error>

Derives and returns a HDKey following the specified derivation path from the HDKey given as the self parameter as the parent key.

pub fn to_wif(&self) -> Result<String, Error>

Convert the ExtendedPrivateKey associated with the HDKey to a Wallet Import Format (WIF). Using wallet import format: https://en.bitcoin.it/wiki/Wallet_import_format Returns an Error if the extended private key is missing or another error is encountered.

pub fn extended_private_key(&self) -> Result<ExtendedPrivateKey, Error>

Returns the extended private key

Returns an error if the extended private key is missing

pub fn extended_public_key(&self) -> Result<ExtendedPublicKey, Error>

Returns the extended public key

Returns an error if the extended public key is missing

pub fn master_seed(&self) -> Seed

Returns the master seed

pub fn derivation_path(&self) -> HDPath

Returns the derivation path

pub fn chain_code(&self) -> [u8; 32]

Returns the chain code

pub fn depth(&self) -> u8

Returns the depth

pub fn parent_fingerprint(&self) -> [u8; 4]

Returns the parent fingerprint

pub fn child_index(&self) -> u32

Returns the child index

pub fn network(&self) -> HDNetworkType

Returns the network associated with the HD Key

pub fn extended_private_key_serialized(&self) -> Result<String, Error>

Extended Private Key Serialization

pub fn extended_public_key_serialized(&self) -> Result<String, Error>

Extended Public Key Serialization

Trait Implementations

impl Clone for HDKey

fn clone(&self) -> HDKey

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for HDKey

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

Formats the value using the given formatter.

impl PartialEq for HDKey

fn eq(&self, other: &HDKey) -> bool

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

const 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 Eq for HDKey

impl StructuralPartialEq for HDKey