hardhatjs 2.22.15

package/src/types/config.ts

@@ -0,0 +1,299 @@
+// This file defines the different config types.
+//
+// For each possible kind of config value, we have two types:
+//
+// One that ends with UserConfig, which represent the config as
+// written in the user's config file.
+//
+// The other one, with the same name except without the User part, represents
+// the resolved value as used during the hardhat execution.
+//
+// Note that while many declarations are repeated here (i.e. network types'
+// fields), we don't use `extends` as that can interfere with plugin authors
+// trying to augment the config types.
+
+// Networks config
+
+export interface NetworksUserConfig {
+  hardhat?: HardhatNetworkUserConfig;
+
+  [networkName: string]: NetworkUserConfig | undefined;
+}
+
+export type NetworkUserConfig =
+  | HardhatNetworkUserConfig
+  | HttpNetworkUserConfig;
+
+export interface HardforkHistoryUserConfig {
+  [hardforkName: string]: number /* block number */;
+}
+
+export interface HardhatNetworkChainUserConfig {
+  hardforkHistory?: HardforkHistoryUserConfig;
+}
+
+export interface HardhatNetworkChainsUserConfig {
+  [chainId: number]: HardhatNetworkChainUserConfig;
+}
+
+export interface HardhatNetworkUserConfig {
+  chainId?: number;
+  from?: string;
+  gas?: "auto" | number;
+  gasPrice?: "auto" | number;
+  gasMultiplier?: number;
+  initialBaseFeePerGas?: number;
+  hardfork?: string;
+  mining?: HardhatNetworkMiningUserConfig;
+  accounts?: HardhatNetworkAccountsUserConfig;
+  blockGasLimit?: number;
+  minGasPrice?: number | string;
+  throwOnTransactionFailures?: boolean;
+  throwOnCallFailures?: boolean;
+  allowUnlimitedContractSize?: boolean;
+  allowBlocksWithSameTimestamp?: boolean;
+  initialDate?: string;
+  loggingEnabled?: boolean;
+  forking?: HardhatNetworkForkingUserConfig;
+  coinbase?: string;
+  chains?: HardhatNetworkChainsUserConfig;
+  enableTransientStorage?: boolean;
+  enableRip7212?: boolean;
+}
+
+export type HardhatNetworkAccountsUserConfig =
+  | HardhatNetworkAccountUserConfig[]
+  | HardhatNetworkHDAccountsUserConfig;
+
+export interface HardhatNetworkAccountUserConfig {
+  privateKey: string;
+  balance: string;
+}
+
+export interface HardhatNetworkHDAccountsUserConfig {
+  mnemonic?: string;
+  initialIndex?: number;
+  count?: number;
+  path?: string;
+  accountsBalance?: string;
+  passphrase?: string;
+}
+
+export interface HDAccountsUserConfig {
+  mnemonic: string;
+  initialIndex?: number;
+  count?: number;
+  path?: string;
+  passphrase?: string;
+}
+
+export interface HardhatNetworkForkingUserConfig {
+  enabled?: boolean;
+  url: string;
+  blockNumber?: number;
+  httpHeaders?: { [name: string]: string };
+}
+
+export type HttpNetworkAccountsUserConfig =
+  | "remote"
+  | string[]
+  | HDAccountsUserConfig;
+
+export interface HttpNetworkUserConfig {
+  chainId?: number;
+  from?: string;
+  gas?: "auto" | number;
+  gasPrice?: "auto" | number;
+  gasMultiplier?: number;
+  url?: string;
+  timeout?: number;
+  httpHeaders?: { [name: string]: string };
+  accounts?: HttpNetworkAccountsUserConfig;
+}
+
+export interface NetworksConfig {
+  hardhat: HardhatNetworkConfig;
+  localhost: HttpNetworkConfig;
+
+  [networkName: string]: NetworkConfig;
+}
+
+export type NetworkConfig = HardhatNetworkConfig | HttpNetworkConfig;
+
+export type HardforkHistoryConfig = Map<
+  /* hardforkName */ string,
+  /* blockNumber */ number
+>;
+
+export interface HardhatNetworkChainConfig {
+  hardforkHistory: HardforkHistoryConfig;
+}
+
+export type HardhatNetworkChainsConfig = Map<
+  /* chainId */ number,
+  HardhatNetworkChainConfig
+>;
+
+export interface HardhatNetworkConfig {
+  chainId: number;
+  from?: string;
+  gas: "auto" | number;
+  gasPrice: "auto" | number;
+  gasMultiplier: number;
+  initialBaseFeePerGas?: number;
+  hardfork: string;
+  mining: HardhatNetworkMiningConfig;
+  accounts: HardhatNetworkAccountsConfig;
+  blockGasLimit: number;
+  minGasPrice: bigint;
+  throwOnTransactionFailures: boolean;
+  throwOnCallFailures: boolean;
+  allowUnlimitedContractSize: boolean;
+  initialDate: string;
+  loggingEnabled: boolean;
+  forking?: HardhatNetworkForkingConfig;
+  coinbase?: string;
+  chains: HardhatNetworkChainsConfig;
+  allowBlocksWithSameTimestamp?: boolean;
+  enableTransientStorage?: boolean;
+  enableRip7212?: boolean;
+}
+
+export type HardhatNetworkAccountsConfig =
+  | HardhatNetworkHDAccountsConfig
+  | HardhatNetworkAccountConfig[];
+
+export interface HardhatNetworkAccountConfig {
+  privateKey: string;
+  balance: string;
+}
+
+export interface HardhatNetworkHDAccountsConfig {
+  mnemonic: string;
+  initialIndex: number;
+  count: number;
+  path: string;
+  accountsBalance: string;
+  passphrase: string;
+}
+
+export interface HardhatNetworkForkingConfig {
+  enabled: boolean;
+  url: string;
+  blockNumber?: number;
+  httpHeaders?: { [name: string]: string };
+}
+
+export interface HttpNetworkConfig {
+  chainId?: number;
+  from?: string;
+  gas: "auto" | number;
+  gasPrice: "auto" | number;
+  gasMultiplier: number;
+  url: string;
+  timeout: number;
+  httpHeaders: { [name: string]: string };
+  accounts: HttpNetworkAccountsConfig;
+}
+
+export type HttpNetworkAccountsConfig =
+  | "remote"
+  | string[]
+  | HttpNetworkHDAccountsConfig;
+
+export interface HttpNetworkHDAccountsConfig {
+  mnemonic: string;
+  initialIndex: number;
+  count: number;
+  path: string;
+  passphrase: string;
+}
+
+export interface HardhatNetworkMiningConfig {
+  auto: boolean;
+  interval: number | [number, number];
+  mempool: HardhatNetworkMempoolConfig;
+}
+
+export interface HardhatNetworkMiningUserConfig {
+  auto?: boolean;
+  interval?: number | [number, number];
+  mempool?: HardhatNetworkMempoolUserConfig;
+}
+
+export interface HardhatNetworkMempoolConfig {
+  order: string; // Guaranteed at runtime to be have a valid value
+}
+
+export interface HardhatNetworkMempoolUserConfig {
+  order?: string;
+}
+
+// Project paths config
+
+export interface ProjectPathsUserConfig {
+  root?: string;
+  cache?: string;
+  artifacts?: string;
+  sources?: string;
+  tests?: string;
+}
+
+export interface ProjectPathsConfig {
+  root: string;
+  configFile: string;
+  cache: string;
+  artifacts: string;
+  sources: string;
+  tests: string;
+}
+
+// Solidity config
+
+// Note that the user config SolidityUserConfig is more complex than the resolved config SolidityConfig
+export type SolidityUserConfig = string | SolcUserConfig | MultiSolcUserConfig;
+
+export interface SolcUserConfig {
+  version: string;
+  settings?: any;
+}
+
+export interface MultiSolcUserConfig {
+  compilers: SolcUserConfig[];
+  overrides?: Record<string, SolcUserConfig>;
+}
+
+export interface SolcConfig {
+  version: string;
+  settings: any;
+}
+
+export interface SolidityConfig {
+  compilers: SolcConfig[];
+  overrides: Record<string, SolcConfig>;
+}
+
+// Hardhat config
+
+export interface HardhatUserConfig {
+  defaultNetwork?: string;
+  paths?: ProjectPathsUserConfig;
+  networks?: NetworksUserConfig;
+  solidity?: SolidityUserConfig;
+  mocha?: Mocha.MochaOptions;
+}
+
+export interface HardhatConfig {
+  defaultNetwork: string;
+  paths: ProjectPathsConfig;
+  networks: NetworksConfig;
+  solidity: SolidityConfig;
+  mocha: Mocha.MochaOptions;
+}
+
+// Plugins config functionality
+
+export type ConfigExtender = (
+  config: HardhatConfig,
+  userConfig: Readonly<HardhatUserConfig>
+) => void;

