hardhat 2.23.0-dev.2 → 2.23.0

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

@@ -1,115 +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:
-        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 _exhaustiveCheck: never = this.kind;
-  }
-
-  public getEdrExceptionalHalt(): ExceptionalHalt {
-    const { ExceptionalHalt } = requireNapiRsModule(
-      "@nomicfoundation/edr"
-    ) as typeof import("@nomicfoundation/edr");
-
-    switch (this.kind) {
-      case ExitCode.OUT_OF_GAS:
-        return ExceptionalHalt.OutOfGas;
-      case ExitCode.INVALID_OPCODE:
-        return ExceptionalHalt.OpcodeNotFound;
-      case ExitCode.CODESIZE_EXCEEDS_MAXIMUM:
-        return ExceptionalHalt.CreateContractSizeLimit;
-      case ExitCode.CREATE_COLLISION:
-        return ExceptionalHalt.CreateCollision;
+const { ExitCode } = requireNapiRsModule(
+  "@nomicfoundation/edr"
+) as typeof import("@nomicfoundation/edr");
 
-      default:
-        // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
-        throw new Error(`Unmatched exit code: ${this.kind}`);
-    }
-  }
-}
+export { ExitCode };

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

@@ -1,12 +1,12 @@
 import type { Provider as EdrProviderT } from "@nomicfoundation/edr";
-import type { Address } from "@nomicfoundation/ethereumjs-util";
+import type { Address } from "@ethereumjs/util";
 import type {
   MinimalEVMResult,
   MinimalInterpreterStep,
   MinimalMessage,
 } from "./types";
 
