fix: validation on fallback proof id

Author: fbwoolf

consensus/types/src/execution_proof_id.rs

@@ -76,12 +76,12 @@ impl TreeHash for ExecutionProofId {
 impl ExecutionProofId {
     /// Creates a new ExecutionProofId if the value is valid
     pub fn new(id: u8) -> Result<Self, String> {
-        if id < EXECUTION_PROOF_TYPE_COUNT {
+        if id < EXECUTION_PROOF_TYPE_COUNT || id == FALLBACK_EXECUTION_PROOF_ID {
             Ok(Self(id))
         } else {
             Err(format!(
-                "Invalid ExecutionProofId: {}, must be < {}",
-                id, EXECUTION_PROOF_TYPE_COUNT
+                "Invalid ExecutionProofId: {}, must be < {} or {}",
+                id, EXECUTION_PROOF_TYPE_COUNT, FALLBACK_EXECUTION_PROOF_ID
             ))
         }
     }
@@ -157,4 +157,23 @@ 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/ethproofs_demo.rs

@@ -60,7 +60,7 @@ pub async fn fetch_proof_from_ethproofs(
     block_hash: types::ExecutionBlockHash,
     cluster: String,
 ) -> Result<Vec<Ethproof>, String> {
-    const MAX_WAIT_TIME_SECS: u64 = 30;
+    const MAX_WAIT_TIME_SECS: u64 = 15;
     const INITIAL_DELAY_MS: u64 = 100;
     const MAX_DELAY_MS: u64 = 5000;
 
@@ -165,6 +165,8 @@ 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() {
         info!(
+            slot = %proof.slot,
+            block_hash = %proof.block_hash,
             proof_id = %proof.proof_id,
             "[Ethproofs] Fallback proof detected, skipping verification"
         );
@@ -188,6 +190,8 @@ pub fn validate_proof(proof: &ExecutionProof) -> bool {
             match store.get(&prover_uuid) {
                 Some(vk) => {
                     info!(
+                        slot = %proof.slot,
+                        block_hash = %proof.block_hash,
                         prover_id = %prover_uuid,
                         vk_size = vk.size(),
                         proof_size = proof.proof_data.len(),
@@ -198,6 +202,8 @@ pub fn validate_proof(proof: &ExecutionProof) -> bool {
                     match VERIFIER_STORE.get(&prover_uuid) {
                         Some(verifier_entry) => {
                             info!(
+                                slot = %proof.slot,
+                                block_hash = %proof.block_hash,
                                 prover_id = %prover_uuid,
                                 verifier = verifier_entry.name,
                                 "[Ethproofs] Found verifier, starting verification"
@@ -207,6 +213,8 @@ pub fn validate_proof(proof: &ExecutionProof) -> bool {
                             match (verifier_entry.verify_fn)(&proof.proof_data, &vk.vk) {
                                 Ok(result) => {
                                     info!(
+                                        slot = %proof.slot,
+                                        block_hash = %proof.block_hash,
                                         prover_id = %prover_uuid,
                                         verification_result = result,
                                         "[Ethproofs] Verification completed"
@@ -215,6 +223,8 @@ pub fn validate_proof(proof: &ExecutionProof) -> bool {
                                 }
                                 Err(e) => {
                                     warn!(
+                                        slot = %proof.slot,
+                                        block_hash = %proof.block_hash,
                                         prover_id = %prover_uuid,
                                         error = %e,
                                         "[Ethproofs] Verification failed with error"
@@ -225,6 +235,8 @@ pub fn validate_proof(proof: &ExecutionProof) -> bool {
                         }
                         None => {
                             warn!(
+                                slot = %proof.slot,
+                                block_hash = %proof.block_hash,
                                 prover_id = %prover_uuid,
                                 "[Ethproofs] No verifier registered for this prover, cannot verify proof"
                             );
@@ -234,6 +246,8 @@ pub fn validate_proof(proof: &ExecutionProof) -> bool {
                 }
                 None => {
                     warn!(
+                        slot = %proof.slot,
+                        block_hash = %proof.block_hash,
                         prover_id = %prover_uuid,
                         "[Ethproofs] No verification key found for this prover"
                     );