hardhat 2.22.11 → 2.22.12

package/src/internal/hardhat-network/stack-traces/solidity-stack-trace.ts

@@ -1,189 +1,86 @@
-import { ReturnData } from "../provider/return-data";
-
-import { ContractFunctionType } from "./model";
-
-export enum StackTraceEntryType {
-  CALLSTACK_ENTRY,
-  UNRECOGNIZED_CREATE_CALLSTACK_ENTRY,
-  UNRECOGNIZED_CONTRACT_CALLSTACK_ENTRY,
-  PRECOMPILE_ERROR,
-  REVERT_ERROR,
-  PANIC_ERROR,
-  CUSTOM_ERROR,
-  FUNCTION_NOT_PAYABLE_ERROR,
-  INVALID_PARAMS_ERROR,
-  FALLBACK_NOT_PAYABLE_ERROR,
-  FALLBACK_NOT_PAYABLE_AND_NO_RECEIVE_ERROR,
-  UNRECOGNIZED_FUNCTION_WITHOUT_FALLBACK_ERROR, // TODO: Should trying to call a private/internal be a special case of this?
-  MISSING_FALLBACK_OR_RECEIVE_ERROR,
-  RETURNDATA_SIZE_ERROR,
-  NONCONTRACT_ACCOUNT_CALLED_ERROR,
-  CALL_FAILED_ERROR,
-  DIRECT_LIBRARY_CALL_ERROR,
-  UNRECOGNIZED_CREATE_ERROR,
-  UNRECOGNIZED_CONTRACT_ERROR,
-  OTHER_EXECUTION_ERROR,
-  // This is a special case to handle a regression introduced in solc 0.6.3
-  // For more info: https://github.com/ethereum/solidity/issues/9006
-  UNMAPPED_SOLC_0_6_3_REVERT_ERROR,
-  CONTRACT_TOO_LARGE_ERROR,
-  INTERNAL_FUNCTION_CALLSTACK_ENTRY,
-  CONTRACT_CALL_RUN_OUT_OF_GAS_ERROR,
-}
-
-export const FALLBACK_FUNCTION_NAME = "<fallback>";
-export const RECEIVE_FUNCTION_NAME = "<receive>";
-export const CONSTRUCTOR_FUNCTION_NAME = "constructor";
-export const UNRECOGNIZED_FUNCTION_NAME = "<unrecognized-selector>";
-export const UNKNOWN_FUNCTION_NAME = "<unknown>";
-export const PRECOMPILE_FUNCTION_NAME = "<precompile>";
-export const UNRECOGNIZED_CONTRACT_NAME = "<UnrecognizedContract>";
-
-export interface SourceReference {
-  sourceName: string;
-  sourceContent: string;
-  contract?: string;
-  function?: string;
-  line: number;
-  range: [number, number];
-}
-
-export interface CallstackEntryStackTraceEntry {
-  type: StackTraceEntryType.CALLSTACK_ENTRY;
-  sourceReference: SourceReference;
-  functionType: ContractFunctionType;
-}
-
-export interface UnrecognizedCreateCallstackEntryStackTraceEntry {
-  type: StackTraceEntryType.UNRECOGNIZED_CREATE_CALLSTACK_ENTRY;
-  sourceReference?: undefined;
-}
-
-export interface UnrecognizedContractCallstackEntryStackTraceEntry {
-  type: StackTraceEntryType.UNRECOGNIZED_CONTRACT_CALLSTACK_ENTRY;
-  address: Uint8Array;
-  sourceReference?: undefined;
-}
-
-export interface PrecompileErrorStackTraceEntry {
-  type: StackTraceEntryType.PRECOMPILE_ERROR;
-  precompile: number;
-  sourceReference?: undefined;
-}
-
-export interface RevertErrorStackTraceEntry {
-  type: StackTraceEntryType.REVERT_ERROR;
-  message: ReturnData;
-  sourceReference: SourceReference;
-  isInvalidOpcodeError: boolean;
-}
-
-export interface PanicErrorStackTraceEntry {
-  type: StackTraceEntryType.PANIC_ERROR;
-  errorCode: bigint;
-  sourceReference?: SourceReference;
-}
-
-export interface CustomErrorStackTraceEntry {
-  type: StackTraceEntryType.CUSTOM_ERROR;
-  // unlike RevertErrorStackTraceEntry, this includes the message already parsed
-  message: string;
-  sourceReference: SourceReference;
-}
-
-export interface UnmappedSolc063RevertErrorStackTraceEntry {
-  type: StackTraceEntryType.UNMAPPED_SOLC_0_6_3_REVERT_ERROR;
-  sourceReference?: SourceReference;
-}
-
-export interface FunctionNotPayableErrorStackTraceEntry {
-  type: StackTraceEntryType.FUNCTION_NOT_PAYABLE_ERROR;
-  value: bigint;
-  sourceReference: SourceReference;
-}
-
-export interface InvalidParamsErrorStackTraceEntry {
-  type: StackTraceEntryType.INVALID_PARAMS_ERROR;
-  sourceReference: SourceReference;
-}
-
-export interface FallbackNotPayableErrorStackTraceEntry {
-  type: StackTraceEntryType.FALLBACK_NOT_PAYABLE_ERROR;
-  value: bigint;
-  sourceReference: SourceReference;
-}
-
-export interface FallbackNotPayableAndNoReceiveErrorStackTraceEntry {
-  type: StackTraceEntryType.FALLBACK_NOT_PAYABLE_AND_NO_RECEIVE_ERROR;
-  value: bigint;
-  sourceReference: SourceReference;
-}
-
-export interface UnrecognizedFunctionWithoutFallbackErrorStackTraceEntry {
-  type: StackTraceEntryType.UNRECOGNIZED_FUNCTION_WITHOUT_FALLBACK_ERROR;
-  sourceReference: SourceReference;
-}
-
-export interface MissingFallbackOrReceiveErrorStackTraceEntry {
-  type: StackTraceEntryType.MISSING_FALLBACK_OR_RECEIVE_ERROR;
-  sourceReference: SourceReference;
-}
-
-export interface ReturndataSizeErrorStackTraceEntry {
-  type: StackTraceEntryType.RETURNDATA_SIZE_ERROR;
-  sourceReference: SourceReference;
-}
-
-export interface NonContractAccountCalledErrorStackTraceEntry {
-  type: StackTraceEntryType.NONCONTRACT_ACCOUNT_CALLED_ERROR;
-  sourceReference: SourceReference;
-}
-
-export interface CallFailedErrorStackTraceEntry {
-  type: StackTraceEntryType.CALL_FAILED_ERROR;
-  sourceReference: SourceReference;
-}
-
-export interface DirectLibraryCallErrorStackTraceEntry {
-  type: StackTraceEntryType.DIRECT_LIBRARY_CALL_ERROR;
-  sourceReference: SourceReference;
-}
-
-export interface UnrecognizedCreateErrorStackTraceEntry {
-  type: StackTraceEntryType.UNRECOGNIZED_CREATE_ERROR;
-  message: ReturnData;
-  sourceReference?: undefined;
-  isInvalidOpcodeError: boolean;
-}
-
-export interface UnrecognizedContractErrorStackTraceEntry {
-  type: StackTraceEntryType.UNRECOGNIZED_CONTRACT_ERROR;
-  address: Uint8Array;
-  message: ReturnData;
-  sourceReference?: undefined;
-  isInvalidOpcodeError: boolean;
-}
-
-export interface OtherExecutionErrorStackTraceEntry {
-  type: StackTraceEntryType.OTHER_EXECUTION_ERROR;
-  sourceReference?: SourceReference;
-}
-
-export interface ContractTooLargeErrorStackTraceEntry {
-  type: StackTraceEntryType.CONTRACT_TOO_LARGE_ERROR;
-  sourceReference?: SourceReference;
-}
-
-export interface InternalFunctionCallStackEntry {
-  type: StackTraceEntryType.INTERNAL_FUNCTION_CALLSTACK_ENTRY;
-  pc: number;
-  sourceReference: SourceReference;
-}
-
-export interface ContractCallRunOutOfGasError {
-  type: StackTraceEntryType.CONTRACT_CALL_RUN_OUT_OF_GAS_ERROR;
-  sourceReference?: SourceReference;
-}
+import type {
+  SourceReference,
+  CallstackEntryStackTraceEntry,
+  UnrecognizedCreateCallstackEntryStackTraceEntry,
+  UnrecognizedContractCallstackEntryStackTraceEntry,
+  PrecompileErrorStackTraceEntry,
+  RevertErrorStackTraceEntry,
+  PanicErrorStackTraceEntry,
+  CustomErrorStackTraceEntry,
+  FunctionNotPayableErrorStackTraceEntry,
+  InvalidParamsErrorStackTraceEntry,
+  FallbackNotPayableErrorStackTraceEntry,
+  FallbackNotPayableAndNoReceiveErrorStackTraceEntry,
+  UnrecognizedFunctionWithoutFallbackErrorStackTraceEntry,
+  MissingFallbackOrReceiveErrorStackTraceEntry,
+  ReturndataSizeErrorStackTraceEntry,
+  NonContractAccountCalledErrorStackTraceEntry,
+  CallFailedErrorStackTraceEntry,
+  DirectLibraryCallErrorStackTraceEntry,
+  UnrecognizedCreateErrorStackTraceEntry,
+  UnrecognizedContractErrorStackTraceEntry,
+  OtherExecutionErrorStackTraceEntry,
+  UnmappedSolc063RevertErrorStackTraceEntry,
+  ContractTooLargeErrorStackTraceEntry,
+  InternalFunctionCallStackEntry,
+  ContractCallRunOutOfGasError,
+} from "@nomicfoundation/edr";
+
+import { requireNapiRsModule } from "../../../common/napi-rs";
+
+const {
+  StackTraceEntryType,
+  stackTraceEntryTypeToString,
+  FALLBACK_FUNCTION_NAME,
+  RECEIVE_FUNCTION_NAME,
+  CONSTRUCTOR_FUNCTION_NAME,
+  UNRECOGNIZED_FUNCTION_NAME,
+  UNKNOWN_FUNCTION_NAME,
+  PRECOMPILE_FUNCTION_NAME,
+  UNRECOGNIZED_CONTRACT_NAME,
+} = requireNapiRsModule(
+  "@nomicfoundation/edr"
+) as typeof import("@nomicfoundation/edr");
+
+export {
+  SourceReference,
+  StackTraceEntryType,
+  stackTraceEntryTypeToString,
+  FALLBACK_FUNCTION_NAME,
+  RECEIVE_FUNCTION_NAME,
+  CONSTRUCTOR_FUNCTION_NAME,
+  UNRECOGNIZED_FUNCTION_NAME,
+  UNKNOWN_FUNCTION_NAME,
+  PRECOMPILE_FUNCTION_NAME,
+  UNRECOGNIZED_CONTRACT_NAME,
+};
+
+export type {
+  CallstackEntryStackTraceEntry,
+  UnrecognizedCreateCallstackEntryStackTraceEntry,
+  UnrecognizedContractCallstackEntryStackTraceEntry,
+  PrecompileErrorStackTraceEntry,
+  RevertErrorStackTraceEntry,
+  PanicErrorStackTraceEntry,
+  CustomErrorStackTraceEntry,
+  FunctionNotPayableErrorStackTraceEntry,
+  InvalidParamsErrorStackTraceEntry,
+  FallbackNotPayableErrorStackTraceEntry,
+  FallbackNotPayableAndNoReceiveErrorStackTraceEntry,
+  UnrecognizedFunctionWithoutFallbackErrorStackTraceEntry,
+  MissingFallbackOrReceiveErrorStackTraceEntry,
+  ReturndataSizeErrorStackTraceEntry,
+  NonContractAccountCalledErrorStackTraceEntry,
+  CallFailedErrorStackTraceEntry,
+  DirectLibraryCallErrorStackTraceEntry,
+  UnrecognizedCreateErrorStackTraceEntry,
+  UnrecognizedContractErrorStackTraceEntry,
+  OtherExecutionErrorStackTraceEntry,
+  UnmappedSolc063RevertErrorStackTraceEntry,
+  ContractTooLargeErrorStackTraceEntry,
+  InternalFunctionCallStackEntry,
+  ContractCallRunOutOfGasError,
+};
 
 export type SolidityStackTraceEntry =
   | CallstackEntryStackTraceEntry

