Support bech32 encoding without a checksum

BOLT 12 Offers uses bech32 encoding without a checksum since QR codes
already have a checksum. Add functions encode_without_checksum and
decode_without_checksum to support this use case.

Also, remove overall length check in decode since it is unnecessary.

Author: jkczyz

src/lib.rs

@@ -134,6 +134,7 @@ pub struct Bech32Writer<'a> {
     formatter: &'a mut fmt::Write,
     chk: u32,
     variant: Variant,
+    checksum: Checksum,
 }
 
 impl<'a> Bech32Writer<'a> {
@@ -144,12 +145,14 @@ impl<'a> Bech32Writer<'a> {
     pub fn new(
         hrp: &str,
         variant: Variant,
+        checksum: Checksum,
         fmt: &'a mut fmt::Write,
     ) -> Result<Bech32Writer<'a>, fmt::Error> {
         let mut writer = Bech32Writer {
             formatter: fmt,
             chk: 1,
             variant,
+            checksum,
         };
 
         writer.formatter.write_str(hrp)?;
@@ -186,6 +189,10 @@ impl<'a> Bech32Writer<'a> {
     }
 
     fn inner_finalize(&mut self) -> fmt::Result {
+        if let Checksum::Exclude = self.checksum {
+            return Ok(());
+        }
+
         // Pad with 6 zeros
         for _ in 0..6 {
             self.polymod_step(u5(0))
@@ -405,13 +412,14 @@ pub fn encode_to_fmt<T: AsRef<[u5]>>(
     hrp: &str,
     data: T,
     variant: Variant,
+    checksum: Checksum,
 ) -> Result<fmt::Result, Error> {
     let hrp_lower = match check_hrp(hrp)? {
         Case::Upper => Cow::Owned(hrp.to_lowercase()),
         Case::Lower | Case::None => Cow::Borrowed(hrp),
     };
 
-    match Bech32Writer::new(&hrp_lower, variant, fmt) {
+    match Bech32Writer::new(&hrp_lower, variant, checksum, fmt) {
         Ok(mut writer) => {
             Ok(writer.write(data.as_ref()).and_then(|_| {
                 // Finalize manually to avoid panic on drop if write fails
@@ -452,6 +460,14 @@ impl Variant {
     }
 }
 
+/// Whether or not a checksum should be included when encoding.
+pub enum Checksum {
+    /// Include a checksum.
+    Include,
+    /// Exclude a checksum.
+    Exclude,
+}
+
 /// Encode a bech32 payload to string.
 ///
 /// # Errors
@@ -460,19 +476,48 @@ impl Variant {
 /// * No length limits are enforced for the data part
 pub fn encode<T: AsRef<[u5]>>(hrp: &str, data: T, variant: Variant) -> Result<String, Error> {
     let mut buf = String::new();
-    encode_to_fmt(&mut buf, hrp, data, variant)?.unwrap();
+    encode_to_fmt(&mut buf, hrp, data, variant, Checksum::Include)?.unwrap();
+    Ok(buf)
+}
+
+/// Encode a bech32 payload to string without the checksum.
+///
+/// # Errors
+/// * If [check_hrp] returns an error for the given HRP.
+/// # Deviations from standard
+/// * No length limits are enforced for the data part
+pub fn encode_without_checksum<T: AsRef<[u5]>>(hrp: &str, data: T, variant: Variant) -> Result<String, Error> {
+    let mut buf = String::new();
+    encode_to_fmt(&mut buf, hrp, data, variant, Checksum::Exclude)?.unwrap();
     Ok(buf)
 }
 
 /// Decode a bech32 string into the raw HRP and the data bytes.
 ///
-/// Returns the HRP in lowercase..
+/// Returns the HRP in lowercase, the data with the checksum removed, and the encoding.
 pub fn decode(s: &str) -> Result<(String, Vec<u5>, Variant), Error> {
-    // Ensure overall length is within bounds
-    if s.len() < 8 {
+    let (hrp_lower, mut data) = decode_without_checksum(s)?;
+    if data.len() < 6 {
         return Err(Error::InvalidLength);
     }
 
+    // Ensure checksum
+    match verify_checksum(hrp_lower.as_bytes(), &data) {
+        Some(variant) => {
+            // Remove checksum from data payload
+            let dbl: usize = data.len();
+            data.truncate(dbl - 6);
+
+            Ok((hrp_lower, data, variant))
+        }
+        None => Err(Error::InvalidChecksum),
+    }
+}
+
+/// Decode a bech32 string into the raw HRP and the data bytes, assuming no checksum.
+///
+/// Returns the HRP in lowercase and the data with the checksum removed.
+pub fn decode_without_checksum(s: &str) -> Result<(String, Vec<u5>), Error> {
     // Split at separator and check for two pieces
     let (raw_hrp, raw_data) = match s.rfind(SEP) {
         None => return Err(Error::MissingSeparator),
@@ -481,9 +526,6 @@ pub fn decode(s: &str) -> Result<(String, Vec<u5>, Variant), Error> {
             (hrp, &data[1..])
         }
     };
-    if raw_data.len() < 6 {
-        return Err(Error::InvalidLength);
-    }
 
     let mut case = check_hrp(raw_hrp)?;
     let hrp_lower = match case {
@@ -493,7 +535,7 @@ pub fn decode(s: &str) -> Result<(String, Vec<u5>, Variant), Error> {
     };
 
     // Check data payload
-    let mut data = raw_data
+    let data = raw_data
         .chars()
         .map(|c| {
             // Only check if c is in the ASCII range, all invalid ASCII
@@ -528,17 +570,7 @@ pub fn decode(s: &str) -> Result<(String, Vec<u5>, Variant), Error> {
         })
         .collect::<Result<Vec<u5>, Error>>()?;
 
-    // Ensure checksum
-    match verify_checksum(hrp_lower.as_bytes(), &data) {
-        Some(variant) => {
-            // Remove checksum from data payload
-            let dbl: usize = data.len();
-            data.truncate(dbl - 6);
-
-            Ok((hrp_lower, data, variant))
-        }
-        None => Err(Error::InvalidChecksum),
-    }
+    Ok((hrp_lower, data))
 }
 
 fn verify_checksum(hrp: &[u8], data: &[u5]) -> Option<Variant> {
@@ -792,6 +824,8 @@ mod tests {
                 Error::InvalidLength),
             ("1p2gdwpf",
                 Error::InvalidLength),
+            ("bc1p2",
+                Error::InvalidLength),
         );
         for p in pairs {
             let (s, expected_error) = p;
@@ -921,13 +955,13 @@ mod tests {
     }
 
     #[test]
-    fn writer() {
+    fn write_with_checksum() {
         let hrp = "lnbc";
         let data = "Hello World!".as_bytes().to_base32();
 
         let mut written_str = String::new();
         {
-            let mut writer = Bech32Writer::new(hrp, Variant::Bech32, &mut written_str).unwrap();
+            let mut writer = Bech32Writer::new(hrp, Variant::Bech32, Checksum::Include, &mut written_str).unwrap();
             writer.write(&data).unwrap();
             writer.finalize().unwrap();
         }
@@ -938,13 +972,30 @@ mod tests {
     }
 
     #[test]
-    fn write_on_drop() {
+    fn write_without_checksum() {
+        let hrp = "lnbc";
+        let data = "Hello World!".as_bytes().to_base32();
+
+        let mut written_str = String::new();
+        {
+            let mut writer = Bech32Writer::new(hrp, Variant::Bech32, Checksum::Exclude, &mut written_str).unwrap();
+            writer.write(&data).unwrap();
+            writer.finalize().unwrap();
+        }
+
+        let encoded_str = encode_without_checksum(hrp, data, Variant::Bech32).unwrap();
+
+        assert_eq!(encoded_str, written_str);
+    }
+
+    #[test]
+    fn write_with_checksum_on_drop() {
         let hrp = "lntb";
         let data = "Hello World!".as_bytes().to_base32();
 
         let mut written_str = String::new();
         {
-            let mut writer = Bech32Writer::new(hrp, Variant::Bech32, &mut written_str).unwrap();
+            let mut writer = Bech32Writer::new(hrp, Variant::Bech32, Checksum::Include, &mut written_str).unwrap();
             writer.write(&data).unwrap();
         }
 
@@ -953,6 +1004,22 @@ mod tests {
         assert_eq!(encoded_str, written_str);
     }
 
+    #[test]
+    fn write_without_checksum_on_drop() {
+        let hrp = "lntb";
+        let data = "Hello World!".as_bytes().to_base32();
+
+        let mut written_str = String::new();
+        {
+            let mut writer = Bech32Writer::new(hrp, Variant::Bech32, Checksum::Exclude, &mut written_str).unwrap();
+            writer.write(&data).unwrap();
+        }
+
+        let encoded_str = encode_without_checksum(hrp, data, Variant::Bech32).unwrap();
+
+        assert_eq!(encoded_str, written_str);
+    }
+
     #[test]
     fn test_hrp_case() {
         // Tests for issue with HRP case checking being ignored for encoding