Use code 3 for JSON-RPC responses where there has been a revert

.changeset/cool-radios-type.md

@@ -0,0 +1,11 @@
+---
+"@nomicfoundation/hardhat-ethers": patch
+"@nomicfoundation/hardhat-ignition-viem": patch
+"@nomicfoundation/hardhat-ignition": patch
+"@nomicfoundation/hardhat-toolbox-viem": patch
+"@nomicfoundation/hardhat-viem-assertions": patch
+"@nomicfoundation/hardhat-viem": patch
+"hardhat": patch
+---
+
+Use code 3 for JSON-RPC revert error codes to align with standard node behavior and preserve error causes in viem/ethers.

.peer-bumps.json

@@ -21,6 +21,11 @@
       "package": "@nomicfoundation/hardhat-ignition-ethers",
       "peer": "@nomicfoundation/hardhat-ignition",
       "reason": "The usage of the new `getUserInterruptionsHandlers` helper from `@nomicfoundation/hardhat-ignition/helpers`"
+    },
+    {
+      "package": "@nomicfoundation/hardhat-viem-assertions",
+      "peer": "hardhat",
+      "reason": "The rewritten `extractRevertError` now relies on viem parsing a code-3 JSON-RPC error with raw hex data, which requires the new SolidityError code-3 behavior from hardhat's JSON-RPC handler"
     }
   ]
 }

packages/example-project/package.json

@@ -51,6 +51,6 @@
     "prettier": "3.2.5",
     "rimraf": "^5.0.5",
     "typescript": "~5.8.0",
-    "viem": "^2.43.0"
+    "viem": "^2.47.6"
   }
 }

packages/hardhat-ethers/test/revert-error-cause.ts

@@ -0,0 +1,96 @@
+import type { HardhatEthers } from "../src/types.js";
+import type { JsonRpcServer } from "hardhat/types/network";
+
+import assert from "node:assert/strict";
+import { after, before, beforeEach, describe, it } from "node:test";
+
+import { ensureError } from "@nomicfoundation/hardhat-utils/error";
+
+import { initializeTestEthers, spawnTestRpcServer } from "./helpers/helpers.js";
+
+let ethers: HardhatEthers;
+
+describe("revert error cause chain", () => {
+  describe("in-process EDR network", async () => {
+    beforeEach(async () => {
+      ({ ethers } = await initializeTestEthers([
+        { artifactName: "Contract", fileName: "error-messages" },
+      ]));
+    });
+
+    it("should have SolidityError as the thrown error", async () => {
+      const contract = await ethers.deployContract("Contract");
+
+      let caughtError: Error | undefined;
+      try {
+        await contract.revertsWithReasonString();
+      } catch (error) {
+        ensureError(error);
+        caughtError = error;
+      }
+
+      assert.ok(
+        caughtError !== undefined && caughtError.name === "SolidityError",
+        `Expected SolidityError, got ${caughtError?.name}`,
+      );
+      assert.ok(
+        "code" in caughtError && caughtError.code === 3,
+        `Expected error code 3, got ${"code" in caughtError ? String(caughtError.code) : "undefined"}`,
+      );
+      assert.ok(
+        caughtError.message.includes("some reason"),
+        `Expected message to include "some reason", got: "${caughtError.message}"`,
+      );
+    });
+  });
+
+  describe("hardhat node (HTTP)", async () => {
+    let server: JsonRpcServer;
+    let port: number;
+    let address: string;
+
+    before(async () => {
+      ({ server, port, address } = await spawnTestRpcServer());
+    });
+
+    after(async () => {
+      await server.close();
+    });
+
+    beforeEach(async () => {
+      ({ ethers } = await initializeTestEthers(
+        [{ artifactName: "Contract", fileName: "error-messages" }],
+        {
+          networks: {
+            localhost: { type: "http", url: `http://${address}:${port}` },
+          },
+        },
+      ));
+    });
+
+    it("should have ProviderError as the thrown error", async () => {
+      const contract = await ethers.deployContract("Contract");
+
+      let caughtError: Error | undefined;
+      try {
+        await contract.revertsWithReasonString();
+      } catch (error) {
+        ensureError(error);
+        caughtError = error;
+      }
+
+      assert.ok(
+        caughtError !== undefined && caughtError.name === "ProviderError",
+        `Expected ProviderError, got ${caughtError?.name}`,
+      );
+      assert.ok(
+        "code" in caughtError && caughtError.code === 3,
+        `Expected error code 3, got ${"code" in caughtError ? String(caughtError.code) : "undefined"}`,
+      );
+      assert.ok(
+        caughtError.message.includes("some reason"),
+        `Expected message to include "some reason", got: "${caughtError.message}"`,
+      );
+    });
+  });
+});

packages/hardhat-ignition-viem/package.json

@@ -64,7 +64,7 @@
     "ts-node": "10.9.2",
     "tsx": "^4.19.3",
     "typescript": "~5.8.0",