package/src/internal/hardhat-network/stack-traces/solidityTracer.ts

@@ -1,255 +1,7 @@
-import { equalsBytes } from "@nomicfoundation/ethereumjs-util";
+import { requireNapiRsModule } from "../../../common/napi-rs";
 
-import { ReturnData } from "../provider/return-data";
-import { ExitCode } from "../provider/vm/exit";
+const { SolidityTracer } = requireNapiRsModule(
+  "@nomicfoundation/edr"
+) as typeof import("@nomicfoundation/edr");
 
-import {
-  ErrorInferrer,
-  instructionToCallstackStackTraceEntry,
-  SubmessageData,
-} from "./error-inferrer";
-import {
-  adjustStackTrace,
-  stackTraceMayRequireAdjustments,
-} from "./mapped-inlined-internal-functions-heuristics";
-import {
-  DecodedCallMessageTrace,
-  DecodedCreateMessageTrace,
-  DecodedEvmMessageTrace,
-  EvmMessageTrace,
-  EvmStep,
-  isCreateTrace,
-  isDecodedCallTrace,
-  isDecodedCreateTrace,
-  isEvmStep,
-  isPrecompileTrace,
-  MessageTrace,
-  PrecompileMessageTrace,
-} from "./message-trace";
-import { Instruction, JumpType } from "./model";
-import { Opcode } from "./opcodes";
-import {
-  SolidityStackTrace,
-  SolidityStackTraceEntry,
-  StackTraceEntryType,
-} from "./solidity-stack-trace";
-
-export class SolidityTracer {
-  private _errorInferrer = new ErrorInferrer();
-
-  public getStackTrace(
-    maybeDecodedMessageTrace: MessageTrace
-  ): SolidityStackTrace {
-    if (!maybeDecodedMessageTrace.exit.isError()) {
-      return [];
-    }
-
-    if (isPrecompileTrace(maybeDecodedMessageTrace)) {
-      return this._getPrecompileMessageStackTrace(maybeDecodedMessageTrace);
-    }
-
-    if (isDecodedCreateTrace(maybeDecodedMessageTrace)) {
-      return this._getCreateMessageStackTrace(maybeDecodedMessageTrace);
-    }
-
-    if (isDecodedCallTrace(maybeDecodedMessageTrace)) {
-      return this._getCallMessageStackTrace(maybeDecodedMessageTrace);
-    }
-
-    return this._getUnrecognizedMessageStackTrace(maybeDecodedMessageTrace);
-  }
-
-  private _getCallMessageStackTrace(
-    trace: DecodedCallMessageTrace
-  ): SolidityStackTrace {
-    const inferredError =
-      this._errorInferrer.inferBeforeTracingCallMessage(trace);
-
-    if (inferredError !== undefined) {
-      return inferredError;
-    }
-
-    return this._traceEvmExecution(trace);
-  }
-
-  private _getUnrecognizedMessageStackTrace(
-    trace: EvmMessageTrace
-  ): SolidityStackTrace {
-    const subtrace = this._getLastSubtrace(trace);
-
-    if (subtrace !== undefined) {
-      // This is not a very exact heuristic, but most of the time it will be right, as solidity
-      // reverts if a call fails, and most contracts are in solidity
-      if (
-        subtrace.exit.isError() &&
-        equalsBytes(trace.returnData, subtrace.returnData)
-      ) {
-        let unrecognizedEntry: SolidityStackTraceEntry;
-
-        if (isCreateTrace(trace)) {
-          unrecognizedEntry = {
-            type: StackTraceEntryType.UNRECOGNIZED_CREATE_CALLSTACK_ENTRY,
-          };
-        } else {
-          unrecognizedEntry = {
-            type: StackTraceEntryType.UNRECOGNIZED_CONTRACT_CALLSTACK_ENTRY,
-            address: trace.address,
-          };
-        }
-
-        return [unrecognizedEntry, ...this.getStackTrace(subtrace)];
-      }
-    }
-
-    if (trace.exit.kind === ExitCode.CODESIZE_EXCEEDS_MAXIMUM) {
-      return [
-        {
-          type: StackTraceEntryType.CONTRACT_TOO_LARGE_ERROR,
-        },
-      ];
-    }
-
-    const isInvalidOpcodeError = trace.exit.kind === ExitCode.INVALID_OPCODE;
-
-    if (isCreateTrace(trace)) {
-      return [
-        {
-          type: StackTraceEntryType.UNRECOGNIZED_CREATE_ERROR,
-          message: new ReturnData(trace.returnData),
-          isInvalidOpcodeError,
-        },
-      ];
-    }
-
-    return [
-      {
-        type: StackTraceEntryType.UNRECOGNIZED_CONTRACT_ERROR,
-        address: trace.address,
-        message: new ReturnData(trace.returnData),
-        isInvalidOpcodeError,
-      },
-    ];
-  }
-
-  private _getCreateMessageStackTrace(
-    trace: DecodedCreateMessageTrace
-  ): SolidityStackTrace {
-    const inferredError =
-      this._errorInferrer.inferBeforeTracingCreateMessage(trace);
-
-    if (inferredError !== undefined) {
-      return inferredError;
-    }
-
-    return this._traceEvmExecution(trace);
-  }
-
-  private _getPrecompileMessageStackTrace(
-    trace: PrecompileMessageTrace
-  ): SolidityStackTrace {
-    return [
-      {
-        type: StackTraceEntryType.PRECOMPILE_ERROR,
-        precompile: trace.precompile,
-      },
-    ];
-  }
-
-  private _traceEvmExecution(
-    trace: DecodedEvmMessageTrace
-  ): SolidityStackTrace {
-    const stackTrace = this._rawTraceEvmExecution(trace);
-
-    if (stackTraceMayRequireAdjustments(stackTrace, trace)) {
-      return adjustStackTrace(stackTrace, trace);
-    }
-
-    return stackTrace;
-  }
-
-  private _rawTraceEvmExecution(
-    trace: DecodedEvmMessageTrace
-  ): SolidityStackTrace {
-    const stacktrace: SolidityStackTrace = [];
-
-    let subtracesSeen = 0;
-
-    // There was a jump into a function according to the sourcemaps
-    let jumpedIntoFunction = false;
-
-    const functionJumpdests: Instruction[] = [];
-
-    let lastSubmessageData: SubmessageData | undefined;
-
-    for (let stepIndex = 0; stepIndex < trace.steps.length; stepIndex++) {
-      const step = trace.steps[stepIndex];
-      const nextStep = trace.steps[stepIndex + 1];
-
-      if (isEvmStep(step)) {
-        const inst = trace.bytecode.getInstruction(step.pc);
-
-        if (
-          inst.jumpType === JumpType.INTO_FUNCTION &&
-          nextStep !== undefined
-        ) {
-          const nextEvmStep = nextStep as EvmStep; // A jump can't be followed by a subtrace
-          const nextInst = trace.bytecode.getInstruction(nextEvmStep.pc);
-
-          if (nextInst !== undefined && nextInst.opcode === Opcode.JUMPDEST) {
-            stacktrace.push(
-              instructionToCallstackStackTraceEntry(trace.bytecode, inst)
-            );
-            if (nextInst.location !== undefined) {
-              jumpedIntoFunction = true;
-            }
-            functionJumpdests.push(nextInst);
-          }
-        } else if (inst.jumpType === JumpType.OUTOF_FUNCTION) {
-          stacktrace.pop();
-          functionJumpdests.pop();
-        }
-      } else {
-        subtracesSeen += 1;
-
-        // If there are more subtraces, this one didn't terminate the execution
-        if (subtracesSeen < trace.numberOfSubtraces) {
-          continue;
-        }
-
-        const submessageTrace = this.getStackTrace(step);
-
-        lastSubmessageData = {
-          messageTrace: step,
-          stepIndex,
-          stacktrace: submessageTrace,
-        };
-      }
-    }
-
-    const stacktraceWithInferredError = this._errorInferrer.inferAfterTracing(
-      trace,
-      stacktrace,
-      functionJumpdests,
-      jumpedIntoFunction,
-      lastSubmessageData
-    );
-
-    return this._errorInferrer.filterRedundantFrames(
-      stacktraceWithInferredError
-    );
-  }
-
-  private _getLastSubtrace(trace: EvmMessageTrace): MessageTrace | undefined {
-    if (trace.numberOfSubtraces < 1) {
-      return undefined;
-    }
-
-    let i = trace.steps.length - 1;
-
-    while (isEvmStep(trace.steps[i])) {
-      i -= 1;
-    }
-
-    return trace.steps[i] as MessageTrace;
-  }
-}
+export { SolidityTracer };

