rust/bip32: collect methods into a new Xpub struct

More ergonomic and Rust-like to have a struct with related methods on
it.

Author: benma

src/rust/bitbox02-rust/src/bip32.rs

@@ -18,69 +18,111 @@ use alloc::vec::Vec;
 
 pub use pb::btc_pub_request::XPubType;
 
-/// Serializes a protobuf XPub to bytes according to the BIP32 specification. If xpub_type is None,
-/// the four version bytes are skipped.
-pub fn serialize_xpub(xpub: &pb::XPub, xpub_type: Option<XPubType>) -> Result<Vec<u8>, ()> {
-    if xpub.depth.len() != 1
-        || xpub.parent_fingerprint.len() != 4
-        || xpub.chain_code.len() != 32
-        || xpub.public_key.len() != 33
-    {
-        return Err(());
+#[derive(Clone)]
+pub struct Xpub {
+    xpub: pb::XPub,
+}
+
+impl core::convert::From<pb::XPub> for Xpub {
+    fn from(xpub: pb::XPub) -> Self {
+        Xpub { xpub }
     }
+}
 
-    // Version bytes for mainnet public, see BIP32.
-    let mut result: Vec<u8> = Vec::new();
-    if let Some(xpub_type) = xpub_type {
-        let version = match xpub_type {
-            XPubType::Tpub => b"\x04\x35\x87\xcf",
-            XPubType::Xpub => b"\x04\x88\xb2\x1e",
-            XPubType::Ypub => b"\x04\x9d\x7c\xb2",
-            XPubType::Zpub => b"\x04\xb2\x47\x46",
-            XPubType::Vpub => b"\x04\x5f\x1c\xf6",
-            XPubType::Upub => b"\x04\x4a\x52\x62",
-            XPubType::CapitalVpub => b"\x02\x57\x54\x83",
-            XPubType::CapitalZpub => b"\x02\xaa\x7e\xd3",
-            XPubType::CapitalUpub => b"\x02\x42\x89\xef",
-            XPubType::CapitalYpub => b"\x02\x95\xb4\x3f",
-        };
-        result.extend_from_slice(version);
+impl core::convert::From<&pb::XPub> for Xpub {
+    fn from(xpub: &pb::XPub) -> Self {
+        Xpub { xpub: xpub.clone() }
     }
-    result.extend_from_slice(&xpub.depth);
-    result.extend_from_slice(&xpub.parent_fingerprint);
-    result.extend_from_slice(&xpub.child_num.to_be_bytes());
-    result.extend_from_slice(&xpub.chain_code);
-    result.extend_from_slice(&xpub.public_key);
-    Ok(result)
 }
 
-/// Serialize an xpub as a Base58Check encoded string according to BIP32.
-pub fn serialize_xpub_str(xpub: &pb::XPub, xpub_type: XPubType) -> Result<String, ()> {
-    Ok(bs58::encode(serialize_xpub(xpub, Some(xpub_type))?)
-        .with_check()
-        .into_string())
+impl core::convert::From<Xpub> for pb::XPub {
+    fn from(xpub: Xpub) -> Self {
+        xpub.xpub
+    }
 }
 
-/// Parses an 78-ytes xpub bytestring, encoded according to BIP32. The 4 version bytes are not
-/// checked and discarded.
-pub fn parse_xpub_bytes(xpub: &[u8]) -> Result<pb::XPub, ()> {
-    if xpub.len() != 78 {
-        return Err(());
+impl Xpub {
+    /// Parses an 78-ytes xpub bytestring, encoded according to BIP32. The 4 version bytes are not
+    /// checked and discarded.
+    pub fn from_bytes(xpub: &[u8]) -> Result<Self, ()> {
+        if xpub.len() != 78 {
+            return Err(());
+        }
+        Ok(Self::from(pb::XPub {
+            depth: xpub[4..5].to_vec(),
+            parent_fingerprint: xpub[5..9].to_vec(),
+            child_num: u32::from_be_bytes(core::convert::TryInto::try_into(&xpub[9..13]).unwrap()),
+            chain_code: xpub[13..45].to_vec(),
+            public_key: xpub[45..78].to_vec(),
+        }))
+    }
+    /// Serializes a protobuf XPub to bytes according to the BIP32 specification. If xpub_type is
+    /// None, the four version bytes are skipped.
+    pub fn serialize(&self, xpub_type: Option<XPubType>) -> Result<Vec<u8>, ()> {
+        let xpub = &self.xpub;
+        if xpub.depth.len() != 1
+            || xpub.parent_fingerprint.len() != 4
+            || xpub.chain_code.len() != 32
+            || xpub.public_key.len() != 33
+        {
+            return Err(());
+        }
+
+        // Version bytes for mainnet public, see BIP32.
+        let mut result: Vec<u8> = Vec::new();
+        if let Some(xpub_type) = xpub_type {
+            let version = match xpub_type {
+                XPubType::Tpub => b"\x04\x35\x87\xcf",
+                XPubType::Xpub => b"\x04\x88\xb2\x1e",
+                XPubType::Ypub => b"\x04\x9d\x7c\xb2",
+                XPubType::Zpub => b"\x04\xb2\x47\x46",
+                XPubType::Vpub => b"\x04\x5f\x1c\xf6",
+                XPubType::Upub => b"\x04\x4a\x52\x62",
+                XPubType::CapitalVpub => b"\x02\x57\x54\x83",
+                XPubType::CapitalZpub => b"\x02\xaa\x7e\xd3",
+                XPubType::CapitalUpub => b"\x02\x42\x89\xef",
+                XPubType::CapitalYpub => b"\x02\x95\xb4\x3f",
+            };
+            result.extend_from_slice(version);
+        }
+        result.extend_from_slice(&xpub.depth);
+        result.extend_from_slice(&xpub.parent_fingerprint);
+        result.extend_from_slice(&xpub.child_num.to_be_bytes());
+        result.extend_from_slice(&xpub.chain_code);
+        result.extend_from_slice(&xpub.public_key);
+        Ok(result)
+    }
+
+    /// Serialize an xpub as a Base58Check encoded string according to BIP32.
+    pub fn serialize_str(&self, xpub_type: XPubType) -> Result<String, ()> {
+        Ok(bs58::encode(self.serialize(Some(xpub_type))?)
+            .with_check()
+            .into_string())
+    }
+
+    /// Returns the 33 bytes secp256k1 compressed pubkey.
+    pub fn public_key(&self) -> &[u8] {
+        self.xpub.public_key.as_slice()
+    }
+
+    /// Return the hash160 of the secp256k1 public key.
+    pub fn pubkey_hash160(&self) -> Vec<u8> {
+        bitbox02::hash160(self.public_key()).to_vec()
+    }
+
+    /// Return the 65 byte secp256k1 compressed pubkey:
+    ///
+    /// (<0x04><64 bytes X><64 bytes Y>).
+    pub fn pubkey_uncompressed(&self) -> Result<[u8; 65], ()> {
+        bitbox02::keystore::secp256k1_pubkey_compressed_to_uncompressed(self.public_key())
     }
-    Ok(pb::XPub {
-        depth: xpub[4..5].to_vec(),
-        parent_fingerprint: xpub[5..9].to_vec(),
-        child_num: u32::from_be_bytes(core::convert::TryInto::try_into(&xpub[9..13]).unwrap()),
-        chain_code: xpub[13..45].to_vec(),
-        public_key: xpub[45..78].to_vec(),
-    })
 }
 
 /// Parses a Base58Check-encoded xpub string. The 4 version bytes are not checked and discarded.
 #[cfg(test)]
 pub fn parse_xpub(xpub: &str) -> Result<pb::XPub, ()> {
     let decoded = bs58::decode(xpub).with_check(None).into_vec().or(Err(()))?;
-    parse_xpub_bytes(&decoded)
+    Ok(Xpub::from_bytes(&decoded)?.into())
 }
 
 #[cfg(test)]
@@ -89,50 +131,74 @@ mod tests {
 
     #[test]
     fn test_parse_serialize_xpub() {
-        let xpub = parse_xpub("xpub6Eu7xJRyXRCi4eLYhJPnfZVjgAQtM7qFaEZwUhvgxGf4enEZMxevGzWvZTawCj9USP2MFTEhKQAwnqHwoaPHetTLqGuvq5r5uaLKyGx5QDZ").unwrap();
+        let xpub = Xpub::from(parse_xpub("xpub6Eu7xJRyXRCi4eLYhJPnfZVjgAQtM7qFaEZwUhvgxGf4enEZMxevGzWvZTawCj9USP2MFTEhKQAwnqHwoaPHetTLqGuvq5r5uaLKyGx5QDZ").unwrap());
         assert_eq!(
-            serialize_xpub(&xpub, None).unwrap(),
+            xpub.serialize(None).unwrap(),
             hex::decode("04b9d184d180000002b5b571ead68edac616c38491d9fd78d4697077e7675333452b586e3282705a3a0281bec7de8d182945744445948b54800e95267a5ac039bab6218a03b8e6f4b38a").unwrap(),
         );
         assert_eq!(
-            serialize_xpub_str(&xpub, XPubType::Tpub).unwrap().as_str(),
+            xpub.serialize_str(XPubType::Tpub).unwrap().as_str(),
             "tpubDFGkUYFfEhAALSXQ9VNssUq71HWYLWLK7sAEqFyqJBQxQ4uGSBW1RSBkoVfijE6iEHZFs2kZrVzzV1nZCSEXYKudtsfEWcWKVXvjjLeRyd8",
         );
         assert_eq!(
-            serialize_xpub_str(&xpub, XPubType::Xpub).unwrap().as_str(),
+            xpub.serialize_str(XPubType::Xpub).unwrap().as_str(),
             "xpub6Eu7xJRyXRCi4eLYhJPnfZVjgAQtM7qFaEZwUhvgxGf4enEZMxevGzWvZTawCj9USP2MFTEhKQAwnqHwoaPHetTLqGuvq5r5uaLKyGx5QDZ",
         );
         assert_eq!(
-            serialize_xpub_str(&xpub, XPubType::Ypub).unwrap().as_str(),
+            xpub.serialize_str(XPubType::Ypub).unwrap().as_str(),
             "ypub6ZjPFy6tg6kBuwXfXfBQsebEr8ZLHjpkVM6AG6paLH2wht3nccpUu4B4afYXCdoPr299zvqFn4XVg7uWXGoJT88whccMQzfaBJPyMrVtPLb",
         );
         assert_eq!(
-            serialize_xpub_str(&xpub, XPubType::Zpub).unwrap().as_str(),
+            xpub.serialize_str(XPubType::Zpub).unwrap().as_str(),
             "zpub6tZeZdmopnHfmEinN1y35jgk26hnEMpFQTcP3ViTiHQpkys1sGz3X7qCbsW7CYTKFfFxkQRpEit3ZQX5EyDKFMpYZxJmzuV4T2TckTXCeKB",
         );
         assert_eq!(
-            serialize_xpub_str(&xpub, XPubType::Vpub).unwrap().as_str(),
+            xpub.serialize_str(XPubType::Vpub).unwrap().as_str(),
             "vpub5bEbLy69E47kN3xK2apYFPJjLE7zTsrFk1XVuv8vCFuJYac6reKo2sCeX3fmCuqdd6njkW3aQ5Tr2G4pNBZG4R696bX5fGD7N8D3CBtsPoq",
         );
         assert_eq!(
-            serialize_xpub_str(&xpub, XPubType::Upub).unwrap().as_str(),
+            xpub.serialize_str(XPubType::Upub).unwrap().as_str(),
             "upub5GQL3JRE5NaGWkmCCE2v3JDEAFyYXFrkpu1H8XF2pFXRVUnsbzAEQoYWVqiBD1BiDTfw12T1wR7J8yTFeV9FGBQYEFpf5MPd6Q9PoXnSeMz",
         );
         assert_eq!(
-            serialize_xpub_str(&xpub, XPubType::CapitalVpub).unwrap().as_str(),
+            xpub.serialize_str(XPubType::CapitalVpub).unwrap().as_str(),
             "Vpub5n8gUCpao1g7nd7gyFHX5TeY42AFgEXr4HBAqBQTa2jiAmB1d3i57z4aKkdEmM4XrZrid63hHHrM9RgafQiDCuCow4dV4fg7FrUun5qYdcZ",
         );
         assert_eq!(
-            serialize_xpub_str(&xpub, XPubType::CapitalZpub).unwrap().as_str(),
+            xpub.serialize_str(XPubType::CapitalZpub).unwrap().as_str(),
             "Zpub75TjgsWFPjr3BotAJgS1up2Yjtk3SiVqijG3xkz164FEPARvdgNKcEh8QaTakygDV8KwczRw7wGYga8qYCNGPqwDQRRBQJx4LkjVLLY6Yta",
         );
         assert_eq!(
-            serialize_xpub_str(&xpub, XPubType::CapitalUpub).unwrap().as_str(),
+            xpub.serialize_str(XPubType::CapitalUpub).unwrap().as_str(),
             "Upub5TJRAY9feL8dwKva8tVtsNZ2t41ojcYM9Aex3nWaC2Mq7fMnNPYWVvQSJYfemSQcSvjuscT8pdVoG951wiJCQfXD4iw4Ukrcz8RGPZ1BoeD",
         );
         assert_eq!(
-            serialize_xpub_str(&xpub, XPubType::CapitalYpub).unwrap().as_str(),
+            xpub.serialize_str(XPubType::CapitalYpub).unwrap().as_str(),
             "Ypub6kdUPCqLF4JZLWh3UKePhiw3ZvbbW6WLocjqBN67i3sML4chP2CkzB2zPNVzm52J5VD8sWqNfGuzoHXGpVxFbcFcY5ikpQ8a52fqwpAmYX2",
         );
     }
+
+    #[test]
+    fn test_pubkey_hash160() {
+        let xpub = Xpub::from(parse_xpub("xpub6GugPDcUhrSudznFss7wXvQV3gwFTEanxHdCyoNoHnZEr3PTbh2Fosg4JjfphaYAsqjBhmtTZ3Yo8tmGjSHtaPhExNiMCSvPzreqjrX4Wr7").unwrap());
+        assert_eq!(
+            xpub.pubkey_hash160(),
+            *b"\xb5\x12\x5c\xec\xa0\xc1\xc8\x90\xda\x07\x9a\x12\x88\xdc\xf7\x7a\xa6\xac\xc4\x99"
+        );
+
+        let xpub = Xpub::from(parse_xpub("xpub6FiMwSqu98LjKsbGy1PfgGRQA9XH7k6dfsyPedsyrdBRJDPwc658JA3qGc7DV2dWUYVGEqzRicztwzCj1NprQSRbSubWcnkKxM3Gwnyh4xo").unwrap());
+        assert_eq!(
+            xpub.pubkey_hash160(),
+            *b"\xe5\xf8\x9a\xb6\x54\x37\x44\xf7\x8f\x15\x86\x7c\x43\x06\xee\x86\x6b\xb1\x1d\xf9"
+        );
+    }
+
+    #[test]
+    fn test_secp256k1_pubkey_uncompressed() {
+        let xpub = Xpub::from(parse_xpub("xpub6FiMwSqu98LjKsbGy1PfgGRQA9XH7k6dfsyPedsyrdBRJDPwc658JA3qGc7DV2dWUYVGEqzRicztwzCj1NprQSRbSubWcnkKxM3Gwnyh4xo").unwrap());
+        assert_eq!(
+            xpub.pubkey_uncompressed().unwrap(),
+            *b"\x04\x77\xa4\x4a\xa9\xe8\xc8\xfb\x51\x05\xef\x5e\xe2\x39\x4e\x8a\xed\x89\xad\x73\xfc\x74\x36\x14\x25\xf0\x63\x47\xec\xfe\x32\x61\x31\xe1\x33\x93\x67\xee\x3c\xbe\x87\x71\x92\x85\xa0\x7f\x77\x4b\x17\xeb\x93\x3e\xcf\x0b\x9b\x82\xac\xeb\xc1\x95\x22\x6d\x63\x42\x44",
+        );
+    }
 }

src/rust/bitbox02-rust/src/hww/api/bitcoin.rs

@@ -105,10 +105,9 @@ async fn xpub(
 ) -> Result<Response, Error> {
     let params = params::get(coin);
     keypath::validate_xpub(keypath, params.bip44_coin, params.taproot_support)?;
-    let xpub = crate::bip32::serialize_xpub_str(
-        &keystore::get_xpub(keypath).or(Err(Error::InvalidInput))?,
-        xpub_type,
-    )?;
+    let xpub = keystore::get_xpub(keypath)
+        .or(Err(Error::InvalidInput))?
+        .serialize_str(xpub_type)?;
     if display {
         let title = format!("{}\naccount #{}", params.name, keypath[2] - HARDENED + 1);
         let confirm_params = confirm::Params {

src/rust/bitbox02-rust/src/hww/api/bitcoin/common.rs

@@ -77,7 +77,7 @@ impl Payload {
     ) -> Result<Self, Error> {
         match simple_type {
             SimpleType::P2wpkh => Ok(Payload {
-                data: keystore::secp256k1_pubkey_hash160(keypath)?,
+                data: keystore::get_xpub(keypath)?.pubkey_hash160(),
                 output_type: BtcOutputType::P2wpkh,
             }),
             SimpleType::P2wpkhP2sh => {

src/rust/bitbox02-rust/src/hww/api/bitcoin/multisig.rs

@@ -40,7 +40,8 @@ pub fn convert_multisig(multisig: &Multisig) -> Result<bitbox02::app_btc::Multis
         xpubs: {
             let mut xpubs = [[0u8; 78]; MAX_SIGNERS];
             for (i, xpub) in multisig.xpubs.iter().enumerate() {
-                xpubs[i] = bip32::serialize_xpub(xpub, Some(bip32::XPubType::Xpub))
+                xpubs[i] = bip32::Xpub::from(xpub)
+                    .serialize(Some(bip32::XPubType::Xpub))
                     .or(Err(Error::InvalidInput))?
                     .try_into()
                     .or(Err(Error::Generic))?;
@@ -100,7 +101,7 @@ pub fn get_hash(
         let mut xpubs_serialized: Vec<Vec<u8>> = multisig
             .xpubs
             .iter()
-            .map(|xpub| bip32::serialize_xpub(xpub, None))
+            .map(|xpub| bip32::Xpub::from(xpub).serialize(None))
             .collect::<Result<Vec<Vec<u8>>, ()>>()?;
         if let SortXpubs::Yes = sort_xpubs {
             xpubs_serialized.sort();
@@ -236,8 +237,9 @@ pub async fn confirm_extended(
     };
     let num_cosigners = multisig.xpubs.len();
     for (i, xpub) in multisig.xpubs.iter().enumerate() {
-        let xpub_str =
-            bip32::serialize_xpub_str(xpub, output_xpub_type).or(Err(Error::InvalidInput))?;
+        let xpub_str = bip32::Xpub::from(xpub)
+            .serialize_str(output_xpub_type)
+            .or(Err(Error::InvalidInput))?;
         confirm::confirm(&confirm::Params {
             title,
             body: (if i == multisig.our_xpub_index as usize {
@@ -287,9 +289,9 @@ pub fn validate(multisig: &Multisig, keypath: &[u32], expected_coin: u32) -> Res
     )
     .or(Err(Error::InvalidInput))?;
 
-    let our_xpub = bip32::serialize_xpub(&crate::keystore::get_xpub(keypath)?, None)?;
+    let our_xpub = crate::keystore::get_xpub(keypath)?.serialize(None)?;
     let maybe_our_xpub =
-        bip32::serialize_xpub(&multisig.xpubs[multisig.our_xpub_index as usize], None)?;
+        bip32::Xpub::from(&multisig.xpubs[multisig.our_xpub_index as usize]).serialize(None)?;
     if our_xpub != maybe_our_xpub {
         return Err(Error::InvalidInput);
     }
@@ -774,7 +776,7 @@ mod tests {
             // invalid keypath, wrong purpose
             let mut invalid = multisig.clone();
             let keypath = &[49 + HARDENED, expected_coin, 0 + HARDENED, 2 + HARDENED];
-            invalid.xpubs[1] = crate::keystore::get_xpub(keypath).unwrap();
+            invalid.xpubs[1] = crate::keystore::get_xpub(keypath).unwrap().into();
             assert!(validate(&invalid, keypath, expected_coin).is_err());
         }
 
@@ -783,7 +785,7 @@ mod tests {
 
             let mut invalid = multisig.clone();
             let keypath = &[48 + HARDENED, expected_coin + 1, 0 + HARDENED, 2 + HARDENED];
-            invalid.xpubs[1] = crate::keystore::get_xpub(keypath).unwrap();
+            invalid.xpubs[1] = crate::keystore::get_xpub(keypath).unwrap().into();
             assert!(validate(&invalid, keypath, expected_coin).is_err());
         }
 
@@ -792,7 +794,7 @@ mod tests {
 
             let mut invalid = multisig.clone();
             let keypath = &[48 + HARDENED, expected_coin, 100 + HARDENED, 2 + HARDENED];
-            invalid.xpubs[1] = crate::keystore::get_xpub(keypath).unwrap();
+            invalid.xpubs[1] = crate::keystore::get_xpub(keypath).unwrap().into();
             assert!(validate(&invalid, keypath, expected_coin).is_err());
         }
 
@@ -801,7 +803,7 @@ mod tests {
 
             let mut invalid = multisig.clone();
             let keypath = &[48 + HARDENED, expected_coin, 0 + HARDENED, 1 + HARDENED];
-            invalid.xpubs[1] = crate::keystore::get_xpub(keypath).unwrap();
+            invalid.xpubs[1] = crate::keystore::get_xpub(keypath).unwrap().into();
             assert!(validate(&invalid, keypath, expected_coin).is_err());
         }
 

src/rust/bitbox02-rust/src/hww/api/bitcoin/signtx.rs

@@ -275,7 +275,7 @@ fn sighash_script(
                 | pb::btc_script_config::SimpleType::P2wpkh => {
                     // See https://github.com/bitcoin/bips/blob/master/bip-0143.mediawiki#specification, item 5:
                     // > For P2WPKH witness program, the scriptCode is 0x1976a914{20-byte-pubkey-hash}88ac.
-                    let pubkey_hash160 = crate::keystore::secp256k1_pubkey_hash160(keypath)?;
+                    let pubkey_hash160 = crate::keystore::get_xpub(keypath)?.pubkey_hash160();
                     let mut result = Vec::<u8>::new();
                     result.extend_from_slice(b"\x76\xa9\x14");
                     result.extend_from_slice(&pubkey_hash160);

src/rust/bitbox02-rust/src/hww/api/electrum.rs

@@ -39,10 +39,9 @@ pub async fn process(
     {
         return Err(Error::InvalidInput);
     }
-    let xpub = bip32::serialize_xpub_str(
-        &keystore::get_xpub(keypath).or(Err(Error::InvalidInput))?,
-        bip32::XPubType::Xpub,
-    )?;
+    let xpub = keystore::get_xpub(keypath)
+        .or(Err(Error::InvalidInput))?
+        .serialize_str(bip32::XPubType::Xpub)?;
 
     Ok(Response::ElectrumEncryptionKey(
         pb::ElectrumEncryptionKeyResponse { key: xpub },

src/rust/bitbox02-rust/src/hww/api/ethereum/pubrequest.rs

@@ -47,8 +47,9 @@ async fn process_address(request: &pb::EthPubRequest) -> Result<Response, Error>
     if !super::keypath::is_valid_keypath_address(&request.keypath) {
         return Err(Error::InvalidInput);
     }
-    let pubkey = crate::keystore::secp256k1_pubkey_uncompressed(&request.keypath)
-        .or(Err(Error::InvalidInput))?;
+    let pubkey = crate::keystore::get_xpub(&request.keypath)
+        .or(Err(Error::InvalidInput))?
+        .pubkey_uncompressed()?;
     let address = super::address::from_pubkey(&pubkey);
 
     if request.display {
@@ -79,10 +80,9 @@ fn process_xpub(request: &pb::EthPubRequest) -> Result<Response, Error> {
     if !super::keypath::is_valid_keypath_xpub(&request.keypath) {
         return Err(Error::InvalidInput);
     }
-    let xpub = bip32::serialize_xpub_str(
-        &keystore::get_xpub(&request.keypath).or(Err(Error::InvalidInput))?,
-        bip32::XPubType::Xpub,
-    )?;
+    let xpub = keystore::get_xpub(&request.keypath)
+        .or(Err(Error::InvalidInput))?
+        .serialize_str(bip32::XPubType::Xpub)?;
 
     Ok(Response::Pub(pb::PubResponse { r#pub: xpub }))
 }