hardhat 2.22.11 → 2.22.13

package/src/internal/hardhat-network/stack-traces/error-inferrer.ts

@@ -1,1845 +0,0 @@
-/* eslint "@typescript-eslint/no-non-null-assertion": "error" */
-import { defaultAbiCoder as abi } from "@ethersproject/abi";
-import { equalsBytes } from "@nomicfoundation/ethereumjs-util";
-import semver from "semver";
-
-import { assertHardhatInvariant } from "../../core/errors";
-import { AbiHelpers } from "../../util/abi-helpers";
-import { ReturnData } from "../provider/return-data";
-import { ExitCode } from "../provider/vm/exit";
-
-import {
-  DecodedCallMessageTrace,
-  DecodedCreateMessageTrace,
-  DecodedEvmMessageTrace,
-  EvmStep,
-  isCreateTrace,
-  isDecodedCallTrace,
-  isDecodedCreateTrace,
-  isEvmStep,
-  isPrecompileTrace,
-  MessageTrace,
-} from "./message-trace";
-import {
-  Bytecode,
-  ContractFunction,
-  ContractFunctionType,
-  ContractType,
-  Instruction,
-  JumpType,
-  SourceLocation,
-} from "./model";
-import { isCall, isCreate, Opcode } from "./opcodes";
-import {
-  CallFailedErrorStackTraceEntry,
-  CallstackEntryStackTraceEntry,
-  CONSTRUCTOR_FUNCTION_NAME,
-  CustomErrorStackTraceEntry,
-  FALLBACK_FUNCTION_NAME,
-  InternalFunctionCallStackEntry,
-  OtherExecutionErrorStackTraceEntry,
-  PanicErrorStackTraceEntry,
-  RECEIVE_FUNCTION_NAME,
-  RevertErrorStackTraceEntry,
-  SolidityStackTrace,
-  SolidityStackTraceEntry,
-  SourceReference,
-  StackTraceEntryType,
-  UnmappedSolc063RevertErrorStackTraceEntry,
-} from "./solidity-stack-trace";
-
-const FIRST_SOLC_VERSION_CREATE_PARAMS_VALIDATION = "0.5.9";
-const FIRST_SOLC_VERSION_RECEIVE_FUNCTION = "0.6.0";
-const FIRST_SOLC_VERSION_WITH_UNMAPPED_REVERTS = "0.6.3";
-
-export interface SubmessageData {
-  messageTrace: MessageTrace;
-  stacktrace: SolidityStackTrace;
-  stepIndex: number;
-}
-
-/* eslint-disable @nomicfoundation/hardhat-internal-rules/only-hardhat-error */
-
-export class ErrorInferrer {
-  public inferBeforeTracingCallMessage(
-    trace: DecodedCallMessageTrace
-  ): SolidityStackTrace | undefined {
-    if (this._isDirectLibraryCall(trace)) {
-      return this._getDirectLibraryCallErrorStackTrace(trace);
-    }
-
-    const calledFunction = trace.bytecode.contract.getFunctionFromSelector(
-      trace.calldata.slice(0, 4)
-    );
-
-    if (
-      calledFunction !== undefined &&
-      this._isFunctionNotPayableError(trace, calledFunction)
-    ) {
-      return [
-        {
-          type: StackTraceEntryType.FUNCTION_NOT_PAYABLE_ERROR,
-          sourceReference: this._getFunctionStartSourceReference(
-            trace,
-            calledFunction
-          ),
-          value: trace.value,
-        },
-      ];
-    }
-
-    if (this._isMissingFunctionAndFallbackError(trace, calledFunction)) {
-      if (this._emptyCalldataAndNoReceive(trace)) {
-        return [
-          {
-            type: StackTraceEntryType.MISSING_FALLBACK_OR_RECEIVE_ERROR,
-            sourceReference:
-              this._getContractStartWithoutFunctionSourceReference(trace),
-          },
-        ];
-      }
-
-      return [
-        {
-          type: StackTraceEntryType.UNRECOGNIZED_FUNCTION_WITHOUT_FALLBACK_ERROR,
-          sourceReference:
-            this._getContractStartWithoutFunctionSourceReference(trace),
-        },
-      ];
-    }
-
-    if (this._isFallbackNotPayableError(trace, calledFunction)) {
-      if (this._emptyCalldataAndNoReceive(trace)) {
-        return [
-          {
-            type: StackTraceEntryType.FALLBACK_NOT_PAYABLE_AND_NO_RECEIVE_ERROR,
-            sourceReference: this._getFallbackStartSourceReference(trace),
-            value: trace.value,
-          },
-        ];
-      }
-
-      return [
-        {
-          type: StackTraceEntryType.FALLBACK_NOT_PAYABLE_ERROR,
-          sourceReference: this._getFallbackStartSourceReference(trace),
-          value: trace.value,
-        },
-      ];
-    }
-  }
-
-  public inferBeforeTracingCreateMessage(
-    trace: DecodedCreateMessageTrace
-  ): SolidityStackTrace | undefined {
-    if (this._isConstructorNotPayableError(trace)) {
-      return [
-        {
-          type: StackTraceEntryType.FUNCTION_NOT_PAYABLE_ERROR,
-          sourceReference: this._getConstructorStartSourceReference(trace),
-          value: trace.value,
-        },
-      ];
-    }
-
-    if (this._isConstructorInvalidArgumentsError(trace)) {
-      return [
-        {
-          type: StackTraceEntryType.INVALID_PARAMS_ERROR,
-          sourceReference: this._getConstructorStartSourceReference(trace),
-        },
-      ];
-    }
-  }
-
-  public inferAfterTracing(
-    trace: DecodedEvmMessageTrace,
-    stacktrace: SolidityStackTrace,
-    functionJumpdests: Instruction[],
-    jumpedIntoFunction: boolean,
-    lastSubmessageData: SubmessageData | undefined
-  ): SolidityStackTrace {
-    return (
-      this._checkLastSubmessage(trace, stacktrace, lastSubmessageData) ??
-      this._checkFailedLastCall(trace, stacktrace) ??
-      this._checkLastInstruction(
-        trace,
-        stacktrace,
-        functionJumpdests,
-        jumpedIntoFunction
-      ) ??
-      this._checkNonContractCalled(trace, stacktrace) ??
-      this._checkSolidity063UnmappedRevert(trace, stacktrace) ??
-      this._checkContractTooLarge(trace) ??
-      this._otherExecutionErrorStacktrace(trace, stacktrace)
-    );
-  }
-
-  public filterRedundantFrames(
-    stacktrace: SolidityStackTrace
-  ): SolidityStackTrace {
-    return stacktrace.filter((frame, i) => {
-      if (i + 1 === stacktrace.length) {
-        return true;
-      }
-
-      const nextFrame = stacktrace[i + 1];
-
-      // we can only filter frames if we know their sourceReference
-      // and the one from the next frame
-      if (
-        frame.sourceReference === undefined ||
-        nextFrame.sourceReference === undefined
-      ) {
-        return true;
-      }
-
-      // look TWO frames ahead to determine if this is a specific occurrence of
-      // a redundant CALLSTACK_ENTRY frame observed when using Solidity 0.8.5:
-      if (
-        frame.type === StackTraceEntryType.CALLSTACK_ENTRY &&
-        i + 2 < stacktrace.length &&
-        stacktrace[i + 2].sourceReference !== undefined &&
-        stacktrace[i + 2].type === StackTraceEntryType.RETURNDATA_SIZE_ERROR
-      ) {
-        // ! below for tsc. we confirmed existence in the enclosing conditional.
-        const thatSrcRef = stacktrace[i + 2].sourceReference;
-        if (
-          thatSrcRef !== undefined &&
-          frame.sourceReference.range[0] === thatSrcRef.range[0] &&
-          frame.sourceReference.range[1] === thatSrcRef.range[1] &&
-          frame.sourceReference.line === thatSrcRef.line
-        ) {
-          return false;
-        }
-      }
-
-      // constructors contain the whole contract, so we ignore them
-      if (
-        frame.sourceReference.function === "constructor" &&
-        nextFrame.sourceReference.function !== "constructor"
-      ) {
-        return true;
-      }
-
-      // this is probably a recursive call
-      if (
-        i > 0 &&
-        frame.type === nextFrame.type &&
-        frame.sourceReference.range[0] === nextFrame.sourceReference.range[0] &&
-        frame.sourceReference.range[1] === nextFrame.sourceReference.range[1] &&
-        frame.sourceReference.line === nextFrame.sourceReference.line
-      ) {
-        return true;
-      }
-
-      if (
-        frame.sourceReference.range[0] <= nextFrame.sourceReference.range[0] &&
-        frame.sourceReference.range[1] >= nextFrame.sourceReference.range[1]
-      ) {
-        return false;
-      }
-
-      return true;
-    });
-  }
-
-  // Heuristics
-
-  /**
-   * Check if the last submessage can be used to generate the stack trace.
-   */
-  private _checkLastSubmessage(
-    trace: DecodedEvmMessageTrace,
-    stacktrace: SolidityStackTrace,
-    lastSubmessageData: SubmessageData | undefined
-  ): SolidityStackTrace | undefined {
-    if (lastSubmessageData === undefined) {
-      return undefined;
-    }
-
-    const inferredStacktrace = [...stacktrace];
-
-    // get the instruction before the submessage and add it to the stack trace
-    const callStep = trace.steps[lastSubmessageData.stepIndex - 1];
-
-    if (!isEvmStep(callStep)) {
-      throw new Error(
-        "This should not happen: MessageTrace should be preceded by a EVM step"
-      );
-    }
-
-    const callInst = trace.bytecode.getInstruction(callStep.pc);
-    const callStackFrame = instructionToCallstackStackTraceEntry(
-      trace.bytecode,
-      callInst
-    );
-
-    const lastMessageFailed = lastSubmessageData.messageTrace.exit.isError();
-    if (lastMessageFailed) {
-      // add the call/create that generated the message to the stack trace
-      inferredStacktrace.push(callStackFrame);
-
-      if (
-        this._isSubtraceErrorPropagated(trace, lastSubmessageData.stepIndex) ||
-        this._isProxyErrorPropagated(trace, lastSubmessageData.stepIndex)
-      ) {
-        inferredStacktrace.push(...lastSubmessageData.stacktrace);
-
-        if (
-          this._isContractCallRunOutOfGasError(
-            trace,
-            lastSubmessageData.stepIndex
-          )
-        ) {
-          const lastFrame = inferredStacktrace.pop();
-          assertHardhatInvariant(
-            lastFrame !== undefined,
-            "Expected inferred stack trace to have at least one frame"
-          );
-          inferredStacktrace.push({
-            type: StackTraceEntryType.CONTRACT_CALL_RUN_OUT_OF_GAS_ERROR,
-            sourceReference: lastFrame.sourceReference,
-          });
-        }
-
-        return this._fixInitialModifier(trace, inferredStacktrace);
-      }
-    } else {
-      const isReturnDataSizeError = this._failsRightAfterCall(
-        trace,
-        lastSubmessageData.stepIndex
-      );
-      if (isReturnDataSizeError) {
-        inferredStacktrace.push({
-          type: StackTraceEntryType.RETURNDATA_SIZE_ERROR,
-          sourceReference: callStackFrame.sourceReference,
-        });
-
-        return this._fixInitialModifier(trace, inferredStacktrace);
-      }
-    }
-  }
-
-  /**
-   * Check if the last call/create that was done failed.
-   */
-  private _checkFailedLastCall(
-    trace: DecodedEvmMessageTrace,
-    stacktrace: SolidityStackTrace
-  ): SolidityStackTrace | undefined {
-    for (let stepIndex = trace.steps.length - 2; stepIndex >= 0; stepIndex--) {
-      const step = trace.steps[stepIndex];
-      const nextStep = trace.steps[stepIndex + 1];
-
-      if (!isEvmStep(step)) {
-        return;
-      }
-
-      const inst = trace.bytecode.getInstruction(step.pc);
-
-      const isCallOrCreate = isCall(inst.opcode) || isCreate(inst.opcode);
-
-      if (isCallOrCreate && isEvmStep(nextStep)) {
-        if (this._isCallFailedError(trace, stepIndex, inst)) {
-          const inferredStacktrace = [
-            ...stacktrace,
-            this._callInstructionToCallFailedToExecuteStackTraceEntry(
-              trace.bytecode,
-              inst
-            ),
-          ];
-
-          return this._fixInitialModifier(trace, inferredStacktrace);
-        }
-      }
-    }
-  }
-
-  /**
-   * Check if the execution stopped with a revert or an invalid opcode.
-   */
-  private _checkRevertOrInvalidOpcode(
-    trace: DecodedEvmMessageTrace,
-    stacktrace: SolidityStackTrace,
-    lastInstruction: Instruction,
-    functionJumpdests: Instruction[],
-    jumpedIntoFunction: boolean
-  ): SolidityStackTrace | undefined {
-    if (
-      lastInstruction.opcode !== Opcode.REVERT &&
-      lastInstruction.opcode !== Opcode.INVALID
-    ) {
-      return;
-    }
-
-    const inferredStacktrace = [...stacktrace];
-
-    if (
-      lastInstruction.location !== undefined &&
-      (!isDecodedCallTrace(trace) || jumpedIntoFunction)
-    ) {
-      // There should always be a function here, but that's not the case with optimizations.
-      //
-      // If this is a create trace, we already checked args and nonpayable failures before
-      // calling this function.
-      //
-      // If it's a call trace, we already jumped into a function. But optimizations can happen.
-      const failingFunction = lastInstruction.location.getContainingFunction();
-
-      // If the failure is in a modifier we add an entry with the function/constructor
-      if (
-        failingFunction !== undefined &&
-        failingFunction.type === ContractFunctionType.MODIFIER
-      ) {
-        inferredStacktrace.push(
-          this._getEntryBeforeFailureInModifier(trace, functionJumpdests)
-        );
-      }
-    }
-
-    const panicStacktrace = this._checkPanic(
-      trace,
-      inferredStacktrace,
-      lastInstruction
-    );
-    if (panicStacktrace !== undefined) {
-      return panicStacktrace;
-    }
-
-    const customErrorStacktrace = this._checkCustomErrors(
-      trace,
-      inferredStacktrace,
-      lastInstruction
-    );
-    if (customErrorStacktrace !== undefined) {
-      return customErrorStacktrace;
-    }
-
-    if (
-      lastInstruction.location !== undefined &&
-      (!isDecodedCallTrace(trace) || jumpedIntoFunction)
-    ) {
-      const failingFunction = lastInstruction.location.getContainingFunction();
-
-      if (failingFunction !== undefined) {
-        inferredStacktrace.push(
-          this._instructionWithinFunctionToRevertStackTraceEntry(
-            trace,
-            lastInstruction
-          )
-        );
-      } else if (isDecodedCallTrace(trace)) {
-        // This is here because of the optimizations
-        const functionSelector =
-          trace.bytecode.contract.getFunctionFromSelector(
-            trace.calldata.slice(0, 4)
-          );
-
-        // in general this shouldn't happen, but it does when viaIR is enabled,
-        // "optimizerSteps": "u" is used, and the called function is fallback or
-        // receive
-        if (functionSelector === undefined) {
-          return;
-        }
-
-        inferredStacktrace.push({
-          type: StackTraceEntryType.REVERT_ERROR,
-          sourceReference: this._getFunctionStartSourceReference(
-            trace,
-            functionSelector
-          ),
-          message: new ReturnData(trace.returnData),
-          isInvalidOpcodeError: lastInstruction.opcode === Opcode.INVALID,
-        });
-      } else {
-        // This is here because of the optimizations
-        inferredStacktrace.push({
-          type: StackTraceEntryType.REVERT_ERROR,
-          sourceReference: this._getConstructorStartSourceReference(trace),
-          message: new ReturnData(trace.returnData),
-          isInvalidOpcodeError: lastInstruction.opcode === Opcode.INVALID,
-        });
-      }
-
-      return this._fixInitialModifier(trace, inferredStacktrace);
-    }
-
-    // If the revert instruction is not mapped but there is return data,
-    // we add the frame anyway, sith the best sourceReference we can get
-    if (lastInstruction.location === undefined && trace.returnData.length > 0) {
-      const revertFrame: RevertErrorStackTraceEntry = {
-        type: StackTraceEntryType.REVERT_ERROR,
-        sourceReference:
-          this._getLastSourceReference(trace) ??
-          this._getContractStartWithoutFunctionSourceReference(trace),
-        message: new ReturnData(trace.returnData),
-        isInvalidOpcodeError: lastInstruction.opcode === Opcode.INVALID,
-      };
-      inferredStacktrace.push(revertFrame);
-
-      return this._fixInitialModifier(trace, inferredStacktrace);
-    }
-  }
-
-  /**
-   * Check if the trace reverted with a panic error.
-   */
-  private _checkPanic(
-    trace: DecodedEvmMessageTrace,
-    stacktrace: SolidityStackTrace,
-    lastInstruction: Instruction
-  ): SolidityStackTrace | undefined {
-    if (!this._isPanicReturnData(trace.returnData)) {
-      return;
-    }
-
-    // If the last frame is an internal function, it means that the trace
-    // jumped there to return the panic. If that's the case, we remove that
-    // frame.
-    const lastFrame = stacktrace[stacktrace.length - 1];
-    if (
-      lastFrame?.type === StackTraceEntryType.INTERNAL_FUNCTION_CALLSTACK_ENTRY
-    ) {
-      stacktrace.splice(-1);
-    }
-
-    const panicReturnData = new ReturnData(trace.returnData);
-    const errorCode = panicReturnData.decodePanic();
-
-    // if the error comes from a call to a zero-initialized function,
-    // we remove the last frame, which represents the call, to avoid
-    // having duplicated frames
-    if (errorCode === 0x51n) {
-      stacktrace.splice(-1);
-    }
-
-    const inferredStacktrace = [...stacktrace];
-    inferredStacktrace.push(
-      this._instructionWithinFunctionToPanicStackTraceEntry(
-        trace,
-        lastInstruction,
-        errorCode
-      )
-    );
-
-    return this._fixInitialModifier(trace, inferredStacktrace);
-  }
-
-  private _checkCustomErrors(
-    trace: DecodedEvmMessageTrace,
-    stacktrace: SolidityStackTrace,
-    lastInstruction: Instruction
-  ): SolidityStackTrace | undefined {
-    const returnData = new ReturnData(trace.returnData);
-
-    if (returnData.isEmpty() || returnData.isErrorReturnData()) {
-      // if there is no return data, or if it's a Error(string),
-      // then it can't be a custom error
-      return;
-    }
-
-    const rawReturnData = Buffer.from(returnData.value).toString("hex");
-    let errorMessage = `reverted with an unrecognized custom error (return data: 0x${rawReturnData})`;
-
-    for (const customError of trace.bytecode.contract.customErrors) {
-      if (returnData.matchesSelector(customError.selector)) {
-        // if the return data matches a custom error in the called contract,
-        // we format the message using the returnData and the custom error instance
-        const decodedValues = abi.decode(
-          customError.paramTypes,
-          returnData.value.slice(4)
-        );
-
-        const params = AbiHelpers.formatValues([...decodedValues]);
-        errorMessage = `reverted with custom error '${customError.name}(${params})'`;
-        break;
-      }
-    }
-
-    const inferredStacktrace = [...stacktrace];
-    inferredStacktrace.push(
-      this._instructionWithinFunctionToCustomErrorStackTraceEntry(
-        trace,
-        lastInstruction,
-        errorMessage
-      )
-    );
-
-    return this._fixInitialModifier(trace, inferredStacktrace);
-  }
-
-  /**
-   * Check last instruction to try to infer the error.
-   */
-  private _checkLastInstruction(
-    trace: DecodedEvmMessageTrace,
-    stacktrace: SolidityStackTrace,
-    functionJumpdests: Instruction[],
-    jumpedIntoFunction: boolean
-  ): SolidityStackTrace | undefined {
-    if (trace.steps.length === 0) {
-      return;
-    }
-
-    const lastStep = trace.steps[trace.steps.length - 1];
-
-    if (!isEvmStep(lastStep)) {
-      throw new Error(
-        "This should not happen: MessageTrace ends with a subtrace"
-      );
-    }
-
-    const lastInstruction = trace.bytecode.getInstruction(lastStep.pc);
-
-    const revertOrInvalidStacktrace = this._checkRevertOrInvalidOpcode(
-      trace,
-      stacktrace,
-      lastInstruction,
-      functionJumpdests,
-      jumpedIntoFunction
-    );
-
-    if (revertOrInvalidStacktrace !== undefined) {
-      return revertOrInvalidStacktrace;
-    }
-
-    if (isDecodedCallTrace(trace) && !jumpedIntoFunction) {
-      if (
-        this._hasFailedInsideTheFallbackFunction(trace) ||
-        this._hasFailedInsideTheReceiveFunction(trace)
-      ) {
-        return [
-          this._instructionWithinFunctionToRevertStackTraceEntry(
-            trace,
-            lastInstruction
-          ),
-        ];
-      }
-
-      // Sometimes we do fail inside of a function but there's no jump into
-      if (lastInstruction.location !== undefined) {
-        const failingFunction =
-          lastInstruction.location.getContainingFunction();
-        if (failingFunction !== undefined) {
-          return [
-            {
-              type: StackTraceEntryType.REVERT_ERROR,
-              sourceReference: this._getFunctionStartSourceReference(
-                trace,
-                failingFunction
-              ),
-              message: new ReturnData(trace.returnData),
-              isInvalidOpcodeError: lastInstruction.opcode === Opcode.INVALID,
-            },
-          ];
-        }
-      }
-
-      const calledFunction = trace.bytecode.contract.getFunctionFromSelector(
-        trace.calldata.slice(0, 4)
-      );
-
-      if (calledFunction !== undefined) {
-        const isValidCalldata = calledFunction.isValidCalldata(
-          trace.calldata.slice(4)
-        );
-
-        if (!isValidCalldata) {
-          return [
-            {
-              type: StackTraceEntryType.INVALID_PARAMS_ERROR,
-              sourceReference: this._getFunctionStartSourceReference(
-                trace,
-                calledFunction
-              ),
-            },
-          ];
-        }
-      }
-
-      if (this._solidity063MaybeUnmappedRevert(trace)) {
-        const revertFrame =
-          this._solidity063GetFrameForUnmappedRevertBeforeFunction(trace);
-
-        if (revertFrame !== undefined) {
-          return [revertFrame];
-        }
-      }
-
-      return [this._getOtherErrorBeforeCalledFunctionStackTraceEntry(trace)];
-    }
-  }
-
-  private _checkNonContractCalled(
-    trace: DecodedEvmMessageTrace,
-    stacktrace: SolidityStackTrace
-  ): SolidityStackTrace | undefined {
-    if (this._isCalledNonContractAccountError(trace)) {
-      const sourceReference = this._getLastSourceReference(trace);
-
-      // We are sure this is not undefined because there was at least a call instruction
-      assertHardhatInvariant(
-        sourceReference !== undefined,
-        "Expected source reference to be defined"
-      );
-
-      const nonContractCalledFrame: SolidityStackTraceEntry = {
-        type: StackTraceEntryType.NONCONTRACT_ACCOUNT_CALLED_ERROR,
-        sourceReference,
-      };
-
-      return [...stacktrace, nonContractCalledFrame];
-    }
-  }
-
-  private _checkSolidity063UnmappedRevert(
-    trace: DecodedEvmMessageTrace,
-    stacktrace: SolidityStackTrace
-  ): SolidityStackTrace | undefined {
-    if (this._solidity063MaybeUnmappedRevert(trace)) {
-      const revertFrame =
-        this._solidity063GetFrameForUnmappedRevertWithinFunction(trace);
-
-      if (revertFrame !== undefined) {
-        return [...stacktrace, revertFrame];
-      }
-    }
-  }
-
-  private _checkContractTooLarge(
-    trace: DecodedEvmMessageTrace
-  ): SolidityStackTrace | undefined {
-    if (isCreateTrace(trace) && this._isContractTooLargeError(trace)) {
-      return [
-        {
-          type: StackTraceEntryType.CONTRACT_TOO_LARGE_ERROR,
-          sourceReference: this._getConstructorStartSourceReference(trace),
-        },
-      ];
-    }
-  }
-
-  private _otherExecutionErrorStacktrace(
-    trace: DecodedEvmMessageTrace,
-    stacktrace: SolidityStackTrace
-  ): SolidityStackTrace {
-    const otherExecutionErrorFrame: SolidityStackTraceEntry = {
-      type: StackTraceEntryType.OTHER_EXECUTION_ERROR,
-      sourceReference: this._getLastSourceReference(trace),
-    };
-
-    return [...stacktrace, otherExecutionErrorFrame];
-  }
-
-  // Helpers
-
-  private _fixInitialModifier(
-    trace: DecodedEvmMessageTrace,
-    stacktrace: SolidityStackTrace
-  ): SolidityStackTrace {
-    const firstEntry = stacktrace[0];
-    if (
-      firstEntry !== undefined &&
-      firstEntry.type === StackTraceEntryType.CALLSTACK_ENTRY &&
-      firstEntry.functionType === ContractFunctionType.MODIFIER
-    ) {
-      return [
-        this._getEntryBeforeInitialModifierCallstackEntry(trace),
-        ...stacktrace,
-      ];
-    }
-
-    return stacktrace;
-  }
-
-  private _isDirectLibraryCall(trace: DecodedCallMessageTrace): boolean {
-    return (
-      trace.depth === 0 && trace.bytecode.contract.type === ContractType.LIBRARY
-    );
-  }
-
-  private _getDirectLibraryCallErrorStackTrace(
-    trace: DecodedCallMessageTrace
-  ): SolidityStackTrace {
-    const func = trace.bytecode.contract.getFunctionFromSelector(
-      trace.calldata.slice(0, 4)
-    );
-
-    if (func !== undefined) {
-      return [
-        {
-          type: StackTraceEntryType.DIRECT_LIBRARY_CALL_ERROR,
-          sourceReference: this._getFunctionStartSourceReference(trace, func),
-        },
-      ];
-    }
-
-    return [
-      {
-        type: StackTraceEntryType.DIRECT_LIBRARY_CALL_ERROR,
-        sourceReference:
-          this._getContractStartWithoutFunctionSourceReference(trace),
-      },
-    ];
-  }
-
-  private _isFunctionNotPayableError(
-    trace: DecodedCallMessageTrace,
-    calledFunction: ContractFunction
-  ): boolean {
-    // This error doesn't return data
-    if (trace.returnData.length > 0) {
-      return false;
-    }
-
-    if (trace.value <= 0n) {
-      return false;
-    }
-
-    // Libraries don't have a nonpayable check
-    if (trace.bytecode.contract.type === ContractType.LIBRARY) {
-      return false;
-    }
-
-    return calledFunction.isPayable === undefined || !calledFunction.isPayable;
-  }
-
-  private _getFunctionStartSourceReference(
-    trace: DecodedEvmMessageTrace,
-    func: ContractFunction
-  ): SourceReference {
-    return {
-      sourceName: func.location.file.sourceName,
-      sourceContent: func.location.file.content,
-      contract: trace.bytecode.contract.name,
-      function: func.name,
-      line: func.location.getStartingLineNumber(),
-      range: [
-        func.location.offset,
-        func.location.offset + func.location.length,
-      ],
-    };
-  }
-
-  private _isMissingFunctionAndFallbackError(
-    trace: DecodedCallMessageTrace,
-    calledFunction: ContractFunction | undefined
-  ): boolean {
-    // This error doesn't return data
-    if (trace.returnData.length > 0) {
-      return false;
-    }
-
-    // the called function exists in the contract
-    if (calledFunction !== undefined) {
-      return false;
-    }
-
-    // there's a receive function and no calldata
-    if (
-      trace.calldata.length === 0 &&
-      trace.bytecode.contract.receive !== undefined
-    ) {
-      return false;
-    }
-
-    return trace.bytecode.contract.fallback === undefined;
-  }
-
-  private _emptyCalldataAndNoReceive(trace: DecodedCallMessageTrace): boolean {
-    // this only makes sense when receive functions are available
-    if (
-      semver.lt(
-        trace.bytecode.compilerVersion,
-        FIRST_SOLC_VERSION_RECEIVE_FUNCTION
-      )
-    ) {
-      return false;
-    }
-
-    return (
-      trace.calldata.length === 0 &&
-      trace.bytecode.contract.receive === undefined
-    );
-  }
-
-  private _getContractStartWithoutFunctionSourceReference(
-    trace: DecodedEvmMessageTrace
-  ): SourceReference {
-    const location = trace.bytecode.contract.location;
-    return {
-      sourceName: location.file.sourceName,
-      sourceContent: location.file.content,
-      contract: trace.bytecode.contract.name,
-      line: location.getStartingLineNumber(),
-      range: [location.offset, location.offset + location.length],
-    };
-  }
-
-  private _isFallbackNotPayableError(
-    trace: DecodedCallMessageTrace,
-    calledFunction: ContractFunction | undefined
-  ): boolean {
-    if (calledFunction !== undefined) {
-      return false;
-    }
-
-    // This error doesn't return data
-    if (trace.returnData.length > 0) {
-      return false;
-    }
-
-    if (trace.value <= 0n) {
-      return false;
-    }
-
-    if (trace.bytecode.contract.fallback === undefined) {
-      return false;
-    }
-
-    const isPayable = trace.bytecode.contract.fallback.isPayable;
-
-    return isPayable === undefined || !isPayable;
-  }
-
-  private _getFallbackStartSourceReference(
-    trace: DecodedCallMessageTrace
-  ): SourceReference {
-    const func = trace.bytecode.contract.fallback;
-
-    if (func === undefined) {
-      throw new Error(
-        "This shouldn't happen: trying to get fallback source reference from a contract without fallback"
-      );
-    }
-
-    return {
-      sourceName: func.location.file.sourceName,
-      sourceContent: func.location.file.content,
-      contract: trace.bytecode.contract.name,
-      function: FALLBACK_FUNCTION_NAME,
-      line: func.location.getStartingLineNumber(),
-      range: [
-        func.location.offset,
-        func.location.offset + func.location.length,
-      ],
-    };
-  }
-
-  private _isConstructorNotPayableError(
-    trace: DecodedCreateMessageTrace
-  ): boolean {
-    // This error doesn't return data
-    if (trace.returnData.length > 0) {
-      return false;
-    }
-
-    const constructor = trace.bytecode.contract.constructorFunction;
-
-    // This function is only matters with contracts that have constructors defined. The ones that
-    // don't are abstract contracts, or their constructor doesn't take any argument.
-    if (constructor === undefined) {
-      return false;
-    }
-
-    return (
-      trace.value > 0n &&
-      (constructor.isPayable === undefined || !constructor.isPayable)
-    );
-  }
-
-  /**
-   * Returns a source reference pointing to the constructor if it exists, or to the contract
-   * otherwise.
-   */
-  private _getConstructorStartSourceReference(
-    trace: DecodedCreateMessageTrace
-  ): SourceReference {
-    const contract = trace.bytecode.contract;
-    const constructor = contract.constructorFunction;
-
-    const line =
-      constructor !== undefined
-        ? constructor.location.getStartingLineNumber()
-        : contract.location.getStartingLineNumber();
-
-    return {
-      sourceName: contract.location.file.sourceName,
-      sourceContent: contract.location.file.content,
-      contract: contract.name,
-      function: CONSTRUCTOR_FUNCTION_NAME,
-      line,
-      range: [
-        contract.location.offset,
-        contract.location.offset + contract.location.length,
-      ],
-    };
-  }
-
-  private _isConstructorInvalidArgumentsError(
-    trace: DecodedCreateMessageTrace
-  ): boolean {
-    // This error doesn't return data
-    if (trace.returnData.length > 0) {
-      return false;
-    }
-
-    const contract = trace.bytecode.contract;
-    const constructor = contract.constructorFunction;
-
-    // This function is only matters with contracts that have constructors defined. The ones that
-    // don't are abstract contracts, or their constructor doesn't take any argument.
-    if (constructor === undefined) {
-      return false;
-    }
-
-    if (
-      semver.lt(
-        trace.bytecode.compilerVersion,
-        FIRST_SOLC_VERSION_CREATE_PARAMS_VALIDATION
-      )
-    ) {
-      return false;
-    }
-
-    const lastStep = trace.steps[trace.steps.length - 1];
-    if (!isEvmStep(lastStep)) {
-      return false;
-    }
-
-    const lastInst = trace.bytecode.getInstruction(lastStep.pc);
-    if (lastInst.opcode !== Opcode.REVERT || lastInst.location !== undefined) {
-      return false;
-    }
-
-    let hasReadDeploymentCodeSize = false;
-
-    // eslint-disable-next-line @typescript-eslint/prefer-for-of
-    for (let stepIndex = 0; stepIndex < trace.steps.length; stepIndex++) {
-      const step = trace.steps[stepIndex];
-      if (!isEvmStep(step)) {
-        return false;
-      }
-
-      const inst = trace.bytecode.getInstruction(step.pc);
-
-      if (
-        inst.location !== undefined &&
-        !contract.location.equals(inst.location) &&
-        !constructor.location.equals(inst.location)
-      ) {
-        return false;
-      }
-
-      if (inst.opcode === Opcode.CODESIZE && isCreateTrace(trace)) {
-        hasReadDeploymentCodeSize = true;
-      }
-    }
-
-    return hasReadDeploymentCodeSize;
-  }
-
-  private _getEntryBeforeInitialModifierCallstackEntry(
-    trace: DecodedEvmMessageTrace
-  ): SolidityStackTraceEntry {
-    if (isDecodedCreateTrace(trace)) {
-      return {
-        type: StackTraceEntryType.CALLSTACK_ENTRY,
-        sourceReference: this._getConstructorStartSourceReference(trace),
-        functionType: ContractFunctionType.CONSTRUCTOR,
-      };
-    }
-
-    const calledFunction = trace.bytecode.contract.getFunctionFromSelector(
-      trace.calldata.slice(0, 4)
-    );
-
-    if (calledFunction !== undefined) {
-      return {
-        type: StackTraceEntryType.CALLSTACK_ENTRY,
-        sourceReference: this._getFunctionStartSourceReference(
-          trace,
-          calledFunction
-        ),
-        functionType: ContractFunctionType.FUNCTION,
-      };
-    }
-
-    // If it failed or made a call from within a modifier, and the selector doesn't match
-    // any function, it must have a fallback.
-    return {
-      type: StackTraceEntryType.CALLSTACK_ENTRY,
-      sourceReference: this._getFallbackStartSourceReference(trace),
-      functionType: ContractFunctionType.FALLBACK,
-    };
-  }
-
-  private _getLastSourceReference(
-    trace: DecodedEvmMessageTrace
-  ): SourceReference | undefined {
-    for (let i = trace.steps.length - 1; i >= 0; i--) {
-      const step = trace.steps[i];
-      if (!isEvmStep(step)) {
-        continue;
-      }
-
-      const inst = trace.bytecode.getInstruction(step.pc);
-
-      if (inst.location === undefined) {
-        continue;
-      }
-
-      const sourceReference = sourceLocationToSourceReference(
-        trace.bytecode,
-        inst.location
-      );
-
-      if (sourceReference !== undefined) {
-        return sourceReference;
-      }
-    }
-
-    return undefined;
-  }
-
-  private _hasFailedInsideTheFallbackFunction(
-    trace: DecodedCallMessageTrace
-  ): boolean {
-    const contract = trace.bytecode.contract;
-
-    if (contract.fallback === undefined) {
-      return false;
-    }
-
-    return this._hasFailedInsideFunction(trace, contract.fallback);
-  }
-
-  private _hasFailedInsideTheReceiveFunction(
-    trace: DecodedCallMessageTrace
-  ): boolean {
-    const contract = trace.bytecode.contract;
-
-    if (contract.receive === undefined) {
-      return false;
-    }
-
-    return this._hasFailedInsideFunction(trace, contract.receive);
-  }
-
-  private _hasFailedInsideFunction(
-    trace: DecodedCallMessageTrace,
-    func: ContractFunction
-  ) {
-    const lastStep = trace.steps[trace.steps.length - 1] as EvmStep;
-    const lastInstruction = trace.bytecode.getInstruction(lastStep.pc);
-
-    return (
-      lastInstruction.location !== undefined &&
-      lastInstruction.opcode === Opcode.REVERT &&
-      func.location.contains(lastInstruction.location)
-    );
-  }
-
-  private _instructionWithinFunctionToRevertStackTraceEntry(
-    trace: DecodedEvmMessageTrace,
-    inst: Instruction
-  ): RevertErrorStackTraceEntry {
-    const sourceReference = sourceLocationToSourceReference(
-      trace.bytecode,
-      inst.location
-    );
-    assertHardhatInvariant(
-      sourceReference !== undefined,
-      "Expected source reference to be defined"
-    );
-
-    return {
-      type: StackTraceEntryType.REVERT_ERROR,
-      sourceReference,
-      message: new ReturnData(trace.returnData),
-      isInvalidOpcodeError: inst.opcode === Opcode.INVALID,
-    };
-  }
-
-  private _instructionWithinFunctionToUnmappedSolc063RevertErrorStackTraceEntry(
-    trace: DecodedEvmMessageTrace,
-    inst: Instruction
-  ): UnmappedSolc063RevertErrorStackTraceEntry {
-    const sourceReference = sourceLocationToSourceReference(
-      trace.bytecode,
-      inst.location
-    );
-
-    return {
-      type: StackTraceEntryType.UNMAPPED_SOLC_0_6_3_REVERT_ERROR,
-      sourceReference,
-    };
-  }
-
-  private _instructionWithinFunctionToPanicStackTraceEntry(
-    trace: DecodedEvmMessageTrace,
-    inst: Instruction,
-    errorCode: bigint
-  ): PanicErrorStackTraceEntry {
-    const lastSourceReference = this._getLastSourceReference(trace);
-    return {
-      type: StackTraceEntryType.PANIC_ERROR,
-      sourceReference:
-        sourceLocationToSourceReference(trace.bytecode, inst.location) ??
-        lastSourceReference,
-      errorCode,
-    };
-  }
-
-  private _instructionWithinFunctionToCustomErrorStackTraceEntry(
-    trace: DecodedEvmMessageTrace,
-    inst: Instruction,
-    message: string
-  ): CustomErrorStackTraceEntry {
-    const lastSourceReference = this._getLastSourceReference(trace);
-
-    assertHardhatInvariant(
-      lastSourceReference !== undefined,
-      "Expected last source reference to be defined"
-    );
-
-    return {
-      type: StackTraceEntryType.CUSTOM_ERROR,
-      sourceReference:
-        sourceLocationToSourceReference(trace.bytecode, inst.location) ??
-        lastSourceReference,
-      message,
-    };
-  }
-
-  private _solidity063MaybeUnmappedRevert(trace: DecodedEvmMessageTrace) {
-    if (trace.steps.length === 0) {
-      return false;
-    }
-
-    const lastStep = trace.steps[trace.steps.length - 1];
-    if (!isEvmStep(lastStep)) {
-      return false;
-    }
-
-    const lastInst = trace.bytecode.getInstruction(lastStep.pc);
-
-    return (
-      semver.satisfies(
-        trace.bytecode.compilerVersion,
-        `^${FIRST_SOLC_VERSION_WITH_UNMAPPED_REVERTS}`
-      ) && lastInst.opcode === Opcode.REVERT
-    );
-  }
-
-  // Solidity 0.6.3 unmapped reverts special handling
-  // For more info: https://github.com/ethereum/solidity/issues/9006
-  private _solidity063GetFrameForUnmappedRevertBeforeFunction(
-    trace: DecodedCallMessageTrace
-  ) {
-    let revertFrame =
-      this._solidity063GetFrameForUnmappedRevertWithinFunction(trace);
-
-    if (
-      revertFrame === undefined ||
-      revertFrame.sourceReference === undefined
-    ) {
-      if (
-        trace.bytecode.contract.receive === undefined ||
-        trace.calldata.length > 0
-      ) {
-        if (trace.bytecode.contract.fallback !== undefined) {
-          // Failed within the fallback
-          const location = trace.bytecode.contract.fallback.location;
-          revertFrame = {
-            type: StackTraceEntryType.UNMAPPED_SOLC_0_6_3_REVERT_ERROR,
-            sourceReference: {
-              contract: trace.bytecode.contract.name,
-              function: FALLBACK_FUNCTION_NAME,
-              sourceName: location.file.sourceName,
-              sourceContent: location.file.content,
-              line: location.getStartingLineNumber(),
-              range: [location.offset, location.offset + location.length],
-            },
-          };
-
-          this._solidity063CorrectLineNumber(revertFrame);
-        }
-      } else {
-        // Failed within the receive function
-        const location = trace.bytecode.contract.receive.location;
-        revertFrame = {
-          type: StackTraceEntryType.UNMAPPED_SOLC_0_6_3_REVERT_ERROR,
-          sourceReference: {
-            contract: trace.bytecode.contract.name,
-            function: RECEIVE_FUNCTION_NAME,
-            sourceName: location.file.sourceName,
-            sourceContent: location.file.content,
-            line: location.getStartingLineNumber(),
-            range: [location.offset, location.offset + location.length],
-          },
-        };
-
-        this._solidity063CorrectLineNumber(revertFrame);
-      }
-    }
-    return revertFrame;
-  }
-
-  private _getOtherErrorBeforeCalledFunctionStackTraceEntry(
-    trace: DecodedCallMessageTrace
-  ): OtherExecutionErrorStackTraceEntry {
-    return {
-      type: StackTraceEntryType.OTHER_EXECUTION_ERROR,
-      sourceReference:
-        this._getContractStartWithoutFunctionSourceReference(trace),
-    };
-  }
-
-  private _isCalledNonContractAccountError(
-    trace: DecodedEvmMessageTrace
-  ): boolean {
-    // We could change this to checking that the last valid location maps to a call, but
-    // it's way more complex as we need to get the ast node from that location.
-
-    const lastIndex = this._getLastInstructionWithValidLocationStepIndex(trace);
-    if (lastIndex === undefined || lastIndex === 0) {
-      return false;
-    }
-
-    const lastStep = trace.steps[lastIndex] as EvmStep; // We know this is an EVM step
-    const lastInst = trace.bytecode.getInstruction(lastStep.pc);
-    if (lastInst.opcode !== Opcode.ISZERO) {
-      return false;
-    }
-
-    const prevStep = trace.steps[lastIndex - 1] as EvmStep; // We know this is an EVM step
-    const prevInst = trace.bytecode.getInstruction(prevStep.pc);
-    return prevInst.opcode === Opcode.EXTCODESIZE;
-  }
-
-  private _solidity063GetFrameForUnmappedRevertWithinFunction(
-    trace: DecodedEvmMessageTrace
-  ): UnmappedSolc063RevertErrorStackTraceEntry | undefined {
-    // If we are within a function there's a last valid location. It may
-    // be the entire contract.
-    const prevInst = this._getLastInstructionWithValidLocation(trace);
-    const lastStep = trace.steps[trace.steps.length - 1] as EvmStep;
-    const nextInstPc = lastStep.pc + 1;
-    const hasNextInst = trace.bytecode.hasInstruction(nextInstPc);
-
-    if (hasNextInst) {
-      const nextInst = trace.bytecode.getInstruction(nextInstPc);
-      const prevLoc = prevInst?.location;
-      const nextLoc = nextInst.location;
-      const prevFunc = prevLoc?.getContainingFunction();
-      const nextFunc = nextLoc?.getContainingFunction();
-
-      // This is probably a require. This means that we have the exact
-      // line, but the stack trace may be degraded (e.g. missing our
-      // synthetic call frames when failing in a modifier) so we still
-      // add this frame as UNMAPPED_SOLC_0_6_3_REVERT_ERROR
-      if (
-        prevFunc !== undefined &&
-        nextLoc !== undefined &&
-        prevLoc !== undefined &&
-        prevLoc.equals(nextLoc)
-      ) {
-        return this._instructionWithinFunctionToUnmappedSolc063RevertErrorStackTraceEntry(
-          trace,
-          nextInst
-        );
-      }
-
-      let revertFrame: UnmappedSolc063RevertErrorStackTraceEntry | undefined;
-
-      // If the previous and next location don't match, we try to use the
-      // previous one if it's inside a function, otherwise we use the next one
-      if (prevFunc !== undefined && prevInst !== undefined) {
-        revertFrame =
-          this._instructionWithinFunctionToUnmappedSolc063RevertErrorStackTraceEntry(
-            trace,
-            prevInst
-          );
-      } else if (nextFunc !== undefined) {
-        revertFrame =
-          this._instructionWithinFunctionToUnmappedSolc063RevertErrorStackTraceEntry(
-            trace,
-            nextInst
-          );
-      }
-
-      if (revertFrame !== undefined) {
-        this._solidity063CorrectLineNumber(revertFrame);
-      }
-
-      return revertFrame;
-    }
-
-    if (isCreateTrace(trace) && prevInst !== undefined) {
-      // Solidity is smart enough to stop emitting extra instructions after
-      // an unconditional revert happens in a constructor. If this is the case
-      // we just return a special error.
-      const constructorRevertFrame: UnmappedSolc063RevertErrorStackTraceEntry =
-        this._instructionWithinFunctionToUnmappedSolc063RevertErrorStackTraceEntry(
-          trace,
-          prevInst
-        );
-
-      // When the latest instruction is not within a function we need
-      // some default sourceReference to show to the user
-      if (constructorRevertFrame.sourceReference === undefined) {
-        const location = trace.bytecode.contract.location;
-        const defaultSourceReference: SourceReference = {
-          function: CONSTRUCTOR_FUNCTION_NAME,
-          contract: trace.bytecode.contract.name,
-          sourceName: location.file.sourceName,
-          sourceContent: location.file.content,
-          line: location.getStartingLineNumber(),
-          range: [location.offset, location.offset + location.length],
-        };
-
-        if (trace.bytecode.contract.constructorFunction !== undefined) {
-          defaultSourceReference.line =
-            trace.bytecode.contract.constructorFunction.location.getStartingLineNumber();
-        }
-
-        constructorRevertFrame.sourceReference = defaultSourceReference;
-      } else {
-        this._solidity063CorrectLineNumber(constructorRevertFrame);
-      }
-
-      return constructorRevertFrame;
-    }
-
-    if (prevInst !== undefined) {
-      // We may as well just be in a function or modifier and just happen
-      // to be at the last instruction of the runtime bytecode.
-      // In this case we just return whatever the last mapped intruction
-      // points to.
-      const latestInstructionRevertFrame: UnmappedSolc063RevertErrorStackTraceEntry =
-        this._instructionWithinFunctionToUnmappedSolc063RevertErrorStackTraceEntry(
-          trace,
-          prevInst
-        );
-
-      if (latestInstructionRevertFrame.sourceReference !== undefined) {
-        this._solidity063CorrectLineNumber(latestInstructionRevertFrame);
-      }
-      return latestInstructionRevertFrame;
-    }
-  }
-
-  private _isContractTooLargeError(trace: DecodedCreateMessageTrace) {
-    return trace.exit.kind === ExitCode.CODESIZE_EXCEEDS_MAXIMUM;
-  }
-
-  private _solidity063CorrectLineNumber(
-    revertFrame: UnmappedSolc063RevertErrorStackTraceEntry
-  ) {
-    if (revertFrame.sourceReference === undefined) {
-      return;
-    }
-
-    const lines = revertFrame.sourceReference.sourceContent.split("\n");
-
-    const currentLine = lines[revertFrame.sourceReference.line - 1];
-
-    if (currentLine.includes("require") || currentLine.includes("revert")) {
-      return;
-    }
-
-    const nextLines = lines.slice(revertFrame.sourceReference.line);
-    const firstNonEmptyLine = nextLines.findIndex((l) => l.trim() !== "");
-
-    if (firstNonEmptyLine === -1) {
-      return;
-    }
-
-    const nextLine = nextLines[firstNonEmptyLine];
-
-    if (nextLine.includes("require") || nextLine.includes("revert")) {
-      revertFrame.sourceReference.line += 1 + firstNonEmptyLine;
-    }
-  }
-
-  private _getLastInstructionWithValidLocationStepIndex(
-    trace: DecodedEvmMessageTrace
-  ): number | undefined {
-    for (let i = trace.steps.length - 1; i >= 0; i--) {
-      const step = trace.steps[i];
-
-      if (!isEvmStep(step)) {
-        return undefined;
-      }
-
-      const inst = trace.bytecode.getInstruction(step.pc);
-
-      if (inst.location !== undefined) {
-        return i;
-      }
-    }
-
-    return undefined;
-  }
-
-  private _getLastInstructionWithValidLocation(
-    trace: DecodedEvmMessageTrace
-  ): Instruction | undefined {
-    const lastLocationIndex =
-      this._getLastInstructionWithValidLocationStepIndex(trace);
-
-    if (lastLocationIndex === undefined) {
-      return undefined;
-    }
-
-    const lastLocationStep = trace.steps[lastLocationIndex];
-    if (isEvmStep(lastLocationStep)) {
-      const lastInstructionWithLocation = trace.bytecode.getInstruction(
-        lastLocationStep.pc
-      );
-      return lastInstructionWithLocation;
-    }
-
-    return undefined;
-  }
-
-  private _callInstructionToCallFailedToExecuteStackTraceEntry(
-    bytecode: Bytecode,
-    callInst: Instruction
-  ): CallFailedErrorStackTraceEntry {
-    const sourceReference = sourceLocationToSourceReference(
-      bytecode,
-      callInst.location
-    );
-    assertHardhatInvariant(
-      sourceReference !== undefined,
-      "Expected source reference to be defined"
-    );
-
-    // Calls only happen within functions
-    return {
-      type: StackTraceEntryType.CALL_FAILED_ERROR,
-      sourceReference,
-    };
-  }
-
-  private _getEntryBeforeFailureInModifier(
-    trace: DecodedEvmMessageTrace,
-    functionJumpdests: Instruction[]
-  ): CallstackEntryStackTraceEntry | InternalFunctionCallStackEntry {
-    // If there's a jumpdest, this modifier belongs to the last function that it represents
-    if (functionJumpdests.length > 0) {
-      return instructionToCallstackStackTraceEntry(
-        trace.bytecode,
-        functionJumpdests[functionJumpdests.length - 1]
-      );
-    }
-
-    // This function is only called after we jumped into the initial function in call traces, so
-    // there should always be at least a function jumpdest.
-    if (!isDecodedCreateTrace(trace)) {
-      throw new Error(
-        "This shouldn't happen: a call trace has no functionJumpdest but has already jumped into a function"
-      );
-    }
-
-    // If there's no jump dest, we point to the constructor.
-    return {
-      type: StackTraceEntryType.CALLSTACK_ENTRY,
-      sourceReference: this._getConstructorStartSourceReference(trace),
-      functionType: ContractFunctionType.CONSTRUCTOR,
-    };
-  }
-
-  private _failsRightAfterCall(
-    trace: DecodedEvmMessageTrace,
-    callSubtraceStepIndex: number
-  ): boolean {
-    const lastStep = trace.steps[trace.steps.length - 1];
-    if (!isEvmStep(lastStep)) {
-      return false;
-    }
-
-    const lastInst = trace.bytecode.getInstruction(lastStep.pc);
-    if (lastInst.opcode !== Opcode.REVERT) {
-      return false;
-    }
-
-    const callOpcodeStep = trace.steps[callSubtraceStepIndex - 1] as EvmStep;
-    const callInst = trace.bytecode.getInstruction(callOpcodeStep.pc);
-
-    // Calls are always made from within functions
-    assertHardhatInvariant(
-      callInst.location !== undefined,
-      "Expected call instruction location to be defined"
-    );
-
-    return this._isLastLocation(
-      trace,
-      callSubtraceStepIndex + 1,
-      callInst.location
-    );
-  }
-
-  private _isCallFailedError(
-    trace: DecodedEvmMessageTrace,
-    instIndex: number,
-    callInstruction: Instruction
-  ): boolean {
-    const callLocation = callInstruction.location;
-
-    // Calls are always made from within functions
-    assertHardhatInvariant(
-      callLocation !== undefined,
-      "Expected call location to be defined"
-    );
-
-    return this._isLastLocation(trace, instIndex, callLocation);
-  }
-
-  private _isLastLocation(
-    trace: DecodedEvmMessageTrace,
-    fromStep: number,
-    location: SourceLocation
-  ): boolean {
-    for (let i = fromStep; i < trace.steps.length; i++) {
-      const step = trace.steps[i];
-
-      if (!isEvmStep(step)) {
-        return false;
-      }
-
-      const stepInst = trace.bytecode.getInstruction(step.pc);
-
-      if (stepInst.location === undefined) {
-        continue;
-      }
-
-      if (!location.equals(stepInst.location)) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  private _isSubtraceErrorPropagated(
-    trace: DecodedEvmMessageTrace,
-    callSubtraceStepIndex: number
-  ): boolean {
-    const call = trace.steps[callSubtraceStepIndex] as MessageTrace;
-
-    if (!equalsBytes(trace.returnData, call.returnData)) {
-      return false;
-    }
-
-    if (
-      trace.exit.kind === ExitCode.OUT_OF_GAS &&
-      call.exit.kind === ExitCode.OUT_OF_GAS
-    ) {
-      return true;
-    }
-
-    // If the return data is not empty, and it's still the same, we assume it
-    // is being propagated
-    if (trace.returnData.length > 0) {
-      return true;
-    }
-
-    return this._failsRightAfterCall(trace, callSubtraceStepIndex);
-  }
-
-  private _isProxyErrorPropagated(
-    trace: DecodedEvmMessageTrace,
-    callSubtraceStepIndex: number
-  ): boolean {
-    if (!isDecodedCallTrace(trace)) {
-      return false;
-    }
-
-    const callStep = trace.steps[callSubtraceStepIndex - 1];
-    if (!isEvmStep(callStep)) {
-      return false;
-    }
-
-    const callInst = trace.bytecode.getInstruction(callStep.pc);
-    if (callInst.opcode !== Opcode.DELEGATECALL) {
-      return false;
-    }
-
-    const subtrace = trace.steps[callSubtraceStepIndex];
-    if (isEvmStep(subtrace)) {
-      return false;
-    }
-
-    if (isPrecompileTrace(subtrace)) {
-      return false;
-    }
-
-    // If we can't recognize the implementation we'd better don't consider it as such
-    if (subtrace.bytecode === undefined) {
-      return false;
-    }
-
-    if (subtrace.bytecode.contract.type === ContractType.LIBRARY) {
-      return false;
-    }
-
-    if (!equalsBytes(trace.returnData, subtrace.returnData)) {
-      return false;
-    }
-
-    for (let i = callSubtraceStepIndex + 1; i < trace.steps.length; i++) {
-      const step = trace.steps[i];
-      if (!isEvmStep(step)) {
-        return false;
-      }
-
-      const inst = trace.bytecode.getInstruction(step.pc);
-
-      // All the remaining locations should be valid, as they are part of the inline asm
-      if (inst.location === undefined) {
-        return false;
-      }
-
-      if (
-        inst.jumpType === JumpType.INTO_FUNCTION ||
-        inst.jumpType === JumpType.OUTOF_FUNCTION
-      ) {
-        return false;
-      }
-    }
-
-    const lastStep = trace.steps[trace.steps.length - 1] as EvmStep;
-    const lastInst = trace.bytecode.getInstruction(lastStep.pc);
-
-    return lastInst.opcode === Opcode.REVERT;
-  }
-
-  private _isContractCallRunOutOfGasError(
-    trace: DecodedEvmMessageTrace,
-    callStepIndex: number
-  ): boolean {
-    if (trace.returnData.length > 0) {
-      return false;
-    }
-
-    if (trace.exit.kind !== ExitCode.REVERT) {
-      return false;
-    }
-
-    const call = trace.steps[callStepIndex] as MessageTrace;
-    if (call.exit.kind !== ExitCode.OUT_OF_GAS) {
-      return false;
-    }
-
-    return this._failsRightAfterCall(trace, callStepIndex);
-  }
-
-  private _isPanicReturnData(returnData: Uint8Array): boolean {
-    return new ReturnData(returnData).isPanicReturnData();
-  }
-}
-
-export function instructionToCallstackStackTraceEntry(
-  bytecode: Bytecode,
-  inst: Instruction
-): CallstackEntryStackTraceEntry | InternalFunctionCallStackEntry {
-  // This means that a jump is made from within an internal solc function.
-  // These are normally made from yul code, so they don't map to any Solidity
-  // function
-  if (inst.location === undefined) {
-    const location = bytecode.contract.location;
-    return {
-      type: StackTraceEntryType.INTERNAL_FUNCTION_CALLSTACK_ENTRY,
-      pc: inst.pc,
-      sourceReference: {
-        sourceName: bytecode.contract.location.file.sourceName,
-        sourceContent: bytecode.contract.location.file.content,
-        contract: bytecode.contract.name,
-        function: undefined,
-        line: bytecode.contract.location.getStartingLineNumber(),
-        range: [location.offset, location.offset + location.length],
-      },
-    };
-  }
-
-  const func = inst.location?.getContainingFunction();
-
-  if (func !== undefined) {
-    const sourceReference = sourceLocationToSourceReference(
-      bytecode,
-      inst.location
-    );
-    assertHardhatInvariant(
-      sourceReference !== undefined,
-      "Expected source reference to be defined"
-    );
-
-    return {
-      type: StackTraceEntryType.CALLSTACK_ENTRY,
-      sourceReference,
-      functionType: func.type,
-    };
-  }
-
-  assertHardhatInvariant(
-    inst.location !== undefined,
-    "Expected instruction location to be defined"
-  );
-
-  return {
-    type: StackTraceEntryType.CALLSTACK_ENTRY,
-    sourceReference: {
-      function: undefined,
-      contract: bytecode.contract.name,
-      sourceName: inst.location.file.sourceName,
-      sourceContent: inst.location.file.content,
-      line: inst.location.getStartingLineNumber(),
-      range: [
-        inst.location.offset,
-        inst.location.offset + inst.location.length,
-      ],
-    },
-    functionType: ContractFunctionType.FUNCTION,
-  };
-}
-
-function sourceLocationToSourceReference(
-  bytecode: Bytecode,
-  location?: SourceLocation
-): SourceReference | undefined {
-  if (location === undefined) {
-    return undefined;
-  }
-
-  const func = location.getContainingFunction();
-
-  if (func === undefined) {
-    return undefined;
-  }
-
-  let funcName = func.name;
-
-  if (func.type === ContractFunctionType.CONSTRUCTOR) {
-    funcName = CONSTRUCTOR_FUNCTION_NAME;
-  } else if (func.type === ContractFunctionType.FALLBACK) {
-    funcName = FALLBACK_FUNCTION_NAME;
-  } else if (func.type === ContractFunctionType.RECEIVE) {
-    funcName = RECEIVE_FUNCTION_NAME;
-  }
-
-  return {
-    function: funcName,
-    contract:
-      func.type === ContractFunctionType.FREE_FUNCTION
-        ? undefined
-        : bytecode.contract.name,
-    sourceName: func.location.file.sourceName,
-    sourceContent: func.location.file.content,
-    line: location.getStartingLineNumber(),
-    range: [location.offset, location.offset + location.length],
-  };
-}