cleanup

Author: roberto-bayardo

examples/sync/src/databases/current.rs

@@ -141,7 +141,6 @@ where
 
     async fn sync_boundary(&self) -> Location {
         self.sync_boundary()
-            .expect("sync_boundary should not overflow")
     }
 
     fn historical_proof(

storage/fuzz/fuzz_targets/current_crash_recovery.rs

@@ -265,10 +265,7 @@ fn fuzz(input: FuzzInput) {
                         {
                             break;
                         }
-                        let Ok(boundary) = db.sync_boundary() else {
-                            break;
-                        };
-                        if db.prune(boundary).await.is_err() {
+                        if db.prune(db.sync_boundary()).await.is_err() {
                             break;
                         }
                     }
@@ -327,9 +324,7 @@ fn fuzz(input: FuzzInput) {
             }
 
             // Verify range proofs over the recovered DB.
-            let floor = *db
-                .sync_boundary()
-                .expect("sync_boundary should not overflow");
+            let floor = *db.sync_boundary();
             let size = *db.bounds().await.end;
             for i in floor..size {
                 let loc = Location::new(i);

storage/fuzz/fuzz_targets/current_mmb_prune_grow.rs

@@ -215,10 +215,9 @@ async fn commit_pending(
 }
 
 async fn prune_to_floor(db: &mut Db, reference_db: &Db, context: &str) {
-    let boundary = db
-        .sync_boundary()
-        .expect("sync_boundary should not overflow");
-    db.prune(boundary).await.expect("prune should not fail");
+    db.prune(db.sync_boundary())
+        .await
+        .expect("prune should not fail");
     assert_matches_reference(db, reference_db, context).await;
 }
 

storage/fuzz/fuzz_targets/current_ordered_operations.rs

@@ -215,7 +215,7 @@ fn fuzz(data: FuzzInput) {
                         &mut pending_inserts, &mut pending_deletes,
                     ).await;
                     committed_op_count = db.bounds().await.end;
-                    db.prune(db.sync_boundary().expect("sync_boundary should not overflow")).await.expect("Prune should not fail");
+                    db.prune(db.sync_boundary()).await.expect("Prune should not fail");
                 }
 
                 CurrentOperation::Root => {
@@ -243,7 +243,7 @@ fn fuzz(data: FuzzInput) {
                     let current_op_count = db.bounds().await.end;
                     let start_loc = Location::new(start_loc % *current_op_count);
 
-                    let oldest_loc = db.sync_boundary().expect("sync_boundary should not overflow");
+                    let oldest_loc = db.sync_boundary();
                     if start_loc >= oldest_loc {
                         let (proof, ops, chunks) = db
                             .range_proof(&mut hasher, start_loc, *max_ops)

storage/fuzz/fuzz_targets/current_unordered_operations.rs

@@ -197,7 +197,7 @@ fn fuzz(data: FuzzInput) {
                 CurrentOperation::Prune => {
                     commit_pending(&mut db, &mut pending_writes, &mut committed_state, &mut pending_expected).await;
                     committed_op_count = db.bounds().await.end;
-                    db.prune(db.sync_boundary().expect("sync_boundary should not overflow")).await.expect("Prune should not fail");
+                    db.prune(db.sync_boundary()).await.expect("Prune should not fail");
                 }
 
                 CurrentOperation::Root => {
@@ -218,7 +218,7 @@ fn fuzz(data: FuzzInput) {
 
                     let current_op_count = db.bounds().await.end;
                     let start_loc = Location::new(start_loc % *current_op_count);
-                    let oldest_loc = db.sync_boundary().expect("sync_boundary should not overflow");
+                    let oldest_loc = db.sync_boundary();
                     if start_loc >= oldest_loc {
                         let (proof, ops, chunks) = db
                             .range_proof(&mut hasher, start_loc, *max_ops)

storage/src/qmdb/any/db.rs

@@ -100,19 +100,13 @@ where
 {
     /// Return the inactivity floor location. This is the location before which all operations are
     /// known to be inactive. Operations before this point can be safely pruned.
-    ///
-    /// This is an implementation detail of the activity tracking; external callers should
-    /// prefer [`Self::sync_boundary`] when constructing a sync target.
+    #[cfg(any(test, feature = "test-traits"))]
     pub(crate) const fn inactivity_floor_loc(&self) -> Location<F> {
         self.inactivity_floor_loc
     }
 
-    /// Return the most recent location from which this database can safely be synced.
-    ///
-    /// Callers constructing a sync [`Target`](crate::qmdb::sync::Target) may use this value, or
-    /// any earlier retained location, as `range.start`. For `any` databases this equals the
-    /// inactivity floor; the receiver's reconstruction does not require chunk alignment, so any
-    /// retained earlier location is also valid.
+    /// Return the most recent location from which this database can safely be synced, and the
+    /// upper bound on [`Self::prune`]'s `loc`. For `any`, this equals the inactivity floor.
     pub const fn sync_boundary(&self) -> Location<F> {
         self.inactivity_floor_loc
     }

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

@@ -50,16 +50,10 @@ pub(crate) mod tests;
 ///
 /// Shared across [crate::qmdb::any] and [crate::qmdb::current] sync because both
 /// build on the same operations-MMR layout and share the same merkle partition.
-///
-/// # Caller contract
-///
-/// `target.range.start()` **must** equal the committed inactivity floor of the
-/// target state (i.e. the floor carried by the last `CommitFloor` op). Only the
-/// persisted tree size and root are checked; the merkle pruning boundary is not.
-/// Callers that set `target.range.start()` below the committed floor (or that
-/// prune their own database past the committed floor) can cause a later
-/// [`qmdb::sync::Database::from_sync_result`] rebuild to fail with `MissingNode`
-/// even though this function returned `true`.
+/// Verifies only that the persisted tree size and root match; the merkle pruning
+/// boundary is not re-checked. Callers must keep their local pruning point at or
+/// below `target.range.start()` or a later
+/// [`qmdb::sync::Database::from_sync_result`] rebuild may fail.
 pub async fn has_local_target_state<F, E, H>(
     context: E,
     merkle_config: journaled::Config,
@@ -78,7 +72,8 @@ where
     )
     .await;
     // Size + root match implies the last CommitFloor op (and therefore the
-    // committed inactivity floor) matches, per the caller contract above.
+    // size + root identify a unique state, so if they match the target's we can reuse
+    // the persisted DB without fetching boundary pins.
     matches!(
         peek,
         Ok(Some((_, journal_leaves, root)))