chore: enable zero out bloom filter in update from output queue (#1555)

Author: ananas-block

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

@@ -56,6 +56,22 @@ impl BatchMetadata {
         &self.batches[self.currently_processing_batch_index as usize]
     }
 
+    pub fn get_previous_batch_index(&self) -> usize {
+        if self.currently_processing_batch_index == 0 {
+            1
+        } else {
+            0
+        }
+    }
+
+    pub fn get_previous_batch(&self) -> &Batch {
+        &self.batches[self.get_previous_batch_index()]
+    }
+
+    pub fn get_previous_batch_mut(&mut self) -> &mut Batch {
+        &mut self.batches[self.get_previous_batch_index()]
+    }
+
     pub fn get_current_batch_mut(&mut self) -> &mut Batch {
         &mut self.batches[self.currently_processing_batch_index as usize]
     }

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

@@ -342,7 +342,9 @@ impl<'a> BatchedMerkleTreeAccount<'a> {
     ///     3.2. Increment the number of inserted zkps.
     ///     3.3. If all zkps are inserted, set batch state to inserted.
     /// 4. Increment next full batch index if inserted.
-    /// 5. Return the batch append event.
+    /// 5. Zero out previous batch bloom filter of input queue
+    ///     if current batch is 50% inserted.
+    /// 6. Return the batch append event.
     ///
     /// Note: when proving inclusion by index in
     ///     value array we need to insert the value into a bloom_filter once it is
@@ -401,8 +403,12 @@ impl<'a> BatchedMerkleTreeAccount<'a> {
             queue_account
                 .batch_metadata
                 .increment_next_full_batch_index_if_inserted(full_batch_state);
+            // 5. Zero out previous batch bloom filter
+            //     if current batch is 50% inserted.
+            // Needs to be executed post mark_as_inserted_in_merkle_tree.
+            self.zero_out_previous_batch_bloom_filter()?;
         }
-        // 5. Return the batch append event.
+        // 6. Return the batch append event.
         Ok(BatchAppendEvent {
             id,
             batch_index: full_batch_index as u64,
@@ -756,14 +762,13 @@ impl<'a> BatchedMerkleTreeAccount<'a> {
                 self.queue_metadata.batches[current_batch].get_num_inserted_elements();
             num_inserted_elements >= batch_size / 2
         };
-
         let previous_full_batch = self
             .queue_metadata
             .batches
             .get_mut(previous_full_batch_index)
             .ok_or(BatchedMerkleTreeError::InvalidBatchIndex)?;
-
         let batch_is_inserted = previous_full_batch.get_state() == BatchState::Inserted;
+
         let previous_batch_is_ready =
             batch_is_inserted && !previous_full_batch.bloom_filter_is_zeroed();
 

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

@@ -1302,6 +1302,52 @@ fn assert_merkle_tree_update(
     queue_account: Option<BatchedQueueAccount>,
     root: [u8; 32],
 ) {
+    let input_queue_previous_batch_state =
+        old_account.queue_metadata.get_previous_batch().get_state();
+    let input_queue_current_batch = old_account.queue_metadata.get_current_batch();
+    let previous_batch_index = old_account.queue_metadata.get_previous_batch_index();
+    let is_half_full = input_queue_current_batch.get_num_inserted_elements()
+        >= input_queue_current_batch.batch_size / 2;
+    if is_half_full
+        && input_queue_previous_batch_state == BatchState::Inserted
+        && !old_account
+            .queue_metadata
+            .get_previous_batch()
+            .bloom_filter_is_zeroed()
+    {
+        old_account
+            .queue_metadata
+            .get_previous_batch_mut()
+            .set_bloom_filter_to_zeroed();
+        old_account.bloom_filter_stores[previous_batch_index]
+            .iter_mut()
+            .for_each(|elem| {
+                *elem = 0;
+            });
+        let previous_full_batch = old_account
+            .queue_metadata
+            .batches
+            .get(previous_batch_index)
+            .unwrap();
+        let sequence_number = previous_full_batch.sequence_number;
+        let overlapping_roots_exits = sequence_number > old_account.sequence_number;
+        if overlapping_roots_exits {
+            let mut oldest_root_index = old_account.root_history.first_index();
+            // 2.1. Get, num of remaining roots.
+            //    Remaining roots have not been updated since
+            //    the update of the previous batch hence enable to prove
+            //    inclusion of values nullified in the previous batch.
+            let num_remaining_roots = sequence_number - old_account.sequence_number;
+            // 2.2. Zero out roots oldest to first safe root index.
+            //      Skip one iteration we don't need to zero out
+            //      the first safe root.
+            for _ in 1..num_remaining_roots {
+                old_account.root_history[oldest_root_index] = [0u8; 32];
+                oldest_root_index += 1;
+                oldest_root_index %= old_account.root_history.len();
+            }
+        }
+    }
     // Output queue update
     if let Some(mut old_queue_account) = old_queue_account {
         let queue_account = queue_account.unwrap();
@@ -1311,7 +1357,6 @@ fn assert_merkle_tree_update(
             .batches
             .get_mut(old_full_batch_index as usize)
             .unwrap();
-        println!("old full batch {:?}", old_full_batch);
         old_full_batch
             .mark_as_inserted_in_merkle_tree(
                 account.sequence_number,