hardhatjs 2.22.15

package/src/internal/core/providers/construction.ts

@@ -0,0 +1,259 @@
+import type {
+  Artifacts,
+  EIP1193Provider,
+  EthereumProvider,
+  HardhatConfig,
+  HardhatNetworkConfig,
+  HDAccountsUserConfig,
+  HttpNetworkAccountsUserConfig,
+  HttpNetworkConfig,
+  NetworkConfig,
+  ProviderExtender,
+} from "../../../types";
+
+import type {
+  ForkConfig,
+  MempoolOrder,
+} from "../../hardhat-network/provider/node-types";
+import type * as DiskCacheT from "../../hardhat-network/provider/utils/disk-cache";
+import { HARDHAT_NETWORK_NAME } from "../../constants";
+import { parseDateString } from "../../util/date";
+
+import { normalizeHardhatNetworkAccountsConfig } from "./util";
+
+export function isHDAccountsConfig(
+  accounts?: HttpNetworkAccountsUserConfig
+): accounts is HDAccountsUserConfig {
+  return accounts !== undefined && Object.keys(accounts).includes("mnemonic");
+}
+
+function isResolvedHttpNetworkConfig(
+  netConfig: Partial<NetworkConfig>
+): netConfig is HttpNetworkConfig {
+  return "url" in netConfig;
+}
+
+// This function is let's you import a provider dynamically in a pretty
+// type-safe way.
+// `ProviderNameT` and `name` must be the same literal string. TS enforces it.
+// `ModuleT` and `filePath` must also be the same, but this is not enforced.
+function importProvider<ModuleT, ProviderNameT extends keyof ModuleT>(
+  filePath: string,
+  name: ProviderNameT
+): ModuleT[ProviderNameT] {
+  const mod = require(filePath);
+  return mod[name];
+}
+
+export async function createProvider(
+  config: HardhatConfig,
+  networkName: string,
+  artifacts?: Artifacts,
+  extenders: ProviderExtender[] = []
+): Promise<EthereumProvider> {
+  let eip1193Provider: EIP1193Provider;
+  const networkConfig = config.networks[networkName];
+  const paths = config.paths;
+
+  if (networkName === HARDHAT_NETWORK_NAME) {
+    const hardhatNetConfig = networkConfig as HardhatNetworkConfig;
+
+    const { createHardhatNetworkProvider } = await import(
+      "../../hardhat-network/provider/provider"
+    );
+
+    let forkConfig: ForkConfig | undefined;
+
+    if (
+      hardhatNetConfig.forking?.enabled === true &&
+      hardhatNetConfig.forking?.url !== undefined
+    ) {
+      forkConfig = {
+        jsonRpcUrl: hardhatNetConfig.forking?.url,
+        blockNumber: hardhatNetConfig.forking?.blockNumber,
+        httpHeaders: hardhatNetConfig.forking.httpHeaders,
+      };
+    }
+
+    const accounts = normalizeHardhatNetworkAccountsConfig(
+      hardhatNetConfig.accounts
+    );
+
+    const { getForkCacheDirPath } =
+      require("../../hardhat-network/provider/utils/disk-cache") as typeof DiskCacheT;
+
+    eip1193Provider = await createHardhatNetworkProvider(
+      {
+        chainId: hardhatNetConfig.chainId,
+        networkId: hardhatNetConfig.chainId,
+        hardfork: hardhatNetConfig.hardfork,
+        blockGasLimit: hardhatNetConfig.blockGasLimit,
+        initialBaseFeePerGas: hardhatNetConfig.initialBaseFeePerGas,
+        minGasPrice: hardhatNetConfig.minGasPrice,
+        throwOnTransactionFailures: hardhatNetConfig.throwOnTransactionFailures,
+        throwOnCallFailures: hardhatNetConfig.throwOnCallFailures,
+        automine: hardhatNetConfig.mining.auto,
+        intervalMining: hardhatNetConfig.mining.interval,
+        // This cast is valid because of the config validation and resolution
+        mempoolOrder: hardhatNetConfig.mining.mempool.order as MempoolOrder,
+        chains: hardhatNetConfig.chains,
+        coinbase: hardhatNetConfig.coinbase,
+        genesisAccounts: accounts,
+        allowUnlimitedContractSize: hardhatNetConfig.allowUnlimitedContractSize,
+        allowBlocksWithSameTimestamp:
+          hardhatNetConfig.allowBlocksWithSameTimestamp ?? false,
+        initialDate:
+          hardhatNetConfig.initialDate !== undefined
+            ? parseDateString(hardhatNetConfig.initialDate)
+            : undefined,
+        forkConfig,
+        forkCachePath:
+          paths !== undefined ? getForkCacheDirPath(paths) : undefined,
+        enableTransientStorage:
+          hardhatNetConfig.enableTransientStorage ?? false,
+        enableRip7212: hardhatNetConfig.enableRip7212 ?? false,
+      },
+      {
+        enabled: hardhatNetConfig.loggingEnabled,
+      },
+      artifacts
+    );
+  } else {
+    const HttpProvider = importProvider<
+      typeof import("./http"),
+      "HttpProvider"
+    >("./http", "HttpProvider");
+    const httpNetConfig = networkConfig as HttpNetworkConfig;
+
+    eip1193Provider = new HttpProvider(
+      httpNetConfig.url!,
+      networkName,
+      httpNetConfig.httpHeaders,
+      httpNetConfig.timeout
+    );
+  }
+
+  let wrappedProvider = eip1193Provider;
+
+  for (const extender of extenders) {
+    wrappedProvider = await extender(wrappedProvider, config, networkName);
+  }
+
+  wrappedProvider = applyProviderWrappers(
+    wrappedProvider,
+    networkConfig,
+    extenders
+  );
+
+  const BackwardsCompatibilityProviderAdapter = importProvider<
+    typeof import("./backwards-compatibility"),
+    "BackwardsCompatibilityProviderAdapter"
+  >("./backwards-compatibility", "BackwardsCompatibilityProviderAdapter");
+
+  return new BackwardsCompatibilityProviderAdapter(wrappedProvider);
+}
+
+export function applyProviderWrappers(
+  provider: EIP1193Provider,
+  netConfig: Partial<NetworkConfig>,
+  extenders: ProviderExtender[]
+): EIP1193Provider {
+  // These dependencies are lazy-loaded because they are really big.
+  const LocalAccountsProvider = importProvider<
+    typeof import("./accounts"),
+    "LocalAccountsProvider"
+  >("./accounts", "LocalAccountsProvider");
+  const HDWalletProvider = importProvider<
+    typeof import("./accounts"),
+    "HDWalletProvider"
+  >("./accounts", "HDWalletProvider");
+  const FixedSenderProvider = importProvider<
+    typeof import("./accounts"),
+    "FixedSenderProvider"
+  >("./accounts", "FixedSenderProvider");
+  const AutomaticSenderProvider = importProvider<
+    typeof import("./accounts"),
+    "AutomaticSenderProvider"
+  >("./accounts", "AutomaticSenderProvider");
+
+  const AutomaticGasProvider = importProvider<
+    typeof import("./gas-providers"),
+    "AutomaticGasProvider"
+  >("./gas-providers", "AutomaticGasProvider");
+  const FixedGasProvider = importProvider<
+    typeof import("./gas-providers"),
+    "FixedGasProvider"
+  >("./gas-providers", "FixedGasProvider");
+  const AutomaticGasPriceProvider = importProvider<
+    typeof import("./gas-providers"),
+    "AutomaticGasPriceProvider"
+  >("./gas-providers", "AutomaticGasPriceProvider");
+  const FixedGasPriceProvider = importProvider<
+    typeof import("./gas-providers"),
+    "FixedGasPriceProvider"
+  >("./gas-providers", "FixedGasPriceProvider");
+  const ChainIdValidatorProvider = importProvider<
+    typeof import("./chainId"),
+    "ChainIdValidatorProvider"
+  >("./chainId", "ChainIdValidatorProvider");
+
+  if (isResolvedHttpNetworkConfig(netConfig)) {
+    const accounts = netConfig.accounts;
+
+    if (Array.isArray(accounts)) {
+      provider = new LocalAccountsProvider(provider, accounts);
+    } else if (isHDAccountsConfig(accounts)) {
+      provider = new HDWalletProvider(
+        provider,
+        accounts.mnemonic,
+        accounts.path,
+        accounts.initialIndex,
+        accounts.count,
+        accounts.passphrase
+      );
+    }
+
+    // TODO: Add some extension mechanism for account plugins here
+  }
+
+  if (netConfig.from !== undefined) {
+    provider = new FixedSenderProvider(provider, netConfig.from);
+  } else {
+    provider = new AutomaticSenderProvider(provider);
+  }
+
+  if (netConfig.gas === undefined || netConfig.gas === "auto") {
+    provider = new AutomaticGasProvider(provider, netConfig.gasMultiplier);
+  } else {
+    provider = new FixedGasProvider(provider, netConfig.gas);
+  }
+
+  if (netConfig.gasPrice === undefined || netConfig.gasPrice === "auto") {
+    // If you use a LocalAccountsProvider or HDWalletProvider, your transactions
+    // are signed locally. This requires having all of their fields available,
+    // including the gasPrice / maxFeePerGas & maxPriorityFeePerGas.
+    //
+    // We never use those providers when using Hardhat Network, but sign within
+    // Hardhat Network itself. This means that we don't need to provide all the
+    // fields, as the missing ones will be resolved there.
+    //
+    // Hardhat Network handles this in a more performant way, so we don't use
+    // the AutomaticGasPriceProvider for it unless there are provider extenders.
+    // The reason for this is that some extenders (like hardhat-ledger's) might
+    // do the signing themselves, and that needs the gas price to be set.
+    if (isResolvedHttpNetworkConfig(netConfig) || extenders.length > 0) {
+      provider = new AutomaticGasPriceProvider(provider);
+    }
+  } else {
+    provider = new FixedGasPriceProvider(provider, netConfig.gasPrice);
+  }
+
+  if (
+    isResolvedHttpNetworkConfig(netConfig) &&
+    netConfig.chainId !== undefined
+  ) {
+    provider = new ChainIdValidatorProvider(provider, netConfig.chainId);
+  }
+
+  return provider;
+}

