fix(l1): close EIP-8025 stateless witness validation gaps (re-enable 9 zkevm tests)

crates/blockchain/blockchain.rs

@@ -1436,6 +1436,9 @@ impl Blockchain {
 
             block_headers_bytes.push(current_header.encode_to_vec());
         }
+        // EELS expects ascending order; we walked the chain backward, so reverse.
+        // Ref: https://github.com/ethereum/execution-specs/blob/projects/zkevm/src/ethereum/forks/amsterdam/stateless.py#L171-L191
+        block_headers_bytes.reverse();
 
         // Get initial state trie root and embed the rest of the trie into it
         let nodes: BTreeMap<H256, Node> = used_trie_nodes
@@ -1670,6 +1673,9 @@ impl Blockchain {
 
             block_headers_bytes.push(current_header.encode_to_vec());
         }
+        // EELS expects ascending order; we walked the chain backward, so reverse.
+        // Ref: https://github.com/ethereum/execution-specs/blob/projects/zkevm/src/ethereum/forks/amsterdam/stateless.py#L171-L191
+        block_headers_bytes.reverse();
 
         // Get initial state trie root and embed the rest of the trie into it
         let nodes: BTreeMap<H256, Node> = used_trie_nodes

crates/common/types/block_execution_witness.rs

@@ -151,36 +151,31 @@ impl RpcExecutionWitness {
             ));
         }
 
-        let mut initial_state_root = None;
-
-        for h in &self.headers {
-            let header = BlockHeader::decode(h)?;
-            if header.number == first_block_number - 1 {
-                initial_state_root = Some(header.state_root);
-                break;
-            }
-        }
-
-        let initial_state_root = initial_state_root.ok_or_else(|| {
-            GuestProgramStateError::Custom(format!(
-                "header for block {} not found",
-                first_block_number - 1
-            ))
-        })?;
+        // Skip headers that fail to decode, then pick parent by number.
+        let initial_state_root = self
+            .headers
+            .iter()
+            .filter_map(|h| BlockHeader::decode(h).ok())
+            .find(|header| header.number == first_block_number - 1)
+            .map(|header| header.state_root)
+            .ok_or_else(|| {
+                GuestProgramStateError::Custom(format!(
+                    "header for block {} not found",
+                    first_block_number - 1
+                ))
+            })?;
 
+        // EIP-8025: drop entries that don't decode. They can't be looked up by
+        // hash anyway; if execution needs them, the trie walk fails there.
+        // Ref: https://github.com/ethereum/execution-specs/blob/projects/zkevm/src/ethereum/forks/amsterdam/witness_state.py#L37-L42
         let nodes: BTreeMap<H256, Node> = self
             .state
             .into_iter()
             .filter_map(|b| {
-                if b == Bytes::from_static(&[0x80]) {
-                    // other implementations of debug_executionWitness allow for a `Null` node,
-                    // which would fail to decode in ours
-                    return None;
-                }
-                let hash = keccak(&b);
-                Some(Node::decode(&b).map(|node| (hash, node)))
+                let node = Node::decode(&b).ok()?;
+                Some((keccak(&b), node))
             })
-            .collect::<Result<_, RLPDecodeError>>()?;
+            .collect();
 
         // get state trie root and embed the rest of the trie into it
         let state_trie_root = if let NodeRef::Node(state_trie_root, _) =
