hardhat 2.13.0-dev.2 → 2.13.0-dev.3

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

@@ -58,6 +58,30 @@ const PRIVATE_RPC_METHODS = new Set([
 
 export const DEFAULT_COINBASE = "0xc014ba5ec014ba5ec014ba5ec014ba5ec014ba5e";
 
+interface HardhatNetworkProviderConfig {
+  hardfork: string;
+  chainId: number;
+  networkId: number;
+  blockGasLimit: number;
+  minGasPrice: bigint;
+  automine: boolean;
+  intervalMining: IntervalMiningConfig;
+  mempoolOrder: MempoolOrder;
+  chains: HardhatNetworkChainsConfig;
+  genesisAccounts: GenesisAccount[];
+  allowUnlimitedContractSize: boolean;
+  throwOnTransactionFailures: boolean;
+  throwOnCallFailures: boolean;
+  allowBlocksWithSameTimestamp: boolean;
+
+  initialBaseFeePerGas?: number;
+  initialDate?: Date;
+  coinbase?: string;
+  experimentalHardhatNetworkMessageTraceHooks?: BoundExperimentalHardhatNetworkMessageTraceHook[];
+  forkConfig?: ForkConfig;
+  forkCachePath?: string;
+}
+
 export class HardhatNetworkProvider
   extends EventEmitter
   implements EIP1193Provider
@@ -75,28 +99,9 @@ export class HardhatNetworkProvider
   private _common?: Common;
 
   constructor(
-    private readonly _hardfork: string,
-    private readonly _networkName: string,
-    private readonly _chainId: number,
-    private readonly _networkId: number,
-    private readonly _blockGasLimit: number,
-    private readonly _initialBaseFeePerGas: number | undefined,
-    private readonly _minGasPrice: bigint,
-    private readonly _throwOnTransactionFailures: boolean,
-    private readonly _throwOnCallFailures: boolean,
-    private readonly _automine: boolean,
-    private readonly _intervalMining: IntervalMiningConfig,
-    private readonly _mempoolOrder: MempoolOrder,
-    private readonly _chains: HardhatNetworkChainsConfig,
+    private readonly _config: HardhatNetworkProviderConfig,
     private readonly _logger: ModulesLogger,
-    private readonly _genesisAccounts: GenesisAccount[] = [],
-    private readonly _artifacts?: Artifacts,
-    private readonly _allowUnlimitedContractSize = false,
-    private readonly _initialDate?: Date,
-    private readonly _experimentalHardhatNetworkMessageTraceHooks: BoundExperimentalHardhatNetworkMessageTraceHook[] = [],
-    private _forkConfig?: ForkConfig,
-    private readonly _forkCachePath?: string,
-    private readonly _coinbase = DEFAULT_COINBASE
+    private readonly _artifacts?: Artifacts
   ) {
     super();
   }
@@ -228,24 +233,26 @@ export class HardhatNetworkProvider
     }
 
     const config: NodeConfig = {
-      automine: this._automine,
-      blockGasLimit: this._blockGasLimit,
-      minGasPrice: this._minGasPrice,
-      genesisAccounts: this._genesisAccounts,
-      allowUnlimitedContractSize: this._allowUnlimitedContractSize,
+      automine: this._config.automine,
+      blockGasLimit: this._config.blockGasLimit,
+      minGasPrice: this._config.minGasPrice,
+      genesisAccounts: this._config.genesisAccounts,
+      allowUnlimitedContractSize: this._config.allowUnlimitedContractSize,
       tracingConfig: await this._makeTracingConfig(),
-      initialBaseFeePerGas: this._initialBaseFeePerGas,
-      mempoolOrder: this._mempoolOrder,
-      hardfork: this._hardfork,
-      networkName: this._networkName,
-      chainId: this._chainId,
-      networkId: this._networkId,
-      initialDate: this._initialDate,
-      forkConfig: this._forkConfig,
+      initialBaseFeePerGas: this._config.initialBaseFeePerGas,
+      mempoolOrder: this._config.mempoolOrder,
+      hardfork: this._config.hardfork,
+      chainId: this._config.chainId,
+      networkId: this._config.networkId,
+      initialDate: this._config.initialDate,
+      forkConfig: this._config.forkConfig,
       forkCachePath:
-        this._forkConfig !== undefined ? this._forkCachePath : undefined,
-      coinbase: this._coinbase,
-      chains: this._chains,
+        this._config.forkConfig !== undefined
+          ? this._config.forkCachePath
+          : undefined,
+      coinbase: this._config.coinbase ?? DEFAULT_COINBASE,
+      chains: this._config.chains,
+      allowBlocksWithSameTimestamp: this._config.allowBlocksWithSameTimestamp,
     };
 
     const [common, node] = await HardhatNode.create(config);
@@ -256,10 +263,10 @@ export class HardhatNetworkProvider
     this._ethModule = new EthModule(
       common,
       node,
-      this._throwOnTransactionFailures,
-      this._throwOnCallFailures,
+      this._config.throwOnTransactionFailures,
+      this._config.throwOnCallFailures,
       this._logger,
-      this._experimentalHardhatNetworkMessageTraceHooks
+      this._config.experimentalHardhatNetworkMessageTraceHooks
     );
 
     const miningTimer = this._makeMiningTimer();
@@ -270,7 +277,8 @@ export class HardhatNetworkProvider
       node,
       miningTimer,
       this._logger,
-      this._experimentalHardhatNetworkMessageTraceHooks
+      this._config.allowBlocksWithSameTimestamp,
+      this._config.experimentalHardhatNetworkMessageTraceHooks
     );
     this._hardhatModule = new HardhatModule(
       node,
@@ -279,7 +287,7 @@ export class HardhatNetworkProvider
         this._logger.setEnabled(loggingEnabled);
       },
       this._logger,
