feat: function to filter queue when a verifier gets disabled

Author: IAvecilla

batcher/aligned-batcher/src/lib.rs

@@ -1013,13 +1013,27 @@ impl Batcher {
     /// Receives new block numbers, checks if conditions are met for submission and
     /// finalizes the batch.
     async fn handle_new_block(&self, block_number: u64) -> Result<(), BatcherError> {
-        let gas_price = match self.get_gas_price().await {
-            Some(price) => price,
-            None => {
-                error!("Failed to get gas price");
-                return Err(BatcherError::GasPriceError);
-            }
-        };
+        let gas_price_future = self.get_gas_price();
+        let disabled_verifiers_future = self.disabled_verifiers();
+
+        let (gas_price, disable_verifiers) =
+            tokio::join!(gas_price_future, disabled_verifiers_future);
+        let gas_price = gas_price.ok_or(BatcherError::GasPriceError)?;
+        let new_disable_verifiers =
+            disable_verifiers.map_err(|e| BatcherError::DisabledVerifiersError(e.to_string()))?;
+
+        let mut disabled_verifiers = self.disabled_verifiers.lock().await;
+        if new_disable_verifiers != *disabled_verifiers {
+            let mut batch_state = self.batch_state.lock().await;
+            *disabled_verifiers = new_disable_verifiers;
+            warn!("Disabled verifiers updated, filtering queue");
+            let filered_batch_queue = zk_utils::filter_disabled_verifiers(
+                batch_state.batch_queue.clone(),
+                disabled_verifiers,
+            )
+            .await;
+            batch_state.batch_queue = filered_batch_queue;
+        }
 
         if let Some(finalized_batch) = self.is_batch_ready(block_number, gas_price).await {
             let batch_finalization_result = self

batcher/aligned-batcher/src/zk_utils/mod.rs

@@ -1,9 +1,14 @@
-use crate::gnark::verify_gnark;
+use crate::connection::send_message;
 use crate::risc_zero::verify_risc_zero_proof;
 use crate::sp1::verify_sp1_proof;
-use aligned_sdk::core::types::{ProvingSystemId, VerificationData};
+use crate::types::batch_queue::BatchQueue;
+use crate::{gnark::verify_gnark, types::batch_queue::BatchQueueEntry};
+use aligned_sdk::core::types::{
+    ProofInvalidReason, ProvingSystemId, ValidityResponseMessage, VerificationData,
+};
 use ethers::types::U256;
-use log::{debug, warn};
+use log::{debug, info, warn};
+use tokio::sync::MutexGuard;
 
 pub(crate) async fn verify(verification_data: &VerificationData) -> bool {
     let verification_data = verification_data.clone();
@@ -70,6 +75,57 @@ pub(crate) fn is_verifier_disabled(
     disabled_verifiers & (U256::one() << verification_data.proving_system as u64) != U256::zero()
 }
 
+pub(crate) async fn filter_disabled_verifiers(
+    batch_queue: BatchQueue,
+    disabled_verifiers: MutexGuard<'_, U256>,
+) -> BatchQueue {
+    let mut removed_entries = Vec::new();
+    let filtered_batch_queue = batch_queue
+        .iter()
+        .filter_map(|(entry, entry_priority)| {
+            info!(
+                "Verifying proof for proving system {}",
+                entry
+                    .nonced_verification_data
+                    .verification_data
+                    .proving_system
+            );
+            let verification_data = &entry.nonced_verification_data.verification_data;
+            if !is_verifier_disabled(*disabled_verifiers, verification_data)
+                && !removed_entries
+                    .iter()
+                    .any(|e: &BatchQueueEntry| e.sender == entry.sender)
+            {
+                Some((entry.clone(), entry_priority.clone()))
+            } else {
+                warn!(
+                    "Verifier for proving system {} is now disabled, removing proofs from batch",
+                    verification_data.proving_system
+                );
+                removed_entries.push(entry.clone());
+
+                None
+            }
+        })
+        .collect();
+    for entry in removed_entries {
+        let ws_sink = entry.messaging_sink.as_ref();
+        if let Some(ws_sink) = ws_sink {
+            send_message(
+                ws_sink.clone(),
+                ValidityResponseMessage::InvalidProof(ProofInvalidReason::DisabledVerifier(
+                    entry
+                        .nonced_verification_data
+                        .verification_data
+                        .proving_system,
+                )),
+            )
+            .await;
+        }
+    }
+    filtered_batch_queue
+}
+
 #[cfg(test)]
 mod test {
     use super::is_verifier_disabled;