@@ -325,17 +320,28 @@ impl GuestProgramState {
         value: ExecutionWitness,
         crypto: &dyn Crypto,
     ) -> Result<Self, GuestProgramStateError> {
-        let block_headers: BTreeMap<u64, BlockHeader> = value
-            .block_headers_bytes
-            .into_iter()
-            .map(|bytes| BlockHeader::decode(bytes.as_ref()))
-            .collect::<Result<Vec<_>, _>>()
-            .map_err(|e| {
-                GuestProgramStateError::Custom(format!("Failed to decode block headers: {}", e))
-            })?
-            .into_iter()
-            .map(|header| (header.number, header))
-            .collect();
+        // EIP-8025: headers must form a contiguous chain in list order (each
+        // `parent_hash` matches keccak of the previous header bytes). Reordered
+        // or fragmented chains are invalid even if by-number lookup would resolve.
+        // Ref: https://github.com/ethereum/execution-specs/blob/projects/zkevm/src/ethereum/forks/amsterdam/stateless.py#L171-L191
+        let mut block_headers: BTreeMap<u64, BlockHeader> = BTreeMap::new();
+        let mut prev_hash: Option<H256> = None;
+        for bytes in &value.block_headers_bytes {
+            let Ok(header) = BlockHeader::decode(bytes.as_ref()) else {
+                // Malformed entry is a chain break; the next parent_hash check fails.
+                prev_hash = None;
+                continue;
+            };
+            if let Some(expected_parent) = prev_hash
+                && header.parent_hash != expected_parent
+            {
+                return Err(GuestProgramStateError::Custom(
+                    "witness headers are not contiguous".to_string(),
+                ));
+            }
+            prev_hash = Some(H256(crypto.keccak256(bytes)));
+            block_headers.insert(header.number, header);
+        }
 
         let parent_number =
             value
@@ -588,28 +594,22 @@ impl GuestProgramState {
         Ok(self.chain_config)
     }
 
-    /// Retrieves the account code for a specific account.
-    /// Returns an Err if the code is not found.
+    /// Retrieves bytecode by code hash. Errors if missing — EIP-8025.
+    ///
+    /// Ref: https://github.com/ethereum/execution-specs/blob/projects/zkevm/src/ethereum/forks/amsterdam/witness_state.py#L204-L212
     pub fn get_account_code(&self, code_hash: H256) -> Result<Code, GuestProgramStateError> {
         if code_hash == *EMPTY_KECCACK_HASH {
             return Ok(Code::default());
         }
-        match self.codes_hashed.get(&code_hash) {
-            Some(code) => Ok(code.clone()),
-            None => {
-                // We do this because what usually happens is that the Witness doesn't have the code we asked for but it is because it isn't relevant for that particular case.
-                // In client implementations there are differences and it's natural for some clients to access more/less information in some edge cases.
-                // Sidenote: logger doesn't work inside SP1, that's why we use println!
-                println!(
-                    "Missing bytecode for hash {} in witness. Defaulting to empty code.", // If there's a state root mismatch and this prints we have to see if it's the cause or not.
-                    hex::encode(code_hash)
-                );
-                Ok(Code::default())
-            }
-        }
+        self.codes_hashed.get(&code_hash).cloned().ok_or_else(|| {
+            GuestProgramStateError::Database(format!(
+                "missing bytecode for hash {} in witness",
+                hex::encode(code_hash)
+            ))
+        })
     }
 
-    /// Retrieves code metadata (length) for a specific code hash.
+    /// Code length by hash. Errors on miss, like `get_account_code`.
     /// This is an optimized path for EXTCODESIZE opcode.
     pub fn get_code_metadata(
         &self,
@@ -620,19 +620,17 @@ impl GuestProgramState {
         if code_hash == *EMPTY_KECCACK_HASH {
             return Ok(CodeMetadata { length: 0 });
         }
-        match self.codes_hashed.get(&code_hash) {
-            Some(code) => Ok(CodeMetadata {
+        self.codes_hashed
+            .get(&code_hash)
+            .map(|code| CodeMetadata {
                 length: code.bytecode.len() as u64,
-            }),
-            None => {
-                // Same as get_account_code - default to empty for missing bytecode
-                println!(
-                    "Missing bytecode for hash {} in witness. Defaulting to empty code metadata.",
+            })
+            .ok_or_else(|| {
+                GuestProgramStateError::Database(format!(
+                    "missing bytecode for hash {} in witness",
                     hex::encode(code_hash)
-                );
-                Ok(CodeMetadata { length: 0 })
-            }
-        }
+                ))
+            })
     }
 
     /// When executing multiple blocks in the L2 it happens that the headers in block_headers correspond to the same block headers that we have in the blocks array. The main goal is to hash these only once and set them in both places.

tooling/ef_tests/blockchain/.fixtures_url_zkevm

@@ -1 +1 @@
-https://github.com/ethereum/execution-spec-tests/releases/download/zkevm%40v0.3.0/fixtures_zkevm.tar.gz
+https://github.com/ethereum/execution-spec-tests/releases/download/zkevm%40v0.3.3/fixtures_zkevm.tar.gz

tooling/ef_tests/blockchain/Makefile

@@ -50,8 +50,8 @@ amsterdam-vectors: $(AMSTERDAM_ARTIFACT) $(SPECTEST_VECTORS_DIR)
 $(ZKEVM_ARTIFACT): $(ZKEVM_FIXTURES_FILE)
 	curl -L -o $(ZKEVM_ARTIFACT) $(ZKEVM_URL)
 
-zkevm-vectors: $(ZKEVM_ARTIFACT) $(SPECTEST_VECTORS_DIR)
-	tar -xzf $(ZKEVM_ARTIFACT) --strip-components=2 -C $(SPECTEST_VECTORS_DIR) fixtures/blockchain_tests/for_amsterdam/amsterdam/eip8025_optional_proofs
+zkevm-vectors: $(ZKEVM_ARTIFACT) $(SPECTEST_VECTORS_DIR) amsterdam-vectors
+	tar -xzf $(ZKEVM_ARTIFACT) --strip-components=2 -C $(SPECTEST_VECTORS_DIR) fixtures/blockchain_tests/for_amsterdam
 
 help: ## 📚 Show help for each of the Makefile recipes
 	@grep -E '^[a-zA-Z0-9_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'

tooling/ef_tests/blockchain/test_runner.rs

@@ -551,32 +551,60 @@ async fn run_stateless_from_fixture(
             continue;
         };
 
+        // zkevm fixtures encode the expected stateless outcome in `statelessOutputBytes`
+        // as `new_payload_request_root (32 bytes) ++ valid (1 byte) ++ trailing padding`.
+        // When the fixture signals `valid = false` the witness is deliberately incomplete
+        // and the stateless path must reject it; absent bytes means "expected to succeed".
+        let expected_valid = block_data
+            .stateless_output_bytes
+            .as_deref()
+            .and_then(parse_expected_valid_flag)
+            .unwrap_or(true);
+
         let block: CoreBlock = block_data.clone().into();
         let block_number = block.header.number;
 
-        let rpc_witness: RpcExecutionWitness = serde_json::from_value(witness_json.clone())
-            .map_err(|e| {
-                format!("Failed to parse executionWitness for block {block_number}: {e}")
-            })?;
-
-        let execution_witness = rpc_witness
-            .into_execution_witness(*chain_config, block_number)
-            .map_err(|e| format!("Witness conversion failed for block {block_number}: {e}"))?;
-
-        let program_input = ProgramInput::new(vec![block], execution_witness);
-
-        let execute_result = match backend_type {
-            BackendType::Exec => ExecBackend::new().execute(program_input),
-            #[cfg(feature = "sp1")]
-            BackendType::SP1 => Sp1Backend::new().execute(program_input),
-        };
-
-        if let Err(e) = execute_result {
-            return Err(format!(
-                "Stateless execution from fixture failed for {test_key} block {block_number}: {e}"
-            ));
+        let stateless_outcome: Result<(), String> = (|| {
+            let rpc_witness: RpcExecutionWitness = serde_json::from_value(witness_json.clone())
+                .map_err(|e| format!("executionWitness parse: {e}"))?;
+            let execution_witness = rpc_witness
+                .into_execution_witness(*chain_config, block_number)
+                .map_err(|e| format!("witness conversion: {e}"))?;
+            let program_input = ProgramInput::new(vec![block.clone()], execution_witness);
+            let res = match backend_type {
+                BackendType::Exec => ExecBackend::new().execute(program_input),
+                #[cfg(feature = "sp1")]
+                BackendType::SP1 => Sp1Backend::new().execute(program_input),
+            };
+            res.map(|_| ()).map_err(|e| format!("execution: {e}"))
+        })();
+
+        match (expected_valid, stateless_outcome) {
+            (true, Ok(())) | (false, Err(_)) => {}
+            (true, Err(e)) => {
+                return Err(format!(
+                    "Stateless execution from fixture failed for {test_key} block {block_number}: {e}"
+                ));
+            }
+            (false, Ok(())) => {
+                return Err(format!(
+                    "Stateless execution from fixture succeeded for {test_key} block \
+                     {block_number} but fixture expected it to fail (invalid executionWitness)"
+                ));
+            }
         }
     }
 
     Ok(())
 }
+
+/// Extract the `valid` byte from a zkevm-fixture `statelessOutputBytes` hex string.
+///
+/// The output encoding is `new_payload_request_root (32 bytes) ++ valid (1 byte) ++ padding`,
+/// so byte index 32 carries the validity marker.
+#[cfg(feature = "stateless")]
+fn parse_expected_valid_flag(hex: &str) -> Option<bool> {
+    let trimmed = hex.strip_prefix("0x").unwrap_or(hex);
+    let byte_hex = trimmed.get(64..66)?;
+    u8::from_str_radix(byte_hex, 16).ok().map(|b| b != 0)
+}