refactor: move verifier disable check to new function and add tests

Author: IAvecilla

batcher/aligned-batcher/src/lib.rs

@@ -414,10 +414,8 @@ impl Batcher {
                     return Ok(());
                 }
             };
-            let verification_data = nonced_verification_data.verification_data.clone();
-            if disabled_verifiers & (U256::one() << verification_data.proving_system as u64)
-                != U256::zero()
-            {
+            let verification_data = &nonced_verification_data.verification_data;
+            if zk_utils::is_verifier_disabled(disabled_verifiers, verification_data) {
                 warn!(
                     "Verifier for proving system {} is disabled, skipping verification",
                     verification_data.proving_system
@@ -430,7 +428,7 @@ impl Batcher {
                 return Ok(());
             }
 
-            if !zk_utils::verify(&verification_data).await {
+            if !zk_utils::verify(verification_data).await {
                 error!("Invalid proof detected. Verification failed");
                 send_message(
                     ws_conn_sink.clone(),

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

@@ -2,6 +2,7 @@ use crate::gnark::verify_gnark;
 use crate::risc_zero::verify_risc_zero_proof;
 use crate::sp1::verify_sp1_proof;
 use aligned_sdk::core::types::{ProvingSystemId, VerificationData};
+use ethers::types::U256;
 use log::{debug, warn};
 
 pub(crate) async fn verify(verification_data: &VerificationData) -> bool {
@@ -61,3 +62,110 @@ fn verify_internal(verification_data: &VerificationData) -> bool {
         }
     }
 }
+
+pub(crate) fn is_verifier_disabled(
+    disabled_verifiers: U256,
+    verification_data: &VerificationData,
+) -> bool {
+    disabled_verifiers & (U256::one() << verification_data.proving_system as u64) != U256::zero()
+}
+
+#[cfg(test)]
+mod test {
+    use super::is_verifier_disabled;
+    use aligned_sdk::core::types::{ProvingSystemId, VerificationData};
+    use ethers::types::Address;
+
+    fn get_all_verifiers() -> Vec<ProvingSystemId> {
+        let verifiers = vec![
+            ProvingSystemId::GnarkPlonkBls12_381,
+            ProvingSystemId::GnarkPlonkBn254,
+            ProvingSystemId::Groth16Bn254,
+            ProvingSystemId::SP1,
+            ProvingSystemId::Risc0,
+        ];
+        // Just to make sure we are not missing any verifier. The compilation will fail if we do and it forces us to add it to the vec above.
+        for verifier in verifiers.iter() {
+            match verifier {
+                ProvingSystemId::SP1 => (),
+                ProvingSystemId::Risc0 => (),
+                ProvingSystemId::GnarkPlonkBls12_381 => (),
+                ProvingSystemId::GnarkPlonkBn254 => (),
+                ProvingSystemId::Groth16Bn254 => (),
+            }
+        }
+        verifiers
+    }
+
+    #[test]
+    fn test_all_verifiers_enabled() {
+        let disabled_verifiers = ethers::types::U256::zero();
+        for verifier in get_all_verifiers().iter() {
+            let verification_data = VerificationData {
+                proving_system: *verifier,
+                vm_program_code: None,
+                pub_input: None,
+                proof: vec![],
+                verification_key: None,
+                proof_generator_addr: Address::zero(),
+            };
+            assert!(
+                !is_verifier_disabled(disabled_verifiers, &verification_data),
+                "Verifier {:?} should not be disabled",
+                verifier
+            );
+        }
+    }
+
+    #[test]
+    fn test_all_verifiers_disabled() {
+        let verifiers = get_all_verifiers();
+        // This creates a number with all bits set to 1 depending on the number of verifiers to disable all of them.
+        let disabled_verifiers = ethers::types::U256::from(2u64.pow(verifiers.len() as u32) - 1);
+        for verifier in get_all_verifiers().iter() {
+            let verification_data = VerificationData {
+                proving_system: *verifier,
+                vm_program_code: None,
+                pub_input: None,
+                proof: vec![],
+                verification_key: None,
+                proof_generator_addr: Address::zero(),
+            };
+            assert!(
+                is_verifier_disabled(disabled_verifiers, &verification_data),
+                "Verifier {:?} should be disabled",
+                verifier
+            );
+        }
+    }
+
+    #[test]
+    fn test_some_verifiers_disabled() {
+        let verifiers = get_all_verifiers();
+        // Disabling only the first verifier
+        let disabled_verifiers = ethers::types::U256::from(0b10001);
+        for verifier in get_all_verifiers().iter() {
+            let verification_data = VerificationData {
+                proving_system: *verifier,
+                vm_program_code: None,
+                pub_input: None,
+                proof: vec![],
+                verification_key: None,
+                proof_generator_addr: Address::zero(),
+            };
+            if verifier == &verifiers[0] || verifier == &verifiers[verifiers.len() - 1] {
+                assert!(
+                    is_verifier_disabled(disabled_verifiers, &verification_data),
+                    "Verifier {:?} should be disabled",
+                    verifier
+                );
+            } else {
+                assert!(
+                    !is_verifier_disabled(disabled_verifiers, &verification_data),
+                    "Verifier {:?} should not be disabled",
+                    verifier
+                );
+            }
+        }
+    }
+}