refactor: create mock validator for test

Author: fbwoolf

Cargo.lock

@@ -0,0 +1,3 @@
+[toolchain]
+channel = "nightly-2025-08-04"
+components = ["clippy", "rustfmt", "rust-analyzer"]

rust-toolchain.toml

@@ -27,3 +27,4 @@ tracing = { workspace = true }
 
 
 [dev-dependencies]
+mockall = "0.12"

zkvm_execution_layer/Cargo.toml

@@ -1,5 +1,6 @@
-use crate::ethproofs_demo::validate_proof;
+use crate::ethproofs_demo::{EthproofsValidator, ProofValidator};
 use crate::proof_verification::{ProofVerificationResult, ProofVerifier, VerificationError};
+use std::sync::Arc;
 use std::time::Duration;
 use tracing::debug;
 use types::{ExecutionProof, ExecutionProofId};
@@ -12,6 +13,7 @@ use types::{ExecutionProof, ExecutionProofId};
 pub struct DummyVerifier {
     proof_id: ExecutionProofId,
     verification_delay: Duration,
+    validator: Arc<dyn ProofValidator>,
 }
 
 impl DummyVerifier {
@@ -20,6 +22,7 @@ impl DummyVerifier {
         Self {
             proof_id,
             verification_delay: Duration::from_millis(0),
+            validator: Arc::new(EthproofsValidator),
         }
     }
 
@@ -28,6 +31,20 @@ impl DummyVerifier {
         Self {
             proof_id,
             verification_delay: delay,
+            validator: Arc::new(EthproofsValidator),
+        }
+    }
+
+    /// Create a new dummy verifier with a custom validator (for testing)
+    #[cfg(test)]
+    fn with_validator(
+        proof_id: ExecutionProofId,
+        validator: Arc<dyn ProofValidator>,
+    ) -> Self {
+        Self {
+            proof_id,
+            verification_delay: Duration::from_millis(0),
+            validator,
         }
     }
 }
@@ -50,8 +67,8 @@ impl ProofVerifier for DummyVerifier {
             "[Ethproofs] Verifying proof"
         );
 
-        // Perform cryptographic verification using Ethproofs verifiers
-        Ok(validate_proof(proof))
+        // Perform cryptographic verification using the injected validator
+        Ok(self.validator.validate(proof))
     }
 
     fn proof_id(&self) -> ExecutionProofId {
@@ -62,13 +79,20 @@ impl ProofVerifier for DummyVerifier {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use types::{ExecutionBlockHash, FixedBytesExtended};
+    use mockall::mock;
+    use types::{ExecutionBlockHash, FixedBytesExtended, Hash256, Slot};
+
+    mock! {
+        TestValidator {}
+        impl ProofValidator for TestValidator {
+            fn validate(&self, proof: &ExecutionProof) -> bool;
+        }
+    }
 
     fn create_test_proof(
         subnet_id: ExecutionProofId,
         block_hash: types::ExecutionBlockHash,
     ) -> ExecutionProof {
-        use types::{Hash256, Slot};
         ExecutionProof::new(
             subnet_id,
             Slot::new(100),
@@ -82,10 +106,17 @@ mod tests {
     #[tokio::test]
     async fn test_dummy_verifier_success() {
         let subnet = ExecutionProofId::new(0).unwrap();
-        let verifier = DummyVerifier::new(subnet);
         let block_hash = ExecutionBlockHash::zero();
         let proof = create_test_proof(subnet, block_hash);
 
+        let mut mock_validator = MockTestValidator::new();
+        mock_validator
+            .expect_validate()
+            .withf(move |p| p.proof_id == subnet)
+            .returning(|_| true);
+
+        let verifier = DummyVerifier::with_validator(subnet, Arc::new(mock_validator));
+
         let result = verifier.verify(&proof);
         assert!(result.is_ok());
         assert!(result.unwrap());
@@ -95,10 +126,12 @@ mod tests {
     async fn test_dummy_verifier_wrong_subnet() {
         let subnet_0 = ExecutionProofId::new(0).unwrap();
         let subnet_1 = ExecutionProofId::new(1).unwrap();
-        let verifier = DummyVerifier::new(subnet_0);
         let block_hash = ExecutionBlockHash::zero();
         let proof = create_test_proof(subnet_1, block_hash);
 
+        let mock_validator = MockTestValidator::new();
+        let verifier = DummyVerifier::with_validator(subnet_0, Arc::new(mock_validator));
+
         let result = verifier.verify(&proof);
         assert!(result.is_err());
         assert!(matches!(

zkvm_execution_layer/src/dummy_proof_verifier.rs

@@ -7,6 +7,21 @@ use std::time::{Duration, Instant};
 use tracing::{debug, warn};
 use types::ExecutionProof;
 
+/// Trait for validating proofs
+pub trait ProofValidator: Send + Sync {
+    /// Validate a proof using the verifier store
+    fn validate(&self, proof: &ExecutionProof) -> bool;
+}
+
+/// Default implementation using the Ethproofs verifier store
+pub struct EthproofsValidator;
+
+impl ProofValidator for EthproofsValidator {
+    fn validate(&self, proof: &ExecutionProof) -> bool {
+        validate_proof(proof)
+    }
+}
+
 /// Global verification key store, loaded once on first access
 pub static VERIFICATION_KEY_STORE: Lazy<Option<VerificationKeyStore>> =
     Lazy::new(|| match VerificationKeyStore::load_embedded() {