refactor(fuzz): extract shared harness library

- Move input generators into arbitrary module, generic over the
  checkpoint data type
- Move differential changeset and checkpoint-order assertions into
  checks module
- Add fuzz_main! macro generating AFL/honggfuzz/libFuzzer entry points
  and a corpus-replay fallback main
- Replace integer op dispatch with explicit Op enums
- Remove leftover debug println

Author: oleonardolima

fuzz/Cargo.toml

@@ -12,7 +12,7 @@ members = ["."]
 
 [dependencies]
 libfuzzer-sys = { version = "0.4", optional = true }
-arbitrary = "1.4.1"
+arbitrary = { version = "1.4.1", features = ["derive"] }
 honggfuzz = { version = "0.5.61", optional = true }
 afl = { version = "0.18.2", optional = true }
 bdk_chain = { path = "../crates/chain" }

fuzz/fuzz_targets/local_chain_apply_update.rs

@@ -1,108 +1,33 @@
 #![cfg_attr(feature = "libfuzzer_fuzz", no_main)]
 
-use std::collections::BTreeMap;
-
-use arbitrary::{Arbitrary, Unstructured};
-use bdk_chain::bitcoin::block::{Header, Version};
 use bdk_chain::bitcoin::hashes::Hash;
-use bdk_chain::bitcoin::{BlockHash, CompactTarget, TxMerkleNode};
-use bdk_chain::local_chain::{ChangeSet, LocalChain, MissingGenesisError};
-use bdk_chain::{BlockId, CheckPoint};
-
-fn arbitrary_hash(u: &mut Unstructured) -> arbitrary::Result<BlockHash> {
-    Ok(BlockHash::from_byte_array(<[u8; 32]>::arbitrary(u)?))
-}
-
-/// Builds a header for `apply_header(_connected_to)`. Its `prev_blockhash` is usually taken
-/// from an existing checkpoint (so the header connects to the chain), sometimes arbitrary.
-fn arbitrary_header(u: &mut Unstructured, chain: &LocalChain) -> arbitrary::Result<(Header, u32)> {
-    let (prev_blockhash, height) = if u.ratio(3, 4)? {
-        let block_ids: Vec<BlockId> = chain.iter_checkpoints().map(|cp| cp.block_id()).collect();
-        let connect_at = u.choose(&block_ids)?;
-        (connect_at.hash, connect_at.height.saturating_add(1))
-    } else {
-        (arbitrary_hash(u)?, u32::arbitrary(u)?)
-    };
-    let header = Header {
-        version: Version::from_consensus(i32::arbitrary(u)?),
-        prev_blockhash,
-        merkle_root: TxMerkleNode::from_byte_array(<[u8; 32]>::arbitrary(u)?),
-        time: u32::arbitrary(u)?,
-        bits: CompactTarget::from_consensus(u32::arbitrary(u)?),
-        nonce: u32::arbitrary(u)?,
-    };
-    Ok((header, height))
+use bdk_chain::bitcoin::BlockHash;
+use bdk_chain::local_chain::{LocalChain, MissingGenesisError};
+use bdk_chain::BlockId;
+use bdk_chain_fuzz::arbitrary::{self, Arbitrary, Unstructured};
+use bdk_chain_fuzz::checks::{assert_changeset_against_chains, assert_checkpoint_order};
+
+/// An operation to perform against the chain under test.
+#[derive(Arbitrary, Debug, Clone, Copy)]
+enum Op {
+    /// `apply_update` with an independently constructed chain as the update.
+    ApplyUpdate,
+    /// `insert_block` with an arbitrary height and hash.
+    InsertBlock,
+    /// `disconnect_from` an existing checkpoint or an arbitrary block id.
+    DisconnectFrom,
+    /// `apply_header` with a header that usually connects to an existing checkpoint.
+    ApplyHeader,
+    /// `apply_header_connected_to` with an arbitrarily picked connection point.
+    ApplyHeaderConnectedTo,
+    /// `apply_update` with an update derived by mutating the chain's own tip, so the
+    /// update shares `Arc` nodes with the original and exercises `merge_chains`'
+    /// `eq_ptr` fast path.
+    ApplyDerivedUpdate,
 }
 
-fn arbitrary_chain(u: &mut Unstructured) -> arbitrary::Result<Option<LocalChain>> {
-    let raw_blocks: BTreeMap<u32, [u8; 32]> = BTreeMap::arbitrary(u)?;
-    println!("{:#?}", raw_blocks);
-    let blocks: BTreeMap<u32, BlockHash> = raw_blocks
-        .into_iter()
-        .map(|(height, hash)| (height, BlockHash::from_byte_array(hash)))
-        .collect();
-
-    let constructed = match u.int_in_range(0..=2)? {
-        0 => LocalChain::from_blocks(blocks.clone()).ok(),
-        1 => {
-            let changeset = ChangeSet {
-                blocks: blocks.iter().map(|(&h, &hash)| (h, Some(hash))).collect(),
-            };
-            LocalChain::from_changeset(changeset).ok()
-        }
-        _ => CheckPoint::from_blocks(blocks.clone())
-            .ok()
-            .and_then(|tip| LocalChain::from_tip(tip).ok()),
-    };
-    let chain = match constructed {
-        Some(chain) => chain,
-        None => return Ok(None),
-    };
-
-    let tip = chain.tip();
-    let (&tip_height, &tip_hash) = blocks.last_key_value().expect("chain is non-empty");
-    assert_eq!(tip.block_id().height, tip_height);
-    assert_eq!(tip.block_id().hash, tip_hash);
-    assert_eq!(chain.genesis_hash(), blocks[&0]);
-
-    Ok(Some(chain))
-}
-
-/// Picks a block id for an operation: either a checkpoint of `chain` or an arbitrary one.
-fn arbitrary_block_id(u: &mut Unstructured, chain: &LocalChain) -> arbitrary::Result<BlockId> {
-    if bool::arbitrary(u)? {
-        let block_ids: Vec<BlockId> = chain.iter_checkpoints().map(|cp| cp.block_id()).collect();
-        Ok(*u.choose(&block_ids)?)
-    } else {
-        Ok(BlockId {
-            height: u32::arbitrary(u)?,
-            hash: arbitrary_hash(u)?,
-        })
-    }
-}
-
-/// On success, `pre`-state plus the returned changeset must reconstruct the post-state.
-/// On failure, the chain must be left untouched.
-fn check_op_result<E>(pre: LocalChain, post: &LocalChain, result: &Result<ChangeSet, E>) {
-    match result {
-        Ok(changeset) => {
-            let mut reconstructed = pre;
-            reconstructed
-                .apply_changeset(changeset)
-                .expect("applying an op's changeset to the pre-state must succeed");
-            assert_eq!(&reconstructed, post);
-        }
-        Err(_) => assert_eq!(&pre, post, "a failed op must not modify the chain"),
-    }
-}
-
-fn check_chain(chain: &LocalChain) {
-    let heights: Vec<u32> = chain.iter_checkpoints().map(|cp| cp.height()).collect();
-    assert!(
-        heights.windows(2).all(|w| w[0] > w[1]),
-        "checkpoint heights must be strictly decreasing from tip"
-    );
-    assert_eq!(heights.last(), Some(&0), "genesis must be present");
+fn assert_chain(chain: &LocalChain) {
+    assert_checkpoint_order(chain);
 
     let tip = chain.chain_tip();
     assert_eq!(tip, chain.tip().block_id());
@@ -137,7 +62,7 @@ fn do_test(data: &[u8]) {
     let mut chain: Option<LocalChain> = None;
     for _ in 0..op_count {
         if chain.is_none() {
-            match arbitrary_chain(&mut u) {
+            match arbitrary::blockhash_chain(&mut u) {
                 Ok(Some(initial)) => chain = Some(initial),
                 Ok(None) => continue,
                 Err(_) => break,
@@ -146,30 +71,30 @@ fn do_test(data: &[u8]) {
         }
         let chain = chain.as_mut().expect("initialized above");
 
-        let op = match u.int_in_range::<u8>(0..=5) {
+        let op = match Op::arbitrary(&mut u) {
             Ok(op) => op,
             Err(_) => break,
         };
         let pre = chain.clone();
         match op {
-            0 => {
-                let update = match arbitrary_chain(&mut u) {
+            Op::ApplyUpdate => {
+                let update = match arbitrary::blockhash_chain(&mut u) {
                     Ok(Some(update)) => update,
                     Ok(None) => continue,
                     Err(_) => break,
                 };
                 let result = chain.apply_update(update.tip());
-                check_op_result(pre, chain, &result);
+                assert_changeset_against_chains(pre, chain, &result);
             }
-            1 => {
+            Op::InsertBlock => {
                 let (height, hash) = match u32::arbitrary(&mut u)
-                    .and_then(|height| arbitrary_hash(&mut u).map(|hash| (height, hash)))
+                    .and_then(|height| arbitrary::hash(&mut u).map(|hash| (height, hash)))
                 {
                     Ok(block) => block,
                     Err(_) => break,
                 };
                 let result = chain.insert_block(height, hash);
-                check_op_result(pre, chain, &result);
+                assert_changeset_against_chains(pre, chain, &result);
                 match &result {
                     Ok(_) => {
                         assert_eq!(chain.get(height).map(|cp| cp.hash()), Some(hash));
@@ -183,13 +108,13 @@ fn do_test(data: &[u8]) {
                     }
                 }
             }
-            2 => {
-                let block_id = match arbitrary_block_id(&mut u, chain) {
+            Op::DisconnectFrom => {
+                let block_id = match arbitrary::block_id(&mut u, chain, &[]) {
                     Ok(block_id) => block_id,
                     Err(_) => break,
                 };
                 let result = chain.disconnect_from(block_id);
-                check_op_result(pre, chain, &result);
+                assert_changeset_against_chains(pre, chain, &result);
                 match &result {
                     Ok(changeset) if !changeset.blocks.is_empty() => {
                         assert!(chain.tip().height() < block_id.height);
@@ -201,46 +126,44 @@ fn do_test(data: &[u8]) {
                     }
                 }
             }
-            3 => {
-                let (header, height) = match arbitrary_header(&mut u, chain) {
+            Op::ApplyHeader => {
+                let (header, height) = match arbitrary::connectable_header(&mut u, chain) {
                     Ok(header) => header,
                     Err(_) => break,
                 };
                 let result = chain.apply_header(&header, height);
-                check_op_result(pre, chain, &result);
+                assert_changeset_against_chains(pre, chain, &result);
                 if result.is_ok() {
                     assert_eq!(
                         chain.get(height).map(|cp| cp.hash()),
                         Some(header.block_hash())
                     );
                 }
             }
-            4 => {
+            Op::ApplyHeaderConnectedTo => {
                 let params: arbitrary::Result<_> = (|| {
-                    let (header, height) = arbitrary_header(&mut u, chain)?;
-                    let connected_to = arbitrary_block_id(&mut u, chain)?;
+                    let (header, height) = arbitrary::connectable_header(&mut u, chain)?;
+                    let connected_to = arbitrary::block_id(&mut u, chain, &[])?;
                     Ok((header, height, connected_to))
                 })();
                 let (header, height, connected_to) = match params {
                     Ok(params) => params,
                     Err(_) => break,
                 };
                 let result = chain.apply_header_connected_to(&header, height, connected_to);
-                check_op_result(pre, chain, &result);
+                assert_changeset_against_chains(pre, chain, &result);
                 if result.is_ok() {
                     assert_eq!(
                         chain.get(height).map(|cp| cp.hash()),
                         Some(header.block_hash())
                     );
                 }
             }
-            _ => {
-                // Derived update: mutate the chain's own tip so the update shares `Arc`
-                // nodes with the original, exercising `merge_chains`' `eq_ptr` fast path.
+            Op::ApplyDerivedUpdate => {
                 let params: arbitrary::Result<_> = (|| {
                     let insert = bool::arbitrary(&mut u)?;
                     let height = u32::arbitrary(&mut u)?;
-                    let hash = arbitrary_hash(&mut u)?;
+                    let hash = arbitrary::hash(&mut u)?;
                     Ok((insert, height, hash))
                 })();
                 let (insert, height, hash) = match params {
@@ -262,54 +185,18 @@ fn do_test(data: &[u8]) {
                     }
                 };
                 let result = chain.apply_update(update_tip);
-                check_op_result(pre, chain, &result);
+                assert_changeset_against_chains(pre, chain, &result);
                 if result.is_ok() {
                     assert_eq!(chain.get(height).map(|cp| cp.hash()), Some(hash));
                 }
             }
         }
-        check_chain(chain);
+        assert_chain(chain);
     }
 
     if let Some(chain) = chain {
-        check_chain(&chain);
-    }
-}
-
-#[cfg(feature = "afl_fuzz")]
-#[macro_use]
-extern crate afl;
-#[cfg(feature = "afl_fuzz")]
-fn main() {
-    fuzz!(|data| { do_test(data) });
-}
-
-#[cfg(feature = "honggfuzz_fuzz")]
-#[macro_use]
-extern crate honggfuzz;
-#[cfg(feature = "honggfuzz_fuzz")]
-fn main() {
-    loop {
-        fuzz!(|data| { do_test(data) });
+        assert_chain(&chain);
     }
 }
 
-#[cfg(feature = "libfuzzer_fuzz")]
-#[macro_use]
-extern crate libfuzzer_sys;
-#[cfg(feature = "libfuzzer_fuzz")]
-fuzz_target!(|data: &[u8]| do_test(data));
-
-/// Replays corpus files passed as arguments. Used for coverage reports and
-/// reproducing crashes without a fuzzer attached.
-#[cfg(not(any(
-    feature = "afl_fuzz",
-    feature = "honggfuzz_fuzz",
-    feature = "libfuzzer_fuzz"
-)))]
-fn main() {
-    for path in std::env::args().skip(1) {
-        let data = std::fs::read(&path).unwrap_or_else(|e| panic!("failed to read {path}: {e}"));
-        do_test(&data);
-    }
-}
+bdk_chain_fuzz::fuzz_main!(do_test);