unify hasher construction for qmdb

Author: roberto-bayardo

storage/src/qmdb/any/mod.rs

@@ -179,7 +179,10 @@ pub(crate) mod test {
     use super::*;
     use crate::{
         journal::contiguous::{fixed::Config as FConfig, variable::Config as VConfig},
-        qmdb::any::{FixedConfig, MerkleConfig, VariableConfig},
+        qmdb::{
+            self,
+            any::{FixedConfig, MerkleConfig, VariableConfig},
+        },
         translator::OneCap,
     };
     use commonware_codec::{Codec, CodecShared};
@@ -258,7 +261,7 @@ pub(crate) mod test {
     use crate::{
         index::Unordered as UnorderedIndex,
         journal::contiguous::Mutable,
-        merkle::{self, mmr},
+        merkle::mmr,
         qmdb::any::{
             db::Db as AnyDb,
             operation::{update::Update as UpdateTrait, Operation as AnyOperation},
@@ -627,7 +630,7 @@ pub(crate) mod test {
         V: CodecShared + Clone + Eq + std::hash::Hash + std::fmt::Debug,
         <D as Provable<mmr::Family>>::Operation: Codec,
     {
-        use crate::{mmr::StandardHasher, qmdb::verify_proof};
+        use crate::qmdb::verify_proof;
 
         const ELEMENTS: u64 = 1000;
 
@@ -689,7 +692,7 @@ pub(crate) mod test {
             }
         }
 
-        let hasher = StandardHasher::<Sha256>::with_bagging(merkle::Bagging::BackwardFold);
+        let hasher = qmdb::hasher::<Sha256>();
         let bounds = db.bounds().await;
         let inactivity_floor = db.inactivity_floor_loc().await;
         for loc in *inactivity_floor..*bounds.end {
@@ -749,7 +752,7 @@ pub(crate) mod test {
         D: DbAny<mmr::Family, Key = Digest, Value = V, Digest = Digest> + Provable<mmr::Family>,
         <D as Provable<mmr::Family>>::Operation: Codec + PartialEq + std::fmt::Debug,
     {
-        use crate::{mmr::StandardHasher, qmdb::verify_proof};
+        use crate::qmdb::verify_proof;
         use commonware_utils::NZU64;
 
         // Add some operations
@@ -779,7 +782,7 @@ pub(crate) mod test {
         assert_eq!(historical_proof.leaves, regular_proof.leaves);
         assert_eq!(historical_proof.digests, regular_proof.digests);
         assert_eq!(historical_ops, regular_ops);
-        let hasher = StandardHasher::<Sha256>::with_bagging(merkle::Bagging::BackwardFold);
+        let hasher = qmdb::hasher::<Sha256>();
         assert!(verify_proof(
             &hasher,
             &historical_proof,
@@ -828,7 +831,7 @@ pub(crate) mod test {
         D: DbAny<mmr::Family, Key = Digest, Value = V, Digest = Digest> + Provable<mmr::Family>,
         <D as Provable<mmr::Family>>::Operation: Codec + PartialEq + std::fmt::Debug + Clone,
     {
-        use crate::{mmr::StandardHasher, qmdb::verify_proof};
+        use crate::qmdb::verify_proof;
         use commonware_utils::NZU64;
 
         // Apply two single-write batches and capture the commit-boundary size after the
@@ -858,7 +861,7 @@ pub(crate) mod test {
         assert_eq!(proof.leaves, historical_op_count);
         assert_eq!(ops.len(), expected_ops_len);
 
-        let hasher = StandardHasher::<Sha256>::with_bagging(merkle::Bagging::BackwardFold);
+        let hasher = qmdb::hasher::<Sha256>();
 
         // Changing the proof digests should cause verification to fail
         {

storage/src/qmdb/any/ordered/fixed.rs

@@ -126,11 +126,11 @@ pub(crate) mod test {
     use crate::{
         index::Unordered as _,
         merkle::{
-            self,
-            mmr::{self, Location, StandardHasher as Standard},
+            mmr::{self, Location},
             Location as GenericLocation,
         },
         qmdb::{
+            self,
             any::{
                 ordered::{
                     test::{
@@ -367,7 +367,7 @@ pub(crate) mod test {
         // confirm that the end state of the db matches that of an identically updated hashmap.
         const ELEMENTS: u64 = 1000;
         executor.start(|context| async move {
-            let hasher = Standard::<Sha256>::with_bagging(merkle::Bagging::BackwardFold);
+            let hasher = qmdb::hasher::<Sha256>();
             let mut db = open_db(context.with_label("first")).await;
 
             let mut map = HashMap::<Digest, Digest>::default();
@@ -676,7 +676,7 @@ pub(crate) mod test {
             let mut db = create_test_db(context.clone()).await;
             let ops = create_test_ops(20);
             apply_ops(&mut db, ops.clone()).await;
-            let hasher = Standard::<Sha256>::with_bagging(merkle::Bagging::BackwardFold);
+            let hasher = qmdb::hasher::<Sha256>();
             let root_hash = db.root();
             let original_op_count = db.bounds().await.end;
 
@@ -730,7 +730,7 @@ pub(crate) mod test {
     fn test_ordered_any_fixed_db_historical_proof_edge_cases() {
         let executor = deterministic::Runner::default();
         executor.start(|context| async move {
-            let hasher = Standard::<Sha256>::with_bagging(merkle::Bagging::BackwardFold);
+            let hasher = qmdb::hasher::<Sha256>();
 
             let mut db = create_test_db(context.with_label("first")).await;
             // Apply ops in multiple batches; each apply_ops ends in a commit, so the size
@@ -801,7 +801,7 @@ pub(crate) mod test {
             let ops = create_test_ops(100);
             apply_ops(&mut db, ops.clone()).await;
 
-            let hasher = Standard::<Sha256>::with_bagging(merkle::Bagging::BackwardFold);
+            let hasher = qmdb::hasher::<Sha256>();
             let root = db.root();
 
             let start_loc = Location::new(20);

storage/src/qmdb/any/sync/mod.rs

@@ -2,16 +2,15 @@
 //! Contains implementation of [crate::qmdb::sync::Database] for all [Db] variants
 //! (ordered/unordered, fixed/variable).
 //!
-//! Callers verifying `any` sync proofs directly should use the same Merkle hasher configuration as
-//! the sync engine.
+//! Callers verifying `any` sync proofs directly should use `qmdb::hasher`.
 
 use crate::{
     index::Factory as IndexFactory,
     journal::{
         authenticated,
         contiguous::{fixed, variable, Mutable, Reader as _},
     },
-    merkle::{self, full, hasher::Standard as StandardHasher, Location},
+    merkle::{self, full, Location},
     qmdb::{
         self,
         any::{
@@ -64,15 +63,14 @@ pub async fn has_local_target_state<F, E, H, S>(
     merkle_config: full::Config<S>,
     target: &qmdb::sync::Target<F, H::Digest>,
     inactive_peaks: usize,
-    bagging: merkle::Bagging,
 ) -> bool
 where
     F: merkle::Family,
     E: Context,
     H: Hasher,
     S: Strategy,
 {
-    let hasher = StandardHasher::<H>::with_bagging(bagging);
+    let hasher = qmdb::hasher::<H>();
     let peek = full::Merkle::<F, _, _, S>::peek_root(
         context.with_label("local_target_probe"),
         merkle_config,
@@ -111,7 +109,7 @@ where
     S: Strategy,
     Operation<F, U>: Codec + Committable + CodecShared,
 {
-    let hasher = merkle::hasher::Standard::<H>::with_bagging(merkle::Bagging::BackwardFold);
+    let hasher = qmdb::hasher::<H>();
 
     let merkle = full::Merkle::<F, _, _, S>::init_sync(
         context.with_label("merkle"),
@@ -209,7 +207,6 @@ macro_rules! impl_sync_database {
                     config.merkle_config.clone(),
                     target,
                     inactive_peaks,
-                    merkle::Bagging::BackwardFold,
                 )
                 .await
             }

storage/src/qmdb/any/unordered/fixed.rs

@@ -123,11 +123,11 @@ pub(crate) mod test {
     use crate::{
         index::Unordered as _,
         merkle::{
-            self,
-            mmr::{self, Location, StandardHasher},
+            mmr::{self, Location},
             Location as GenericLocation,
         },
         qmdb::{
+            self,
             any::{
                 test::fixed_db_config,
                 unordered::{fixed::Operation, Update},
@@ -592,7 +592,7 @@ pub(crate) mod test {
             assert_eq!(historical_proof.leaves, regular_proof.leaves);
             assert_eq!(historical_proof.digests, regular_proof.digests);
             assert_eq!(historical_ops, regular_ops);
-            let hasher = StandardHasher::<Sha256>::with_bagging(merkle::Bagging::BackwardFold);
+            let hasher = qmdb::hasher::<Sha256>();
             assert!(verify_proof(
                 &hasher,
                 &historical_proof,
@@ -640,7 +640,7 @@ pub(crate) mod test {
     fn test_any_fixed_db_historical_proof_edge_cases() {
         let executor = deterministic::Runner::default();
         executor.start(|context| async move {
-            let hasher = StandardHasher::<Sha256>::with_bagging(merkle::Bagging::BackwardFold);
+            let hasher = qmdb::hasher::<Sha256>();
 
             let mut db = create_test_db(context.with_label("first")).await;
             // Apply ops in multiple batches; each apply_ops ends in a commit, so the size
@@ -708,7 +708,7 @@ pub(crate) mod test {
         let executor = deterministic::Runner::default();
         executor.start(|context| async move {
             let ops = create_test_ops(100);
-            let hasher = StandardHasher::<Sha256>::with_bagging(merkle::Bagging::BackwardFold);
+            let hasher = qmdb::hasher::<Sha256>();
             let start_loc = Location::new(2);
             let max_ops = NZU64!(10);
 

storage/src/qmdb/compact_witness.rs

@@ -23,9 +23,9 @@
 //!    its proof on every serve.
 
 use crate::{
-    merkle::{self, compact, Family, Location, Proof},
+    merkle::{compact, Family, Location, Proof},
     metadata::Metadata,
-    qmdb::{sync::compact::Target, Error},
+    qmdb::{self, sync::compact::Target, Error},
     Context,
 };
 use commonware_codec::{Decode as _, Encode as _, FixedSize};
@@ -236,7 +236,7 @@ where
 
     let inactive_peaks =
         F::inactive_peaks(F::location_to_position(leaf_count), inactivity_floor_loc);
-    let hasher = merkle::hasher::Standard::<H>::with_bagging(merkle::Bagging::BackwardFold);
+    let hasher = qmdb::hasher::<H>();
     let root = merkle
         .root(&hasher, inactive_peaks)
         .map_err(|_| Error::DataCorrupted("failed to compute compact witness root"))?;
@@ -279,7 +279,7 @@ where
     H: Hasher,
     S: Strategy,
 {
-    let hasher = merkle::hasher::Standard::<H>::with_bagging(merkle::Bagging::BackwardFold);
+    let hasher = qmdb::hasher::<H>();
     let batch = {
         let batch = merkle.new_batch().add(&hasher, &commit_op_bytes);
         merkle.with_mem(|mem| batch.merkleize(mem, &hasher))
@@ -360,7 +360,7 @@ where
     H: Hasher,
     S: Strategy,
 {
-    let hasher = merkle::hasher::Standard::<H>::with_bagging(merkle::Bagging::BackwardFold);
+    let hasher = qmdb::hasher::<H>();
     let last_commit_loc = source.last_commit_loc();
     let inactivity_floor_loc = source.inactivity_floor_loc();
     let commit_op_bytes = source.encode_current_commit_op();

storage/src/qmdb/current/batch.rs

@@ -6,11 +6,11 @@ use crate::{
     index::Unordered as UnorderedIndex,
     journal::contiguous::{Contiguous, Mutable},
     merkle::{
-        self, batch::MerkleizedBatch as GenericMerkleizedBatch, hasher::Standard as StandardHasher,
-        mem::Mem, storage::Storage as MerkleStorage, Bagging, Graftable, Location, Position,
-        Readable,
+        self, batch::MerkleizedBatch as GenericMerkleizedBatch, mem::Mem,
+        storage::Storage as MerkleStorage, Graftable, Location, Position, Readable,
     },
     qmdb::{
+        self,
         any::{
             self,
             batch::{lookup_sorted, DiffEntry},
@@ -610,7 +610,7 @@ where
         (idx, chunk)
     });
 
-    let hasher = StandardHasher::<H>::with_bagging(Bagging::BackwardFold);
+    let hasher = qmdb::hasher::<H>();
     let new_leaves = compute_grafted_leaves::<F, H, S, N>(
         &hasher,
         &ops_tree_adapter,

storage/src/qmdb/current/db.rs

@@ -10,10 +10,11 @@ use crate::{
     },
     merkle::{
         self, hasher::Standard as StandardHasher, mem::Mem, storage::Storage as MerkleStorage,
-        Bagging, Location, Position,
+        Location, Position,
     },
     metadata::{Config as MConfig, Metadata},
     qmdb::{
+        self,
         any::{
             self,
             operation::{update::Update, Operation},
@@ -153,7 +154,7 @@ where
             &self.grafted_tree,
             grafting::height::<N>(),
             &self.any.log.merkle,
-            StandardHasher::<H>::with_bagging(Bagging::BackwardFold),
+            qmdb::hasher::<H>(),
         )
     }
 
@@ -291,7 +292,7 @@ where
     /// Unlike [`range_proof`](Self::range_proof) which returns grafted proofs incorporating the
     /// activity bitmap, this returns ops-tree Merkle proofs suitable for state sync. Direct
     /// verifiers should use the same Merkle hasher configuration as QMDB sync:
-    /// [`Bagging::BackwardFold`].
+    /// [`crate::merkle::Bagging::BackwardFold`].
     pub async fn ops_historical_proof(
         &self,
         historical_size: Location<F>,
@@ -562,7 +563,7 @@ where
         // the caller; reads through them now return inconsistent data.
         self.any.rewind(size).await?;
 
-        let hasher = StandardHasher::<H>::with_bagging(Bagging::BackwardFold);
+        let hasher = qmdb::hasher::<H>();
         let grafted_tree = build_grafted_tree::<F, H, S, N>(
             &hasher,
             self.any.bitmap.as_ref(),
@@ -1164,7 +1165,7 @@ mod tests {
                 next_idx += 1;
             }
 
-            let mut hasher = StandardHasher::<Sha256>::with_bagging(Bagging::BackwardFold);
+            let mut hasher = qmdb::hasher::<Sha256>();
             let witness = db.ops_root_witness(&mut hasher).await.unwrap();
             let ops_root = db.ops_root();
             let canonical_root = db.root();
@@ -1196,7 +1197,7 @@ mod tests {
             .unwrap();
             populate_fixed_db::<mmb::Family, _>(&mut db, 0, 260).await;
 
-            let mut hasher = StandardHasher::<Sha256>::with_bagging(merkle::Bagging::BackwardFold);
+            let mut hasher = qmdb::hasher::<Sha256>();
             let witness = db.ops_root_witness(&mut hasher).await.unwrap();
             let ops_root = db.ops_root();
             let canonical_root = db.root();
@@ -1245,7 +1246,7 @@ mod tests {
                 "test requires at least one pruned chunk to exercise the zero-chunk path"
             );
 
-            let mut hasher = StandardHasher::<Sha256>::with_bagging(Bagging::BackwardFold);
+            let mut hasher = qmdb::hasher::<Sha256>();
             let witness = db.ops_root_witness(&mut hasher).await.unwrap();
             let ops_root = db.ops_root();
             let canonical_root = db.root();
@@ -1272,7 +1273,7 @@ mod tests {
             .await
             .unwrap();
 
-            let mut hasher = StandardHasher::<Sha256>::with_bagging(Bagging::BackwardFold);
+            let mut hasher = qmdb::hasher::<Sha256>();
             let witness = db.ops_root_witness(&mut hasher).await.unwrap();
             let ops_root = db.ops_root();
             let canonical_root = db.root();