feat: cleanup provider and stack traces logic

Author: schaable

v-next/hardhat/src/internal/builtin-plugins/network-manager/edr/edr-provider.ts

@@ -3,8 +3,6 @@ import type { LoggerConfig } from "./types/logger.js";
 import type { TracingConfig } from "./types/node-types.js";
 import type { EdrNetworkConfig } from "../../../../types/config.js";
 import type {
-  EthSubscription,
-  FailedJsonRpcResponse,
   JsonRpcResponse,
   RequestArguments,
   SuccessfulJsonRpcResponse,
@@ -15,7 +13,6 @@ import type {
   SubscriptionEvent,
   Response,
   Provider,
-  DebugTraceResult,
   ProviderConfig,
 } from "@ignored/edr-optimism";
 
@@ -25,25 +22,20 @@ import {
   l1GenesisState,
   l1HardforkFromString,
 } from "@ignored/edr-optimism";
+import { assertHardhatInvariant } from "@ignored/hardhat-vnext-errors";
 import { toSeconds } from "@ignored/hardhat-vnext-utils/date";
+import { numberToHexString } from "@ignored/hardhat-vnext-utils/hex";
 import { deepEqual } from "@ignored/hardhat-vnext-utils/lang";
 import debug from "debug";
 
-import {
-  EDR_NETWORK_RESET_EVENT,
-  EDR_NETWORK_REVERT_SNAPSHOT_EVENT,
-} from "../../../constants.js";
+import { EDR_NETWORK_REVERT_SNAPSHOT_EVENT } from "../../../constants.js";
 import { DEFAULT_HD_ACCOUNTS_CONFIG_PARAMS } from "../accounts/constants.js";
 import { BaseProvider } from "../base-provider.js";
 import { getJsonRpcRequest, isFailedJsonRpcResponse } from "../json-rpc.js";
 
 import { getGlobalEdrContext } from "./edr-context.js";
-import {
-  InvalidArgumentsError,
-  InvalidInputError,
-  ProviderError,
-} from "./errors.js";
-import { encodeSolidityStackTrace } from "./stack-traces/stack-trace-solidity-errors.js";
+import { InvalidArgumentsError, ProviderError } from "./errors.js";
+import { createSolidityErrorWithStackTrace } from "./stack-traces/stack-trace-solidity-errors.js";
 import { clientVersion } from "./utils/client-version.js";
 import { ConsoleLogger } from "./utils/console-logger.js";
 import {
@@ -55,6 +47,7 @@ import {
   hardhatChainsToEdrChains,
   hardhatForkingConfigToEdrForkConfig,
   hardhatChainTypeToEdrChainType,
+  isDebugTraceResult,
 } from "./utils/convert-to-edr.js";
 import { printLine, replaceLastLine } from "./utils/logger.js";
 
@@ -177,27 +170,22 @@ export class EdrProvider extends BaseProvider {
     super();
 
     this.#provider = provider;
-
     this.#jsonRpcRequestWrapper = jsonRpcRequestWrapper;
   }
 
-  public async request(args: RequestArguments): Promise<unknown> {
-    if (args.params !== undefined && !Array.isArray(args.params)) {
-      // eslint-disable-next-line no-restricted-syntax -- TODO: review whether this should be a HH error
-      throw new InvalidInputError(
-        "Hardhat Network doesn't support JSON-RPC params sent as an object",
-      );
-    }
-
-    const params = args.params ?? [];
+  public async request(
+    requestArguments: RequestArguments,
+  ): Promise<SuccessfulJsonRpcResponse["result"]> {
+    const { method, params } = requestArguments;
 
     const jsonRpcRequest = getJsonRpcRequest(
       this.#nextRequestId++,
-      args.method,
+      method,
       params,
     );
 
     let jsonRpcResponse: JsonRpcResponse;
+
     if (this.#jsonRpcRequestWrapper !== undefined) {
       jsonRpcResponse = await this.#jsonRpcRequestWrapper(
         jsonRpcRequest,
@@ -216,12 +204,6 @@ export class EdrProvider extends BaseProvider {
       jsonRpcResponse = await this.#handleEdrResponse(edrResponse);
     }
 
-    if (args.method === "hardhat_reset") {
-      this.emit(EDR_NETWORK_RESET_EVENT);
-    } else if (args.method === "evm_revert") {
-      this.emit(EDR_NETWORK_REVERT_SNAPSHOT_EVENT);
-    }
-
     // this can only happen if a wrapper doesn't call the default
     // behavior as the default throws on FailedJsonRpcResponse
     if (isFailedJsonRpcResponse(jsonRpcResponse)) {
@@ -235,19 +217,27 @@ export class EdrProvider extends BaseProvider {
       throw error;
     }
 
+    if (jsonRpcRequest.method === "evm_revert") {
+      this.emit(EDR_NETWORK_REVERT_SNAPSHOT_EVENT);
+    }
+
     // Override EDR version string with Hardhat version string with EDR backend,
     // e.g. `HardhatNetwork/2.19.0/@ignored/edr-optimism/0.2.0-dev`
-    if (args.method === "web3_clientVersion") {
-      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- TODO
-      return clientVersion(jsonRpcResponse.result as string);
+    if (jsonRpcRequest.method === "web3_clientVersion") {
+      assertHardhatInvariant(
+        typeof jsonRpcResponse.result === "string",
+        "Invalid client version response",
+      );
+      return clientVersion(jsonRpcResponse.result);
     } else if (
-      args.method === "debug_traceTransaction" ||
-      args.method === "debug_traceCall"
+      jsonRpcRequest.method === "debug_traceTransaction" ||
+      jsonRpcRequest.method === "debug_traceCall"
     ) {
-      return edrRpcDebugTraceToHardhat(
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- TODO
-        jsonRpcResponse.result as DebugTraceResult,
+      assertHardhatInvariant(
+        isDebugTraceResult(jsonRpcResponse.result),
+        "Invalid debug trace response",
       );
+      return edrRpcDebugTraceToHardhat(jsonRpcResponse.result);
     } else {
       return jsonRpcResponse.result;
     }
@@ -257,10 +247,6 @@ export class EdrProvider extends BaseProvider {
     // TODO: what needs cleaned up?
   }
 
-  #isErrorResponse(response: any): response is FailedJsonRpcResponse {
-    return typeof response.error !== "undefined";
-  }
-
   async #handleEdrResponse(
     edrResponse: Response,
   ): Promise<SuccessfulJsonRpcResponse> {
@@ -272,7 +258,8 @@ export class EdrProvider extends BaseProvider {
       jsonRpcResponse = edrResponse.data;
     }
 
-    if (this.#isErrorResponse(jsonRpcResponse)) {
+    if (isFailedJsonRpcResponse(jsonRpcResponse)) {
+      const responseError = jsonRpcResponse.error;
       let error;
 
       let stackTrace: SolidityStackTrace | null = null;
@@ -283,66 +270,61 @@ export class EdrProvider extends BaseProvider {
       }
 
       if (stackTrace !== null) {
-        error = encodeSolidityStackTrace(
-          jsonRpcResponse.error.message,
+        // Pass data and transaction hash from the original error
+        /* eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        -- If we have a stack trace, we know that the json rpc response data
+        is an object with the data and transactionHash fields */
+        const responseErrorData = responseError.data as {
+          data?: string;
+          transactionHash?: string;
+        };
+
+        error = createSolidityErrorWithStackTrace(
+          responseError.message,
           stackTrace,
+          responseErrorData?.data,
+          responseErrorData?.transactionHash,
         );
-
-        // Pass data and transaction hash from the original error
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- TODO: can we improve this `any
-        (error as any).data =
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- TODO: can we improve this `any
-          (jsonRpcResponse as any).error.data?.data ?? undefined;
-
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- TODO: can we improve this `any`
-        (error as any).transactionHash =
-          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- TODO: this really needs fixed
-          (jsonRpcResponse as any).error.data?.transactionHash ?? undefined;
       } else {
-        if (jsonRpcResponse.error.code === InvalidArgumentsError.CODE) {
-          error = new InvalidArgumentsError(jsonRpcResponse.error.message);
-        } else {
-          error = new ProviderError(
-            jsonRpcResponse.error.message,
-            jsonRpcResponse.error.code,
-          );
-        }
-        error.data = jsonRpcResponse.error.data;
+        error =
+          responseError.code === InvalidArgumentsError.CODE
+            ? new InvalidArgumentsError(responseError.message)
+            : new ProviderError(responseError.message, responseError.code);
+        error.data = responseError.data;
       }
 
-      // eslint-disable-next-line no-restricted-syntax -- we may throw non-Hardaht errors inside of an EthereumProvider
+      /* eslint-disable-next-line no-restricted-syntax -- we may throw
+      non-Hardaht errors inside of an EthereumProvider */
       throw error;
     }
 
     return jsonRpcResponse;
   }
 
   public onSubscriptionEvent(event: SubscriptionEvent): void {
-    const subscription = `0x${event.filterId.toString(16)}`;
+    const subscription = numberToHexString(event.filterId);
     const results = Array.isArray(event.result) ? event.result : [event.result];
     for (const result of results) {
       this.#emitLegacySubscriptionEvent(subscription, result);
       this.#emitEip1193SubscriptionEvent(subscription, result);
     }
   }
 
-  #emitLegacySubscriptionEvent(subscription: string, result: any) {
+  #emitLegacySubscriptionEvent(subscription: string, result: unknown) {
     this.emit("notification", {
       subscription,
       result,
     });
   }
 
   #emitEip1193SubscriptionEvent(subscription: string, result: unknown) {
-    const message: EthSubscription = {
+    this.emit("message", {
       type: "eth_subscription",
       data: {
         subscription,
         result,
       },
-    };
-
-    this.emit("message", message);
+    });
   }
 }
 

v-next/hardhat/src/internal/builtin-plugins/network-manager/edr/errors.ts

@@ -88,14 +88,6 @@ export class InternalError extends ProviderError {
   }
 }
 
-export class InvalidInputError extends ProviderError {
-  public static readonly CODE = -32000;
-
-  constructor(message: string, parent?: Error) {
-    super(message, InvalidInputError.CODE, parent);
-  }
-}
-
 export class TransactionExecutionError extends ProviderError {
   public static readonly CODE = -32003;