hardhat 2.18.3 → 2.19.0

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