Merge pull request #6965 from NomicFoundation/fix-node-crash

fix: node crash when sending tx with insufficient funds

Author: schaable

.changeset/twenty-lies-destroy.md

@@ -0,0 +1,5 @@
+---
+"hardhat": patch
+---
+
+Fix node crash when sending a tx with insufficient funds

v-next/hardhat/src/internal/builtin-plugins/node/json-rpc/handler.ts

@@ -7,6 +7,9 @@ import type {
 import type { IncomingMessage, ServerResponse } from "node:http";
 import type WebSocket from "ws";
 
+import { ensureError } from "@nomicfoundation/hardhat-utils/error";
+import { isObject } from "@nomicfoundation/hardhat-utils/lang";
+
 import {
   isJsonRpcRequest,
   isJsonRpcResponse,
@@ -36,10 +39,11 @@ export class JsonRpcHandler {
       return;
     }
 
-    let jsonHttpRequest: any;
+    let jsonHttpRequest: unknown;
     try {
       jsonHttpRequest = await _readJsonHttpRequest(req);
     } catch (error) {
+      ensureError(error);
       this.#sendResponse(res, _handleError(error));
       return;
     }
@@ -48,7 +52,9 @@ export class JsonRpcHandler {
     // the following code block could be safely removed.
     if (Array.isArray(jsonHttpRequest)) {
       const responses = await Promise.all(
-        jsonHttpRequest.map((singleReq: any) => this.#handleRequest(singleReq)),
+        jsonHttpRequest.map((singleReq: unknown) =>
+          this.#handleRequest(singleReq),
+        ),
       );
 
       this.#sendResponse(res, responses);
@@ -80,6 +86,7 @@ export class JsonRpcHandler {
           }),
         );
       } catch (error) {
+        ensureError(error);
         _handleError(error);
       }
     };
@@ -100,6 +107,7 @@ export class JsonRpcHandler {
             )
           : await this.#handleWsRequest(rpcReq, subscriptions);
       } catch (error) {
+        ensureError(error);
         rpcResp = _handleError(error);
       }
 
@@ -142,28 +150,36 @@ export class JsonRpcHandler {
     res.end(JSON.stringify(rpcResp));
   }
 
-  async #handleRequest(req: JsonRpcRequest): Promise<JsonRpcResponse> {
-    req.params = req.params ?? [];
+  async #handleRequest(payload: unknown): Promise<JsonRpcResponse> {
+    if (!isObject(payload)) {
+      return _handleError(new InvalidRequestError());
+    }
+
+    const maybeReq = {
+      ...payload,
+      params: payload.params ?? [],
+    };
 
-    if (!isJsonRpcRequest(req)) {
+    if (!isJsonRpcRequest(maybeReq)) {
       return _handleError(new InvalidRequestError());
     }
 
-    const rpcReq: JsonRpcRequest = req;
+    const rpcReq: JsonRpcRequest = maybeReq;
     let rpcResp: JsonRpcResponse | undefined;
 
     try {
       const result = await this.#provider.request({
-        method: req.method,
-        params: req.params,
+        method: rpcReq.method,
+        params: rpcReq.params,
       });
 
       rpcResp = {
         jsonrpc: "2.0",
-        id: req.id,
+        id: rpcReq.id,
         result,
       };
     } catch (error) {
+      ensureError(error);
       rpcResp = _handleError(error);
     }
 
@@ -195,8 +211,8 @@ export class JsonRpcHandler {
   }
 }
 
-const _readJsonHttpRequest = async (req: IncomingMessage): Promise<any> => {
-  let json;
+const _readJsonHttpRequest = async (req: IncomingMessage): Promise<unknown> => {
+  let json: unknown;
 
   try {
     const bytes: number[] = [];
@@ -233,26 +249,7 @@ const _readWsRequest = (msg: string): JsonRpcRequest | JsonRpcRequest[] => {
   return json;
 };
 
-const _handleError = (error: any): JsonRpcResponse => {
-  // extract the relevant fields from the error before wrapping it
-  let txHash: string | undefined;
-  let returnData: string | undefined;
-
-  if (error.transactionHash !== undefined) {
-    txHash = error.transactionHash;
-  }
-  if (error.data !== undefined) {
-    if (error.data.data !== undefined) {
-      returnData = error.data.data;
-    } else {
-      returnData = error.data;
-    }
-
-    if (txHash === undefined && error.data.transactionHash !== undefined) {
-      txHash = error.data.transactionHash;
-    }
-  }
-
+const _handleError = (error: Error): JsonRpcResponse => {
   // In case of non-hardhat error, treat it as internal and associate the appropriate error code.
   if (!ProviderError.isProviderError(error)) {
     error = new InternalError(undefined, error);
@@ -262,24 +259,46 @@ const _handleError = (error: any): JsonRpcResponse => {
     jsonrpc: "2.0",
     id: null,
     error: {
-      code: error.code,
+      code:
+        "code" in error && typeof error.code === "number"
+          ? error.code
+          : InternalError.CODE,
       message: error.message,
+      data: {
+        message: error.message,
+        txHash: extractTxHash(error),
+        data: extractReturnData(error),
+      },
     },
   };
 
-  const data: any = {
-    message: error.message,
-  };
+  return response;
+};
 
-  if (txHash !== undefined) {
-    data.txHash = txHash;
+function extractTxHash(error: Error): string | undefined {
+  if ("transactionHash" in error && typeof error.transactionHash === "string") {
+    return error.transactionHash;
+  }
+
+  if (
+    "data" in error &&
+    isObject(error.data) &&
+    typeof error.data.transactionHash === "string"
+  ) {
+    return error.data.transactionHash;
   }
+}
 
-  if (returnData !== undefined) {
-    data.data = returnData;
+function extractReturnData(error: Error): string | undefined {
+  if (!("data" in error)) {
+    return undefined;
   }
 
-  response.error.data = data;
+  if (typeof error.data === "string") {
+    return error.data;
+  }
 
-  return response;
-};
+  if (isObject(error.data) && typeof error.data.data === "string") {
+    return error.data.data;
+  }
+}