diff --git a/bitcoin/src/util/bip32.rs b/bitcoin/src/bip32.rs similarity index 87% rename from bitcoin/src/util/bip32.rs rename to bitcoin/src/bip32.rs index 1c91b3fa..8f85c5af 100644 --- a/bitcoin/src/util/bip32.rs +++ b/bitcoin/src/bip32.rs @@ -7,22 +7,24 @@ //! at . //! -use crate::prelude::*; - -use crate::io::Write; -use core::{fmt, str::FromStr, default::Default}; +use core::default::Default; +use core::fmt; use core::ops::Index; -#[cfg(feature = "serde")] use serde; +use core::str::FromStr; use bitcoin_internals::write_err; -use crate::hash_types::XpubIdentifier; -use crate::hashes::{sha512, Hash, HashEngine, Hmac, HmacEngine, hex}; use secp256k1::{self, Secp256k1, XOnlyPublicKey}; +#[cfg(feature = "serde")] +use serde; -use crate::network::constants::Network; -use crate::util::{base58, endian, key}; -use crate::util::key::{PublicKey, PrivateKey, KeyPair}; +use crate::hash_types::XpubIdentifier; +use crate::hashes::{hex, sha512, Hash, HashEngine, Hmac, HmacEngine}; use crate::internal_macros::{impl_array_newtype, impl_bytes_newtype, serde_string_impl}; +use crate::io::Write; +use crate::network::constants::Network; +use crate::prelude::*; +use crate::util::key::{KeyPair, PrivateKey, PublicKey}; +use crate::util::{base58, endian, key}; /// A chain code #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] @@ -51,7 +53,7 @@ pub struct ExtendedPrivKey { /// Private key pub private_key: secp256k1::SecretKey, /// Chain code - pub chain_code: ChainCode + pub chain_code: ChainCode, } serde_string_impl!(ExtendedPrivKey, "a BIP-32 extended private key"); @@ -84,7 +86,7 @@ pub struct ExtendedPubKey { /// Public key pub public_key: secp256k1::PublicKey, /// Chain code - pub chain_code: ChainCode + pub chain_code: ChainCode, } serde_string_impl!(ExtendedPubKey, "a BIP-32 extended public key"); @@ -94,12 +96,12 @@ pub enum ChildNumber { /// Non-hardened key Normal { /// Key index, within [0, 2^31 - 1] - index: u32 + index: u32, }, /// Hardened key Hardened { /// Key index, within [0, 2^31 - 1] - index: u32 + index: u32, }, } @@ -131,25 +133,23 @@ impl ChildNumber { /// Returns `true` if the child number is a [`Normal`] value. /// /// [`Normal`]: #variant.Normal - pub fn is_normal(&self) -> bool { - !self.is_hardened() - } + 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, + ChildNumber::Hardened { .. } => true, + ChildNumber::Normal { .. } => false, } } /// Returns the child number that is a single increment from this one. pub fn increment(self) -> Result { match self { - ChildNumber::Normal{ index: idx } => ChildNumber::from_normal_idx(idx+1), - ChildNumber::Hardened{ index: idx } => ChildNumber::from_hardened_idx(idx+1), + ChildNumber::Normal { index: idx } => ChildNumber::from_normal_idx(idx + 1), + ChildNumber::Hardened { index: idx } => ChildNumber::from_hardened_idx(idx + 1), } } } @@ -180,7 +180,7 @@ impl fmt::Display for ChildNumber { fmt::Display::fmt(&index, f)?; let alt = f.alternate(); f.write_str(if alt { "h" } else { "'" }) - }, + } ChildNumber::Normal { index } => fmt::Display::fmt(&index, f), } } @@ -192,7 +192,9 @@ impl FromStr for ChildNumber { fn from_str(inp: &str) -> Result { let is_hardened = inp.chars().last().map_or(false, |l| l == '\'' || l == 'h'); Ok(if is_hardened { - ChildNumber::from_hardened_idx(inp[0..inp.len() - 1].parse().map_err(|_| Error::InvalidChildNumberFormat)?)? + ChildNumber::from_hardened_idx( + inp[0..inp.len() - 1].parse().map_err(|_| Error::InvalidChildNumberFormat)?, + )? } else { ChildNumber::from_normal_idx(inp.parse().map_err(|_| Error::InvalidChildNumberFormat)?)? }) @@ -240,55 +242,45 @@ where type Output = as Index>::Output; #[inline] - fn index(&self, index: I) -> &Self::Output { - &self.0[index] - } + fn index(&self, index: I) -> &Self::Output { &self.0[index] } } impl Default for DerivationPath { - fn default() -> DerivationPath { - DerivationPath::master() - } + fn default() -> DerivationPath { DerivationPath::master() } } -impl IntoDerivationPath for T where T: Into { - fn into_derivation_path(self) -> Result { - Ok(self.into()) - } +impl IntoDerivationPath for T +where + T: Into, +{ + fn into_derivation_path(self) -> Result { Ok(self.into()) } } impl IntoDerivationPath for String { - fn into_derivation_path(self) -> Result { - self.parse() - } + fn into_derivation_path(self) -> Result { self.parse() } } impl<'a> IntoDerivationPath for &'a str { - fn into_derivation_path(self) -> Result { - self.parse() - } + fn into_derivation_path(self) -> Result { self.parse() } } impl From> for DerivationPath { - fn from(numbers: Vec) -> Self { - DerivationPath(numbers) - } + fn from(numbers: Vec) -> Self { DerivationPath(numbers) } } impl From for Vec { - fn from(path: DerivationPath) -> Self { - path.0 - } + fn from(path: DerivationPath) -> Self { path.0 } } impl<'a> From<&'a [ChildNumber]> for DerivationPath { - fn from(numbers: &'a [ChildNumber]) -> Self { - DerivationPath(numbers.to_vec()) - } + fn from(numbers: &'a [ChildNumber]) -> Self { DerivationPath(numbers.to_vec()) } } impl core::iter::FromIterator for DerivationPath { - fn from_iter(iter: T) -> Self where T: IntoIterator { + fn from_iter(iter: T) -> Self + where + T: IntoIterator, + { DerivationPath(Vec::from_iter(iter)) } } @@ -296,15 +288,11 @@ impl core::iter::FromIterator for DerivationPath { impl<'a> core::iter::IntoIterator for &'a DerivationPath { type Item = &'a ChildNumber; type IntoIter = slice::Iter<'a, ChildNumber>; - fn into_iter(self) -> Self::IntoIter { - self.0.iter() - } + fn into_iter(self) -> Self::IntoIter { self.0.iter() } } impl AsRef<[ChildNumber]> for DerivationPath { - fn as_ref(&self) -> &[ChildNumber] { - &self.0 - } + fn as_ref(&self) -> &[ChildNumber] { &self.0 } } impl FromStr for DerivationPath { @@ -334,10 +322,7 @@ pub struct DerivationPathIterator<'a> { impl<'a> DerivationPathIterator<'a> { /// Start a new [DerivationPathIterator] at the given child. pub fn start_from(path: &'a DerivationPath, start: ChildNumber) -> DerivationPathIterator<'a> { - DerivationPathIterator { - base: path, - next_child: Some(start), - } + DerivationPathIterator { base: path, next_child: Some(start) } } } @@ -353,25 +338,17 @@ impl<'a> Iterator for DerivationPathIterator<'a> { impl DerivationPath { /// Returns length of the derivation path - pub fn len(&self) -> usize { - self.0.len() - } + pub fn len(&self) -> usize { self.0.len() } /// Returns `true` if the derivation path is empty - pub fn is_empty(&self) -> bool { - self.0.is_empty() - } + pub fn is_empty(&self) -> bool { self.0.is_empty() } /// Returns derivation path for a master key (i.e. empty derivation path) - pub fn master() -> DerivationPath { - DerivationPath(vec![]) - } + pub fn master() -> DerivationPath { DerivationPath(vec![]) } /// Returns whether derivation path represents master key (i.e. it's length /// is empty). True for `m` path. - pub fn is_master(&self) -> bool { - self.0.is_empty() - } + pub fn is_master(&self) -> bool { self.0.is_empty() } /// Create a new [DerivationPath] that is a child of this one. pub fn child(&self, cn: ChildNumber) -> DerivationPath { @@ -395,12 +372,12 @@ impl DerivationPath { /// Get an [Iterator] over the unhardened children of this [DerivationPath]. pub fn normal_children(&self) -> DerivationPathIterator { - DerivationPathIterator::start_from(self, ChildNumber::Normal{ index: 0 }) + DerivationPathIterator::start_from(self, ChildNumber::Normal { index: 0 }) } /// Get an [Iterator] over the hardened children of this [DerivationPath]. pub fn hardened_children(&self) -> DerivationPathIterator { - DerivationPathIterator::start_from(self, ChildNumber::Hardened{ index: 0 }) + DerivationPathIterator::start_from(self, ChildNumber::Hardened { index: 0 }) } /// Concatenate `self` with `path` and return the resulting new path. @@ -438,9 +415,7 @@ impl fmt::Display for DerivationPath { } impl fmt::Debug for DerivationPath { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - fmt::Display::fmt(&self, f) - } + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { fmt::Display::fmt(&self, f) } } /// Full information on the used extended public key: fingerprint of the @@ -468,19 +443,23 @@ pub enum Error { /// Base58 encoding error Base58(base58::Error), /// Hexadecimal decoding error - Hex(hex::Error) + Hex(hex::Error), } 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::CannotDeriveFromHardenedKey => + f.write_str("cannot derive hardened key from public key"), Error::Secp256k1(ref e) => write_err!(f, "secp256k1 error"; e), - Error::InvalidChildNumber(ref n) => write!(f, "child number {} is invalid (not within [0, 2^31 - 1])", n), + Error::InvalidChildNumber(ref n) => + write!(f, "child number {} is invalid (not within [0, 2^31 - 1])", n), Error::InvalidChildNumberFormat => f.write_str("invalid child number format"), Error::InvalidDerivationPathFormat => f.write_str("invalid derivation path format"), - Error::UnknownVersion(ref bytes) => write!(f, "unknown version magic bytes: {:?}", bytes), - Error::WrongExtendedKeyLength(ref len) => write!(f, "encoded extended key data has wrong length {}", len), + Error::UnknownVersion(ref bytes) => + write!(f, "unknown version magic bytes: {:?}", bytes), + Error::WrongExtendedKeyLength(ref len) => + write!(f, "encoded extended key data has wrong length {}", len), Error::Base58(ref e) => write_err!(f, "base58 encoding error"; e), Error::Hex(ref e) => write_err!(f, "Hexadecimal decoding error"; e), } @@ -513,7 +492,7 @@ impl From for Error { key::Error::Base58(e) => Error::Base58(e), key::Error::Secp256k1(e) => Error::Secp256k1(e), key::Error::InvalidKeyPrefix(_) => Error::Secp256k1(secp256k1::Error::InvalidPublicKey), - key::Error::Hex(e) => Error::Hex(e) + key::Error::Hex(e) => Error::Hex(e), } } } @@ -523,9 +502,7 @@ impl From for Error { } impl From for Error { - fn from(err: base58::Error) -> Self { - Error::Base58(err) - } + fn from(err: base58::Error) -> Self { Error::Base58(err) } } impl ExtendedPrivKey { @@ -547,17 +524,14 @@ impl ExtendedPrivKey { /// Constructs ECDSA compressed private key matching internal secret key representation. pub fn to_priv(self) -> PrivateKey { - PrivateKey { - compressed: true, - network: self.network, - inner: self.private_key - } + PrivateKey { compressed: true, network: self.network, inner: self.private_key } } /// Constructs BIP340 keypair for Schnorr signatures and Taproot use matching the internal /// secret key representation. pub fn to_keypair(self, secp: &Secp256k1) -> KeyPair { - KeyPair::from_seckey_slice(secp, &self.private_key[..]).expect("BIP32 internal private key representation is broken") + KeyPair::from_seckey_slice(secp, &self.private_key[..]) + .expect("BIP32 internal private key representation is broken") } /// Attempts to derive an extended private key from a path. @@ -576,12 +550,18 @@ impl ExtendedPrivKey { } /// Private->Private child key derivation - pub fn ckd_priv(&self, secp: &Secp256k1, i: ChildNumber) -> Result { + pub fn ckd_priv( + &self, + secp: &Secp256k1, + i: ChildNumber, + ) -> Result { let mut hmac_engine: HmacEngine = HmacEngine::new(&self.chain_code[..]); match i { ChildNumber::Normal { .. } => { // Non-hardened key: compute public data and use that - hmac_engine.input(&secp256k1::PublicKey::from_secret_key(secp, &self.private_key).serialize()[..]); + hmac_engine.input( + &secp256k1::PublicKey::from_secret_key(secp, &self.private_key).serialize()[..], + ); } ChildNumber::Hardened { .. } => { // Hardened key: use only secret data to prevent public derivation @@ -592,8 +572,10 @@ impl ExtendedPrivKey { hmac_engine.input(&endian::u32_to_array_be(u32::from(i))); let hmac_result: Hmac = Hmac::from_engine(hmac_engine); - let sk = secp256k1::SecretKey::from_slice(&hmac_result[..32]).expect("statistically impossible to hit"); - let tweaked = sk.add_tweak(&self.private_key.into()).expect("statistically impossible to hit"); + let sk = secp256k1::SecretKey::from_slice(&hmac_result[..32]) + .expect("statistically impossible to hit"); + let tweaked = + sk.add_tweak(&self.private_key.into()).expect("statistically impossible to hit"); Ok(ExtendedPrivKey { network: self.network, @@ -601,14 +583,14 @@ impl ExtendedPrivKey { parent_fingerprint: self.fingerprint(secp), child_number: i, private_key: tweaked, - chain_code: ChainCode::from(&hmac_result[32..]) + chain_code: ChainCode::from(&hmac_result[32..]), }) } /// Decoding extended private key from binary data according to BIP 32 pub fn decode(data: &[u8]) -> Result { if data.len() != 78 { - return Err(Error::WrongExtendedKeyLength(data.len())) + return Err(Error::WrongExtendedKeyLength(data.len())); } let network = if data[0..4] == [0x04u8, 0x88, 0xAD, 0xE4] { @@ -634,10 +616,12 @@ impl ExtendedPrivKey { /// Extended private key binary encoding according to BIP 32 pub fn encode(&self) -> [u8; 78] { let mut ret = [0; 78]; - ret[0..4].copy_from_slice(&match self.network { - Network::Bitcoin => [0x04, 0x88, 0xAD, 0xE4], - Network::Testnet | Network::Signet | Network::Regtest => [0x04, 0x35, 0x83, 0x94], - }[..]); + ret[0..4].copy_from_slice( + &match self.network { + Network::Bitcoin => [0x04, 0x88, 0xAD, 0xE4], + Network::Testnet | Network::Signet | Network::Regtest => [0x04, 0x35, 0x83, 0x94], + }[..], + ); ret[4] = self.depth as u8; ret[5..9].copy_from_slice(&self.parent_fingerprint[..]); ret[9..13].copy_from_slice(&endian::u32_to_array_be(u32::from(self.child_number))); @@ -660,30 +644,26 @@ impl ExtendedPrivKey { impl ExtendedPubKey { /// Derives a public key from a private key - pub fn from_priv(secp: &Secp256k1, sk: &ExtendedPrivKey) -> ExtendedPubKey { + pub fn from_priv( + secp: &Secp256k1, + sk: &ExtendedPrivKey, + ) -> ExtendedPubKey { ExtendedPubKey { network: sk.network, depth: sk.depth, parent_fingerprint: sk.parent_fingerprint, child_number: sk.child_number, public_key: secp256k1::PublicKey::from_secret_key(secp, &sk.private_key), - chain_code: sk.chain_code + chain_code: sk.chain_code, } } /// Constructs ECDSA compressed public key matching internal public key representation. - pub fn to_pub(self) -> PublicKey { - PublicKey { - compressed: true, - inner: self.public_key - } - } + pub fn to_pub(self) -> PublicKey { PublicKey { compressed: true, inner: self.public_key } } /// Constructs BIP340 x-only public key for BIP-340 signatures and Taproot use matching /// the internal public key representation. - pub fn to_x_only_pub(self) -> XOnlyPublicKey { - XOnlyPublicKey::from(self.public_key) - } + pub fn to_x_only_pub(self) -> XOnlyPublicKey { XOnlyPublicKey::from(self.public_key) } /// Attempts to derive an extended public key from a path. /// @@ -701,13 +681,15 @@ impl ExtendedPubKey { } /// Compute the scalar tweak added to this key to get a child key - pub fn ckd_pub_tweak(&self, i: ChildNumber) -> Result<(secp256k1::SecretKey, ChainCode), Error> { + pub fn ckd_pub_tweak( + &self, + i: ChildNumber, + ) -> Result<(secp256k1::SecretKey, ChainCode), Error> { match i { - ChildNumber::Hardened { .. } => { - Err(Error::CannotDeriveFromHardenedKey) - } + ChildNumber::Hardened { .. } => Err(Error::CannotDeriveFromHardenedKey), ChildNumber::Normal { index: n } => { - let mut hmac_engine: HmacEngine = HmacEngine::new(&self.chain_code[..]); + let mut hmac_engine: HmacEngine = + HmacEngine::new(&self.chain_code[..]); hmac_engine.input(&self.public_key.serialize()[..]); hmac_engine.input(&endian::u32_to_array_be(n)); @@ -742,7 +724,7 @@ impl ExtendedPubKey { /// Decoding extended public key from binary data according to BIP 32 pub fn decode(data: &[u8]) -> Result { if data.len() != 78 { - return Err(Error::WrongExtendedKeyLength(data.len())) + return Err(Error::WrongExtendedKeyLength(data.len())); } Ok(ExtendedPubKey { @@ -766,10 +748,12 @@ impl ExtendedPubKey { /// Extended public key binary encoding according to BIP 32 pub fn encode(&self) -> [u8; 78] { let mut ret = [0; 78]; - ret[0..4].copy_from_slice(&match self.network { - Network::Bitcoin => [0x04u8, 0x88, 0xB2, 0x1E], - Network::Testnet | Network::Signet | Network::Regtest => [0x04u8, 0x35, 0x87, 0xCF], - }[..]); + ret[0..4].copy_from_slice( + &match self.network { + Network::Bitcoin => [0x04u8, 0x88, 0xB2, 0x1E], + Network::Testnet | Network::Signet | Network::Regtest => [0x04u8, 0x35, 0x87, 0xCF], + }[..], + ); ret[4] = self.depth as u8; ret[5..9].copy_from_slice(&self.parent_fingerprint[..]); ret[9..13].copy_from_slice(&endian::u32_to_array_be(u32::from(self.child_number))); @@ -786,9 +770,7 @@ impl ExtendedPubKey { } /// Returns the first four bytes of the identifier - pub fn fingerprint(&self) -> Fingerprint { - Fingerprint::from(&self.identifier()[0..4]) - } + pub fn fingerprint(&self) -> Fingerprint { Fingerprint::from(&self.identifier()[0..4]) } } impl fmt::Display for ExtendedPrivKey { @@ -832,27 +814,22 @@ impl FromStr for ExtendedPubKey { } impl From for XpubIdentifier { - fn from(key: ExtendedPubKey) -> XpubIdentifier { - key.identifier() - } + fn from(key: ExtendedPubKey) -> XpubIdentifier { key.identifier() } } impl From<&ExtendedPubKey> for XpubIdentifier { - fn from(key: &ExtendedPubKey) -> XpubIdentifier { - key.identifier() - } + fn from(key: &ExtendedPubKey) -> XpubIdentifier { key.identifier() } } #[cfg(test)] mod tests { - use super::*; - use super::ChildNumber::{Hardened, Normal}; - use core::str::FromStr; use secp256k1::{self, Secp256k1}; - use crate::hashes::hex::FromHex; + use super::ChildNumber::{Hardened, Normal}; + use super::*; + use crate::hashes::hex::FromHex; use crate::network::constants::Network::{self, Bitcoin}; #[test] @@ -862,7 +839,10 @@ mod tests { 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/2147483648"), + Err(Error::InvalidChildNumber(2147483648)) + ); assert_eq!(DerivationPath::master(), DerivationPath::from_str("m").unwrap()); assert_eq!(DerivationPath::master(), DerivationPath::default()); @@ -873,7 +853,11 @@ mod tests { ); assert_eq!( DerivationPath::from_str("m/0'/1"), - Ok(vec![ChildNumber::from_hardened_idx(0).unwrap(), ChildNumber::from_normal_idx(1).unwrap()].into()) + Ok(vec![ + ChildNumber::from_hardened_idx(0).unwrap(), + ChildNumber::from_normal_idx(1).unwrap() + ] + .into()) ); assert_eq!( DerivationPath::from_str("m/0h/1/2'"), @@ -881,7 +865,8 @@ mod tests { ChildNumber::from_hardened_idx(0).unwrap(), ChildNumber::from_normal_idx(1).unwrap(), ChildNumber::from_hardened_idx(2).unwrap(), - ].into()) + ] + .into()) ); assert_eq!( DerivationPath::from_str("m/0'/1/2h/2"), @@ -890,7 +875,8 @@ mod tests { ChildNumber::from_normal_idx(1).unwrap(), ChildNumber::from_hardened_idx(2).unwrap(), ChildNumber::from_normal_idx(2).unwrap(), - ].into()) + ] + .into()) ); assert_eq!( DerivationPath::from_str("m/0'/1/2'/2/1000000000"), @@ -900,7 +886,8 @@ mod tests { ChildNumber::from_hardened_idx(2).unwrap(), ChildNumber::from_normal_idx(2).unwrap(), ChildNumber::from_normal_idx(1000000000).unwrap(), - ].into()) + ] + .into()) ); let s = "m/0'/50/3'/5/545456"; assert_eq!(DerivationPath::from_str(s), s.into_derivation_path()); @@ -913,7 +900,10 @@ mod tests { 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()]); + 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); @@ -925,8 +915,8 @@ mod tests { seed: &[u8], path: DerivationPath, expected_sk: &str, - expected_pk: &str) - { + expected_pk: &str, + ) { let mut sk = ExtendedPrivKey::new_master(network, seed).unwrap(); let mut pk = ExtendedPubKey::from_priv(secp, &sk); @@ -945,16 +935,13 @@ mod tests { for &num in path.0.iter() { sk = sk.ckd_priv(secp, num).unwrap(); match num { - Normal {..} => { + Normal { .. } => { let pk2 = pk.ckd_pub(secp, num).unwrap(); pk = ExtendedPubKey::from_priv(secp, &sk); assert_eq!(pk, pk2); } - Hardened {..} => { - assert_eq!( - pk.ckd_pub(secp, num), - Err(Error::CannotDeriveFromHardenedKey) - ); + Hardened { .. } => { + assert_eq!(pk.ckd_pub(secp, num), Err(Error::CannotDeriveFromHardenedKey)); pk = ExtendedPubKey::from_priv(secp, &sk); } } @@ -974,15 +961,15 @@ mod tests { fn test_increment() { let idx = 9345497; // randomly generated, I promise let cn = ChildNumber::from_normal_idx(idx).unwrap(); - assert_eq!(cn.increment().ok(), Some(ChildNumber::from_normal_idx(idx+1).unwrap())); + assert_eq!(cn.increment().ok(), Some(ChildNumber::from_normal_idx(idx + 1).unwrap())); let cn = ChildNumber::from_hardened_idx(idx).unwrap(); - assert_eq!(cn.increment().ok(), Some(ChildNumber::from_hardened_idx(idx+1).unwrap())); + assert_eq!(cn.increment().ok(), Some(ChildNumber::from_hardened_idx(idx + 1).unwrap())); - let max = (1<<31)-1; + let max = (1 << 31) - 1; let cn = ChildNumber::from_normal_idx(max).unwrap(); - assert_eq!(cn.increment().err(), Some(Error::InvalidChildNumber(1<<31))); + assert_eq!(cn.increment().err(), Some(Error::InvalidChildNumber(1 << 31))); let cn = ChildNumber::from_hardened_idx(max).unwrap(); - assert_eq!(cn.increment().err(), Some(Error::InvalidChildNumber(1<<31))); + assert_eq!(cn.increment().err(), Some(Error::InvalidChildNumber(1 << 31))); let cn = ChildNumber::from_normal_idx(350).unwrap(); let path = DerivationPath::from_str("m/42'").unwrap(); @@ -1099,7 +1086,6 @@ mod tests { test_path(&secp, Bitcoin, &seed, "m/0h".parse().unwrap(), "xprv9uPDJpEQgRQfDcW7BkF7eTya6RPxXeJCqCJGHuCJ4GiRVLzkTXBAJMu2qaMWPrS7AANYqdq6vcBcBUdJCVVFceUvJFjaPdGZ2y9WACViL4L", "xpub68NZiKmJWnxxS6aaHmn81bvJeTESw724CRDs6HbuccFQN9Ku14VQrADWgqbhhTHBaohPX4CjNLf9fq9MYo6oDaPPLPxSb7gwQN3ih19Zm4Y"); - } #[test] @@ -1117,7 +1103,8 @@ mod tests { #[cfg(feature = "serde")] pub fn encode_fingerprint_chaincode() { use serde_json; - let fp = Fingerprint::from(&[1u8,2,3,42][..]); + let fp = Fingerprint::from(&[1u8, 2, 3, 42][..]); + #[rustfmt::skip] let cc = ChainCode::from( &[1u8,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2][..] ); @@ -1175,7 +1162,6 @@ mod tests { ExtendedPrivKey::from_str(xpriv_str).unwrap(); } - #[test] #[should_panic(expected = "Secp256k1(InvalidSecretKey)")] fn schnorr_broken_privkey_ffs() { diff --git a/bitcoin/src/lib.rs b/bitcoin/src/lib.rs index 8e320cf8..f68a9f44 100644 --- a/bitcoin/src/lib.rs +++ b/bitcoin/src/lib.rs @@ -81,6 +81,7 @@ mod serde_utils; pub mod network; pub mod address; pub mod bip158; +pub mod bip32; pub mod blockdata; pub mod consensus; pub mod error; diff --git a/bitcoin/src/util/mod.rs b/bitcoin/src/util/mod.rs index 2ff777b7..ebce5697 100644 --- a/bitcoin/src/util/mod.rs +++ b/bitcoin/src/util/mod.rs @@ -11,7 +11,6 @@ pub mod ecdsa; pub mod schnorr; pub mod amount; pub mod base58; -pub mod bip32; pub mod bip152; pub mod hash; pub mod merkleblock; @@ -117,5 +116,8 @@ pub mod address { pub use crate::address::*; } +#[deprecated(since = "0.30.0", note = "Please use crate::bip32")] +pub use crate::bip32; + #[deprecated(since = "0.30.0", note = "Please use crate::bip158")] pub use crate::bip158;