package/src/types/index.ts

@@ -0,0 +1,5 @@
+export * from "./config";
+export * from "./provider";
+export * from "./runtime";
+export * from "./artifacts";
+export * from "./builtin-tasks";

package/src/types/provider.ts

@@ -0,0 +1,58 @@
+import { EventEmitter } from "events";
+
+export interface RequestArguments {
+  readonly method: string;
+  readonly params?: readonly unknown[] | object;
+}
+
+export interface ProviderRpcError extends Error {
+  code: number;
+  data?: unknown;
+}
+
+export interface ProviderMessage {
+  readonly type: string;
+  readonly data: unknown;
+}
+
+export interface EthSubscription extends ProviderMessage {
+  readonly type: "eth_subscription";
+  readonly data: {
+    readonly subscription: string;
+    readonly result: unknown;
+  };
+}
+
+export interface ProviderConnectInfo {
+  readonly chainId: string;
+}
+
+export interface EIP1193Provider extends EventEmitter {
+  request(args: RequestArguments): Promise<unknown>;
+}
+
+export interface JsonRpcRequest {
+  jsonrpc: string;
+  method: string;
+  params: any[];
+  id: number;
+}
+
+export interface JsonRpcResponse {
+  jsonrpc: string;
+  id: number;
+  result?: any;
+  error?: {
+    code: number;
+    message: string;
+    data?: any;
+  };
+}
+
+export interface EthereumProvider extends EIP1193Provider {
+  send(method: string, params?: any[]): Promise<any>;
+  sendAsync(
+    payload: JsonRpcRequest,
+    callback: (error: any, response: JsonRpcResponse) => void
+  ): void;
+}

