cleanup

Author: ananas-block

program-libs/batched-merkle-tree/src/merkle_tree.rs

@@ -834,41 +834,27 @@ impl<'a> BatchedMerkleTreeAccount<'a> {
             .batches
             .get_mut(previous_pending_batch_index)
             .ok_or(BatchedMerkleTreeError::InvalidBatchIndex)?;
-        println!(
-            "previous_pending_batch_index {}",
-            previous_pending_batch_index
-        );
+
         let no_insert_since_last_batch_root = (previous_pending_batch
             .sequence_number
             .saturating_sub(root_history_len))
             == sequence_number;
         let previous_batch_is_inserted = previous_pending_batch.get_state() == BatchState::Inserted;
         let previous_batch_is_ready =
             previous_batch_is_inserted && !previous_pending_batch.bloom_filter_is_zeroed();
-        println!("current_batch_is_half_full {}", current_batch_is_half_full);
-        println!("previous_batch_is_ready {}", previous_batch_is_ready);
-        println!(
-            "no_insert_since_last_batch_root {}",
-            no_insert_since_last_batch_root
-        );
 
         // Current batch is at least half full, previous batch is inserted, and not zeroed.
         if current_batch_is_half_full && previous_batch_is_ready && !no_insert_since_last_batch_root
         {
             // 3.1. Mark bloom filter zeroed.
             previous_pending_batch.set_bloom_filter_to_zeroed();
             let seq = previous_pending_batch.sequence_number;
-            println!(
-                "previous_pending_batch.sequence_number {}",
-                previous_pending_batch.sequence_number
-            );
-            println!("current sequence_number {}", sequence_number);
             // previous_pending_batch.root_index is the index the root
             // of the last update of that batch was inserted at.
             // This is the last unsafe root index.
             // The next index is safe.
-            // TODO: add init check that root history must be greater than 2x batch size.
-            let first_safe_root_index = previous_pending_batch.root_index + 1;
+            let first_safe_root_index =
+                (previous_pending_batch.root_index + 1) % (self.root_history.len() as u32);
 
             // 3.2. Zero out bloom filter.
             {
@@ -1315,11 +1301,7 @@ mod test {
             println!("previous_roots: {:?}", previous_roots);
             assert_ne!(previous_roots, current_roots);
             let root_index = account.queue_batches.batches[0].root_index;
-            // assert_eq!(
-            //     account.root_history[root_index as usize],
-            //     previous_roots[root_index as usize]
-            // );
-            println!("last_batch0_root {:?}", last_batch0_root);
+
             assert_eq!(
                 account.queue_batches.batches[0].get_state(),
                 BatchState::Inserted
@@ -1581,7 +1563,6 @@ mod test {
                     .queue_batches
                     .increment_pending_batch_index_if_inserted(state);
             }
-            //last_batch1_root_update2 = account.root_history.last().unwrap();
             assert_eq!(
                 account.queue_batches.batches[0].get_state(),
                 BatchState::Inserted

program-libs/batched-merkle-tree/tests/kani/batch.rs

@@ -253,7 +253,7 @@ fn verify_start_slot_flag() {
     assert!(batch.start_slot_is_set());
 }
 
-/// Verify start_slot getter/setter duality (Firecracker pattern)
+/// Verify start_slot getter/setter duality
 #[kani::proof]
 fn verify_start_slot_duality() {
     let mut batch = any_batch();
@@ -265,7 +265,7 @@ fn verify_start_slot_duality() {
     assert!(batch.start_slot_is_set());
 }
 
-/// Verify that state transitions cover expected execution paths (Firecracker pattern)
+/// Verify that state transitions cover expected execution paths
 #[kani::proof]
 fn verify_state_transition_coverage() {
     let mut batch = any_batch();
@@ -283,7 +283,7 @@ fn verify_state_transition_coverage() {
     kani::cover!(batch.get_state() == BatchState::Fill);
 }
 
-/// Verify that invalid transitions are properly covered (Firecracker pattern)
+/// Verify that invalid transitions are properly covered
 #[kani::proof]
 fn verify_invalid_transition_coverage() {
     let mut batch = any_batch();

program-libs/batched-merkle-tree/tests/kani/zero_out_roots.rs

@@ -12,7 +12,7 @@ fn stub_hash_to_bn254(_input: &[u8]) -> [u8; 32] {
 }
 
 // Helper to create a BatchedMerkleTreeAccount with bounded parameters for Kani
-// Uses CONCRETE values for initialization to avoid state explosion (Firecracker pattern)
+// Uses CONCRETE values for initialization to avoid state explosion
 // We only need symbolic inputs for zero_out_roots parameters, not for tree setup!
 //
 // NOTE: We use concrete values instead of kani::any() to eliminate state explosion
@@ -165,7 +165,7 @@ fn verify_zero_out_roots_error_too_many() {
         BatchedMerkleTreeError::CannotZeroCompleteRootHistory
     );
 
-    // Coverage: ensure error path is reachable (Firecracker pattern)
+    // Coverage: ensure error path is reachable
     kani::cover!(true);
 }
 
@@ -270,7 +270,7 @@ fn verify_zero_out_roots_wraparound() {
     kani::cover!(first_safe_root_index < oldest_root_index as u32);
 }
 
-/// Verify that defensive assertion always holds (Firecracker pattern)
+/// Verify that defensive assertion always holds
 /// This tests the internal consistency check: oldest_root_index after zeroing == first_safe_root_index
 #[kani::proof]
 #[kani::stub(