-import { AsyncEventEmitter } from "@nomicfoundation/ethereumjs-util";
+import { AsyncEventEmitter } from "@ethereumjs/util";
 
 /**
  * Used by the provider to keep the `_vm` variable used by some plugins. This
@@ -82,7 +82,12 @@ export function getMinimalEthereumJsVm(
           })
         );
 
-        const response = JSON.parse(responseObject.json);
+        let response;
+        if (typeof responseObject.data === "string") {
+          response = JSON.parse(responseObject.data);
+        } else {
+          response = responseObject.data;
+        }
 
         return Buffer.from(response.result.slice(2), "hex");
       },

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

@@ -1,5 +1,5 @@
 import type { ExceptionalHalt, SuccessReason } from "@nomicfoundation/edr";
-import type { Address } from "@nomicfoundation/ethereumjs-util";
+import type { Address } from "@ethereumjs/util";
 
 /**
  * These types are minimal versions of the values returned by ethereumjs

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

@@ -3,7 +3,7 @@ import {
   bytesToHex as bufferToHex,
   bytesToInt,
   fromSigned,
-} from "@nomicfoundation/ethereumjs-util";
+} from "@ethereumjs/util";
 import util from "util";
 
 import {
@@ -42,113 +42,62 @@ import {
   Bytes8Ty,
   Bytes9Ty,
   BytesTy,
-  ConsoleLogs,
   Int256Ty,
   StringTy,
   Uint256Ty,
+  CONSOLE_LOG_SIGNATURES,
 } from "./logger";
-import {
-  EvmMessageTrace,
-  isCallTrace,
-  isEvmStep,
-  isPrecompileTrace,
-  MessageTrace,
-} from "./message-trace";
 
-const CONSOLE_ADDRESS = "0x000000000000000000636F6e736F6c652e6c6f67"; // toHex("console.log")
 const REGISTER_SIZE = 32;
 
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-interface ConsoleLogArray extends Array<ConsoleLogEntry> {}
-
-export type ConsoleLogEntry = string | ConsoleLogArray;
-
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-export type ConsoleLogs = ConsoleLogEntry[];
+/** The decoded string representation of the arguments supplied to console.log */
+export type ConsoleLogArgs = string[];
+export type ConsoleLogs = ConsoleLogArgs[];
 
 export class ConsoleLogger {
-  private readonly _consoleLogs: {
-    [key: number]: string[];
-  } = {};
-
-  constructor() {
-    this._consoleLogs = ConsoleLogs;
-  }
-
-  public getLogMessages(maybeDecodedMessageTrace: MessageTrace): string[] {
-    return this.getExecutionLogs(maybeDecodedMessageTrace).map(
-      consoleLogToString
-    );
-  }
-
-  public getExecutionLogs(
-    maybeDecodedMessageTrace: MessageTrace
-  ): ConsoleLogs[] {
-    if (isPrecompileTrace(maybeDecodedMessageTrace)) {
-      return [];
-    }
-
-    const logs: ConsoleLogs[] = [];
-    this._collectExecutionLogs(maybeDecodedMessageTrace, logs);
-    return logs;
-  }
-
-  private _collectExecutionLogs(trace: EvmMessageTrace, logs: ConsoleLogs) {
-    for (const messageTrace of trace.steps) {
-      if (isEvmStep(messageTrace) || isPrecompileTrace(messageTrace)) {
-        continue;
-      }
-
-      if (
-        isCallTrace(messageTrace) &&
-        bufferToHex(messageTrace.address) === CONSOLE_ADDRESS.toLowerCase()
-      ) {
-        const log = this._maybeConsoleLog(Buffer.from(messageTrace.calldata));
-        if (log !== undefined) {
-          logs.push(log);
-        }
-
-        continue;
-      }
-
-      this._collectExecutionLogs(messageTrace, logs);
-    }
-  }
-
   /**
    * Temporary code to print console.sol messages that come from EDR
    */
-  public getDecodedLogs(messages: Buffer[]): string[] {
+  public static getDecodedLogs(messages: Buffer[]): string[] {
     const logs: string[] = [];
 
     for (const message of messages) {
-      const log = this._maybeConsoleLog(message);
+      const log = ConsoleLogger._maybeConsoleLog(message);
       if (log !== undefined) {
-        logs.push(consoleLogToString(log));
+        logs.push(ConsoleLogger.format(log));
       }
     }
 
     return logs;
   }
 
-  private _maybeConsoleLog(calldata: Buffer): ConsoleLogs | undefined {
-    const sig = bytesToInt(calldata.slice(0, 4));
+  /**
+   * Returns a formatted string using the first argument as a `printf`-like
+   * format string which can contain zero or more format specifiers.
+   *
+   * If there are more arguments passed than the number of specifiers, the
+   * extra arguments are concatenated to the returned string, separated by spaces.
+   */
+  public static format(args: ConsoleLogArgs = []): string {
+    return util.format(...args);
+  }
+
+  /** Decodes a calldata buffer into string arguments for a console log. */
+  private static _maybeConsoleLog(
+    calldata: Buffer
+  ): ConsoleLogArgs | undefined {
+    const selector = bytesToInt(calldata.slice(0, 4));
     const parameters = calldata.slice(4);
 
-    const types = this._consoleLogs[sig];
-    if (types === undefined) {
+    const argTypes = CONSOLE_LOG_SIGNATURES[selector];
+    if (argTypes === undefined) {
       return;
     }
 
-    const consoleLogs = this._decode(parameters, types);
+    const decodedArgs = ConsoleLogger._decode(parameters, argTypes);
 
-    this._replaceNumberFormatSpecifiers(consoleLogs);
-
-    return consoleLogs;
-  }
-
-  private _replaceNumberFormatSpecifiers(consoleLogs: ConsoleLogs) {
     /**
+     * The first argument is interpreted as the format string, which may need adjusting.
      * Replace the occurrences of %d and %i with %s. This is necessary because if the arguments passed are numbers,
      * they could be too large to be formatted as a Number or an Integer, so it is safer to use a String.
      * %d and %i are replaced only if there is an odd number of % before the d or i.
@@ -160,15 +109,18 @@ export class ConsoleLogger {
      * (?<!%) negative look-behind to make this work.
      * The (?:) is just to avoid capturing that inner group.
      */
-    if (consoleLogs.length > 0 && typeof consoleLogs[0] === "string") {
-      consoleLogs[0] = consoleLogs[0].replace(
+    if (decodedArgs.length > 0) {
+      decodedArgs[0] = decodedArgs[0].replace(
         /((?<!%)(?:%%)*)(%[di])/g,
         "$1%s"
       );
     }
+
+    return decodedArgs;
   }
 
-  private _decode(data: Buffer, types: string[]): ConsoleLogs {
+  /** Decodes calldata parameters from `data` according to `types` into their string representation. */
+  private static _decode(data: Buffer, types: string[]): string[] {
     return types.map((type, i) => {
       const position: number = i * 32;
       switch (types[i]) {
@@ -282,16 +234,3 @@ export class ConsoleLogger {
     });
   }
 }
-
-export function consoleLogToString(log: ConsoleLogs): string {
-  if (log === undefined) {
-    return "";
-  }
-
-  // special case for console.log()
-  if (log.length === 0) {
-    return "";
-  }
-
-  return util.format(log[0], ...log.slice(1));
-}

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

@@ -1,2 +1 @@
-export const SUPPORTED_SOLIDITY_VERSION_RANGE = "<=0.8.24";
-export const FIRST_SOLC_VERSION_SUPPORTED = "0.5.1";
+export const SUPPORTED_SOLIDITY_VERSION_RANGE = "<=0.8.28";

package/src/internal/hardhat-network/stack-traces/library-utils.ts

@@ -1,92 +1,7 @@
-import { CompilerOutputBytecode } from "../../../types";
+import { requireNapiRsModule } from "../../../common/napi-rs";
 
-import { Opcode } from "./opcodes";
+const { linkHexStringBytecode } = requireNapiRsModule(
+  "@nomicfoundation/edr"
+) as typeof import("@nomicfoundation/edr");
 
-export function getLibraryAddressPositions(
-  bytecodeOutput: CompilerOutputBytecode
-): number[] {
-  const positions = [];
-  for (const libs of Object.values(bytecodeOutput.linkReferences)) {
-    for (const references of Object.values(libs)) {
-      for (const ref of references) {
-        positions.push(ref.start);
-      }
-    }
-  }
-
-  return positions;
-}
-
-export function normalizeCompilerOutputBytecode(
-  compilerOutputBytecodeObject: string,
-  addressesPositions: number[]
-): Buffer {
-  const ZERO_ADDRESS = "0000000000000000000000000000000000000000";
-  for (const position of addressesPositions) {
-    compilerOutputBytecodeObject = linkHexStringBytecode(
-      compilerOutputBytecodeObject,
-      ZERO_ADDRESS,
-      position
-    );
-  }
-
-  return Buffer.from(compilerOutputBytecodeObject, "hex");
-}
-
-export function linkHexStringBytecode(
-  code: string,
-  address: string,
-  position: number
-) {
-  if (address.startsWith("0x")) {
-    address = address.substring(2);
-  }
-
-  return (
-    code.substring(0, position * 2) +
-    address +
-    code.slice(position * 2 + address.length)
-  );
-}
-
-export function zeroOutAddresses(
-  code: Uint8Array,
-  addressesPositions: number[]
-): Uint8Array {
-  const addressesSlices = addressesPositions.map((start) => ({
-    start,
-    length: 20,
-  }));
-
-  return zeroOutSlices(code, addressesSlices);
-}
-
-export function zeroOutSlices(
-  code: Uint8Array,
-  slices: Array<{ start: number; length: number }>
-): Uint8Array {
-  for (const { start, length } of slices) {
-    code = Buffer.concat([
-      code.slice(0, start),
-      Buffer.alloc(length, 0),
-      code.slice(start + length),
-    ]);
-  }
-
-  return code;
-}
-
-export function normalizeLibraryRuntimeBytecodeIfNecessary(
-  code: Uint8Array
-): Uint8Array {
-  // Libraries' protection normalization:
-  // Solidity 0.4.20 introduced a protection to prevent libraries from being called directly.
-  // This is done by modifying the code on deployment, and hard-coding the contract address.
-  // The first instruction is a PUSH20 of the address, which we zero-out as a way of normalizing
-  // it. Note that it's also zeroed-out in the compiler output.
-  if (code[0] === Opcode.PUSH20) {
-    return zeroOutAddresses(code, [1]);
-  }
-
-  return code;
-}
+export { linkHexStringBytecode };