Struct hdwallet::extended_key::ExtendedPrivKey

pub struct ExtendedPrivKey {
    pub private_key: SecretKey,
    pub chain_code: Vec<u8>,
}

ExtendedPrivKey is used for child key derivation. See secp256k1 crate documentation for SecretKey signatures usage.

Examples

use hdwallet::{ExtendedPrivKey, KeyIndex};
use rand;

let mut rng = rand::thread_rng();
let master_key = ExtendedPrivKey::random(&mut rng).unwrap();
let hardened_key_index = KeyIndex::hardened_from_normalize_index(0).unwrap();
let hardended_child_priv_key = master_key.derive_private_key(hardened_key_index).unwrap();
let normal_key_index = KeyIndex::Normal(0);
let noamal_child_priv_key = master_key.derive_private_key(normal_key_index).unwrap();

Fields

private_key: SecretKey

chain_code: Vec<u8>

Implementations

impl ExtendedPrivKey

pub fn random<R: RngCore + CryptoRng>( rng: &mut R ) -> Result<ExtendedPrivKey, Error>

Generate an ExtendedPrivKey, use 256 size random seed.

pub fn random_with_seed_size<R: RngCore + CryptoRng>( rng: &mut R, seed_size: KeySeed ) -> Result<ExtendedPrivKey, Error>

Generate an ExtendedPrivKey which use 128 or 256 or 512 bits random seed.

pub fn with_seed(seed: &[u8]) -> Result<ExtendedPrivKey, Error>

Generate an ExtendedPrivKey from seed

pub fn derive_private_key( &self, key_index: KeyIndex ) -> Result<ExtendedPrivKey, Error>

Derive a child key from ExtendedPrivKey.

Trait Implementations

impl Clone for ExtendedPrivKey

fn clone(&self) -> ExtendedPrivKey

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ExtendedPrivKey

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

Formats the value using the given formatter.

impl Deserialize<&[u8], Error> for ExtendedPrivKey

fn deserialize(data: &[u8]) -> Result<Self, Error>

impl PartialEq<ExtendedPrivKey> for ExtendedPrivKey

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize<Vec<u8, Global>> for ExtendedPrivKey

fn serialize(&self) -> Vec<u8>

impl Eq for ExtendedPrivKey

impl StructuralEq for ExtendedPrivKey

impl StructuralPartialEq for ExtendedPrivKey