hardhat 2.22.11 → 2.22.13

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

@@ -1,699 +1,7 @@
-import debug from "debug";
+import { requireNapiRsModule } from "../../../common/napi-rs";
 
-import {
-  CompilerInput,
-  CompilerOutput,
-  CompilerOutputBytecode,
-} from "../../../types";
+const { createModelsAndDecodeBytecodes } = requireNapiRsModule(
+  "@nomicfoundation/edr"
+) as typeof import("@nomicfoundation/edr");
 
-import {
-  getLibraryAddressPositions,
-  normalizeCompilerOutputBytecode,
-} from "./library-utils";
-import {
-  Bytecode,
-  Contract,
-  ContractFunction,
-  ContractFunctionType,
-  ContractFunctionVisibility,
-  ContractType,
-  CustomError,
-  SourceFile,
-  SourceLocation,
-} from "./model";
-import { decodeInstructions } from "./source-maps";
-
-const abi = require("ethereumjs-abi");
-
-const log = debug("hardhat:core:hardhat-network:compiler-to-model");
-
-interface ContractAbiEntry {
-  name?: string;
-  inputs?: Array<{
-    type: string;
-  }>;
-}
-
-type ContractAbi = ContractAbiEntry[];
-
-export function createModelsAndDecodeBytecodes(
-  solcVersion: string,
-  compilerInput: CompilerInput,
-  compilerOutput: CompilerOutput
-): Bytecode[] {
-  const fileIdToSourceFile = new Map<number, SourceFile>();
-  const contractIdToContract = new Map<number, Contract>();
-
-  createSourcesModelFromAst(
-    compilerOutput,
-    compilerInput,
-    fileIdToSourceFile,
-    contractIdToContract
-  );
-
-  const bytecodes = decodeBytecodes(
-    solcVersion,
-    compilerOutput,
-    fileIdToSourceFile,
-    contractIdToContract
-  );
-
-  correctSelectors(bytecodes, compilerOutput);
-
-  return bytecodes;
-}
-
-function createSourcesModelFromAst(
-  compilerOutput: CompilerOutput,
-  compilerInput: CompilerInput,
-  fileIdToSourceFile: Map<number, SourceFile>,
-  contractIdToContract: Map<number, Contract>
-) {
-  const contractIdToLinearizedBaseContractIds = new Map<number, number[]>();
-
-  // Create a `sourceName => contract => abi` mapping
-  const sourceNameToContractToAbi = new Map<string, Map<string, ContractAbi>>();
-  for (const [sourceName, contracts] of Object.entries(
-    compilerOutput.contracts
-  )) {
-    const contractToAbi = new Map<string, ContractAbi>();
-    sourceNameToContractToAbi.set(sourceName, contractToAbi);
-    for (const [contractName, contract] of Object.entries(contracts)) {
-      contractToAbi.set(contractName, contract.abi);
-    }
-  }
-
-  for (const [sourceName, source] of Object.entries(compilerOutput.sources)) {
-    const contractToAbi = sourceNameToContractToAbi.get(sourceName);
-    const file = new SourceFile(
-      sourceName,
-      compilerInput.sources[sourceName].content
-    );
-
-    fileIdToSourceFile.set(source.id, file);
-
-    for (const node of source.ast.nodes) {
-      if (node.nodeType === "ContractDefinition") {
-        const contractType = contractKindToContractType(node.contractKind);
-
-        if (contractType === undefined) {
-          continue;
-        }
-
-        const contractAbi = contractToAbi?.get(node.name);
-
-        processContractAstNode(
-          file,
-          node,
-          fileIdToSourceFile,
-          contractType,
-          contractIdToContract,
-          contractIdToLinearizedBaseContractIds,
-          contractAbi
-        );
-      }
-
-      // top-level functions
-      if (node.nodeType === "FunctionDefinition") {
-        processFunctionDefinitionAstNode(
-          node,
-          fileIdToSourceFile,
-          undefined,
-          file
-        );
-      }
-    }
-  }
-
-  applyContractsInheritance(
-    contractIdToContract,
-    contractIdToLinearizedBaseContractIds
-  );
-}
-
-function processContractAstNode(
-  file: SourceFile,
-  contractNode: any,
-  fileIdToSourceFile: Map<number, SourceFile>,
-  contractType: ContractType,
-  contractIdToContract: Map<number, Contract>,
-  contractIdToLinearizedBaseContractIds: Map<number, number[]>,
-  contractAbi?: ContractAbi
-) {
-  const contractLocation = astSrcToSourceLocation(
-    contractNode.src,
-    fileIdToSourceFile
-  )!;
-
-  const contract = new Contract(
-    contractNode.name,
-    contractType,
-    contractLocation
-  );
-
-  contractIdToContract.set(contractNode.id, contract);
-  contractIdToLinearizedBaseContractIds.set(
-    contractNode.id,
-    contractNode.linearizedBaseContracts
-  );
-
-  file.addContract(contract);
-
-  for (const node of contractNode.nodes) {
-    if (node.nodeType === "FunctionDefinition") {
-      const functionAbis = contractAbi?.filter(
-        (abiEntry) => abiEntry.name === node.name
-      );
-
-      processFunctionDefinitionAstNode(
-        node,
-        fileIdToSourceFile,
-        contract,
-        file,
-        functionAbis
-      );
-    } else if (node.nodeType === "ModifierDefinition") {
-      processModifierDefinitionAstNode(
-        node,
-        fileIdToSourceFile,
-        contract,
-        file
-      );
-    } else if (node.nodeType === "VariableDeclaration") {
-      const getterAbi = contractAbi?.find(
-        (abiEntry) => abiEntry.name === node.name
-      );
-      processVariableDeclarationAstNode(
-        node,
-        fileIdToSourceFile,
-        contract,
-        file,
-        getterAbi
-      );
-    }
-  }
-}
-
-function processFunctionDefinitionAstNode(
-  functionDefinitionNode: any,
-  fileIdToSourceFile: Map<number, SourceFile>,
-  contract: Contract | undefined,
-  file: SourceFile,
-  functionAbis?: ContractAbiEntry[]
-) {
-  if (functionDefinitionNode.implemented === false) {
-    return;
-  }
-
-  const functionType = functionDefinitionKindToFunctionType(
-    functionDefinitionNode.kind
-  );
-  const functionLocation = astSrcToSourceLocation(
-    functionDefinitionNode.src,
-    fileIdToSourceFile
-  )!;
-  const visibility = astVisibilityToVisibility(
-    functionDefinitionNode.visibility
-  );
-
-  let selector: Buffer | undefined;
-  if (
-    functionType === ContractFunctionType.FUNCTION &&
-    (visibility === ContractFunctionVisibility.EXTERNAL ||
-      visibility === ContractFunctionVisibility.PUBLIC)
-  ) {
-    selector = astFunctionDefinitionToSelector(functionDefinitionNode);
-  }
-
-  // function can be overloaded, match the abi by the selector
-  const matchingFunctionAbi = functionAbis?.find((functionAbi) => {
-    if (functionAbi.name === undefined) {
-      return false;
-    }
-
-    const functionAbiSelector = abi.methodID(
-      functionAbi.name,
-      functionAbi.inputs?.map((input) => input.type) ?? []
-    );
-
-    if (selector === undefined || functionAbiSelector === undefined) {
-      return false;
-    }
-
-    return selector.equals(functionAbiSelector);
-  });
-
-  const paramTypes = matchingFunctionAbi?.inputs?.map((input) => input.type);
-
-  const cf = new ContractFunction(
-    functionDefinitionNode.name,
-    functionType,
-    functionLocation,
-    contract,
-    visibility,
-    functionDefinitionNode.stateMutability === "payable",
-    selector,
-    paramTypes
-  );
-
-  if (contract !== undefined) {
-    contract.addLocalFunction(cf);
-  }
-
-  file.addFunction(cf);
-}
-
-function processModifierDefinitionAstNode(
-  modifierDefinitionNode: any,
-  fileIdToSourceFile: Map<number, SourceFile>,
-  contract: Contract,
-  file: SourceFile
-) {
-  const functionLocation = astSrcToSourceLocation(
-    modifierDefinitionNode.src,
-    fileIdToSourceFile
-  )!;
-
-  const cf = new ContractFunction(
-    modifierDefinitionNode.name,
-    ContractFunctionType.MODIFIER,
-    functionLocation,
-    contract
-  );
-
-  contract.addLocalFunction(cf);
-  file.addFunction(cf);
-}
-
-function canonicalAbiTypeForElementaryOrUserDefinedTypes(keyType: any): any {
-  if (isElementaryType(keyType)) {
-    return toCanonicalAbiType(keyType.name);
-  }
-
-  if (isEnumType(keyType)) {
-    return "uint256";
-  }
-
-  if (isContractType(keyType)) {
-    return "address";
-  }
-
-  return undefined;
-}
-
-function getPublicVariableSelectorFromDeclarationAstNode(
-  variableDeclaration: any
-) {
-  if (variableDeclaration.functionSelector !== undefined) {
-    return Buffer.from(variableDeclaration.functionSelector, "hex");
-  }
-
-  const paramTypes: string[] = [];
-
-  // VariableDeclaration nodes for function parameters or state variables will always
-  // have their typeName fields defined.
-  let nextType = variableDeclaration.typeName;
-  while (true) {
-    if (nextType.nodeType === "Mapping") {
-      const canonicalType = canonicalAbiTypeForElementaryOrUserDefinedTypes(
-        nextType.keyType
-      );
-      paramTypes.push(canonicalType);
-
-      nextType = nextType.valueType;
-    } else {
-      if (nextType.nodeType === "ArrayTypeName") {
-        paramTypes.push("uint256");
-      }
-
-      break;
-    }
-  }
-
-  return abi.methodID(variableDeclaration.name, paramTypes);
-}
-
-function processVariableDeclarationAstNode(
-  variableDeclarationNode: any,
-  fileIdToSourceFile: Map<number, SourceFile>,
-  contract: Contract,
-  file: SourceFile,
-  getterAbi?: ContractAbiEntry
-) {
-  const visibility = astVisibilityToVisibility(
-    variableDeclarationNode.visibility
-  );
-
-  // Variables can't be external
-  if (visibility !== ContractFunctionVisibility.PUBLIC) {
-    return;
-  }
-
-  const functionLocation = astSrcToSourceLocation(
-    variableDeclarationNode.src,
-    fileIdToSourceFile
-  )!;
-
-  const paramTypes = getterAbi?.inputs?.map((input) => input.type);
-
-  const cf = new ContractFunction(
-    variableDeclarationNode.name,
-    ContractFunctionType.GETTER,
-    functionLocation,
-    contract,
-    visibility,
-    false, // Getters aren't payable
-    getPublicVariableSelectorFromDeclarationAstNode(variableDeclarationNode),
-    paramTypes
-  );
-
-  contract.addLocalFunction(cf);
-  file.addFunction(cf);
-}
-
-function applyContractsInheritance(
-  contractIdToContract: Map<number, Contract>,
-  contractIdToLinearizedBaseContractIds: Map<number, number[]>
-) {
-  for (const [cid, contract] of contractIdToContract.entries()) {
-    const inheritanceIds = contractIdToLinearizedBaseContractIds.get(cid)!;
-
-    for (const baseId of inheritanceIds) {
-      const baseContract = contractIdToContract.get(baseId);
-
-      if (baseContract === undefined) {
-        // This list includes interface, which we don't model
-        continue;
-      }
-
-      contract.addNextLinearizedBaseContract(baseContract);
-    }
-  }
-}
-
-function decodeBytecodes(
-  solcVersion: string,
-  compilerOutput: CompilerOutput,
-  fileIdToSourceFile: Map<number, SourceFile>,
-  contractIdToContract: Map<number, Contract>
-): Bytecode[] {
-  const bytecodes: Bytecode[] = [];
-
-  for (const contract of contractIdToContract.values()) {
-    const contractFile = contract.location.file.sourceName;
-    const contractEvmOutput =
-      compilerOutput.contracts[contractFile][contract.name].evm;
-    const contractAbiOutput =
-      compilerOutput.contracts[contractFile][contract.name].abi;
-
-    for (const abiItem of contractAbiOutput) {
-      if (abiItem.type === "error") {
-        const customError = CustomError.fromABI(abiItem.name, abiItem.inputs);
-
-        if (customError !== undefined) {
-          contract.addCustomError(customError);
-        } else {
-          log(`Couldn't build CustomError for error '${abiItem.name}'`);
-        }
-      }
-    }
-
-    // This is an abstract contract
-    if (contractEvmOutput.bytecode.object === "") {
-      continue;
-    }
-
-    const deploymentBytecode = decodeEvmBytecode(
-      contract,
-      solcVersion,
-      true,
-      contractEvmOutput.bytecode,
-      fileIdToSourceFile
-    );
-
-    const runtimeBytecode = decodeEvmBytecode(
-      contract,
-      solcVersion,
-      false,
-      contractEvmOutput.deployedBytecode,
-      fileIdToSourceFile
-    );
-
-    bytecodes.push(deploymentBytecode);
-    bytecodes.push(runtimeBytecode);
-  }
-
-  return bytecodes;
-}
-
-function decodeEvmBytecode(
-  contract: Contract,
-  solcVersion: string,
-  isDeployment: boolean,
-  compilerBytecode: CompilerOutputBytecode,
-  fileIdToSourceFile: Map<number, SourceFile>
-): Bytecode {
-  const libraryAddressPositions = getLibraryAddressPositions(compilerBytecode);
-
-  const immutableReferences =
-    compilerBytecode.immutableReferences !== undefined
-      ? Object.values(compilerBytecode.immutableReferences).reduce(
-          (previousValue, currentValue) => [...previousValue, ...currentValue],
-          []
-        )
-      : [];
-
-  const normalizedCode = normalizeCompilerOutputBytecode(
-    compilerBytecode.object,
-    libraryAddressPositions
-  );
-
-  const instructions = decodeInstructions(
-    normalizedCode,
-    compilerBytecode.sourceMap,
-    fileIdToSourceFile,
-    isDeployment
-  );
-
-  return new Bytecode(
-    contract,
-    isDeployment,
-    normalizedCode,
-    instructions,
-    libraryAddressPositions,
-    immutableReferences,
-    solcVersion
-  );
-}
-
-function astSrcToSourceLocation(
-  src: string,
-  fileIdToSourceFile: Map<number, SourceFile>
-): SourceLocation | undefined {
-  const [offset, length, fileId] = src.split(":").map((p) => +p);
-  const file = fileIdToSourceFile.get(fileId);
-
-  if (file === undefined) {
-    return undefined;
-  }
-
-  return new SourceLocation(file, offset, length);
-}
-
-function contractKindToContractType(
-  contractKind?: string
-): ContractType | undefined {
-  if (contractKind === "library") {
-    return ContractType.LIBRARY;
-  }
-
-  if (contractKind === "contract") {
-    return ContractType.CONTRACT;
-  }
-
-  return undefined;
-}
-
-function astVisibilityToVisibility(
-  visibility: string
-): ContractFunctionVisibility {
-  if (visibility === "private") {
-    return ContractFunctionVisibility.PRIVATE;
-  }
-
-  if (visibility === "internal") {
-    return ContractFunctionVisibility.INTERNAL;
-  }
-
-  if (visibility === "public") {
-    return ContractFunctionVisibility.PUBLIC;
-  }
-
-  return ContractFunctionVisibility.EXTERNAL;
-}
-
-function functionDefinitionKindToFunctionType(
-  kind: string | undefined
-): ContractFunctionType {
-  if (kind === "constructor") {
-    return ContractFunctionType.CONSTRUCTOR;
-  }
-
-  if (kind === "fallback") {
-    return ContractFunctionType.FALLBACK;
-  }
-
-  if (kind === "receive") {
-    return ContractFunctionType.RECEIVE;
-  }
-
-  if (kind === "freeFunction") {
-    return ContractFunctionType.FREE_FUNCTION;
-  }
-
-  return ContractFunctionType.FUNCTION;
-}
-
-function astFunctionDefinitionToSelector(functionDefinition: any): Buffer {
-  const paramTypes: string[] = [];
-
-  // The function selector is available in solc versions >=0.6.0
-  if (functionDefinition.functionSelector !== undefined) {
-    return Buffer.from(functionDefinition.functionSelector, "hex");
-  }
-
-  for (const param of functionDefinition.parameters.parameters) {
-    if (isContractType(param)) {
-      paramTypes.push("address");
-      continue;
-    }
-
-    // TODO: implement ABIv2 structs parsing
-    // This might mean we need to parse struct definitions before
-    // resolving types and trying to calculate function selectors.
-    // if (isStructType(param)) {
-    //   paramTypes.push(something);
-    //   continue;
-    // }
-
-    if (isEnumType(param)) {
-      // TODO: If the enum has >= 256 elements this will fail. It should be a uint16. This is
-      //  complicated, as enums can be inherited. Fortunately, if multiple parent contracts
-      //  define the same enum, solc fails to compile.
-      paramTypes.push("uint8");
-      continue;
-    }
-
-    // The rest of the function parameters always have their typeName node defined
-    const typename = param.typeName;
-    if (
-      typename.nodeType === "ArrayTypeName" ||
-      typename.nodeType === "FunctionTypeName" ||
-      typename.nodeType === "Mapping"
-    ) {
-      paramTypes.push(typename.typeDescriptions.typeString);
-      continue;
-    }
-
-    paramTypes.push(toCanonicalAbiType(typename.name));
-  }
-
-  return abi.methodID(functionDefinition.name, paramTypes);
-}
-
-function isContractType(param: any): boolean {
-  return (
-    (param.typeName?.nodeType === "UserDefinedTypeName" ||
-      param?.nodeType === "UserDefinedTypeName") &&
-    param.typeDescriptions?.typeString !== undefined &&
-    param.typeDescriptions.typeString.startsWith("contract ")
-  );
-}
-
-function isEnumType(param: any): boolean {
-  return (
-    (param.typeName?.nodeType === "UserDefinedTypeName" ||
-      param?.nodeType === "UserDefinedTypeName") &&
-    param.typeDescriptions?.typeString !== undefined &&
-    param.typeDescriptions.typeString.startsWith("enum ")
-  );
-}
-
-function isElementaryType(param: any) {
-  return (
-    param.type === "ElementaryTypeName" ||
-    param.nodeType === "ElementaryTypeName"
-  );
-}
-
-function toCanonicalAbiType(type: string): string {
-  if (type.startsWith("int[")) {
-    return `int256${type.slice(3)}`;
-  }
-
-  if (type === "int") {
-    return "int256";
-  }
-
-  if (type.startsWith("uint[")) {
-    return `uint256${type.slice(4)}`;
-  }
-
-  if (type === "uint") {
-    return "uint256";
-  }
-
-  if (type.startsWith("fixed[")) {
-    return `fixed128x128${type.slice(5)}`;
-  }
-
-  if (type === "fixed") {
-    return "fixed128x128";
-  }
-
-  if (type.startsWith("ufixed[")) {
-    return `ufixed128x128${type.slice(6)}`;
-  }
-
-  if (type === "ufixed") {
-    return "ufixed128x128";
-  }
-
-  return type;
-}
-
-function correctSelectors(
-  bytecodes: Bytecode[],
-  compilerOutput: CompilerOutput
-) {
-  for (const bytecode of bytecodes) {
-    if (bytecode.isDeployment) {
-      continue;
-    }
-
-    const contract = bytecode.contract;
-    const methodIdentifiers =
-      compilerOutput.contracts[contract.location.file.sourceName][contract.name]
-        .evm.methodIdentifiers;
-
-    for (const [signature, hexSelector] of Object.entries(methodIdentifiers)) {
-      const functionName = signature.slice(0, signature.indexOf("("));
-      const selector = Buffer.from(hexSelector, "hex");
-
-      const contractFunction = contract.getFunctionFromSelector(selector);
-
-      if (contractFunction !== undefined) {
-        continue;
-      }
-
-      const fixedSelector = contract.correctSelector(functionName, selector);
-
-      if (!fixedSelector) {
-        // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
-        throw new Error(
-          `Failed to compute the selector one or more implementations of ${contract.name}#${functionName}. Hardhat Network can automatically fix this problem if you don't use function overloading.`
-        );
-      }
-    }
-  }
-}
+export { createModelsAndDecodeBytecodes };