hardhat 2.20.1 → 2.21.0-dev.0

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

@@ -48,7 +48,6 @@ import {
   Uint256Ty,
 } from "./logger";
 import {
-  CallMessageTrace,
   EvmMessageTrace,
   isCallTrace,
   isEvmStep,
@@ -77,18 +76,9 @@ export class ConsoleLogger {
   }
 
   public getLogMessages(maybeDecodedMessageTrace: MessageTrace): string[] {
-    return this.getExecutionLogs(maybeDecodedMessageTrace).map((log) => {
-      if (log === undefined) {
-        return "";
-      }
-
-      // special case for console.log()
-      if (log.length === 0) {
-        return "";
-      }
-
-      return util.format(log[0], ...log.slice(1));
-    });
+    return this.getExecutionLogs(maybeDecodedMessageTrace).map(
+      consoleLogToString
+    );
   }
 
   public getExecutionLogs(
@@ -113,7 +103,7 @@ export class ConsoleLogger {
         isCallTrace(messageTrace) &&
         bufferToHex(messageTrace.address) === CONSOLE_ADDRESS.toLowerCase()
       ) {
-        const log = this._maybeConsoleLog(messageTrace);
+        const log = this._maybeConsoleLog(Buffer.from(messageTrace.calldata));
         if (log !== undefined) {
           logs.push(log);
         }
@@ -125,9 +115,25 @@ export class ConsoleLogger {
     }
   }
 
-  private _maybeConsoleLog(call: CallMessageTrace): ConsoleLogs | undefined {
-    const sig = bytesToInt(call.calldata.slice(0, 4));
-    const parameters = call.calldata.slice(4);
+  /**
+   * Temporary code to print console.sol messages that come from EDR
+   */
+  public getDecodedLogs(messages: Buffer[]): string[] {
+    const logs: string[] = [];
+
+    for (const message of messages) {
+      const log = this._maybeConsoleLog(message);
+      if (log !== undefined) {
+        logs.push(consoleLogToString(log));
+      }
+    }
+
+    return logs;
+  }
+
+  private _maybeConsoleLog(calldata: Buffer): ConsoleLogs | undefined {
+    const sig = bytesToInt(calldata.slice(0, 4));
+    const parameters = calldata.slice(4);
 
     const types = this._consoleLogs[sig];
     if (types === undefined) {
@@ -162,7 +168,7 @@ export class ConsoleLogger {
     }
   }
 
-  private _decode(data: Uint8Array, types: string[]): ConsoleLogs {
+  private _decode(data: Buffer, types: string[]): ConsoleLogs {
     return types.map((type, i) => {
       const position: number = i * 32;
       switch (types[i]) {
@@ -187,9 +193,9 @@ export class ConsoleLogger {
             data.slice(position, position + REGISTER_SIZE)
           );
           const sLen = bytesToInt(data.slice(sStart, sStart + REGISTER_SIZE));
-          return Buffer.from(
-            data.slice(sStart + REGISTER_SIZE, sStart + REGISTER_SIZE + sLen)
-          ).toString();
+          return data
+            .slice(sStart + REGISTER_SIZE, sStart + REGISTER_SIZE + sLen)
+            .toString();
 
         case AddressTy:
           return bufferToHex(
@@ -276,3 +282,16 @@ 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/contracts-identifier.ts

@@ -1,11 +1,10 @@
-import { bytesToHex as bufferToHex } from "@nomicfoundation/ethereumjs-util";
+import { bytesToHex } from "@nomicfoundation/ethereumjs-util";
 
 import {
   normalizeLibraryRuntimeBytecodeIfNecessary,
   zeroOutAddresses,
   zeroOutSlices,
 } from "./library-utils";
-import { EvmMessageTrace, isCreateTrace } from "./message-trace";
 import { Bytecode } from "./model";
 import { getOpcodeLength, Opcode } from "./opcodes";
 
@@ -100,16 +99,15 @@ export class ContractsIdentifier {
     this._cache.clear();
   }
 
-  public getBytecodeFromMessageTrace(
-    trace: EvmMessageTrace
+  public getBytecodeForCall(
+    code: Uint8Array,
+    isCreate: boolean
   ): Bytecode | undefined {
-    const normalizedCode = normalizeLibraryRuntimeBytecodeIfNecessary(
-      trace.code
-    );
+    const normalizedCode = normalizeLibraryRuntimeBytecodeIfNecessary(code);
 
     let normalizedCodeHex: string | undefined;
     if (this._enableCache) {
-      normalizedCodeHex = bufferToHex(normalizedCode);
+      normalizedCodeHex = bytesToHex(normalizedCode);
       const cached = this._cache.get(normalizedCodeHex);
 
       if (cached !== undefined) {
@@ -117,7 +115,7 @@ export class ContractsIdentifier {
       }
     }
 
-    const result = this._searchBytecode(trace, normalizedCode);
+    const result = this._searchBytecode(isCreate, normalizedCode);
 
     if (this._enableCache) {
       if (result !== undefined) {
@@ -129,7 +127,7 @@ export class ContractsIdentifier {
   }
 
   private _searchBytecode(
-    trace: EvmMessageTrace,
+    isCreate: boolean,
     code: Uint8Array,
     normalizeLibraries = true,
     trie = this._trie,
@@ -159,7 +157,7 @@ export class ContractsIdentifier {
     // We take advantage of this last observation, and just return the bytecode that exactly
     // matched the searchResult (sub)trie that we got.
     if (
-      isCreateTrace(trace) &&
+      isCreate &&
       searchResult.match !== undefined &&
       searchResult.match.isDeployment
     ) {
@@ -186,7 +184,7 @@ export class ContractsIdentifier {
         );
 
         const normalizedResult = this._searchBytecode(
-          trace,
+          isCreate,
           normalizedCode,
           false,
           searchResult,

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

@@ -58,8 +58,8 @@ export function printCreateTrace(trace: CreateMessageTrace, depth: number) {
     );
   }
 
-  if (trace.error !== undefined) {
-    console.log(`${margin} error: ${trace.error.error}`);
+  if (trace.exit.isError()) {
+    console.log(`${margin} error: ${trace.exit.getReason()}`);
 
     // The return data is the deployed-bytecode if there was no error, so we don't show it
     console.log(`${margin} returnData: ${bufferToHex(trace.returnData)}`);
@@ -79,8 +79,8 @@ export function printPrecompileTrace(
   console.log(`${margin} value: ${trace.value.toString(10)}`);
   console.log(`${margin} calldata: ${bufferToHex(trace.calldata)}`);
 
-  if (trace.error !== undefined) {
-    console.log(`${margin} error: ${trace.error.error}`);
+  if (trace.exit.isError()) {
+    console.log(`${margin} error: ${trace.exit.getReason()}`);
   }
 
   console.log(`${margin} returnData: ${bufferToHex(trace.returnData)}`);
@@ -104,8 +104,8 @@ export function printCallTrace(trace: CallMessageTrace, depth: number) {
   console.log(`${margin} value: ${trace.value.toString(10)}`);
   console.log(`${margin} calldata: ${bufferToHex(trace.calldata)}`);
 
-  if (trace.error !== undefined) {
-    console.log(`${margin} error: ${trace.error.error}`);
+  if (trace.exit.isError()) {
+    console.log(`${margin} error: ${trace.exit.getReason()}`);
   }
 
   console.log(`${margin} returnData: ${bufferToHex(trace.returnData)}`);

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

@@ -1,12 +1,12 @@
 /* eslint "@typescript-eslint/no-non-null-assertion": "error" */
 import { defaultAbiCoder as abi } from "@ethersproject/abi";
-import { ERROR } from "@nomicfoundation/ethereumjs-evm/dist/cjs/exceptions";
 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,
@@ -275,8 +275,7 @@ export class ErrorInferrer {
       callInst
     );
 
-    const lastMessageFailed =
-      lastSubmessageData.messageTrace.error !== undefined;
+    const lastMessageFailed = lastSubmessageData.messageTrace.exit.isError();
     if (lastMessageFailed) {
       // add the call/create that generated the message to the stack trace
       inferredStacktrace.push(callStackFrame);
@@ -579,6 +578,10 @@ export class ErrorInferrer {
     functionJumpdests: Instruction[],
     jumpedIntoFunction: boolean
   ): SolidityStackTrace | undefined {
+    if (trace.steps.length === 0) {
+      return;
+    }
+
     const lastStep = trace.steps[trace.steps.length - 1];
 
     if (!isEvmStep(lastStep)) {
@@ -1211,6 +1214,10 @@ export class ErrorInferrer {
   }
 
   private _solidity063MaybeUnmappedRevert(trace: DecodedEvmMessageTrace) {
+    if (trace.steps.length === 0) {
+      return false;
+    }
+
     const lastStep = trace.steps[trace.steps.length - 1];
     if (!isEvmStep(lastStep)) {
       return false;
@@ -1425,7 +1432,7 @@ export class ErrorInferrer {
   }
 
   private _isContractTooLargeError(trace: DecodedCreateMessageTrace) {
-    return trace.error?.error === ERROR.CODESIZE_EXCEEDS_MAXIMUM;
+    return trace.exit.kind === ExitCode.CODESIZE_EXCEEDS_MAXIMUM;
   }
 
   private _solidity063CorrectLineNumber(
@@ -1629,8 +1636,8 @@ export class ErrorInferrer {
     }
 
     if (
-      trace.error?.error === ERROR.OUT_OF_GAS &&
-      call.error?.error === ERROR.OUT_OF_GAS
+      trace.exit.kind === ExitCode.OUT_OF_GAS &&
+      call.exit.kind === ExitCode.OUT_OF_GAS
     ) {
       return true;
     }
@@ -1719,12 +1726,12 @@ export class ErrorInferrer {
       return false;
     }
 
-    if (trace.error?.error !== ERROR.REVERT) {
+    if (trace.exit.kind !== ExitCode.REVERT) {
       return false;
     }
 
     const call = trace.steps[callStepIndex] as MessageTrace;
-    if (call.error?.error !== ERROR.OUT_OF_GAS) {
+    if (call.exit.kind !== ExitCode.OUT_OF_GAS) {
       return false;
     }
 

package/src/internal/hardhat-network/stack-traces/message-trace.ts

@@ -1,6 +1,12 @@
-import type { EvmError } from "@nomicfoundation/ethereumjs-evm";
-
 import type { Bytecode } from "./model";
+import type { Exit } from "../provider/vm/exit";
+import type {
+  CallOutput,
+  CreateOutput,
+  HaltResult,
+  RevertResult,
+  SuccessResult,
+} from "@nomicfoundation/edr";
 
 export type MessageTrace =
   | CreateMessageTrace
@@ -16,7 +22,7 @@ export type DecodedEvmMessageTrace =
 export interface BaseMessageTrace {
   value: bigint;
   returnData: Uint8Array;
-  error?: EvmError;
+  exit: Exit;
   gasUsed: bigint;
   depth: number;
 }
@@ -30,7 +36,6 @@ export interface BaseEvmMessageTrace extends BaseMessageTrace {
   code: Uint8Array;
   value: bigint;
   returnData: Uint8Array;
-  error?: EvmError;
   steps: MessageTraceStep[];
   bytecode?: Bytecode;
   // The following is just an optimization: When processing this traces it's useful to know ahead of
@@ -93,3 +98,34 @@ export type MessageTraceStep = MessageTrace | EvmStep;
 export interface EvmStep {
   pc: number;
 }
+
+export function isCallOutput(
+  output: CallOutput | CreateOutput
+): output is CallOutput {
+  return !isCreateOutput(output);
+}
+
+export function isCreateOutput(
+  output: CallOutput | CreateOutput
+): output is CreateOutput {
+  return "address" in output;
+}
+
+export function isSuccessResult(
+  result: SuccessResult | RevertResult | HaltResult
+): result is SuccessResult {
+  // Only need to check for one unique field
+  return "gasRefunded" in result;
+}
+
+export function isRevertResult(
+  result: SuccessResult | RevertResult | HaltResult
+): result is RevertResult {
+  return !("reason" in result);
+}
+
+export function isHaltResult(
+  result: SuccessResult | RevertResult | HaltResult
+): result is HaltResult {
+  return !("output" in result);
+}

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

@@ -308,6 +308,49 @@ export class Instruction {
     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 {
@@ -345,4 +388,22 @@ export class Bytecode {
   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;
+  }
 }

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

@@ -306,6 +306,10 @@ export enum Opcode {
   SELFDESTRUCT = 0xff,
 }
 
+export function opcodeName(opcode: number): string {
+  return Opcode[opcode] ?? `<unrecognized opcode ${opcode}>`;
+}
+
 export function isPush(opcode: Opcode) {
   return opcode >= Opcode.PUSH1 && opcode <= Opcode.PUSH32;
 }

package/src/internal/hardhat-network/stack-traces/solidity-errors.ts

@@ -66,8 +66,8 @@ export function encodeSolidityStackTrace(
     if (previousStack !== undefined) {
       stack = previousStack;
     } else {
-      // We remove Hardhat Network related stack traces
-      stack.splice(0, 3);
+      // We remove error management related stack traces
+      stack.splice(0, 1);
     }
 
     for (const entry of stackTrace) {

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

@@ -1,6 +1,7 @@
-import { ERROR } from "@nomicfoundation/ethereumjs-evm/dist/cjs/exceptions";
 import { equalsBytes } from "@nomicfoundation/ethereumjs-util";
+
 import { ReturnData } from "../provider/return-data";
+import { ExitCode } from "../provider/vm/exit";
 
 import {
   ErrorInferrer,
@@ -39,7 +40,7 @@ export class SolidityTracer {
   public getStackTrace(
     maybeDecodedMessageTrace: MessageTrace
   ): SolidityStackTrace {
-    if (maybeDecodedMessageTrace.error === undefined) {
+    if (!maybeDecodedMessageTrace.exit.isError()) {
       return [];
     }
 
@@ -80,7 +81,7 @@ export class SolidityTracer {
       // 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.error !== undefined &&
+        subtrace.exit.isError() &&
         equalsBytes(trace.returnData, subtrace.returnData)
       ) {
         let unrecognizedEntry: SolidityStackTraceEntry;
@@ -100,7 +101,7 @@ export class SolidityTracer {
       }
     }
 
-    if (trace.error?.error === ERROR.CODESIZE_EXCEEDS_MAXIMUM) {
+    if (trace.exit.kind === ExitCode.CODESIZE_EXCEEDS_MAXIMUM) {
       return [
         {
           type: StackTraceEntryType.CONTRACT_TOO_LARGE_ERROR,
@@ -108,7 +109,7 @@ export class SolidityTracer {
       ];
     }
 
-    const isInvalidOpcodeError = trace.error?.error === ERROR.INVALID_OPCODE;
+    const isInvalidOpcodeError = trace.exit.kind === ExitCode.INVALID_OPCODE;
 
     if (isCreateTrace(trace)) {
       return [

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

@@ -1,10 +1,72 @@
+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 { isEvmStep, isPrecompileTrace, MessageTrace } from "./message-trace";
-import { Bytecode } from "./model";
+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";
+
+const log = debug("hardhat:core:hardhat-network:node");
 
 export class VmTraceDecoder {
   constructor(private readonly _contractsIdentifier: ContractsIdentifier) {}
 
+  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;
@@ -12,8 +74,10 @@ export class VmTraceDecoder {
 
     return {
       ...messageTrace,
-      bytecode:
-        this._contractsIdentifier.getBytecodeFromMessageTrace(messageTrace),
+      bytecode: this._contractsIdentifier.getBytecodeForCall(
+        messageTrace.code,
+        isCreateTrace(messageTrace)
+      ),
       steps: messageTrace.steps.map((s) =>
         isEvmStep(s) ? s : this.tryToDecodeMessageTrace(s)
       ),
@@ -24,3 +88,48 @@ export class VmTraceDecoder {
     this._contractsIdentifier.addBytecode(bytecode);
   }
 }
+
+export function initializeVmTraceDecoder(
+  vmTraceDecoder: VmTraceDecoder,
+  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);
+      }
+    }
+  } catch (error) {
+    console.warn(
+      chalk.yellow(
+        "The Hardhat Network tracing engine could not be initialized. Run Hardhat with --verbose to learn more."
+      )
+    );
+
+    log(
+      "Hardhat Network tracing disabled: ContractsIdentifier failed to be initialized. Please report this to help us improve Hardhat.\n",
+      error
+    );
+
+    if (error instanceof Error) {
+      Reporter.reportError(error);
+    }
+  }
+}