diff --git a/crates/vm/levm/src/vm.rs b/crates/vm/levm/src/vm.rs index df15dbc1d09..0548b3ee889 100644 --- a/crates/vm/levm/src/vm.rs +++ b/crates/vm/levm/src/vm.rs @@ -30,6 +30,7 @@ use rustc_hash::{FxHashMap, FxHashSet}; use std::{ cell::{OnceCell, RefCell}, collections::{BTreeMap, BTreeSet}, + io::Write, mem, rc::Rc, }; @@ -435,6 +436,8 @@ pub struct VM<'a> { pub storage_original_values: FxHashMap>, /// Call tracer for execution tracing. pub tracer: LevmCallTracer, + /// EIP-3155: When true, emit per-opcode JSON traces to stderr. + pub eip3155_trace: bool, /// Debug mode for development diagnostics. pub debug_mode: DebugMode, /// Pool of reusable stacks to reduce allocations. @@ -481,6 +484,7 @@ impl<'a> VM<'a> { hooks: get_hooks(&vm_type), storage_original_values: FxHashMap::default(), tracer, + eip3155_trace: false, debug_mode: DebugMode::disabled(), stack_pool: Vec::new(), vm_type, @@ -648,6 +652,25 @@ impl<'a> VM<'a> { loop { let opcode = self.current_call_frame.next_opcode(); + + // EIP-3155: capture pre-execution state for trace output. + #[allow(clippy::as_conversions)] + let trace_snapshot = if self.eip3155_trace { + let pc = self.current_call_frame.pc; + let gas = self.current_call_frame.gas_remaining; + let depth = self.current_call_frame.depth + 1; // EIP-3155 depth is 1-indexed + let mem_size = self.current_call_frame.memory.len(); + let stack: Vec = { + let s = &self.current_call_frame.stack; + let mut v = s.values[s.offset..].to_vec(); + v.reverse(); // EIP-3155: bottom-to-top order + v + }; + Some((pc, gas, depth, mem_size, stack)) + } else { + None + }; + self.advance_pc(1)?; #[cfg(feature = "perf_opcode_timings")] @@ -657,6 +680,14 @@ impl<'a> VM<'a> { #[allow(clippy::indexing_slicing, clippy::as_conversions)] let op_result = self.opcode_table[opcode as usize].call(self, &mut error); + // EIP-3155: emit trace line to stderr after opcode execution. + #[allow(clippy::as_conversions)] + if let Some((pc, gas_before, depth, mem_size, stack)) = trace_snapshot { + let gas_after = self.current_call_frame.gas_remaining; + let gas_cost = gas_before.saturating_sub(gas_after); + eip3155_emit(pc, opcode, gas_before, gas_cost, &stack, depth, mem_size); + } + #[cfg(feature = "perf_opcode_timings")] { let time = opcode_time_start.elapsed(); @@ -813,3 +844,36 @@ impl Substate { Ok(substate) } } + +/// Emit a single EIP-3155 trace line to stderr. +/// +/// Format: `{"pc":,"op":,"gas":"0x","gasCost":"0x","stack":[...],"depth":,"memSize":}` +#[allow(clippy::as_conversions)] +fn eip3155_emit( + pc: usize, + opcode: u8, + gas_before: i64, + gas_cost: i64, + stack: &[U256], + depth: usize, + mem_size: usize, +) { + let mut stderr = std::io::stderr().lock(); + + // Build the JSON manually to avoid pulling in serde for the VM crate's hot path. + let _ = write!( + stderr, + r#"{{"pc":{},"op":{},"gas":"0x{:x}","gasCost":"0x{:x}","stack":["#, + pc, + opcode, + gas_before.max(0) as u64, + gas_cost.max(0) as u64, + ); + for (i, val) in stack.iter().enumerate() { + if i > 0 { + let _ = write!(stderr, ","); + } + let _ = write!(stderr, "\"0x{:x}\"", val); + } + let _ = writeln!(stderr, r#"],"depth":{},"memSize":{}}}"#, depth, mem_size); +} diff --git a/tooling/Cargo.lock b/tooling/Cargo.lock index 25b2b35537a..ed6131244d3 100644 --- a/tooling/Cargo.lock +++ b/tooling/Cargo.lock @@ -2899,6 +2899,41 @@ dependencies = [ "tokio", ] +[[package]] +name = "ef_tests-blocktest" +version = "4.0.0" +dependencies = [ + "clap 4.5.54", + "ef_tests-blockchain", + "rayon", + "regex", + "serde", + "serde_json", +] + +[[package]] +name = "ef_tests-enginetest" +version = "4.0.0" +dependencies = [ + "bytes", + "clap 4.5.54", + "ef_tests-blockchain", + "ethrex-blockchain", + "ethrex-common 9.0.0", + "ethrex-crypto", + "ethrex-p2p", + "ethrex-rlp 9.0.0", + "ethrex-rpc", + "ethrex-storage 9.0.0", + "ethrex-vm", + "hex", + "rayon", + "regex", + "serde", + "serde_json", + "tokio", +] + [[package]] name = "ef_tests-state" version = "0.1.0" @@ -2927,6 +2962,23 @@ dependencies = [ "tokio", ] +[[package]] +name = "ef_tests-statetest" +version = "4.0.0" +dependencies = [ + "clap 4.5.54", + "ethrex-common 9.0.0", + "ethrex-crypto", + "ethrex-levm", + "ethrex-rlp 9.0.0", + "rayon", + "regex", + "rustc-hash 2.1.1", + "secp256k1 0.30.0", + "serde", + "serde_json", +] + [[package]] name = "ef_tests-statev2" version = "4.0.0" diff --git a/tooling/Cargo.toml b/tooling/Cargo.toml index 0f8a310280e..5906b6907c5 100644 --- a/tooling/Cargo.toml +++ b/tooling/Cargo.toml @@ -1,8 +1,11 @@ [workspace] members = [ "archive_sync", + "ef_tests/blocktest", "ef_tests/blockchain", + "ef_tests/enginetest", "ef_tests/state", + "ef_tests/statetest", "ef_tests/state_v2", "hive_report", "load_test", diff --git a/tooling/ef_tests/blocktest/Cargo.toml b/tooling/ef_tests/blocktest/Cargo.toml new file mode 100644 index 00000000000..b71fbf86f48 --- /dev/null +++ b/tooling/ef_tests/blocktest/Cargo.toml @@ -0,0 +1,24 @@ +[package] +name = "ef_tests-blocktest" +version.workspace = true +edition.workspace = true +authors.workspace = true +documentation.workspace = true +license.workspace = true + +[dependencies] +ef_tests-blockchain = { path = "../blockchain" } + +serde.workspace = true +serde_json.workspace = true +clap.workspace = true +rayon.workspace = true +regex = "1" + +[features] +default = ["c-kzg"] +c-kzg = ["ef_tests-blockchain/c-kzg"] + +[[bin]] +name = "ef_tests-blocktest" +path = "src/main.rs" diff --git a/tooling/ef_tests/blocktest/src/main.rs b/tooling/ef_tests/blocktest/src/main.rs new file mode 100644 index 00000000000..0cbb215e69e --- /dev/null +++ b/tooling/ef_tests/blocktest/src/main.rs @@ -0,0 +1,194 @@ +use std::path::PathBuf; +use std::sync::atomic::{AtomicUsize, Ordering}; +use std::time::Instant; + +use clap::Parser; +use rayon::iter::{IntoParallelIterator, ParallelIterator}; +use regex::Regex; +use serde::Serialize; + +use ef_tests_blockchain::test_runner::parse_and_execute; + +/// Fast blockchain test runner for ethrex -- CLI binary with parallel execution. +#[derive(Parser, Debug)] +#[command(name = "ef_tests-blockfast")] +struct Cli { + /// Path to a blockchain test directory or a single .json file. + #[arg(short, long, value_name = "PATH")] + path: PathBuf, + + /// Number of parallel worker threads. + #[arg(short, long, default_value = "1")] + workers: usize, + + /// Regex filter: only run tests whose file path matches this pattern. + #[arg(long)] + run: Option, + + /// Output results as JSON array to stdout. + #[arg(long)] + json: bool, +} + +/// Known tests to skip (same as SKIPPED_BASE in blockchain/tests/all.rs). +const SKIPPED: &[&str] = &[ + // Skip because they take too long to run, but they pass + "static_Call50000_sha256", + "CALLBlake2f_MaxRounds", + "loopMul", + // Skip because it tries to deserialize number > U256::MAX + "ValueOverflowParis", + // Skip because it's a "Create" Blob Transaction, which doesn't actually exist. + "createBlobhashTx", +]; + +#[derive(Serialize)] +struct TestResult { + name: String, + pass: bool, + #[serde(skip_serializing_if = "Option::is_none")] + error: Option, +} + +fn main() { + let cli = Cli::parse(); + let start = Instant::now(); + + // Discover all .json fixture files. + eprintln!("Scanning for fixture files in {:?} ...", cli.path); + let mut files = if cli.path.is_file() { + vec![cli.path.clone()] + } else { + collect_json_files(&cli.path) + }; + + // Apply skip list: remove files whose name contains a skipped pattern. + files.retain(|f| { + let name = f.file_name().unwrap_or_default().to_string_lossy(); + !SKIPPED.iter().any(|s| name.contains(s)) + }); + + // Apply --run regex filter on the full file path. + if let Some(ref pattern) = cli.run { + let re = Regex::new(pattern).unwrap_or_else(|e| { + eprintln!("Invalid --run regex '{}': {}", pattern, e); + std::process::exit(1); + }); + files.retain(|f| re.is_match(&f.to_string_lossy())); + } + + let parse_time = start.elapsed(); + eprintln!( + "Found {} fixture files in {:.2}s", + files.len(), + parse_time.as_secs_f64(), + ); + + // Build rayon thread pool. + let pool = rayon::ThreadPoolBuilder::new() + .num_threads(cli.workers) + .build() + .expect("failed to build thread pool"); + + let passing = AtomicUsize::new(0); + let failing = AtomicUsize::new(0); + + let exec_start = Instant::now(); + + let results: Vec = pool.install(|| { + files + .into_par_iter() + .map(|file| { + let name = file + .file_name() + .unwrap_or_default() + .to_string_lossy() + .to_string(); + + // parse_and_execute handles: + // - JSON parsing + // - skipping pre-Merge forks + // - building store, executing blocks, verifying post-state + // - returning Ok(()) or Err with combined failure messages + let result = parse_and_execute(&file, Some(SKIPPED), None); + + match result { + Ok(()) => { + passing.fetch_add(1, Ordering::Relaxed); + TestResult { + name, + pass: true, + error: None, + } + } + Err(e) => { + failing.fetch_add(1, Ordering::Relaxed); + TestResult { + name, + pass: false, + error: Some(e.to_string()), + } + } + } + }) + .collect() + }); + + let exec_time = exec_start.elapsed(); + let total = results.len(); + let passed = passing.load(Ordering::Relaxed); + let failed = failing.load(Ordering::Relaxed); + + if cli.json { + println!( + "{}", + serde_json::to_string_pretty(&results).unwrap() + ); + } else { + // Print failures to stderr. + for r in &results { + if !r.pass { + eprintln!( + "FAIL: {} -- {}", + r.name, + r.error.as_deref().unwrap_or("unknown"), + ); + } + } + } + + eprintln!( + "\nTotal: {} | Passed: {} | Failed: {} | Time: {:.2}s (scan: {:.2}s, exec: {:.2}s)", + total, + passed, + failed, + start.elapsed().as_secs_f64(), + parse_time.as_secs_f64(), + exec_time.as_secs_f64(), + ); + + if failed > 0 { + std::process::exit(1); + } +} + +/// Recursively collect all .json files under a directory. +fn collect_json_files(dir: &PathBuf) -> Vec { + let mut result = Vec::new(); + let entries = match std::fs::read_dir(dir) { + Ok(rd) => rd, + Err(e) => { + eprintln!("Cannot read directory {:?}: {}", dir, e); + return result; + } + }; + for entry in entries.flatten() { + let path = entry.path(); + if path.is_dir() { + result.extend(collect_json_files(&path)); + } else if path.extension().is_some_and(|ext| ext == "json") { + result.push(path); + } + } + result +} diff --git a/tooling/ef_tests/enginetest/Cargo.toml b/tooling/ef_tests/enginetest/Cargo.toml new file mode 100644 index 00000000000..be9ea8fdfa9 --- /dev/null +++ b/tooling/ef_tests/enginetest/Cargo.toml @@ -0,0 +1,36 @@ +[package] +name = "ef_tests-enginetest" +version.workspace = true +edition.workspace = true +authors.workspace = true +documentation.workspace = true +license.workspace = true + +[dependencies] +ef_tests-blockchain = { path = "../blockchain" } + +ethrex-blockchain.workspace = true +ethrex-common.workspace = true +ethrex-crypto.workspace = true +ethrex-p2p.workspace = true +ethrex-rpc.workspace = true +ethrex-storage.workspace = true +ethrex-vm.workspace = true +ethrex-rlp.workspace = true + +serde = { workspace = true, features = ["derive"] } +serde_json.workspace = true +bytes.workspace = true +hex.workspace = true +clap.workspace = true +rayon.workspace = true +regex = "1" +tokio = { workspace = true, features = ["full"] } + +[features] +default = ["c-kzg"] +c-kzg = ["ef_tests-blockchain/c-kzg"] + +[[bin]] +name = "ef_tests-enginetest" +path = "src/main.rs" diff --git a/tooling/ef_tests/enginetest/src/main.rs b/tooling/ef_tests/enginetest/src/main.rs new file mode 100644 index 00000000000..a0cf62a451a --- /dev/null +++ b/tooling/ef_tests/enginetest/src/main.rs @@ -0,0 +1,272 @@ +#[allow(dead_code)] +mod runner; +#[allow(dead_code)] +mod types; + +use std::path::PathBuf; +use std::sync::atomic::{AtomicUsize, Ordering}; +use std::time::Instant; + +use clap::Parser; +use rayon::iter::{IntoParallelIterator, ParallelIterator}; +use regex::Regex; +use runner::TestResult; +use types::EngineTestFile; + +use ef_tests_blockchain::fork::Fork; + +/// Engine test runner for ethrex -- runs blockchain_test_engine +/// fixtures through the real Engine API execution path. +#[derive(Parser, Debug)] +#[command(name = "ef_tests-enginetest")] +struct Cli { + /// Path to a blockchain_tests_engine directory or a single + /// .json file. + #[arg(short, long, value_name = "PATH")] + path: PathBuf, + + /// Number of parallel worker threads. + #[arg(short, long, default_value = "1")] + workers: usize, + + /// Regex filter: only run tests whose name matches this pattern. + #[arg(long)] + run: Option, + + /// Output results as JSON array to stdout. + #[arg(long)] + json: bool, +} + +/// Tests to skip. +const SKIPPED: &[&str] = &[ + // Too slow but pass + "static_Call50000_sha256", + "CALLBlake2f_MaxRounds", + "loopMul", + // Deserialize error: number > U256::MAX + "ValueOverflowParis", + // Create Blob Transaction (invalid) + "createBlobhashTx", +]; + +fn main() { + let cli = Cli::parse(); + let start = Instant::now(); + + eprintln!( + "Scanning for engine test fixtures in {:?} ...", + cli.path + ); + + let mut files = if cli.path.is_file() { + vec![cli.path.clone()] + } else { + collect_json_files(&cli.path) + }; + + // Apply skip list + files.retain(|f| { + let name = + f.file_name().unwrap_or_default().to_string_lossy(); + !SKIPPED.iter().any(|s| name.contains(s)) + }); + + // Apply --run regex filter + if let Some(ref pattern) = cli.run { + let re = Regex::new(pattern).unwrap_or_else(|e| { + eprintln!("Invalid --run regex '{pattern}': {e}"); + std::process::exit(1); + }); + files.retain(|f| re.is_match(&f.to_string_lossy())); + } + + let scan_time = start.elapsed(); + eprintln!( + "Found {} fixture files in {:.2}s", + files.len(), + scan_time.as_secs_f64(), + ); + + // Build rayon thread pool + let pool = rayon::ThreadPoolBuilder::new() + .num_threads(cli.workers) + .build() + .expect("failed to build thread pool"); + + let passing = AtomicUsize::new(0); + let failing = AtomicUsize::new(0); + + let exec_start = Instant::now(); + + let results: Vec = pool.install(|| { + files + .into_par_iter() + .flat_map(|file| { + let data = match std::fs::read(&file) { + Ok(d) => d, + Err(e) => { + eprintln!( + "Cannot read {:?}: {e}", + file + ); + return vec![TestResult { + name: file + .to_string_lossy() + .to_string(), + pass: false, + error: Some(format!( + "read error: {e}" + )), + }]; + } + }; + + let test_map: EngineTestFile = + match serde_json::from_slice(&data) { + Ok(m) => m, + Err(e) => { + eprintln!( + "JSON parse error in {:?}: {e}", + file + ); + return vec![TestResult { + name: file + .to_string_lossy() + .to_string(), + pass: false, + error: Some(format!( + "parse error: {e}" + )), + }]; + } + }; + + let rt = + tokio::runtime::Runtime::new().unwrap(); + + test_map + .into_iter() + .map(|(test_name, test)| { + // Skip pre-Merge forks + if test.network < Fork::Merge { + return TestResult { + name: test_name, + pass: true, + error: None, + }; + } + + // Skip tests whose names match the + // skip list + if SKIPPED.iter().any(|s| { + test_name.contains(s) + }) { + return TestResult { + name: test_name, + pass: true, + error: None, + }; + } + + let result = rt.block_on( + runner::run_engine_test( + &test_name, + &test, + ), + ); + + match result { + Ok(()) => { + passing.fetch_add( + 1, + Ordering::Relaxed, + ); + TestResult { + name: test_name, + pass: true, + error: None, + } + } + Err(e) => { + failing.fetch_add( + 1, + Ordering::Relaxed, + ); + TestResult { + name: test_name, + pass: false, + error: Some(e), + } + } + } + }) + .collect::>() + }) + .collect() + }); + + let exec_time = exec_start.elapsed(); + let total = results.len(); + let passed = passing.load(Ordering::Relaxed); + let failed = failing.load(Ordering::Relaxed); + + if cli.json { + println!( + "{}", + serde_json::to_string_pretty(&results).unwrap() + ); + } else { + for r in &results { + if !r.pass { + eprintln!( + "FAIL: {} -- {}", + r.name, + r.error.as_deref().unwrap_or("unknown"), + ); + } + } + } + + eprintln!( + "\nTotal: {} | Passed: {} | Failed: {} | \ + Time: {:.2}s (scan: {:.2}s, exec: {:.2}s)", + total, + passed, + failed, + start.elapsed().as_secs_f64(), + scan_time.as_secs_f64(), + exec_time.as_secs_f64(), + ); + + if failed > 0 { + std::process::exit(1); + } +} + +/// Recursively collect all .json files under a directory. +fn collect_json_files(dir: &PathBuf) -> Vec { + let mut result = Vec::new(); + let entries = match std::fs::read_dir(dir) { + Ok(rd) => rd, + Err(e) => { + eprintln!( + "Cannot read directory {:?}: {e}", + dir + ); + return result; + } + }; + for entry in entries.flatten() { + let path = entry.path(); + if path.is_dir() { + result.extend(collect_json_files(&path)); + } else if path + .extension() + .is_some_and(|ext| ext == "json") + { + result.push(path); + } + } + result +} diff --git a/tooling/ef_tests/enginetest/src/runner.rs b/tooling/ef_tests/enginetest/src/runner.rs new file mode 100644 index 00000000000..1d66a78594b --- /dev/null +++ b/tooling/ef_tests/enginetest/src/runner.rs @@ -0,0 +1,492 @@ +use std::sync::Arc; + +use ethrex_blockchain::Blockchain; +use ethrex_common::{ + H256, + constants::EMPTY_KECCACK_HASH, + types::{Account as CoreAccount, DEFAULT_BUILDER_GAS_CEIL}, +}; +use ethrex_rpc::{ + ClientVersion, GasTipEstimator, NodeData, RpcApiContext, + RpcErr, RpcErrorMetadata, RpcHandler, + start_block_executor, + test_utils::{ + dummy_peer_handler, dummy_sync_manager, + example_local_node_record, example_p2p_node, + }, +}; +use ethrex_rpc::engine::fork_choice::{ + ForkChoiceUpdatedV1, ForkChoiceUpdatedV2, + ForkChoiceUpdatedV3, ForkChoiceUpdatedV4, +}; +use ethrex_rpc::engine::payload::{ + NewPayloadV1Request, NewPayloadV2Request, + NewPayloadV3Request, NewPayloadV4Request, + NewPayloadV5Request, +}; +use ethrex_rpc::types::fork_choice::ForkChoiceResponse; +use ethrex_rpc::types::payload::{ + PayloadStatus, PayloadValidationStatus, +}; +use ethrex_storage::{EngineType, Store}; +use serde::Serialize; +use tokio::sync::{Mutex as TokioMutex, OnceCell}; + +use crate::types::{EngineNewPayload, EngineTestUnit}; + +use bytes::Bytes; +use ethrex_p2p::peer_handler::PeerHandler; +use ethrex_p2p::sync_manager::SyncManager; + +/// Shared dummy infrastructure (SyncManager + PeerHandler) that is +/// expensive to create. Built once and reused across all tests so +/// we don't exhaust OS thread limits. +struct SharedTestInfra { + syncer: Arc, + peer_handler: PeerHandler, +} + +/// Lazily-initialised shared infrastructure. +static SHARED_INFRA: OnceCell = + OnceCell::const_new(); + +/// Returns a reference to the shared infra, initializing it on the +/// first call (within the current async runtime). +async fn shared_infra() -> &'static SharedTestInfra { + SHARED_INFRA + .get_or_init(|| async { + let dummy_store = Store::new( + "", + EngineType::InMemory, + ) + .expect("Failed to create dummy store"); + SharedTestInfra { + syncer: Arc::new(dummy_sync_manager().await), + peer_handler: dummy_peer_handler( + dummy_store, + ) + .await, + } + }) + .await +} + +/// Build a lightweight `RpcApiContext` for a single test, reusing the +/// shared SyncManager and PeerHandler. +#[allow(unexpected_cfgs)] +async fn build_context(store: Store) -> RpcApiContext { + let blockchain = + Arc::new(Blockchain::default_with_store(store.clone())); + let block_worker_channel = + start_block_executor(blockchain.clone()); + let infra = shared_infra().await; + + RpcApiContext { + storage: store, + blockchain, + active_filters: Default::default(), + syncer: Some(infra.syncer.clone()), + peer_handler: Some(infra.peer_handler.clone()), + node_data: NodeData { + jwt_secret: Default::default(), + local_p2p_node: example_p2p_node(), + local_node_record: example_local_node_record(), + client_version: ClientVersion::new( + "ethrex".to_string(), + "0.1.0".to_string(), + "test".to_string(), + "abcd1234".to_string(), + "x86_64".to_string(), + "1.70.0".to_string(), + ), + extra_data: Bytes::new(), + }, + gas_tip_estimator: Arc::new( + TokioMutex::new(GasTipEstimator::new()), + ), + log_filter_handler: None, + gas_ceil: DEFAULT_BUILDER_GAS_CEIL, + block_worker_channel, + #[cfg(feature = "eip-8025")] + proof_coordinator: None, + } +} + +#[derive(Serialize)] +pub struct TestResult { + pub name: String, + pub pass: bool, + #[serde(skip_serializing_if = "Option::is_none")] + pub error: Option, +} + +/// Run a single engine test. Returns `Ok(())` on pass, `Err(msg)` on +/// failure. +pub async fn run_engine_test( + test_key: &str, + test: &EngineTestUnit, +) -> Result<(), String> { + let store = build_store(test).await; + let context = build_context(store.clone()).await; + + // Track the current head hash for fork-choice updates. + #[allow(unused_assignments)] + let mut head_hash = test.genesis_block_header.hash; + + for (i, payload_entry) in + test.engine_new_payloads.iter().enumerate() + { + let expects_error = payload_entry.expects_error(); + let expected_rpc_code = payload_entry.error_code; + + let version = payload_entry.new_payload_version; + let params = Some(payload_entry.params.clone()); + + // ---- 1. Dispatch to the real RPC handler ---- + // + // RpcHandler::parse() validates parameter count and + // deserializes the payload, and handle() runs the full + // engine pipeline: payload validation, block construction, + // block hash check, blob versioned hash check, execution + // requests validation, block execution, and storage. + let handler_result: Result = + dispatch_new_payload(version, ¶ms, &context).await; + + // ---- 2. Check for RPC-level errors ---- + match handler_result { + Err(rpc_err) => { + let meta: RpcErrorMetadata = rpc_err.into(); + if let Some(expected_code) = expected_rpc_code { + if meta.code == expected_code as i32 { + // Expected RPC error, skip this payload. + continue; + } + return Err(format!( + "payload[{i}]: expected RPC error code \ + {expected_code}, got {} ({})", + meta.code, meta.message + )); + } + if expects_error { + // The fixture expected an INVALID status but + // we got an RPC error instead. Treat it as a + // matching error. + continue; + } + return Err(format!( + "payload[{i}]: unexpected RPC error: \ + code={}, msg={}", + meta.code, meta.message + )); + } + Ok(ref _val) if expected_rpc_code.is_some() => { + return Err(format!( + "payload[{i}]: expected RPC error code {:?} \ + but handler succeeded", + expected_rpc_code + )); + } + Ok(response_value) => { + // ---- 3. Inspect PayloadStatus ---- + let status: PayloadStatus = + serde_json::from_value(response_value.clone()) + .map_err(|e| { + format!( + "payload[{i}]: failed to \ + deserialize PayloadStatus: {e} \ + (raw: {response_value})" + ) + })?; + + match status.status { + PayloadValidationStatus::Valid => { + if expects_error { + return Err(format!( + "payload[{i}]: expected error \ + ({:?}) but got VALID", + payload_entry.validation_error + )); + } + } + PayloadValidationStatus::Invalid => { + if !expects_error { + return Err(format!( + "payload[{i}]: got INVALID \ + unexpectedly: {:?}", + status.validation_error + )); + } + // Expected error -- do NOT advance fork + // choice, but continue processing + // subsequent payloads. + continue; + } + PayloadValidationStatus::Syncing + | PayloadValidationStatus::Accepted => { + // Syncing/Accepted in a test context is + // unexpected; the dummy SyncManager runs + // in Full mode so this should not happen. + return Err(format!( + "payload[{i}]: unexpected status {:?}", + status.status + )); + } + } + } + } + + // ---- 4. Apply fork choice (advance the canonical + // head) via the real handler ---- + head_hash = payload_entry + .block_hash_from_params() + .unwrap_or(head_hash); + + let fcu_version = payload_entry.forkchoice_updated_version; + dispatch_fork_choice( + fcu_version, + head_hash, + &context, + ) + .await + .map_err(|e| { + format!("payload[{i}]: fork choice update failed: {e}") + })?; + } + + // ---- 5. Verify post-state ---- + verify_post_state(test_key, test, &store).await?; + + Ok(()) +} + +// ---- RPC dispatch helpers ---- + +/// Dispatch to the version-appropriate `engine_newPayload` handler. +async fn dispatch_new_payload( + version: u8, + params: &Option>, + context: &RpcApiContext, +) -> Result { + match version { + 1 => { + let req = NewPayloadV1Request::parse(params)?; + req.handle(context.clone()).await + } + 2 => { + let req = NewPayloadV2Request::parse(params)?; + req.handle(context.clone()).await + } + 3 => { + let req = NewPayloadV3Request::parse(params)?; + req.handle(context.clone()).await + } + 4 => { + let req = NewPayloadV4Request::parse(params)?; + req.handle(context.clone()).await + } + 5 => { + let req = NewPayloadV5Request::parse(params)?; + req.handle(context.clone()).await + } + _ => Err(RpcErr::BadParams(format!( + "Unsupported newPayload version: {version}" + ))), + } +} + +/// Dispatch to the version-appropriate `engine_forkchoiceUpdated` +/// handler. We only pass the fork-choice state (no payload +/// attributes) since the test runner does not build payloads. +async fn dispatch_fork_choice( + version: u8, + head_hash: H256, + context: &RpcApiContext, +) -> Result<(), String> { + let fcu_state = serde_json::json!({ + "headBlockHash": head_hash, + "safeBlockHash": head_hash, + "finalizedBlockHash": head_hash, + }); + let params = Some(vec![fcu_state]); + + let result = match version { + 1 => { + let req = ForkChoiceUpdatedV1::parse(¶ms) + .map_err(|e| format!("FCU parse: {e}"))?; + req.handle(context.clone()) + .await + .map_err(|e| format!("FCU handle: {e}")) + } + 2 => { + let req = ForkChoiceUpdatedV2::parse(¶ms) + .map_err(|e| format!("FCU parse: {e}"))?; + req.handle(context.clone()) + .await + .map_err(|e| format!("FCU handle: {e}")) + } + 3 => { + let req = ForkChoiceUpdatedV3::parse(¶ms) + .map_err(|e| format!("FCU parse: {e}"))?; + req.handle(context.clone()) + .await + .map_err(|e| format!("FCU handle: {e}")) + } + 4 => { + let req = ForkChoiceUpdatedV4::parse(¶ms) + .map_err(|e| format!("FCU parse: {e}"))?; + req.handle(context.clone()) + .await + .map_err(|e| format!("FCU handle: {e}")) + } + _ => { + return Err(format!( + "Unsupported forkchoiceUpdated version: {version}" + )); + } + }?; + + // Verify the FCU response indicates VALID (not SYNCING or + // INVALID). + let response: ForkChoiceResponse = + serde_json::from_value(result).map_err(|e| { + format!("Failed to parse ForkChoiceResponse: {e}") + })?; + + match response.payload_status.status { + PayloadValidationStatus::Valid => Ok(()), + other => Err(format!( + "Fork choice returned {:?}: {:?}", + other, response.payload_status.validation_error + )), + } +} + +// ---- Store setup ---- + +async fn build_store(test: &EngineTestUnit) -> Store { + let mut store = Store::new("store.db", EngineType::InMemory) + .expect("Failed to build DB for engine test"); + let genesis = test.get_genesis(); + store + .add_initial_state(genesis) + .await + .expect("Failed to add genesis state"); + store +} + +// ---- Post-state verification ---- + +async fn verify_post_state( + test_key: &str, + test: &EngineTestUnit, + store: &Store, +) -> Result<(), String> { + let latest_block_number = + store.get_latest_block_number().await.map_err(|e| { + format!("Failed to get latest block number: {e}") + })?; + + // Verify account state + if let Some(post_state) = &test.post_state { + for (addr, account) in post_state { + let expected: CoreAccount = account.clone().into(); + + let db_info = store + .get_account_info(latest_block_number, *addr) + .await + .map_err(|e| format!("DB read error: {e}"))? + .ok_or_else(|| { + format!( + "{test_key}: account {addr} not found \ + in post-state" + ) + })?; + + if db_info != expected.info { + return Err(format!( + "{test_key}: account {addr} info mismatch: \ + expected {:?}, got {:?}", + expected.info, db_info + )); + } + + let code_hash = expected.info.code_hash; + if code_hash != *EMPTY_KECCACK_HASH { + let db_code = store + .get_account_code(code_hash) + .map_err(|e| format!("DB read error: {e}"))? + .ok_or_else(|| { + format!( + "{test_key}: code {code_hash} \ + not found" + ) + })?; + if db_code != expected.code { + return Err(format!( + "{test_key}: code mismatch for {addr}" + )); + } + } + + for (key, value) in &expected.storage { + let db_val = store + .get_storage_at( + latest_block_number, + *addr, + *key, + ) + .map_err(|e| format!("DB read error: {e}"))? + .ok_or_else(|| { + format!( + "{test_key}: storage {key} for \ + {addr} not found" + ) + })?; + if db_val != *value { + return Err(format!( + "{test_key}: storage mismatch for \ + {addr} key {key}: expected {value}, \ + got {db_val}" + )); + } + } + } + } + + // Verify lastblockhash + let last_header = store + .get_block_header(latest_block_number) + .map_err(|e| format!("DB read error: {e}"))? + .ok_or_else(|| { + format!("{test_key}: last block header not found") + })?; + let last_hash = last_header.hash(); + + if test.lastblockhash != last_hash { + return Err(format!( + "{test_key}: lastblockhash mismatch: expected \ + {:#x}, got {last_hash:#x}", + test.lastblockhash + )); + } + + Ok(()) +} + +impl EngineNewPayload { + /// Returns true if this payload entry expects an error (INVALID + /// status or validation error). + pub fn expects_error(&self) -> bool { + self.validation_error + .as_ref() + .is_some_and(|s| !s.is_empty()) + } + + /// Extract the block hash from params[0] of the fixture. + pub fn block_hash_from_params(&self) -> Option { + self.params.first().and_then(|p| { + p.get("blockHash") + .and_then(|v| serde_json::from_value(v.clone()).ok()) + }) + } +} diff --git a/tooling/ef_tests/enginetest/src/types.rs b/tooling/ef_tests/enginetest/src/types.rs new file mode 100644 index 00000000000..f6cb4712d11 --- /dev/null +++ b/tooling/ef_tests/enginetest/src/types.rs @@ -0,0 +1,352 @@ +use std::collections::HashMap; + +use bytes::Bytes; +use ethrex_common::{ + Address, Bloom, H256, H64, U256, + types::{ + Block, BlockBody, BlockHeader, Genesis, Withdrawal, + block_access_list::BlockAccessList, compute_transactions_root, + compute_withdrawals_root, requests::EncodedRequests, + }, +}; +use ethrex_crypto::NativeCrypto; +use serde::Deserialize; + +use ef_tests_blockchain::fork::Fork; +use ef_tests_blockchain::types::{Account, BlobSchedule, Info}; + +// ---- Top-level fixture map ---- + +/// A single JSON file maps test names to `EngineTestUnit`. +pub type EngineTestFile = HashMap; + +// ---- Engine test fixture ---- + +#[derive(Debug, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct EngineTestUnit { + #[serde(default, rename = "_info")] + pub info: Info, + pub network: Fork, + pub genesis_block_header: Header, + pub pre: HashMap, + #[serde(default)] + pub post_state: Option>, + pub lastblockhash: H256, + #[serde(rename = "engineNewPayloads")] + pub engine_new_payloads: Vec, + pub config: Option, +} + +#[derive(Debug, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct FixtureConfig { + pub blob_schedule: Option, +} + +impl EngineTestUnit { + pub fn get_genesis(&self) -> Genesis { + let mut config = *self.network.chain_config(); + if let Some(test_config) = &self.config + && let Some(ref schedule) = test_config.blob_schedule + { + config.blob_schedule = schedule.clone().into(); + } + Genesis { + config, + alloc: self + .pre + .clone() + .into_iter() + .map(|(key, val)| (key, val.into())) + .collect(), + coinbase: self.genesis_block_header.coinbase, + difficulty: self.genesis_block_header.difficulty, + extra_data: self.genesis_block_header.extra_data.clone(), + gas_limit: self.genesis_block_header.gas_limit.as_u64(), + nonce: self.genesis_block_header.nonce.to_low_u64_be(), + mix_hash: self.genesis_block_header.mix_hash, + timestamp: self.genesis_block_header.timestamp.as_u64(), + base_fee_per_gas: self + .genesis_block_header + .base_fee_per_gas + .map(|v| v.as_u64()), + blob_gas_used: self + .genesis_block_header + .blob_gas_used + .map(|v| v.as_u64()), + excess_blob_gas: self + .genesis_block_header + .excess_blob_gas + .map(|v| v.as_u64()), + requests_hash: self.genesis_block_header.requests_hash, + block_access_list_hash: self + .genesis_block_header + .block_access_list_hash, + slot_number: self + .genesis_block_header + .slot_number + .map(|v| v.as_u64()), + } + } +} + +// ---- Genesis block header (reuse from blockchain tests) ---- + +#[derive(Debug, PartialEq, Eq, Clone, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct Header { + pub bloom: Bloom, + pub coinbase: Address, + pub difficulty: U256, + #[serde(with = "ethrex_common::serde_utils::bytes")] + pub extra_data: Bytes, + pub gas_limit: U256, + pub gas_used: U256, + pub hash: H256, + pub mix_hash: H256, + pub nonce: H64, + pub number: U256, + pub parent_hash: H256, + pub receipt_trie: H256, + pub state_root: H256, + pub timestamp: U256, + pub transactions_trie: H256, + pub uncle_hash: H256, + pub base_fee_per_gas: Option, + pub withdrawals_root: Option, + pub blob_gas_used: Option, + pub excess_blob_gas: Option, + pub parent_beacon_block_root: Option, + pub requests_hash: Option, + pub block_access_list_hash: Option, + pub slot_number: Option, +} + +// ---- Engine new payload entry ---- + +#[derive(Debug, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct EngineNewPayload { + /// params[0] = ExecutionPayload + /// params[1] = versionedHashes (V3+) + /// params[2] = parentBeaconBlockRoot (V3+) + /// params[3] = executionRequests (V4+) + pub params: Vec, + + /// "1", "2", "3", "4", or "5" + #[serde(deserialize_with = "deserialize_version_string")] + pub new_payload_version: u8, + + /// "1", "2", "3", or "4" + #[serde(deserialize_with = "deserialize_version_string")] + pub forkchoice_updated_version: u8, + + /// Empty string means no error expected (VALID). + /// Non-empty means INVALID with this error description. + #[serde(default)] + pub validation_error: Option, + + /// JSON-RPC error code (e.g. -32602). Null/absent means no RPC + /// error. May appear as an integer or a string in fixtures. + #[serde( + default, + deserialize_with = "deserialize_error_code" + )] + pub error_code: Option, +} + +fn deserialize_error_code<'de, D>( + deserializer: D, +) -> Result, D::Error> +where + D: serde::Deserializer<'de>, +{ + let val: Option = + Option::deserialize(deserializer)?; + match val { + None | Some(serde_json::Value::Null) => Ok(None), + Some(serde_json::Value::Number(n)) => { + Ok(Some(n.as_i64().ok_or_else(|| { + serde::de::Error::custom(format!( + "errorCode number out of i64 range: {n}" + )) + })?)) + } + Some(serde_json::Value::String(s)) => { + let parsed = s.parse::().map_err(|e| { + serde::de::Error::custom(format!( + "errorCode string parse error: {e}" + )) + })?; + Ok(Some(parsed)) + } + Some(other) => Err(serde::de::Error::custom(format!( + "unexpected errorCode type: {other}" + ))), + } +} + +fn deserialize_version_string<'de, D>(deserializer: D) -> Result +where + D: serde::Deserializer<'de>, +{ + let s = String::deserialize(deserializer)?; + s.parse::().map_err(serde::de::Error::custom) +} + +// ---- Execution payload from fixture params[0] ---- + +#[derive(Debug, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct FixtureExecutionPayload { + pub parent_hash: H256, + pub fee_recipient: Address, + pub state_root: H256, + pub receipts_root: H256, + pub logs_bloom: Bloom, + #[serde(with = "ethrex_common::serde_utils::u64::hex_str")] + pub block_number: u64, + #[serde(with = "ethrex_common::serde_utils::u64::hex_str")] + pub gas_limit: u64, + #[serde(with = "ethrex_common::serde_utils::u64::hex_str")] + pub gas_used: u64, + #[serde(with = "ethrex_common::serde_utils::u64::hex_str")] + pub timestamp: u64, + #[serde(with = "ethrex_common::serde_utils::bytes")] + pub extra_data: Bytes, + pub prev_randao: H256, + #[serde(with = "ethrex_common::serde_utils::u64::hex_str")] + pub base_fee_per_gas: u64, + pub block_hash: H256, + pub transactions: Vec, + #[serde(default)] + pub withdrawals: Option>, + #[serde( + default, + with = "ethrex_common::serde_utils::u64::hex_str_opt" + )] + pub blob_gas_used: Option, + #[serde( + default, + with = "ethrex_common::serde_utils::u64::hex_str_opt" + )] + pub excess_blob_gas: Option, + // V5 field: block access list + #[serde( + default, + with = "ethrex_common::serde_utils::block_access_list::rlp_str_opt" + )] + pub block_access_list: Option, + // V5 field: slot number + #[serde( + default, + with = "ethrex_common::serde_utils::u64::hex_str_opt" + )] + pub slot_number: Option, +} + +impl FixtureExecutionPayload { + /// Convert the fixture execution payload into an ethrex `Block`. + /// + /// This mirrors the logic in + /// `ethrex_rpc::types::payload::ExecutionPayload::into_block`. + pub fn into_block( + self, + parent_beacon_block_root: Option, + requests_hash: Option, + block_access_list_hash: Option, + ) -> Result { + // Decode transactions from hex-encoded RLP + let transactions = self + .transactions + .iter() + .enumerate() + .map(|(i, tx_val)| { + let hex_str = tx_val + .as_str() + .ok_or_else(|| format!("tx[{i}] is not a string"))?; + let bytes = hex::decode(hex_str.trim_start_matches("0x")) + .map_err(|e| format!("tx[{i}] hex decode: {e}"))?; + ethrex_common::types::Transaction::decode_canonical(&bytes) + .map_err(|e| format!("tx[{i}] RLP decode: {e}")) + }) + .collect::, _>>()?; + + let body = BlockBody { + transactions: transactions.clone(), + ommers: vec![], + withdrawals: self.withdrawals, + }; + + let header = BlockHeader { + parent_hash: self.parent_hash, + ommers_hash: *ethrex_common::constants::DEFAULT_OMMERS_HASH, + coinbase: self.fee_recipient, + state_root: self.state_root, + transactions_root: compute_transactions_root( + &body.transactions, + &NativeCrypto, + ), + receipts_root: self.receipts_root, + logs_bloom: self.logs_bloom, + difficulty: 0.into(), + number: self.block_number, + gas_limit: self.gas_limit, + gas_used: self.gas_used, + timestamp: self.timestamp, + extra_data: self.extra_data, + prev_randao: self.prev_randao, + nonce: 0, + base_fee_per_gas: Some(self.base_fee_per_gas), + withdrawals_root: body + .withdrawals + .as_ref() + .map(|w| compute_withdrawals_root(w, &NativeCrypto)), + blob_gas_used: self.blob_gas_used, + excess_blob_gas: self.excess_blob_gas, + parent_beacon_block_root, + requests_hash, + slot_number: self.slot_number, + block_access_list_hash, + ..Default::default() + }; + + Ok(Block::new(header, body)) + } +} + +/// Parse versioned hashes from params[1]. +pub fn parse_versioned_hashes( + val: &serde_json::Value, +) -> Result, String> { + serde_json::from_value(val.clone()) + .map_err(|e| format!("Failed to parse versioned hashes: {e}")) +} + +/// Parse parent beacon block root from params[2]. +pub fn parse_beacon_root(val: &serde_json::Value) -> Result { + serde_json::from_value(val.clone()) + .map_err(|e| format!("Failed to parse beacon root: {e}")) +} + +/// Parse execution requests from params[3]. +pub fn parse_execution_requests( + val: &serde_json::Value, +) -> Result, String> { + serde_json::from_value(val.clone()) + .map_err(|e| format!("Failed to parse execution requests: {e}")) +} + +/// Compute the BAL hash from the raw JSON payload, hashing the +/// original RLP bytes before deserialization reorders them. +pub fn compute_raw_bal_hash( + payload_json: &serde_json::Value, +) -> Option { + payload_json.get("blockAccessList").and_then(|v| { + let hex_str = v.as_str()?; + let bytes = + hex::decode(hex_str.trim_start_matches("0x")).ok()?; + Some(ethrex_common::utils::keccak(bytes)) + }) +} diff --git a/tooling/ef_tests/statetest/Cargo.toml b/tooling/ef_tests/statetest/Cargo.toml new file mode 100644 index 00000000000..774df80f672 --- /dev/null +++ b/tooling/ef_tests/statetest/Cargo.toml @@ -0,0 +1,29 @@ +[package] +name = "ef_tests-statetest" +version.workspace = true +edition.workspace = true +authors.workspace = true +documentation.workspace = true +license.workspace = true + +[dependencies] +ethrex-levm.workspace = true +ethrex-common.workspace = true +ethrex-crypto.workspace = true +ethrex-rlp.workspace = true + +serde = { workspace = true, features = ["derive"] } +serde_json.workspace = true +clap.workspace = true +rayon.workspace = true +regex = "1" +rustc-hash = "2.1.1" +secp256k1.workspace = true + +[features] +default = ["c-kzg"] +c-kzg = ["ethrex-levm/c-kzg", "ethrex-common/c-kzg"] + +[[bin]] +name = "ef_tests-statetest" +path = "src/main.rs" diff --git a/tooling/ef_tests/statetest/src/main.rs b/tooling/ef_tests/statetest/src/main.rs new file mode 100644 index 00000000000..36a773ac69b --- /dev/null +++ b/tooling/ef_tests/statetest/src/main.rs @@ -0,0 +1,221 @@ +mod runner; +mod types; + +use std::path::PathBuf; +use std::sync::atomic::{AtomicUsize, Ordering}; +use std::time::Instant; + +use clap::Parser; +use rayon::iter::{IntoParallelIterator, ParallelIterator}; +use regex::Regex; + +use runner::TestResult; +use types::{Test, Tests}; + +/// Fast state test runner for ethrex LEVM -- no Store, no trie, no async. +#[derive(Parser, Debug)] +#[command(name = "ef_tests-statefast")] +struct Cli { + /// Path to a state test directory or a single .json file. + #[arg(short, long, value_name = "PATH")] + path: PathBuf, + + /// Number of parallel worker threads. + #[arg(short, long, default_value = "1")] + workers: usize, + + /// Regex filter: only run tests whose name matches this pattern. + #[arg(long)] + run: Option, + + /// Output results as JSON array to stdout. + #[arg(long)] + json: bool, + + /// Emit EIP-3155 per-opcode traces to stderr. + #[arg(long)] + trace: bool, +} + +/// Tests to ignore (same set as state_v2). +const IGNORED_TESTS: &[&str] = &[ + "dynamicAccountOverwriteEmpty_Paris.json", + "RevertInCreateInInitCreate2Paris.json", + "RevertInCreateInInit_Paris.json", + "create2collisionStorageParis.json", + "InitCollisionParis.json", + "InitCollision.json", + "HighGasPrice.json", + "HighGasPriceParis.json", + "static_Call50000_sha256.json", + "CALLBlake2f_MaxRounds.json", + "loopMul.json", + "ValueOverflow.json", + "ValueOverflowParis.json", + "contract_create.json", +]; + +fn main() { + let cli = Cli::parse(); + + let start = Instant::now(); + + // Parse all test files. + eprintln!("Parsing test files from {:?} ...", cli.path); + let mut all_tests = if cli.path.is_file() { + parse_file(&cli.path) + } else { + parse_dir(&cli.path) + }; + + // Apply --run regex filter. + if let Some(ref pattern) = cli.run { + let re = Regex::new(pattern).unwrap_or_else(|e| { + eprintln!("Invalid --run regex '{}': {}", pattern, e); + std::process::exit(1); + }); + all_tests.retain(|t| re.is_match(&t.name)); + } + + let parse_time = start.elapsed(); + let total_cases: usize = all_tests.iter().map(|t| t.test_cases.len()).sum(); + eprintln!( + "Parsed {} tests ({} sub-cases) in {:.2}s", + all_tests.len(), + total_cases, + parse_time.as_secs_f64() + ); + + // Build rayon thread pool. + let pool = rayon::ThreadPoolBuilder::new() + .num_threads(cli.workers) + .build() + .expect("failed to build thread pool"); + + let passing = AtomicUsize::new(0); + let failing = AtomicUsize::new(0); + let total_run = AtomicUsize::new(0); + + let exec_start = Instant::now(); + + // Flatten all (test, case) pairs and run in parallel. + let work_items: Vec<(&Test, usize)> = all_tests + .iter() + .flat_map(|test| (0..test.test_cases.len()).map(move |i| (test, i))) + .collect(); + + let trace = cli.trace; + let results: Vec = pool.install(|| { + work_items + .into_par_iter() + .map(|(test, case_idx)| { + let tc = &test.test_cases[case_idx]; + let result = + runner::run_test_case(&test.name, &test.env, &test.pre, tc, trace); + + if result.pass { + passing.fetch_add(1, Ordering::Relaxed); + } else { + failing.fetch_add(1, Ordering::Relaxed); + } + total_run.fetch_add(1, Ordering::Relaxed); + result + }) + .collect() + }); + + let exec_time = exec_start.elapsed(); + let total = total_run.load(Ordering::Relaxed); + let passed = passing.load(Ordering::Relaxed); + let failed = failing.load(Ordering::Relaxed); + + if cli.json { + // JSON output mode. + let json_results: Vec = results + .iter() + .map(|r| { + serde_json::json!({ + "name": r.name, + "pass": r.pass, + "fork": r.fork, + "stateRoot": r.state_root, + "error": r.error, + }) + }) + .collect(); + println!( + "{}", + serde_json::to_string_pretty(&json_results).unwrap() + ); + } else { + // Print failures. + for r in &results { + if !r.pass { + let err_msg = if r.error.is_empty() { "unknown" } else { &r.error }; + eprintln!("FAIL: {} -- {}", r.name, err_msg); + } + } + } + + eprintln!( + "\nTotal: {} | Passed: {} | Failed: {} | Time: {:.2}s (parse: {:.2}s, exec: {:.2}s)", + total, + passed, + failed, + start.elapsed().as_secs_f64(), + parse_time.as_secs_f64(), + exec_time.as_secs_f64(), + ); + + if failed > 0 { + std::process::exit(1); + } +} + +// ---- File / directory parsing ---- + +fn parse_file(path: &PathBuf) -> Vec { + let data = std::fs::read(path).unwrap_or_else(|e| { + eprintln!("Cannot read {:?}: {}", path, e); + std::process::exit(1); + }); + let mut tests: Tests = serde_json::from_slice(&data).unwrap_or_else(|e| { + eprintln!("JSON parse error in {:?}: {}", path, e); + std::process::exit(1); + }); + for test in tests.0.iter_mut() { + test.path = path.clone(); + } + tests.0 +} + +fn parse_dir(path: &PathBuf) -> Vec { + let entries: Vec<_> = match std::fs::read_dir(path) { + Ok(rd) => rd.flatten().collect(), + Err(e) => { + eprintln!("Cannot read directory {:?}: {}", path, e); + std::process::exit(1); + } + }; + + entries + .into_par_iter() + .flat_map(|entry| { + let ft = entry.file_type().unwrap(); + if ft.is_dir() { + parse_dir(&entry.path()) + } else if ft.is_file() + && entry.path().extension().is_some_and(|ext| ext == "json") + { + let file_name = entry.file_name(); + let name_str = file_name.to_string_lossy(); + if IGNORED_TESTS.iter().any(|&skip| name_str == skip) { + return Vec::new(); + } + parse_file(&entry.path()) + } else { + Vec::new() + } + }) + .collect() +} diff --git a/tooling/ef_tests/statetest/src/runner.rs b/tooling/ef_tests/statetest/src/runner.rs new file mode 100644 index 00000000000..3bff11a3b26 --- /dev/null +++ b/tooling/ef_tests/statetest/src/runner.rs @@ -0,0 +1,537 @@ +use std::collections::HashMap; +use std::sync::Arc; + +use ethrex_common::{ + Address, H256, U256, + types::{ + Account, AccountInfo, Code, EIP1559Transaction, EIP2930Transaction, + EIP4844Transaction, EIP7702Transaction, Fork, LegacyTransaction, + Transaction, TxKind, + }, +}; +use ethrex_crypto::NativeCrypto; +use ethrex_levm::{ + EVMConfig, Environment, + db::Database as LevmDatabase, + db::gen_db::GeneralizedDatabase, + errors::{DatabaseError, VMError}, + tracing::LevmCallTracer, + utils::get_base_fee_per_blob_gas, + vm::{VM, VMType}, +}; +use ethrex_rlp::encode::PayloadRLPEncode; +use rustc_hash::FxHashMap; +use secp256k1::{Message, Secp256k1, SecretKey}; + +use crate::types::{AccountState, Env, TestCase, chain_config_for_fork}; + +// ---- Result type for each sub-test ---- + +#[derive(Debug, Clone)] +pub struct TestResult { + pub name: String, + pub pass: bool, + pub fork: String, + pub state_root: String, + pub error: String, +} + +// ---- Lightweight in-memory database ---- + +/// Minimal Database implementation backed by HashMaps. +/// All pre-state accounts are loaded into GeneralizedDatabase's cache, +/// so this backing store only needs to return defaults for misses +/// and serve code lookups. +struct InMemoryDb { + chain_config: ethrex_common::types::ChainConfig, + codes: FxHashMap, +} + +impl LevmDatabase for InMemoryDb { + fn get_account_state( + &self, + _address: Address, + ) -> Result { + Ok(ethrex_common::types::AccountState::default()) + } + + fn get_storage_value( + &self, + _address: Address, + _key: H256, + ) -> Result { + Ok(U256::zero()) + } + + fn get_block_hash(&self, _block_number: u64) -> Result { + Ok(H256::zero()) + } + + fn get_chain_config(&self) -> Result { + Ok(self.chain_config) + } + + fn get_account_code(&self, code_hash: H256) -> Result { + Ok(self.codes.get(&code_hash).cloned().unwrap_or_default()) + } + + fn get_code_metadata( + &self, + code_hash: H256, + ) -> Result { + let length = self + .codes + .get(&code_hash) + .map(|c| c.bytecode.len() as u64) + .unwrap_or(0); + Ok(ethrex_common::types::CodeMetadata { length }) + } +} + +// ---- Build GeneralizedDatabase from pre-state ---- + +fn build_db( + pre: &HashMap, + fork: &Fork, +) -> GeneralizedDatabase { + let chain_config = chain_config_for_fork(fork); + + let mut accounts: FxHashMap = FxHashMap::default(); + let mut codes: FxHashMap = FxHashMap::default(); + + for (addr, state) in pre { + let code = Code::from_bytecode(state.code.clone(), &NativeCrypto); + let storage: FxHashMap = state + .storage + .iter() + .map(|(k, v)| (H256::from(k.to_big_endian()), *v)) + .collect(); + codes.insert(code.hash, code.clone()); + accounts.insert( + *addr, + Account { + info: AccountInfo { + code_hash: code.hash, + balance: state.balance, + nonce: state.nonce, + }, + code, + storage, + }, + ); + } + + let db = InMemoryDb { chain_config, codes }; + GeneralizedDatabase::new_with_account_state(Arc::new(db), accounts) +} + +// ---- Build Environment ---- + +fn build_env(env: &Env, tc: &TestCase) -> Result { + let blob_schedule = EVMConfig::canonical_values(tc.fork); + let config = EVMConfig::new(tc.fork, blob_schedule); + let gas_price = effective_gas_price(env, tc)?; + let base_blob_fee_per_gas = get_base_fee_per_blob_gas( + env.current_excess_blob_gas + .map(|x| x.try_into().unwrap()), + &config, + ) + .map_err(|e| format!("blob base fee error: {e}"))?; + + Ok(Environment { + origin: tc.sender, + gas_limit: tc.gas, + config, + block_number: env.current_number.try_into().unwrap(), + coinbase: env.current_coinbase, + timestamp: env.current_timestamp.try_into().unwrap(), + prev_randao: env.current_random, + difficulty: env.current_difficulty, + slot_number: env.slot_number.unwrap_or_default(), + chain_id: U256::from(1), + base_fee_per_gas: env.current_base_fee.unwrap_or_default(), + base_blob_fee_per_gas, + gas_price, + block_excess_blob_gas: env + .current_excess_blob_gas + .map(|x| x.try_into().unwrap()), + block_blob_gas_used: None, + tx_blob_hashes: tc.blob_versioned_hashes.clone(), + tx_max_priority_fee_per_gas: tc.max_priority_fee_per_gas, + tx_max_fee_per_gas: tc.max_fee_per_gas, + tx_max_fee_per_blob_gas: tc.max_fee_per_blob_gas, + tx_nonce: tc.nonce, + block_gas_limit: env.current_gas_limit, + is_privileged: false, + fee_token: None, + disable_balance_check: false, + }) +} + +fn effective_gas_price(env: &Env, tc: &TestCase) -> Result { + match tc.gas_price { + Some(price) => Ok(price), + None => { + let base_fee = env + .current_base_fee + .ok_or("missing current_base_fee for EIP-1559+ tx")?; + let priority = tc + .max_priority_fee_per_gas + .ok_or("missing max_priority_fee_per_gas")?; + let max_fee = tc + .max_fee_per_gas + .ok_or("missing max_fee_per_gas")?; + Ok(std::cmp::min(max_fee, base_fee + priority)) + } + } +} + +// ---- Build Transaction ---- + +fn build_tx(tc: &TestCase) -> Result { + // Prefer decoding from txbytes when available (already signed). + if !tc.tx_bytes.is_empty() { + return Transaction::decode_canonical(&tc.tx_bytes) + .map_err(|e| format!("txbytes decode error: {e}")); + } + + // Fall back to constructing + signing manually. + let chain_id: u64 = 1; + let access_list: Vec<(Address, Vec)> = tc + .access_list + .iter() + .map(|item| (item.address, item.storage_keys.clone())) + .collect(); + + let mut tx = if let Some(ref auth_list) = tc.authorization_list { + Transaction::EIP7702Transaction(EIP7702Transaction { + to: match tc.to { + TxKind::Call(to) => to, + TxKind::Create => return Err("EIP-7702 tx cannot be create".into()), + }, + value: tc.value, + data: tc.data.clone(), + access_list: access_list.clone(), + authorization_list: auth_list + .iter() + .map(|a| a.clone().into_authorization_tuple()) + .collect(), + chain_id, + nonce: tc.nonce, + max_priority_fee_per_gas: tc + .max_priority_fee_per_gas + .unwrap() + .as_u64(), + max_fee_per_gas: tc.max_fee_per_gas.unwrap().as_u64(), + gas_limit: tc.gas, + ..Default::default() + }) + } else if tc.max_fee_per_blob_gas.is_some() { + Transaction::EIP4844Transaction(EIP4844Transaction { + chain_id, + nonce: tc.nonce, + max_priority_fee_per_gas: tc + .max_priority_fee_per_gas + .unwrap() + .as_u64(), + max_fee_per_gas: tc.max_fee_per_gas.unwrap().as_u64(), + gas: tc.gas, + to: match tc.to { + TxKind::Call(to) => to, + TxKind::Create => { + return Err("EIP-4844 tx cannot be create".into()) + } + }, + value: tc.value, + data: tc.data.clone(), + access_list: access_list.clone(), + max_fee_per_blob_gas: tc.max_fee_per_blob_gas.unwrap(), + blob_versioned_hashes: tc.blob_versioned_hashes.clone(), + ..Default::default() + }) + } else if tc.max_priority_fee_per_gas.is_some() && tc.max_fee_per_gas.is_some() { + Transaction::EIP1559Transaction(EIP1559Transaction { + chain_id, + nonce: tc.nonce, + max_priority_fee_per_gas: tc + .max_priority_fee_per_gas + .unwrap() + .as_u64(), + max_fee_per_gas: tc.max_fee_per_gas.unwrap().as_u64(), + gas_limit: tc.gas, + to: tc.to.clone(), + value: tc.value, + data: tc.data.clone(), + access_list: access_list.clone(), + ..Default::default() + }) + } else if !tc.access_list.is_empty() { + Transaction::EIP2930Transaction(EIP2930Transaction { + chain_id, + nonce: tc.nonce, + gas_price: tc.gas_price.unwrap(), + gas_limit: tc.gas, + to: tc.to.clone(), + value: tc.value, + data: tc.data.clone(), + access_list, + ..Default::default() + }) + } else { + Transaction::LegacyTransaction(LegacyTransaction { + nonce: tc.nonce, + gas_price: tc.gas_price.unwrap(), + gas: tc.gas, + to: tc.to.clone(), + value: tc.value, + data: tc.data.clone(), + ..Default::default() + }) + }; + + // Sign the transaction synchronously using secp256k1. + sign_tx(&mut tx, &tc.secret_key)?; + Ok(tx) +} + +/// Sign a transaction in-place using the raw secp256k1 secret key. +fn sign_tx(tx: &mut Transaction, secret_key: &H256) -> Result<(), String> { + let secp = Secp256k1::new(); + let sk = SecretKey::from_slice(secret_key.as_bytes()) + .map_err(|e| format!("invalid secret key: {e}"))?; + + let payload = match *tx { + Transaction::LegacyTransaction(ref t) => t.encode_payload_to_vec(), + Transaction::EIP2930Transaction(ref t) => { + let mut buf = vec![0x01u8]; + buf.append(&mut t.encode_payload_to_vec()); + buf + } + Transaction::EIP1559Transaction(ref t) => { + let mut buf = vec![0x02u8]; + buf.append(&mut t.encode_payload_to_vec()); + buf + } + Transaction::EIP4844Transaction(ref t) => { + let mut buf = vec![0x03u8]; + buf.append(&mut t.encode_payload_to_vec()); + buf + } + Transaction::EIP7702Transaction(ref t) => { + let mut buf = vec![0x04u8]; + buf.append(&mut t.encode_payload_to_vec()); + buf + } + _ => return Err("unsupported tx type for signing".into()), + }; + + let msg_hash = ethrex_common::utils::keccak(&payload); + let message = Message::from_digest(*msg_hash.as_fixed_bytes()); + let (rec_id, sig_bytes) = secp + .sign_ecdsa_recoverable(&message, &sk) + .serialize_compact(); + let rec_id_i32: i32 = rec_id.into(); + let y_parity = rec_id_i32 != 0; + let r = U256::from_big_endian(&sig_bytes[..32]); + let s = U256::from_big_endian(&sig_bytes[32..]); + + match *tx { + Transaction::LegacyTransaction(ref mut t) => { + t.v = U256::from(rec_id_i32) + 27; + t.r = r; + t.s = s; + } + Transaction::EIP2930Transaction(ref mut t) => { + t.signature_y_parity = y_parity; + t.signature_r = r; + t.signature_s = s; + } + Transaction::EIP1559Transaction(ref mut t) => { + t.signature_y_parity = y_parity; + t.signature_r = r; + t.signature_s = s; + } + Transaction::EIP4844Transaction(ref mut t) => { + t.signature_y_parity = y_parity; + t.signature_r = r; + t.signature_s = s; + } + Transaction::EIP7702Transaction(ref mut t) => { + t.signature_y_parity = y_parity; + t.signature_r = r; + t.signature_s = s; + } + _ => return Err("unsupported tx type for signing".into()), + } + Ok(()) +} + +// ---- Check post-state ---- + +fn check_post_state( + vm: &mut VM<'_>, + tc: &TestCase, + execution_result: &Result, +) -> Result<(), String> { + // If an exception was expected, just check that execution failed. + if let Some(ref _expected) = tc.post.expected_exceptions { + if execution_result.is_ok() { + return Err("expected exception but execution succeeded".into()); + } + // Exception was expected and execution did fail -- pass. + return Ok(()); + } + + // Execution must have succeeded. + let _report = execution_result + .as_ref() + .map_err(|e| format!("unexpected execution error: {e}"))?; + + // Compare accounts from the expected post-state. + if let Some(ref expected_state) = tc.post.state { + for (addr, expected) in expected_state { + let account = vm + .db + .get_account(*addr) + .map_err(|e| format!("failed to get account {addr}: {e}"))?; + + if account.info.balance != expected.balance { + return Err(format!( + "balance mismatch for {addr}: expected={}, got={}", + expected.balance, account.info.balance + )); + } + if account.info.nonce != expected.nonce { + return Err(format!( + "nonce mismatch for {addr}: expected={}, got={}", + expected.nonce, account.info.nonce + )); + } + + let expected_code_hash = ethrex_common::types::code_hash( + &expected.code, + &NativeCrypto, + ); + if account.info.code_hash != expected_code_hash { + return Err(format!( + "code hash mismatch for {addr}: expected={:?}, got={:?}", + expected_code_hash, account.info.code_hash + )); + } + + for (slot, expected_val) in &expected.storage { + let slot_h256 = H256::from(slot.to_big_endian()); + let actual_val = account + .storage + .get(&slot_h256) + .copied() + .unwrap_or_default(); + if actual_val != *expected_val { + return Err(format!( + "storage mismatch for {addr} slot {slot}: expected={expected_val}, got={actual_val}" + )); + } + } + } + return Ok(()); + } + + // No explicit state field -- we cannot compute trie root without Store. + // Fall back to a warning; treat as pass since we have no way to verify. + Ok(()) +} + +// ---- Public entry point: run a single test case ---- + +pub fn run_test_case( + test_name: &str, + env: &Env, + pre: &HashMap, + tc: &TestCase, + eip3155_trace: bool, +) -> TestResult { + let label = test_name.to_string(); + let fork_str = format!("{:?}", tc.fork); + + // Build the in-memory database from pre-state. + let mut db = build_db(pre, &tc.fork); + + let expected_root = format!("{:#x}", tc.post.hash); + + // Build the environment. + let vm_env = match build_env(env, tc) { + Ok(e) => e, + Err(e) => { + return TestResult { + name: label, + pass: false, + fork: fork_str, + state_root: expected_root, + error: format!("env build error: {e}"), + }; + } + }; + + // Build the transaction. + let tx = match build_tx(tc) { + Ok(t) => t, + Err(e) => { + return TestResult { + name: label, + pass: false, + fork: fork_str, + state_root: expected_root, + error: format!("tx build error: {e}"), + }; + } + }; + + // Create and execute the VM. + let tracer = LevmCallTracer::disabled(); + let mut vm = match VM::new(vm_env, &mut db, &tx, tracer, VMType::L1, &NativeCrypto) { + Ok(mut vm) => { + vm.eip3155_trace = eip3155_trace; + vm + } + Err(e) => { + // VM::new can fail for invalid transactions. + // If an exception was expected, that counts as a pass. + if tc.post.expected_exceptions.is_some() { + return TestResult { + name: label, + pass: true, + fork: fork_str, + state_root: expected_root, + error: String::new(), + }; + } + return TestResult { + name: label, + pass: false, + fork: fork_str, + state_root: expected_root, + error: format!("VM creation error: {e}"), + }; + } + }; + + let execution_result = vm.execute(); + + // Check post-state. + match check_post_state(&mut vm, tc, &execution_result) { + Ok(()) => TestResult { + name: label, + pass: true, + fork: fork_str, + state_root: expected_root, + error: String::new(), + }, + Err(e) => TestResult { + name: label, + pass: false, + fork: fork_str, + state_root: expected_root, + error: e, + }, + } +} diff --git a/tooling/ef_tests/statetest/src/types.rs b/tooling/ef_tests/statetest/src/types.rs new file mode 100644 index 00000000000..d58c2a604e4 --- /dev/null +++ b/tooling/ef_tests/statetest/src/types.rs @@ -0,0 +1,461 @@ +use std::collections::HashMap; +use std::path::PathBuf; +use std::str::FromStr; + +use ethrex_common::{ + Address, Bytes, H160, H256, U256, + serde_utils::{bytes, u64, u256}, + types::{AuthorizationTuple, BlobSchedule, ChainConfig, Fork, TxKind}, +}; +use serde::Deserialize; +use serde_json::Value; + +/// Forks we support (post-Merge only). +const SUPPORTED_FORKS: [&str; 5] = ["Merge", "Shanghai", "Cancun", "Prague", "Amsterdam"]; + +// ---- Top-level fixture structures ---- + +/// A single JSON file can contain multiple tests. Each test shares an +/// environment and pre-state, with multiple test cases (fork x tx combos). +#[derive(Debug, Clone)] +pub struct Test { + pub name: String, + pub path: PathBuf, + pub env: Env, + pub pre: HashMap, + pub test_cases: Vec, +} + +/// Wrapper for deserializing the top-level JSON object. +#[derive(Debug)] +pub struct Tests(pub Vec); + +impl<'de> Deserialize<'de> for Tests { + fn deserialize(deserializer: D) -> Result + where + D: serde::Deserializer<'de>, + { + let test_file: HashMap> = + HashMap::deserialize(deserializer)?; + let mut ef_tests = Vec::new(); + + for test_name in test_file.keys() { + let test_data = test_file + .get(test_name) + .ok_or(serde::de::Error::missing_field("test data value"))?; + + let tx_field = test_data + .get("transaction") + .ok_or(serde::de::Error::missing_field("transaction"))? + .clone(); + let raw_tx: RawTransaction = serde_json::from_value(tx_field).map_err(|err| { + serde::de::Error::custom(format!( + "Failed to deserialize `transaction` in test {}: {}", + test_name, err + )) + })?; + + let post_field = test_data + .get("post") + .ok_or(serde::de::Error::missing_field("post"))? + .clone(); + let post: RawPost = serde_json::from_value(post_field).map_err(|err| { + serde::de::Error::custom(format!( + "Failed to deserialize `post` in test {}: {}", + test_name, err + )) + })?; + + let mut test_cases = Vec::new(); + for fork in post.forks.keys() { + if !SUPPORTED_FORKS.contains(&Into::<&str>::into(*fork)) { + continue; + } + let fork_cases = post.forks.get(fork).ok_or(serde::de::Error::custom( + "Failed to find fork in post value", + ))?; + for case in fork_cases { + let tc = build_test_case(&raw_tx, fork, case) + .map_err(|e| serde::de::Error::custom(e))?; + test_cases.push(tc); + } + } + + let env_field = test_data + .get("env") + .ok_or(serde::de::Error::missing_field("env"))?; + let test_env: Env = serde_json::from_value(env_field.clone()).map_err(|err| { + serde::de::Error::custom(format!( + "Failed to deserialize `env` in test {}: {}", + test_name, err + )) + })?; + + let pre_field = test_data + .get("pre") + .ok_or(serde::de::Error::missing_field("pre"))?; + let test_pre: HashMap = + serde_json::from_value(pre_field.clone()).map_err(|err| { + serde::de::Error::custom(format!( + "Failed to deserialize `pre` in test {}: {}", + test_name, err + )) + })?; + + ef_tests.push(Test { + name: test_name.clone(), + path: PathBuf::default(), + env: test_env, + pre: test_pre, + test_cases, + }); + } + Ok(Tests(ef_tests)) + } +} + +// ---- Environment ---- + +#[derive(Debug, Deserialize, Clone, Copy)] +#[serde(rename_all = "camelCase")] +pub struct Env { + #[serde(default, deserialize_with = "u256::deser_hex_str_opt")] + pub current_base_fee: Option, + pub current_coinbase: Address, + #[serde(deserialize_with = "u256::deser_hex_str")] + pub current_difficulty: U256, + #[serde(default, deserialize_with = "u256::deser_hex_str_opt")] + pub current_excess_blob_gas: Option, + #[serde(with = "u64::hex_str")] + pub current_gas_limit: u64, + #[serde(deserialize_with = "u256::deser_hex_str")] + pub current_number: U256, + pub current_random: Option, + #[serde(deserialize_with = "u256::deser_hex_str")] + pub current_timestamp: U256, + #[serde(default, deserialize_with = "u256::deser_hex_str_opt")] + pub slot_number: Option, +} + +// ---- Account state ---- + +#[derive(Debug, Deserialize, Clone)] +pub struct AccountState { + #[serde(deserialize_with = "u256::deser_hex_str")] + pub balance: U256, + #[serde(with = "bytes")] + pub code: Bytes, + #[serde(with = "u64::hex_str")] + pub nonce: u64, + #[serde(with = "u256::hashmap")] + pub storage: HashMap, +} + +// ---- Test case (fork x data/gas/value combo) ---- + +#[derive(Debug, Clone)] +pub struct TestCase { + pub vector: (usize, usize, usize), + pub data: Bytes, + pub gas: u64, + pub value: U256, + pub tx_bytes: Bytes, + pub gas_price: Option, + pub max_fee_per_gas: Option, + pub max_priority_fee_per_gas: Option, + pub max_fee_per_blob_gas: Option, + pub nonce: u64, + pub secret_key: H256, + pub sender: Address, + pub to: TxKind, + pub fork: Fork, + pub post: Post, + pub blob_versioned_hashes: Vec, + pub access_list: Vec, + pub authorization_list: Option>, +} + +#[derive(Debug, Clone)] +#[allow(dead_code)] +pub struct Post { + pub hash: H256, + pub logs: H256, + pub state: Option>, + pub expected_exceptions: Option>, +} + +#[derive(Debug, Deserialize, Clone)] +#[serde(rename_all = "camelCase")] +pub struct AccessListItem { + pub address: Address, + pub storage_keys: Vec, +} + +#[derive(Debug, Deserialize, Clone)] +#[serde(rename_all = "camelCase")] +#[allow(dead_code)] +pub struct AuthorizationListTupleRaw { + #[serde(deserialize_with = "u256::deser_hex_str")] + pub chain_id: U256, + pub address: Address, + #[serde(with = "u64::hex_str")] + pub nonce: u64, + #[serde(deserialize_with = "u256::deser_hex_str")] + pub v: U256, + #[serde(deserialize_with = "u256::deser_hex_str")] + pub r: U256, + #[serde(deserialize_with = "u256::deser_hex_str")] + pub s: U256, + pub signer: Option
, +} + +impl AuthorizationListTupleRaw { + pub fn into_authorization_tuple(self) -> AuthorizationTuple { + AuthorizationTuple { + chain_id: self.chain_id, + address: self.address, + nonce: self.nonce, + y_parity: self.v, + r_signature: self.r, + s_signature: self.s, + } + } +} + +// ---- Raw JSON structures ---- + +#[derive(Debug, Deserialize)] +struct RawPost { + #[serde(flatten)] + #[serde(deserialize_with = "deserialize_post")] + forks: HashMap>, +} + +#[derive(Debug, Deserialize, Clone)] +struct RawPostValue { + #[serde(rename = "expectException", default)] + expect_exception: Option, + hash: H256, + #[serde(deserialize_with = "deserialize_ef_post_value_indexes")] + indexes: HashMap, + logs: H256, + #[serde(default, with = "bytes")] + txbytes: Bytes, + state: Option>, +} + +#[derive(Debug, Deserialize)] +#[serde(rename_all = "camelCase")] +struct RawTransaction { + #[serde(with = "bytes::vec")] + data: Vec, + #[serde(deserialize_with = "u64::hex_str::deser_vec")] + gas_limit: Vec, + #[serde(default, deserialize_with = "u256::deser_hex_str_opt")] + gas_price: Option, + #[serde(with = "u64::hex_str")] + nonce: u64, + secret_key: H256, + sender: Address, + to: TxKind, + #[serde(with = "u256::vec")] + value: Vec, + #[serde(default, deserialize_with = "u256::deser_hex_str_opt")] + max_fee_per_gas: Option, + #[serde(default, deserialize_with = "u256::deser_hex_str_opt")] + max_priority_fee_per_gas: Option, + #[serde(default, deserialize_with = "u256::deser_hex_str_opt")] + max_fee_per_blob_gas: Option, + blob_versioned_hashes: Option>, + #[serde(default, deserialize_with = "deserialize_access_lists")] + access_lists: Option>>, + #[serde(default, deserialize_with = "deserialize_authorization_lists")] + authorization_list: Option>, +} + +// ---- Test case builder ---- + +fn build_test_case( + raw_tx: &RawTransaction, + fork: &Fork, + raw_post: &RawPostValue, +) -> Result { + let data_index = raw_post + .indexes + .get("data") + .ok_or("missing data index")? + .as_usize(); + let value_index = raw_post + .indexes + .get("value") + .ok_or("missing value index")? + .as_usize(); + let gas_index = raw_post + .indexes + .get("gas") + .ok_or("missing gas index")? + .as_usize(); + + let access_list_raw = raw_tx.access_lists.clone().unwrap_or_default(); + let access_list = if !access_list_raw.is_empty() { + access_list_raw + .get(data_index) + .cloned() + .unwrap_or_default() + } else { + Vec::new() + }; + + let expected_exceptions = raw_post.expect_exception.as_ref().map(|s| { + s.split('|').map(|part| part.trim().to_string()).collect() + }); + + Ok(TestCase { + vector: (data_index, value_index, gas_index), + data: raw_tx.data[data_index].clone(), + value: raw_tx.value[value_index], + gas: raw_tx.gas_limit[gas_index], + tx_bytes: raw_post.txbytes.clone(), + gas_price: raw_tx.gas_price, + nonce: raw_tx.nonce, + secret_key: raw_tx.secret_key, + sender: raw_tx.sender, + max_fee_per_blob_gas: raw_tx.max_fee_per_blob_gas, + max_fee_per_gas: raw_tx.max_fee_per_gas, + max_priority_fee_per_gas: raw_tx.max_priority_fee_per_gas, + to: raw_tx.to.clone(), + fork: *fork, + authorization_list: raw_tx.authorization_list.clone(), + access_list, + blob_versioned_hashes: raw_tx.blob_versioned_hashes.clone().unwrap_or_default(), + post: Post { + hash: raw_post.hash, + logs: raw_post.logs, + state: raw_post.state.clone(), + expected_exceptions, + }, + }) +} + +// ---- Chain config from fork ---- + +pub fn chain_config_for_fork(fork: &Fork) -> ChainConfig { + let mut cfg = ChainConfig { + chain_id: 1, + homestead_block: Some(0), + dao_fork_block: Some(0), + dao_fork_support: true, + eip150_block: Some(0), + eip155_block: Some(0), + eip158_block: Some(0), + byzantium_block: Some(0), + constantinople_block: Some(0), + petersburg_block: Some(0), + istanbul_block: Some(0), + muir_glacier_block: Some(0), + berlin_block: Some(0), + london_block: Some(0), + arrow_glacier_block: Some(0), + gray_glacier_block: Some(0), + merge_netsplit_block: Some(0), + shanghai_time: None, + cancun_time: None, + prague_time: None, + verkle_time: None, + osaka_time: None, + terminal_total_difficulty: Some(0), + terminal_total_difficulty_passed: true, + blob_schedule: BlobSchedule::default(), + deposit_contract_address: H160::from_str( + "0x4242424242424242424242424242424242424242", + ) + .unwrap(), + ..Default::default() + }; + + if *fork >= Fork::Shanghai { + cfg.shanghai_time = Some(0); + } + if *fork >= Fork::Cancun { + cfg.cancun_time = Some(0); + } + if *fork >= Fork::Prague { + cfg.prague_time = Some(0); + } + if *fork >= Fork::Osaka { + cfg.osaka_time = Some(0); + } + if *fork >= Fork::Amsterdam { + cfg.amsterdam_time = Some(0); + } + + cfg +} + +// ---- Custom deserializers ---- + +fn deserialize_ef_post_value_indexes<'de, D>( + deserializer: D, +) -> Result, D::Error> +where + D: serde::Deserializer<'de>, +{ + let aux: HashMap = HashMap::deserialize(deserializer)?; + Ok(aux.into_iter().map(|(k, v)| (k, U256::from(v))).collect()) +} + +fn deserialize_access_lists<'de, D>( + deserializer: D, +) -> Result>>, D::Error> +where + D: serde::Deserializer<'de>, +{ + let lists: Option>>> = Option::deserialize(deserializer)?; + Ok(lists.map(|ls| ls.into_iter().map(|l| l.unwrap_or_default()).collect())) +} + +fn deserialize_authorization_lists<'de, D>( + deserializer: D, +) -> Result>, D::Error> +where + D: serde::Deserializer<'de>, +{ + Option::>::deserialize(deserializer) +} + +fn deserialize_post<'de, D>( + deserializer: D, +) -> Result>, D::Error> +where + D: serde::Deserializer<'de>, +{ + let raw = HashMap::>::deserialize(deserializer)?; + let mut parsed = HashMap::new(); + for (fork_str, values) in raw { + let fork = match fork_str.as_str() { + "Frontier" => Fork::Frontier, + "Homestead" => Fork::Homestead, + "Constantinople" => Fork::Constantinople, + "ConstantinopleFix" | "Petersburg" => Fork::Petersburg, + "Istanbul" => Fork::Istanbul, + "Berlin" => Fork::Berlin, + "London" => Fork::London, + "Paris" | "Merge" => Fork::Paris, + "Shanghai" => Fork::Shanghai, + "Cancun" => Fork::Cancun, + "Prague" => Fork::Prague, + "Byzantium" => Fork::Byzantium, + "EIP158" => Fork::SpuriousDragon, + "EIP150" => Fork::Tangerine, + "Osaka" => Fork::Osaka, + "Amsterdam" => Fork::Amsterdam, + other => { + return Err(serde::de::Error::custom(format!( + "Unknown fork name: {other}" + ))); + } + }; + parsed.insert(fork, values); + } + Ok(parsed) +}