hardhat 2.17.3 → 2.17.4

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

@@ -1,4 +1,12 @@
 import { rpcHash } from "../../../core/jsonrpc/types/base-types";
+import {
+  OptionalRpcNewBlockTag,
+  optionalRpcNewBlockTag,
+} from "../../../core/jsonrpc/types/input/blockTag";
+import {
+  RpcCallRequest,
+  rpcCallRequest,
+} from "../../../core/jsonrpc/types/input/callRequest";
 import {
   rpcDebugTracingConfig,
   RpcDebugTracingConfig,
@@ -10,17 +18,22 @@ import {
 } from "../../../core/providers/errors";
 import { HardhatNode } from "../node";
 import { RpcDebugTraceOutput } from "../output";
+import { Base } from "./base";
 
 /* eslint-disable @nomicfoundation/hardhat-internal-rules/only-hardhat-error */
 
-export class DebugModule {
-  constructor(private readonly _node: HardhatNode) {}
+export class DebugModule extends Base {
+  constructor(_node: HardhatNode) {
+    super(_node);
+  }
 
   public async processRequest(
     method: string,
     params: any[] = []
   ): Promise<any> {
     switch (method) {
+      case "debug_traceCall":
+        return this._traceCallAction(...this._traceCallParams(params));
       case "debug_traceTransaction":
         return this._traceTransactionAction(
           ...this._traceTransactionParams(params)
@@ -30,6 +43,34 @@ export class DebugModule {
     throw new MethodNotFoundError(`Method ${method} not found`);
   }
 
+  // debug_traceCall
+
+  private _traceCallParams(
+    params: any[]
+  ): [RpcCallRequest, OptionalRpcNewBlockTag, RpcDebugTracingConfig] {
+    const validatedParams = validateParams(
+      params,
+      rpcCallRequest,
+      optionalRpcNewBlockTag,
+      rpcDebugTracingConfig
+    );
+
+    this._validateTracerParam(validatedParams[2]);
+
+    return validatedParams;
+  }
+
+  private async _traceCallAction(
+    callConfig: RpcCallRequest,
+    block: OptionalRpcNewBlockTag,
+    traceConfig: RpcDebugTracingConfig
+  ): Promise<RpcDebugTraceOutput> {
+    const callParams = await this.rpcCallRequestToNodeCallParams(callConfig);
+    const blockNumber = await this.resolveNewBlockTag(block);
+
+    return this._node.traceCall(callParams, blockNumber, traceConfig);
+  }
+
   // debug_traceTransaction
 
   private _traceTransactionParams(
@@ -46,6 +87,13 @@ export class DebugModule {
     return validatedParams;
   }
 
+  private async _traceTransactionAction(
+    hash: Buffer,
+    config: RpcDebugTracingConfig
+  ): Promise<RpcDebugTraceOutput> {
+    return this._node.traceTransaction(hash, config);
+  }
+
   private _validateTracerParam(config: RpcDebugTracingConfig) {
     if (config?.tracer !== undefined) {
       throw new InvalidArgumentsError(
@@ -53,11 +101,4 @@ export class DebugModule {
       );
     }
   }
-
-  private async _traceTransactionAction(
-    hash: Buffer,
-    config: RpcDebugTracingConfig
-  ): Promise<RpcDebugTraceOutput> {
-    return this._node.traceTransaction(hash, config);
-  }
 }

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

@@ -5,18 +5,10 @@ import {
   TransactionFactory,
   TypedTransaction,
 } from "@nomicfoundation/ethereumjs-tx";
-import {
-  Address,
-  bufferToHex,
-  toBuffer,
-  toRpcSig,
-  zeroAddress,
-} from "@nomicfoundation/ethereumjs-util";
+import { Address, toBuffer, toRpcSig } from "@nomicfoundation/ethereumjs-util";
 import * as t from "io-ts";
 import cloneDeep from "lodash/cloneDeep";
-
 import { BoundExperimentalHardhatNetworkMessageTraceHook } from "../../../../types";
-import { RpcAccessList } from "../../../core/jsonrpc/types/access-list";
 import {
   bufferToRpcData,
   numberToRpcQuantity,
@@ -69,7 +61,6 @@ import { MessageTrace } from "../../stack-traces/message-trace";
 import { LATEST_BLOCK } from "../filter";
 import { HardhatNode } from "../node";
 import {
-  CallParams,
   FilterParams,
   GatherTracesResult,
   MineBlockResult,
@@ -90,6 +81,7 @@ import { optional } from "../../../util/io-ts";
 import * as BigIntUtils from "../../../util/bigint";
 import { HardforkName } from "../../../util/hardforks";
 import { ModulesLogger } from "./logger";
+import { Base } from "./base";
 
 const EIP1559_MIN_HARDFORK = HardforkName.LONDON;
 const ACCESS_LIST_MIN_HARDFORK = HardforkName.BERLIN;
@@ -97,15 +89,17 @@ const EIP155_MIN_HARDFORK = HardforkName.SPURIOUS_DRAGON;
 const EIP3860_MIN_HARDFORK = HardforkName.SHANGHAI;
 
 /* eslint-disable @nomicfoundation/hardhat-internal-rules/only-hardhat-error */
-export class EthModule {
+export class EthModule extends Base {
   constructor(
     private readonly _common: Common,
-    private readonly _node: HardhatNode,
+    _node: HardhatNode,
     private readonly _throwOnTransactionFailures: boolean,
     private readonly _throwOnCallFailures: boolean,
     private readonly _logger: ModulesLogger,
     private readonly _experimentalHardhatNetworkMessageTraceHooks: BoundExperimentalHardhatNetworkMessageTraceHook[] = []
-  ) {}
+  ) {
+    super(_node);
+  }
 
   public async processRequest(
     method: string,
@@ -354,9 +348,9 @@ export class EthModule {
   ): Promise<string> {
     this._validateTransactionAndCallRequest(rpcCall);
 
-    const blockNumberOrPending = await this._resolveNewBlockTag(blockTag);
+    const blockNumberOrPending = await this.resolveNewBlockTag(blockTag);
 
-    const callParams = await this._rpcCallRequestToNodeCallParams(rpcCall);
+    const callParams = await this.rpcCallRequestToNodeCallParams(rpcCall);
 
     const {
       result: returnData,
@@ -434,12 +428,12 @@ export class EthModule {
 
     // estimateGas behaves differently when there's no blockTag
     // it uses "pending" as default instead of "latest"
-    const blockNumberOrPending = await this._resolveNewBlockTag(
+    const blockNumberOrPending = await this.resolveNewBlockTag(
       blockTag,
       "pending"
     );
 
-    const callParams = await this._rpcCallRequestToNodeCallParams(callRequest);
+    const callParams = await this.rpcCallRequestToNodeCallParams(callRequest);
 
     const { estimation, error, trace, consoleLogMessages } =
       await this._node.estimateGas(callParams, blockNumberOrPending);
@@ -487,7 +481,7 @@ export class EthModule {
     address: Buffer,
     blockTag: OptionalRpcNewBlockTag
   ): Promise<string> {
-    const blockNumberOrPending = await this._resolveNewBlockTag(blockTag);
+    const blockNumberOrPending = await this.resolveNewBlockTag(blockTag);
 
     return numberToRpcQuantity(
       await this._node.getAccountBalance(
@@ -612,7 +606,7 @@ export class EthModule {
     address: Buffer,
     blockTag: OptionalRpcNewBlockTag
   ): Promise<string> {
-    const blockNumberOrPending = await this._resolveNewBlockTag(blockTag);
+    const blockNumberOrPending = await this.resolveNewBlockTag(blockTag);
 
     return bufferToRpcData(
       await this._node.getCode(new Address(address), blockNumberOrPending)
@@ -721,7 +715,7 @@ export class EthModule {
     slot: bigint,
     blockTag: OptionalRpcNewBlockTag
   ): Promise<string> {
-    const blockNumberOrPending = await this._resolveNewBlockTag(blockTag);
+    const blockNumberOrPending = await this.resolveNewBlockTag(blockTag);
 
     const data = await this._node.getStorageAt(
       new Address(address),
@@ -854,7 +848,7 @@ export class EthModule {
     address: Buffer,
     blockTag: OptionalRpcNewBlockTag
   ): Promise<string> {
-    const blockNumberOrPending = await this._resolveNewBlockTag(blockTag);
+    const blockNumberOrPending = await this.resolveNewBlockTag(blockTag);
 
     return numberToRpcQuantity(
       await this._node.getNextConfirmedNonce(
@@ -1240,7 +1234,7 @@ export class EthModule {
       );
     }
 
-    const resolvedNewestBlock = await this._resolveNewBlockTag(newestBlock);
+    const resolvedNewestBlock = await this.resolveNewBlockTag(newestBlock);
 
     const feeHistory = await this._node.getFeeHistory(
       blockCount,
@@ -1263,29 +1257,6 @@ export class EthModule {
 
   // Utility methods
 
-  private async _rpcCallRequestToNodeCallParams(
-    rpcCall: RpcCallRequest
-  ): Promise<CallParams> {
-    return {
-      to: rpcCall.to,
-      from:
-        rpcCall.from !== undefined
-          ? rpcCall.from
-          : await this._getDefaultCallFrom(),
-      data: rpcCall.data !== undefined ? rpcCall.data : toBuffer([]),
-      gasLimit:
-        rpcCall.gas !== undefined ? rpcCall.gas : this._node.getBlockGasLimit(),
-      value: rpcCall.value !== undefined ? rpcCall.value : 0n,
-      accessList:
-        rpcCall.accessList !== undefined
-          ? this._rpcAccessListToNodeAccessList(rpcCall.accessList)
-          : undefined,
-      gasPrice: rpcCall.gasPrice,
-      maxFeePerGas: rpcCall.maxFeePerGas,
-      maxPriorityFeePerGas: rpcCall.maxPriorityFeePerGas,
-    };
-  }
-
   private async _rpcTransactionRequestToNodeTransactionParams(
     rpcTx: RpcTransactionRequest
   ): Promise<TransactionParams> {
@@ -1365,15 +1336,6 @@ export class EthModule {
     };
   }
 
-  private _rpcAccessListToNodeAccessList(
-    rpcAccessList: RpcAccessList
-  ): Array<[Buffer, Buffer[]]> {
-    return rpcAccessList.map((tuple) => [
-      tuple.address,
-      tuple.storageKeys ?? [],
-    ]);
-  }
-
   private async _resolveOldBlockTag(
     oldBlockTag: RpcOldBlockTag
   ): Promise<bigint | "pending" | undefined> {
@@ -1485,22 +1447,6 @@ export class EthModule {
     return blockTag;
   }
 
-  private _newBlockTagToString(tag: RpcNewBlockTag): string {
-    if (typeof tag === "string") {
-      return tag;
-    }
-
-    if (BigIntUtils.isBigInt(tag)) {
-      return tag.toString();
-    }
-
-    if ("blockNumber" in tag) {
-      return tag.blockNumber.toString();
-    }
-
-    return bufferToHex(tag.blockHash);
-  }
-
   private _extractNormalizedLogTopics(
     topics: OptionalRpcLogTopics
   ): Array<Array<Buffer | null> | null> {
@@ -1532,16 +1478,6 @@ export class EthModule {
     return address;
   }
 
-  private async _getDefaultCallFrom(): Promise<Buffer> {
-    const localAccounts = await this._node.getLocalAccountAddresses();
-
-    if (localAccounts.length === 0) {
-      return toBuffer(zeroAddress());
-    }
-
-    return toBuffer(localAccounts[0]);
-  }
-
   private async _sendTransactionAndReturnHash(tx: TypedTransaction) {
     let result = await this._node.sendTransaction(tx);
 
@@ -1816,15 +1752,4 @@ You can use them by running Hardhat Network with 'hardfork' ${EIP1559_MIN_HARDFO
       );
     }
   }
-
-  private _checkPostMergeBlockTags(blockTag: "safe" | "finalized") {
-    const isPostMerge = this._node.isPostMergeHardfork();
-    const hardfork = this._node.hardfork;
-
-    if (!isPostMerge) {
-      throw new InvalidArgumentsError(
-        `The '${blockTag}' block tag is not allowed in pre-merge hardforks. You are using the '${hardfork}' hardfork.`
-      );
-    }
-  }
 }

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

@@ -1377,6 +1377,18 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     await this._persistIrregularWorldState();
   }
 
+  public async traceCall(
+    callParams: CallParams,
+    block: bigint | "pending",
+    traceConfig: RpcDebugTracingConfig
+  ) {
+    const vmDebugTracer = new VMDebugTracer(this._vm);
+
+    return vmDebugTracer.trace(async () => {
+      await this.runCall(callParams, block);
+    }, traceConfig);
+  }
+
   public async traceTransaction(hash: Buffer, config: RpcDebugTracingConfig) {
     const block = await this.getBlockByTransactionHash(hash);
     if (block === undefined) {