hardhatjs 2.22.15

package/src/internal/constants.ts

@@ -0,0 +1,38 @@
+export const HARDHAT_NAME = "Hardhat";
+
+export const HARDHAT_EXECUTABLE_NAME = "hardhat";
+export const HARDHAT_NETWORK_NAME = "hardhat";
+
+export const SOLIDITY_FILES_CACHE_FILENAME = "solidity-files-cache.json";
+
+export const HARDHAT_NETWORK_SUPPORTED_HARDFORKS = [
+  // "chainstart",
+  // "homestead",
+  // "dao",
+  // "tangerineWhistle",
+  // "spuriousDragon",
+  "byzantium",
+  "constantinople",
+  "petersburg",
+  "istanbul",
+  "muirGlacier",
+  "berlin",
+  "london",
+  "arrowGlacier",
+  "grayGlacier",
+  "merge",
+  "shanghai",
+  "cancun",
+];
+
+export const HARDHAT_MEMPOOL_SUPPORTED_ORDERS = ["fifo", "priority"] as const;
+
+export const ARTIFACT_FORMAT_VERSION = "hh-sol-artifact-1";
+export const DEBUG_FILE_FORMAT_VERSION = "hh-sol-dbg-1";
+export const BUILD_INFO_FORMAT_VERSION = "hh-sol-build-info-1";
+export const BUILD_INFO_DIR_NAME = "build-info";
+export const EDIT_DISTANCE_THRESHOLD = 3;
+
+export const HARDHAT_NETWORK_RESET_EVENT = "hardhatNetworkReset";
+export const HARDHAT_NETWORK_REVERT_SNAPSHOT_EVENT =
+  "hardhatNetworkRevertSnapshot";

package/src/internal/context.ts

@@ -0,0 +1,107 @@
+import {
+  ConfigExtender,
+  EnvironmentExtender,
+  HardhatRuntimeEnvironment,
+  ProviderExtender,
+} from "../types";
+
+import { assertHardhatInvariant, HardhatError } from "./core/errors";
+import { ERRORS } from "./core/errors-list";
+import { VarsManagerSetup } from "./core/vars/vars-manager-setup";
+import { VarsManager } from "./core/vars/vars-manager";
+import { TasksDSL } from "./core/tasks/dsl";
+import { getVarsFilePath } from "./util/global-dir";
+import { getRequireCachedFiles } from "./util/platform";
+
+export type GlobalWithHardhatContext = typeof global & {
+  __hardhatContext: HardhatContext;
+};
+
+export class HardhatContext {
+  constructor() {
+    this.varsManager = new VarsManager(getVarsFilePath());
+  }
+
+  public static isCreated(): boolean {
+    const globalWithHardhatContext = global as GlobalWithHardhatContext;
+    return globalWithHardhatContext.__hardhatContext !== undefined;
+  }
+
+  public static createHardhatContext(): HardhatContext {
+    if (this.isCreated()) {
+      throw new HardhatError(ERRORS.GENERAL.CONTEXT_ALREADY_CREATED);
+    }
+    const globalWithHardhatContext = global as GlobalWithHardhatContext;
+    const ctx = new HardhatContext();
+    globalWithHardhatContext.__hardhatContext = ctx;
+    return ctx;
+  }
+
+  public static getHardhatContext(): HardhatContext {
+    const globalWithHardhatContext = global as GlobalWithHardhatContext;
+    const ctx = globalWithHardhatContext.__hardhatContext;
+    if (ctx === undefined) {
+      throw new HardhatError(ERRORS.GENERAL.CONTEXT_NOT_CREATED);
+    }
+    return ctx;
+  }
+
+  public static deleteHardhatContext() {
+    const globalAsAny = global as any;
+    globalAsAny.__hardhatContext = undefined;
+  }
+
+  public readonly tasksDSL = new TasksDSL();
+  public readonly environmentExtenders: EnvironmentExtender[] = [];
+  public environment?: HardhatRuntimeEnvironment;
+  public readonly providerExtenders: ProviderExtender[] = [];
+  public varsManager: VarsManager | VarsManagerSetup;
+
+  public readonly configExtenders: ConfigExtender[] = [];
+
+  private _filesLoadedBeforeConfig?: string[];
+  private _filesLoadedAfterConfig?: string[];
+
+  public setHardhatRuntimeEnvironment(env: HardhatRuntimeEnvironment) {
+    if (this.environment !== undefined) {
+      throw new HardhatError(ERRORS.GENERAL.CONTEXT_HRE_ALREADY_DEFINED);
+    }
+    this.environment = env;
+  }
+
+  public getHardhatRuntimeEnvironment(): HardhatRuntimeEnvironment {
+    if (this.environment === undefined) {
+      throw new HardhatError(ERRORS.GENERAL.CONTEXT_HRE_NOT_DEFINED);
+    }
+    return this.environment;
+  }
+
+  public setConfigLoadingAsStarted() {
+    this._filesLoadedBeforeConfig = getRequireCachedFiles();
+  }
+
+  public setConfigLoadingAsFinished() {
+    this._filesLoadedAfterConfig = getRequireCachedFiles();
+  }
+
+  public getFilesLoadedDuringConfig(): string[] {
+    // No config was loaded
+    if (this._filesLoadedBeforeConfig === undefined) {
+      return [];
+    }
+
+    assertHardhatInvariant(
+      this._filesLoadedAfterConfig !== undefined,
+      "Config loading was set as started and not finished"
+    );
+
+    return arraysDifference(
+      this._filesLoadedAfterConfig,
+      this._filesLoadedBeforeConfig
+    );
+  }
+}
+
+function arraysDifference<T>(a: T[], b: T[]): T[] {
+  return a.filter((e) => !b.includes(e));
+}

