refactor: fallback proof

Author: fbwoolf

consensus/types/src/execution_proof_id.rs

@@ -9,11 +9,6 @@ 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);
@@ -75,39 +70,30 @@ impl TreeHash for ExecutionProofId {
 
 impl ExecutionProofId {
     /// Creates a new ExecutionProofId if the value is valid
+    ///
+    /// Valid IDs are in the range [0, EXECUTION_PROOF_TYPE_COUNT).
     pub fn new(id: u8) -> Result<Self, String> {
-        if id < EXECUTION_PROOF_TYPE_COUNT || id == FALLBACK_EXECUTION_PROOF_ID {
+        if id < EXECUTION_PROOF_TYPE_COUNT {
             Ok(Self(id))
         } else {
             Err(format!(
-                "Invalid ExecutionProofId: {}, must be < {} or {}",
-                id, EXECUTION_PROOF_TYPE_COUNT, FALLBACK_EXECUTION_PROOF_ID
+                "Invalid ExecutionProofId: {}, must be < {}",
+                id, EXECUTION_PROOF_TYPE_COUNT
             ))
         }
     }
 
-    /// 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
+    /// Returns the proof ID as a usize
     pub fn as_usize(&self) -> usize {
         self.0 as usize
     }
 
-    /// Returns all valid subnet IDs
+    /// Returns all valid proof IDs
     pub fn all() -> Vec<Self> {
         (0..EXECUTION_PROOF_TYPE_COUNT).map(Self).collect()
     }
@@ -157,23 +143,4 @@ mod tests {
             assert_eq!(proof_id.as_usize(), idx);
         }
     }
-
-    #[test]
-    fn test_fallback_proof_id() {
-        // Test that fallback() creates an ID with value 255
-        let fallback = ExecutionProofId::fallback();
-        assert_eq!(fallback.as_u8(), FALLBACK_EXECUTION_PROOF_ID);
-        assert!(fallback.is_fallback());
-
-        // Test that new(255) creates a valid fallback ID
-        let fallback_from_new = ExecutionProofId::new(FALLBACK_EXECUTION_PROOF_ID);
-        assert!(fallback_from_new.is_ok());
-        assert_eq!(fallback_from_new.unwrap().as_u8(), FALLBACK_EXECUTION_PROOF_ID);
-
-        // Test that fallback ID can be SSZ encoded and decoded
-        let encoded = fallback.as_ssz_bytes();
-        let decoded = ExecutionProofId::from_ssz_bytes(&encoded);
-        assert!(decoded.is_ok());
-        assert_eq!(decoded.unwrap(), fallback);
-    }
 }

zkvm_execution_layer/src/dummy_proof_gen.rs

@@ -6,7 +6,6 @@ use async_trait::async_trait;
 use std::time::Duration;
 use tokio::time::sleep;
 use tracing::{info, 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.
@@ -39,23 +38,24 @@ impl DummyProofGenerator {
 
     /// TODO(ethproofs): Fallback when the Ethproofs API fails or test verification fails.
     ///
-    /// Create a fallback dummy proof with a reserved fallback proof ID
+    /// Create a fallback dummy proof using proof_id 0, which maps to the FallbackVerifier.
+    /// The FallbackVerifier skips cryptographic verification and accepts all proofs.
     fn create_dummy_proof(
         &self,
         slot: Slot,
         payload_hash: &ExecutionBlockHash,
         block_root: &Hash256,
     ) -> ProofGenerationResult<ExecutionProof> {
         let dummy_data = format!(
-            "ethproofs_fallback_proof_id_{}_slot_{}_hash_{}",
-            FALLBACK_EXECUTION_PROOF_ID,
+            "ethproofs_fallback_proof_id_0_slot_{}_hash_{}",
             slot.as_u64(),
             payload_hash
         )
         .into_bytes();
 
-        // Use the fallback proof ID to mark this as a dummy proof
-        let fallback_proof_id = ExecutionProofId::fallback();
+        // Use proof_id 0 (Fallback verifier) to mark this as a dummy proof
+        let fallback_proof_id = ExecutionProofId::new(0)
+            .expect("proof_id 0 is always valid");
         ExecutionProof::new(
             fallback_proof_id,
             slot,
@@ -190,7 +190,8 @@ mod tests {
 
         let proof = result.unwrap();
 
-        assert!(proof.proof_id.is_fallback());
+        // Should create a fallback proof (proof_id = 0)
+        assert_eq!(proof.proof_id.as_u8(), 0);
         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

@@ -161,14 +161,15 @@ pub async fn download_proof_binary(proof_id: u64) -> Result<Vec<u8>, String> {
 /// 1. Looking up the verifier for the proof's proof_id
 /// 2. Running the cryptographic verification function
 /// 3. Returning whether the proof is valid
+///
+/// Note: Fallback proofs (proof_id = 0) bypass this pipeline and are accepted immediately.
 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() {
+    // Fallback proofs (proof_id 0) are accepted without verification
+    if proof.proof_id.as_u8() == 0 {
         info!(
             slot = %proof.slot,
             block_hash = %proof.block_hash,
-            proof_id = %proof.proof_id,
-            "[Ethproofs] Fallback proof detected, skipping verification"
+            "[Ethproofs] Fallback proof accepted without cryptographic verification"
         );
         return true;
     }
@@ -206,7 +207,7 @@ pub fn validate_proof(proof: &ExecutionProof) -> bool {
                                 block_hash = %proof.block_hash,
                                 prover_id = %prover_uuid,
                                 verifier = verifier_entry.name,
-                                "[Ethproofs] Found verifier, starting verification"
+                                "[Ethproofs] Verification started"
                             );
 
                             // Run the actual cryptographic verification

zkvm_execution_layer/src/verifiers/fallback.rs

@@ -0,0 +1,53 @@
+//! Fallback proof verifier
+//!
+//! This module implements a pass-through verifier for fallback proofs.
+//! Fallback proofs are created when the Ethproofs API fails or times out,
+//! and they are used to allow blocks to progress without cryptographic verification.
+
+use super::{ProofVerifier, VerificationResult};
+use tracing::debug;
+
+/// Fallback verifier that accepts all proofs without cryptographic verification.
+///
+/// This verifier is used for fallback proofs created when:
+/// - The Ethproofs API times out
+/// - The Ethproofs API returns an error
+/// - Other proof generation systems are unavailable
+///
+/// Since fallback proofs are created locally and represent a "best effort" state,
+/// they bypass the full cryptographic verification pipeline.
+pub struct FallbackVerifier;
+
+impl ProofVerifier for FallbackVerifier {
+    fn verify(_proof_data: &[u8], _vk_data: &[u8]) -> VerificationResult {
+        debug!("Fallback verifier: accepting proof without cryptographic verification");
+        Ok(true)
+    }
+
+    fn name() -> &'static str {
+        "fallback"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_fallback_verifier_name() {
+        assert_eq!(FallbackVerifier::name(), "fallback");
+    }
+
+    #[test]
+    fn test_fallback_verifier_always_accepts() {
+        // Fallback verifier should accept any input without verification
+        let result = FallbackVerifier::verify(&[], &[]);
+        assert_eq!(result, Ok(true));
+
+        // Test with non-empty data
+        let proof_data = vec![1, 2, 3, 4, 5];
+        let vk_data = vec![6, 7, 8, 9, 10];
+        let result = FallbackVerifier::verify(&proof_data, &vk_data);
+        assert_eq!(result, Ok(true));
+    }
+}

zkvm_execution_layer/src/verifiers/mod.rs

@@ -3,6 +3,7 @@
 //! This module manages different proof verification systems based on prover type.
 //! Each verifier implements cryptographic proof verification for a specific zkVM or proof system.
 
+pub mod fallback;
 pub mod pico;
 pub mod sp1_hypercube;
 pub mod zisk;
@@ -19,24 +20,42 @@ pub type VerificationResult = Result<bool, String>;
 /// Ethproofs demo prover UUIDs - hardcoded mapping for demo testing
 /// These constants define the relationship between internal proof_ids (0, 1, 2, etc.)
 /// and Ethproofs prover UUIDs.
+///
+/// Proof ID Mapping:
+/// - proof_id 0 → Fallback verifier (used when Ethproofs API fails/times out)
+/// - proof_id 1 → Brevis/Pico Prism verifier
+/// - proof_id 2 → ZisK verifier
+/// - proof_id 3 → ZkCloud verifier
+/// - proof_id 4 → ZKM verifier
+/// - proof_id 5 → SP1-Hypercube verifier
+/// - proof_id 6-7 → reserved for future use
 pub mod ethproofs_ids {
     use uuid::Uuid;
 
-    /// Brevis/Pico Prism verifier UUID (proof_id = 0)
+    /// Fallback verifier UUID (proof_id = 0)
+    /// Used for dummy proofs when Ethproofs API fails or times out
+    pub const FALLBACK_UUID: &str = "00000000-0000-0000-0000-000000000000";
+
+    /// Brevis/Pico Prism verifier UUID (proof_id = 1)
     pub const BREVIS_UUID: &str = "79041a5b-ee8d-49b3-8207-86c7debf8e13";
 
-    /// ZisK verifier UUID (proof_id = 1)
+    /// ZisK verifier UUID (proof_id = 2)
     pub const ZISK_UUID: &str = "33f14a82-47b7-42d7-9bc1-b81a46eea4fe";
 
-    /// ZkCloud verifier UUID (proof_id = 2)
+    /// ZkCloud verifier UUID (proof_id = 3)
     pub const ZKCLOUD_UUID: &str = "884fcc21-d522-4b4a-b535-7cfde199485c";
 
-    /// ZKM verifier UUID (proof_id = 3)
+    /// ZKM verifier UUID (proof_id = 4)
     pub const ZKM_UUID: &str = "84a01f4b-8078-44cf-b463-90ddcd124960";
 
-    /// SP1-Hypercube verifier UUID (proof_id = 4)
+    /// SP1-Hypercube verifier UUID (proof_id = 5)
     pub const SP1_HYPERCUBE_UUID: &str = "9d0bd54d-69f9-4404-8f30-020516a8155d";
 
+    /// Parse a Fallback UUID
+    pub fn fallback() -> Uuid {
+        Uuid::parse_str(FALLBACK_UUID).expect("Valid UUID")
+    }
+
     /// Parse a Brevis UUID
     pub fn brevis() -> Uuid {
         Uuid::parse_str(BREVIS_UUID).expect("Valid UUID")
@@ -134,19 +153,21 @@ impl VerifierStore {
     /// Get the prover UUID corresponding to a proof_id (Ethproofs demo mapping)
     ///
     /// For Ethproofs demo testing, this provides a hardcoded mapping of proof_ids to prover UUIDs:
-    /// - proof_id 0 → brevis (Pico verifier)
-    /// - proof_id 1 → zisk (ZisK verifier)
-    /// - proof_id 2 → zkcloud (ZkCloud verifier)
-    /// - proof_id 3 → zkm (ZKM verifier)
-    /// - proof_id 4 → sp1-hypercube (SP1-Hypercube verifier)
+    /// - proof_id 0 → fallback (Fallback verifier)
+    /// - proof_id 1 → brevis (Pico verifier)
+    /// - proof_id 2 → zisk (ZisK verifier)
+    /// - proof_id 3 → zkcloud (ZkCloud verifier)
+    /// - proof_id 4 → zkm (ZKM verifier)
+    /// - proof_id 5 → sp1-hypercube (SP1-Hypercube verifier)
     pub fn get_prover_uuid_for_proof_id(&self, proof_id: ExecutionProofId) -> Option<Uuid> {
         let id = proof_id.as_u8() as u32;
         match id {
-            0 => Some(ethproofs_ids::brevis()),
-            1 => Some(ethproofs_ids::zisk()),
-            2 => Some(ethproofs_ids::zkcloud()),
-            3 => Some(ethproofs_ids::zkm()),
-            4 => Some(ethproofs_ids::sp1_hypercube()),
+            0 => Some(ethproofs_ids::fallback()),
+            1 => Some(ethproofs_ids::brevis()),
+            2 => Some(ethproofs_ids::zisk()),
+            3 => Some(ethproofs_ids::zkcloud()),
+            4 => Some(ethproofs_ids::zkm()),
+            5 => Some(ethproofs_ids::sp1_hypercube()),
             _ => None,
         }
     }
@@ -157,6 +178,13 @@ impl VerifierStore {
     pub fn with_defaults() -> Self {
         let mut store = Self::new();
 
+        // Register Fallback verifier
+        store.register(
+            ethproofs_ids::fallback(),
+            fallback::FallbackVerifier::name(),
+            fallback::FallbackVerifier::verify,
+        );
+
         // Register Pico verifier for brevis
         store.register(
             ethproofs_ids::brevis(),