commonwarexyz · patrick-ogrady · Jul 21, 2025 · Jul 16, 2025 · Jul 16, 2025 · Jul 16, 2025
diff --git a/examples/sync/src/bin/client.rs b/examples/sync/src/bin/client.rs
@@ -34,7 +34,7 @@ struct Config {
 
 #[derive(Debug)]
 struct ServerMetadata {
-    target_hash: Digest,
+    root: Digest,
     oldest_retained_loc: u64,
     latest_op_loc: u64,
 }
@@ -50,7 +50,7 @@ where
 
     let metadata = resolver.get_server_metadata().await?;
     let metadata = ServerMetadata {
-        target_hash: metadata.target_hash,
+        root: metadata.root,
         oldest_retained_loc: metadata.oldest_retained_loc,
         latest_op_loc: metadata.latest_op_loc,
     };
@@ -74,7 +74,7 @@ where
 
     // Get server metadata to determine sync parameters
     let ServerMetadata {
-        target_hash,
+        root,
         oldest_retained_loc,
         latest_op_loc,
     } = get_server_metadata(&resolver).await?;
@@ -102,7 +102,7 @@ where
         db_config,
         fetch_batch_size: NonZeroU64::new(config.batch_size).unwrap(),
         target: SyncTarget {
-            hash: target_hash,
+            root,
             lower_bound_ops: oldest_retained_loc,
             upper_bound_ops: latest_op_loc,
         },
@@ -123,23 +123,26 @@ where
     info!("Beginning sync operation...");
     let database = sync::sync(sync_config).await?;
 
-    // Get the root hash of the synced database
+    // Get the root digest of the synced database
     let mut hasher = Standard::new();
-    let root_hash = database.root(&mut hasher);
+    let got_root = database.root(&mut hasher);
 
-    // Verify the hash matches the  target hash.
-    if root_hash != target_hash {
-        return Err(format!("Synced database root hash does not match target hash: {root_hash:?} != {target_hash:?}").into());
+    // Verify the digest matches the  target digest.
+    if got_root != root {
+        return Err(format!(
+            "Synced database root digest does not match target root digest: {got_root:?} != {root:?}"
+        )
+        .into());
     }
 
-    let root_hash_hex = root_hash
+    let root_hex = got_root
         .as_ref()
         .iter()
         .map(|b| format!("{b:02x}"))
         .collect::<String>();
     info!(
         database_ops = database.op_count(),
-        root_hash = %root_hash_hex,
+        root = %root_hex,
         "✅ Sync completed successfully"
     );
 

diff --git a/examples/sync/src/bin/server.rs b/examples/sync/src/bin/server.rs
@@ -109,15 +109,15 @@ where
     let oldest_retained_loc = database.oldest_retained_loc().unwrap_or(0);
     let latest_op_loc = database.op_count().saturating_sub(1);
 
-    let target_hash = {
+    let root = {
         let mut hasher = Standard::new();
         database.root(&mut hasher)
     };
 
     drop(database);
 
     let response = GetServerMetadataResponse {
-        target_hash,
+        root,
         oldest_retained_loc,
         latest_op_loc,
     };
@@ -399,16 +399,16 @@ fn main() {
 
         // Display database state
         let mut hasher = Standard::new();
-        let root_hash = database.root(&mut hasher);
-        let root_hash_hex = root_hash
+        let root = database.root(&mut hasher);
+        let root_hex = root
             .as_ref()
             .iter()
             .map(|b| format!("{b:02x}"))
             .collect::<String>();
 
         info!(
             op_count = database.op_count(),
-            root_hash = %root_hash_hex,
+            root = %root_hex,
             "Database ready"
         );
 

diff --git a/examples/sync/src/protocol.rs b/examples/sync/src/protocol.rs
@@ -5,7 +5,7 @@
 //! logic for safe network communication.
 //!
 //! The protocol supports:
-//! - Getting server metadata (database size, target hash, operation bounds)
+//! - Getting server metadata (database size, root digest, operation bounds)
 //! - Fetching operations with cryptographic proofs
 //! - Error handling
 
@@ -32,7 +32,7 @@ pub enum Message {
     GetOperationsRequest(GetOperationsRequest),
     /// Response with operations and proof.
     GetOperationsResponse(GetOperationsResponse),
-    /// Request server metadata (target hash, bounds, etc.).
+    /// Request server metadata (target root digest, bounds, etc.).
     GetServerMetadataRequest,
     /// Response with server metadata.
     GetServerMetadataResponse(GetServerMetadataResponse),
@@ -67,8 +67,8 @@ pub struct GetOperationsResponse {
 /// Response with server metadata.
 #[derive(Debug, Clone)]
 pub struct GetServerMetadataResponse {
-    /// Target hash of the database.
-    pub target_hash: Digest,
+    /// Target root digest of the database.
+    pub root: Digest,
     /// Oldest retained operation location.
     pub oldest_retained_loc: u64,
     /// Latest operation location.
@@ -233,15 +233,15 @@ impl Read for GetOperationsResponse {
 
 impl Write for GetServerMetadataResponse {
     fn write(&self, buf: &mut impl BufMut) {
-        self.target_hash.write(buf);
+        self.root.write(buf);
         self.oldest_retained_loc.write(buf);
         self.latest_op_loc.write(buf);
     }
 }
 
 impl EncodeSize for GetServerMetadataResponse {
     fn encode_size(&self) -> usize {
-        self.target_hash.encode_size()
+        self.root.encode_size()
             + self.oldest_retained_loc.encode_size()
             + self.latest_op_loc.encode_size()
     }
@@ -251,11 +251,11 @@ impl Read for GetServerMetadataResponse {
     type Cfg = ();
 
     fn read_cfg(buf: &mut impl Buf, _: &()) -> Result<Self, CodecError> {
-        let target_hash = Digest::read(buf)?;
+        let root = Digest::read(buf)?;
         let oldest_retained_loc = u64::read(buf)?;
         let latest_op_loc = u64::read(buf)?;
         Ok(Self {
-            target_hash,
+            root,
             oldest_retained_loc,
             latest_op_loc,
         })

diff --git a/examples/sync/src/resolver.rs b/examples/sync/src/resolver.rs
@@ -99,7 +99,7 @@ where
             .map_err(|e| ResolverError::DeserializationError(e.to_string()))
     }
 
-    /// Get server metadata (target hash and bounds)
+    /// Get server metadata (target root digest and bounds)
     pub async fn get_server_metadata(&self) -> Result<GetServerMetadataResponse, ResolverError> {
         match self.send_request(Message::GetServerMetadataRequest).await? {
             Message::GetServerMetadataResponse(response) => {

diff --git a/storage/src/adb/any/mod.rs b/storage/src/adb/any/mod.rs
@@ -687,7 +687,7 @@ impl<E: RStorage + Clock + Metrics, K: Array, V: Array, H: CHasher, T: Translato
         proof: &Proof<H::Digest>,
         start_loc: u64,
         ops: &[Operation<K, V>],
-        root_digest: &H::Digest,
+        root: &H::Digest,
     ) -> bool {
         let start_pos = leaf_num_to_pos(start_loc);
 
@@ -696,7 +696,7 @@ impl<E: RStorage + Clock + Metrics, K: Array, V: Array, H: CHasher, T: Translato
             .map(|op| Any::<E, _, _, _, T>::op_digest(hasher, op))
             .collect::<Vec<_>>();
 
-        proof.verify_range_inclusion(hasher, &digests, start_pos, root_digest)
+        proof.verify_range_inclusion(hasher, &digests, start_pos, root)
     }
 
     /// Commit any pending operations to the db, ensuring they are persisted to disk & recoverable
@@ -1216,10 +1216,10 @@ pub(super) mod test {
             assert_eq!(db.snapshot.items(), 857);
 
             // Close & reopen the db, making sure the re-opened db has exactly the same state.
-            let root_digest = db.root(&mut hasher);
+            let root = db.root(&mut hasher);
             db.close().await.unwrap();
             let mut db = open_db(context.clone()).await;
-            assert_eq!(root_digest, db.root(&mut hasher));
+            assert_eq!(root, db.root(&mut hasher));
             assert_eq!(db.op_count(), 2336);
             assert_eq!(db.inactivity_floor_loc, 1478);
             assert_eq!(db.snapshot.items(), 857);
@@ -1400,10 +1400,10 @@ pub(super) mod test {
             assert!(db.get(&k).await.unwrap().is_none());
 
             // Close & reopen the db, making sure the re-opened db has exactly the same state.
-            let root_digest = db.root(&mut hasher);
+            let root = db.root(&mut hasher);
             db.close().await.unwrap();
             let db = open_db(context.clone()).await;
-            assert_eq!(root_digest, db.root(&mut hasher));
+            assert_eq!(root, db.root(&mut hasher));
             assert!(db.get(&k).await.unwrap().is_none());
 
             db.destroy().await.unwrap();
@@ -1655,7 +1655,7 @@ pub(super) mod test {
                 source_db.log.size().await.unwrap()
             );
 
-            // Verify the root hash matches the target
+            // Verify the root digest matches the target
             assert_eq!(db.root(&mut hasher), target_hash);
 
             // Verify state matches the source operations
@@ -1854,7 +1854,7 @@ pub(super) mod test {
                 leaf_num_to_pos(sync_lower_bound)
             );
 
-            // Verify the root hash matches the target
+            // Verify the root digest matches the target
             assert_eq!(sync_db.root(&mut hasher), target_hash);
 
             // Verify state matches the source operations
@@ -2235,7 +2235,7 @@ pub(super) mod test {
                 ));
             }
 
-            // Changing the root hash should cause verification to fail
+            // Changing the root digest should cause verification to fail
             {
                 assert!(!AnyTest::verify_proof(
                     &mut hasher,
@@ -2292,7 +2292,7 @@ pub(super) mod test {
             // Final commit to establish the inactivity floor
             db.commit().await.unwrap();
 
-            // Get the root hash
+            // Get the root digest
             let original_root = db.root(&mut hasher);
 
             // Verify the pruning boundary is correct