hardhat 2.22.10 → 2.22.12

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,
+};

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

@@ -1,208 +1,7 @@
-import type {
-  CreateOutput,
-  ExecutionResult,
-  TracingMessage,
-  TracingStep,
-} from "@nomicfoundation/edr";
+import { requireNapiRsModule } from "../../../common/napi-rs";
 
-import { bytesToBigInt } from "@nomicfoundation/ethereumjs-util";
+const { VmTracer } = requireNapiRsModule(
+  "@nomicfoundation/edr"
+) as typeof import("@nomicfoundation/edr");
 
-import { assertHardhatInvariant } from "../../core/errors";
-import { Exit, ExitCode } from "../provider/vm/exit";
-
-import {
-  CallMessageTrace,
-  CreateMessageTrace,
-  isCreateTrace,
-  isHaltResult,
-  isPrecompileTrace,
-  isSuccessResult,
-  MessageTrace,
-  PrecompileMessageTrace,
-} from "./message-trace";
-
-/* eslint-disable @nomicfoundation/hardhat-internal-rules/only-hardhat-error */
-
-const DUMMY_RETURN_DATA = Buffer.from([]);
-const DUMMY_GAS_USED = 0n;
-
-/**
- * Consumes the incoming VM trace events, until an error occurs, to keep track
- * of the last top level message trace/error.
- */
-export class VMTracer {
-  public tracingSteps: TracingStep[] = [];
-
-  private _messageTraces: MessageTrace[] = [];
-  private _lastError: Error | undefined;
-  private _maxPrecompileNumber;
-
-  constructor() {
-    // TODO: temporarily hardcoded to remove the need of using ethereumjs' common and evm here
-    this._maxPrecompileNumber = 10;
-  }
-
-  public getLastTopLevelMessageTrace(): MessageTrace | undefined {
-    return this._messageTraces[0];
-  }
-
-  public getLastError(): Error | undefined {
-    return this._lastError;
-  }
-
-  private _shouldKeepTracing() {
-    return this._lastError === undefined;
-  }
-
-  public addBeforeMessage(message: TracingMessage) {
-    if (!this._shouldKeepTracing()) {
-      return;
-    }
-
-    try {
-      let trace: MessageTrace;
-
-      if (message.depth === 0) {
-        this._messageTraces = [];
-        this.tracingSteps = [];
-      }
-
-      if (message.to === undefined) {
-        const createTrace: CreateMessageTrace = {
-          code: message.data,
-          steps: [],
-          value: message.value,
-          exit: new Exit(ExitCode.SUCCESS),
-          returnData: DUMMY_RETURN_DATA,
-          numberOfSubtraces: 0,
-          depth: message.depth,
-          deployedContract: undefined,
-          gasUsed: DUMMY_GAS_USED,
-        };
-
-        trace = createTrace;
-      } else {
-        const toAsBigInt = bytesToBigInt(message.to);
-
-        if (toAsBigInt > 0 && toAsBigInt <= this._maxPrecompileNumber) {
-          const precompileTrace: PrecompileMessageTrace = {
-            precompile: Number(toAsBigInt),
-            calldata: message.data,
-            value: message.value,
-            exit: new Exit(ExitCode.SUCCESS),
-            returnData: DUMMY_RETURN_DATA,
-            depth: message.depth,
-            gasUsed: DUMMY_GAS_USED,
-          };
-
-          trace = precompileTrace;
-        } else {
-          const codeAddress = message.codeAddress;
-
-          // if we enter here, then `to` is not undefined, therefore
-          // `codeAddress` and `code` should be defined
-          assertHardhatInvariant(
-            codeAddress !== undefined,
-            "codeAddress should be defined"
-          );
-          assertHardhatInvariant(
-            message.code !== undefined,
-            "code should be defined"
-          );
-
-          const callTrace: CallMessageTrace = {
-            code: message.code,
-            calldata: message.data,
-            steps: [],
-            value: message.value,
-            exit: new Exit(ExitCode.SUCCESS),
-            returnData: DUMMY_RETURN_DATA,
-            address: message.to,
-            numberOfSubtraces: 0,
-            depth: message.depth,
-            gasUsed: DUMMY_GAS_USED,
-            codeAddress,
-          };
-
-          trace = callTrace;
-        }
-      }
-
-      if (this._messageTraces.length > 0) {
-        const parentTrace = this._messageTraces[this._messageTraces.length - 1];
-
-        if (isPrecompileTrace(parentTrace)) {
-          throw new Error(
-            "This should not happen: message execution started while a precompile was executing"
-          );
-        }
-
-        parentTrace.steps.push(trace);
-        parentTrace.numberOfSubtraces += 1;
-      }
-
-      this._messageTraces.push(trace);
-    } catch (error) {
-      this._lastError = error as Error;
-    }
-  }
-
-  public addStep(step: TracingStep) {
-    if (!this._shouldKeepTracing()) {
-      return;
-    }
-
-    this.tracingSteps.push(step);
-
-    try {
-      const trace = this._messageTraces[this._messageTraces.length - 1];
-
-      if (isPrecompileTrace(trace)) {
-        throw new Error(
-          "This should not happen: step event fired while a precompile was executing"
-        );
-      }
-
-      trace.steps.push({ pc: Number(step.pc) });
-    } catch (error) {
-      this._lastError = error as Error;
-    }
-  }
-
-  public addAfterMessage(result: ExecutionResult) {
-    if (!this._shouldKeepTracing()) {
-      return;
-    }
-
-    try {
-      const trace = this._messageTraces[this._messageTraces.length - 1];
-      trace.gasUsed = result.result.gasUsed;
-
-      const executionResult = result.result;
-      if (isSuccessResult(executionResult)) {
-        trace.exit = Exit.fromEdrSuccessReason(executionResult.reason);
-        trace.returnData = executionResult.output.returnValue;
-
-        if (isCreateTrace(trace)) {
-          trace.deployedContract = (
-            executionResult.output as CreateOutput
-          ).address;
-        }
-      } else if (isHaltResult(executionResult)) {
-        trace.exit = Exit.fromEdrExceptionalHalt(executionResult.reason);
-
-        trace.returnData = Buffer.from([]);
-      } else {
-        trace.exit = new Exit(ExitCode.REVERT);
-
-        trace.returnData = executionResult.output;
-      }
-
-      if (this._messageTraces.length > 1) {
-        this._messageTraces.pop();
-      }
-    } catch (error) {
-      this._lastError = error as Error;
-    }
-  }
-}
+export { VmTracer as VMTracer };

