Bech32 prefix instead of Bech32m (#218)

Author: casey

src/bech32m_decoder.rs src/bech32_decoder.rssrc/bech32m_decoder.rs renamed to src/bech32_decoder.rs

@@ -1,13 +1,13 @@
 use super::*;
 
-pub(crate) struct Bech32mDecoder<'a> {
+pub(crate) struct Bech32Decoder<'a> {
   data: &'a [u8],
   i: usize,
-  ty: Bech32mType,
+  ty: Bech32Type,
 }
 
-impl<'a> Bech32mDecoder<'a> {
-  pub(crate) fn byte_array<const LEN: usize>(&mut self) -> Result<[u8; LEN], Bech32mError> {
+impl<'a> Bech32Decoder<'a> {
+  pub(crate) fn byte_array<const LEN: usize>(&mut self) -> Result<[u8; LEN], Bech32Error> {
     let mut array = [0; LEN];
 
     for (slot, byte) in array.iter_mut().zip(self.bytes(LEN)?) {
@@ -17,7 +17,7 @@ impl<'a> Bech32mDecoder<'a> {
     Ok(array)
   }
 
-  fn bytes(&mut self, len: usize) -> Result<impl Iterator<Item = u8>, Bech32mError> {
+  fn bytes(&mut self, len: usize) -> Result<impl Iterator<Item = u8>, Bech32Error> {
     let fe_len = (len * 8).div_ceil(5);
 
     let fes = self.fes(fe_len)?;
@@ -26,14 +26,14 @@ impl<'a> Bech32mDecoder<'a> {
       let padding_len = (i + 1) * 5 % 8;
 
       if padding_len > 4 {
-        return Err(Bech32mError::Padding {
+        return Err(Bech32Error::Padding {
           source: PaddingError::TooMuch,
           ty: self.ty,
         });
       }
 
       if u64::from(last.to_u8().trailing_zeros()) < padding_len.into_u64() {
-        return Err(Bech32mError::Padding {
+        return Err(Bech32Error::Padding {
           source: PaddingError::NonZero,
           ty: self.ty,
         });
@@ -43,30 +43,30 @@ impl<'a> Bech32mDecoder<'a> {
     Ok(fes.fes_to_bytes())
   }
 
-  pub(crate) fn done(self) -> Result<(), Bech32mError> {
+  pub(crate) fn done(self) -> Result<(), Bech32Error> {
     let excess = self.data.len() - self.i;
 
     ensure! {
       excess == 0,
-      bech32m_error::Overlong { excess, ty: self.ty },
+      bech32_error::Overlong { excess, ty: self.ty },
     }
 
     Ok(())
   }
 
-  pub(crate) fn fe(&mut self) -> Result<Fe32, Bech32mError> {
+  pub(crate) fn fe(&mut self) -> Result<Fe32, Bech32Error> {
     let next = self
       .data
       .get(self.i)
       .map(|c| Fe32::from_char_unchecked(*c))
-      .context(bech32m_error::Truncated { ty: self.ty })?;
+      .context(bech32_error::Truncated { ty: self.ty })?;
 
     self.i += 1;
 
     Ok(next)
   }
 
-  pub(crate) fn fe_array<const LEN: usize>(&mut self) -> Result<[Fe32; LEN], Bech32mError> {
+  pub(crate) fn fe_array<const LEN: usize>(&mut self) -> Result<[Fe32; LEN], Bech32Error> {
     let mut array = [Fe32::Q; LEN];
 
     for slot in &mut array {
@@ -79,11 +79,11 @@ impl<'a> Bech32mDecoder<'a> {
   fn fes(
     &mut self,
     len: usize,
-  ) -> Result<impl Iterator<Item = Fe32> + Clone + use<'a>, Bech32mError> {
+  ) -> Result<impl Iterator<Item = Fe32> + Clone + use<'a>, Bech32Error> {
     let end = self.i + len;
 
     if end > self.data.len() {
-      return Err(Bech32mError::Truncated { ty: self.ty });
+      return Err(Bech32Error::Truncated { ty: self.ty });
     }
 
     let fes = &self.data[self.i..end];
@@ -93,29 +93,29 @@ impl<'a> Bech32mDecoder<'a> {
     Ok(fes.iter().map(|c| Fe32::from_char_unchecked(*c)))
   }
 
-  pub(crate) fn into_bytes(mut self) -> Result<Vec<u8>, Bech32mError> {
+  pub(crate) fn into_bytes(mut self) -> Result<Vec<u8>, Bech32Error> {
     let fes = self.data.len() - self.i;
     Ok(self.bytes(fes * 5 / 8)?.collect())
   }
 
-  pub(crate) fn new(ty: Bech32mType, s: &'a str) -> Result<Self, Bech32mError> {
+  pub(crate) fn new(ty: Bech32Type, s: &'a str) -> Result<Self, Bech32Error> {
     let hrp_string =
-      CheckedHrpstring::new::<bech32::Bech32m>(s).context(bech32m_error::Decode { ty })?;
+      CheckedHrpstring::new::<bech32::Bech32m>(s).context(bech32_error::Decode { ty })?;
 
     let actual = hrp_string.hrp();
 
     ensure! {
       actual == *ty.hrp(),
-      bech32m_error::Hrp { ty, actual },
+      bech32_error::Hrp { ty, actual },
     }
 
     let mut fes = hrp_string.fe32_iter::<std::vec::IntoIter<u8>>();
 
-    let version = fes.next().context(bech32m_error::Truncated { ty })?;
+    let version = fes.next().context(bech32_error::Truncated { ty })?;
 
     ensure! {
-      version == BECH32M_VERSION,
-      bech32m_error::UnsupportedVersion { ty, version },
+      version == BECH32_VERSION,
+      bech32_error::UnsupportedVersion { ty, version },
     }
 
     Ok(Self {

src/bech32m_encoder.rs src/bech32_encoder.rssrc/bech32m_encoder.rs renamed to src/bech32_encoder.rs

@@ -1,11 +1,11 @@
 use super::*;
 
-pub(crate) struct Bech32mEncoder {
+pub(crate) struct Bech32Encoder {
   fes: Vec<Fe32>,
-  ty: Bech32mType,
+  ty: Bech32Type,
 }
 
-impl Bech32mEncoder {
+impl Bech32Encoder {
   pub(crate) fn bytes(&mut self, bytes: &[u8]) {
     self.fes.extend(bytes.iter().copied().bytes_to_fes());
   }
@@ -14,15 +14,15 @@ impl Bech32mEncoder {
     self.fes.extend_from_slice(fes);
   }
 
-  pub(crate) fn new(ty: Bech32mType) -> Self {
+  pub(crate) fn new(ty: Bech32Type) -> Self {
     Self {
-      fes: vec![BECH32M_VERSION],
+      fes: vec![BECH32_VERSION],
       ty,
     }
   }
 }
 
-impl Display for Bech32mEncoder {
+impl Display for Bech32Encoder {
   fn fmt(&self, f: &mut Formatter) -> fmt::Result {
     for c in self
       .fes

src/bech32_error.rs

@@ -0,0 +1,30 @@
+use super::*;
+
+#[derive(Debug, Snafu)]
+#[snafu(context(suffix(false)), visibility(pub(crate)))]
+pub enum Bech32Error {
+  #[snafu(display("failed to decode bech32 {ty}"))]
+  Decode {
+    ty: Bech32Type,
+    source: CheckedHrpstringError,
+  },
+  #[snafu(display(
+    "expected bech32 human-readable part `{}1...` but found `{actual}1...`",
+    ty.hrp(),
+  ))]
+  Hrp { ty: Bech32Type, actual: crate::Hrp },
+  #[snafu(display("bech32 {ty} overlong by {}", Count(*excess, "characters")))]
+  Overlong { excess: usize, ty: Bech32Type },
+  #[snafu(display("bech32 {ty} has invalid padding"))]
+  Padding {
+    ty: Bech32Type,
+    source: PaddingError,
+  },
+  #[snafu(display("bech32 {ty} truncated"))]
+  Truncated { ty: Bech32Type },
+  #[snafu(display("bech32 {ty} version `{version}` is not supported"))]
+  UnsupportedVersion {
+    ty: Bech32Type,
+    version: bech32::Fe32,
+  },
+}

src/bech32m_type.rs src/bech32_type.rssrc/bech32m_type.rs renamed to src/bech32_type.rs

@@ -1,14 +1,14 @@
 use super::*;
 
 #[derive(Clone, Copy, Debug, PartialEq)]
-pub enum Bech32mType {
+pub enum Bech32Type {
   Fingerprint,
   PrivateKey,
   PublicKey,
   Signature,
 }
 
-impl Bech32mType {
+impl Bech32Type {
   pub(crate) fn hrp(self) -> &'static Hrp {
     static FINGERPRINT: Hrp = Hrp::parse_unchecked("package");
     static PRIVATE_KEY: Hrp = Hrp::parse_unchecked("private");
@@ -24,7 +24,7 @@ impl Bech32mType {
   }
 }
 
-impl Display for Bech32mType {
+impl Display for Bech32Type {
   fn fmt(&self, f: &mut Formatter) -> fmt::Result {
     match self {
       Self::Fingerprint => write!(f, "package fingerprint"),

src/bech32m_error.rs

@@ -4,7 +4,7 @@ pub(crate) struct DisplaySecret(pub(crate) PrivateKey);
 
 impl Display for DisplaySecret {
   fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-    let mut encoder = Bech32mEncoder::new(Bech32mType::PrivateKey);
+    let mut encoder = Bech32Encoder::new(Bech32Type::PrivateKey);
     encoder.bytes(&self.0.as_secret_bytes());
     write!(f, "{encoder}")
   }

src/display_secret.rs

@@ -9,44 +9,44 @@ pub enum Error {
     actual: Hash,
     expected: Hash,
   },
-  #[snafu(display("failed to decode bech32m `{bech32m}`"))]
-  Bech32mDecode {
+  #[snafu(display("failed to decode bech32 `{bech32}`"))]
+  Bech32Decode {
     backtrace: Option<Backtrace>,
-    bech32m: String,
+    bech32: String,
     source: CheckedHrpstringError,
   },
-  #[snafu(display("failed to encode bech32m"))]
-  Bech32mEncode {
+  #[snafu(display("failed to encode bech32"))]
+  Bech32Encode {
     backtrace: Option<Backtrace>,
     source: bech32::EncodeError,
   },
-  #[snafu(display("failed to parse bech32m human-readable part"))]
-  Bech32mHrp {
+  #[snafu(display("failed to parse bech32 human-readable part"))]
+  Bech32Hrp {
     backtrace: Option<Backtrace>,
     source: bech32::primitives::hrp::Error,
   },
-  #[snafu(display("invalid bech32m prefix character `{character}`"))]
-  Bech32mPrefix {
+  #[snafu(display("invalid bech32 prefix character `{character}`"))]
+  Bech32Prefix {
     backtrace: Option<Backtrace>,
     character: char,
     source: bech32::primitives::gf32::FromCharError,
   },
-  #[snafu(display("bech32m prefix missing"))]
-  Bech32mPrefixMissing { backtrace: Option<Backtrace> },
-  #[snafu(display("invalid bech32m version character `{version}`"))]
-  Bech32mVersion {
+  #[snafu(display("bech32 prefix missing"))]
+  Bech32PrefixMissing { backtrace: Option<Backtrace> },
+  #[snafu(display("invalid bech32 version character `{version}`"))]
+  Bech32Version {
     backtrace: Option<Backtrace>,
     source: bech32::primitives::gf32::FromCharError,
     version: char,
   },
-  #[snafu(display("bech32m version `{actual}` does not match expected `{expected}`"))]
-  Bech32mVersionMismatch {
+  #[snafu(display("bech32 version `{actual}` does not match expected `{expected}`"))]
+  Bech32VersionMismatch {
     backtrace: Option<Backtrace>,
     actual: bech32::Fe32,
     expected: bech32::Fe32,
   },
-  #[snafu(display("bech32m version character missing"))]
-  Bech32mVersionMissing { backtrace: Option<Backtrace> },
+  #[snafu(display("bech32 version character missing"))]
+  Bech32VersionMissing { backtrace: Option<Backtrace> },
   #[snafu(display("failed to get current directory"))]
   CurrentDir {
     backtrace: Option<Backtrace>,
@@ -227,7 +227,7 @@ pub enum Error {
   PrivateKeyLoad {
     backtrace: Option<Backtrace>,
     path: DisplayPath,
-    source: Bech32mError,
+    source: Bech32Error,
   },
   #[snafu(display("private key not found: `{path}`"))]
   PrivateKeyNotFound {

src/error.rs

@@ -14,17 +14,17 @@ impl Fingerprint {
 
 impl Display for Fingerprint {
   fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-    let mut encoder = Bech32mEncoder::new(Bech32mType::Fingerprint);
+    let mut encoder = Bech32Encoder::new(Bech32Type::Fingerprint);
     encoder.bytes(self.as_bytes());
     write!(f, "{encoder}")
   }
 }
 
 impl FromStr for Fingerprint {
-  type Err = Bech32mError;
+  type Err = Bech32Error;
 
   fn from_str(s: &str) -> Result<Self, Self::Err> {
-    let mut decoder = Bech32mDecoder::new(Bech32mType::Fingerprint, s)?;
+    let mut decoder = Bech32Decoder::new(Bech32Type::Fingerprint, s)?;
     let inner = decoder.byte_array()?;
     decoder.done()?;
     Ok(Self(inner.into()))

src/fingerprint.rs

@@ -19,10 +19,10 @@
 use {
   self::{
     arguments::Arguments,
-    bech32m_decoder::Bech32mDecoder,
-    bech32m_encoder::Bech32mEncoder,
-    bech32m_error::Bech32mError,
-    bech32m_type::Bech32mType,
+    bech32_decoder::Bech32Decoder,
+    bech32_encoder::Bech32Encoder,
+    bech32_error::Bech32Error,
+    bech32_type::Bech32Type,
     component::Component,
     component_error::ComponentError,
     count::Count,
@@ -134,10 +134,10 @@ macro_rules! assert_matches {
 }
 
 mod arguments;
-mod bech32m_decoder;
-mod bech32m_encoder;
-mod bech32m_error;
-mod bech32m_type;
+mod bech32_decoder;
+mod bech32_encoder;
+mod bech32_error;
+mod bech32_type;
 mod component;
 mod component_error;
 mod count;
@@ -201,7 +201,7 @@ mod ssh;
 #[cfg(test)]
 mod test;
 
-const BECH32M_VERSION: Fe32 = Fe32::A;
+const BECH32_VERSION: Fe32 = Fe32::A;
 
 type Result<T = (), E = Error> = std::result::Result<T, E>;