Add a buffer when writing

As we did when writing in the `segwit` module; add a buffer to cache
characters and do writes a buffer at a time. Here we do not have a known
maximum length of the string we are encoding so we use an arbitrary
sized buffer and do multiple writes if it fills up.

Author: tcharding

src/lib.rs

@@ -166,6 +166,12 @@ pub use {
     crate::primitives::{Bech32, Bech32m, NoChecksum},
 };
 
+// Write to fmt buffer, small during testing to exercise full code path.
+#[cfg(not(test))]
+const BUF_LENGTH: usize = 1024;
+#[cfg(test)]
+const BUF_LENGTH: usize = 10;
+
 /// Decodes a bech32 encoded string.
 ///
 /// If this function succeeds the input string was found to be well formed (hrp, separator, bech32
@@ -319,11 +325,25 @@ pub fn encode_lower_to_fmt<Ck: Checksum, W: fmt::Write>(
     hrp: &Hrp,
     data: &[u8],
 ) -> Result<(), fmt::Error> {
+    let mut buf = [0u8; BUF_LENGTH];
+    let mut pos = 0;
+
     let iter = data.iter().copied().bytes_to_fes();
     let chars = iter.with_checksum::<Ck>(hrp).chars();
+
     for c in chars {
-        fmt.write_char(c)?;
+        buf[pos] = c as u8;
+        pos += 1;
+        if pos == BUF_LENGTH {
+            let s = core::str::from_utf8(&buf).expect("we only write ASCII");
+            fmt.write_str(s)?;
+            pos = 0;
+        }
     }
+
+    let s = core::str::from_utf8(&buf[..pos]).expect("we only write ASCII");
+    fmt.write_str(s)?;
+
     Ok(())
 }
 
@@ -346,11 +366,25 @@ pub fn encode_upper_to_fmt<Ck: Checksum, W: fmt::Write>(
     hrp: &Hrp,
     data: &[u8],
 ) -> Result<(), fmt::Error> {
+    let mut buf = [0u8; BUF_LENGTH];
+    let mut pos = 0;
+
     let iter = data.iter().copied().bytes_to_fes();
     let chars = iter.with_checksum::<Ck>(hrp).chars();
+
     for c in chars {
-        fmt.write_char(c.to_ascii_uppercase())?;
+        buf[pos] = c.to_ascii_uppercase() as u8;
+        pos += 1;
+        if pos == BUF_LENGTH {
+            let s = core::str::from_utf8(&buf).expect("we only write ASCII");
+            fmt.write_str(s)?;
+            pos = 0;
+        }
     }
+
+    let s = core::str::from_utf8(&buf[..pos]).expect("we only write ASCII");
+    fmt.write_str(s)?;
+
     Ok(())
 }
 
@@ -397,11 +431,23 @@ pub fn encode_lower_to_writer<Ck: Checksum, W: std::io::Write>(
     hrp: &Hrp,
     data: &[u8],
 ) -> Result<(), std::io::Error> {
+    let mut buf = [0u8; BUF_LENGTH];
+    let mut pos = 0;
+
     let iter = data.iter().copied().bytes_to_fes();
     let chars = iter.with_checksum::<Ck>(hrp).chars();
+
     for c in chars {
-        w.write_all(&[c as u8])?;
+        buf[pos] = c as u8;
+        pos += 1;
+        if pos == BUF_LENGTH {
+            w.write_all(&buf)?;
+            pos = 0;
+        }
     }
+
+    w.write_all(&buf[..pos])?;
+
     Ok(())
 }
 
@@ -425,11 +471,23 @@ pub fn encode_upper_to_writer<Ck: Checksum, W: std::io::Write>(
     hrp: &Hrp,
     data: &[u8],
 ) -> Result<(), std::io::Error> {
+    let mut buf = [0u8; BUF_LENGTH];
+    let mut pos = 0;
+
     let iter = data.iter().copied().bytes_to_fes();
     let chars = iter.with_checksum::<Ck>(hrp).chars();
+
     for c in chars {
-        w.write_all(&[c.to_ascii_uppercase() as u8])?;
+        buf[pos] = c.to_ascii_uppercase() as u8;
+        pos += 1;
+        if pos == BUF_LENGTH {
+            w.write_all(&buf)?;
+            pos = 0;
+        }
     }
+
+    w.write_all(&buf[..pos])?;
+
     Ok(())
 }