hardhat 2.22.10 → 2.22.12

package/src/internal/hardhat-network/stack-traces/mapped-inlined-internal-functions-heuristics.ts

@@ -1,163 +0,0 @@
-/**
- * This file includes Solidity tracing heuristics for solc starting with version
- * 0.6.9.
- *
- * This solc version introduced a significant change to how sourcemaps are
- * handled for inline yul/internal functions. These were mapped to the
- * unmapped/-1 file before, which lead to many unmapped reverts. Now, they are
- * mapped to the part of the Solidity source that lead to their inlining.
- *
- * This change is a very positive change, as errors would point to the correct
- * line by default. The only problem is that we used to rely very heavily on
- * unmapped reverts to decide when our error detection heuristics were to be
- * run. In fact, this heuristics were first introduced because of unmapped
- * reverts.
- *
- * Instead of synthetically completing stack traces when unmapped reverts occur,
- * we now start from complete stack traces and adjust them if we can provide
- * more meaningful errors.
- */
-
-import semver from "semver";
-
-import {
-  DecodedEvmMessageTrace,
-  isDecodedCallTrace,
-  isDecodedCreateTrace,
-  isEvmStep,
-} from "./message-trace";
-import { Opcode } from "./opcodes";
-import {
-  SolidityStackTrace,
-  StackTraceEntryType,
-} from "./solidity-stack-trace";
-
-const FIRST_SOLC_VERSION_WITH_MAPPED_SMALL_INTERNAL_FUNCTIONS = "0.6.9";
-
-export function stackTraceMayRequireAdjustments(
-  stackTrace: SolidityStackTrace,
-  decodedTrace: DecodedEvmMessageTrace
-): boolean {
-  if (stackTrace.length === 0) {
-    return false;
-  }
-
-  const lastFrame = stackTrace[stackTrace.length - 1];
-
-  return (
-    lastFrame.type === StackTraceEntryType.REVERT_ERROR &&
-    !lastFrame.isInvalidOpcodeError &&
-    lastFrame.message.isEmpty() &&
-    semver.gte(
-      decodedTrace.bytecode.compilerVersion,
-      FIRST_SOLC_VERSION_WITH_MAPPED_SMALL_INTERNAL_FUNCTIONS
-    )
-  );
-}
-
-export function adjustStackTrace(
-  stackTrace: SolidityStackTrace,
-  decodedTrace: DecodedEvmMessageTrace
-): SolidityStackTrace {
-  const start = stackTrace.slice(0, -1);
-  const [revert] = stackTrace.slice(-1);
-
-  if (isNonContractAccountCalledError(decodedTrace)) {
-    return [
-      ...start,
-      {
-        type: StackTraceEntryType.NONCONTRACT_ACCOUNT_CALLED_ERROR,
-        sourceReference: revert.sourceReference!,
-      },
-    ];
-  }
-
-  if (isConstructorInvalidParamsError(decodedTrace)) {
-    return [
-      ...start,
-      {
-        type: StackTraceEntryType.INVALID_PARAMS_ERROR,
-        sourceReference: revert.sourceReference!,
-      },
-    ];
-  }
-
-  if (isCallInvalidParamsError(decodedTrace)) {
-    return [
-      ...start,
-      {
-        type: StackTraceEntryType.INVALID_PARAMS_ERROR,
-        sourceReference: revert.sourceReference!,
-      },
-    ];
-  }
-
-  return stackTrace;
-}
-
-function isNonContractAccountCalledError(
-  decodedTrace: DecodedEvmMessageTrace
-): boolean {
-  return matchOpcodes(decodedTrace, -9, [
-    Opcode.EXTCODESIZE,
-    Opcode.ISZERO,
-    Opcode.DUP1,
-    Opcode.ISZERO,
-  ]);
-}
-
-function isConstructorInvalidParamsError(decodedTrace: DecodedEvmMessageTrace) {
-  if (!isDecodedCreateTrace(decodedTrace)) {
-    return false;
-  }
-
-  return (
-    matchOpcodes(decodedTrace, -20, [Opcode.CODESIZE]) &&
-    matchOpcodes(decodedTrace, -15, [Opcode.CODECOPY]) &&
-    matchOpcodes(decodedTrace, -7, [Opcode.LT, Opcode.ISZERO])
-  );
-}
-
-function isCallInvalidParamsError(decodedTrace: DecodedEvmMessageTrace) {
-  if (!isDecodedCallTrace(decodedTrace)) {
-    return false;
-  }
-
-  return (
-    matchOpcodes(decodedTrace, -11, [Opcode.CALLDATASIZE]) &&
-    matchOpcodes(decodedTrace, -7, [Opcode.LT, Opcode.ISZERO])
-  );
-}
-
-function matchOpcode(
-  decodedTrace: DecodedEvmMessageTrace,
-  stepIndex: number,
-  opcode: Opcode
-): boolean {
-  const [step] = decodedTrace.steps.slice(stepIndex, stepIndex + 1);
-
-  if (step === undefined || !isEvmStep(step)) {
-    return false;
-  }
-
-  const instruction = decodedTrace.bytecode.getInstruction(step.pc);
-
-  return instruction.opcode === opcode;
-}
-
-function matchOpcodes(
-  decodedTrace: DecodedEvmMessageTrace,
-  firstStepIndex: number,
-  opcodes: Opcode[]
-): boolean {
-  let index = firstStepIndex;
-  for (const opcode of opcodes) {
-    if (!matchOpcode(decodedTrace, index, opcode)) {
-      return false;
-    }
-
-    index += 1;
-  }
-
-  return true;
-}

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