package/src/internal/hardhat-network/stack-traces/vm-trace-decoder.ts

@@ -1,121 +1,22 @@
+import type { VmTraceDecoder as VmTraceDecoderT } from "@nomicfoundation/edr";
 import chalk from "chalk";
 import debug from "debug";
 import { Reporter } from "../../sentry/reporter";
 import { TracingConfig } from "../provider/node-types";
-import { createModelsAndDecodeBytecodes } from "./compiler-to-model";
-import { ContractsIdentifier } from "./contracts-identifier";
-import {
-  isCreateTrace,
-  isEvmStep,
-  isPrecompileTrace,
-  MessageTrace,
-} from "./message-trace";
-import { Bytecode, ContractFunctionType } from "./model";
-import {
-  FALLBACK_FUNCTION_NAME,
-  RECEIVE_FUNCTION_NAME,
-  UNRECOGNIZED_CONTRACT_NAME,
-  UNRECOGNIZED_FUNCTION_NAME,
-} from "./solidity-stack-trace";
+import { requireNapiRsModule } from "../../../common/napi-rs";
 
 const log = debug("hardhat:core:hardhat-network:node");
 
-export class VmTraceDecoder {
-  constructor(private readonly _contractsIdentifier: ContractsIdentifier) {}
+const { VmTraceDecoder, initializeVmTraceDecoder } = requireNapiRsModule(
+  "@nomicfoundation/edr"
+) as typeof import("@nomicfoundation/edr");
 
-  public getContractAndFunctionNamesForCall(
-    code: Buffer,
-    calldata?: Buffer
-  ): { contractName: string; functionName?: string } {
-    const isCreate = calldata === undefined;
-    const bytecode = this._contractsIdentifier.getBytecodeForCall(
-      code,
-      isCreate
-    );
-
-    const contractName = bytecode?.contract.name ?? UNRECOGNIZED_CONTRACT_NAME;
-
-    if (isCreate) {
-      return {
-        contractName,
-      };
-    } else {
-      if (bytecode === undefined) {
-        return {
-          contractName,
-          functionName: "",
-        };
-      } else {
-        const func = bytecode.contract.getFunctionFromSelector(
-          calldata.slice(0, 4)
-        );
-
-        const functionName: string =
-          func === undefined
-            ? UNRECOGNIZED_FUNCTION_NAME
-            : func.type === ContractFunctionType.FALLBACK
-            ? FALLBACK_FUNCTION_NAME
-            : func.type === ContractFunctionType.RECEIVE
-            ? RECEIVE_FUNCTION_NAME
-            : func.name;
-
-        return {
-          contractName,
-          functionName,
-        };
-      }
-    }
-  }
-
-  public tryToDecodeMessageTrace(messageTrace: MessageTrace): MessageTrace {
-    if (isPrecompileTrace(messageTrace)) {
-      return messageTrace;
-    }
-
-    return {
-      ...messageTrace,
-      bytecode: this._contractsIdentifier.getBytecodeForCall(
-        messageTrace.code,
-        isCreateTrace(messageTrace)
-      ),
-      steps: messageTrace.steps.map((s) =>
-        isEvmStep(s) ? s : this.tryToDecodeMessageTrace(s)
-      ),
-    };
-  }
-
-  public addBytecode(bytecode: Bytecode) {
-    this._contractsIdentifier.addBytecode(bytecode);
-  }
-}
-
-export function initializeVmTraceDecoder(
-  vmTraceDecoder: VmTraceDecoder,
+function initializeVmTraceDecoderWrapper(
+  vmTraceDecoder: VmTraceDecoderT,
   tracingConfig: TracingConfig
 ) {
-  if (tracingConfig.buildInfos === undefined) {
-    return;
-  }
-
   try {
-    for (const buildInfo of tracingConfig.buildInfos) {
-      const bytecodes = createModelsAndDecodeBytecodes(
-        buildInfo.solcVersion,
-        buildInfo.input,
-        buildInfo.output
-      );
-
-      for (const bytecode of bytecodes) {
-        if (
-          tracingConfig.ignoreContracts === true &&
-          bytecode.contract.name.startsWith("Ignored")
-        ) {
-          continue;
-        }
-
-        vmTraceDecoder.addBytecode(bytecode);
-      }
-    }
+    initializeVmTraceDecoder(vmTraceDecoder, tracingConfig);
   } catch (error) {
     console.warn(
       chalk.yellow(
@@ -124,7 +25,7 @@ export function initializeVmTraceDecoder(
     );
 
     log(
-      "Hardhat Network tracing disabled: ContractsIdentifier failed to be initialized. Please report this to help us improve Hardhat.\n",
+      "Hardhat Network tracing disabled: VmTraceDecoder failed to be initialized. Please report this to help us improve Hardhat.\n",
       error
     );
 
@@ -133,3 +34,9 @@ export function initializeVmTraceDecoder(
     }
   }
 }
+
+export {
+  VmTraceDecoder,
+  VmTraceDecoderT,
+  initializeVmTraceDecoderWrapper as initializeVmTraceDecoder,
+};