package/src/internal/core/providers/errors.ts

@@ -0,0 +1,128 @@
+import { ProviderRpcError } from "../../../types";
+import { CustomError } from "../errors";
+
+// Codes taken from: https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1474.md#error-codes
+//
+// Code	  Message	              Meaning	                            Category
+//
+// -32700	Parse error	          Invalid JSON	                      standard
+// -32600	Invalid request	      JSON is not a valid request object  standard
+// -32601	Method not found	    Method does not exist	              standard
+// -32602	Invalid params	      Invalid method parameters	          standard
+// -32603	Internal error	      Internal JSON-RPC error	            standard
+// -32004	Method not supported	Method is not implemented	          non-standard
+// -32000	Invalid input	        Missing or invalid parameters	      non-standard
+// -32003	Transaction rejected	Transaction creation failed	        non-standard
+//
+//
+// Non standard:
+
+// -32999 Invalid response      The server returned a JSON-RPC      hardhat-sepecific
+//                              response, but the result is not
+//                              in the expected format
+//
+// Not implemented:
+//
+// -32001	Resource not found	  Requested resource not found	      non-standard
+// -32002	Resource unavailable	Requested resource not available	  non-standard
+
+export class ProviderError extends CustomError implements ProviderRpcError {
+  public static isProviderError(other: any): other is ProviderError {
+    return (
+      other !== undefined && other !== null && other._isProviderError === true
+    );
+  }
+  public code: number;
+  public data?: unknown;
+
+  private readonly _isProviderError;
+
+  constructor(message: string, code: number, public readonly parent?: Error) {
+    super(message, parent);
+    this.code = code;
+
+    this._isProviderError = true;
+  }
+}
+
+export class InvalidJsonInputError extends ProviderError {
+  public static readonly CODE = -32700;
+
+  constructor(message: string, parent?: Error) {
+    super(message, InvalidJsonInputError.CODE, parent);
+  }
+}
+
+export class InvalidRequestError extends ProviderError {
+  public static readonly CODE = -32600;
+
+  constructor(message: string, parent?: Error) {
+    super(message, InvalidRequestError.CODE, parent);
+  }
+}
+
+export class MethodNotFoundError extends ProviderError {
+  public static readonly CODE = -32601;
+
+  constructor(message: string, parent?: Error) {
+    super(message, MethodNotFoundError.CODE, parent);
+  }
+}
+
+export class InvalidArgumentsError extends ProviderError {
+  public static readonly CODE = -32602;
+
+  constructor(message: string, parent?: Error) {
+    super(message, InvalidArgumentsError.CODE, parent);
+  }
+}
+
+export class InternalError extends ProviderError {
+  public static readonly CODE = -32603;
+
+  constructor(message: string, parent?: Error) {
+    super(message, InternalError.CODE, parent);
+  }
+}
+
+export class InvalidInputError extends ProviderError {
+  public static readonly CODE = -32000;
+
+  constructor(message: string, parent?: Error) {
+    super(message, InvalidInputError.CODE, parent);
+  }
+}
+
+export class TransactionExecutionError extends ProviderError {
+  public static readonly CODE = -32003;
+
+  // TODO: This should have the transaction id
+  // TODO: Normalize this constructor
+  constructor(parentOrMsg: Error | string) {
+    if (typeof parentOrMsg === "string") {
+      super(parentOrMsg, TransactionExecutionError.CODE);
+    } else {
+      super(parentOrMsg.message, TransactionExecutionError.CODE, parentOrMsg);
+    }
+  }
+}
+
+export class MethodNotSupportedError extends ProviderError {
+  public static readonly CODE = -32004;
+
+  constructor(method: string, parent?: Error) {
+    super(
+      `Method ${method} is not supported`,
+      MethodNotSupportedError.CODE,
+      parent
+    );
+  }
+}
+
+export class InvalidResponseError extends ProviderError {
+  public static readonly CODE = -32999;
+
+  constructor(message: string, parent?: Error) {
+    super(message, InvalidResponseError.CODE, parent);
+  }
+}

