add fuzztest for equivalence between new and old transaction decoding

Author: apoelstra

fuzz/Cargo.toml

@@ -33,6 +33,13 @@ allowed_duplicates = [
     "wasi",
 ]
 
+[[bin]]
+name = "decode_equiv_transaction"
+path = "fuzz_targets/decode_equiv_transaction.rs"
+test = false
+doc = false
+bench = false
+
 [[bin]]
 name = "deserialize_block"
 path = "fuzz_targets/deserialize_block.rs"

fuzz/fuzz_targets/decode_equiv_transaction.rs

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+//! Fuzz test for equivalent decoding between the legacy and consensus-encoding decoding schemes.
+
+#![cfg_attr(fuzzing, no_main)]
+#![cfg_attr(not(fuzzing), allow(unused))]
+use libfuzzer_sys::fuzz_target;
+
+use elements::bitcoin::hex::DisplayHex as _;
+
+type Target = elements::Transaction;
+
+#[cfg(not(fuzzing))]
+fn main() {}
+
+struct DisplayError<'e>(&'e dyn std::error::Error);
+
+impl core::fmt::Display for DisplayError<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}\n", self.0)?;
+        let mut e = self.0;
+        while let Some(source) = e.source() {
+            write!(f, "caused by {}\n", source)?;
+            e = source;
+        }
+        Ok(())
+    }
+}
+
+fn do_test(data: &[u8]) {
+    let old: Result<Target, _> = elements::encode::deserialize(data);
+    let new: Result<Target, _> = elements::encoding::decode_from_slice(data);
+
+    match (old, new) {
+        (Err(_), Err(_)) => {},
+        (Err(e), Ok(new)) => {
+            let e = DisplayError(&e);
+            panic!("Decodable trait failed with {e}; Decode parsed {:?}", new);
+        }
+        (Ok(old), Err(e)) => {
+            let e = DisplayError(&e);
+            panic!("Decode trait failed with {e}; Decodable parsed {:?}", old);
+        }
+        (Ok(old), Ok(new)) => {
+            assert_eq!(
+                old, new,
+                "Decodable (left) did not match Decode (right)",
+            );
+
+            let reser_old = elements::encode::serialize(&old);
+            let reser_new = elements::encoding::encode_to_vec(&new);
+            assert_eq!(
+                reser_old, reser_new,
+                "Encodable (left) did not match Encode (right)\nOld hex: {}\nNew hex: {}\nTransaction: {:?}",
+                reser_old.as_hex(),
+                reser_new.as_hex(),
+                old,
+            );
+        }
+    }
+}
+
+fuzz_target!(|data: &[u8]| {
+    do_test(data);
+});
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn duplicate_crash() {
+        let v = elements::hex::decode_to_vec("abcd");
+        super::do_test(&v);
+    }
+}