Add more info on crash

src/task_monitor/tasks/process_identities.rs

@@ -183,37 +183,37 @@
     updates: &[AppliedTreeUpdate],
 ) -> AnyhowResult<()> {
     // If the update is an insertion
     if updates
         .first()
         .context("Updates should be > 1")?
         .update
         .element
         != Hash::ZERO
     {
         let prover = identity_manager
             .get_suitable_insertion_prover(updates.len())
             .await?;
 
         info!(
             "Sending timed-out insertion batch with {}/{} updates.",
             updates.len(),
             prover.batch_size()
         );
 
         insert_identities(database, identity_manager, batching_tree, updates, prover).await?;
     } else {
         let prover = identity_manager
             .get_suitable_deletion_prover(updates.len())
             .await?;
 
         info!(
             "Sending timed-out deletion batch with {}/{} updates.",
             updates.len(),
             prover.batch_size()
         );
 
         delete_identities(database, identity_manager, batching_tree, updates, prover).await?;
     }
 
     Ok(())
 }
@@ -242,11 +242,23 @@
         .leaf_index;
 
     for update in &updates[1..] {
-        assert_eq!(
-            last_index + 1,
-            update.update.leaf_index,
-            "Identities are not consecutive leaves in the tree."
-        );
+        if last_index + 1 != update.update.leaf_index {
+            let leaf_indexes = updates
+                .iter()
+                .map(|update| update.update.leaf_index)
+                .collect::<Vec<_>>();
+            let commitments = updates
+                .iter()
+                .map(|update| update.update.element)
+                .collect::<Vec<_>>();
+
+            panic!(
+                "Identities are not consecutive leaves in the tree (leaf_indexes = {:?}, \
+                 commitments = {:?})",
+                leaf_indexes, commitments
+            );
+        }
+
         last_index = update.update.leaf_index;
     }
 
@@ -392,28 +404,28 @@
     Ok(())
 }
 
 pub async fn delete_identities(
     database: &Database,
     identity_manager: &IdentityManager,
     batching_tree: &TreeVersion<Intermediate>,
     updates: &[AppliedTreeUpdate],
     prover: ReadOnlyProver<'_, Prover>,
 ) -> AnyhowResult<()> {
     TaskMonitor::log_identities_queues(database).await?;
 
     if updates.is_empty() {
         warn!("Identity commit requested with zero identities. Continuing.");
         return Ok(());
     }
 
     debug!("Starting identity commit for {} identities.", updates.len());
 
     // Grab the initial conditions before the updates are applied to the tree.
     let pre_root: U256 = batching_tree.get_root().into();
 
     let mut deletion_indices = updates
         .iter()
         .map(|f| f.update.leaf_index as u32)
         .collect::<Vec<u32>>();
 
     let commitments =
@@ -454,7 +466,7 @@
     // ensure that our batches match that size. We do this by padding deletion
     // indices with tree.depth() ^ 2. The deletion prover will skip the proof for
     // any deletion with an index greater than the max tree depth
     let pad_index = 2_u32.pow(latest_tree_from_updates.depth() as u32);
 
     if commitment_count != batch_size {
         let padding = batch_size - commitment_count;
@@ -517,7 +529,7 @@
     let transaction_id = identity_manager
         .delete_identities(
             proof,
             batch_size as u32,
             packed_deletion_indices,
             pre_root,
             post_root,