-      this._experimentalHardhatNetworkMessageTraceHooks
+      this._config.experimentalHardhatNetworkMessageTraceHooks
     );
     this._debugModule = new DebugModule(node);
     this._personalModule = new PersonalModule(node);
@@ -320,13 +328,16 @@ export class HardhatNetworkProvider
   }
 
   private _makeMiningTimer(): MiningTimer {
-    const miningTimer = new MiningTimer(this._intervalMining, async () => {
-      try {
-        await this.request({ method: "hardhat_intervalMine" });
-      } catch (e) {
-        console.error("Unexpected error calling hardhat_intervalMine:", e);
+    const miningTimer = new MiningTimer(
+      this._config.intervalMining,
+      async () => {
+        try {
+          await this.request({ method: "hardhat_intervalMine" });
+        } catch (e) {
+          console.error("Unexpected error calling hardhat_intervalMine:", e);
+        }
       }
-    });
+    );
 
     miningTimer.start();
 
@@ -334,7 +345,7 @@ export class HardhatNetworkProvider
   }
 
   private async _reset(miningTimer: MiningTimer, forkConfig?: ForkConfig) {
-    this._forkConfig = forkConfig;
+    this._config.forkConfig = forkConfig;
     if (this._node !== undefined) {
       this._stopForwardingNodeEvents(this._node);
     }

package/src/internal/hardhat-network/provider/return-data.ts

@@ -1,7 +1,7 @@
-import { rawDecode } from "ethereumjs-abi";
-
 import { assertHardhatInvariant } from "../../core/errors";
 
+const { rawDecode } = require("ethereumjs-abi");
+
 // selector of Error(string)
 const ERROR_SELECTOR = "08c379a0";
 // selector of Panic(uint256)

package/src/internal/hardhat-network/provider/transactions/FakeSenderAccessListEIP2930Transaction.ts

@@ -16,6 +16,7 @@ import {
   InternalError,
   InvalidArgumentsError,
 } from "../../../core/providers/errors";
+import { makeFakeSignature } from "../utils/makeFakeSignature";
 
 /* eslint-disable @nomiclabs/hardhat-internal-rules/only-hardhat-error */
 
@@ -124,12 +125,14 @@ export class FakeSenderAccessListEIP2930Transaction extends AccessListEIP2930Tra
     data: AccessListEIP2930TxData = {},
     opts?: TxOptions
   ) {
+    const fakeSignature = makeFakeSignature(data, sender);
+
     super(
       {
         ...data,
         v: data.v ?? 1,
-        r: data.r ?? 1,
-        s: data.s ?? 2,
+        r: data.r ?? fakeSignature.r,
+        s: data.s ?? fakeSignature.s,
       },
       { ...opts, freeze: false }
     );

package/src/internal/hardhat-network/provider/transactions/FakeSenderEIP1559Transaction.ts

@@ -15,6 +15,7 @@ import {
   InternalError,
   InvalidArgumentsError,
 } from "../../../core/providers/errors";
+import { makeFakeSignature } from "../utils/makeFakeSignature";
 
 /* eslint-disable @nomiclabs/hardhat-internal-rules/only-hardhat-error */
 
@@ -123,12 +124,14 @@ export class FakeSenderEIP1559Transaction extends FeeMarketEIP1559Transaction {
     data: FeeMarketEIP1559TxData = {},
     opts?: TxOptions
   ) {
+    const fakeSignature = makeFakeSignature(data, sender);
+
     super(
       {
         ...data,
         v: data.v ?? 1,
-        r: data.r ?? 1,
-        s: data.s ?? 2,
+        r: data.r ?? fakeSignature.r,
+        s: data.s ?? fakeSignature.s,
       },
       { ...opts, freeze: false }
     );

package/src/internal/hardhat-network/provider/transactions/FakeSenderTransaction.ts

@@ -7,6 +7,7 @@ import {
   InternalError,
   InvalidArgumentsError,
 } from "../../../core/providers/errors";
+import { makeFakeSignature } from "../utils/makeFakeSignature";
 
 /* eslint-disable @nomiclabs/hardhat-internal-rules/only-hardhat-error */
 
@@ -97,12 +98,14 @@ export class FakeSenderTransaction extends Transaction {
   private readonly _sender: Address;
 
   constructor(sender: Address, data: TxData = {}, opts?: TxOptions) {
+    const fakeSignature = makeFakeSignature(data, sender);
+
     super(
       {
         ...data,
         v: data.v ?? 27,
-        r: data.r ?? 1,
-        s: data.s ?? 2,
+        r: data.r ?? fakeSignature.r,
+        s: data.s ?? fakeSignature.s,
       },
       { ...opts, freeze: false }
     );

package/src/internal/hardhat-network/provider/utils/makeFakeSignature.ts

@@ -0,0 +1,46 @@
+import {
+  AccessListEIP2930Transaction,
+  FeeMarketEIP1559Transaction,
+  TxData,
+} from "@nomicfoundation/ethereumjs-tx";
+import { Address } from "@nomicfoundation/ethereumjs-util";
+
+import { createNonCryptographicHashBasedIdentifier } from "../../../util/hash";
+
+// Produces a signature with r and s values taken from a hash of the inputs.
+export function makeFakeSignature(
+  tx: TxData | AccessListEIP2930Transaction | FeeMarketEIP1559Transaction,
+  sender: Address
+): {
+  r: number;
+  s: number;
+} {
+  const hashInputString = [
+    sender,
+    tx.nonce,
+    tx.gasLimit,
+    tx.value,
+    tx.to,
+    tx.data,
+    "gasPrice" in tx ? tx.gasPrice : "",
+    "chainId" in tx ? tx.chainId : "",
+    "maxPriorityFeePerGas" in tx ? tx.maxPriorityFeePerGas : "",
+    "maxFeePerGas" in tx ? tx.maxFeePerGas : "",
+    "accessList" in tx
+      ? tx.accessList?.map(([buf, bufs]) =>
+          [buf, ...bufs].map((b) => b.toString("hex")).join(";")
+        )
+      : "",
+  ]
+    .map((a) => a?.toString() ?? "")
+    .join(",");
+
+  const hashDigest = createNonCryptographicHashBasedIdentifier(
+    Buffer.from(hashInputString)
+  );
+
+  return {
+    r: hashDigest.readUInt32LE(),
+    s: hashDigest.readUInt32LE(4),
+  };
+}

package/src/internal/hardhat-network/provider/utils/putGenesisBlock.ts

@@ -12,7 +12,7 @@ import { getCurrentTimestamp } from "./getCurrentTimestamp";
 export async function putGenesisBlock(
   blockchain: HardhatBlockchain,
   common: Common,
-  { initialDate, blockGasLimit }: LocalNodeConfig,
+  { initialDate, blockGasLimit: initialBlockGasLimit }: LocalNodeConfig,
   stateTrie: Trie,
   hardfork: HardforkName,
   initialMixHash: Buffer,
@@ -27,7 +27,7 @@ export async function putGenesisBlock(
 
   const header: HeaderData = {
     timestamp: `0x${initialBlockTimestamp.toString(16)}`,
-    gasLimit: blockGasLimit,
+    gasLimit: initialBlockGasLimit,
     difficulty: isPostMerge ? 0 : 1,
     nonce: isPostMerge ? "0x0000000000000000" : "0x0000000000000042",
     extraData: "0x1234",

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

@@ -1,5 +1,4 @@
 import debug from "debug";
-import abi from "ethereumjs-abi";
 
 import {
   CompilerInput,
@@ -24,8 +23,19 @@ import {
 } 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,
@@ -61,7 +71,20 @@ function createSourcesModelFromAst(
 ) {
   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
@@ -77,13 +100,16 @@ function createSourcesModelFromAst(
           continue;
         }
 
+        const contractAbi = contractToAbi?.get(node.name);
+
         processContractAstNode(
           file,
           node,
           fileIdToSourceFile,
           contractType,
           contractIdToContract,
-          contractIdToLinearizedBaseContractIds
+          contractIdToLinearizedBaseContractIds,
+          contractAbi
         );
       }
 
@@ -111,7 +137,8 @@ function processContractAstNode(
   fileIdToSourceFile: Map<number, SourceFile>,
   contractType: ContractType,
   contractIdToContract: Map<number, Contract>,
-  contractIdToLinearizedBaseContractIds: Map<number, number[]>
+  contractIdToLinearizedBaseContractIds: Map<number, number[]>,
+  contractAbi?: ContractAbi
 ) {
   const contractLocation = astSrcToSourceLocation(
     contractNode.src,
@@ -134,11 +161,16 @@ function processContractAstNode(
 
   for (const node of contractNode.nodes) {
     if (node.nodeType === "FunctionDefinition") {
+      const functionAbis = contractAbi?.filter(
+        (abiEntry) => abiEntry.name === node.name
+      );
+
       processFunctionDefinitionAstNode(
         node,
         fileIdToSourceFile,
         contract,
-        file
+        file,
+        functionAbis
       );
     } else if (node.nodeType === "ModifierDefinition") {
       processModifierDefinitionAstNode(
@@ -148,11 +180,15 @@ function processContractAstNode(
         file
       );
     } else if (node.nodeType === "VariableDeclaration") {
+      const getterAbi = contractAbi?.find(
+        (abiEntry) => abiEntry.name === node.name
+      );
       processVariableDeclarationAstNode(
         node,
         fileIdToSourceFile,
         contract,
-        file
+        file,
+        getterAbi
       );
     }
   }
@@ -162,7 +198,8 @@ function processFunctionDefinitionAstNode(
   functionDefinitionNode: any,
   fileIdToSourceFile: Map<number, SourceFile>,
   contract: Contract | undefined,
-  file: SourceFile
+  file: SourceFile,
+  functionAbis?: ContractAbiEntry[]
 ) {
   if (functionDefinitionNode.implemented === false) {
     return;
@@ -188,6 +225,26 @@ function processFunctionDefinitionAstNode(
     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,
@@ -195,7 +252,8 @@ function processFunctionDefinitionAstNode(
     contract,
     visibility,
     functionDefinitionNode.stateMutability === "payable",
-    selector
+    selector,
+    paramTypes
   );
 
   if (contract !== undefined) {
@@ -279,7 +337,8 @@ function processVariableDeclarationAstNode(
   variableDeclarationNode: any,
   fileIdToSourceFile: Map<number, SourceFile>,
   contract: Contract,
-  file: SourceFile
+  file: SourceFile,
+  getterAbi?: ContractAbiEntry
 ) {
   const visibility = astVisibilityToVisibility(
     variableDeclarationNode.visibility
@@ -295,6 +354,8 @@ function processVariableDeclarationAstNode(
     fileIdToSourceFile
   )!;
 
+  const paramTypes = getterAbi?.inputs?.map((input) => input.type);
+
   const cf = new ContractFunction(
     variableDeclarationNode.name,
     ContractFunctionType.GETTER,
@@ -302,7 +363,8 @@ function processVariableDeclarationAstNode(
     contract,
     visibility,
     false, // Getters aren't payable
-    getPublicVariableSelectorFromDeclarationAstNode(variableDeclarationNode)
+    getPublicVariableSelectorFromDeclarationAstNode(variableDeclarationNode),
+    paramTypes
   );
 
   contract.addLocalFunction(cf);

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

@@ -139,7 +139,7 @@ export class ConsoleLogger {
 
   private _decode(data: Buffer, types: string[]): ConsoleLogs {
     return types.map((type, i) => {
-      const position = i * 32;
+      const position: number = i * 32;
       switch (types[i]) {
         case Uint256Ty:
           return bufferToBigInt(

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

@@ -1,2 +1,2 @@
-export const SUPPORTED_SOLIDITY_VERSION_RANGE = "<=0.8.17";
+export const SUPPORTED_SOLIDITY_VERSION_RANGE = "<=0.8.18";
 export const FIRST_SOLC_VERSION_SUPPORTED = "0.5.1";

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

@@ -1,4 +1,5 @@
 import { bufferToHex } from "@nomicfoundation/ethereumjs-util";
+import chalk from "chalk";
 
 import {
   CallMessageTrace,
@@ -146,7 +147,7 @@ function traceSteps(
         if (isJump(inst.opcode)) {
           const jump =
             inst.jumpType !== JumpType.NOT_JUMP
-              ? `\x1b[1m(${JumpType[inst.jumpType]})\x1b[0m`
+              ? chalk.bold(`(${JumpType[inst.jumpType]})`)
               : "";
 
           console.log(
@@ -209,5 +210,11 @@ export function printStackTrace(trace: SolidityStackTrace) {
     sourceReference: flattenSourceReference(entry.sourceReference),
   }));
 
-  console.log(JSON.stringify(withFlattenedSourceReferences, undefined, 2));
+  console.log(
+    JSON.stringify(
+      withFlattenedSourceReferences,
+      (key, value) => (typeof value === "bigint" ? value.toString() : value),
+      2
+    )
+  );
 }