Merge f1aef37 into bbd8e76

Author: LeanSerra

Cargo.lock

@@ -9,13 +9,15 @@ ethrex-common.workspace = true
 ethrex-storage.workspace = true
 ethrex-rlp.workspace = true
 ethrex-vm.workspace = true
+ethrex-prover = { path = "../../../crates/l2/prover", default-features = false, optional = true }
+zkvm_interface = { path = "../../../crates/l2/prover/zkvm/interface", default-features = false, optional = true }
 
 serde.workspace = true
 serde_json.workspace = true
 bytes.workspace = true
 hex.workspace = true
 lazy_static.workspace = true
-tokio = { workspace = true , features = ["full"] }
+tokio = { workspace = true, features = ["full"] }
 
 [dev-dependencies]
 datatest-stable = "0.2.9"
@@ -28,6 +30,7 @@ default = ["c-kzg", "blst"]
 blst = ["ethrex-vm/blst"]
 c-kzg = ["ethrex-blockchain/c-kzg"]
 levm = []
+stateless = ["dep:ethrex-prover", "dep:zkvm_interface"]
 
 [[test]]
 name = "cancun"

cmd/ef_tests/blockchain/Cargo.toml

@@ -29,6 +29,9 @@ test-levm: $(SPECTEST_VECTORS_DIR) ## 🧪 Run blockchain tests with LEVM
 test-revm: $(SPECTEST_VECTORS_DIR) ## 🧪 Run blockchain tests with REVM
 	cargo test --release
 
+test-stateless: $(SPECTEST_VECTORS_DIR) ## 🧪 Run blockchain tests with LEVM with stateless execution
+	cargo test --release --features levm,stateless
+
 test: $(SPECTEST_VECTORS_DIR) ## 🧪 Run blockchain tests with both VMs
 	$(MAKE) test-levm
 	$(MAKE) test-revm

cmd/ef_tests/blockchain/Makefile

@@ -11,6 +11,8 @@ use ethrex_common::types::{
 use ethrex_rlp::decode::RLPDecode;
 use ethrex_storage::{EngineType, Store};
 use ethrex_vm::EvmEngine;
+#[cfg(feature = "stateless")]
+use zkvm_interface::io::ProgramInput;
 
 pub fn parse_and_execute(path: &Path, evm: EvmEngine, skipped_tests: Option<&[&str]>) {
     let rt = tokio::runtime::Runtime::new().unwrap();
@@ -64,7 +66,7 @@ pub async fn run_ef_test(test_key: &str, test: &TestUnit, evm: EvmEngine) {
                     "Transaction execution unexpectedly failed on test: {}, with error {}",
                     test_key, error
                 );
-                return;
+                break;
             }
             Ok(_) => {
                 assert!(
@@ -77,7 +79,9 @@ pub async fn run_ef_test(test_key: &str, test: &TestUnit, evm: EvmEngine) {
             }
         }
     }
-    check_poststate_against_db(test_key, test, &store).await
+    check_poststate_against_db(test_key, test, &store).await;
+    #[cfg(feature = "stateless")]
+    re_run_stateless(blockchain, test, genesis_block_header).await;
 }
 
 /// Tests the rlp decoding of a block
@@ -221,3 +225,47 @@ async fn check_poststate_against_db(test_key: &str, test: &TestUnit, db: &Store)
     assert!(last_block.is_some(), "Block hash is not stored in db");
     // State root was alredy validated by `add_block``
 }
