hardhat 2.22.11 → 2.22.12

package/src/internal/hardhat-network/provider/provider.ts

@@ -11,6 +11,8 @@ import type {
 import type {
   EdrContext,
   Provider as EdrProviderT,
+  VmTraceDecoder as VmTraceDecoderT,
+  VMTracer as VMTracerT,
   RawTrace,
   Response,
   SubscriptionEvent,
@@ -42,7 +44,6 @@ import { isErrorResponse } from "../../core/providers/http";
 import { getHardforkName } from "../../util/hardforks";
 import { createModelsAndDecodeBytecodes } from "../stack-traces/compiler-to-model";
 import { ConsoleLogger } from "../stack-traces/consoleLogger";
-import { ContractsIdentifier } from "../stack-traces/contracts-identifier";
 import {
   VmTraceDecoder,
   initializeVmTraceDecoder,
@@ -167,7 +168,7 @@ export class EdrProviderWrapper
   private _callOverrideCallback?: CallOverrideCallback;
 
   /** Used for internal stack trace tests. */
-  private _vmTracer?: VMTracer;
+  private _vmTracer?: VMTracerT;
 
   private constructor(
     private readonly _provider: EdrProviderT,
@@ -175,7 +176,7 @@ export class EdrProviderWrapper
     private readonly _node: {
       _vm: MinimalEthereumJsVm;
     },
-    private readonly _vmTraceDecoder: VmTraceDecoder,
+    private readonly _vmTraceDecoder: VmTraceDecoderT,
     // The common configuration for EthereumJS VM is not used by EDR, but tests expect it as part of the provider.
     private readonly _common: Common,
     tracingConfig?: TracingConfig
@@ -221,8 +222,7 @@ export class EdrProviderWrapper
     const printLineFn = loggerConfig.printLineFn ?? printLine;
     const replaceLastLineFn = loggerConfig.replaceLastLineFn ?? replaceLastLine;
 
-    const contractsIdentifier = new ContractsIdentifier();
-    const vmTraceDecoder = new VmTraceDecoder(contractsIdentifier);
+    const vmTraceDecoder = new VmTraceDecoder();
 
     const hardforkName = getHardforkName(config.hardfork);
 
@@ -368,6 +368,9 @@ export class EdrProviderWrapper
     if (needsTraces) {
       const rawTraces = responseObject.traces;
       for (const rawTrace of rawTraces) {
+        this._vmTracer?.observe(rawTrace);
+
+        // For other consumers in JS we need to marshall the entire trace over FFI
         const trace = rawTrace.trace();
 
         // beforeTx event
@@ -384,8 +387,6 @@ export class EdrProviderWrapper
                 edrTracingStepToMinimalInterpreterStep(traceItem)
               );
             }
-
-            this._vmTracer?.addStep(traceItem);
           }
           // afterMessage event
           else if ("executionResult" in traceItem) {
@@ -395,8 +396,6 @@ export class EdrProviderWrapper
                 edrTracingMessageResultToMinimalEVMResult(traceItem)
               );
             }
-
-            this._vmTracer?.addAfterMessage(traceItem.executionResult);
           }
           // beforeMessage event
           else {
@@ -406,8 +405,6 @@ export class EdrProviderWrapper
                 edrTracingMessageToMinimalMessage(traceItem)
               );
             }
-
-            this._vmTracer?.addBeforeMessage(traceItem);
           }
         }
 
@@ -474,7 +471,7 @@ export class EdrProviderWrapper
    *
    * Used for internal stack traces integration tests.
    */
-  public setVmTracer(vmTracer?: VMTracer) {
+  public setVmTracer(vmTracer?: VMTracerT) {
     this._vmTracer = vmTracer;
   }
 
@@ -552,7 +549,7 @@ export class EdrProviderWrapper
       );
 
       log(
-        "ContractsIdentifier failed to be updated. Please report this to help us improve Hardhat.\n",
+        "VmTraceDecoder failed to be updated. Please report this to help us improve Hardhat.\n",
         error
       );
 
