fix: start error strings with lowercase in descriptors::key module

Author: chris-ricketts

src/descriptor/key.rs

@@ -354,20 +354,20 @@ impl fmt::Display for MalformedKeyDataKind {
         use MalformedKeyDataKind::*;
 
         let err = match self {
-            EmptyKey => "Empty key",
-            EncounteredUnprintableCharacter => "Encountered an unprintable character",
-            InvalidFullPublicKeyPrefix => "Only full public keys with prefixes '02', '03' or '04' are allowed",
-            InvalidMasterFingerprintLength => "Master fingerprint should be 8 characters long",
-            InvalidMultiIndexStep => "Invalid multi index step in multipath descriptor",
-            InvalidMultiXKeyDerivation => "Can't make a multi-xpriv with hardened derivation steps that are not shared among all paths into a public key",
-            InvalidPublicKeyLength => "Public keys must be 64, 66 or 130 characters in size",
+            EmptyKey => "empty key",
+            EncounteredUnprintableCharacter => "encountered an unprintable character",
+            InvalidFullPublicKeyPrefix => "only full public keys with prefixes '02', '03' or '04' are allowed",
+            InvalidMasterFingerprintLength => "master fingerprint should be 8 characters long",
+            InvalidMultiIndexStep => "invalid multi index step in multipath descriptor",
+            InvalidMultiXKeyDerivation => "can't make a multi-xpriv with hardened derivation steps that are not shared among all paths into a public key",
+            InvalidPublicKeyLength => "public keys must be 64, 66 or 130 characters in size",
             InvalidWildcardInDerivationPath => "'*' may only appear as last element in a derivation path",
-            KeyTooShort => "Key too short",
-            MultipleFingerprintsInPublicKey => "Multiple ']' in Descriptor Public Key",
+            KeyTooShort => "key too short",
+            MultipleFingerprintsInPublicKey => "multiple ']' in Descriptor Public Key",
             MultipleDerivationPathIndexSteps => "'<' may only appear once in a derivation path",
-            NoKeyAfterOrigin => "No key after origin",
-            NoMasterFingerprintFound => "No master fingerprint found after '['",
-            UnclosedSquareBracket => "Unclosed '['",
+            NoKeyAfterOrigin => "no key after origin",
+            NoMasterFingerprintFound => "no master fingerprint found after '['",
+            UnclosedSquareBracket => "unclosed '['",
             WildcardAsDerivedDescriptorKey => "cannot parse key with a wilcard as a DerivedDescriptorKey",
         };
 
@@ -415,34 +415,34 @@ impl fmt::Display for DescriptorKeyParseError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
             DescriptorKeyParseError::Bip32Xpriv(err) => {
-                write!(f, "Error while parsing BIP32 Xpriv: {err}")
+                write!(f, "error while parsing BIP32 Xpriv: {err}")
             }
             DescriptorKeyParseError::Bip32Xpub(err) => {
-                write!(f, "Error while parsing BIP32 Xpub: {err}")
+                write!(f, "error while parsing BIP32 Xpub: {err}")
             }
             DescriptorKeyParseError::DerivationIndexError { index, err } => {
-                write!(f, "Error while parsing derivation index '{index}': {err}")
+                write!(f, "error while parsing derivation index '{index}': {err}")
             }
             DescriptorKeyParseError::DeriveHardenedKey(err) => {
-                write!(f, "Unable to derive the hardened steps: {err}")
+                write!(f, "unable to derive the hardened steps: {err}")
             }
             DescriptorKeyParseError::MalformedKeyData(err) => {
                 write!(f, "{err}")
             }
             DescriptorKeyParseError::MasterDerivationPath(err) => {
-                write!(f, "Error while parsing master derivation path: {err}")
+                write!(f, "error while parsing master derivation path: {err}")
             }
             DescriptorKeyParseError::MasterFingerprint { fingerprint, err } => {
-                write!(f, "Error while parsing master fingerprint '{fingerprint}': {err}")
+                write!(f, "error while parsing master fingerprint '{fingerprint}': {err}")
             }
             DescriptorKeyParseError::FullPublicKey(err) => {
-                write!(f, "Error while parsing full public key: {err}")
+                write!(f, "error while parsing full public key: {err}")
             }
             DescriptorKeyParseError::WifPrivateKey(err) => {
-                write!(f, "Error while parsing WIF private key: {err}")
+                write!(f, "error while parsing WIF private key: {err}")
             }
             DescriptorKeyParseError::XonlyPublicKey(err) => {
-                write!(f, "Error while parsing xonly public key: {err}")
+                write!(f, "error while parsing xonly public key: {err}")
             }
         }
     }
