hardhatjs 2.22.15

package/src/internal/core/tasks/util.ts

@@ -0,0 +1,18 @@
+import { TaskIdentifier } from "../../../types";
+
+export function parseTaskIdentifier(taskIdentifier: TaskIdentifier): {
+  scope: string | undefined;
+  task: string;
+} {
+  if (typeof taskIdentifier === "string") {
+    return {
+      scope: undefined,
+      task: taskIdentifier,
+    };
+  } else {
+    return {
+      scope: taskIdentifier.scope,
+      task: taskIdentifier.task,
+    };
+  }
+}

package/src/internal/core/typescript-support.ts

@@ -0,0 +1,93 @@
+import { HardhatConfig } from "../../types";
+
+import { resolveConfigPath } from "./config/config-loading";
+import { HardhatError } from "./errors";
+import { ERRORS } from "./errors-list";
+import { isRunningHardhatCoreTests } from "./execution-mode";
+
+let cachedIsTypescriptSupported: boolean | undefined;
+
+/**
+ * Returns true if Hardhat will run in using typescript mode.
+ * @param configPath The config path if provider by the user.
+ */
+export function willRunWithTypescript(configPath?: string): boolean {
+  const config = resolveConfigPath(configPath);
+  return isNonEsmTypescriptFile(config);
+}
+
+/**
+ * Returns true if an Hardhat is already running with typescript.
+ */
+export function isRunningWithTypescript(config: HardhatConfig): boolean {
+  return isNonEsmTypescriptFile(config.paths.configFile);
+}
+
+export function isTypescriptSupported() {
+  if (cachedIsTypescriptSupported === undefined) {
+    try {
+      // We resolve these from Hardhat's installation.
+      require.resolve("typescript");
+      require.resolve("ts-node");
+      cachedIsTypescriptSupported = true;
+    } catch {
+      cachedIsTypescriptSupported = false;
+    }
+  }
+
+  return cachedIsTypescriptSupported;
+}
+
+export function loadTsNode(
+  tsConfigPath?: string,
+  shouldTypecheck: boolean = false
+) {
+  try {
+    require.resolve("typescript");
+  } catch {
+    throw new HardhatError(ERRORS.GENERAL.TYPESCRIPT_NOT_INSTALLED);
+  }
+
+  try {
+    require.resolve("ts-node");
+  } catch {
+    throw new HardhatError(ERRORS.GENERAL.TS_NODE_NOT_INSTALLED);
+  }
+
+  // If we are running tests we just want to transpile
+  if (isRunningHardhatCoreTests()) {
+    // eslint-disable-next-line import/no-extraneous-dependencies
+    require("ts-node/register/transpile-only");
+    return;
+  }
+
+  if (tsConfigPath !== undefined) {
+    process.env.TS_NODE_PROJECT = tsConfigPath;
+  }
+
+  // See: https://github.com/nomiclabs/hardhat/issues/265
+  if (process.env.TS_NODE_FILES === undefined) {
+    process.env.TS_NODE_FILES = "true";
+  }
+
+  let tsNodeRequirement = "ts-node/register";
+
+  if (!shouldTypecheck) {
+    tsNodeRequirement += "/transpile-only";
+  }
+
+  // eslint-disable-next-line import/no-extraneous-dependencies
+  require(tsNodeRequirement);
+}
+
+function isNonEsmTypescriptFile(path: string): boolean {
+  return /\.(ts|cts)$/i.test(path);
+}
+
+export function isTypescriptFile(path: string): boolean {
+  return /\.(ts|cts|mts)$/i.test(path);
+}
+
+export function isJavascriptFile(path: string): boolean {
+  return /\.(js|cjs|mjs)$/i.test(path);
+}

package/src/internal/core/vars/vars-manager-setup.ts