package/src/internal/solidity/compiler/solc-info.ts

@@ -61,6 +61,9 @@ const defaultEvmTargets: { [key: string]: string } = {
   "0.8.22": "shanghai",
   "0.8.23": "shanghai",
   "0.8.24": "shanghai",
+  "0.8.25": "cancun",
+  "0.8.26": "cancun",
+  "0.8.27": "cancun",
 };
 
 export function getEvmVersionFromSolcVersion(

package/internal/hardhat-network/stack-traces/contracts-identifier.d.ts

@@ -1,15 +0,0 @@
-import { Bytecode } from "./model";
-export declare class ContractsIdentifier {
-    private readonly _enableCache;
-    private _trie;
-    private _cache;
-    constructor(_enableCache?: boolean);
-    addBytecode(bytecode: Bytecode): void;
-    getBytecodeForCall(code: Uint8Array, isCreate: boolean): Bytecode | undefined;
-    private _searchBytecode;
-    /**
-     * Returns true if the lastByte is placed right when the metadata starts or after it.
-     */
-    private _isMatchingMetadata;
-}
-//# sourceMappingURL=contracts-identifier.d.ts.map

package/internal/hardhat-network/stack-traces/contracts-identifier.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"contracts-identifier.d.ts","sourceRoot":"","sources":["../../../src/internal/hardhat-network/stack-traces/contracts-identifier.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAmFnC,qBAAa,mBAAmB;IAIlB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAHzC,OAAO,CAAC,KAAK,CAAwB;IACrC,OAAO,CAAC,MAAM,CAAoC;gBAErB,YAAY,UAAO;IAEzC,WAAW,CAAC,QAAQ,EAAE,QAAQ;IAK9B,kBAAkB,CACvB,IAAI,EAAE,UAAU,EAChB,QAAQ,EAAE,OAAO,GAChB,QAAQ,GAAG,SAAS;IAwBvB,OAAO,CAAC,eAAe;IAyFvB;;OAEG;IACH,OAAO,CAAC,mBAAmB;CAc5B"}