package/src/internal/core/config/config-env.ts

@@ -0,0 +1,219 @@
+import {
+  ActionType,
+  ConfigExtender,
+  ConfigurableScopeDefinition,
+  ConfigurableTaskDefinition,
+  EnvironmentExtender,
+  ProviderExtender,
+  TaskArguments,
+} from "../../../types";
+import { HardhatContext } from "../../context";
+import { HardhatError } from "../errors";
+import { ERRORS } from "../errors-list";
+import * as argumentTypes from "../params/argumentTypes";
+
+/**
+ * Creates a task, overriding any previous task with the same name.
+ *
+ * @remarks The action must await every async call made within it.
+ *
+ * @param name The task's name.
+ * @param description The task's description.
+ * @param action The task's action.
+ * @returns A task definition.
+ */
+export function task<TaskArgumentsT extends TaskArguments>(
+  name: string,
+  description?: string,
+  action?: ActionType<TaskArgumentsT>
+): ConfigurableTaskDefinition;
+
+/**
+ * Creates a task without description, overriding any previous task
+ * with the same name.
+ *
+ * @remarks The action must await every async call made within it.
+ *
+ * @param name The task's name.
+ * @param action The task's action.
+ *
+ * @returns A task definition.
+ */
+export function task<TaskArgumentsT extends TaskArguments>(
+  name: string,
+  action: ActionType<TaskArgumentsT>
+): ConfigurableTaskDefinition;
+
+export function task<TaskArgumentsT extends TaskArguments>(
+  name: string,
+  descriptionOrAction?: string | ActionType<TaskArgumentsT>,
+  action?: ActionType<TaskArgumentsT>
+): ConfigurableTaskDefinition {
+  const ctx = HardhatContext.getHardhatContext();
+  const dsl = ctx.tasksDSL;
+
+  if (descriptionOrAction === undefined) {
+    return dsl.task(name);
+  }
+
+  if (typeof descriptionOrAction !== "string") {
+    return dsl.task(name, descriptionOrAction);
+  }
+
+  return dsl.task(name, descriptionOrAction, action);
+}
+
+/**
+ * Creates a subtask, overriding any previous task with the same name.
+ *
+ * @remarks The subtasks won't be displayed in the CLI help messages.
+ * @remarks The action must await every async call made within it.
+ *
+ * @param name The task's name.
+ * @param description The task's description.
+ * @param action The task's action.
+ * @returns A task definition.
+ */
+export function subtask<TaskArgumentsT extends TaskArguments>(
+  name: string,
+  description?: string,
+  action?: ActionType<TaskArgumentsT>
+): ConfigurableTaskDefinition;
+
+/**
+ * Creates a subtask without description, overriding any previous
+ * task with the same name.
+ *
+ * @remarks The subtasks won't be displayed in the CLI help messages.
+ * @remarks The action must await every async call made within it.
+ *
+ * @param name The task's name.
+ * @param action The task's action.
+ * @returns A task definition.
+ */
+export function subtask<TaskArgumentsT extends TaskArguments>(
+  name: string,
+  action: ActionType<TaskArgumentsT>
+): ConfigurableTaskDefinition;
+
+export function subtask<TaskArgumentsT extends TaskArguments>(
+  name: string,
+  descriptionOrAction?: string | ActionType<TaskArgumentsT>,
+  action?: ActionType<TaskArgumentsT>
+): ConfigurableTaskDefinition {
+  const ctx = HardhatContext.getHardhatContext();
+  const dsl = ctx.tasksDSL;
+
+  if (descriptionOrAction === undefined) {
+    return dsl.subtask(name);
+  }
+
+  if (typeof descriptionOrAction !== "string") {
+    return dsl.subtask(name, descriptionOrAction);
+  }
+
+  return dsl.subtask(name, descriptionOrAction, action);
+}
+
+// Backwards compatibility alias
+export const internalTask = subtask;
+
+export function scope(
+  name: string,
+  description?: string
+): ConfigurableScopeDefinition {
+  const ctx = HardhatContext.getHardhatContext();
+  const dsl = ctx.tasksDSL;
+
+  return dsl.scope(name, description);
+}
+
+export const types = argumentTypes;
+
+/**
+ * Register an environment extender what will be run after the
+ * Hardhat Runtime Environment is initialized.
+ *
+ * @param extender A function that receives the Hardhat Runtime
+ * Environment.
+ */
+export function extendEnvironment(extender: EnvironmentExtender) {
+  const ctx = HardhatContext.getHardhatContext();
+  ctx.environmentExtenders.push(extender);
+}
+
+/**
+ * Register a config extender what will be run after the
+ * Hardhat Runtime Environment is initialized.
+ *
+ * @param extender A function that receives the resolved config
+ * to be modified and the config provided by the user
+ */
+export function extendConfig(extender: ConfigExtender) {
+  const ctx = HardhatContext.getHardhatContext();
+  ctx.configExtenders.push(extender);
+}
+
+/**
+ * Register a provider extender what will be run after the
+ * Hardhat Runtime Environment is initialized.
+ *
+ * @param extender A function that receives the current provider
+ * and returns a new one.
+ */
+export function extendProvider(extender: ProviderExtender) {
+  const ctx = HardhatContext.getHardhatContext();
+  ctx.providerExtenders.push(extender);
+}
+
+/**
+ * This object provides methods to interact with the configuration variables.
+ */
+export const vars = {
+  has: hasVar,
+  get: getVar,
+};
+
+/**
+ * Checks if a configuration variable exists.
+ *
+ * @remarks
+ * This method, when used during setup (via `npx hardhat vars setup`), will mark the variable as optional.
+ *
+ * @param varName - The name of the variable to check.
+ *
+ * @returns `true` if the variable exists, `false` otherwise.
+ */
+function hasVar(varName: string): boolean {
+  // varsManager will be an instance of VarsManager or VarsManagerSetup depending on the context (vars setup mode or not)
+  return HardhatContext.getHardhatContext().varsManager.has(varName, true);
+}
+
+/**
+ * Gets the value of the given configuration variable.
+ *
+ * @remarks
+ * This method, when used during setup (via `npx hardhat vars setup`), will mark the variable as required,
+ * unless a default value is provided.
+ *
+ * @param varName - The name of the variable to retrieve.
+ * @param [defaultValue] - An optional default value to return if the variable does not exist.
+ *
+ * @returns The value of the configuration variable if it exists, or the default value if provided.
+ *
+ * @throws HH1201 if the variable does not exist and no default value is set.
+ */
+function getVar(varName: string, defaultValue?: string): string {
+  // varsManager will be an instance of VarsManager or VarsManagerSetup depending on the context (vars setup mode or not)
+  const value = HardhatContext.getHardhatContext().varsManager.get(
+    varName,
+    defaultValue,
+    true
+  );
+
+  if (value !== undefined) return value;
+
+  throw new HardhatError(ERRORS.VARS.VALUE_NOT_FOUND_FOR_VAR, {
+    value: varName,
+  });
+}