@@ -1387,42 +1387,42 @@ mod test {
         let desc = "[NonHexor]xpub6ERApfZwUNrhLCkDtcHTcxd75RbzS1ed54G1LkBUHQVHQKqhMkhgbmJbZRkrgZw4koxb5JaHWkY4ALHY2grBGRjaDMzQLcgJvLJuZZvRcEL/1/*";
         assert_eq!(
             DescriptorPublicKey::from_str(desc).unwrap_err().to_string(),
-            "Error while parsing master fingerprint 'NonHexor': failed to parse hex digit"
+            "error while parsing master fingerprint 'NonHexor': failed to parse hex digit"
         );
 
         // And ones with invalid xpubs..
         let desc = "[78412e3a]xpub1ed54G1LkBUHQVHQKqhMkhgbmJbZRkrgZw4koxb5JaLcgJvLJuZZvRcEL/1/*";
         assert_eq!(
             DescriptorPublicKey::from_str(desc).unwrap_err().to_string(),
-            "Error while parsing BIP32 Xpub: base58 encoding error"
+            "error while parsing BIP32 Xpub: base58 encoding error"
         );
 
         // ..or invalid raw keys
         let desc = "[78412e3a]0208a117f3897c3a13c9384b8695eed98dc31bc2500feb19a1af424cd47a5d83/1/*";
         assert_eq!(
             DescriptorPublicKey::from_str(desc).unwrap_err().to_string(),
-            "Public keys must be 64, 66 or 130 characters in size",
+            "public keys must be 64, 66 or 130 characters in size",
         );
 
         // ..or invalid separators
         let desc = "[78412e3a]]03f28773c2d975288bc7d1d205c3748651b075fbc6610e58cddeeddf8f19405aa8";
         assert_eq!(
             DescriptorPublicKey::from_str(desc).unwrap_err().to_string(),
-            "Multiple \']\' in Descriptor Public Key"
+            "multiple \']\' in Descriptor Public Key"
         );
 
         // fuzzer errors
         let desc = "[11111f11]033333333333333333333333333333323333333333333333333333333433333333]]333]]3]]101333333333333433333]]]10]333333mmmm";
         assert_eq!(
             DescriptorPublicKey::from_str(desc).unwrap_err().to_string(),
-            "Multiple \']\' in Descriptor Public Key"
+            "multiple \']\' in Descriptor Public Key"
         );
 
         // fuzz failure, hybrid keys
         let desc = "0777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777";
         assert_eq!(
             DescriptorPublicKey::from_str(desc).unwrap_err().to_string(),
-            "Only full public keys with prefixes '02', '03' or '04' are allowed"
+            "only full public keys with prefixes '02', '03' or '04' are allowed"
         );
     }
 
@@ -1434,21 +1434,21 @@ mod test {
             DescriptorSecretKey::from_str(secret_key)
                 .unwrap_err()
                 .to_string(),
-            "Error while parsing BIP32 Xpriv: unknown version magic bytes: [4, 136, 178, 30]"
+            "error while parsing BIP32 Xpriv: unknown version magic bytes: [4, 136, 178, 30]"
         );
 
         // And ones with invalid fingerprints
         let desc = "[NonHexor]tprv8ZgxMBicQKsPcwcD4gSnMti126ZiETsuX7qwrtMypr6FBwAP65puFn4v6c3jrN9VwtMRMph6nyT63NrfUL4C3nBzPcduzVSuHD7zbX2JKVc/1/*";
         assert_eq!(
             DescriptorSecretKey::from_str(desc).unwrap_err().to_string(),
-            "Error while parsing master fingerprint 'NonHexor': failed to parse hex digit"
+            "error while parsing master fingerprint 'NonHexor': failed to parse hex digit"
         );
 
         // ..or invalid raw keys
         let desc = "[78412e3a]L32jTfVLei6BYTPUpwpJSkrHx8iL9GZzeErVS8y4Y/1/*";
         assert_eq!(
             DescriptorSecretKey::from_str(desc).unwrap_err().to_string(),
-            "Error while parsing WIF private key: invalid base58"
+            "error while parsing WIF private key: invalid base58"
         );
     }