@@ -0,0 +1,124 @@
+import debug from "debug";
+import { VarsManager } from "./vars-manager";
+
+const log = debug("hardhat:core:vars:varsManagerSetup");
+
+/**
+ * This class is ONLY used when collecting the required and optional vars that have to be filled by the user
+ */
+export class VarsManagerSetup extends VarsManager {
+  private readonly _getVarsAlreadySet: Set<string>;
+  private readonly _hasVarsAlreadySet: Set<string>;
+  private readonly _getVarsWithDefaultValueAlreadySet: Set<string>;
+
+  private readonly _getVarsToSet: Set<string>;
+  private readonly _hasVarsToSet: Set<string>;
+  private readonly _getVarsWithDefaultValueToSet: Set<string>;
+
+  constructor(varsFilePath: string) {
+    log("Creating a new instance of VarsManagerSetup");
+
+    super(varsFilePath);
+
+    this._getVarsAlreadySet = new Set();
+    this._hasVarsAlreadySet = new Set();
+    this._getVarsWithDefaultValueAlreadySet = new Set();
+
+    this._getVarsToSet = new Set();
+    this._hasVarsToSet = new Set();
+    this._getVarsWithDefaultValueToSet = new Set();
+  }
+
+  // Checks if the key exists, and updates sets accordingly.
+  // Ignore the parameter 'includeEnvs' defined in the parent class because during setup env vars are ignored.
+  public has(key: string): boolean {
+    log(`function 'has' called with key '${key}'`);
+
+    const hasKey = super.has(key);
+
+    if (hasKey) {
+      this._hasVarsAlreadySet.add(key);
+    } else {
+      this._hasVarsToSet.add(key);
+    }
+
+    return hasKey;
+  }
+
+  // Gets the value for the provided key, and updates sets accordingly.
+  // Ignore the parameter 'includeEnvs' defined in the parent class because during setup env vars are ignored.
+  public get(key: string, defaultValue?: string): string {
+    log(`function 'get' called with key '${key}'`);
+
+    const varAlreadySet = super.has(key);
+
+    if (varAlreadySet) {
+      if (defaultValue !== undefined) {
+        this._getVarsWithDefaultValueAlreadySet.add(key);
+      } else {
+        this._getVarsAlreadySet.add(key);
+      }
+    } else {
+      if (defaultValue !== undefined) {
+        this._getVarsWithDefaultValueToSet.add(key);
+      } else {
+        this._getVarsToSet.add(key);
+      }
+    }
+
+    // Do not return undefined to avoid throwing an error
+    return super.get(key, defaultValue) ?? "";
+  }
+
+  public getRequiredVarsAlreadySet(): string[] {
+    return this._getRequired(this._getVarsAlreadySet, this._hasVarsAlreadySet);
+  }
+
+  public getOptionalVarsAlreadySet(): string[] {
+    return this._getOptionals(
+      this._getVarsAlreadySet,
+      this._hasVarsAlreadySet,
+      this._getVarsWithDefaultValueAlreadySet
+    );
+  }
+
+  public getRequiredVarsToSet(): string[] {
+    return this._getRequired(this._getVarsToSet, this._hasVarsToSet);
+  }
+
+  public getOptionalVarsToSet(): string[] {
+    return this._getOptionals(
+      this._getVarsToSet,
+      this._hasVarsToSet,
+      this._getVarsWithDefaultValueToSet
+    );
+  }
+
+  // How to calculate required and optional variables:
+  //
+  // G = get function
+  // H = has function
+  // GD = get function with default value
+  //
+  // optional variables = H + (GD - G)
+  // required variables = G - H
+  private _getRequired(getVars: Set<string>, hasVars: Set<string>): string[] {
+    return Array.from(getVars).filter((k) => !hasVars.has(k));
+  }
+
+  private _getOptionals(
+    getVars: Set<string>,
+    hasVars: Set<string>,
+    getVarsWithDefault: Set<string>
+  ): string[] {
+    const result = new Set(hasVars);
+
+    for (const k of getVarsWithDefault) {
+      if (!getVars.has(k)) {
+        result.add(k);
+      }
+    }
+
+    return Array.from(result);
+  }
+}

package/src/internal/core/vars/vars-manager.ts

