New component: zcash_address crate

components/zcash_address/proptest-regressions/kind/unified.txt

@@ -0,0 +1,7 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+cc e08469bc301313ef868b97a5c37d9a9746d9720c915a9127c89db25c3be778fd # shrinks to ua = Address([Sapling([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), P2pkh([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])])

components/zcash_address/src/kind/unified.rs

@@ -120,22 +120,77 @@ impl TryFrom<&[u8]> for Address {
 impl Address {
     /// Returns the raw encoding of this Unified Address.
     pub(crate) fn to_bytes(&self) -> Vec<u8> {
-        self.0
+        let encoded: Vec<_> = self
+            .0
             .iter()
             .flat_map(|receiver| {
                 let addr = receiver.addr();
                 // Holds by construction.
                 assert!(addr.len() < 256);
 
-                let encoded: Vec<_> = iter::empty()
+                iter::empty()
                     .chain(Some(receiver.typecode()))
                     .chain(Some(addr.len() as u8))
                     .chain(addr.into_iter().cloned())
-                    .chain(iter::repeat(0).take(PADDING_LEN))
-                    .collect();
-
-                f4jumble::f4jumble(&encoded).unwrap()
             })
-            .collect()
+            .chain(iter::repeat(0).take(PADDING_LEN))
+            .collect();
+
+        f4jumble::f4jumble(&encoded).unwrap()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::convert::TryFrom;
+
+    use proptest::{
+        array::{uniform11, uniform20, uniform32},
+        prelude::*,
+    };
+
+    use super::{Address, Receiver};
+
+    prop_compose! {
+        fn uniform43()(a in uniform11(0u8..), b in uniform32(0u8..)) -> [u8; 43] {
+            let mut c = [0; 43];
+            c[..11].copy_from_slice(&a);
+            c[11..].copy_from_slice(&b);
+            c
+        }
+    }
+
+    fn arb_shielded_receiver() -> BoxedStrategy<Receiver> {
+        prop_oneof![
+            uniform43().prop_map(Receiver::Sapling),
+            uniform43().prop_map(Receiver::Orchard),
+        ]
+        .boxed()
+    }
+
+    fn arb_transparent_receiver() -> BoxedStrategy<Receiver> {
+        prop_oneof![
+            uniform20(0u8..).prop_map(Receiver::P2pkh),
+            uniform20(0u8..).prop_map(Receiver::P2sh),
+        ]
+        .boxed()
+    }
+
+    prop_compose! {
+        fn arb_unified_address()(
+            shielded in prop::collection::hash_set(arb_shielded_receiver(), 1..2),
+            transparent in prop::option::of(arb_transparent_receiver()),
+        ) -> Address {
+            Address(shielded.into_iter().chain(transparent).collect())
+        }
+    }
+
+    proptest! {
+        #[test]
+        fn ua_roundtrip(ua in arb_unified_address()) {
+            let bytes = ua.to_bytes();
+            let decoded = Address::try_from(&bytes[..]);
+            prop_assert_eq!(decoded, Ok(ua));
+        }
     }
 }