chore: merge main into feat/multichain (#615)

* edr-0.4.1

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

* chore: run prettier (#535)

* test: avoid unconditional reverts in stack traces tests (#537)

* fix: allow missing nonce in remote blocks (#539)

* fix: allow missing nonce in remote blocks

* misc: add changeset

* ci: upgrade pnpm/action-setup (#541)

* ci: enable some debug logs for hardhat tests (#538)

* Sync with recent Hardhat changes and deduplicate the Hardhat dep (#544)

* chore: Explicitly depend on semver and fs-extra in hardhat-tests

Appeases ESLint. These are de facto pulled by other dependencies but
it's implicit.

* refactor: Unify ts-node and use the one currently used by Hardhat

Deduping the hardhat package makes it easier to patch it while working
on the stack trace porting feature branch.

* chore: Use the newest Hardhat 2.22.6

This will make patching the changes easier to review as we will sync
with the upstream as it has some changes already related to the stack
traces that we port.

* feat: upgrade revm dependencies (#546)

* feat: upgrade revm dependencies

* Create wild-phones-drum.md

* edr-0.4.2 (#540)

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

* ci: remove path checks for benchmarks (#550)

* ci: remove path restrictions for EDR jobs (#551)

* ci: check that index.d.ts is up to date (#553)

* feat: add support for RIP-7212 (#552)

* feat: add support for RIP-7212

* misc: add changelog

* fix: updated index.d.ts

* fix: revert rename of InvalidFEOpcode

* fix: set enableRip7212 in ProviderConfig

* test: validate that disabling RIP-7212 works

* refactor: use runtime variable instead of const

* Path Hardhat dev dep to work with latest EDR changes

EDR uses Hardhat as a dev dependency to run some javascript tests. The
way this works is that the tests are run using Hardhat, but we use pnpm
to override the EDR dependency in Hardhat with the local one. This works
fine as long as there are no breaking changes in EDR. When there are, we
have a circular dependency problem: we can't publish a new version of
EDR until the tests pass, but for the tests to pass we need a version of
Hardhat that works with the new version of EDR.

A temporary workaround for this is to use `pnpm patch` to temporarily
modify the Hardhat code in a way that works with the breaking change.
In this case, this just means adding the new field when constructing
the provider.

---------

Co-authored-by: Franco Victorio <[email protected]>

* edr-0.5.0 (#555)

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

* build: upgrade revm to v12 (#557)

* build: upgrade revm to v12

* test: remove invalid test

* misc: add changeset

* fix: use remote chain id for pre-fork simulation (#567)

* fix: use remote chain id for pre-fork simulation

* Fix error message

* chore: Bump hardhat to 2.22.7 (#571)

* chore: Bump hardhat to 2.22.7

* fixup: Don't enable RIP-7212 in our tests

* Adapt for NomicFoundation/hardhat#5411

* fix: prevent crash when returning large JSON responses (#569)

* ci: update collaborator check in the benchmarks workflow (#574)

* edr-0.5.1 (#559)

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

* fix: add json alias property in provider response (#582)

* fix: add json alias property in provider response

* Create empty-bobcats-refuse.md

* edr-0.5.2 (#583)

Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>

* breaking change: rename response.json to response.data (#584)

* breaking change: rename response.json to response.data

* Create sour-donkeys-draw.md

* Update sour-donkeys-draw.md

---------

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: github-actions[bot] <github-actions[bot]@users.noreply.github.com>
Co-authored-by: Franco Victorio <[email protected]>
Co-authored-by: Igor Matuszewski <[email protected]>
Co-authored-by: Agost Biro <[email protected]>
Co-authored-by: Piotr Galar <[email protected]>

Author: 6 people

.changeset/sour-donkeys-draw.md

@@ -0,0 +1,5 @@
+---
+"@nomicfoundation/edr": minor
+---
+
+Renamed `json` field in response to `data` and changed its type to `string | object` (specified as `string | any` due to an napi-rs limitation).

.github/workflows/edr-benchmark.yml

@@ -24,7 +24,7 @@ jobs:
     environment: github-action-benchmark
     runs-on: self-hosted
     # Only run for trusted collaborators since third-parties could run malicious code on the self-hosted benchmark runner.
-    if: github.ref == 'refs/heads/main' || (github.event.pull_request.author_association == 'OWNER' || github.event.pull_request.author_association == 'MEMBER' || github.event.pull_request.author_association == 'COLLABORATOR')
+    if: github.ref == 'refs/heads/main' || github.repository == github.event.pull_request.head.repo.full_name
     steps:
       - uses: actions/checkout@v3
 

crates/edr_evm/src/blockchain.rs

@@ -125,6 +125,14 @@ where
     /// Retrieves the instances chain ID.
     fn chain_id(&self) -> u64;
 
+    /// Retrieves the chain ID of the block at the provided number.
+    /// The chain ID can be different in fork mode pre- and post-fork block
+    /// number.
+    fn chain_id_at_block_number(&self, _block_number: u64) -> Result<u64, Self::BlockchainError> {
+        // Chain id only depends on the block number in fork mode
+        Ok(self.chain_id())
+    }
+
     /// Retrieves the last block in the blockchain.
     fn last_block(
         &self,

crates/edr_evm/src/blockchain/forked.rs

@@ -365,6 +365,18 @@ where
         self.chain_id
     }
 
+    fn chain_id_at_block_number(&self, block_number: u64) -> Result<u64, Self::BlockchainError> {
+        if block_number > self.last_block_number() {
+            return Err(BlockchainError::UnknownBlockNumber);
+        }
+
+        if block_number <= self.fork_block_number {
+            Ok(self.remote_chain_id())
+        } else {
+            Ok(self.chain_id())
+        }
+    }
+
     #[cfg_attr(feature = "tracing", tracing::instrument(skip_all))]
     fn last_block(
         &self,

crates/edr_napi/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @nomicfoundation/edr
 
+## 0.5.2
+
+### Patch Changes
+
+- 66ca796: fix: added `json` alias property in provider response to fix breaking change in v0.5.1
+
+## 0.5.1
+
+### Patch Changes
+
+- 0bba027: Fixed a bug in fork mode where the locally overridden chain id was used instead of the remote chain id when simulating transactions in pre-fork blocks.
+- e02eb22: Fixed a bug in the JSON-RPC where we previously allowed a null value for storage keys of an access list
+- 8ae31b9: Fixed crash when returning large JSON responses
+
 ## 0.5.0
 
 ### Minor Changes

crates/edr_napi/index.d.ts

@@ -418,7 +418,8 @@ export class Provider {
   setVerboseTracing(verboseTracing: boolean): void
 }
 export class Response {
-  get json(): string
+  /** Returns the response data as a JSON string or a JSON object. */
+  get data(): string | any
   get solidityTrace(): RawTrace | null
   get traces(): Array<RawTrace>
 }

crates/edr_napi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nomicfoundation/edr",
-  "version": "0.5.0",
+  "version": "0.5.2",
   "main": "index.js",
   "types": "index.d.ts",
   "files": [
@@ -38,6 +38,7 @@
     "@types/node": "^18.0.0",
     "chai": "^4.3.6",
     "chai-as-promised": "^7.1.1",
+    "json-stream-stringify": "^3.1.4",
     "mocha": "^10.0.0",
     "ts-node": "^10.8.0",
     "typescript": "~4.5.2"
@@ -55,8 +56,8 @@
     "universal": "napi universal",
     "version": "napi version",
     "pretest": "pnpm build",
-    "test": "pnpm tsc && mocha --recursive \"test/**/*.ts\"",
-    "testNoBuild": "pnpm tsc && mocha --recursive \"test/**/*.ts\"",
+    "test": "pnpm tsc && node --max-old-space-size=8192 node_modules/mocha/bin/_mocha --recursive \"test/**/*.ts\"",
+    "testNoBuild": "pnpm tsc && node --max-old-space-size=8192 node_modules/mocha/bin/_mocha --recursive \"test/**/*.ts\"",
     "clean": "rm -rf @nomicfoundation/edr.node"
   }
 }

crates/edr_napi/src/provider.rs

@@ -5,7 +5,7 @@ use std::sync::Arc;
 use edr_eth::chain_spec::L1ChainSpec;
 use edr_provider::{time::CurrentTime, InvalidRequestReason};
 use edr_rpc_eth::jsonrpc;
-use napi::{tokio::runtime, Env, JsFunction, JsObject, Status};
+use napi::{tokio::runtime, Either, Env, JsFunction, JsObject, Status};
 use napi_derive::napi;
 
 use self::config::ProviderConfig;
@@ -121,9 +121,9 @@ impl Provider {
                             format!("Invalid JSON `{json_request}` due to: {error}"),
                         )
                     })
-                    .map(|json_response| Response {
+                    .map(|json| Response {
                         solidity_trace: None,
-                        json: json_response,
+                        data: Either::A(json),
                         traces: Vec::new(),
                     });
             }
@@ -169,10 +169,25 @@ impl Provider {
         let response = jsonrpc::ResponseData::from(response.map(|response| response.result));
 
         serde_json::to_string(&response)
-            .map_err(|e| napi::Error::new(Status::GenericFailure, e.to_string()))
-            .map(|json_response| Response {
+            .and_then(|json| {
+                // We experimentally determined that 500_000_000 was the maximum string length
+                // that can be returned without causing the error:
+                //
+                // > Failed to convert rust `String` into napi `string`
+                //
+                // To be safe, we're limiting string lengths to half of that.
+                const MAX_STRING_LENGTH: usize = 250_000_000;
+
+                if json.len() <= MAX_STRING_LENGTH {
+                    Ok(Either::A(json))
+                } else {
+                    serde_json::to_value(response).map(Either::B)
+                }
+            })
+            .map_err(|error| napi::Error::new(Status::GenericFailure, error.to_string()))
+            .map(|data| Response {
                 solidity_trace,
-                json: json_response,
+                data,
                 traces: traces.into_iter().map(Arc::new).collect(),
             })
     }
@@ -210,7 +225,10 @@ impl Provider {
 
 #[napi]
 pub struct Response {
-    json: String,
+    // N-API is known to be slow when marshalling `serde_json::Value`s, so we try to return a
+    // `String`. If the object is too large to be represented as a `String`, we return a `Buffer`
+    // instead.
+    data: Either<String, serde_json::Value>,
     /// When a transaction fails to execute, the provider returns a trace of the
     /// transaction.
     solidity_trace: Option<Arc<edr_evm::trace::Trace<L1ChainSpec>>>,
@@ -220,9 +238,10 @@ pub struct Response {
 
 #[napi]
 impl Response {
+    /// Returns the response data as a JSON string or a JSON object.
     #[napi(getter)]
-    pub fn json(&self) -> String {
-        self.json.clone()
+    pub fn data(&self) -> Either<String, serde_json::Value> {
+        self.data.clone()
     }
 
     #[napi(getter)]

crates/edr_napi/test/helpers.ts

@@ -1,5 +1,22 @@
 import { TracingMessage, TracingMessageResult, TracingStep } from "..";
 
+function getEnv(key: string): string | undefined {
+  const variable = process.env[key];
+  if (variable === undefined || variable === "") {
+    return undefined;
+  }
+
+  const trimmed = variable.trim();
+
+  return trimmed.length === 0 ? undefined : trimmed;
+}
+
+export const ALCHEMY_URL = getEnv("ALCHEMY_URL");
+
+export function isCI(): boolean {
+  return getEnv("CI") === "true";
+}
+
 /**
  * Given a trace, return only its steps.
  */

crates/edr_napi/test/issues.ts

@@ -0,0 +1,109 @@
+import chai, { assert } from "chai";
+import { JsonStreamStringify } from "json-stream-stringify";
+
+import {
+  ContractAndFunctionName,
+  EdrContext,
+  MineOrdering,
+  Provider,
+  SpecId,
+  SubscriptionEvent,
+} from "..";
+import { ALCHEMY_URL, isCI } from "./helpers";
+
+describe("Provider", () => {
+  const context = new EdrContext();
+  const providerConfig = {
+    allowBlocksWithSameTimestamp: false,
+    allowUnlimitedContractSize: true,
+    bailOnCallFailure: false,
+    bailOnTransactionFailure: false,
+    blockGasLimit: 300_000_000n,
+    chainId: 1n,
+    chains: [],
+    coinbase: Buffer.from("0000000000000000000000000000000000000000", "hex"),
+    enableRip7212: false,
+    genesisAccounts: [
+      {
+        secretKey:
+          "0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80",
+        balance: 1000n * 10n ** 18n,
+      },
+    ],
+    hardfork: SpecId.Latest,
+    initialBlobGas: {
+      gasUsed: 0n,
+      excessGas: 0n,
+    },
+    initialParentBeaconBlockRoot: Buffer.from(
+      "0000000000000000000000000000000000000000000000000000000000000000",
+      "hex",
+    ),
+    minGasPrice: 0n,
+    mining: {
+      autoMine: true,
+      memPool: {
+        order: MineOrdering.Priority,
+      },
+    },
+    networkId: 123n,
+  };
+
+  const loggerConfig = {
+    enable: false,
+    decodeConsoleLogInputsCallback: (inputs: Buffer[]): string[] => {
+      return [];
+    },
+    getContractAndFunctionNameCallback: (
+      _code: Buffer,
+      _calldata?: Buffer,
+    ): ContractAndFunctionName => {
+      return {
+        contractName: "",
+      };
+    },
+    printLineCallback: (message: string, replace: boolean) => {},
+  };
+
+  it("issue 543", async function () {
+    if (ALCHEMY_URL === undefined || !isCI()) {
+      this.skip();
+    }
+
+    // This test is slow because the debug_traceTransaction is performed on a large transaction.
+    this.timeout(240_000);
+
+    const provider = await Provider.withConfig(
+      context,
+      {
+        fork: {
+          jsonRpcUrl: ALCHEMY_URL,
+        },
+        initialBaseFeePerGas: 0n,
+        ...providerConfig,
+      },
+      loggerConfig,
+      (_event: SubscriptionEvent) => {},
+    );
+
+    const debugTraceTransaction = `{
+        "jsonrpc": "2.0",
+        "method": "debug_traceTransaction",
+        "params": ["0x7e460f200343e5ab6653a8857cc5ef798e3f5bea6a517b156f90c77ef311a57c"],
+        "id": 1
+      }`;
+
+    const response = await provider.handleRequest(debugTraceTransaction);
+
+    let responseData;
+
+    if (typeof response.data === "string") {
+      responseData = JSON.parse(response.data);
+    } else {
+      responseData = response.data;
+    }
+
+    // Validate that we can query the response data without crashing.
+    const _json = new JsonStreamStringify(responseData);
+  });
+});

crates/edr_napi/test/provider.ts

@@ -9,23 +9,10 @@ import {
   SpecId,
   SubscriptionEvent,
 } from "..";
-import { collectMessages, collectSteps } from "./helpers";
+import { collectMessages, collectSteps, ALCHEMY_URL } from "./helpers";
 
 chai.use(chaiAsPromised);
 
-function getEnv(key: string): string | undefined {
-  const variable = process.env[key];
-  if (variable === undefined || variable === "") {
-    return undefined;
-  }
-
-  const trimmed = variable.trim();
-
-  return trimmed.length === 0 ? undefined : trimmed;
-}
-
-const ALCHEMY_URL = getEnv("ALCHEMY_URL");
-
 describe("Provider", () => {
   const context = new EdrContext();
   const providerConfig = {
@@ -350,7 +337,15 @@ describe("Provider", () => {
         }),
       );
 
-      const txHash = JSON.parse(sendTxResponse.json).result;
+      let responseData;
+
+      if (typeof sendTxResponse.data === "string") {
+        responseData = JSON.parse(sendTxResponse.data);
+      } else {
+        responseData = sendTxResponse.data;
+      }
+
+      const txHash = responseData.result;
 
       const traceTransactionResponse = await provider.handleRequest(
         JSON.stringify({