refactor: Re-use the compiler to model and opcodes logic from EDR

Author: Xanewok

packages/hardhat-core/src/internal/hardhat-network/stack-traces/compiler-to-model.ts

@@ -10,8 +10,8 @@ import {
   MessageTrace,
   PrecompileMessageTrace,
 } from "./message-trace";
-import { JumpType } from "./model";
-import { isJump, isPush, Opcode } from "./opcodes";
+import { JumpType, jumpTypeToString } from "./model";
+import { isJump, isPush, opcodeToString } from "./opcodes";
 import {
   SolidityStackTrace,
   SourceReference,
@@ -147,23 +147,23 @@ function traceSteps(
         if (isJump(inst.opcode)) {
           const jump =
             inst.jumpType !== JumpType.NOT_JUMP
-              ? chalk.bold(`(${JumpType[inst.jumpType]})`)
+              ? chalk.bold(`(${jumpTypeToString(inst.jumpType)})`)
               : "";
 
           console.log(
-            `${margin}  ${pc}   ${Opcode[inst.opcode]} ${jump}`.padEnd(50),
+            `${margin}  ${pc}   ${opcodeToString(inst.opcode)} ${jump}`.padEnd(50),
             location
           );
         } else if (isPush(inst.opcode)) {
           console.log(
-            `${margin}  ${pc}   ${Opcode[inst.opcode]} ${bufferToHex(
+            `${margin}  ${pc}   ${opcodeToString(inst.opcode)} ${bufferToHex(
               inst.pushData!
             )}`.padEnd(50),
             location
           );
         } else {
           console.log(
-            `${margin}  ${pc}   ${Opcode[inst.opcode]}`.padEnd(50),
+            `${margin}  ${pc}   ${opcodeToString(inst.opcode)}`.padEnd(50),
             location
           );
         }

packages/hardhat-core/src/internal/hardhat-network/stack-traces/debug.ts

@@ -641,9 +641,13 @@ export class ErrorInferrer {
       );
 
       if (calledFunction !== undefined) {
-        const isValidCalldata = calledFunction.isValidCalldata(
-          trace.calldata.slice(4)
-        );
+        const isValidCalldata =
+          // if we don't know the param types, we just assume that the call is valid
+          calledFunction.paramTypes === undefined ||
+          AbiHelpers.isValidCalldata(
+            calledFunction.paramTypes,
+            trace.calldata.slice(4)
+          );
 
         if (!isValidCalldata) {
           return [

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

@@ -1,53 +1,10 @@
-import { CompilerOutputBytecode } from "../../../types";
-
+import {
+  getLibraryAddressPositions,
+  linkHexStringBytecode,
+} from "@nomicfoundation/edr";
 import { Opcode } from "./opcodes";
 
-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 { getLibraryAddressPositions, linkHexStringBytecode };
 
 export function zeroOutAddresses(
   code: Uint8Array,