refactor: fallback verification with dummy proof

Author: fbwoolf

consensus/types/src/execution_proof_id.rs

@@ -9,6 +9,11 @@ use tree_hash::TreeHash;
 /// TODO(zkproofs): The number 8 is a parameter that we will want to configure in the future
 pub const EXECUTION_PROOF_TYPE_COUNT: u8 = 8;
 
+/// TODO(ethproofs): Added to handle when proof generation fails.
+///
+/// Special proof ID reserved for fallback proofs
+pub const FALLBACK_EXECUTION_PROOF_ID: u8 = 255;
+
 /// ExecutionProofId identifies which zkVM/proof system a proof belongs to.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
 pub struct ExecutionProofId(u8);
@@ -81,11 +86,22 @@ impl ExecutionProofId {
         }
     }
 
+    /// Creates a fallback ExecutionProofId (255)
+    /// Used for dummy proofs when Ethproofs API fails or times out
+    pub fn fallback() -> Self {
+        Self(FALLBACK_EXECUTION_PROOF_ID)
+    }
+
     /// Returns the inner u8 value
     pub fn as_u8(&self) -> u8 {
         self.0
     }
 
+    /// Check if this is a fallback proof ID
+    pub fn is_fallback(&self) -> bool {
+        self.0 == FALLBACK_EXECUTION_PROOF_ID
+    }
+
     /// Returns the subnet ID as a usize
     pub fn as_usize(&self) -> usize {
         self.0 as usize

zkvm_execution_layer/src/dummy_proof_gen.rs

@@ -6,6 +6,7 @@ use async_trait::async_trait;
 use std::time::Duration;
 use tokio::time::sleep;
 use tracing::{debug, warn};
+use types::execution_proof_id::FALLBACK_EXECUTION_PROOF_ID;
 use types::{ExecutionBlockHash, ExecutionProof, ExecutionProofId, Hash256, Slot};
 
 /// TODO(ethproofs): Implementation of proof generation for demo.
@@ -36,23 +37,33 @@ impl DummyProofGenerator {
         }
     }
 
-    /// TODO(ethproofs): Used when Ethproofs API fails or verification fails.
+    /// TODO(ethproofs): Fallback when the Ethproofs API fails or test verification fails.
     ///
-    /// Create a fallback dummy proof
+    /// Create a fallback dummy proof with a reserved fallback proof ID
     fn create_dummy_proof(
         &self,
         slot: Slot,
         payload_hash: &ExecutionBlockHash,
         block_root: &Hash256,
     ) -> ProofGenerationResult<ExecutionProof> {
         let dummy_data = format!(
-            "ethproofs_fallback_subnet_{:?}_slot_{:?}_hash_{:?}",
-            self.proof_id, slot, payload_hash
+            "ethproofs_fallback_proof_id_{}_slot_{}_hash_{}",
+            FALLBACK_EXECUTION_PROOF_ID,
+            slot.as_u64(),
+            payload_hash
         )
         .into_bytes();
 
-        ExecutionProof::new(self.proof_id, slot, *payload_hash, *block_root, dummy_data)
-            .map_err(ProofGenerationError::ProofGenerationFailed)
+        // Use the fallback proof ID to mark this as a dummy proof
+        let fallback_proof_id = ExecutionProofId::fallback();
+        ExecutionProof::new(
+            fallback_proof_id,
+            slot,
+            *payload_hash,
+            *block_root,
+            dummy_data,
+        )
+        .map_err(ProofGenerationError::ProofGenerationFailed)
     }
 }
 
@@ -178,7 +189,8 @@ mod tests {
         assert!(result.is_ok());
 
         let proof = result.unwrap();
-        assert_eq!(proof.proof_id, subnet);
+
+        assert!(proof.proof_id.is_fallback());
         assert_eq!(proof.slot, slot);
         assert_eq!(proof.block_hash, block_hash);
         assert_eq!(proof.block_root, block_root);

zkvm_execution_layer/src/ethproofs_demo.rs

@@ -162,6 +162,15 @@ pub async fn download_proof_binary(proof_id: u64) -> Result<Vec<u8>, String> {
 /// 2. Running the cryptographic verification function
 /// 3. Returning whether the proof is valid
 pub fn validate_proof(proof: &ExecutionProof) -> bool {
+    // Check if this is a fallback proof (created when Ethproofs API failed/timed out)
+    if proof.proof_id.is_fallback() {
+        debug!(
+            proof_id = %proof.proof_id,
+            "[Ethproofs] Fallback proof detected, skipping verification"
+        );
+        return true;
+    }
+
     // Get the prover UUID for this proof_id from the hardcoded mapping
     let prover_uuid = match VERIFIER_STORE.get_prover_uuid_for_proof_id(proof.proof_id) {
         Some(uuid) => uuid,

zkvm_execution_layer/src/test_proofs/brevis_79041a5b-ee8d-49b3-8207-86c7debf8e13_542871.bin

@@ -96,9 +96,38 @@ impl ProofVerifier for PicoVerifier {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::path::PathBuf;
 
     #[test]
     fn test_pico_verifier_name() {
         assert_eq!(PicoVerifier::name(), "pico");
     }
+
+    #[test]
+    fn test_pico_verifier_with_real_proof() {
+        // Path to the test proof file
+        let proof_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+            .join("src/test_proofs/brevis_79041a5b-ee8d-49b3-8207-86c7debf8e13_542871.bin");
+
+        // Path to the verification key file
+        let vk_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+            .join("src/verification_keys/brevis_79041a5b-ee8d-49b3-8207-86c7debf8e13.bin");
+
+        // Read the proof and verification key
+        let proof_data = std::fs::read(&proof_path)
+            .expect("Failed to read test proof file");
+        let vk_data = std::fs::read(&vk_path)
+            .expect("Failed to read test verification key file");
+
+        // Verify the proof
+        let result = PicoVerifier::verify(&proof_data, &vk_data);
+
+        // Log the result for debugging
+        eprintln!("Proof size: {} bytes", proof_data.len());
+        eprintln!("VK size: {} bytes", vk_data.len());
+        eprintln!("Verification result: {:?}", result);
+
+        // The result should be Ok with a boolean (true if valid, false if invalid)
+        assert!(result.is_ok(), "Verification should not error: {:?}", result.err());
+    }
 }