Struct thor_devkit::hdnode::HDNodeBuilder

pub struct HDNodeBuilder<'a> { /* private fields */ }

Builder for HDNode: use this to construct a node from different sources.

The following sources are supported:

• Binary seed. 64 bytes of raw entropy to use for key generation.
• BIP39 mnemonic with optional password. This method is compatible with derivation in Sync2 wallet.
• Master private key bytes and chain code
• Extended private key
• Master public key bytes and chain code
• Extended public key

First two methods accept a derivation path to use (defaults to VeChain path).

For example, here’s what you could do:

use thor_devkit::hdnode::{Mnemonic, Language, HDNode};
use rand::RngCore;
use rand::rngs::OsRng;

let mnemonic = Mnemonic::from_phrase(
    "ignore empty bird silly journey junior ripple have guard waste between tenant",
    Language::English,
)
.expect("Should be constructible");
let wallet = HDNode::build().mnemonic(mnemonic).build().expect("Must be buildable");
// OR
let mut entropy = [0u8; 64];
OsRng.fill_bytes(&mut entropy);
let other_wallet = HDNode::build().seed(entropy).build().expect("Must be buildable");

Implementations

impl<'a> HDNodeBuilder<'a>

pub fn path(self, path: DerivationPath) -> Self

Set a derivation path to use.

If not called, defaults to VET_EXTERNAL_PATH.

pub fn seed(self, seed: [u8; 64]) -> Self

Set a seed to use.

pub fn mnemonic(self, mnemonic: Mnemonic) -> Self

Set a mnemonic to use. You may optionally provide a password as well.

Derivation from mnemonic is compatible with Sync2 wallet (with empty password).

pub fn mnemonic_with_password( self, mnemonic: Mnemonic, password: &'a str ) -> Self

Set a password for the mnemonic to use.

Replaces previous mnemonic, if any.

pub fn master_private_key_bytes<T: Into<ChainCode>>( self, key: [u8; 33], chain_code: T ) -> Self

Create an HDNode from private key bytes and chain code.

pub fn private_key(self, ext_key: ExtendedKey) -> Self

Create an HDNode from extended private key structure.

pub fn master_public_key_bytes<T: Into<ChainCode>>( self, key: [u8; 33], chain_code: T ) -> Self

Create an HDNode from private key bytes and chain code.

Beware that this node cannot be used to derive new private keys.

pub fn public_key(self, ext_key: ExtendedKey) -> Self

Create an HDNode from extended public key structure.

Beware that this node cannot be used to derive new private keys.

pub fn build(self) -> Result<HDNode, HDNodeError>

Create an HDNode from given arguments.

Trait Implementations

impl<'a> Clone for HDNodeBuilder<'a>

fn clone(&self) -> HDNodeBuilder<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Default for HDNodeBuilder<'a>

fn default() -> HDNodeBuilder<'a>

Returns the “default value” for a type.