hardhat 2.20.1 → 2.21.0-dev.0

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

@@ -1,156 +0,0 @@
-import { Block } from "@nomicfoundation/ethereumjs-block";
-import {
-  bytesToHex as bufferToHex,
-  toBytes,
-  zeroAddress,
-} from "@nomicfoundation/ethereumjs-util";
-import {
-  OptionalRpcNewBlockTag,
-  RpcNewBlockTag,
-} from "../../../core/jsonrpc/types/input/blockTag";
-import { HardhatNode } from "../node";
-import * as BigIntUtils from "../../../util/bigint";
-import {
-  InvalidArgumentsError,
-  InvalidInputError,
-} from "../../../core/providers/errors";
-import { RpcCallRequest } from "../../../core/jsonrpc/types/input/callRequest";
-import { CallParams } from "../node-types";
-import { RpcAccessList } from "../../../core/jsonrpc/types/access-list";
-
-/* eslint-disable @nomicfoundation/hardhat-internal-rules/only-hardhat-error */
-
-export class Base {
-  constructor(protected readonly _node: HardhatNode) {}
-
-  public async resolveNewBlockTag(
-    newBlockTag: OptionalRpcNewBlockTag,
-    defaultValue: RpcNewBlockTag = "latest"
-  ): Promise<bigint | "pending"> {
-    if (newBlockTag === undefined) {
-      newBlockTag = defaultValue;
-    }
-
-    if (newBlockTag === "pending") {
-      return "pending";
-    }
-
-    if (newBlockTag === "latest") {
-      return this._node.getLatestBlockNumber();
-    }
-
-    if (newBlockTag === "earliest") {
-      return 0n;
-    }
-
-    if (newBlockTag === "safe" || newBlockTag === "finalized") {
-      this._checkPostMergeBlockTags(newBlockTag);
-
-      return this._node.getLatestBlockNumber();
-    }
-
-    if (!BigIntUtils.isBigInt(newBlockTag)) {
-      if ("blockNumber" in newBlockTag && "blockHash" in newBlockTag) {
-        throw new InvalidArgumentsError(
-          "Invalid block tag received. Only one of hash or block number can be used."
-        );
-      }
-
-      if ("blockNumber" in newBlockTag && "requireCanonical" in newBlockTag) {
-        throw new InvalidArgumentsError(
-          "Invalid block tag received. requireCanonical only works with hashes."
-        );
-      }
-    }
-
-    let block: Block | undefined;
-    if (BigIntUtils.isBigInt(newBlockTag)) {
-      block = await this._node.getBlockByNumber(newBlockTag);
-    } else if ("blockNumber" in newBlockTag) {
-      block = await this._node.getBlockByNumber(newBlockTag.blockNumber);
-    } else {
-      block = await this._node.getBlockByHash(newBlockTag.blockHash);
-    }
-
-    if (block === undefined) {
-      const latestBlock = this._node.getLatestBlockNumber();
-
-      throw new InvalidInputError(
-        `Received invalid block tag ${this._newBlockTagToString(
-          newBlockTag
-        )}. Latest block number is ${latestBlock.toString()}`
-      );
-    }
-
-    return block.header.number;
-  }
-
-  public 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 : Buffer.from([]),
-      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,
-    };
-  }
-
-  protected _rpcAccessListToNodeAccessList(
-    rpcAccessList: RpcAccessList
-  ): Array<[Buffer, Buffer[]]> {
-    return rpcAccessList.map((tuple) => [
-      tuple.address,
-      tuple.storageKeys ?? [],
-    ]);
-  }
-
-  protected _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.`
-      );
-    }
-  }
-
-  protected _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 async _getDefaultCallFrom(): Promise<Buffer> {
-    const localAccounts = await this._node.getLocalAccountAddresses();
-
-    if (localAccounts.length === 0) {
-      return Buffer.from(toBytes(zeroAddress()));
-    }
-
-    return Buffer.from(toBytes(localAccounts[0]));
-  }
-}

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

@@ -1,104 +0,0 @@
-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,
-} from "../../../core/jsonrpc/types/input/debugTraceTransaction";
-import { validateParams } from "../../../core/jsonrpc/types/input/validation";
-import {
-  InvalidArgumentsError,
-  MethodNotFoundError,
-} 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 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)
-        );
-    }
-
-    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(
-    params: any[]
-  ): [Buffer, RpcDebugTracingConfig] {
-    const validatedParams = validateParams(
-      params,
-      rpcHash,
-      rpcDebugTracingConfig
-    );
-
-    this._validateTracerParam(validatedParams[1]);
-
-    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(
-        "Hardhat currently only supports the default tracer, so no tracer parameter should be passed."
-      );
-    }
-  }
-}