@@ -578,17 +575,7 @@ export class EdrProviderWrapper
     rawTrace: RawTrace
   ): Promise<SolidityStackTrace | undefined> {
     const vmTracer = new VMTracer();
-
-    const trace = rawTrace.trace();
-    for (const traceItem of trace) {
-      if ("pc" in traceItem) {
-        vmTracer.addStep(traceItem);
-      } else if ("executionResult" in traceItem) {
-        vmTracer.addAfterMessage(traceItem.executionResult);
-      } else {
-        vmTracer.addBeforeMessage(traceItem);
-      }
-    }
+    vmTracer.observe(rawTrace);
 
     let vmTrace = vmTracer.getLastTopLevelMessageTrace();
     const vmTracerError = vmTracer.getLastError();

package/src/internal/hardhat-network/provider/return-data.ts

@@ -1,75 +1,7 @@
-import { bytesToBigInt } from "@nomicfoundation/ethereumjs-util";
-import { assertHardhatInvariant } from "../../core/errors";
+import { requireNapiRsModule } from "../../../common/napi-rs";
 
-const { rawDecode } = require("ethereumjs-abi");
+const { ReturnData } = requireNapiRsModule(
+  "@nomicfoundation/edr"
+) as typeof import("@nomicfoundation/edr");
 
-// selector of Error(string)
-const ERROR_SELECTOR = "08c379a0";
-// selector of Panic(uint256)
-const PANIC_SELECTOR = "4e487b71";
-
-/**
- * Represents the returnData of a transaction, whose contents are unknown.
- */
-export class ReturnData {
-  private _selector: string | undefined;
-
-  constructor(public value: Uint8Array) {
-    if (value.length >= 4) {
-      this._selector = Buffer.from(value.slice(0, 4)).toString("hex");
-    }
-  }
-
-  public isEmpty(): boolean {
-    return this.value.length === 0;
-  }
-
-  public matchesSelector(selector: Uint8Array): boolean {
-    if (this._selector === undefined) {
-      return false;
-    }
-
-    return this._selector === Buffer.from(selector).toString("hex");
-  }
-
-  public isErrorReturnData(): boolean {
-    return this._selector === ERROR_SELECTOR;
-  }
-
-  public isPanicReturnData(): boolean {
-    return this._selector === PANIC_SELECTOR;
-  }
-
-  public decodeError(): string {
-    if (this.isEmpty()) {
-      return "";
-    }
-
-    assertHardhatInvariant(
-      this._selector === ERROR_SELECTOR,
-      "Expected return data to be a Error(string)"
-    );
-
-    const [decodedError] = rawDecode(["string"], this.value.slice(4)) as [
-      string
-    ];
-
-    return decodedError;
-  }
-
-  public decodePanic(): bigint {
-    assertHardhatInvariant(
-      this._selector === PANIC_SELECTOR,
-      "Expected return data to be a Panic(uint256)"
-    );
-
-    // we are assuming that panic codes are smaller than Number.MAX_SAFE_INTEGER
-    const errorCode = bytesToBigInt(this.value.slice(4));
-
-    return errorCode;
-  }
-
-  public getSelector(): string | undefined {
-    return this._selector;
-  }
-}
+export { ReturnData };

package/src/internal/hardhat-network/provider/vm/exit.ts

@@ -1,95 +1,7 @@
-import type { ExceptionalHalt, SuccessReason } from "@nomicfoundation/edr";
-
 import { requireNapiRsModule } from "../../../../common/napi-rs";
 
-export enum ExitCode {
-  SUCCESS,
-  REVERT,
-  OUT_OF_GAS,
-  INTERNAL_ERROR,
-  INVALID_OPCODE,
-  STACK_UNDERFLOW,
-  CODESIZE_EXCEEDS_MAXIMUM,
-  CREATE_COLLISION,
-  STATIC_STATE_CHANGE,
-}
-
-export class Exit {
-  public static fromEdrSuccessReason(reason: SuccessReason): Exit {
-    const { SuccessReason } = requireNapiRsModule(
-      "@nomicfoundation/edr"
-    ) as typeof import("@nomicfoundation/edr");
-
-    switch (reason) {
-      case SuccessReason.Stop:
-      case SuccessReason.Return:
-      case SuccessReason.SelfDestruct:
-      case SuccessReason.EofReturnContract:
-        return new Exit(ExitCode.SUCCESS);
-    }
-
-    const _exhaustiveCheck: never = reason;
-  }
-
-  public static fromEdrExceptionalHalt(halt: ExceptionalHalt): Exit {
-    const { ExceptionalHalt } = requireNapiRsModule(
-      "@nomicfoundation/edr"
-    ) as typeof import("@nomicfoundation/edr");
-
-    switch (halt) {
-      case ExceptionalHalt.OutOfGas:
-        return new Exit(ExitCode.OUT_OF_GAS);
-
-      case ExceptionalHalt.OpcodeNotFound:
-      case ExceptionalHalt.InvalidFEOpcode:
-      // Returned when an opcode is not implemented for the hardfork
-      case ExceptionalHalt.NotActivated:
-        return new Exit(ExitCode.INVALID_OPCODE);
-
-      case ExceptionalHalt.StackUnderflow:
-        return new Exit(ExitCode.STACK_UNDERFLOW);
-
-      case ExceptionalHalt.CreateCollision:
-        return new Exit(ExitCode.CREATE_COLLISION);
-
-      case ExceptionalHalt.CreateContractSizeLimit:
-        return new Exit(ExitCode.CODESIZE_EXCEEDS_MAXIMUM);
-
-      default: {
-        // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
-        throw new Error(`Unmatched EDR exceptional halt: ${halt}`);
-      }
-    }
-  }
-
-  constructor(public kind: ExitCode) {}
-
-  public isError(): boolean {
-    return this.kind !== ExitCode.SUCCESS;
-  }
-
-  public getReason(): string {
-    switch (this.kind) {
-      case ExitCode.SUCCESS:
-        return "Success";
-      case ExitCode.REVERT:
-        return "Reverted";
-      case ExitCode.OUT_OF_GAS:
-        return "Out of gas";
-      case ExitCode.INTERNAL_ERROR:
-        return "Internal error";
-      case ExitCode.INVALID_OPCODE:
-        return "Invalid opcode";
-      case ExitCode.STACK_UNDERFLOW:
-        return "Stack underflow";
-      case ExitCode.CODESIZE_EXCEEDS_MAXIMUM:
-        return "Codesize exceeds maximum";
-      case ExitCode.CREATE_COLLISION:
-        return "Create collision";
-      case ExitCode.STATIC_STATE_CHANGE:
-        return "Static state change";
-    }
+const { ExitCode } = requireNapiRsModule(
+  "@nomicfoundation/edr"
+) as typeof import("@nomicfoundation/edr");
 
-    const _exhaustiveCheck: never = this.kind;
-  }
-}
+export { ExitCode };