Add encoded_length functions

Currently we do not enforce the BIP-173 maximum character length for
bech32 endoded strings.

Add two public functions, both called `encoded_length` that calculate
the length of an encoded bech32 string.

Do not call the functions yet.

Author: tcharding

src/lib.rs

@@ -345,6 +345,12 @@ pub fn encode_upper_to_writer<Ck: Checksum, W: std::io::Write>(
     Ok(())
 }
 
+/// Returns the length of the bech32 string after encoding `hrp` and `data` (incl. checksum).
+pub fn encoded_length<Ck: Checksum>(hrp: Hrp, data: &[u8]) -> usize {
+    let iter = data.iter().copied().bytes_to_fes();
+    hrp.len() + 1 + iter.len() + Ck::CHECKSUM_LENGTH // +1 for separator
+}
+
 /// An error while decoding a bech32 string.
 #[cfg(feature = "alloc")]
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -390,7 +396,7 @@ impl From<UncheckedHrpstringError> for DecodeError {
 #[cfg(feature = "alloc")]
 mod tests {
     use super::*;
-    use crate::Bech32;
+    use crate::{Bech32, Bech32m};
 
     // Tests below using this data, are based on the test vector (from BIP-173):
     // BC1QW508D6QEJXTDG4Y5R3ZARVARY0C5XW7KV8F3T4: 0014751e76e8199196d454941c45d1b3a323f1433bd6
@@ -475,4 +481,16 @@ mod tests {
         assert_eq!(hrp, Hrp::parse_unchecked("TEST"));
         assert_eq!(data, DATA);
     }
+
+    #[test]
+    fn encoded_length_works() {
+        let s = "test1lu08d6qejxtdg4y5r3zarvary0c5xw7kmz4lky";
+        let (hrp, data) = decode(s).expect("valid string");
+
+        let encoded = encode::<Bech32m>(hrp, &data).expect("valid data");
+        let want = encoded.len();
+        let got = encoded_length::<Bech32m>(hrp, &data);
+
+        assert_eq!(got, want);
+    }
 }

src/primitives/encode.rs

@@ -9,6 +9,8 @@
 //! In general, directly using these adaptors is not very ergonomic, and users are recommended to
 //! instead use the higher-level functions at the root of this crate.
 //!
+//! WARNING: This module does not enforce the maximum length of an encoded bech32 string (90 chars).
+//!
 //! # Examples
 //!
 //! ```

src/primitives/iter.rs

@@ -8,6 +8,8 @@
 //! - `FesToBytes`: An iterator over field elements to an iterator over bytes.
 //! - `Checksummed`: An iterator over field elements that appends the checksum.
 //!
+//! WARNING: This module does not enforce the maximum length of an encoded bech32 string (90 chars).
+//!
 //! # Examples
 //!
 //! ```

src/segwit.rs

@@ -264,6 +264,16 @@ pub fn encode_upper_to_writer_unchecked<W: std::io::Write>(
     Ok(())
 }
 
+/// Returns the length of the bech32 string after encoding HRP, witness version and program.
+pub fn encoded_length(
+    hrp: Hrp,
+    _witness_version: Fe32, // Emphasize that this is only for segwit.
+    witness_program: &[u8],
+) -> usize {
+    // Ck is only for length and since they are both the same we can use either here.
+    crate::encoded_length::<Bech32>(hrp, witness_program) + 1 // +1 for witness version.
+}
+
 /// An error while decoding a segwit address.
 #[cfg(feature = "alloc")]
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -428,4 +438,22 @@ mod tests {
         let want = "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4";
         assert_eq!(address, want);
     }
+
+    #[test]
+    fn encoded_length_works() {
+        let addresses = vec![
+            "bc1q2s3rjwvam9dt2ftt4sqxqjf3twav0gdx0k0q2etxflx38c3x8tnssdmnjq",
+            "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4",
+        ];
+
+        for address in addresses {
+            let (hrp, version, program) = decode(address).expect("valid address");
+
+            let encoded = encode(hrp, version, &program).expect("valid data");
+            let want = encoded.len();
+            let got = encoded_length(hrp, version, &program);
+
+            assert_eq!(got, want);
+        }
+    }
 }