From 418f1c0a9493750ebd4cbe37be333d088bb09a9e Mon Sep 17 00:00:00 2001 From: Wodann Date: Tue, 17 Nov 2026 05:41:38 +0000 Subject: [PATCH] test: pin the field set of debug_trace* struct logs No test rejected a struct log field outside the spec's StructLog schema. A field that revm-inspectors or alloy added would pass every test. EDR serialises the struct log verbatim, so it would reach every consumer. The new test traces a call into a loop that runs out of gas, with memory and return data enabled. Its steps carry all eleven StructLog fields. The test asserts that no step has any other field. It also asserts that the steps together have every field, so an empty or partial trace cannot pass it. The trace's top-level fields are pinned to the OpcodeTransactionTrace set. --- .../src/requests/debug/tests/edr.rs | 93 +++++++++++++++++++ 1 file changed, 93 insertions(+) diff --git a/crates/edr_provider/src/requests/debug/tests/edr.rs b/crates/edr_provider/src/requests/debug/tests/edr.rs index a3db3fd75b..c1b5651666 100644 --- a/crates/edr_provider/src/requests/debug/tests/edr.rs +++ b/crates/edr_provider/src/requests/debug/tests/edr.rs @@ -17,9 +17,60 @@ //! - The spec does not define `debug_traceCall`, so EDR follows geth. It //! defaults to the latest block, traces a creation without a recipient and //! persists no state. +//! - The spec's `StructLog` and `OpcodeTransactionTrace` schemas do not forbid +//! additional properties. EDR pins their field sets anyway. EDR serialises +//! alloy's `StructLog`, which revm-inspectors fills, verbatim. A field added +//! by either crate would reach every consumer of the trace. Such a field must +//! be deliberate and get a changeset. The test also asserts that the steps +//! together carry every field, so an empty or partial trace cannot pass it. +//! From Amsterdam, EDR adds the EIP-8037 `stateGasCost` and +//! `stateGasReservoir` fields deliberately, and the `eip8037` integration +//! tests pin them. + +use std::collections::BTreeSet; use super::*; +/// The properties of the spec's `OpcodeTransactionTrace` schema. +const TRACE_FIELDS: [&str; 4] = ["failed", "gas", "returnValue", "structLogs"]; +/// The properties of the spec's `StructLog` schema. +const STRUCT_LOG_FIELDS: [&str; 11] = [ + "pc", + "op", + "gas", + "gasCost", + "depth", + "error", + "refund", + "stack", + "memory", + "returnData", + "storage", +]; + +/// Gas cost of a cold account access, in gas units (EIP-2929). +const COLD_ACCOUNT_ACCESS_COST: u64 = 2_600; +/// Gas limit of a transaction to `caller_code` whose callee loops, in gas +/// units. It pays the caller's cold `SSTORE` and cold `CALL`, and leaves +/// `LOOP_GAS_BUDGET` for the caller's other steps and the callee. The callee +/// exhausts all but the sixty-fourth that EIP-150 keeps back, and that share +/// pays the caller's steps after the call. +const CALLING_LOOP_GAS_LIMIT: u64 = TRANSACTION_BASE_GAS + + COLD_SLOAD_COST + + SSTORE_SET_GAS + + COLD_ACCOUNT_ACCESS_COST + + LOOP_GAS_BUDGET; + +/// Returns the keys of a JSON object, and panics when `object` is not one. +fn keys(object: &Value) -> BTreeSet<&str> { + object + .as_object() + .unwrap_or_else(|| panic!("an object is expected, got {object}")) + .keys() + .map(String::as_str) + .collect() +} + #[test] fn undefined_opcode_is_reported_as_unknown() -> anyhow::Result<()> { let trace = trace_contract_transaction(&[(CONTRACT, &[UNDEFINED_OPCODE])], None)?; @@ -239,3 +290,45 @@ fn trace_call_does_not_persist_state() -> anyhow::Result<()> { Ok(()) } + +#[test] +fn trace_and_struct_logs_have_exactly_the_spec_fields() -> anyhow::Result<()> { + let mut fixture = TraceFixture::new(&[ + (CONTRACT, &caller_code(CallKind::Call)), + (CALLEE, &INFINITE_LOOP_CODE), + ])?; + let transaction_hash = fixture.send( + TxKind::Call(CONTRACT), + &[], + CALLING_LOOP_GAS_LIMIT, + U256::ZERO, + )?; + + let trace = fixture.trace_transaction( + transaction_hash, + Some(json!({ "enableMemory": true, "enableReturnData": true })), + )?; + + assert_eq!( + keys(&trace), + BTreeSet::from(TRACE_FIELDS), + "the trace should carry only the OpcodeTransactionTrace fields" + ); + let struct_log_fields = BTreeSet::from(STRUCT_LOG_FIELDS); + let mut step_fields = BTreeSet::new(); + for step in struct_logs(&trace) { + for key in keys(step) { + assert!( + struct_log_fields.contains(key), + "`{key}` is not a spec field in {step}" + ); + step_fields.insert(key); + } + } + assert_eq!( + step_fields, struct_log_fields, + "the steps should together exercise every StructLog field" + ); + + Ok(()) +}