-    "viem": "^2.43.0",
+    "viem": "^2.47.6",
     "@nomicfoundation/hardhat-verify": "workspace:^3.0.0"
   },
   "dependencies": {
@@ -76,6 +76,6 @@
     "@nomicfoundation/ignition-core": "workspace:^3.0.7",
     "@nomicfoundation/hardhat-verify": "workspace:^3.0.0",
     "@nomicfoundation/hardhat-viem": "workspace:^3.0.4",
-    "viem": "^2.43.0"
+    "viem": "^2.47.6"
   }
 }

packages/hardhat-ignition/package.json

@@ -80,7 +80,7 @@
     "sinon": "^14.0.0",
     "ts-node": "10.9.2",
     "typescript": "~5.8.0",
-    "viem": "^2.43.0",
+    "viem": "^2.47.6",
     "@nomicfoundation/hardhat-verify": "workspace:^3.0.0"
   },
   "dependencies": {

packages/hardhat-toolbox-viem/package.json

@@ -63,7 +63,7 @@
     "rimraf": "^5.0.5",
     "tsx": "^4.19.3",
     "typescript": "~5.8.0",
-    "viem": "^2.43.0",
+    "viem": "^2.47.6",
     "hardhat": "workspace:^3.0.0"
   },
   "peerDependencies": {
@@ -77,6 +77,6 @@
     "@nomicfoundation/hardhat-verify": "workspace:^3.0.0",
     "@nomicfoundation/ignition-core": "workspace:^3.0.7",
     "hardhat": "workspace:^3.0.0",
-    "viem": "^2.43.0"
+    "viem": "^2.47.6"
   }
 }

packages/hardhat-viem-assertions/package.json

@@ -58,7 +58,7 @@
     "rimraf": "^5.0.5",
     "tsx": "^4.19.3",
     "typescript": "~5.8.0",
-    "viem": "^2.43.0",
+    "viem": "^2.47.6",
     "hardhat": "workspace:^3.0.0"
   },
   "dependencies": {
@@ -68,6 +68,6 @@
   "peerDependencies": {
     "@nomicfoundation/hardhat-viem": "workspace:^3.0.4",
     "hardhat": "workspace:^3.0.0",
-    "viem": "^2.43.0"
+    "viem": "^2.47.6"
   }
 }

packages/hardhat-viem-assertions/src/internal/assertions/revert/extract-revert-error.ts

@@ -2,57 +2,43 @@ import type { Hex } from "viem";
 
 import { assertHardhatInvariant } from "@nomicfoundation/hardhat-errors";
 import { ensureError } from "@nomicfoundation/hardhat-utils/error";
-import { isPrefixedHexString } from "@nomicfoundation/hardhat-utils/hex";
+import {
+  ContractFunctionExecutionError,
+  ContractFunctionRevertedError,
+} from "viem";
 
 /**
- * Recursively extracts, if it exists, the revert data hex string from an error.
+ * Extracts the revert data hex string from a viem contract error.
  *
- * When a contract call reverts, Viem throws an `Error` whose `data` property
- * contains the hex-encoded revert reason. That `data` may live on the top-level
- * error or deeper in a chain of `cause` errors. This function walks down the
- * `cause` chain until it finds a valid `0x` hex string.
+ * When a contract call reverts, viem throws a
+ * `ContractFunctionExecutionError` whose cause is a
+ * `ContractFunctionRevertedError` that carries the raw hex revert data
+ * in its `raw` property.
  *
- * @param error - The thrown Viem `Error` object, which may include a `data` field
- *                or nested `cause` errors carrying the revert data.
- * @returns The `0x` hex string representing the revert data.
+ * @param error - The thrown viem `Error` object.
+ * @returns An object with the error `name`, `message`, and `data` (`0x`-prefixed hex revert data).
  *
- * @throws If no valid `0x` prefixed hex string revert data is found anywhere in the error chain.
+ * @throws If the error is not the expected viem revert error structure.
  */
 export function extractRevertError(error: unknown): {
   name: string;
   message: string;
   data: Hex;
 } {
-  ensureError(error);
+  ensureError(error, ContractFunctionExecutionError);
 
-  let dataReason: Hex | undefined;
+  const { cause } = error;
 
-  let current: Error | undefined = error;
-  let message: string = "";
-  while (current !== undefined) {
-    // Traverse the cause chain to find a valid raw error reason, if one exists.
-    if ("data" in current) {
-      const { data } = current;
-
-      if (typeof data === "string" && isPrefixedHexString(data)) {
-        dataReason = data;
-        message = current.message;
-      }
-    }
-
-    /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    -- all the nested errors might contain a `cause` field */
-    current = current.cause as Error | undefined;
-  }
+  ensureError(cause, ContractFunctionRevertedError);
 
   assertHardhatInvariant(
-    dataReason !== undefined,
-    `No revert data found on error.\nError name: "${error.name}", message: ${error.message}`,
+    cause.raw !== undefined,
+    `Expected raw revert data on ContractFunctionRevertedError, but got none. Error: "${cause.message}"`,
   );
 
   return {
     name: error.name,
-    message,
-    data: dataReason,
+    message: cause.message,
+    data: cause.raw,
   };
 }