Merge pull request #5776 from NomicFoundation/hook-context-fix

Define the `HookContext` as a partial view of the `HRE`

Author: alcuadrado

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

@@ -118,15 +118,6 @@ export class HardhatRuntimeEnvironmentImplementation
 
     const interruptions = new UserInterruptionManagerImplementation(hooks);
 
-    const hookContext: HookContext = {
-      hooks,
-      config,
-      globalOptions,
-      interruptions,
-    };
-
-    hooks.setContext(hookContext);
-
     const hre = new HardhatRuntimeEnvironmentImplementation(
       extendedUserConfig,
       config,
@@ -136,6 +127,19 @@ export class HardhatRuntimeEnvironmentImplementation
       globalOptionDefinitions,
     );
 
+    // We create an object with the HRE as its prototype, and overwrite the
+    // tasks property with undefined, so that hooks don't have access to the
+    // task runner.
+    //
+    // The reason we do this with a prototype instead of a shallow copy is that
+    // the handlers hooked into hre/created may assign new properties to the
+    // HRE and we want those to be accessible to all the handlers.
+    const hookContext: HookContext = Object.create(hre, {
+      tasks: { value: undefined },
+    });
+
+    hooks.setContext(hookContext);
+
     await hooks.runSequentialHandlers("hre", "created", [hre]);
 
     return hre;

v-next/hardhat/src/types/hooks.ts

@@ -4,9 +4,7 @@ import type {
   HardhatUserConfig,
   ResolvedConfigurationVariable,
 } from "./config.js";
-import type { GlobalOptions } from "./global-options.js";
 import type { HardhatRuntimeEnvironment } from "./hre.js";
-import type { UserInterruptionManager } from "./user-interruptions.js";
 import type {
   LastParameter,
   ParametersExceptFirst,
@@ -32,12 +30,7 @@ declare module "./hre.js" {
  * The `HookContext` offers a subset of the functionality that the
  * `HardhatRuntimeEnvironment` does.
  */
-export interface HookContext {
-  readonly config: HardhatConfig;
-  readonly globalOptions: GlobalOptions;
-  readonly interruptions: UserInterruptionManager;
-  readonly hooks: HookManager;
-}
+export type HookContext = Omit<HardhatRuntimeEnvironment, "tasks">;
 
 /**
  * The different hooks that a plugin can define handlers for.

v-next/hardhat/test/internal/core/hook-manager.ts

@@ -482,6 +482,77 @@ describe("HookManager", () => {
         );
       });
     });
+
+    describe("HookContext and HRE extensions interactions", () => {
+      it("Should not make the task manager available to the handlers", async () => {
+        const assertionPlugin: HardhatPlugin = {
+          id: "assertion",
+          hookHandlers: {
+            hre: async () => ({
+              created: async (context, _): Promise<void> => {
+                assert.equal((context as any).tasks, undefined);
+              },
+            }),
+          },
+        };
+
+        await HardhatRuntimeEnvironmentImplementation.create(
+          { plugins: [assertionPlugin] },
+          {},
+        );
+      });
+
+      it("Should make the core fields of the HRE available to the handlers", async () => {
+        const assertionPlugin: HardhatPlugin = {
+          id: "assertion",
+          hookHandlers: {
+            hre: async () => ({
+              created: async (context, hre): Promise<void> => {
+                for (const field in Object.keys(hre)) {
+                  if (field !== "tasks") {
+                    assert.equal((context as any)[field], (hre as any)[field]);
+                  }
+                }
+              },
+            }),
+          },
+        };
+
+        await HardhatRuntimeEnvironmentImplementation.create(
+          { plugins: [assertionPlugin] },
+          {},
+        );
+      });
+
+      it("should make any extention to the HRE available to all the handlers as part of the HookContext", async () => {
+        const extensionPlugin: HardhatPlugin = {
+          id: "extension",
+          hookHandlers: {
+            hre: async () => ({
+              created: async (_, hre): Promise<void> => {
+                (hre as any).myExtension = "myExtension";
+              },
+            }),
+          },
+        };
+
+        const assertionPlugin: HardhatPlugin = {
+          id: "assertion",
+          hookHandlers: {
+            hre: async () => ({
+              created: async (context, _): Promise<void> => {
+                assert.equal((context as any).myExtension, "myExtension");
+              },
+            }),
+          },
+        };
+
+        await HardhatRuntimeEnvironmentImplementation.create(
+          { plugins: [extensionPlugin, assertionPlugin] },
+          {},
+        );
+      });
+    });
   });
 
   describe("dynamic hooks", () => {