From ea71363f10fe19f3991f4aeace5165c849e57d3d Mon Sep 17 00:00:00 2001 From: Wodann Date: Fri, 2 Oct 2026 19:05:54 +0000 Subject: [PATCH 1/4] bench: add --vm-step-listener to benchmark the trace-reading path Hardhat 2 only reads the EVM traces of a response when a VM event listener exists. Plugins like coverage or tracers register one, but the harness registered none, so it never measured that path. --- js/benchmark/README.md | 6 ++++++ js/benchmark/src/index.ts | 22 ++++++++++++++++++---- 2 files changed, 24 insertions(+), 4 deletions(-) diff --git a/js/benchmark/README.md b/js/benchmark/README.md index f6fcb35a63..d992910195 100644 --- a/js/benchmark/README.md +++ b/js/benchmark/README.md @@ -18,6 +18,12 @@ pnpm providerBenchmark --benchmark-output provider-report.json This will run all the provider benchmarks, and it will save the measurements to `./provider-report.json` as json. +Hardhat 2 only reads the EVM traces of a response when a plugin listens to VM events, like coverage or tracer plugins do. To benchmark that path, pass `--vm-step-listener`; it registers a no-op `step` listener: + +```shell +pnpm providerBenchmark --benchmark-output provider-report.json --vm-step-listener +``` + The CI is set up to run `providerBenchmark` on every commit in `main`, save the measurements and then compare PRs against the latest measurements from `main`. The measurements from `main` are visualized [here.](https://nomic-foundation-automation.github.io/edr-benchmark-results/bench/) ## Solidity Test Benchmarks diff --git a/js/benchmark/src/index.ts b/js/benchmark/src/index.ts index be326f7750..17c52d1864 100644 --- a/js/benchmark/src/index.ts +++ b/js/benchmark/src/index.ts @@ -60,6 +60,8 @@ interface ParsedArguments { // eslint-disable-next-line @typescript-eslint/naming-convention forge_path?: string; verbosity?: number; + // eslint-disable-next-line @typescript-eslint/naming-convention + vm_step_listener: boolean; } interface BenchmarkScenarioResult { @@ -139,6 +141,10 @@ async function main(): Promise { type: "int", help: `Hardhat verbosity level (0-5, i.e. -v to -vvvvv) for the \`solidity-tests-memory\` command. Pass one level per run; omit to measure verbosities ${MEMORY_VERBOSITIES.join(", ")}, the ones with distinct trace-collection behaviour.`, }); + parser.add_argument("--vm-step-listener", { + action: "store_true", + help: "Register a no-op `step` listener on the Hardhat 2 VM for the `provider-benchmark` command. Hardhat 2 only reads the EVM traces of a response when a VM listener exists, as with coverage or tracer plugins.", + }); const args: ParsedArguments = parser.parse_args(); // if --benchmark-output is relative, resolve it relatively to cwd @@ -155,11 +161,14 @@ async function main(): Promise { if (scenarioFileName.includes(args.grep)) { // We store the results to avoid GC // eslint-disable-next-line @typescript-eslint/no-unused-vars - results = await benchmarkScenario(scenarioFileName); + results = await benchmarkScenario( + scenarioFileName, + args.vm_step_listener + ); } } } else { - benchmarkAllScenarios(benchmarkOutputPath); + benchmarkAllScenarios(benchmarkOutputPath, args.vm_step_listener); } } else if (args.command === "verify-provider-benchmark") { return verify(benchmarkOutputPath); @@ -388,7 +397,7 @@ function setDifference(a: Set, b: Set): Set { return new Set(Array.from(a).filter((item) => !b.has(item))); } -function benchmarkAllScenarios(outPath: string) { +function benchmarkAllScenarios(outPath: string, vmStepListener: boolean) { const result: any = {}; let totalTime = 0; let totalFailures = 0; @@ -403,6 +412,7 @@ function benchmarkAllScenarios(outPath: string) { "provider-benchmark", "-g", scenarioFileName, + ...(vmStepListener ? ["--vm-step-listener"] : []), ]; let processResult: SpawnSyncReturns | undefined; @@ -480,7 +490,8 @@ function medianOfResults(results: BenchmarkScenarioResult[]) { } async function benchmarkScenario( - scenarioFileName: string + scenarioFileName: string, + vmStepListener: boolean ): Promise { const { config, requests } = await loadScenario(scenarioFileName); const name = path.basename(scenarioFileName).split(".")[0]; @@ -491,6 +502,9 @@ async function benchmarkScenario( const provider = await createHardhatNetworkProvider(config.providerConfig, { enabled: config.loggerEnabled, }); + if (vmStepListener) { + provider._node._vm.evm.events.on("step", () => {}); + } const failures = []; const rpcCallResults = []; From 9880dba4d28c47ef8ede37f3a39219d4b3c01063 Mon Sep 17 00:00:00 2001 From: Wodann Date: Fri, 2 Oct 2026 21:03:29 +0000 Subject: [PATCH 2/4] feat: allow toggling includeCallTraces at runtime `Provider.setIncludeCallTraces` sets which call traces the responses of later requests include. It follows the `setVerboseTracing` plumbing: `SyncProvider`, then `Provider`, then a `SetIncludeCallTraces` message that the event loop applies to `ProviderData`. Traces that are not included are never collected. A consumer that reads traces conditionally can keep collection off while nothing reads them. --- .changeset/brave-owls-toggle.md | 5 +++++ crates/edr_napi/index.d.ts | 10 +++++++++ crates/edr_napi/src/mock.rs | 7 +++++++ crates/edr_napi/src/provider.rs | 22 +++++++++++++++++++- crates/edr_napi/test/provider.ts | 29 +++++++++++++++++++++++---- crates/edr_napi_core/src/provider.rs | 10 +++++++++ crates/edr_provider/src/data.rs | 5 +++++ crates/edr_provider/src/event_loop.rs | 12 +++++++++++ crates/edr_provider/src/provider.rs | 16 ++++++++++++++- 9 files changed, 110 insertions(+), 6 deletions(-) create mode 100644 .changeset/brave-owls-toggle.md diff --git a/.changeset/brave-owls-toggle.md b/.changeset/brave-owls-toggle.md new file mode 100644 index 0000000000..5c1c561d6e --- /dev/null +++ b/.changeset/brave-owls-toggle.md @@ -0,0 +1,5 @@ +--- +"@nomicfoundation/edr": minor +--- + +Added `Provider::setIncludeCallTraces` method to change which call traces are collected for subsequent requests diff --git a/crates/edr_napi/index.d.ts b/crates/edr_napi/index.d.ts index a4768612d4..5de71fb113 100644 --- a/crates/edr_napi/index.d.ts +++ b/crates/edr_napi/index.d.ts @@ -87,6 +87,16 @@ export declare class Provider { * `false` to disable this. */ setVerboseTracing(verboseTracing: boolean): Promise + /** + * Sets which transactions' call traces the `traces()` and `callTraces()` + * of later responses include. Requests handled after the returned promise + * resolves use the new value. + * + * Traces that are not included are never collected. Consumers that read + * traces conditionally can keep this at `IncludeTraces.None` while + * nothing reads them, and avoid the collection cost. + */ + setIncludeCallTraces(includeCallTraces: IncludeTraces): Promise } export declare class ProviderFactory {} diff --git a/crates/edr_napi/src/mock.rs b/crates/edr_napi/src/mock.rs index 3d7b5de94f..ab8442cfae 100644 --- a/crates/edr_napi/src/mock.rs +++ b/crates/edr_napi/src/mock.rs @@ -51,4 +51,11 @@ impl SyncProvider for MockProvider { fn set_verbose_tracing(&self, _enabled: bool) -> napi::Result<()> { Ok(()) } + + fn set_include_call_traces( + &self, + _include_call_traces: edr_solidity::config::IncludeTraces, + ) -> napi::Result<()> { + Ok(()) + } } diff --git a/crates/edr_napi/src/provider.rs b/crates/edr_napi/src/provider.rs index 25e53e26a3..91f2221bda 100644 --- a/crates/edr_napi/src/provider.rs +++ b/crates/edr_napi/src/provider.rs @@ -25,7 +25,7 @@ pub use self::factory::ProviderFactory; use self::response::{call_trace_external_mem_size, GcResponse, Response}; use crate::{ async_deallocator::AsyncDeallocatorSender, call_override::CallOverrideCallback, - contract_decoder::ContractDecoder, gc::gc_tracked, + contract_decoder::ContractDecoder, gc::gc_tracked, solidity_tests::config::IncludeTraces, }; /// A JSON-RPC provider for Ethereum. @@ -318,6 +318,26 @@ impl Provider { .await .map_err(|error| napi::Error::new(Status::GenericFailure, error.to_string()))? } + + /// Sets which transactions' call traces the `traces()` and `callTraces()` + /// of later responses include. Requests handled after the returned promise + /// resolves use the new value. + /// + /// Traces that are not included are never collected. Consumers that read + /// traces conditionally can keep this at `IncludeTraces.None` while + /// nothing reads them, and avoid the collection cost. + #[napi(catch_unwind)] + pub async fn set_include_call_traces( + &self, + include_call_traces: IncludeTraces, + ) -> napi::Result<()> { + let provider = self.provider.clone(); + + self.runtime + .spawn_blocking(move || provider.set_include_call_traces(include_call_traces.into())) + .await + .map_err(|error| napi::Error::new(Status::GenericFailure, error.to_string()))? + } } gc_tracked! { diff --git a/crates/edr_napi/test/provider.ts b/crates/edr_napi/test/provider.ts index cc74f9ffd8..65185e2448 100644 --- a/crates/edr_napi/test/provider.ts +++ b/crates/edr_napi/test/provider.ts @@ -242,10 +242,8 @@ describe("Provider", () => { assert.deepEqual(steps[3].stack, [1n, 2n, 3n]); }); - async function pushThreeAndStopStacks( - provider: Provider - ): Promise { - const responseObject = await provider.handleRequest( + function sendPushThreeAndStop(provider: Provider): Promise { + return provider.handleRequest( JSON.stringify({ id: 1, jsonrpc: "2.0", @@ -263,6 +261,12 @@ describe("Provider", () => { ], }) ); + } + + async function pushThreeAndStopStacks( + provider: Provider + ): Promise { + const responseObject = await sendPushThreeAndStop(provider); const rawTraces = responseObject.traces(); assert.lengthOf(rawTraces, 1); @@ -311,6 +315,23 @@ describe("Provider", () => { assert.deepEqual(await pushThreeAndStopStacks(provider), TOP_OF_STACK); }); + it("should follow setIncludeCallTraces for subsequent requests", async function () { + const provider = await createGenericProvider(context, { + genesisState: fundedGenesisState(), + observability: { + recordStack: StackSnapshotType.Top, + }, + }); + + assert.lengthOf((await sendPushThreeAndStop(provider)).traces(), 0); + + await provider.setIncludeCallTraces(IncludeTraces.All); + assert.deepEqual(await pushThreeAndStopStacks(provider), TOP_OF_STACK); + + await provider.setIncludeCallTraces(IncludeTraces.None); + assert.lengthOf((await sendPushThreeAndStop(provider)).traces(), 0); + }); + it("should include the top of the stack across nested call frames", async function () { const provider = await createGenericProvider(context, { ...tracingProviderOverrides, diff --git a/crates/edr_napi_core/src/provider.rs b/crates/edr_napi_core/src/provider.rs index 1f84d98a7d..5a809d8f67 100644 --- a/crates/edr_napi_core/src/provider.rs +++ b/crates/edr_napi_core/src/provider.rs @@ -4,6 +4,7 @@ use std::{str::FromStr as _, sync::Arc}; use edr_provider::{time::TimeSinceEpoch, InvalidRequestReason, SyncCallOverride}; use edr_rpc_client::jsonrpc; +use edr_solidity::config::IncludeTraces; pub use self::config::{Config, ConfigOption}; use crate::spec::{Response, SyncNapiSpec}; @@ -34,6 +35,10 @@ pub trait SyncProvider: Send + Sync { /// Set the verbose tracing flag to the provided value. fn set_verbose_tracing(&self, enabled: bool) -> napi::Result<()>; + + /// Sets which transactions' call traces are included in responses, for + /// requests handled from this point on. + fn set_include_call_traces(&self, include_call_traces: IncludeTraces) -> napi::Result<()>; } impl, TimerT: Clone + TimeSinceEpoch> SyncProvider @@ -72,6 +77,11 @@ impl, TimerT: Clone + TimeSinceEpoch> SyncProvi edr_provider::Provider::set_verbose_tracing(self, enabled) .map_err(|error| napi::Error::new(napi::Status::GenericFailure, error.to_string())) } + + fn set_include_call_traces(&self, include_call_traces: IncludeTraces) -> napi::Result<()> { + edr_provider::Provider::set_include_call_traces(self, include_call_traces) + .map_err(|error| napi::Error::new(napi::Status::GenericFailure, error.to_string())) + } } /// Constructs the JSON-RPC error response for a request that failed to diff --git a/crates/edr_provider/src/data.rs b/crates/edr_provider/src/data.rs index 8787a82a47..09e1dc566e 100644 --- a/crates/edr_provider/src/data.rs +++ b/crates/edr_provider/src/data.rs @@ -490,6 +490,11 @@ where self.observability.verbose_raw_tracing = verbose_tracing; } + /// Sets which transactions' call traces responses include. + pub fn set_include_call_traces(&mut self, include_call_traces: IncludeTraces) { + self.observability.include_call_traces = include_call_traces; + } + pub fn stop_impersonating_account(&mut self, address: Address) -> bool { self.impersonated_accounts.remove(&address) } diff --git a/crates/edr_provider/src/event_loop.rs b/crates/edr_provider/src/event_loop.rs index a4cb44c457..8c13e08428 100644 --- a/crates/edr_provider/src/event_loop.rs +++ b/crates/edr_provider/src/event_loop.rs @@ -15,6 +15,7 @@ use std::{ use crossbeam_channel::{Receiver, Sender}; use edr_chain_spec::TransactionValidation; use edr_chain_spec_provider::ProviderChainSpec; +use edr_solidity::config::IncludeTraces; use edr_transaction::{IsEip155, IsEip4844, TransactionMut, TransactionType}; use crate::{ @@ -90,6 +91,11 @@ pub(crate) enum Message { }, /// Set whether traces include the full stack and memory. SetVerboseTracing { enabled: bool, ack: Sender<()> }, + /// Set which transactions' call traces responses include. + SetIncludeCallTraces { + include_call_traces: IncludeTraces, + ack: Sender<()>, + }, /// Log a failed request deserialization through the provider's logger. /// Not acknowledged, so a caller on the JS main thread is never blocked. LogFailedDeserialization { @@ -172,6 +178,12 @@ pub(crate) fn run( // Ignore the error: the caller may have stopped waiting. let _ = ack.send(()); } + Ok(Message::SetIncludeCallTraces { include_call_traces, ack }) => { + data.set_include_call_traces(include_call_traces); + + // Ignore the error: the caller may have stopped waiting. + let _ = ack.send(()); + } Ok(Message::LogFailedDeserialization { method_name, error }) => { if let Err(error) = data .logger_mut() diff --git a/crates/edr_provider/src/provider.rs b/crates/edr_provider/src/provider.rs index 96f64d6bed..d227e49966 100644 --- a/crates/edr_provider/src/provider.rs +++ b/crates/edr_provider/src/provider.rs @@ -2,7 +2,7 @@ use std::{marker::PhantomData, sync::Arc}; use crossbeam_channel::{bounded, unbounded, RecvError, Sender}; use edr_chain_spec::{ProtocolHardforkChainSpec, TransactionValidation}; -use edr_solidity::contract_decoder::ContractDecoder; +use edr_solidity::{config::IncludeTraces, contract_decoder::ContractDecoder}; use edr_transaction::{IsEip155, IsEip4844, TransactionMut, TransactionType}; use edr_utils_sync::CancellableThread; use parking_lot::RwLock; @@ -105,6 +105,20 @@ impl, TimerT: Clone + TimeSinceEpoch> let _ = self.send_message(Message::SetVerboseTracing { enabled, ack }); }) } + + /// Sets which transactions' call traces are included in responses, for + /// requests handled from this point on. + pub fn set_include_call_traces( + &self, + include_call_traces: IncludeTraces, + ) -> Result<(), ProviderErrorForChainSpec> { + Self::wait_for_reply(|ack| { + let _ = self.send_message(Message::SetIncludeCallTraces { + include_call_traces, + ack, + }); + }) + } } impl< From 454b7c7bfa3dfb1a59f72aede63a0bf70e877cfc Mon Sep 17 00:00:00 2001 From: Wodann Date: Fri, 2 Oct 2026 21:03:34 +0000 Subject: [PATCH 3/4] perf(hardhat): collect call traces only while listeners exist Hardhat 2 created its provider with `includeCallTraces: All`. Every response then recorded and retained a call trace arena, even without a VM event listener to read it. The provider is now created without call traces. Before each request, the wrapper evaluates whether a VM event listener exists. When that differs from the last applied value, it calls `setIncludeCallTraces`. `hardhat_reset` recreates the provider from the creation-time config, so the tracked value resets with it. --- .../provider/trace-event-bridge.ts | 139 +++++++++++++++--- patches/hardhat@2.28.6.patch | 129 ++++++++++++---- pnpm-lock.yaml | 8 +- 3 files changed, 224 insertions(+), 52 deletions(-) diff --git a/hardhat-tests/test/internal/hardhat-network/provider/trace-event-bridge.ts b/hardhat-tests/test/internal/hardhat-network/provider/trace-event-bridge.ts index e28314ebd6..7928b69288 100644 --- a/hardhat-tests/test/internal/hardhat-network/provider/trace-event-bridge.ts +++ b/hardhat-tests/test/internal/hardhat-network/provider/trace-event-bridge.ts @@ -3,16 +3,18 @@ import { createHardhatNetworkProvider } from "hardhat/internal/hardhat-network/p import { DEFAULT_ACCOUNTS } from "../helpers/providers"; +// Init code executing exactly 4 steps: PUSH1 1, PUSH1 2, PUSH1 3, STOP +const FOUR_STEP_INIT_CODE = "0x60016002600300"; +const FOUR_STEP_INIT_CODE_STEPS = 4; + interface VmEventCounts { steps: number; beforeMessages: number; afterMessages: number; } -async function sendTransactionCountingVmEvents( - data: string -): Promise { - const provider: any = await createHardhatNetworkProvider( +async function createProvider(): Promise { + return createHardhatNetworkProvider( { hardfork: "cancun", chainId: 123, @@ -33,6 +35,43 @@ async function sendTransactionCountingVmEvents( }, { enabled: false } ); +} + +async function sendTransaction(provider: any, data: string): Promise { + const [sender] = (await provider.request({ + method: "eth_accounts", + })) as string[]; + + await provider.request({ + method: "eth_sendTransaction", + params: [{ from: sender, data, gas: "0x100000" }], + }); + + // The minimal vm uses AsyncEventEmitter: listeners run on a later tick + await new Promise((resolve) => setImmediate(resolve)); +} + +/** + * Records the number of call traces of each response the wrapper's current + * EDR provider returns. `hardhat_reset` replaces that provider, so call this + * again after a reset. + */ +function recordTraceCounts(provider: any): number[] { + const traceCounts: number[] = []; + const edrProvider = provider._provider; + const handleRequest = edrProvider.handleRequest.bind(edrProvider); + edrProvider.handleRequest = async (request: string) => { + const response = await handleRequest(request); + traceCounts.push(response.traces().length); + return response; + }; + return traceCounts; +} + +async function sendTransactionCountingVmEvents( + data: string +): Promise { + const provider = await createProvider(); const counts: VmEventCounts = { steps: 0, @@ -49,29 +88,18 @@ async function sendTransactionCountingVmEvents( counts.afterMessages += 1; }); - const [sender] = (await provider.request({ - method: "eth_accounts", - })) as string[]; - - await provider.request({ - method: "eth_sendTransaction", - params: [{ from: sender, data, gas: "0x100000" }], - }); - - // The minimal vm uses AsyncEventEmitter: listeners run on a later tick - await new Promise((resolve) => setImmediate(resolve)); + await sendTransaction(provider, data); return counts; } describe("Trace-event bridge", function () { it("emits step/beforeMessage/afterMessage on a transaction", async function () { - // Init code executing exactly 4 steps: PUSH1 1, PUSH1 2, PUSH1 3, STOP - const counts = await sendTransactionCountingVmEvents("0x60016002600300"); + const counts = await sendTransactionCountingVmEvents(FOUR_STEP_INIT_CODE); assert.equal(counts.beforeMessages, 1, "beforeMessage events"); assert.equal(counts.afterMessages, 1, "afterMessage events"); - assert.equal(counts.steps, 4, "step events"); + assert.equal(counts.steps, FOUR_STEP_INIT_CODE_STEPS, "step events"); }); it("emits beforeMessage/afterMessage for a precompile call", async function () { @@ -86,4 +114,79 @@ describe("Trace-event bridge", function () { assert.equal(counts.afterMessages, 2, "afterMessage events"); assert.equal(counts.steps, 9, "step events"); }); + + it("collects no call traces while no VM listener is registered", async function () { + const provider = await createProvider(); + const traceCounts = recordTraceCounts(provider); + + await sendTransaction(provider, FOUR_STEP_INIT_CODE); + + assert.deepEqual(traceCounts, [0, 0], "traces per response"); + }); + + it("collects call traces only while a VM listener is registered", async function () { + const provider = await createProvider(); + const traceCounts = recordTraceCounts(provider); + + let steps = 0; + const onStep = () => { + steps += 1; + }; + + provider._node._vm.evm.events.on("step", onStep); + await sendTransaction(provider, FOUR_STEP_INIT_CODE); + assert.equal(steps, FOUR_STEP_INIT_CODE_STEPS, "steps while registered"); + + provider._node._vm.evm.events.off("step", onStep); + await sendTransaction(provider, FOUR_STEP_INIT_CODE); + assert.equal(steps, FOUR_STEP_INIT_CODE_STEPS, "steps after removal"); + + // eth_accounts, then eth_sendTransaction, per transaction + assert.deepEqual(traceCounts, [0, 1, 0, 0], "traces per response"); + }); + + it("keeps emitting step events for a listener registered across hardhat_reset", async function () { + const provider = await createProvider(); + + let steps = 0; + provider._node._vm.evm.events.on("step", () => { + steps += 1; + }); + + await sendTransaction(provider, FOUR_STEP_INIT_CODE); + await provider.request({ method: "hardhat_reset", params: [] }); + await sendTransaction(provider, FOUR_STEP_INIT_CODE); + + assert.equal(steps, 2 * FOUR_STEP_INIT_CODE_STEPS, "step events"); + }); + + it("follows a listener removed before and re-added after hardhat_reset", async function () { + const provider = await createProvider(); + + let steps = 0; + const onStep = () => { + steps += 1; + }; + + provider._node._vm.evm.events.on("step", onStep); + await sendTransaction(provider, FOUR_STEP_INIT_CODE); + provider._node._vm.evm.events.off("step", onStep); + + await provider.request({ method: "hardhat_reset", params: [] }); + const traceCountsAfterReset = recordTraceCounts(provider); + + await sendTransaction(provider, FOUR_STEP_INIT_CODE); + assert.equal(steps, FOUR_STEP_INIT_CODE_STEPS, "steps while removed"); + + provider._node._vm.evm.events.on("step", onStep); + await sendTransaction(provider, FOUR_STEP_INIT_CODE); + assert.equal(steps, 2 * FOUR_STEP_INIT_CODE_STEPS, "steps after re-adding"); + + // eth_accounts, then eth_sendTransaction, per transaction + assert.deepEqual( + traceCountsAfterReset, + [0, 0, 0, 1], + "traces per response after reset" + ); + }); }); diff --git a/patches/hardhat@2.28.6.patch b/patches/hardhat@2.28.6.patch index a54ae10791..2d459b46b5 100644 --- a/patches/hardhat@2.28.6.patch +++ b/patches/hardhat@2.28.6.patch @@ -1,16 +1,18 @@ diff --git a/internal/hardhat-network/provider/provider.d.ts b/internal/hardhat-network/provider/provider.d.ts -index abba026d4e3dcbe3658047c20a5cc4fcfd43ffdb..5e3578f963ed2b8e020425be35145665f680a926 100644 +index abba026d4e3dcbe3658047c20a5cc4fcfd43ffdb..d4289a10fa312deb108e70d8b732185eac041461 100644 --- a/internal/hardhat-network/provider/provider.d.ts +++ b/internal/hardhat-network/provider/provider.d.ts -@@ -38,6 +38,8 @@ export declare class EdrProviderWrapper extends EventEmitter implements EIP1193P +@@ -38,7 +38,10 @@ export declare class EdrProviderWrapper extends EventEmitter implements EIP1193P private readonly _originalGenesisAccounts; private readonly _originalCacheDir; private readonly _originalChainOverrides; + private readonly _originalGenesisBlockGasLimit; + private readonly _originalGenesisBlockTime; private _failedStackTraces; ++ private _callTracesEnabled; private _callOverrideCallback?; private constructor(); + static create(config: HardhatNetworkProviderConfig, loggerConfig: LoggerConfig, tracingConfig?: TracingConfigWithBuffers): Promise; diff --git a/internal/hardhat-network/provider/provider.d.ts.map b/internal/hardhat-network/provider/provider.d.ts.map index 660aca206496602e24483581278607023d4e52d3..8cea6390b517149bf07f70fb4b57bf16fb70481f 100644 --- a/internal/hardhat-network/provider/provider.d.ts.map @@ -21,7 +23,7 @@ index 660aca206496602e24483581278607023d4e52d3..8cea6390b517149bf07f70fb4b57bf16 +{"version":3,"file":"provider.d.ts","sourceRoot":"","sources":["../../../src/internal/hardhat-network/provider/provider.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EAGT,eAAe,EAEf,0BAA0B,EAC1B,gBAAgB,EACjB,MAAM,gBAAgB,CAAC;AAExB,OAAO,KAAK,EACV,UAAU,EAKV,wBAAwB,EAKzB,MAAM,sBAAsB,CAAC;AAU9B,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAoCtC,OAAO,EACL,UAAU,EACV,cAAc,EACd,oBAAoB,EACpB,YAAY,EACb,MAAM,cAAc,CAAC;AAUtB,OAAO,EAAE,YAAY,EAA8B,MAAM,kBAAkB,CAAC;AAO5E,eAAO,MAAM,gBAAgB,+CAA+C,CAAC;AAI7E,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,UAAU,CAAC,CAgB/D;AAED,UAAU,4BAA4B;IACpC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,aAAa,EAAE,MAAM,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,OAAO,CAAC;IAClB,cAAc,EAAE,oBAAoB,CAAC;IACrC,YAAY,EAAE,YAAY,CAAC;IAC3B,MAAM,EAAE,0BAA0B,CAAC;IACnC,eAAe,EAAE,cAAc,EAAE,CAAC;IAClC,0BAA0B,EAAE,OAAO,CAAC;IACpC,0BAA0B,EAAE,OAAO,CAAC;IACpC,mBAAmB,EAAE,OAAO,CAAC;IAC7B,4BAA4B,EAAE,OAAO,CAAC;IAEtC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,WAAW,CAAC,EAAE,IAAI,CAAC;IACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,sBAAsB,EAAE,OAAO,CAAC;IAChC,aAAa,EAAE,OAAO,CAAC;CACxB;AAWD,qBAAa,kBACX,SAAQ,YACR,YAAW,eAAe;IAQxB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,QAAQ,CAAC,eAAe;IAChC,OAAO,CAAC,QAAQ,CAAC,aAAa;IAE9B,OAAO,CAAC,KAAK;IAGb,OAAO,CAAC,QAAQ,CAAC,mBAAmB;IAGpC,OAAO,CAAC,QAAQ,CAAC,wBAAwB;IACzC,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAClC,OAAO,CAAC,QAAQ,CAAC,uBAAuB;IACxC,OAAO,CAAC,QAAQ,CAAC,6BAA6B;IAC9C,OAAO,CAAC,QAAQ,CAAC,yBAAyB;IApB5C,OAAO,CAAC,kBAAkB,CAAK;IAG/B,OAAO,CAAC,qBAAqB,CAAC,CAAuB;IAErD,OAAO;WAoBa,MAAM,CACxB,MAAM,EAAE,4BAA4B,EACpC,YAAY,EAAE,YAAY,EAC1B,aAAa,CAAC,EAAE,wBAAwB,GACvC,OAAO,CAAC,kBAAkB,CAAC;IAuLjB,OAAO,CAAC,IAAI,EAAE,gBAAgB,GAAG,OAAO,CAAC,OAAO,CAAC;YA0JhD,qBAAqB;YAerB,MAAM;YAsEN,wBAAwB;YAexB,kBAAkB;IAIhC,OAAO,CAAC,iBAAiB;IASzB,OAAO,CAAC,4BAA4B;IAOpC,OAAO,CAAC,6BAA6B;CAWtC;AAQD,wBAAsB,4BAA4B,CAChD,4BAA4B,EAAE,4BAA4B,EAC1D,YAAY,EAAE,YAAY,EAC1B,SAAS,CAAC,EAAE,SAAS,GACpB,OAAO,CAAC,eAAe,CAAC,CAY1B"} \ No newline at end of file diff --git a/internal/hardhat-network/provider/provider.js b/internal/hardhat-network/provider/provider.js -index 10f3b552eff7297ca16ae3acb5c30e5d97c5498e..734cc28a6ba359d235b98573dff2ca0130a5a62d 100644 +index 10f3b552eff7297ca16ae3acb5c30e5d97c5498e..c73ef2e4db60f85ca974ad8531267d46c96ac6f3 100644 --- a/internal/hardhat-network/provider/provider.js +++ b/internal/hardhat-network/provider/provider.js @@ -64,15 +64,14 @@ async function getGlobalEdrContext() { @@ -44,16 +46,18 @@ index 10f3b552eff7297ca16ae3acb5c30e5d97c5498e..734cc28a6ba359d235b98573dff2ca01 super(); this._provider = _provider; this._providerConfig = _providerConfig; -@@ -82,6 +81,8 @@ class EdrProviderWrapper extends events_1.EventEmitter { +@@ -82,7 +81,10 @@ class EdrProviderWrapper extends events_1.EventEmitter { this._originalGenesisAccounts = _originalGenesisAccounts; this._originalCacheDir = _originalCacheDir; this._originalChainOverrides = _originalChainOverrides; + this._originalGenesisBlockGasLimit = _originalGenesisBlockGasLimit; + this._originalGenesisBlockTime = _originalGenesisBlockTime; this._failedStackTraces = 0; ++ this._callTracesEnabled = false; } static async create(config, loggerConfig, tracingConfig) { -@@ -100,9 +101,13 @@ class EdrProviderWrapper extends events_1.EventEmitter { + const { GENERIC_CHAIN_TYPE } = (0, napi_rs_1.requireNapiRsModule)("@nomicfoundation/edr"); +@@ -100,9 +102,13 @@ class EdrProviderWrapper extends events_1.EventEmitter { }; }); const cacheDir = config.forkCachePath; @@ -69,7 +73,7 @@ index 10f3b552eff7297ca16ae3acb5c30e5d97c5498e..734cc28a6ba359d235b98573dff2ca01 blockNumber: config.forkConfig.blockNumber !== undefined ? BigInt(config.forkConfig.blockNumber) : undefined, -@@ -112,59 +117,67 @@ class EdrProviderWrapper extends events_1.EventEmitter { +@@ -112,59 +118,66 @@ class EdrProviderWrapper extends events_1.EventEmitter { url: config.forkConfig.jsonRpcUrl, }; } @@ -140,7 +144,6 @@ index 10f3b552eff7297ca16ae3acb5c30e5d97c5498e..734cc28a6ba359d235b98573dff2ca01 networkId: BigInt(config.networkId), - observability: {}, + observability: { -+ includeCallTraces: edr_1.IncludeTraces.All, + recordStack: edr_1.StackSnapshotType.Top, + }, ownedAccounts, @@ -181,9 +184,27 @@ index 10f3b552eff7297ca16ae3acb5c30e5d97c5498e..734cc28a6ba359d235b98573dff2ca01 return wrapper; } async request(args) { -@@ -234,10 +248,8 @@ class EdrProviderWrapper extends events_1.EventEmitter { - const needsTraces = this._node._vm.evm.events.eventNames().length > 0 || - this._node._vm.events.eventNames().length > 0; +@@ -223,6 +237,14 @@ class EdrProviderWrapper extends events_1.EventEmitter { + method: args.method, + params, + }); ++ const needsTraces = this._node._vm.evm.events.eventNames().length > 0 || ++ this._node._vm.events.eventNames().length > 0; ++ // Trace collection is expensive, so only enable it while something ++ // consumes the traces. ++ if (needsTraces !== this._callTracesEnabled) { ++ await this._provider.setIncludeCallTraces(needsTraces ? edr_1.IncludeTraces.All : edr_1.IncludeTraces.None); ++ this._callTracesEnabled = needsTraces; ++ } + const responseObject = await this._provider.handleRequest(stringifiedArgs); + let response; + if (typeof responseObject.data === "string") { +@@ -231,13 +253,9 @@ class EdrProviderWrapper extends events_1.EventEmitter { + else { + response = responseObject.data; + } +- const needsTraces = this._node._vm.evm.events.eventNames().length > 0 || +- this._node._vm.events.eventNames().length > 0; if (needsTraces) { - const rawTraces = responseObject.traces; - for (const rawTrace of rawTraces) { @@ -194,7 +215,7 @@ index 10f3b552eff7297ca16ae3acb5c30e5d97c5498e..734cc28a6ba359d235b98573dff2ca01 // beforeTx event if (this._node._vm.events.listenerCount("beforeTx") > 0) { this._node._vm.events.emit("beforeTx"); -@@ -250,7 +262,7 @@ class EdrProviderWrapper extends events_1.EventEmitter { +@@ -250,7 +268,7 @@ class EdrProviderWrapper extends events_1.EventEmitter { } } // afterMessage event @@ -203,7 +224,7 @@ index 10f3b552eff7297ca16ae3acb5c30e5d97c5498e..734cc28a6ba359d235b98573dff2ca01 if (this._node._vm.evm.events.listenerCount("afterMessage") > 0) { this._node._vm.evm.events.emit("afterMessage", (0, convertToEdr_1.edrTracingMessageResultToMinimalEVMResult)(traceItem)); } -@@ -270,21 +282,25 @@ class EdrProviderWrapper extends events_1.EventEmitter { +@@ -270,21 +288,25 @@ class EdrProviderWrapper extends events_1.EventEmitter { } if ((0, http_1.isErrorResponse)(response)) { let error; @@ -238,7 +259,7 @@ index 10f3b552eff7297ca16ae3acb5c30e5d97c5498e..734cc28a6ba359d235b98573dff2ca01 if (response.error.code === errors_1.InvalidArgumentsError.CODE) { error = new errors_1.InvalidArgumentsError(response.error.message); } -@@ -304,10 +320,6 @@ class EdrProviderWrapper extends events_1.EventEmitter { +@@ -304,10 +326,6 @@ class EdrProviderWrapper extends events_1.EventEmitter { if (args.method === "web3_clientVersion") { return clientVersion(response.result); } @@ -249,7 +270,7 @@ index 10f3b552eff7297ca16ae3acb5c30e5d97c5498e..734cc28a6ba359d235b98573dff2ca01 else { return response.result; } -@@ -328,14 +340,16 @@ class EdrProviderWrapper extends events_1.EventEmitter { +@@ -328,14 +346,16 @@ class EdrProviderWrapper extends events_1.EventEmitter { const [genesisState, ownedAccounts] = _genesisStateAndOwnedAccounts(forkConfig !== undefined, this._providerConfig.hardfork, this._originalGenesisAccounts); this._providerConfig.genesisState = genesisState; this._providerConfig.ownedAccounts = ownedAccounts; @@ -273,7 +294,7 @@ index 10f3b552eff7297ca16ae3acb5c30e5d97c5498e..734cc28a6ba359d235b98573dff2ca01 blockNumber: forkConfig.blockNumber !== undefined ? BigInt(forkConfig.blockNumber) : undefined, -@@ -346,7 +360,16 @@ class EdrProviderWrapper extends events_1.EventEmitter { +@@ -346,12 +366,23 @@ class EdrProviderWrapper extends events_1.EventEmitter { }; } else { @@ -291,6 +312,13 @@ index 10f3b552eff7297ca16ae3acb5c30e5d97c5498e..734cc28a6ba359d235b98573dff2ca01 } const context = await getGlobalEdrContext(); const provider = await context.createProvider(GENERIC_CHAIN_TYPE, this._providerConfig, this._loggerConfig, this._subscriptionConfig, this._provider.contractDecoder()); + this._provider = provider; + this._node._vm.stateManager.updateProvider(provider); ++ // The new provider starts from the creation-time config. ++ this._callTracesEnabled = false; + this.emit(constants_1.HARDHAT_NETWORK_RESET_EVENT); + return true; + } diff --git a/internal/hardhat-network/provider/provider.js.map b/internal/hardhat-network/provider/provider.js.map index 2bddfb96c5affd4463f5230e45ffe49e28ff0773..43e571e11700516bc748ea7c57bc5f5cc3e32be8 100644 --- a/internal/hardhat-network/provider/provider.js.map @@ -557,7 +585,7 @@ index f83df9fdce13dcce820f520b556ec9dce9537ff8..b97968227b38b48845d60e4a93e8dd21 +{"version":3,"file":"convertToEdr.js","sourceRoot":"","sources":["../../../../src/internal/hardhat-network/provider/utils/convertToEdr.ts"],"names":[],"mappings":"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"} \ No newline at end of file diff --git a/src/internal/hardhat-network/provider/provider.ts b/src/internal/hardhat-network/provider/provider.ts -index d299f5c6853ab9dc2521234bbeb431c328fb9db8..85fba933c7aae219399657e09e47a6e23b56e26d 100644 +index d299f5c6853ab9dc2521234bbeb431c328fb9db8..f21bc9c8d373ace456f1f61bf86eb55695f488ca 100644 --- a/src/internal/hardhat-network/provider/provider.ts +++ b/src/internal/hardhat-network/provider/provider.ts @@ -21,7 +21,12 @@ import type { @@ -591,7 +619,15 @@ index d299f5c6853ab9dc2521234bbeb431c328fb9db8..85fba933c7aae219399657e09e47a6e2 type CallOverrideCallback = ( address: Buffer, data: Buffer -@@ -157,11 +159,14 @@ export class EdrProviderWrapper +@@ -144,6 +146,7 @@ export class EdrProviderWrapper + implements EIP1193Provider + { + private _failedStackTraces = 0; ++ private _callTracesEnabled = false; + + // temporarily added to make smock work with HH+EDR + private _callOverrideCallback?: CallOverrideCallback; +@@ -157,11 +160,14 @@ export class EdrProviderWrapper _vm: MinimalEthereumJsVm; }, private readonly _subscriptionConfig: SubscriptionConfig, @@ -609,7 +645,7 @@ index d299f5c6853ab9dc2521234bbeb431c328fb9db8..85fba933c7aae219399657e09e47a6e2 ) { super(); } -@@ -200,9 +205,15 @@ export class EdrProviderWrapper +@@ -200,9 +206,15 @@ export class EdrProviderWrapper const cacheDir = config.forkCachePath; @@ -627,7 +663,7 @@ index d299f5c6853ab9dc2521234bbeb431c328fb9db8..85fba933c7aae219399657e09e47a6e2 blockNumber: config.forkConfig.blockNumber !== undefined ? BigInt(config.forkConfig.blockNumber) -@@ -212,16 +223,18 @@ export class EdrProviderWrapper +@@ -212,16 +224,18 @@ export class EdrProviderWrapper httpHeaders: httpHeadersToEdr(config.forkConfig.httpHeaders), url: config.forkConfig.jsonRpcUrl, }; @@ -654,7 +690,7 @@ index d299f5c6853ab9dc2521234bbeb431c328fb9db8..85fba933c7aae219399657e09e47a6e2 const printLineFn = loggerConfig.printLineFn ?? printLine; const replaceLastLineFn = loggerConfig.replaceLastLineFn ?? replaceLastLine; -@@ -230,7 +243,7 @@ export class EdrProviderWrapper +@@ -230,7 +244,7 @@ export class EdrProviderWrapper const edrHardfork = ethereumsjsHardforkToEdrSpecId(hardforkName); const [genesisState, ownedAccounts] = _genesisStateAndOwnedAccounts( @@ -663,7 +699,7 @@ index d299f5c6853ab9dc2521234bbeb431c328fb9db8..85fba933c7aae219399657e09e47a6e2 edrHardfork, config.genesisAccounts ); -@@ -241,20 +254,29 @@ export class EdrProviderWrapper +@@ -241,20 +255,29 @@ export class EdrProviderWrapper : [precompileP256Verify()] : []; @@ -696,7 +732,7 @@ index d299f5c6853ab9dc2521234bbeb431c328fb9db8..85fba933c7aae219399657e09e47a6e2 initialBaseFeePerGas: config.initialBaseFeePerGas !== undefined ? BigInt(config.initialBaseFeePerGas!) -@@ -262,25 +284,20 @@ export class EdrProviderWrapper +@@ -262,25 +285,19 @@ export class EdrProviderWrapper minGasPrice: config.minGasPrice, mining: { autoMine: config.automine, @@ -710,7 +746,6 @@ index d299f5c6853ab9dc2521234bbeb431c328fb9db8..85fba933c7aae219399657e09e47a6e2 networkId: BigInt(config.networkId), - observability: {}, + observability: { -+ includeCallTraces: IncludeTraces.All, + recordStack: StackSnapshotType.Top, + }, ownedAccounts, @@ -759,9 +794,34 @@ index d299f5c6853ab9dc2521234bbeb431c328fb9db8..85fba933c7aae219399657e09e47a6e2 return wrapper; } -@@ -392,11 +409,8 @@ export class EdrProviderWrapper - this._node._vm.events.eventNames().length > 0; +@@ -376,6 +393,19 @@ export class EdrProviderWrapper + params, + }); ++ const needsTraces = ++ this._node._vm.evm.events.eventNames().length > 0 || ++ this._node._vm.events.eventNames().length > 0; ++ ++ // Trace collection is expensive, so only enable it while something ++ // consumes the traces. ++ if (needsTraces !== this._callTracesEnabled) { ++ await this._provider.setIncludeCallTraces( ++ needsTraces ? IncludeTraces.All : IncludeTraces.None ++ ); ++ this._callTracesEnabled = needsTraces; ++ } ++ + const responseObject: Response = await this._provider.handleRequest( + stringifiedArgs + ); +@@ -387,16 +417,9 @@ export class EdrProviderWrapper + response = responseObject.data; + } + +- const needsTraces = +- this._node._vm.evm.events.eventNames().length > 0 || +- this._node._vm.events.eventNames().length > 0; +- if (needsTraces) { - const rawTraces = responseObject.traces; - for (const rawTrace of rawTraces) { @@ -773,7 +833,7 @@ index d299f5c6853ab9dc2521234bbeb431c328fb9db8..85fba933c7aae219399657e09e47a6e2 // beforeTx event if (this._node._vm.events.listenerCount("beforeTx") > 0) { this._node._vm.events.emit("beforeTx"); -@@ -413,7 +427,7 @@ export class EdrProviderWrapper +@@ -413,7 +436,7 @@ export class EdrProviderWrapper } } // afterMessage event @@ -782,7 +842,7 @@ index d299f5c6853ab9dc2521234bbeb431c328fb9db8..85fba933c7aae219399657e09e47a6e2 if (this._node._vm.evm.events.listenerCount("afterMessage") > 0) { this._node._vm.evm.events.emit( "afterMessage", -@@ -442,20 +456,32 @@ export class EdrProviderWrapper +@@ -442,20 +465,32 @@ export class EdrProviderWrapper if (isErrorResponse(response)) { let error; @@ -823,7 +883,7 @@ index d299f5c6853ab9dc2521234bbeb431c328fb9db8..85fba933c7aae219399657e09e47a6e2 if (response.error.code === InvalidArgumentsError.CODE) { error = new InvalidArgumentsError(response.error.message); } else { -@@ -479,11 +505,6 @@ export class EdrProviderWrapper +@@ -479,11 +514,6 @@ export class EdrProviderWrapper // e.g. `HardhatNetwork/2.19.0/@nomicfoundation/edr/0.2.0-dev` if (args.method === "web3_clientVersion") { return clientVersion(response.result); @@ -835,7 +895,7 @@ index d299f5c6853ab9dc2521234bbeb431c328fb9db8..85fba933c7aae219399657e09e47a6e2 } else { return response.result; } -@@ -519,18 +540,19 @@ export class EdrProviderWrapper +@@ -519,18 +549,19 @@ export class EdrProviderWrapper this._providerConfig.genesisState = genesisState; this._providerConfig.ownedAccounts = ownedAccounts; @@ -864,7 +924,7 @@ index d299f5c6853ab9dc2521234bbeb431c328fb9db8..85fba933c7aae219399657e09e47a6e2 blockNumber: forkConfig.blockNumber !== undefined ? BigInt(forkConfig.blockNumber) -@@ -541,7 +563,18 @@ export class EdrProviderWrapper +@@ -541,7 +572,18 @@ export class EdrProviderWrapper url: forkConfig.jsonRpcUrl, }; } else { @@ -884,6 +944,15 @@ index d299f5c6853ab9dc2521234bbeb431c328fb9db8..85fba933c7aae219399657e09e47a6e2 } const context = await getGlobalEdrContext(); +@@ -555,6 +597,8 @@ export class EdrProviderWrapper + + this._provider = provider; + this._node._vm.stateManager.updateProvider(provider); ++ // The new provider starts from the creation-time config. ++ this._callTracesEnabled = false; + + this.emit(HARDHAT_NETWORK_RESET_EVENT); + diff --git a/src/internal/hardhat-network/provider/utils/convertToEdr.ts b/src/internal/hardhat-network/provider/utils/convertToEdr.ts index 7fc17b29c0483c4f72ec471f8be60ce7d563add8..a77598208744be77e9acc6ffba6ce281fb210360 100644 --- a/src/internal/hardhat-network/provider/utils/convertToEdr.ts diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index d7d726a218..113b3c7a77 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -8,7 +8,7 @@ overrides: hardhat>@nomicfoundation/edr: workspace:* patchedDependencies: - hardhat@2.28.6: b8790b083be74288377cfb15e513008d2674febe060595223c378dae7a0f2b5f + hardhat@2.28.6: c69d9427f0483caed16df85ef7eecfa27ac716725e8808f3cdc35c01f3cc4d03 hardhat@3.18.0: a06714727fa15e18d65840ee713f8400cd01daa9e4837354fe7ad532bdda2b68 importers: @@ -215,7 +215,7 @@ importers: version: 7.0.1 hardhat: specifier: 2.28.6 - version: 2.28.6(patch_hash=b8790b083be74288377cfb15e513008d2674febe060595223c378dae7a0f2b5f)(supports-color@8.1.1)(ts-node@10.9.2(@types/node@22.20.5)(typescript@5.8.3))(typescript@5.8.3) + version: 2.28.6(patch_hash=c69d9427f0483caed16df85ef7eecfa27ac716725e8808f3cdc35c01f3cc4d03)(supports-color@8.1.1)(ts-node@10.9.2(@types/node@22.20.5)(typescript@5.8.3))(typescript@5.8.3) mocha: specifier: ^11.1.0 version: 11.8.0 @@ -297,7 +297,7 @@ importers: version: 3.18.0(patch_hash=a06714727fa15e18d65840ee713f8400cd01daa9e4837354fe7ad532bdda2b68) hardhat2: specifier: npm:hardhat@2.28.6 - version: hardhat@2.28.6(patch_hash=b8790b083be74288377cfb15e513008d2674febe060595223c378dae7a0f2b5f)(supports-color@8.1.1)(ts-node@10.9.2(@types/node@22.20.5)(typescript@5.8.3))(typescript@5.8.3) + version: hardhat@2.28.6(patch_hash=c69d9427f0483caed16df85ef7eecfa27ac716725e8808f3cdc35c01f3cc4d03)(supports-color@8.1.1)(ts-node@10.9.2(@types/node@22.20.5)(typescript@5.8.3))(typescript@5.8.3) lodash: specifier: ^4.17.11 version: 4.18.1 @@ -6200,7 +6200,7 @@ snapshots: graphemer@1.4.0: {} - hardhat@2.28.6(patch_hash=b8790b083be74288377cfb15e513008d2674febe060595223c378dae7a0f2b5f)(supports-color@8.1.1)(ts-node@10.9.2(@types/node@22.20.5)(typescript@5.8.3))(typescript@5.8.3): + hardhat@2.28.6(patch_hash=c69d9427f0483caed16df85ef7eecfa27ac716725e8808f3cdc35c01f3cc4d03)(supports-color@8.1.1)(ts-node@10.9.2(@types/node@22.20.5)(typescript@5.8.3))(typescript@5.8.3): dependencies: '@ethereumjs/util': 9.1.0 '@ethersproject/abi': 5.8.0 From cdde332ba0548e40d369c5bb4e12e50061e767fb Mon Sep 17 00:00:00 2001 From: Wodann Date: Fri, 2 Oct 2026 21:30:49 +0000 Subject: [PATCH 4/4] perf: record stack and memory snapshots only while traces are included The tracing inspector recorded step stack and memory snapshots for every transaction, even while responses excluded call traces. Only `Response::traces()` reads those snapshots. It only has call traces to read while they are included. The Solidity stack-trace path reads only `pc` and `op`. `recorded_stack()` and `records_memory()` now record nothing while `include_call_traces` is `None`. The observer config is built from them for each EVM run, so `setIncludeCallTraces` also switches recording. --- crates/edr_napi/src/provider.rs | 5 +- crates/edr_provider/src/observability.rs | 58 ++++++++++++++++++++++-- 2 files changed, 56 insertions(+), 7 deletions(-) diff --git a/crates/edr_napi/src/provider.rs b/crates/edr_napi/src/provider.rs index 91f2221bda..2257558e36 100644 --- a/crates/edr_napi/src/provider.rs +++ b/crates/edr_napi/src/provider.rs @@ -39,8 +39,9 @@ pub struct Provider { /// enabled. record_stack: StackSnapshotType, /// What a response reports to V8 for each call trace arena it carries. - /// Follows the recorded stack snapshots, which - /// [`Self::set_verbose_tracing`] changes. + /// Follows the stack snapshots recorded while call traces are included, + /// which [`Self::set_verbose_tracing`] changes. Responses carry no arenas + /// otherwise. call_trace_external_mem_size: AtomicI64, #[cfg(feature = "scenarios")] scenario_file: Option>>, diff --git a/crates/edr_provider/src/observability.rs b/crates/edr_provider/src/observability.rs index a836ef73b7..a2c12e41dc 100644 --- a/crates/edr_provider/src/observability.rs +++ b/crates/edr_provider/src/observability.rs @@ -50,7 +50,8 @@ pub struct ObservabilityConfig { pub include_call_traces: IncludeTraces, pub on_collected_coverage_fn: Option>, pub on_collected_gas_report_fn: Option>, - /// How much of the stack each recorded step carries. + /// How much of the stack each recorded step carries while call traces are + /// included. pub record_stack: StackSnapshotType, /// Records the full stack and memory while enabled. `record_stack` keeps /// its configured value meanwhile. @@ -59,18 +60,33 @@ pub struct ObservabilityConfig { impl ObservabilityConfig { /// Whether recorded steps carry a memory snapshot. + /// + /// Never while call traces are excluded from responses. Only + /// `Response::traces()` reads step snapshots, and it only has call traces + /// to read when they are included. pub fn records_memory(&self) -> bool { - self.verbose_raw_tracing + self.includes_call_traces() && self.verbose_raw_tracing } /// How much of the stack recorded steps carry. + /// + /// Nothing while call traces are excluded from responses, for the same + /// reason as [`Self::records_memory`]. pub fn recorded_stack(&self) -> StackSnapshotType { - recorded_stack(self.record_stack, self.verbose_raw_tracing) + if self.includes_call_traces() { + recorded_stack(self.record_stack, self.verbose_raw_tracing) + } else { + StackSnapshotType::None + } + } + + fn includes_call_traces(&self) -> bool { + !matches!(self.include_call_traces, IncludeTraces::None) } } -/// How much of the stack recorded steps carry, given the configured amount and -/// whether verbose raw tracing is enabled. +/// How much of the stack recorded steps carry while call traces are included, +/// given the configured amount and whether verbose raw tracing is enabled. pub const fn recorded_stack( record_stack: StackSnapshotType, verbose_raw_tracing: bool, @@ -455,3 +471,35 @@ pub(crate) fn observe_execution< include_call_traces, }) } + +#[cfg(test)] +mod tests { + use super::*; + + fn config_recording_everything(include_call_traces: IncludeTraces) -> ObservabilityConfig { + ObservabilityConfig { + include_call_traces, + record_stack: StackSnapshotType::Top, + verbose_raw_tracing: true, + ..ObservabilityConfig::default() + } + } + + #[test] + fn records_no_snapshots_while_call_traces_are_excluded() { + let config = config_recording_everything(IncludeTraces::None); + + assert!(!config.records_memory()); + assert_eq!(config.recorded_stack(), StackSnapshotType::None); + } + + #[test] + fn records_snapshots_while_call_traces_are_included() { + for include_call_traces in [IncludeTraces::Failing, IncludeTraces::All] { + let config = config_recording_everything(include_call_traces); + + assert!(config.records_memory()); + assert_eq!(config.recorded_stack(), StackSnapshotType::Full); + } + } +}