hardhat 2.22.11 → 2.22.12

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

@@ -1,220 +1,7 @@
-import { bytesToHex as bufferToHex } from "@nomicfoundation/ethereumjs-util";
-import chalk from "chalk";
+import { requireNapiRsModule } from "../../../common/napi-rs";
 
-import {
-  CallMessageTrace,
-  CreateMessageTrace,
-  isCreateTrace,
-  isEvmStep,
-  isPrecompileTrace,
-  MessageTrace,
-  PrecompileMessageTrace,
-} from "./message-trace";
-import { JumpType } from "./model";
-import { isJump, isPush, Opcode } from "./opcodes";
-import {
-  SolidityStackTrace,
-  SourceReference,
-  StackTraceEntryType,
-} from "./solidity-stack-trace";
+const { printMessageTrace, printStackTrace } = requireNapiRsModule(
+  "@nomicfoundation/edr"
+) as typeof import("@nomicfoundation/edr");
 
-const MARGIN_SPACE = 6;
-
-export function printMessageTrace(trace: MessageTrace, depth = 0) {
-  console.log("");
-
-  if (isCreateTrace(trace)) {
-    printCreateTrace(trace, depth);
-  } else if (isPrecompileTrace(trace)) {
-    printPrecompileTrace(trace, depth);
-  } else {
-    printCallTrace(trace, depth);
-  }
-
-  console.log("");
-}
-
-export function printCreateTrace(trace: CreateMessageTrace, depth: number) {
-  const margin = "".padStart(depth * MARGIN_SPACE);
-  console.log(`${margin}Create trace`);
-
-  if (trace.bytecode !== undefined) {
-    console.log(
-      `${margin} deploying contract: ${trace.bytecode.contract.location.file.sourceName}:${trace.bytecode.contract.name}`
-    );
-
-    console.log(`${margin} code: ${bufferToHex(trace.code)}`);
-  } else {
-    console.log(
-      `${margin} unrecognized deployment code: ${bufferToHex(trace.code)}`
-    );
-  }
-
-  console.log(`${margin} value: ${trace.value.toString(10)}`);
-
-  if (trace.deployedContract !== undefined) {
-    console.log(
-      `${margin} contract address: ${bufferToHex(trace.deployedContract)}`
-    );
-  }
-
-  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)}`);
-  }
-
-  traceSteps(trace, depth);
-}
-
-export function printPrecompileTrace(
-  trace: PrecompileMessageTrace,
-  depth: number
-) {
-  const margin = "".padStart(depth * MARGIN_SPACE);
-  console.log(`${margin}Precompile trace`);
-
-  console.log(`${margin} precompile number: ${trace.precompile}`);
-  console.log(`${margin} value: ${trace.value.toString(10)}`);
-  console.log(`${margin} calldata: ${bufferToHex(trace.calldata)}`);
-
-  if (trace.exit.isError()) {
-    console.log(`${margin} error: ${trace.exit.getReason()}`);
-  }
-
-  console.log(`${margin} returnData: ${bufferToHex(trace.returnData)}`);
-}
-
-export function printCallTrace(trace: CallMessageTrace, depth: number) {
-  const margin = "".padStart(depth * MARGIN_SPACE);
-  console.log(`${margin}Call trace`);
-
-  if (trace.bytecode !== undefined) {
-    console.log(
-      `${margin} calling contract: ${trace.bytecode.contract.location.file.sourceName}:${trace.bytecode.contract.name}`
-    );
-  } else {
-    console.log(
-      `${margin} unrecognized contract code: ${bufferToHex(trace.code)}`
-    );
-    console.log(`${margin} contract: ${bufferToHex(trace.address)}`);
-  }
-
-  console.log(`${margin} value: ${trace.value.toString(10)}`);
-  console.log(`${margin} calldata: ${bufferToHex(trace.calldata)}`);
-
-  if (trace.exit.isError()) {
-    console.log(`${margin} error: ${trace.exit.getReason()}`);
-  }
-
-  console.log(`${margin} returnData: ${bufferToHex(trace.returnData)}`);
-
-  traceSteps(trace, depth);
-}
-
-function traceSteps(
-  trace: CreateMessageTrace | CallMessageTrace,
-  depth: number
-) {
-  const margin = "".padStart(depth * MARGIN_SPACE);
-
-  console.log(`${margin} steps:`);
-  console.log("");
-
-  for (const step of trace.steps) {
-    if (isEvmStep(step)) {
-      const pc = step.pc.toString(10).padStart(3, "0").padStart(5);
-
-      if (trace.bytecode !== undefined) {
-        const inst = trace.bytecode.getInstruction(step.pc);
-
-        let location: string = "";
-
-        if (inst.location !== undefined) {
-          location += inst.location.file.sourceName;
-
-          const func = inst.location.getContainingFunction();
-          if (func !== undefined) {
-            location += `:${
-              func.contract?.name ?? func.location.file.sourceName
-            }:${func.name}`;
-          }
-
-          location += `   -  ${inst.location.offset}:${inst.location.length}`;
-        }
-
-        if (isJump(inst.opcode)) {
-          const jump =
-            inst.jumpType !== JumpType.NOT_JUMP
-              ? chalk.bold(`(${JumpType[inst.jumpType]})`)
-              : "";
-
-          console.log(
-            `${margin}  ${pc}   ${Opcode[inst.opcode]} ${jump}`.padEnd(50),
-            location
-          );
-        } else if (isPush(inst.opcode)) {
-          console.log(
-            `${margin}  ${pc}   ${Opcode[inst.opcode]} ${bufferToHex(
-              inst.pushData!
-            )}`.padEnd(50),
-            location
-          );
-        } else {
-          console.log(
-            `${margin}  ${pc}   ${Opcode[inst.opcode]}`.padEnd(50),
-            location
-          );
-        }
-      } else {
-        console.log(`${margin}  ${pc}`);
-      }
-    } else {
-      printMessageTrace(step, depth + 1);
-    }
-  }
-}
-
-function flattenSourceReference(sourceReference?: SourceReference) {
-  if (sourceReference === undefined) {
-    return undefined;
-  }
-
-  return {
-    ...sourceReference,
-    file: sourceReference.sourceName,
-  };
-}
-
-export function printStackTrace(trace: SolidityStackTrace) {
-  const withDecodedMessages = trace.map((entry) =>
-    entry.type === StackTraceEntryType.REVERT_ERROR
-      ? { ...entry, message: entry.message.decodeError() }
-      : entry
-  );
-
-  const withHexAddress = withDecodedMessages.map((entry) =>
-    "address" in entry
-      ? { ...entry, address: bufferToHex(entry.address) }
-      : entry
-  );
-
-  const withTextualType = withHexAddress.map((entry) => ({
-    ...entry,
-    type: StackTraceEntryType[entry.type],
-  }));
-
-  const withFlattenedSourceReferences = withTextualType.map((entry) => ({
-    ...entry,
-    sourceReference: flattenSourceReference(entry.sourceReference),
-  }));
-
-  console.log(
-    JSON.stringify(
-      withFlattenedSourceReferences,
-      (key, value) => (typeof value === "bigint" ? value.toString() : value),
-      2
-    )
-  );
-}
+export { printMessageTrace, printStackTrace };

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

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

@@ -1,129 +1,12 @@
-import type { Bytecode } from "./model";
-import type { Exit } from "../provider/vm/exit";
 import type {
-  CallOutput,
-  CreateOutput,
-  HaltResult,
-  RevertResult,
-  SuccessResult,
+  PrecompileMessageTrace,
+  CreateMessageTrace,
+  CallMessageTrace,
 } from "@nomicfoundation/edr";
 
+export type { PrecompileMessageTrace, CreateMessageTrace, CallMessageTrace };
+
 export type MessageTrace =
   | CreateMessageTrace
   | CallMessageTrace
   | PrecompileMessageTrace;
-
-export type EvmMessageTrace = CreateMessageTrace | CallMessageTrace;
-
-export type DecodedEvmMessageTrace =
-  | DecodedCreateMessageTrace
-  | DecodedCallMessageTrace;
-
-export interface BaseMessageTrace {
-  value: bigint;
-  returnData: Uint8Array;
-  exit: Exit;
-  gasUsed: bigint;
-  depth: number;
-}
-
-export interface PrecompileMessageTrace extends BaseMessageTrace {
-  precompile: number;
-  calldata: Uint8Array;
-}
-
-export interface BaseEvmMessageTrace extends BaseMessageTrace {
-  code: Uint8Array;
-  steps: MessageTraceStep[];
-  bytecode?: Bytecode;
-  // The following is just an optimization: When processing this traces it's useful to know ahead of
-  // time how many subtraces there are.
-  numberOfSubtraces: number;
-}
-
-export interface CreateMessageTrace extends BaseEvmMessageTrace {
-  deployedContract: Uint8Array | undefined;
-}
-
-export interface CallMessageTrace extends BaseEvmMessageTrace {
-  calldata: Uint8Array;
-  address: Uint8Array;
-  codeAddress: Uint8Array;
-}
-
-export interface DecodedCreateMessageTrace extends CreateMessageTrace {
-  bytecode: Bytecode;
-}
-
-export interface DecodedCallMessageTrace extends CallMessageTrace {
-  bytecode: Bytecode;
-}
-
-export function isPrecompileTrace(
-  trace: MessageTrace
-): trace is PrecompileMessageTrace {
-  return "precompile" in trace;
-}
-
-export function isCreateTrace(
-  trace: MessageTrace
-): trace is CreateMessageTrace {
-  return "code" in trace && !isCallTrace(trace);
-}
-
-export function isDecodedCreateTrace(
-  trace: MessageTrace
-): trace is DecodedCreateMessageTrace {
-  return isCreateTrace(trace) && trace.bytecode !== undefined;
-}
-
-export function isCallTrace(trace: MessageTrace): trace is CallMessageTrace {
-  return "code" in trace && "calldata" in trace;
-}
-
-export function isDecodedCallTrace(
-  trace: MessageTrace
-): trace is DecodedCallMessageTrace {
-  return isCallTrace(trace) && trace.bytecode !== undefined;
-}
-
-export function isEvmStep(step: MessageTraceStep): step is EvmStep {
-  return "pc" in step && step.pc !== undefined;
-}
-
-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/solidity-errors.ts

@@ -1,5 +1,6 @@
 import { bytesToHex as bufferToHex } from "@nomicfoundation/ethereumjs-util";
 
+import { ReturnData } from "../provider/return-data";
 import { panicErrorCodeToMessage } from "./panic-errors";
 import {
   CONSTRUCTOR_FUNCTION_NAME,
@@ -258,24 +259,21 @@ function getMessageFromLastStackTraceEntry(
       return `Transaction reverted: library was called directly`;
 
     case StackTraceEntryType.UNRECOGNIZED_CREATE_ERROR:
-    case StackTraceEntryType.UNRECOGNIZED_CONTRACT_ERROR:
-      if (stackTraceEntry.message.isErrorReturnData()) {
-        return `VM Exception while processing transaction: reverted with reason string '${stackTraceEntry.message.decodeError()}'`;
+    case StackTraceEntryType.UNRECOGNIZED_CONTRACT_ERROR: {
+      const returnData = new ReturnData(stackTraceEntry.returnData);
+      if (returnData.isErrorReturnData()) {
+        return `VM Exception while processing transaction: reverted with reason string '${returnData.decodeError()}'`;
       }
 
-      if (stackTraceEntry.message.isPanicReturnData()) {
-        const message = panicErrorCodeToMessage(
-          stackTraceEntry.message.decodePanic()
-        );
+      if (returnData.isPanicReturnData()) {
+        const message = panicErrorCodeToMessage(returnData.decodePanic());
         return `VM Exception while processing transaction: ${message}`;
       }
 
-      if (!stackTraceEntry.message.isEmpty()) {
-        const returnData = Buffer.from(stackTraceEntry.message.value).toString(
-          "hex"
-        );
+      if (!returnData.isEmpty()) {
+        const buffer = Buffer.from(returnData.value).toString("hex");
 
-        return `VM Exception while processing transaction: reverted with an unrecognized custom error (return data: 0x${returnData})`;
+        return `VM Exception while processing transaction: reverted with an unrecognized custom error (return data: 0x${buffer})`;
       }
 
       if (stackTraceEntry.isInvalidOpcodeError) {
@@ -283,10 +281,12 @@ function getMessageFromLastStackTraceEntry(
       }
 
       return "Transaction reverted without a reason string";
+    }
 
-    case StackTraceEntryType.REVERT_ERROR:
-      if (stackTraceEntry.message.isErrorReturnData()) {
-        return `VM Exception while processing transaction: reverted with reason string '${stackTraceEntry.message.decodeError()}'`;
+    case StackTraceEntryType.REVERT_ERROR: {
+      const returnData = new ReturnData(stackTraceEntry.returnData);
+      if (returnData.isErrorReturnData()) {
+        return `VM Exception while processing transaction: reverted with reason string '${returnData.decodeError()}'`;
       }
 
       if (stackTraceEntry.isInvalidOpcodeError) {
@@ -294,6 +294,7 @@ function getMessageFromLastStackTraceEntry(
       }
 
       return "Transaction reverted without a reason string";
+    }
 
     case StackTraceEntryType.PANIC_ERROR:
       const panicMessage = panicErrorCodeToMessage(stackTraceEntry.errorCode);