refactor: add MalformedKeyDataKind enum to DescriptorKeyParseError definition

Author: chris-ricketts

src/descriptor/key.rs

@@ -278,7 +278,7 @@ impl DescriptorMultiXKey<bip32::Xpriv> {
                             Ok(*child_num)
                         } else {
                             Err(DescriptorKeyParseError::MalformedKeyData(
-                                "Can't make a multi-xpriv with hardened derivation steps that are not shared among all paths into a public key"
+                                MalformedKeyDataKind::InvalidMultiXKeyDerivation,
                             ))
                         }
                     })
@@ -327,6 +327,53 @@ impl DescriptorMultiXKey<bip32::Xpriv> {
     }
 }
 
+/// Kinds of malformed key data
+#[derive(Debug, PartialEq, Clone)]
+#[non_exhaustive]
+pub enum MalformedKeyDataKind {
+    InvalidMultiXKeyDerivation,
+    KeyTooShort,
+    InvalidFullPublicKeyPrefix,
+    InvalidPublicKeyLength,
+    EncounteredUnprintableCharacter,
+    EmptyKey,
+    UnclosedSquareBracket,
+    NoMasterFingerprintFound,
+    InvalidMasterFingerprintLength,
+    NoKeyAfterOrigin,
+    MultipleClosingSquareBracketsInPublicKey,
+    InvalidWildcardInDerivationPath,
+    MultipleDerivationPathIndexSteps,
+    InvalidMultiIndexStep,
+    WildcardAsDerivedDescriptorKey,
+}
+
+impl fmt::Display for MalformedKeyDataKind {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use MalformedKeyDataKind::*;
+
+        let err = match self {
+            InvalidMultiXKeyDerivation => "Can't make a multi-xpriv with hardened derivation steps that are not shared among all paths into a public key",
+            KeyTooShort => "Key too short",
+            InvalidFullPublicKeyPrefix => "Only full public keys with prefixes '02', '03' or '04' are allowed",
+            InvalidPublicKeyLength => "Public keys must be 64, 66 or 130 characters in size",
+            EncounteredUnprintableCharacter => "Encountered an unprintable character",
+            EmptyKey => "Empty key",
+            UnclosedSquareBracket => "Unclosed '['",
+            NoMasterFingerprintFound => "No master fingerprint found after '['",
+            InvalidMasterFingerprintLength => "Master fingerprint should be 8 characters long",
+            NoKeyAfterOrigin => "No key after origin",
+            MultipleClosingSquareBracketsInPublicKey => "Multiple ']' in Descriptor Public Key",
+            InvalidWildcardInDerivationPath => "'*' may only appear as last element in a derivation path",
+            MultipleDerivationPathIndexSteps => "'<' may only appear once in a derivation path",
+            InvalidMultiIndexStep => "Invalid multi index step in multipath descriptor",
+            WildcardAsDerivedDescriptorKey => "cannot parse key with a wilcard as a DerivedDescriptorKey",
+        };
+
+        f.write_str(err)
+    }
+}
+
 /// Descriptor Key parsing errors
 #[derive(Debug, PartialEq, Clone)]
 #[non_exhaustive]
@@ -344,8 +391,8 @@ pub enum DescriptorKeyParseError {
     },
     /// Error deriving the hardened private key.
     DeriveHardenedKey(bip32::Error),