@@ -0,0 +1,152 @@
+import fs from "fs-extra";
+import debug from "debug";
+import { HardhatError } from "../errors";
+import { ERRORS } from "../errors-list";
+
+interface Var {
+  value: string;
+}
+
+interface VarsFile {
+  _format: string; // Version of the json vars file
+  vars: Record<string, Var>;
+}
+
+const log = debug("hardhat:core:vars:varsManager");
+
+export class VarsManager {
+  private readonly _VERSION = "hh-vars-1";
+  private readonly _ENV_VAR_PREFIX = "HARDHAT_VAR_";
+  private readonly _storageCache: VarsFile;
+  private readonly _envCache: Record<string, string>;
+
+  constructor(private readonly _varsFilePath: string) {
+    log("Creating a new instance of VarsManager");
+
+    this._initializeVarsFile();
+    this._storageCache = fs.readJSONSync(this._varsFilePath);
+
+    this._envCache = {};
+    this._loadVarsFromEnv();
+  }
+
+  public getStoragePath(): string {
+    return this._varsFilePath;
+  }
+
+  public set(key: string, value: string) {
+    this.validateKey(key);
+
+    if (value === "") {
+      throw new HardhatError(ERRORS.VARS.INVALID_EMPTY_VALUE);
+    }
+
+    const vars = this._storageCache.vars;
+
+    vars[key] = { value };
+    this._writeStoredVars(vars);
+  }
+
+  public has(key: string, includeEnvs: boolean = false): boolean {
+    if (includeEnvs && key in this._envCache) {
+      return true;
+    }
+
+    return key in this._storageCache.vars;
+  }
+
+  public get(
+    key: string,
+    defaultValue?: string,
+    includeEnvs: boolean = false
+  ): string | undefined {
+    if (includeEnvs && key in this._envCache) {
+      return this._envCache[key];
+    }
+
+    return this._storageCache.vars[key]?.value ?? defaultValue;
+  }
+
+  public getEnvVars(): string[] {
+    return Object.keys(this._envCache).map(
+      (k) => `${this._ENV_VAR_PREFIX}${k}`
+    );
+  }
+
+  public list(): string[] {
+    return Object.keys(this._storageCache.vars);
+  }
+
+  public delete(key: string): boolean {
+    const vars = this._storageCache.vars;
+
+    if (vars[key] === undefined) return false;
+
+    delete vars[key];
+    this._writeStoredVars(vars);
+
+    return true;
+  }
+
+  public validateKey(key: string) {
+    const KEY_REGEX = /^[a-zA-Z_]+[a-zA-Z0-9_]*$/;
+
+    if (!KEY_REGEX.test(key)) {
+      throw new HardhatError(ERRORS.VARS.INVALID_CONFIG_VAR_NAME, {
+        value: key,
+      });
+    }
+  }
+
+  private _initializeVarsFile() {
+    if (!fs.pathExistsSync(this._varsFilePath)) {
+      // Initialize the vars file if it does not exist
+      log(
+        `Vars file do not exist. Creating a new one at '${this._varsFilePath}' with version '${this._VERSION}'`
+      );
+
+      fs.writeJSONSync(this._varsFilePath, this._getVarsFileStructure(), {
+        spaces: 2,
+      });
+    }
+  }
+
+  private _getVarsFileStructure(): VarsFile {
+    return {
+      _format: this._VERSION,
+      vars: {},
+    };
+  }
+
+  private _loadVarsFromEnv() {
+    log("Loading ENV variables if any");
+
+    for (const key in process.env) {
+      if (key.startsWith(this._ENV_VAR_PREFIX)) {
+        const envVar = process.env[key];
+
+        if (
+          envVar === undefined ||
+          envVar.replace(/[\s\t]/g, "").length === 0
+        ) {
+          throw new HardhatError(ERRORS.ARGUMENTS.INVALID_ENV_VAR_VALUE, {
+            varName: key,
+            value: envVar!,
+          });
+        }
+
+        const envKey = key.replace(this._ENV_VAR_PREFIX, "");
+        this.validateKey(envKey);
+
+        // Store only in cache, not in a file, as the vars are sourced from environment variables
+        this._envCache[envKey] = envVar;
+      }
+    }
+  }
+
+  private _writeStoredVars(vars: Record<string, Var>) {
+    // ENV variables are not stored in the file
+    this._storageCache.vars = vars;
+    fs.writeJSONSync(this._varsFilePath, this._storageCache, { spaces: 2 });
+  }
+}