package/src/types/runtime.ts

@@ -0,0 +1,262 @@
+import { Artifacts } from "./artifacts";
+import { HardhatConfig, HardhatUserConfig, NetworkConfig } from "./config";
+import { EIP1193Provider, EthereumProvider } from "./provider";
+
+/**
+ * This class is used to dynamically validate task's argument types.
+ */
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export interface ArgumentType<T> {
+  /**
+   * The type's name.
+   */
+  name: string;
+
+  /**
+   * Check if argument value is of type <T>.
+   *
+   * @param argName {string} argument's name - used for context in case of error.
+   * @param argumentValue - value to be validated
+   *
+   * @throws HH301 if value is not of type <t>
+   */
+  validate(argName: string, argumentValue: any): void;
+}
+
+/**
+ * This is a special case of ArgumentType.
+ *
+ * These types must have a human-friendly string representation, so that they
+ * can be used as command line arguments.
+ */
+export interface CLIArgumentType<T> extends ArgumentType<T> {
+  /**
+   * Parses strValue into T. This function MUST throw HH301 if it
+   * can parse the given value.
+   *
+   * @param argName argument's name - used for context in case of error.
+   * @param strValue argument's string value to be parsed.
+   */
+  parse(argName: string, strValue: string): T;
+}
+
+export interface ConfigurableTaskDefinition {
+  setDescription(description: string): this;
+
+  setAction(action: ActionType<TaskArguments>): this;
+
+  addParam<T>(
+    name: string,
+    description?: string,
+    defaultValue?: T,
+    type?: ArgumentType<T>,
+    isOptional?: boolean
+  ): this;
+
+  addOptionalParam<T>(
+    name: string,
+    description?: string,
+    defaultValue?: T,
+    type?: ArgumentType<T>
+  ): this;
+
+  addPositionalParam<T>(
+    name: string,
+    description?: string,
+    defaultValue?: T,
+    type?: ArgumentType<T>,
+    isOptional?: boolean
+  ): this;
+
+  addOptionalPositionalParam<T>(
+    name: string,
+    description?: string,
+    defaultValue?: T,
+    type?: ArgumentType<T>
+  ): this;
+
+  addVariadicPositionalParam<T>(
+    name: string,
+    description?: string,
+    defaultValue?: T[],
+    type?: ArgumentType<T>,
+    isOptional?: boolean
+  ): this;
+
+  addOptionalVariadicPositionalParam<T>(
+    name: string,
+    description?: string,
+    defaultValue?: T[],
+    type?: ArgumentType<T>
+  ): this;
+
+  addFlag(name: string, description?: string): this;
+}
+
+// type alias to get the overloaded function type
+// for 'task` and 'subtask'
+declare function addTask<TaskArgumentsT extends TaskArguments>(
+  name: string,
+  description?: string,
+  action?: ActionType<TaskArgumentsT>
+): ConfigurableTaskDefinition;
+declare function addTask<TaskArgumentsT extends TaskArguments>(
+  name: string,
+  action: ActionType<TaskArgumentsT>
+): ConfigurableTaskDefinition;
+type AddConfigurableTaskFunction = typeof addTask;
+
+export interface ConfigurableScopeDefinition {
+  setDescription(description: string): this;
+
+  task: AddConfigurableTaskFunction;
+  subtask: AddConfigurableTaskFunction;
+}
+
+export interface ParamDefinition<T> {
+  name: string;
+  defaultValue?: T;
+  type: ArgumentType<T>;
+  description?: string;
+  isOptional: boolean;
+  isFlag: boolean;
+  isVariadic: boolean;
+}
+
+export interface OptionalParamDefinition<T> extends ParamDefinition<T> {
+  defaultValue: T;
+  isOptional: true;
+}
+
+export interface CLIOptionalParamDefinition<T>
+  extends OptionalParamDefinition<T> {
+  type: CLIArgumentType<T>;
+}
+
+export interface ParamDefinitionsMap {
+  [paramName: string]: ParamDefinition<any>;
+}
+
+export interface TaskDefinition extends ConfigurableTaskDefinition {
+  readonly scope?: string;
+  readonly name: string;
+  readonly description?: string;
+  readonly action: ActionType<TaskArguments>;
+  readonly isSubtask: boolean;
+
+  // TODO: Rename this to something better. It doesn't include the positional
+  // params, and that's not clear.
+  readonly paramDefinitions: ParamDefinitionsMap;
+
+  readonly positionalParamDefinitions: Array<ParamDefinition<any>>;
+}
+
+export interface ScopeDefinition extends ConfigurableScopeDefinition {
+  readonly name: string;
+  readonly description?: string;
+  readonly tasks: TasksMap;
+}
+
+export type TaskIdentifier = string | { scope?: string; task: string };
+
+/**
+ * @type TaskArguments {object-like} - the input arguments for a task.
+ *
+ * TaskArguments type is set to 'any' because it's interface is dynamic.
+ * It's impossible in TypeScript to statically specify a variadic
+ * number of fields and at the same time define specific types for\
+ * the argument values.
+ *
+ * For example, we could define:
+ * type TaskArguments = Record<string, any>;
+ *
+ * ...but then, we couldn't narrow the actual argument value's type in compile time,
+ * thus we have no other option than forcing it to be just 'any'.
+ */
+export type TaskArguments = any;
+
+export interface SubtaskArguments {
+  [subtaskName: string]: TaskArguments;
+}
+
+export interface RunSuperFunction<TaskArgumentsT extends TaskArguments> {
+  (
+    taskArguments?: TaskArgumentsT,
+    subtaskArguments?: SubtaskArguments
+  ): Promise<any>;
+  isDefined: boolean;
+}
+
+export type ActionType<TaskArgumentsT extends TaskArguments> = (
+  taskArgs: TaskArgumentsT,
+  env: HardhatRuntimeEnvironment,
+  runSuper: RunSuperFunction<TaskArgumentsT>
+) => Promise<any>;
+
+export interface HardhatArguments {
+  network?: string;
+  showStackTraces: boolean;
+  version: boolean;
+  help: boolean;
+  emoji: boolean;
+  config?: string;
+  verbose: boolean;
+  maxMemory?: number;
+  tsconfig?: string;
+  flamegraph?: boolean;
+  typecheck?: boolean;
+}
+
+export type HardhatParamDefinitions = {
+  [param in keyof Required<HardhatArguments>]: CLIOptionalParamDefinition<
+    HardhatArguments[param]
+  >;
+};
+
+export interface TasksMap {
+  [name: string]: TaskDefinition;
+}
+
+export interface ScopesMap {
+  [scopeName: string]: ScopeDefinition;
+}
+
+export type RunTaskFunction = (
+  taskIdentifier: TaskIdentifier,
+  taskArguments?: TaskArguments,
+  subtaskArguments?: SubtaskArguments
+) => Promise<any>;
+
+export interface HardhatRuntimeEnvironment {
+  readonly config: HardhatConfig;
+  readonly userConfig: HardhatUserConfig;
+  readonly hardhatArguments: HardhatArguments;
+  readonly tasks: TasksMap;
+  readonly scopes: ScopesMap;
+  readonly run: RunTaskFunction;
+  readonly network: Network;
+  readonly artifacts: Artifacts;
+  readonly version: string;
+}
+
+export interface Network {
+  name: string;
+  config: NetworkConfig;
+  provider: EthereumProvider;
+}
+
+/**
+ * A function that receives a HardhatRuntimeEnvironment and
+ * modify its properties or add new ones.
+ */
+export type EnvironmentExtender = (env: HardhatRuntimeEnvironment) => void;
+
+/**
+ * A function that receives a provider, crafts and returns a new one.
+ * Adding and modifying the current provider is preferred over ignoring it and returning a new instance.
+ */
+export type ProviderExtender = (
+  provider: EIP1193Provider,
+  config: HardhatConfig,
+  network: string
+) => EIP1193Provider | Promise<EIP1193Provider>;