-    /// Error indicating the key data was malformed with details provided
-    MalformedKeyData(&'static str),
+    /// Error indicating the key data was malformed
+    MalformedKeyData(MalformedKeyDataKind),
     /// Error while parsing the master derivation path.
     MasterDerivationPath(bip32::Error),
     /// Error indicating a malformed master fingerprint (invalid hex).
@@ -567,7 +614,9 @@ impl FromStr for DescriptorPublicKey {
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         // A "raw" public key without any origin is the least we accept.
         if s.len() < 64 {
-            return Err(DescriptorKeyParseError::MalformedKeyData("Key too short"));
+            return Err(DescriptorKeyParseError::MalformedKeyData(
+                MalformedKeyDataKind::KeyTooShort,
+            ));
         }
 
         let (key_part, origin) = parse_key_origin(s)?;
@@ -602,7 +651,7 @@ impl FromStr for DescriptorPublicKey {
                         || &key_part[0..2] == "04")
                     {
                         return Err(DescriptorKeyParseError::MalformedKeyData(
-                            "Only publickeys with prefixes '02', '03' or '04' are allowed",
+                            MalformedKeyDataKind::InvalidFullPublicKeyPrefix,
                         ));
                     }
                     let key = bitcoin::PublicKey::from_str(key_part)
@@ -611,7 +660,7 @@ impl FromStr for DescriptorPublicKey {
                 }
                 _ => {
                     return Err(DescriptorKeyParseError::MalformedKeyData(
-                        "Public keys must be 64, 66 or 130 characters in size",
+                        MalformedKeyDataKind::InvalidPublicKeyLength,
                     ))
                 }
             };
@@ -878,31 +927,33 @@ fn parse_key_origin(s: &str) -> Result<(&str, Option<bip32::KeySource>), Descrip
     for ch in s.as_bytes() {
         if *ch < 20 || *ch > 127 {
             return Err(DescriptorKeyParseError::MalformedKeyData(
-                "Encountered an unprintable character",
+                MalformedKeyDataKind::EncounteredUnprintableCharacter,
             ));
         }
     }
 
     if s.is_empty() {
-        return Err(DescriptorKeyParseError::MalformedKeyData("Empty key"));
+        return Err(DescriptorKeyParseError::MalformedKeyData(MalformedKeyDataKind::EmptyKey));
     }
     let mut parts = s[1..].split(']');
 
     if let Some('[') = s.chars().next() {
         let mut raw_origin = parts
             .next()
-            .ok_or(DescriptorKeyParseError::MalformedKeyData("Unclosed '['"))?
+            .ok_or(DescriptorKeyParseError::MalformedKeyData(
+                MalformedKeyDataKind::UnclosedSquareBracket,
+            ))?
             .split('/');
 
         let origin_id_hex = raw_origin
             .next()
             .ok_or(DescriptorKeyParseError::MalformedKeyData(
-                "No master fingerprint found after '['",
+                MalformedKeyDataKind::NoMasterFingerprintFound,
             ))?;
 
         if origin_id_hex.len() != 8 {
             return Err(DescriptorKeyParseError::MalformedKeyData(
-                "Master fingerprint should be 8 characters long",
+                MalformedKeyDataKind::InvalidMasterFingerprintLength,
             ));
         }
         let parent_fingerprint = bip32::Fingerprint::from_hex(origin_id_hex).map_err(|err| {
@@ -918,11 +969,13 @@ fn parse_key_origin(s: &str) -> Result<(&str, Option<bip32::KeySource>), Descrip
 
         let key = parts
             .next()
-            .ok_or(DescriptorKeyParseError::MalformedKeyData("No key after origin"))?;
+            .ok_or(DescriptorKeyParseError::MalformedKeyData(
+                MalformedKeyDataKind::NoKeyAfterOrigin,
+            ))?;
 
         if parts.next().is_some() {
             Err(DescriptorKeyParseError::MalformedKeyData(
-                "Multiple ']' in Descriptor Public Key",
+                MalformedKeyDataKind::MultipleClosingSquareBracketsInPublicKey,
             ))
         } else {
             Ok((key, Some((parent_fingerprint, origin_path))))
@@ -947,7 +1000,9 @@ fn parse_xkey_deriv<Key>(
     let mut key_deriv = key_deriv.split('/');
     let xkey_str = key_deriv
         .next()
-        .ok_or(DescriptorKeyParseError::MalformedKeyData("No key after origin"))?;
+        .ok_or(DescriptorKeyParseError::MalformedKeyData(
+            MalformedKeyDataKind::NoKeyAfterOrigin,
+        ))?;
 
     let xkey = parse_xkey_fn(xkey_str)?;
 
@@ -963,7 +1018,7 @@ fn parse_xkey_deriv<Key>(
                 None
             } else if wildcard != Wildcard::None {
                 Some(Err(DescriptorKeyParseError::MalformedKeyData(
-                    "'*' may only appear as last element in a derivation path",
+                    MalformedKeyDataKind::InvalidWildcardInDerivationPath,
                 )))
             } else {
                 // BIP389 defines a new step in the derivation path. This step contains two or more
@@ -972,7 +1027,7 @@ fn parse_xkey_deriv<Key>(
                     // There may only be one occurence of this step.
                     if multipath {
                         return Some(Err(DescriptorKeyParseError::MalformedKeyData(
-                            "'<' may only appear once in a derivation path",
+                            MalformedKeyDataKind::MultipleDerivationPathIndexSteps,
                         )));
                     }
                     multipath = true;
@@ -981,7 +1036,7 @@ fn parse_xkey_deriv<Key>(
                     // So it's at least '<' + a number + ';' + a number + '>'.
                     if p.len() < 5 || !p.contains(';') {
                         return Some(Err(DescriptorKeyParseError::MalformedKeyData(
-                            "Invalid multi index step in multipath descriptor",
+                            MalformedKeyDataKind::InvalidMultiIndexStep,
                         )));
                     }
 
@@ -1239,7 +1294,7 @@ impl FromStr for DefiniteDescriptorKey {
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let inner = DescriptorPublicKey::from_str(s)?;
         DefiniteDescriptorKey::new(inner).ok_or(DescriptorKeyParseError::MalformedKeyData(
-            "cannot parse key with a wilcard as a DerivedDescriptorKey",
+            MalformedKeyDataKind::WildcardAsDerivedDescriptorKey,
         ))
     }
 }
@@ -1366,7 +1421,7 @@ mod test {
         let desc = "0777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777";
         assert_eq!(
             DescriptorPublicKey::from_str(desc).unwrap_err().to_string(),
-            "Only publickeys with prefixes '02', '03' or '04' are allowed"
+            "Only full public keys with prefixes '02', '03' or '04' are allowed"
         );
     }