Use "global" instead of "singleton" for the shared HRE instance

Author: alcuadrado

v-next/hardhat/src/index.ts

@@ -7,14 +7,14 @@ import type { UserInterruptionManager } from "./types/user-interruptions.js";
 
 import { resolveHardhatConfigPath } from "./config.js";
 import { createHardhatRuntimeEnvironment } from "./hre.js";
-import { importUserConfig } from "./internal/helpers/config-loading.js";
 import {
-  getHardhatRuntimeEnvironmentSingleton,
-  setHardhatRuntimeEnvironmentSingleton,
-} from "./internal/hre-singleton.js";
+  getGlobalHardhatRuntimeEnvironment,
+  setGlobalHardhatRuntimeEnvironment,
+} from "./internal/global-hre-instance.js";
+import { importUserConfig } from "./internal/helpers/config-loading.js";
 
 let maybeHre: HardhatRuntimeEnvironment | undefined =
-  getHardhatRuntimeEnvironmentSingleton();
+  getGlobalHardhatRuntimeEnvironment();
 
 if (maybeHre === undefined) {
   /* eslint-disable no-restricted-syntax -- Allow top-level await here */
@@ -24,7 +24,7 @@ if (maybeHre === undefined) {
   maybeHre = await createHardhatRuntimeEnvironment(userConfig);
   /* eslint-enable no-restricted-syntax */
 
-  setHardhatRuntimeEnvironmentSingleton(maybeHre);
+  setGlobalHardhatRuntimeEnvironment(maybeHre);
 }
 
 const hre: HardhatRuntimeEnvironment = maybeHre;

v-next/hardhat/src/internal/cli/main.ts

@@ -29,8 +29,8 @@ import { kebabToCamelCase } from "@ignored/hardhat-vnext-utils/string";
 import { resolveHardhatConfigPath } from "../../config.js";
 import { createHardhatRuntimeEnvironment } from "../../hre.js";
 import { builtinPlugins } from "../builtin-plugins/index.js";
+import { setGlobalHardhatRuntimeEnvironment } from "../global-hre-instance.js";
 import { importUserConfig } from "../helpers/config-loading.js";
-import { setHardhatRuntimeEnvironmentSingleton } from "../hre-singleton.js";
 
 import { printErrorMessages } from "./error-handler.js";
 import { getGlobalHelpString } from "./helpers/getGlobalHelpString.js";
@@ -92,7 +92,7 @@ export async function main(
     );
 
     // This must be the first time we set it, otherwise we let it crash
-    setHardhatRuntimeEnvironmentSingleton(hre);
+    setGlobalHardhatRuntimeEnvironment(hre);
 
     const taskOrId = parseTask(cliArguments, usedCliArguments, hre);
 

v-next/hardhat/src/internal/global-hre-instance.ts

@@ -0,0 +1,41 @@
+import type { HardhatRuntimeEnvironment } from "../types/hre.js";
+
+import { assertHardhatInvariant } from "@ignored/hardhat-vnext-errors";
+
+let hre: HardhatRuntimeEnvironment | undefined;
+
+/**
+ * This function returns a global instance of the Hardhat Runtime Environment
+ * if it was already initialized.
+ *
+ * It exists so that the CLI and the programmatic API (as in `import "hardhat"`)
+ * are always using the same HRE instance.
+ */
+export function getGlobalHardhatRuntimeEnvironment():
+  | HardhatRuntimeEnvironment
+  | undefined {
+  return hre;
+}
+
+/**
+ * Sets the global instance of the Hardhat Runtime Environment.
+ */
+export function setGlobalHardhatRuntimeEnvironment(
+  newHre: HardhatRuntimeEnvironment,
+): void {
+  assertHardhatInvariant(
+    hre === undefined,
+    "The global instances of the HRE is already set",
+  );
+  hre = newHre;
+}
+
+/**
+ * This function resets the global instance of the Hardhat Runtime Environment,
+ * so that it can be reinitialized.
+ *
+ * It should be used only in tests.
+ */
+export function resetGlobalHardhatRuntimeEnvironment(): void {
+  hre = undefined;
+}

v-next/hardhat/src/internal/hre-singleton.ts

@@ -7,15 +7,15 @@ import { resolveHardhatConfigPath } from "../../src/config.js";
 import { createHardhatRuntimeEnvironment } from "../../src/hre.js";
 import { builtinPlugins } from "../../src/internal/builtin-plugins/index.js";
 import {
-  getHardhatRuntimeEnvironmentSingleton,
-  resetHardhatRuntimeEnvironmentSingleton,
-  setHardhatRuntimeEnvironmentSingleton,
-} from "../../src/internal/hre-singleton.js";
+  getGlobalHardhatRuntimeEnvironment,
+  resetGlobalHardhatRuntimeEnvironment,
+  setGlobalHardhatRuntimeEnvironment,
+} from "../../src/internal/global-hre-instance.js";
 import { useFixtureProject } from "../helpers/project.js";
 
 describe("HRE", () => {
   afterEach(() => {
-    resetHardhatRuntimeEnvironmentSingleton();
+    resetGlobalHardhatRuntimeEnvironment();
   });
 
   describe("createHardhatRuntimeEnvironment", () => {
@@ -26,30 +26,30 @@ describe("HRE", () => {
     });
   });
 
-  describe("getHardhatRuntimeEnvironmentSingleton", () => {
-    it("Should return undefined if it wasn't set", () => {
-      assert.equal(getHardhatRuntimeEnvironmentSingleton(), undefined);
-      assert.equal(getHardhatRuntimeEnvironmentSingleton(), undefined);
+  describe("getGlobalHardhatRuntimeEnvironment", () => {
+    it("Should return undefined if the global instance isn't set", () => {
+      assert.equal(getGlobalHardhatRuntimeEnvironment(), undefined);
+      assert.equal(getGlobalHardhatRuntimeEnvironment(), undefined);
     });
 
     it("should return the same instance after it's set", async () => {
       const hre = await createHardhatRuntimeEnvironment({});
-      setHardhatRuntimeEnvironmentSingleton(hre);
+      setGlobalHardhatRuntimeEnvironment(hre);
 
-      const hre1 = getHardhatRuntimeEnvironmentSingleton();
-      const hre2 = getHardhatRuntimeEnvironmentSingleton();
+      const hre1 = getGlobalHardhatRuntimeEnvironment();
+      const hre2 = getGlobalHardhatRuntimeEnvironment();
 
       assert.ok(hre1 === hre, "The instances are not the same");
       assert.ok(hre2 === hre, "The instances are not the same");
     });
 
-    it("should include the builtin plugins", async () => {
+    it("should include the builtin plugins when initialized using createHardhatRuntimeEnvironment", async () => {
       const hre = await createHardhatRuntimeEnvironment({});
-      setHardhatRuntimeEnvironmentSingleton(hre);
-      const singletonHre = getHardhatRuntimeEnvironmentSingleton();
+      setGlobalHardhatRuntimeEnvironment(hre);
+      const globalHre = getGlobalHardhatRuntimeEnvironment();
 
-      assert.ok(singletonHre === hre, "The instances are not the same");
-      assert.deepEqual(singletonHre.config.plugins, builtinPlugins);
+      assert.ok(globalHre === hre, "The instances are not the same");
+      assert.deepEqual(globalHre.config.plugins, builtinPlugins);
     });
   });
 

v-next/hardhat/test/hre/index.ts

@@ -32,7 +32,7 @@ import {
   parseTask,
   parseTaskArguments,
 } from "../../../src/internal/cli/main.js";
-import { resetHardhatRuntimeEnvironmentSingleton } from "../../../src/internal/hre-singleton.js";
+import { resetGlobalHardhatRuntimeEnvironment } from "../../../src/internal/global-hre-instance.js";
 import { getHardhatVersion } from "../../../src/internal/utils/package.js";
 import { useFixtureProject } from "../../helpers/project.js";
 
@@ -83,7 +83,7 @@ async function getTasksAndSubtaskResults(
 describe("main", function () {
   describe("main", function () {
     afterEach(function () {
-      resetHardhatRuntimeEnvironmentSingleton();
+      resetGlobalHardhatRuntimeEnvironment();
     });
 
     describe("version", function () {