[storage/fuzz] generalize fuzz tests on merkle family (#3646)

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: roberto-bayardo

storage/fuzz/fuzz_targets/current_crash_recovery.rs

@@ -15,7 +15,7 @@ use commonware_runtime::{
 };
 use commonware_storage::{
     journal::contiguous::variable::Config as VConfig,
-    mmr::{self, journaled::Config as MmrConfig, Location},
+    merkle::{journaled::Config as MerkleConfig, mmb, mmr, Graftable, Location},
     qmdb::current::{unordered::variable::Db as Current, VariableConfig},
     translator::TwoCap,
 };
@@ -34,7 +34,7 @@ type RawValue = [u8; 32];
 /// Maximum write buffer size.
 const MAX_WRITE_BUF: usize = 2048;
 
-type Db = Current<mmr::Family, deterministic::Context, Key, Value, Sha256, TwoCap, 32>;
+type Db<F> = Current<F, deterministic::Context, Key, Value, Sha256, TwoCap, 32>;
 
 fn bounded_page_size(u: &mut Unstructured<'_>) -> Result<u16> {
     u.int_in_range(1..=256)
@@ -75,7 +75,7 @@ struct FuzzInput {
     #[arbitrary(with = bounded_page_cache_size)]
     page_cache_size: usize,
     #[arbitrary(with = bounded_items_per_blob)]
-    mmr_items_per_blob: u64,
+    merkle_items_per_blob: u64,
     #[arbitrary(with = bounded_items_per_blob)]
     log_items_per_blob: u64,
     #[arbitrary(with = bounded_write_buffer)]
@@ -92,16 +92,16 @@ fn make_config(
     suffix: &str,
     page_size: NonZeroU16,
     page_cache_size: NonZeroUsize,
-    mmr_items_per_blob: u64,
+    merkle_items_per_blob: u64,
     log_items_per_blob: u64,
     write_buffer: NonZeroUsize,
 ) -> VariableConfig<TwoCap, ((), ())> {
     let page_cache = CacheRef::from_pooler(ctx, page_size, page_cache_size);
     VariableConfig {
-        merkle_config: MmrConfig {
-            journal_partition: format!("crash-mmr-journal-{suffix}"),
-            metadata_partition: format!("crash-mmr-metadata-{suffix}"),
-            items_per_blob: NZU64!(mmr_items_per_blob),
+        merkle_config: MerkleConfig {
+            journal_partition: format!("crash-merkle-journal-{suffix}"),
+            metadata_partition: format!("crash-merkle-metadata-{suffix}"),
+            items_per_blob: NZU64!(merkle_items_per_blob),
             write_buffer,
             thread_pool: None,
             page_cache: page_cache.clone(),
@@ -114,7 +114,7 @@ fn make_config(
             codec_config: ((), ()),
             page_cache,
         },
-        grafted_metadata_partition: format!("crash-grafted-mmr-metadata-{suffix}"),
+        grafted_metadata_partition: format!("crash-grafted-merkle-metadata-{suffix}"),
         translator: TwoCap,
     }
 }
@@ -147,8 +147,8 @@ fn apply_pending(
 }
 
 /// Commit pending writes. Returns `true` on success, `false` on error.
-async fn commit_pending(
-    db: &mut Db,
+async fn commit_pending<F: Graftable>(
+    db: &mut Db<F>,
     pending_writes: &mut Vec<(Key, Option<Value>)>,
     pending: &mut HashMap<RawKey, Option<RawValue>>,
     committed: &mut HashMap<RawKey, RawValue>,
@@ -177,20 +177,20 @@ async fn commit_pending(
     true
 }
 
-fn fuzz(input: FuzzInput) {
+fn fuzz_family<F: Graftable>(input: &FuzzInput, suffix_base: &str) {
     if input.operations.is_empty() {
         return;
     }
 
     let page_size = NonZeroU16::new(input.page_size).unwrap();
     let page_cache_size = NonZeroUsize::new(input.page_cache_size).unwrap();
-    let mmr_items_per_blob = input.mmr_items_per_blob;
+    let merkle_items_per_blob = input.merkle_items_per_blob;
     let log_items_per_blob = input.log_items_per_blob;
     let write_buffer = NonZeroUsize::new(input.write_buffer).unwrap();
     let sync_failure_rate = input.sync_failure_rate;
     let write_failure_rate = input.write_failure_rate;
-    let operations = input.operations;
-    let suffix = format!("current_{}", input.seed);
+    let operations = input.operations.clone();
+    let suffix = format!("{suffix_base}_{}", input.seed);
 
     let cfg = deterministic::Config::default().with_seed(input.seed);
     let runner = deterministic::Runner::new(cfg);
@@ -201,14 +201,14 @@ fn fuzz(input: FuzzInput) {
         let suffix = suffix.clone();
         let operations = operations.clone();
         async move {
-            let mut db = Db::init(
+            let mut db: Db<F> = Db::init(
                 ctx.with_label("db"),
                 make_config(
                     &ctx,
                     &suffix,
                     page_size,
                     page_cache_size,
-                    mmr_items_per_blob,
+                    merkle_items_per_blob,
                     log_items_per_blob,
                     write_buffer,
                 ),
@@ -283,14 +283,14 @@ fn fuzz(input: FuzzInput) {
         async move {
             *ctx.storage_fault_config().write() = deterministic::FaultConfig::default();
 
-            let mut db = Db::init(
+            let mut db: Db<F> = Db::init(
                 ctx.with_label("recovered"),
                 make_config(
                     &ctx,
                     &suffix,
                     page_size,
                     page_cache_size,
-                    mmr_items_per_blob,
+                    merkle_items_per_blob,
                     log_items_per_blob,
                     write_buffer,
                 ),
@@ -318,7 +318,7 @@ fn fuzz(input: FuzzInput) {
                     .await
                     .expect("proof generation should not fail for committed key");
                 assert!(
-                    Db::verify_key_value_proof(&mut hasher, k, v, &proof, &root),
+                    Db::<F>::verify_key_value_proof(&mut hasher, k, v, &proof, &root),
                     "key value proof failed to verify after crash recovery"
                 );
             }
@@ -327,13 +327,13 @@ fn fuzz(input: FuzzInput) {
             let floor = *db.sync_boundary();
             let size = *db.bounds().await.end;
             for i in floor..size {
-                let loc = Location::new(i);
+                let loc = Location::<F>::new(i);
                 let (proof, ops, chunks) = db
                     .range_proof(&mut hasher, loc, NZU64!(4))
                     .await
                     .expect("range proof should not fail after recovery");
                 assert!(
-                    Db::verify_range_proof(&mut hasher, &proof, loc, &ops, &chunks, &root),
+                    Db::<F>::verify_range_proof(&mut hasher, &proof, loc, &ops, &chunks, &root),
                     "range proof failed to verify after crash recovery at loc {loc}"
                 );
             }
@@ -362,5 +362,6 @@ fn fuzz(input: FuzzInput) {
 }
 
 fuzz_target!(|input: FuzzInput| {
-    fuzz(input);
+    fuzz_family::<mmr::Family>(&input, "current-crash-mmr");
+    fuzz_family::<mmb::Family>(&input, "current-crash-mmb");
 });

storage/fuzz/fuzz_targets/current_ordered_operations.rs

@@ -5,7 +5,7 @@ use commonware_cryptography::{sha256::Digest, Hasher, Sha256};
 use commonware_runtime::{buffer::paged::CacheRef, deterministic, Runner};
 use commonware_storage::{
     journal::contiguous::fixed::Config as FConfig,
-    mmr::{self, journaled::Config as MmrConfig, Location},
+    merkle::{journaled::Config as MerkleConfig, mmb, mmr, Graftable, Location},
     qmdb::current::{ordered::fixed::Db as CurrentDb, FixedConfig as Config},
     translator::TwoCap,
 };
@@ -20,7 +20,7 @@ type Key = FixedBytes<32>;
 type Value = FixedBytes<32>;
 type RawKey = [u8; 32];
 type RawValue = [u8; 32];
-type Db = CurrentDb<mmr::Family, deterministic::Context, Key, Value, Sha256, TwoCap, 32>;
+type Db<F> = CurrentDb<F, deterministic::Context, Key, Value, Sha256, TwoCap, 32>;
 
 #[derive(Arbitrary, Debug, Clone)]
 enum CurrentOperation {
@@ -78,12 +78,12 @@ impl<'a> Arbitrary<'a> for FuzzInput {
 
 const PAGE_SIZE: NonZeroU16 = NZU16!(91);
 const PAGE_CACHE_SIZE: usize = 8;
-const MMR_ITEMS_PER_BLOB: u64 = 11;
+const MERKLE_ITEMS_PER_BLOB: u64 = 11;
 const LOG_ITEMS_PER_BLOB: u64 = 7;
 const WRITE_BUFFER_SIZE: usize = 1024;
 
-async fn commit_pending(
-    db: &mut Db,
+async fn commit_pending<F: Graftable>(
+    db: &mut Db<F>,
     pending_writes: &mut Vec<(Key, Option<Value>)>,
     committed_state: &mut HashMap<RawKey, RawValue>,
     pending_inserts: &mut HashMap<RawKey, RawValue>,
@@ -104,9 +104,11 @@ async fn commit_pending(
     committed_state.extend(pending_inserts.drain());
 }
 
-fn fuzz(data: FuzzInput) {
+fn fuzz_family<F: Graftable>(data: &FuzzInput, suffix: &str) {
     let runner = deterministic::Runner::default();
 
+    let suffix = suffix.to_string();
+    let operations = data.operations.clone();
     runner.start(|context| async move {
         let mut hasher = Sha256::new();
         let page_cache = CacheRef::from_pooler(
@@ -115,25 +117,25 @@ fn fuzz(data: FuzzInput) {
             NZUsize!(PAGE_CACHE_SIZE),
         );
         let cfg = Config {
-            merkle_config: MmrConfig {
-                journal_partition: "fuzz-current-mmr-journal".into(),
-                metadata_partition: "fuzz-current-mmr-metadata".into(),
-                items_per_blob: NZU64!(MMR_ITEMS_PER_BLOB),
+            merkle_config: MerkleConfig {
+                journal_partition: format!("fuzz-current-ord-{suffix}-merkle-journal"),
+                metadata_partition: format!("fuzz-current-ord-{suffix}-merkle-metadata"),
+                items_per_blob: NZU64!(MERKLE_ITEMS_PER_BLOB),
                 write_buffer: NZUsize!(WRITE_BUFFER_SIZE),
                 thread_pool: None,
                 page_cache: page_cache.clone(),
             },
             journal_config: FConfig {
-                partition: "fuzz-current-log-journal".into(),
+                partition: format!("fuzz-current-ord-{suffix}-log-journal"),
                 items_per_blob: NZU64!(LOG_ITEMS_PER_BLOB),
                 write_buffer: NZUsize!(WRITE_BUFFER_SIZE),
                 page_cache,
             },
-            grafted_metadata_partition: "fuzz-current-grafted-mmr-metadata".into(),
+            grafted_metadata_partition: format!("fuzz-current-ord-{suffix}-grafted-merkle-metadata"),
             translator: TwoCap,
         };
 
-        let mut db = Db::init(context.clone(), cfg)
+        let mut db: Db<F> = Db::init(context.clone(), cfg)
             .await
             .expect("Failed to initialize Current database");
 
@@ -144,9 +146,9 @@ fn fuzz(data: FuzzInput) {
         let mut pending_deletes: HashSet<RawKey> = HashSet::new();
         let mut all_keys = HashSet::new();
         let mut pending_writes: Vec<(Key, Option<Value>)> = Vec::new();
-        let mut committed_op_count = Location::new(1);
+        let mut committed_op_count = Location::<F>::new(1);
 
-        for op in &data.operations {
+        for op in &operations {
             match op {
                 CurrentOperation::Update { key, value } => {
                     let k = Key::new(*key);
@@ -241,7 +243,7 @@ fn fuzz(data: FuzzInput) {
                     let current_root = db.root();
 
                     let current_op_count = db.bounds().await.end;
-                    let start_loc = Location::new(start_loc % *current_op_count);
+                    let start_loc = Location::<F>::new(start_loc % *current_op_count);
 
                     let oldest_loc = db.sync_boundary();
                     if start_loc >= oldest_loc {
@@ -251,7 +253,7 @@ fn fuzz(data: FuzzInput) {
                             .expect("Range proof should not fail");
 
                         assert!(
-                            Db::verify_range_proof(
+                            Db::<F>::verify_range_proof(
                                 &mut hasher,
                                 &proof,
                                 start_loc,
@@ -276,7 +278,7 @@ fn fuzz(data: FuzzInput) {
                     committed_op_count = db.bounds().await.end;
 
                     let current_op_count = db.bounds().await.end;
-                    let start_loc = Location::new(start_loc % current_op_count.as_u64());
+                    let start_loc = Location::<F>::new(start_loc % current_op_count.as_u64());
                     let root = db.root();
 
                     if let Ok((range_proof, ops, chunks)) = db
@@ -287,7 +289,7 @@ fn fuzz(data: FuzzInput) {
                         if range_proof.proof.digests != bad_digests {
                             let mut bad_proof = range_proof.clone();
                             bad_proof.proof.digests = bad_digests;
-                            assert!(!Db::verify_range_proof(
+                            assert!(!Db::<F>::verify_range_proof(
                                 &mut hasher,
                                 &bad_proof,
                                 start_loc,
@@ -299,7 +301,7 @@ fn fuzz(data: FuzzInput) {
 
                         // Try to verify the proof when providing bad input chunks.
                         if &chunks != bad_chunks {
-                            assert!(!Db::verify_range_proof(
+                            assert!(!Db::<F>::verify_range_proof(
                                 &mut hasher,
                                 &range_proof,
                                 start_loc,
@@ -324,7 +326,7 @@ fn fuzz(data: FuzzInput) {
                     match db.key_value_proof(&mut hasher, k.clone()).await {
                         Ok(proof) => {
                             let value = db.get(&k).await.expect("get should not fail").expect("key should exist");
-                            let verification_result = Db::verify_key_value_proof(
+                            let verification_result = Db::<F>::verify_key_value_proof(
                                 &mut hasher,
                                 k,
                                 value,
@@ -354,7 +356,7 @@ fn fuzz(data: FuzzInput) {
 
                     match db.exclusion_proof(&mut hasher, &k).await {
                         Ok(proof) => {
-                            let verification_result = Db::verify_exclusion_proof(
+                            let verification_result = Db::<F>::verify_exclusion_proof(
                                 &mut hasher,
                                 &k,
                                 &proof,
@@ -404,5 +406,6 @@ fn fuzz(data: FuzzInput) {
 }
 
 fuzz_target!(|input: FuzzInput| {
-    fuzz(input);
+    fuzz_family::<mmr::Family>(&input, "mmr");
+    fuzz_family::<mmb::Family>(&input, "mmb");
 });

storage/fuzz/fuzz_targets/current_unordered_batch_root.rs

@@ -5,7 +5,7 @@ use commonware_cryptography::Sha256;
 use commonware_runtime::{buffer::paged::CacheRef, deterministic, BufferPooler, Runner};
 use commonware_storage::{
     journal::contiguous::fixed::Config as FConfig,
-    mmr::{self, journaled::Config as MmrConfig},
+    merkle::{journaled::Config as MerkleConfig, mmb, mmr, Graftable},
     qmdb::current::{unordered::fixed::Db as CurrentDb, FixedConfig as Config},
     translator::OneCap,
 };
@@ -15,7 +15,7 @@ use std::num::NonZeroU16;
 
 type Key = FixedBytes<32>;
 type Value = FixedBytes<32>;
-type Db = CurrentDb<mmr::Family, deterministic::Context, Key, Value, Sha256, OneCap, 32>;
+type Db<F> = CurrentDb<F, deterministic::Context, Key, Value, Sha256, OneCap, 32>;
 
 const PAGE_SIZE: NonZeroU16 = NZU16!(137);
 const COLLISION_GROUPS: u8 = 4;
@@ -76,8 +76,8 @@ impl<'a> Arbitrary<'a> for FuzzInput {
 fn test_config(name: &str, pooler: &impl BufferPooler) -> Config<OneCap> {
     let page_cache = CacheRef::from_pooler(pooler, PAGE_SIZE, NZUsize!(2));
     Config {
-        merkle_config: MmrConfig {
-            journal_partition: format!("{name}-mmr"),
+        merkle_config: MerkleConfig {
+            journal_partition: format!("{name}-merkle"),
             metadata_partition: format!("{name}-meta"),
             items_per_blob: NZU64!(17),
             write_buffer: NZUsize!(1024),
@@ -107,12 +107,13 @@ fn value_from_bytes(bytes: [u8; 32]) -> Value {
     Value::new(bytes)
 }
 
-fn fuzz(input: FuzzInput) {
+fn fuzz_family<F: Graftable>(input: &FuzzInput, test_name: &str) {
     let runner = deterministic::Runner::default();
 
+    let test_name = test_name.to_string();
     runner.start(|context| async move {
-        let cfg = test_config("fuzz-current-unordered-pending-vs-committed-root", &context);
-        let mut db = Db::init(context.clone(), cfg)
+        let cfg = test_config(&test_name, &context);
+        let mut db: Db<F> = Db::init(context.clone(), cfg)
             .await
             .expect("init current unordered db");
 
@@ -196,5 +197,6 @@ fn fuzz(input: FuzzInput) {
 }
 
 fuzz_target!(|input: FuzzInput| {
-    fuzz(input);
+    fuzz_family::<mmr::Family>(&input, "fuzz-mmr-current-unordered-batch-root");
+    fuzz_family::<mmb::Family>(&input, "fuzz-mmb-current-unordered-batch-root");
 });