package/src/internal/core/providers/gas-providers.ts

@@ -0,0 +1,306 @@
+import { EIP1193Provider, RequestArguments } from "../../../types";
+import {
+  numberToRpcQuantity,
+  rpcQuantityToNumber,
+  rpcQuantityToBigInt,
+} from "../jsonrpc/types/base-types";
+
+import { ProviderWrapper } from "./wrapper";
+
+const DEFAULT_GAS_MULTIPLIER = 1;
+
+export class FixedGasProvider extends ProviderWrapper {
+  constructor(provider: EIP1193Provider, private readonly _gasLimit: number) {
+    super(provider);
+  }
+
+  public async request(args: RequestArguments): Promise<unknown> {
+    if (args.method === "eth_sendTransaction") {
+      const params = this._getParams(args);
+
+      // TODO: Should we validate this type?
+      const tx = params[0];
+      if (tx !== undefined && tx.gas === undefined) {
+        tx.gas = numberToRpcQuantity(this._gasLimit);
+      }
+    }
+
+    return this._wrappedProvider.request(args);
+  }
+}
+
+export class FixedGasPriceProvider extends ProviderWrapper {
+  constructor(provider: EIP1193Provider, private readonly _gasPrice: number) {
+    super(provider);
+  }
+
+  public async request(args: RequestArguments): Promise<unknown> {
+    if (args.method === "eth_sendTransaction") {
+      const params = this._getParams(args);
+
+      // TODO: Should we validate this type?
+      const tx = params[0];
+      // temporary change to ignore EIP-1559
+      if (
+        tx !== undefined &&
+        tx.gasPrice === undefined &&
+        tx.maxFeePerGas === undefined &&
+        tx.maxPriorityFeePerGas === undefined
+      ) {
+        tx.gasPrice = numberToRpcQuantity(this._gasPrice);
+      }
+    }
+
+    return this._wrappedProvider.request(args);
+  }
+}
+
+abstract class MultipliedGasEstimationProvider extends ProviderWrapper {
+  private _blockGasLimit: number | undefined;
+
+  constructor(
+    provider: EIP1193Provider,
+    private readonly _gasMultiplier: number
+  ) {
+    super(provider);
+  }
+
+  protected async _getMultipliedGasEstimation(params: any[]): Promise<string> {
+    try {
+      const realEstimation = (await this._wrappedProvider.request({
+        method: "eth_estimateGas",
+        params,
+      })) as string;
+
+      if (this._gasMultiplier === 1) {
+        return realEstimation;
+      }
+
+      const normalGas = rpcQuantityToNumber(realEstimation);
+      const gasLimit = await this._getBlockGasLimit();
+
+      const multiplied = Math.floor(normalGas * this._gasMultiplier);
+      const gas = multiplied > gasLimit ? gasLimit - 1 : multiplied;
+
+      return numberToRpcQuantity(gas);
+    } catch (error) {
+      if (error instanceof Error) {
+        if (error.message.toLowerCase().includes("execution error")) {
+          const blockGasLimit = await this._getBlockGasLimit();
+          return numberToRpcQuantity(blockGasLimit);
+        }
+      }
+
+      // eslint-disable-next-line @nomicfoundation/hardhat-internal-rules/only-hardhat-error
+      throw error;
+    }
+  }
+
+  private async _getBlockGasLimit(): Promise<number> {
+    if (this._blockGasLimit === undefined) {
+      const latestBlock = (await this._wrappedProvider.request({
+        method: "eth_getBlockByNumber",
+        params: ["latest", false],
+      })) as { gasLimit: string };
+
+      const fetchedGasLimit = rpcQuantityToNumber(latestBlock.gasLimit);
+
+      // We store a lower value in case the gas limit varies slightly
+      this._blockGasLimit = Math.floor(fetchedGasLimit * 0.95);
+    }
+
+    return this._blockGasLimit;
+  }
+}
+
+export class AutomaticGasProvider extends MultipliedGasEstimationProvider {
+  constructor(
+    provider: EIP1193Provider,
+    gasMultiplier: number = DEFAULT_GAS_MULTIPLIER
+  ) {
+    super(provider, gasMultiplier);
+  }
+
+  public async request(args: RequestArguments): Promise<unknown> {
+    if (args.method === "eth_sendTransaction") {
+      const params = this._getParams(args);
+
+      // TODO: Should we validate this type?
+      const tx = params[0];
+      if (tx !== undefined && tx.gas === undefined) {
+        tx.gas = await this._getMultipliedGasEstimation(params);
+      }
+    }
+
+    return this._wrappedProvider.request(args);
+  }
+}
+
+export class AutomaticGasPriceProvider extends ProviderWrapper {
+  // We pay the max base fee that can be required if the next
+  // EIP1559_BASE_FEE_MAX_FULL_BLOCKS_PREFERENCE are full.
+  public static readonly EIP1559_BASE_FEE_MAX_FULL_BLOCKS_PREFERENCE: bigint =
+    3n;
+
+  // See eth_feeHistory for an explanation of what this means
+  public static readonly EIP1559_REWARD_PERCENTILE = 50;
+
+  private _nodeHasFeeHistory?: boolean;
+  private _nodeSupportsEIP1559?: boolean;
+
+  public async request(args: RequestArguments): Promise<unknown> {
+    if (args.method !== "eth_sendTransaction") {
+      return this._wrappedProvider.request(args);
+    }
+
+    const params = this._getParams(args);
+
+    // TODO: Should we validate this type?
+    const tx = params[0];
+
+    if (tx === undefined) {
+      return this._wrappedProvider.request(args);
+    }
+
+    // We don't need to do anything in these cases
+    if (
+      tx.gasPrice !== undefined ||
+      (tx.maxFeePerGas !== undefined && tx.maxPriorityFeePerGas !== undefined)
+    ) {
+      return this._wrappedProvider.request(args);
+    }
+
+    let suggestedEip1559Values = await this._suggestEip1559FeePriceValues();
+
+    // eth_feeHistory failed, so we send a legacy one
+    if (
+      tx.maxFeePerGas === undefined &&
+      tx.maxPriorityFeePerGas === undefined &&
+      suggestedEip1559Values === undefined
+    ) {
+      tx.gasPrice = numberToRpcQuantity(await this._getGasPrice());
+      return this._wrappedProvider.request(args);
+    }
+
+    // If eth_feeHistory failed, but the user still wants to send an EIP-1559 tx
+    // we use the gasPrice as default values.
+    if (suggestedEip1559Values === undefined) {
+      const gasPrice = await this._getGasPrice();
+
+      suggestedEip1559Values = {
+        maxFeePerGas: gasPrice,
+        maxPriorityFeePerGas: gasPrice,
+      };
+    }
+
+    let maxFeePerGas =
+      tx.maxFeePerGas !== undefined
+        ? rpcQuantityToBigInt(tx.maxFeePerGas)
+        : suggestedEip1559Values.maxFeePerGas;
+
+    const maxPriorityFeePerGas =
+      tx.maxPriorityFeePerGas !== undefined
+        ? rpcQuantityToBigInt(tx.maxPriorityFeePerGas)
+        : suggestedEip1559Values.maxPriorityFeePerGas;
+
+    if (maxFeePerGas < maxPriorityFeePerGas) {
+      maxFeePerGas += maxPriorityFeePerGas;
+    }
+
+    tx.maxFeePerGas = numberToRpcQuantity(maxFeePerGas);
+    tx.maxPriorityFeePerGas = numberToRpcQuantity(maxPriorityFeePerGas);
+
+    return this._wrappedProvider.request(args);
+  }
+
+  private async _getGasPrice(): Promise<bigint> {
+    const response = (await this._wrappedProvider.request({
+      method: "eth_gasPrice",
+    })) as string;
+
+    return rpcQuantityToBigInt(response);
+  }
+
+  private async _suggestEip1559FeePriceValues(): Promise<
+    | {
+        maxFeePerGas: bigint;
+        maxPriorityFeePerGas: bigint;
+      }
+    | undefined
+  > {
+    if (this._nodeSupportsEIP1559 === undefined) {
+      const block = (await this._wrappedProvider.request({
+        method: "eth_getBlockByNumber",
+        params: ["latest", false],
+      })) as any;
+
+      this._nodeSupportsEIP1559 = block.baseFeePerGas !== undefined;
+    }
+
+    if (
+      this._nodeHasFeeHistory === false ||
+      this._nodeSupportsEIP1559 === false
+    ) {
+      return;
+    }
+
+    try {
+      const response = (await this._wrappedProvider.request({
+        method: "eth_feeHistory",
+        params: [
+          "0x1",
+          "latest",
+          [AutomaticGasPriceProvider.EIP1559_REWARD_PERCENTILE],
+        ],
+      })) as { baseFeePerGas: string[]; reward: string[][] };
+
+      let maxPriorityFeePerGas = rpcQuantityToBigInt(response.reward[0][0]);
+
+      if (maxPriorityFeePerGas === 0n) {
+        try {
+          const suggestedMaxPriorityFeePerGas =
+            (await this._wrappedProvider.request({
+              method: "eth_maxPriorityFeePerGas",
+              params: [],
+            })) as string;
+
+          maxPriorityFeePerGas = rpcQuantityToBigInt(
+            suggestedMaxPriorityFeePerGas
+          );
+        } catch {
+          // if eth_maxPriorityFeePerGas does not exist, use 1 wei
+          maxPriorityFeePerGas = 1n;
+        }
+      }
+
+      // If after all of these we still have a 0 wei maxPriorityFeePerGas, we
+      // use 1 wei. This is to improve the UX of the automatic gas price
+      // on chains that are very empty (i.e local testnets). This will be very
+      // unlikely to trigger on a live chain.
+      if (maxPriorityFeePerGas === 0n) {
+        maxPriorityFeePerGas = 1n;
+      }
+
+      return {
+        // Each block increases the base fee by 1/8 at most, when full.
+        // We have the next block's base fee, so we compute a cap for the
+        // next N blocks here.
+
+        maxFeePerGas:
+          (rpcQuantityToBigInt(response.baseFeePerGas[1]) *
+            9n **
+              (AutomaticGasPriceProvider.EIP1559_BASE_FEE_MAX_FULL_BLOCKS_PREFERENCE -
+                1n)) /
+          8n **
+            (AutomaticGasPriceProvider.EIP1559_BASE_FEE_MAX_FULL_BLOCKS_PREFERENCE -
+              1n),
+
+        maxPriorityFeePerGas,
+      };
+    } catch {
+      this._nodeHasFeeHistory = false;
+
+      return undefined;
+    }
+  }
+}