// Rust Bitcoin Library // Written in 2014 by // Andrew Poelstra // To the extent possible under law, the author(s) have dedicated all // copyright and related and neighboring rights to this software to // the public domain worldwide. This software is distributed without // any warranty. // // You should have received a copy of the CC0 Public Domain Dedication // along with this software. // If not, see . // //! BIP32 Implementation //! //! Implementation of BIP32 hierarchical deterministic wallets, as defined //! at https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki use std::default::Default; use std::io::Cursor; use std::{error, fmt}; use std::str::FromStr; #[cfg(feature = "serde")] use serde; use byteorder::{BigEndian, ByteOrder, ReadBytesExt}; use bitcoin_hashes::{hash160, sha512, Hash, HashEngine, Hmac, HmacEngine}; use secp256k1::key::{PublicKey, SecretKey}; use secp256k1::{self, Secp256k1}; use network::constants::Network; use util::base58; /// A chain code pub struct ChainCode([u8; 32]); impl_array_newtype!(ChainCode, u8, 32); impl_array_newtype_show!(ChainCode); impl_array_newtype_encodable!(ChainCode, u8, 32); /// A fingerprint pub struct Fingerprint([u8; 4]); impl_array_newtype!(Fingerprint, u8, 4); impl_array_newtype_show!(Fingerprint); impl_array_newtype_encodable!(Fingerprint, u8, 4); impl Default for Fingerprint { fn default() -> Fingerprint { Fingerprint([0; 4]) } } /// Extended private key #[derive(Copy, Clone, PartialEq, Eq, Debug)] pub struct ExtendedPrivKey { /// The network this key is to be used on pub network: Network, /// How many derivations this key is from the master (which is 0) pub depth: u8, /// Fingerprint of the parent key (0 for master) pub parent_fingerprint: Fingerprint, /// Child number of the key used to derive from parent (0 for master) pub child_number: ChildNumber, /// Secret key pub secret_key: SecretKey, /// Chain code pub chain_code: ChainCode } /// Extended public key #[derive(Copy, Clone, PartialEq, Eq, Debug)] pub struct ExtendedPubKey { /// The network this key is to be used on pub network: Network, /// How many derivations this key is from the master (which is 0) pub depth: u8, /// Fingerprint of the parent key pub parent_fingerprint: Fingerprint, /// Child number of the key used to derive from parent (0 for master) pub child_number: ChildNumber, /// Public key pub public_key: PublicKey, /// Chain code pub chain_code: ChainCode } /// A child number for a derived key #[derive(Copy, Clone, PartialEq, Eq, Debug)] pub enum ChildNumber { /// Non-hardened key Normal { /// Key index, within [0, 2^31 - 1] index: u32 }, /// Hardened key Hardened { /// Key index, within [0, 2^31 - 1] index: u32 }, } impl ChildNumber { /// Create a [`Normal`] from an index, returns an error if the index is not within /// [0, 2^31 - 1]. /// /// [`Normal`]: #variant.Normal pub fn from_normal_idx(index: u32) -> Result { if index & (1 << 31) == 0 { Ok(ChildNumber::Normal { index: index }) } else { Err(Error::InvalidChildNumber(index)) } } /// Create a [`Hardened`] from an index, returns an error if the index is not within /// [0, 2^31 - 1]. /// /// [`Hardened`]: #variant.Hardened pub fn from_hardened_idx(index: u32) -> Result { if index & (1 << 31) == 0 { Ok(ChildNumber::Hardened { index: index }) } else { Err(Error::InvalidChildNumber(index)) } } /// Returns `true` if the child number is a [`Normal`] value. /// /// [`Normal`]: #variant.Normal pub fn is_normal(&self) -> bool { !self.is_hardened() } /// Returns `true` if the child number is a [`Hardened`] value. /// /// [`Hardened`]: #variant.Hardened pub fn is_hardened(&self) -> bool { match *self { ChildNumber::Hardened {..} => true, ChildNumber::Normal {..} => false, } } } impl From for ChildNumber { fn from(number: u32) -> Self { if number & (1 << 31) != 0 { ChildNumber::Hardened { index: number ^ (1 << 31) } } else { ChildNumber::Normal { index: number } } } } impl From for u32 { fn from(cnum: ChildNumber) -> Self { match cnum { ChildNumber::Normal { index } => index, ChildNumber::Hardened { index } => index | (1 << 31), } } } impl fmt::Display for ChildNumber { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { ChildNumber::Hardened { index } => write!(f, "{}'", index), ChildNumber::Normal { index } => write!(f, "{}", index), } } } impl FromStr for ChildNumber { type Err = Error; fn from_str(inp: &str) -> Result { Ok(match inp.chars().last().map_or(false, |l| l == '\'' || l == 'h') { true => ChildNumber::from_hardened_idx( inp[0..inp.len() - 1].parse().map_err(|_| Error::InvalidChildNumberFormat)? )?, false => ChildNumber::from_normal_idx( inp.parse().map_err(|_| Error::InvalidChildNumberFormat)? )?, }) } } #[cfg(feature = "serde")] impl<'de> serde::Deserialize<'de> for ChildNumber { fn deserialize(deserializer: D) -> Result where D: serde::Deserializer<'de>, { u32::deserialize(deserializer).map(ChildNumber::from) } } #[cfg(feature = "serde")] impl serde::Serialize for ChildNumber { fn serialize(&self, serializer: S) -> Result where S: serde::Serializer, { u32::from(*self).serialize(serializer) } } /// A BIP-32 derivation path. #[derive(Clone, PartialEq, Eq)] pub struct DerivationPath(Vec); impl_index_newtype!(DerivationPath, ChildNumber); impl From> for DerivationPath { fn from(numbers: Vec) -> Self { DerivationPath(numbers) } } impl Into> for DerivationPath { fn into(self) -> Vec { self.0 } } impl<'a> From<&'a [ChildNumber]> for DerivationPath { fn from(numbers: &'a [ChildNumber]) -> Self { DerivationPath(numbers.to_vec()) } } impl ::std::iter::FromIterator for DerivationPath { fn from_iter(iter: T) -> Self where T: IntoIterator { DerivationPath(Vec::from_iter(iter)) } } impl<'a> ::std::iter::IntoIterator for &'a DerivationPath { type Item = &'a ChildNumber; type IntoIter = ::std::slice::Iter<'a, ChildNumber>; fn into_iter(self) -> Self::IntoIter { self.0.iter() } } impl AsRef<[ChildNumber]> for DerivationPath { fn as_ref(&self) -> &[ChildNumber] { &self.0 } } impl FromStr for DerivationPath { type Err = Error; fn from_str(path: &str) -> Result { let mut parts = path.split("/"); // First parts must be `m`. if parts.next().unwrap() != "m" { return Err(Error::InvalidDerivationPathFormat); } let ret: Result, Error> = parts.map(str::parse).collect(); Ok(DerivationPath(ret?)) } } impl DerivationPath { /// Create a new DerivationPath that is a child of this one. pub fn child(&self, cn: ChildNumber) -> DerivationPath { let mut path = self.0.clone(); path.push(cn); DerivationPath(path) } /// Convert into a DerivationPath that is a child of this one. pub fn into_child(self, cn: ChildNumber) -> DerivationPath { let mut path = self.0; path.push(cn); DerivationPath(path) } } impl fmt::Display for DerivationPath { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str("m")?; for cn in self.0.iter() { f.write_str("/")?; fmt::Display::fmt(cn, f)?; } Ok(()) } } impl fmt::Debug for DerivationPath { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&self, f) } } #[cfg(feature = "serde")] impl<'de> serde::Deserialize<'de> for DerivationPath { fn deserialize>(deserializer: D) -> Result { use std::fmt; use serde::de; struct Visitor; impl<'de> de::Visitor<'de> for Visitor { type Value = DerivationPath; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("a Bitcoin address") } fn visit_str(self, v: &str) -> Result { DerivationPath::from_str(v).map_err(E::custom) } fn visit_borrowed_str(self, v: &'de str) -> Result { self.visit_str(v) } fn visit_string(self, v: String) -> Result { self.visit_str(&v) } } deserializer.deserialize_str(Visitor) } } #[cfg(feature = "serde")] impl serde::Serialize for DerivationPath { fn serialize(&self, serializer: S) -> Result { serializer.serialize_str(&self.to_string()) } } /// A BIP32 error #[derive(Clone, PartialEq, Eq, Debug)] pub enum Error { /// A pk->pk derivation was attempted on a hardened key CannotDeriveFromHardenedKey, /// A secp256k1 error occurred Ecdsa(secp256k1::Error), /// A child number was provided that was out of range InvalidChildNumber(u32), /// Error creating a master seed --- for application use RngError(String), /// Invalid childnumber format. InvalidChildNumberFormat, /// Invalid derivation path format. InvalidDerivationPathFormat, } impl fmt::Display for Error { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { Error::CannotDeriveFromHardenedKey => f.write_str("cannot derive hardened key from public key"), Error::Ecdsa(ref e) => fmt::Display::fmt(e, f), Error::InvalidChildNumber(ref n) => write!(f, "child number {} is invalid (not within [0, 2^31 - 1])", n), Error::RngError(ref s) => write!(f, "rng error {}", s), Error::InvalidChildNumberFormat => f.write_str("invalid child number format"), Error::InvalidDerivationPathFormat => f.write_str("invalid derivation path format"), } } } impl error::Error for Error { fn cause(&self) -> Option<&error::Error> { if let Error::Ecdsa(ref e) = *self { Some(e) } else { None } } fn description(&self) -> &str { match *self { Error::CannotDeriveFromHardenedKey => "cannot derive hardened key from public key", Error::Ecdsa(ref e) => error::Error::description(e), Error::InvalidChildNumber(_) => "child number is invalid", Error::RngError(_) => "rng error", Error::InvalidChildNumberFormat => "invalid child number format", Error::InvalidDerivationPathFormat => "invalid derivation path format", } } } impl From for Error { fn from(e: secp256k1::Error) -> Error { Error::Ecdsa(e) } } impl ExtendedPrivKey { /// Construct a new master key from a seed value pub fn new_master(network: Network, seed: &[u8]) -> Result { let mut hmac_engine: HmacEngine = HmacEngine::new(b"Bitcoin seed"); hmac_engine.input(seed); let hmac_result: Hmac = Hmac::from_engine(hmac_engine); Ok(ExtendedPrivKey { network: network, depth: 0, parent_fingerprint: Default::default(), child_number: ChildNumber::from_normal_idx(0)?, secret_key: SecretKey::from_slice(&hmac_result[..32]).map_err(Error::Ecdsa)?, chain_code: ChainCode::from(&hmac_result[32..]), }) } /// Attempts to derive an extended private key from a path. /// /// The `path` argument can be both of type `DerivationPath` or `Vec`. pub fn derive_priv>( &self, secp: &Secp256k1, path: &P, ) -> Result { let mut sk: ExtendedPrivKey = *self; for cnum in path.as_ref() { sk = sk.ckd_priv(secp, *cnum)?; } Ok(sk) } /// Private->Private child key derivation pub fn ckd_priv(&self, secp: &Secp256k1, i: ChildNumber) -> Result { let mut hmac_engine: HmacEngine = HmacEngine::new(&self.chain_code[..]); let mut be_n = [0; 4]; match i { ChildNumber::Normal {..} => { // Non-hardened key: compute public data and use that hmac_engine.input(&PublicKey::from_secret_key(secp, &self.secret_key).serialize()[..]); } ChildNumber::Hardened {..} => { // Hardened key: use only secret data to prevent public derivation hmac_engine.input(&[0u8]); hmac_engine.input(&self.secret_key[..]); } } BigEndian::write_u32(&mut be_n, u32::from(i)); hmac_engine.input(&be_n); let hmac_result: Hmac = Hmac::from_engine(hmac_engine); let mut sk = SecretKey::from_slice(&hmac_result[..32]).map_err(Error::Ecdsa)?; sk.add_assign(&self.secret_key[..]).map_err(Error::Ecdsa)?; Ok(ExtendedPrivKey { network: self.network, depth: self.depth + 1, parent_fingerprint: self.fingerprint(secp), child_number: i, secret_key: sk, chain_code: ChainCode::from(&hmac_result[32..]) }) } /// Returns the HASH160 of the chaincode pub fn identifier(&self, secp: &Secp256k1) -> hash160::Hash { ExtendedPubKey::from_private(secp, self).identifier() } /// Returns the first four bytes of the identifier pub fn fingerprint(&self, secp: &Secp256k1) -> Fingerprint { Fingerprint::from(&self.identifier(secp)[0..4]) } } impl ExtendedPubKey { /// Derives a public key from a private key pub fn from_private(secp: &Secp256k1, sk: &ExtendedPrivKey) -> ExtendedPubKey { ExtendedPubKey { network: sk.network, depth: sk.depth, parent_fingerprint: sk.parent_fingerprint, child_number: sk.child_number, public_key: PublicKey::from_secret_key(secp, &sk.secret_key), chain_code: sk.chain_code } } /// Attempts to derive an extended public key from a path. /// /// The `path` argument can be both of type `DerivationPath` or `Vec`. pub fn derive_pub>( &self, secp: &Secp256k1, path: &P, ) -> Result { let mut pk: ExtendedPubKey = *self; for cnum in path.as_ref() { pk = pk.ckd_pub(secp, *cnum)? } Ok(pk) } /// Compute the scalar tweak added to this key to get a child key pub fn ckd_pub_tweak(&self, i: ChildNumber) -> Result<(SecretKey, ChainCode), Error> { match i { ChildNumber::Hardened {..} => { Err(Error::CannotDeriveFromHardenedKey) } ChildNumber::Normal { index: n } => { let mut hmac_engine: HmacEngine = HmacEngine::new(&self.chain_code[..]); hmac_engine.input(&self.public_key.serialize()[..]); let mut be_n = [0; 4]; BigEndian::write_u32(&mut be_n, n); hmac_engine.input(&be_n); let hmac_result: Hmac = Hmac::from_engine(hmac_engine); let secret_key = SecretKey::from_slice(&hmac_result[..32])?; let chain_code = ChainCode::from(&hmac_result[32..]); Ok((secret_key, chain_code)) } } } /// Public->Public child key derivation pub fn ckd_pub( &self, secp: &Secp256k1, i: ChildNumber, ) -> Result { let (sk, chain_code) = self.ckd_pub_tweak(i)?; let mut pk = self.public_key.clone(); pk.add_exp_assign(secp, &sk[..]).map_err(Error::Ecdsa)?; Ok(ExtendedPubKey { network: self.network, depth: self.depth + 1, parent_fingerprint: self.fingerprint(), child_number: i, public_key: pk, chain_code: chain_code }) } /// Returns the HASH160 of the chaincode pub fn identifier(&self) -> hash160::Hash { hash160::Hash::hash(&self.public_key.serialize()) } /// Returns the first four bytes of the identifier pub fn fingerprint(&self) -> Fingerprint { Fingerprint::from(&self.identifier()[0..4]) } } impl fmt::Display for ExtendedPrivKey { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let mut ret = [0; 78]; ret[0..4].copy_from_slice(&match self.network { Network::Bitcoin => [0x04, 0x88, 0xAD, 0xE4], Network::Testnet | Network::Regtest => [0x04, 0x35, 0x83, 0x94], }[..]); ret[4] = self.depth as u8; ret[5..9].copy_from_slice(&self.parent_fingerprint[..]); BigEndian::write_u32(&mut ret[9..13], u32::from(self.child_number)); ret[13..45].copy_from_slice(&self.chain_code[..]); ret[45] = 0; ret[46..78].copy_from_slice(&self.secret_key[..]); fmt.write_str(&base58::check_encode_slice(&ret[..])) } } impl FromStr for ExtendedPrivKey { type Err = base58::Error; fn from_str(inp: &str) -> Result { let data = base58::from_check(inp)?; if data.len() != 78 { return Err(base58::Error::InvalidLength(data.len())); } let cn_int: u32 = Cursor::new(&data[9..13]).read_u32::().unwrap(); let child_number: ChildNumber = ChildNumber::from(cn_int); Ok(ExtendedPrivKey { network: if &data[0..4] == [0x04u8, 0x88, 0xAD, 0xE4] { Network::Bitcoin } else if &data[0..4] == [0x04u8, 0x35, 0x83, 0x94] { Network::Testnet } else { return Err(base58::Error::InvalidVersion((&data[0..4]).to_vec())); }, depth: data[4], parent_fingerprint: Fingerprint::from(&data[5..9]), child_number: child_number, chain_code: ChainCode::from(&data[13..45]), secret_key: SecretKey::from_slice( &data[46..78]).map_err(|e| base58::Error::Other(e.to_string()))? }) } } impl fmt::Display for ExtendedPubKey { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { let mut ret = [0; 78]; ret[0..4].copy_from_slice(&match self.network { Network::Bitcoin => [0x04u8, 0x88, 0xB2, 0x1E], Network::Testnet | Network::Regtest => [0x04u8, 0x35, 0x87, 0xCF], }[..]); ret[4] = self.depth as u8; ret[5..9].copy_from_slice(&self.parent_fingerprint[..]); BigEndian::write_u32(&mut ret[9..13], u32::from(self.child_number)); ret[13..45].copy_from_slice(&self.chain_code[..]); ret[45..78].copy_from_slice(&self.public_key.serialize()[..]); fmt.write_str(&base58::check_encode_slice(&ret[..])) } } impl FromStr for ExtendedPubKey { type Err = base58::Error; fn from_str(inp: &str) -> Result { let data = base58::from_check(inp)?; if data.len() != 78 { return Err(base58::Error::InvalidLength(data.len())); } let cn_int: u32 = Cursor::new(&data[9..13]).read_u32::().unwrap(); let child_number: ChildNumber = ChildNumber::from(cn_int); Ok(ExtendedPubKey { network: if &data[0..4] == [0x04u8, 0x88, 0xB2, 0x1E] { Network::Bitcoin } else if &data[0..4] == [0x04u8, 0x35, 0x87, 0xCF] { Network::Testnet } else { return Err(base58::Error::InvalidVersion((&data[0..4]).to_vec())); }, depth: data[4], parent_fingerprint: Fingerprint::from(&data[5..9]), child_number: child_number, chain_code: ChainCode::from(&data[13..45]), public_key: PublicKey::from_slice( &data[45..78]).map_err(|e| base58::Error::Other(e.to_string()))? }) } } #[cfg(test)] mod tests { use std::str::FromStr; use std::string::ToString; use secp256k1::{self, Secp256k1}; use hex::decode as hex_decode; use network::constants::Network::{self, Bitcoin}; use super::{ChildNumber, DerivationPath, ExtendedPrivKey, ExtendedPubKey}; use super::ChildNumber::{Hardened, Normal}; use super::Error; #[test] fn test_parse_derivation_path() { assert_eq!(DerivationPath::from_str("42"), Err(Error::InvalidDerivationPathFormat)); assert_eq!(DerivationPath::from_str("n/0'/0"), Err(Error::InvalidDerivationPathFormat)); assert_eq!(DerivationPath::from_str("4/m/5"), Err(Error::InvalidDerivationPathFormat)); assert_eq!(DerivationPath::from_str("m//3/0'"), Err(Error::InvalidChildNumberFormat)); assert_eq!(DerivationPath::from_str("m/0h/0x"), Err(Error::InvalidChildNumberFormat)); assert_eq!(DerivationPath::from_str("m/2147483648"), Err(Error::InvalidChildNumber(2147483648))); assert_eq!(DerivationPath::from_str("m"), Ok(vec![].into())); assert_eq!( DerivationPath::from_str("m/0'"), Ok(vec![ChildNumber::from_hardened_idx(0).unwrap()].into()) ); assert_eq!( DerivationPath::from_str("m/0'/1"), Ok(vec![ChildNumber::from_hardened_idx(0).unwrap(), ChildNumber::from_normal_idx(1).unwrap()].into()) ); assert_eq!( DerivationPath::from_str("m/0h/1/2'"), Ok(vec![ ChildNumber::from_hardened_idx(0).unwrap(), ChildNumber::from_normal_idx(1).unwrap(), ChildNumber::from_hardened_idx(2).unwrap(), ].into()) ); assert_eq!( DerivationPath::from_str("m/0'/1/2h/2"), Ok(vec![ ChildNumber::from_hardened_idx(0).unwrap(), ChildNumber::from_normal_idx(1).unwrap(), ChildNumber::from_hardened_idx(2).unwrap(), ChildNumber::from_normal_idx(2).unwrap(), ].into()) ); assert_eq!( DerivationPath::from_str("m/0'/1/2'/2/1000000000"), Ok(vec![ ChildNumber::from_hardened_idx(0).unwrap(), ChildNumber::from_normal_idx(1).unwrap(), ChildNumber::from_hardened_idx(2).unwrap(), ChildNumber::from_normal_idx(2).unwrap(), ChildNumber::from_normal_idx(1000000000).unwrap(), ].into()) ); } #[test] fn test_derivation_path_convertion_index() { let path = DerivationPath::from_str("m/0h/1/2'").unwrap(); let numbers: Vec = path.clone().into(); let path2: DerivationPath = numbers.into(); assert_eq!(path, path2); assert_eq!(&path[..2], &[ChildNumber::from_hardened_idx(0).unwrap(), ChildNumber::from_normal_idx(1).unwrap()]); let indexed: DerivationPath = path[..2].into(); assert_eq!(indexed, DerivationPath::from_str("m/0h/1").unwrap()); assert_eq!(indexed.child(ChildNumber::from_hardened_idx(2).unwrap()), path); } fn test_path(secp: &Secp256k1, network: Network, seed: &[u8], path: DerivationPath, expected_sk: &str, expected_pk: &str) { let mut sk = ExtendedPrivKey::new_master(network, seed).unwrap(); let mut pk = ExtendedPubKey::from_private(secp, &sk); // Check derivation convenience method for ExtendedPrivKey assert_eq!( &sk.derive_priv(secp, &path).unwrap().to_string()[..], expected_sk ); // Check derivation convenience method for ExtendedPubKey, should error // appropriately if any ChildNumber is hardened if path.0.iter().any(|cnum| cnum.is_hardened()) { assert_eq!( pk.derive_pub(secp, &path), Err(Error::CannotDeriveFromHardenedKey) ); } else { assert_eq!( &pk.derive_pub(secp, &path).unwrap().to_string()[..], expected_pk ); } // Derive keys, checking hardened and non-hardened derivation one-by-one for &num in path.0.iter() { sk = sk.ckd_priv(secp, num).unwrap(); match num { Normal {..} => { let pk2 = pk.ckd_pub(secp, num).unwrap(); pk = ExtendedPubKey::from_private(secp, &sk); assert_eq!(pk, pk2); } Hardened {..} => { assert_eq!( pk.ckd_pub(secp, num), Err(Error::CannotDeriveFromHardenedKey) ); pk = ExtendedPubKey::from_private(secp, &sk); } } } // Check result against expected base58 assert_eq!(&sk.to_string()[..], expected_sk); assert_eq!(&pk.to_string()[..], expected_pk); // Check decoded base58 against result let decoded_sk = ExtendedPrivKey::from_str(expected_sk); let decoded_pk = ExtendedPubKey::from_str(expected_pk); assert_eq!(Ok(sk), decoded_sk); assert_eq!(Ok(pk), decoded_pk); } #[test] fn test_vector_1() { let secp = Secp256k1::new(); let seed = hex_decode("000102030405060708090a0b0c0d0e0f").unwrap(); // m test_path(&secp, Bitcoin, &seed, "m".parse().unwrap(), "xprv9s21ZrQH143K3QTDL4LXw2F7HEK3wJUD2nW2nRk4stbPy6cq3jPPqjiChkVvvNKmPGJxWUtg6LnF5kejMRNNU3TGtRBeJgk33yuGBxrMPHi", "xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8"); // m/0h test_path(&secp, Bitcoin, &seed, "m/0h".parse().unwrap(), "xprv9uHRZZhk6KAJC1avXpDAp4MDc3sQKNxDiPvvkX8Br5ngLNv1TxvUxt4cV1rGL5hj6KCesnDYUhd7oWgT11eZG7XnxHrnYeSvkzY7d2bhkJ7", "xpub68Gmy5EdvgibQVfPdqkBBCHxA5htiqg55crXYuXoQRKfDBFA1WEjWgP6LHhwBZeNK1VTsfTFUHCdrfp1bgwQ9xv5ski8PX9rL2dZXvgGDnw"); // m/0h/1 test_path(&secp, Bitcoin, &seed, "m/0h/1".parse().unwrap(), "xprv9wTYmMFdV23N2TdNG573QoEsfRrWKQgWeibmLntzniatZvR9BmLnvSxqu53Kw1UmYPxLgboyZQaXwTCg8MSY3H2EU4pWcQDnRnrVA1xe8fs", "xpub6ASuArnXKPbfEwhqN6e3mwBcDTgzisQN1wXN9BJcM47sSikHjJf3UFHKkNAWbWMiGj7Wf5uMash7SyYq527Hqck2AxYysAA7xmALppuCkwQ"); // m/0h/1/2h test_path(&secp, Bitcoin, &seed, "m/0h/1/2h".parse().unwrap(), "xprv9z4pot5VBttmtdRTWfWQmoH1taj2axGVzFqSb8C9xaxKymcFzXBDptWmT7FwuEzG3ryjH4ktypQSAewRiNMjANTtpgP4mLTj34bhnZX7UiM", "xpub6D4BDPcP2GT577Vvch3R8wDkScZWzQzMMUm3PWbmWvVJrZwQY4VUNgqFJPMM3No2dFDFGTsxxpG5uJh7n7epu4trkrX7x7DogT5Uv6fcLW5"); // m/0h/1/2h/2 test_path(&secp, Bitcoin, &seed, "m/0h/1/2h/2".parse().unwrap(), "xprvA2JDeKCSNNZky6uBCviVfJSKyQ1mDYahRjijr5idH2WwLsEd4Hsb2Tyh8RfQMuPh7f7RtyzTtdrbdqqsunu5Mm3wDvUAKRHSC34sJ7in334", "xpub6FHa3pjLCk84BayeJxFW2SP4XRrFd1JYnxeLeU8EqN3vDfZmbqBqaGJAyiLjTAwm6ZLRQUMv1ZACTj37sR62cfN7fe5JnJ7dh8zL4fiyLHV"); // m/0h/1/2h/2/1000000000 test_path(&secp, Bitcoin, &seed, "m/0h/1/2h/2/1000000000".parse().unwrap(), "xprvA41z7zogVVwxVSgdKUHDy1SKmdb533PjDz7J6N6mV6uS3ze1ai8FHa8kmHScGpWmj4WggLyQjgPie1rFSruoUihUZREPSL39UNdE3BBDu76", "xpub6H1LXWLaKsWFhvm6RVpEL9P4KfRZSW7abD2ttkWP3SSQvnyA8FSVqNTEcYFgJS2UaFcxupHiYkro49S8yGasTvXEYBVPamhGW6cFJodrTHy"); } #[test] fn test_vector_2() { let secp = Secp256k1::new(); let seed = hex_decode("fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542").unwrap(); // m test_path(&secp, Bitcoin, &seed, "m".parse().unwrap(), "xprv9s21ZrQH143K31xYSDQpPDxsXRTUcvj2iNHm5NUtrGiGG5e2DtALGdso3pGz6ssrdK4PFmM8NSpSBHNqPqm55Qn3LqFtT2emdEXVYsCzC2U", "xpub661MyMwAqRbcFW31YEwpkMuc5THy2PSt5bDMsktWQcFF8syAmRUapSCGu8ED9W6oDMSgv6Zz8idoc4a6mr8BDzTJY47LJhkJ8UB7WEGuduB"); // m/0 test_path(&secp, Bitcoin, &seed, "m/0".parse().unwrap(), "xprv9vHkqa6EV4sPZHYqZznhT2NPtPCjKuDKGY38FBWLvgaDx45zo9WQRUT3dKYnjwih2yJD9mkrocEZXo1ex8G81dwSM1fwqWpWkeS3v86pgKt", "xpub69H7F5d8KSRgmmdJg2KhpAK8SR3DjMwAdkxj3ZuxV27CprR9LgpeyGmXUbC6wb7ERfvrnKZjXoUmmDznezpbZb7ap6r1D3tgFxHmwMkQTPH"); // m/0/2147483647h test_path(&secp, Bitcoin, &seed, "m/0/2147483647h".parse().unwrap(), "xprv9wSp6B7kry3Vj9m1zSnLvN3xH8RdsPP1Mh7fAaR7aRLcQMKTR2vidYEeEg2mUCTAwCd6vnxVrcjfy2kRgVsFawNzmjuHc2YmYRmagcEPdU9", "xpub6ASAVgeehLbnwdqV6UKMHVzgqAG8Gr6riv3Fxxpj8ksbH9ebxaEyBLZ85ySDhKiLDBrQSARLq1uNRts8RuJiHjaDMBU4Zn9h8LZNnBC5y4a"); // m/0/2147483647h/1 test_path(&secp, Bitcoin, &seed, "m/0/2147483647h/1".parse().unwrap(), "xprv9zFnWC6h2cLgpmSA46vutJzBcfJ8yaJGg8cX1e5StJh45BBciYTRXSd25UEPVuesF9yog62tGAQtHjXajPPdbRCHuWS6T8XA2ECKADdw4Ef", "xpub6DF8uhdarytz3FWdA8TvFSvvAh8dP3283MY7p2V4SeE2wyWmG5mg5EwVvmdMVCQcoNJxGoWaU9DCWh89LojfZ537wTfunKau47EL2dhHKon"); // m/0/2147483647h/1/2147483646h test_path(&secp, Bitcoin, &seed, "m/0/2147483647h/1/2147483646h".parse().unwrap(), "xprvA1RpRA33e1JQ7ifknakTFpgNXPmW2YvmhqLQYMmrj4xJXXWYpDPS3xz7iAxn8L39njGVyuoseXzU6rcxFLJ8HFsTjSyQbLYnMpCqE2VbFWc", "xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJbZRkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL"); // m/0/2147483647h/1/2147483646h/2 test_path(&secp, Bitcoin, &seed, "m/0/2147483647h/1/2147483646h/2".parse().unwrap(), "xprvA2nrNbFZABcdryreWet9Ea4LvTJcGsqrMzxHx98MMrotbir7yrKCEXw7nadnHM8Dq38EGfSh6dqA9QWTyefMLEcBYJUuekgW4BYPJcr9E7j", "xpub6FnCn6nSzZAw5Tw7cgR9bi15UV96gLZhjDstkXXxvCLsUXBGXPdSnLFbdpq8p9HmGsApME5hQTZ3emM2rnY5agb9rXpVGyy3bdW6EEgAtqt"); } #[test] fn test_vector_3() { let secp = Secp256k1::new(); let seed = hex_decode("4b381541583be4423346c643850da4b320e46a87ae3d2a4e6da11eba819cd4acba45d239319ac14f863b8d5ab5a0d0c64d2e8a1e7d1457df2e5a3c51c73235be").unwrap(); // m test_path(&secp, Bitcoin, &seed, "m".parse().unwrap(), "xprv9s21ZrQH143K25QhxbucbDDuQ4naNntJRi4KUfWT7xo4EKsHt2QJDu7KXp1A3u7Bi1j8ph3EGsZ9Xvz9dGuVrtHHs7pXeTzjuxBrCmmhgC6", "xpub661MyMwAqRbcEZVB4dScxMAdx6d4nFc9nvyvH3v4gJL378CSRZiYmhRoP7mBy6gSPSCYk6SzXPTf3ND1cZAceL7SfJ1Z3GC8vBgp2epUt13"); // m/0h test_path(&secp, Bitcoin, &seed, "m/0h".parse().unwrap(), "xprv9uPDJpEQgRQfDcW7BkF7eTya6RPxXeJCqCJGHuCJ4GiRVLzkTXBAJMu2qaMWPrS7AANYqdq6vcBcBUdJCVVFceUvJFjaPdGZ2y9WACViL4L", "xpub68NZiKmJWnxxS6aaHmn81bvJeTESw724CRDs6HbuccFQN9Ku14VQrADWgqbhhTHBaohPX4CjNLf9fq9MYo6oDaPPLPxSb7gwQN3ih19Zm4Y"); } #[test] #[cfg(all(feature = "serde", feature = "strason"))] pub fn encode_decode_childnumber() { serde_round_trip!(ChildNumber::from_normal_idx(0).unwrap()); serde_round_trip!(ChildNumber::from_normal_idx(1).unwrap()); serde_round_trip!(ChildNumber::from_normal_idx((1 << 31) - 1).unwrap()); serde_round_trip!(ChildNumber::from_hardened_idx(0).unwrap()); serde_round_trip!(ChildNumber::from_hardened_idx(1).unwrap()); serde_round_trip!(ChildNumber::from_hardened_idx((1 << 31) - 1).unwrap()); } }