hardhat 2.18.3 → 2.19.1

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 });
+  }
+}

package/src/internal/hardhat-network/stack-traces/constants.ts

@@ -1,2 +1,2 @@
-export const SUPPORTED_SOLIDITY_VERSION_RANGE = "<=0.8.21";
+export const SUPPORTED_SOLIDITY_VERSION_RANGE = "<=0.8.22";
 export const FIRST_SOLC_VERSION_SUPPORTED = "0.5.1";

package/src/internal/solidity/compiler/downloader.ts

@@ -60,7 +60,11 @@ export interface ICompilerDownloader {
    * Downloads the compiler for a given version, which can later be obtained
    * with getCompiler.
    */
-  downloadCompiler(version: string): Promise<void>;
+  downloadCompiler(
+    version: string,
+    downloadStartedCb: (isCompilerDownloaded: boolean) => Promise<any>,
+    downloadEndedCb: (isCompilerDownloaded: boolean) => Promise<any>
+  ): Promise<void>;
 
   /**
    * Returns the compiler, which MUST be downloaded before calling this function.
@@ -146,8 +150,24 @@ export class CompilerDownloader implements ICompilerDownloader {
     return fsExtra.pathExists(downloadPath);
   }
 
-  public async downloadCompiler(version: string): Promise<void> {
+  public async downloadCompiler(
+    version: string,
+    downloadStartedCb: (isCompilerDownloaded: boolean) => Promise<any>,
+    downloadEndedCb: (isCompilerDownloaded: boolean) => Promise<any>
+  ): Promise<void> {
+    // Since only one process at a time can acquire the mutex, we avoid the risk of downloading the same compiler multiple times.
+    // This is because the mutex blocks access until a compiler has been fully downloaded, preventing any new process
+    // from checking whether that version of the compiler exists. Without mutex it might incorrectly
+    // return false, indicating that the compiler isn't present, even though it is currently being downloaded.
     await this._mutex.use(async () => {
+      const isCompilerDownloaded = await this.isCompilerDownloaded(version);
+
+      if (isCompilerDownloaded === true) {
+        return;
+      }
+
+      await downloadStartedCb(isCompilerDownloaded);
+
       let build = await this._getCompilerBuild(version);
 
       if (build === undefined && (await this._shouldDownloadCompilerList())) {
@@ -189,6 +209,8 @@ export class CompilerDownloader implements ICompilerDownloader {
       }
 
       await this._postProcessCompilerDownload(build, downloadPath);
+
+      await downloadEndedCb(isCompilerDownloaded);
     });
   }
 

package/src/internal/solidity/compiler/solc-info.ts

@@ -58,6 +58,7 @@ const defaultEvmTargets: { [key: string]: string } = {
   "0.8.19": "paris",
   "0.8.20": "shanghai",
   "0.8.21": "shanghai",
+  "0.8.22": "shanghai",
 };
 
 export function getEvmVersionFromSolcVersion(

package/src/internal/util/global-dir.ts

@@ -140,3 +140,7 @@ export function writePromptedForHHVSCode() {
 
   fs.writeFileSync(extensionPromptedPath, "{}");
 }
+
+export function getVarsFilePath(): string {
+  return path.join(getConfigDirSync(), "vars.json");
+}