fuzz: add regression test for taptree behavior

This fuzztest currently does almost nothing, because both 12.x and
master just pass through to rust-bitcoin's `TapRootSpendInfo` structure
for everything related to taptrees.

In a later PR we will move all this stuff into rust-miniscript and then
we will want a regression test.

Author: apoelstra

.github/workflows/cron-daily-fuzz.yml

@@ -25,6 +25,7 @@ parse_descriptor,
 parse_descriptor_priv,
 parse_descriptor_secret,
 regression_descriptor_parse,
+regression_taptree,
 roundtrip_concrete,
 roundtrip_descriptor,
 roundtrip_miniscript_script,

fuzz/Cargo.toml

@@ -46,6 +46,10 @@ path = "fuzz_targets/parse_descriptor_secret.rs"
 name = "regression_descriptor_parse"
 path = "fuzz_targets/regression_descriptor_parse.rs"
 
+[[bin]]
+name = "regression_taptree"
+path = "fuzz_targets/regression_taptree.rs"
+
 [[bin]]
 name = "roundtrip_concrete"
 path = "fuzz_targets/roundtrip_concrete.rs"

fuzz/fuzz_targets/regression_taptree.rs

@@ -0,0 +1,46 @@
+use descriptor_fuzz::FuzzPk;
+use honggfuzz::fuzz;
+use miniscript::descriptor::Tr;
+use old_miniscript::descriptor::Tr as OldTr;
+
+fn do_test(data: &[u8]) {
+    let data_str = String::from_utf8_lossy(data);
+    match (data_str.parse::<Tr<FuzzPk>>(), data_str.parse::<OldTr<FuzzPk>>()) {
+        (Err(_), Err(_)) => {}
+        (Ok(_), Err(_)) => {} // 12.x logic rejects some parses for sanity reasons
+        (Err(e), Ok(x)) => panic!("old logic parses {} as {:?}, new fails with {}", data_str, x, e),
+        (Ok(new), Ok(old)) => {
+            let new_si = new.spend_info();
+            let old_si = old.spend_info();
+            assert_eq!(
+                old_si.internal_key(),
+                new_si.internal_key(),
+                "merkle root mismatch (left is old, new is right)",
+            );
+            assert_eq!(
+                old_si.merkle_root(),
+                new_si.merkle_root(),
+                "merkle root mismatch (left is old, new is right)",
+            );
+            assert_eq!(
+                old_si.output_key(),
+                new_si.output_key(),
+                "merkle root mismatch (left is old, new is right)",
+            );
+        }
+    }
+}
+
+fn main() {
+    loop {
+        fuzz!(|data| {
+            do_test(data);
+        });
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn duplicate_crash() { crate::do_test(b"tr(0,{0,0})"); }
+}

fuzz/src/lib.rs

@@ -42,14 +42,42 @@ impl MiniscriptKey for FuzzPk {
     type Hash256 = u8;
 }
 
+impl ToPublicKey for FuzzPk {
+    fn to_public_key(&self) -> PublicKey {
+        let secp_pk = secp256k1::PublicKey::from_slice(&[
+            0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3b, 0x78,
+            0xce, 0x56, 0x3f, 0x89, 0xa0, 0xed, 0x94, 0x14, 0xf5, 0xaa, 0x28, 0xad, 0x0d, 0x96,
+            0xd6, 0x79, 0x5f, 0x9c, 0x63, 0x3f, 0x39, 0x79, 0xbf, 0x72, 0xae, 0x82, 0x02, 0x98,
+            0x3d, 0xc9, 0x89, 0xae, 0xc7, 0xf2, 0xff, 0x2e, 0xd9, 0x1b, 0xdd, 0x69, 0xce, 0x02,
+            0xfc, 0x07, 0x00, 0xca, 0x10, 0x0e, 0x59, 0xdd, 0xf3,
+        ])
+        .unwrap();
+        PublicKey { inner: secp_pk, compressed: self.compressed }
+    }
+
+    fn to_sha256(hash: &Self::Sha256) -> sha256::Hash { sha256::Hash::from_byte_array([*hash; 32]) }
+
+    fn to_hash256(hash: &Self::Hash256) -> hash256::Hash {
+        hash256::Hash::from_byte_array([*hash; 32])
+    }
+
+    fn to_ripemd160(hash: &Self::Ripemd160) -> ripemd160::Hash {
+        ripemd160::Hash::from_byte_array([*hash; 20])
+    }
+
+    fn to_hash160(hash: &Self::Ripemd160) -> hash160::Hash {
+        hash160::Hash::from_byte_array([*hash; 20])
+    }
+}
+
 impl old_miniscript::MiniscriptKey for FuzzPk {
     type Sha256 = u8;
     type Ripemd160 = u8;
     type Hash160 = u8;
     type Hash256 = u8;
 }
 
-impl ToPublicKey for FuzzPk {
+impl old_miniscript::ToPublicKey for FuzzPk {
     fn to_public_key(&self) -> PublicKey {
         let secp_pk = secp256k1::PublicKey::from_slice(&[
             0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3b, 0x78,
@@ -64,8 +92,8 @@ impl ToPublicKey for FuzzPk {
 
     fn to_sha256(hash: &Self::Sha256) -> sha256::Hash { sha256::Hash::from_byte_array([*hash; 32]) }
 
-    fn to_hash256(hash: &Self::Hash256) -> hash256::Hash {
-        hash256::Hash::from_byte_array([*hash; 32])
+    fn to_hash256(hash: &Self::Hash256) -> old_miniscript::hash256::Hash {
+        old_miniscript::hash256::Hash::from_byte_array([*hash; 32])
     }
 
     fn to_ripemd160(hash: &Self::Ripemd160) -> ripemd160::Hash {