Re-write crate level API

Now we have all the new `primitives` pieces in place we can re-write the
public API to take advantage of them - WIN!

fuzz/fuzz_targets/decode_rnd.rs

@@ -1,14 +1,15 @@
 extern crate bech32;
 
+use bech32::Bech32m;
+
 fn do_test(data: &[u8]) {
     let data_str = String::from_utf8_lossy(data);
-    let decoded = bech32::decode(&data_str);
-    let b32 = match decoded {
-        Ok(b32) => b32,
+    let (hrp, data) = match bech32::decode_bech32m(&data_str) {
+        Ok((hrp, data)) => (hrp, data),
         Err(_) => return,
     };
 
-    assert_eq!(bech32::encode(b32.0, b32.1, b32.2).unwrap(), data_str);
+    assert_eq!(bech32::encode::<Bech32m>(hrp, &data).unwrap(), data_str);
 }
 
 #[cfg(feature = "afl")]

fuzz/fuzz_targets/encode_decode.rs

@@ -1,9 +1,8 @@
 extern crate bech32;
 
-use std::convert::TryFrom;
 use std::str;
 
-use bech32::Hrp;
+use bech32::{Bech32m, Hrp};
 
 fn do_test(data: &[u8]) {
     if data.len() < 1 {
@@ -16,28 +15,17 @@ fn do_test(data: &[u8]) {
         return;
     }
 
-    let dp = data[hrp_end..]
-        .iter()
-        .map(|b| bech32::u5::try_from(b % 32).unwrap())
-        .collect::<Vec<_>>();
-
-    let variant = if data[0] > 0x0f {
-        bech32::Variant::Bech32m
-    } else {
-        bech32::Variant::Bech32
-    };
+    let dp = &data[hrp_end..];
 
     match str::from_utf8(&data[1..hrp_end]) {
         Err(_) => return,
         Ok(s) => {
             match Hrp::parse(&s) {
                 Err(_) => return,
                 Ok(hrp) => {
-                    if let Ok(data_str) = bech32::encode(hrp, &dp, variant).map(|b32| b32.to_string()) {
-                        let decoded = bech32::decode(&data_str);
-                        let b32 = decoded.expect("should be able to decode own encoding");
-
-                        assert_eq!(bech32::encode(b32.0, &b32.1, b32.2).unwrap(), data_str);
+                    if let Ok(address) = bech32::encode::<Bech32m>(hrp, dp) {
+                        let (hrp, data) = bech32::decode_bech32m(&address).expect("should be able to decode own encoding");
+                        assert_eq!(bech32::encode::<Bech32m>(hrp, &data).unwrap(), address);
                     }
                 }
             }

src/hrp.rs

@@ -0,0 +1,15 @@
+// SPDX-License-Identifier: MIT
+
+//! Re-export the hrp types to make importing ergonomic for the top level APIs.
+
+/// The human-readable part used by the Bitcoin mainnet network.
+#[doc(inline)]
+pub use crate::primitives::hrp::BC;
+/// The human-readable part used when running a Bitcoin regtest network.
+#[doc(inline)]
+pub use crate::primitives::hrp::BCRT;
+/// The human-readable part used by the Bitcoin testnet networks (testnet, signet).
+#[doc(inline)]
+pub use crate::primitives::hrp::TB;
+/// The human-readable part (human readable prefix before the '1' separator).
+pub use crate::primitives::hrp::Hrp;