+
+#[cfg(feature = "stateless")]
+async fn re_run_stateless(
+    blockchain: Blockchain,
+    test: &TestUnit,
+    genesis_header: CoreBlockHeader,
+) {
+    let blocks = test
+        .blocks
+        .iter()
+        .map(|block_fixture| block_fixture.block().unwrap().clone().into())
+        .collect::<Vec<CoreBlock>>();
+
+    let test_should_fail = test.blocks.iter().any(|t| t.expect_exception.is_some());
+
+    let witness = blockchain
+        .generate_witness_for_blocks(&blocks)
+        .await
+        .unwrap_or_else(|_| {
+            use ethrex_common::types::block_execution_witness::ExecutionWitnessResult;
+            if test_should_fail {
+                ExecutionWitnessResult {
+                    state_trie_nodes: Some(Vec::new()),
+                    storage_trie_nodes: Some(HashMap::new()),
+                    ..Default::default()
+                }
+            } else {
+                panic!("Failed to create witness for a test that should not fail")
+            }
+        });
+
+    let program_input = ProgramInput {
+        blocks,
+        parent_block_header: genesis_header,
+        db: witness,
+        elasticity_multiplier: ethrex_common::types::ELASTICITY_MULTIPLIER,
+    };
+
+    if let Err(e) = ethrex_prover_lib::execute(program_input) {
+        assert!(test_should_fail, "Expected test to succeed failed with {e}")
+    } else {
+        assert!(!test_should_fail, "Expected test to fail succeeded")
+    }
+}

cmd/ef_tests/blockchain/test_runner.rs

@@ -175,7 +175,14 @@ impl Blockchain {
                 .map_err(|_e| ChainError::Custom("Failed to get block hashes".to_string()))?
                 .clone();
             block_hashes.extend(logger_block_hashes);
-
+            // Access all the accounts needed for withdrawals
+            if let Some(withdrawals) = block.body.withdrawals.as_ref() {
+                for withdrawal in withdrawals {
+                    let _ = trie.get(&hash_address(&withdrawal.address)).map_err(|_e| {
+                        ChainError::Custom("Failed to access account from trie".to_string())
+                    });
+                }
+            }
             // Access all the accounts from the initial trie
             // Record all the storage nodes for the initial state
             for (account, keys) in logger

crates/blockchain/blockchain.rs

@@ -394,7 +394,11 @@ impl Trie {
     }
 
     pub fn root_node(&self) -> Result<Option<Node>, TrieError> {
-        self.root.get_node(self.db.as_ref())
+        if self.root.compute_hash().finalize() == *EMPTY_TRIE_HASH {
+            self.root.get_node(self.db.as_ref())
+        } else {
+            Ok(None)
+        }
     }
 
     /// Creates a new Trie based on a temporary InMemory DB

crates/common/trie/trie.rs

@@ -5,7 +5,9 @@ use crate::withdrawals::{get_block_withdrawals, get_withdrawals_merkle_root};
 
 use crate::io::{ProgramInput, ProgramOutput};
 use ethrex_blockchain::error::ChainError;
-use ethrex_blockchain::{validate_block, validate_gas_used};
+use ethrex_blockchain::{
+    validate_block, validate_gas_used, validate_receipts_root, validate_requests_hash,
+};
 use ethrex_common::{
     types::{block_execution_witness::ExecutionWitnessResult, Block, BlockHeader},
     H256,
@@ -22,6 +24,10 @@ pub enum StatelessExecutionError {
     BlockValidationError(ChainError),
     #[error("Gas validation error: {0}")]
     GasValidationError(ChainError),
+    #[error("Withdrawals validation error: {0}")]
+    RequestsRootValidationError(ChainError),
+    #[error("Receipts validation error: {0}")]
+    ReceiptsRootValidationError(ChainError),
     #[error("EVM error: {0}")]
     EvmError(EvmError),
     #[cfg(feature = "l2")]
@@ -190,6 +196,11 @@ fn execute_stateless(
 
         validate_gas_used(&receipts, &block.header)
             .map_err(StatelessExecutionError::GasValidationError)?;
+        validate_receipts_root(&block.header, &receipts)
+            .map_err(StatelessExecutionError::ReceiptsRootValidationError)?;
+        // validate_requests_hash doesn't do anything for l2 blocks as this verifies l1 requests (withdrawals, deposits and consolidations)
+        validate_requests_hash(&block.header, &db.chain_config, &result.requests)
+            .map_err(StatelessExecutionError::RequestsRootValidationError)?;
         parent_header = &block.header;
         acc_receipts.push(receipts);
     }