@@ -1,409 +0,0 @@
-import { bytesToHex as bufferToHex } from "@nomicfoundation/ethereumjs-util";
-
-import { AbiHelpers } from "../../util/abi-helpers";
-
-import { Opcode } from "./opcodes";
-
-/* eslint-disable @nomicfoundation/hardhat-internal-rules/only-hardhat-error */
-
-export enum JumpType {
-  NOT_JUMP,
-  INTO_FUNCTION,
-  OUTOF_FUNCTION,
-  INTERNAL_JUMP,
-}
-
-export enum ContractType {
-  CONTRACT,
-  LIBRARY,
-}
-
-export enum ContractFunctionType {
-  CONSTRUCTOR,
-  FUNCTION,
-  FALLBACK,
-  RECEIVE,
-  GETTER,
-  MODIFIER,
-  FREE_FUNCTION,
-}
-
-export enum ContractFunctionVisibility {
-  PRIVATE,
-  INTERNAL,
-  PUBLIC,
-  EXTERNAL,
-}
-
-export class SourceFile {
-  public readonly contracts: Contract[] = [];
-  public readonly functions: ContractFunction[] = [];
-
-  constructor(
-    public readonly sourceName: string,
-    public readonly content: string
-  ) {}
-
-  public addContract(contract: Contract) {
-    if (contract.location.file !== this) {
-      throw new Error("Trying to add a contract from another file");
-    }
-
-    this.contracts.push(contract);
-  }
-
-  public addFunction(func: ContractFunction) {
-    if (func.location.file !== this) {
-      throw new Error("Trying to add a function from another file");
-    }
-
-    this.functions.push(func);
-  }
-
-  public getContainingFunction(
-    location: SourceLocation
-  ): ContractFunction | undefined {
-    // TODO: Optimize this with a binary search or an internal tree
-
-    for (const func of this.functions) {
-      if (func.location.contains(location)) {
-        return func;
-      }
-    }
-
-    return undefined;
-  }
-}
-
-export class SourceLocation {
-  private _line: number | undefined;
-
-  constructor(
-    public readonly file: SourceFile,
-    public readonly offset: number,
-    public readonly length: number
-  ) {}
-
-  public getStartingLineNumber(): number {
-    if (this._line === undefined) {
-      this._line = 1;
-
-      for (const c of this.file.content.slice(0, this.offset)) {
-        if (c === "\n") {
-          this._line += 1;
-        }
-      }
-    }
-
-    return this._line;
-  }
-
-  public getContainingFunction(): ContractFunction | undefined {
-    return this.file.getContainingFunction(this);
-  }
-
-  public contains(other: SourceLocation) {
-    if (this.file !== other.file) {
-      return false;
-    }
-
-    if (other.offset < this.offset) {
-      return false;
-    }
-
-    return other.offset + other.length <= this.offset + this.length;
-  }
-
-  public equals(other: SourceLocation) {
-    return (
-      this.file === other.file &&
-      this.offset === other.offset &&
-      this.length === other.length
-    );
-  }
-}
-
-export class Contract {
-  public readonly localFunctions: ContractFunction[] = [];
-  public readonly customErrors: CustomError[] = [];
-
-  private _constructor: ContractFunction | undefined;
-  private _fallback: ContractFunction | undefined;
-  private _receive: ContractFunction | undefined;
-  private readonly _selectorHexToFunction: Map<string, ContractFunction> =
-    new Map();
-
-  constructor(
-    public readonly name: string,
-    public readonly type: ContractType,
-    public readonly location: SourceLocation
-  ) {}
-
-  public get constructorFunction(): ContractFunction | undefined {
-    return this._constructor;
-  }
-
-  public get fallback(): ContractFunction | undefined {
-    return this._fallback;
-  }
-
-  public get receive(): ContractFunction | undefined {
-    return this._receive;
-  }
-
-  public addLocalFunction(func: ContractFunction) {
-    if (func.contract !== this) {
-      throw new Error("Function isn't local");
-    }
-
-    if (
-      func.visibility === ContractFunctionVisibility.PUBLIC ||
-      func.visibility === ContractFunctionVisibility.EXTERNAL
-    ) {
-      if (
-        func.type === ContractFunctionType.FUNCTION ||
-        func.type === ContractFunctionType.GETTER
-      ) {
-        this._selectorHexToFunction.set(bufferToHex(func.selector!), func);
-      } else if (func.type === ContractFunctionType.CONSTRUCTOR) {
-        this._constructor = func;
-      } else if (func.type === ContractFunctionType.FALLBACK) {
-        this._fallback = func;
-      } else if (func.type === ContractFunctionType.RECEIVE) {
-        this._receive = func;
-      }
-    }
-
-    this.localFunctions.push(func);
-  }
-
-  public addCustomError(customError: CustomError) {
-    this.customErrors.push(customError);
-  }
-
-  public addNextLinearizedBaseContract(baseContract: Contract) {
-    if (this._fallback === undefined && baseContract._fallback !== undefined) {
-      this._fallback = baseContract._fallback;
-    }
-    if (this._receive === undefined && baseContract._receive !== undefined) {
-      this._receive = baseContract._receive;
-    }
-
-    for (const baseContractFunction of baseContract.localFunctions) {
-      if (
-        baseContractFunction.type !== ContractFunctionType.GETTER &&
-        baseContractFunction.type !== ContractFunctionType.FUNCTION
-      ) {
-        continue;
-      }
-
-      if (
-        baseContractFunction.visibility !== ContractFunctionVisibility.PUBLIC &&
-        baseContractFunction.visibility !== ContractFunctionVisibility.EXTERNAL
-      ) {
-        continue;
-      }
-
-      const selectorHex = bufferToHex(baseContractFunction.selector!);
-      if (!this._selectorHexToFunction.has(selectorHex)) {
-        this._selectorHexToFunction.set(selectorHex, baseContractFunction);
-      }
-    }
-  }
-
-  public getFunctionFromSelector(
-    selector: Uint8Array
-  ): ContractFunction | undefined {
-    return this._selectorHexToFunction.get(bufferToHex(selector));
-  }
-
-  /**
-   * We compute selectors manually, which is particularly hard. We do this
-   * because we need to map selectors to AST nodes, and it seems easier to start
-   * from the AST node. This is surprisingly super hard: things like inherited
-   * enums, structs and ABIv2 complicate it.
-   *
-   * As we know that that can fail, we run a heuristic that tries to correct
-   * incorrect selectors. What it does is checking the `evm.methodIdentifiers`
-   * compiler output, and detect missing selectors. Then we take those and
-   * find contract functions with the same name. If there are multiple of those
-   * we can't do anything. If there is a single one, it must have an incorrect
-   * selector, so we update it with the `evm.methodIdentifiers`'s value.
-   */
-  public correctSelector(functionName: string, selector: Buffer): boolean {
-    const functions = Array.from(this._selectorHexToFunction.values()).filter(
-      (cf) => cf.name === functionName
-    );
-
-    if (functions.length !== 1) {
-      return false;
-    }
-
-    const functionToCorrect = functions[0];
-
-    if (functionToCorrect.selector !== undefined) {
-      this._selectorHexToFunction.delete(
-        bufferToHex(functionToCorrect.selector)
-      );
-    }
-
-    functionToCorrect.selector = selector;
-    this._selectorHexToFunction.set(bufferToHex(selector), functionToCorrect);
-    return true;
-  }
-}
-
-export class ContractFunction {
-  constructor(
-    public readonly name: string,
-    public readonly type: ContractFunctionType,
-    public readonly location: SourceLocation,
-    public readonly contract?: Contract,
-    public readonly visibility?: ContractFunctionVisibility,
-    public readonly isPayable?: boolean,
-    public selector?: Uint8Array,
-    public readonly paramTypes?: any[]
-  ) {
-    if (contract !== undefined && !contract.location.contains(location)) {
-      throw new Error("Incompatible contract and function location");
-    }
-  }
-
-  public isValidCalldata(calldata: Uint8Array): boolean {
-    if (this.paramTypes === undefined) {
-      // if we don't know the param types, we just assume that the call is valid
-      return true;
-    }
-
-    return AbiHelpers.isValidCalldata(this.paramTypes, calldata);
-  }
-}
-
-export class CustomError {
-  /**
-   * Return a CustomError from the given ABI information: the name
-   * of the error and its inputs. Returns undefined if it can't build
-   * the CustomError.
-   */
-  public static fromABI(name: string, inputs: any[]): CustomError | undefined {
-    const selector = AbiHelpers.computeSelector(name, inputs);
-
-    if (selector !== undefined) {
-      return new CustomError(selector, name, inputs);
-    }
-  }
-
-  private constructor(
-    public readonly selector: Uint8Array,
-    public readonly name: string,
-    public readonly paramTypes: any[]
-  ) {}
-}
-
-export class Instruction {
-  constructor(
-    public readonly pc: number,
-    public readonly opcode: Opcode,
-    public readonly jumpType: JumpType,
-    public readonly pushData?: Buffer,
-    public readonly location?: SourceLocation
-  ) {}
-
-  /**
-   * Checks equality with another Instruction.
-   */
-  public equals(other: Instruction): boolean {
-    if (this.pc !== other.pc) {
-      return false;
-    }
-
-    if (this.opcode !== other.opcode) {
-      return false;
-    }
-
-    if (this.jumpType !== other.jumpType) {
-      return false;
-    }
-
-    if (this.pushData !== undefined) {
-      if (other.pushData === undefined) {
-        return false;
-      }
-
-      if (!this.pushData.equals(other.pushData)) {
-        return false;
-      }
-    } else if (other.pushData !== undefined) {
-      return false;
-    }
-
-    if (this.location !== undefined) {
-      if (other.location === undefined) {
-        return false;
-      }
-
-      if (!this.location.equals(other.location)) {
-        return false;
-      }
-    } else if (other.location !== undefined) {
-      return false;
-    }
-
-    return true;
-  }
-}
-
-interface ImmutableReference {
-  start: number;
-  length: number;
-}
-
-export class Bytecode {
-  private readonly _pcToInstruction: Map<number, Instruction> = new Map();
-
-  constructor(
-    public readonly contract: Contract,
-    public readonly isDeployment: boolean,
-    public readonly normalizedCode: Buffer,
-    public readonly instructions: Instruction[],
-    public readonly libraryAddressPositions: number[],
-    public readonly immutableReferences: ImmutableReference[],
-    public readonly compilerVersion: string
-  ) {
-    for (const inst of instructions) {
-      this._pcToInstruction.set(inst.pc, inst);
-    }
-  }
-
-  public getInstruction(pc: number): Instruction {
-    const inst = this._pcToInstruction.get(pc);
-
-    if (inst === undefined) {
-      throw new Error(`There's no instruction at pc ${pc}`);
-    }
-
-    return inst;
-  }
-
-  public hasInstruction(pc: number): boolean {
-    return this._pcToInstruction.has(pc);
-  }
-
-  /**
-   * Checks equality with another Bytecode.
-   */
-  public equals(other: Bytecode): boolean {
-    if (this._pcToInstruction.size !== other._pcToInstruction.size) {
-      return false;
-    }
-
-    for (const [key, val] of this._pcToInstruction) {
-      const otherVal = other._pcToInstruction.get(key);
-      if (otherVal === undefined || !val.equals(otherVal)) {
-        return false;
-      }
-    }
-
-    return true;
-  }
-}