Merge branch 'v-next' of github.com:NomicFoundation/hardhat into feature/add-logic-for-init-command

Author: ChristopherDedominici

pnpm-lock.yaml

@@ -5,7 +5,7 @@ This package contains the new core of Hardhat, which includes:
 - The config system
 - The configuration variables system
 - The plugin system
-- The global arguments system
+- The global options system
 - The hooks system
 - The tasks system
 - The user interruptions system

v-next/core/README.md

@@ -14,7 +14,7 @@
     "./types/cli": "./dist/src/types/cli.js",
     "./types/common": "./dist/src/types/common.js",
     "./types/config": "./dist/src/types/config.js",
-    "./types/global-parameters": "./dist/src/types/global-parameters.js",
+    "./types/global-options": "./dist/src/types/global-options.js",
     "./types/hooks": "./dist/src/types/hooks.js",
     "./types/hre": "./dist/src/types/hre.js",
     "./types/plugins": "./dist/src/types/plugins.js",

v-next/core/package.json

@@ -16,8 +16,8 @@ export * from "./types/common.js";
 export type * from "./types/common.js";
 export * from "./types/config.js";
 export type * from "./types/config.js";
-export * from "./types/global-parameters.js";
-export type * from "./types/global-parameters.js";
+export * from "./types/global-options.js";
+export type * from "./types/global-options.js";
 export * from "./types/hooks.js";
 export type * from "./types/hooks.js";
 export * from "./types/hre.js";

v-next/core/scripts/api-extractor.sh

@@ -1,12 +1,13 @@
+import type { ParameterTypeToValueType } from "./types/common.js";
 import type { ConfigurationVariable } from "./types/config.js";
-import type { GlobalParameter } from "./types/global-parameters.js";
+import type { GlobalOption } from "./types/global-options.js";
 import type {
   EmptyTaskDefinitionBuilder,
   NewTaskDefinitionBuilder,
   TaskOverrideDefinitionBuilder,
 } from "./types/tasks.js";
 
-import { buildGlobalParameterDefinition } from "./internal/global-parameters.js";
+import { buildGlobalOptionDefinition } from "./internal/global-options.js";
 import {
   EmptyTaskDefinitionBuilderImplementation,
   NewTaskDefinitionBuilderImplementation,
@@ -55,15 +56,15 @@ export function overrideTask(
 }
 
 /**
- * Defines a global parameter.
+ * Defines a global option.
  */
-export function globalParameter(options: {
+export function globalOption<T extends ParameterType>(options: {
   name: string;
   description: string;
-  parameterType: ParameterType;
-  defaultValue: any;
-}): GlobalParameter {
-  return buildGlobalParameterDefinition(options);
+  parameterType?: T;
+  defaultValue: ParameterTypeToValueType<T>;
+}): GlobalOption {
+  return buildGlobalOptionDefinition(options);
 }
 
 /**
@@ -72,8 +73,8 @@ export function globalParameter(options: {
 export function globalFlag(options: {
   name: string;
   description: string;
-}): GlobalParameter {
-  return buildGlobalParameterDefinition({
+}): GlobalOption {
+  return buildGlobalOptionDefinition({
     ...options,
     parameterType: ParameterType.BOOLEAN,
     defaultValue: false,

v-next/core/src/config.ts

@@ -1,6 +1,6 @@
 import type { UnsafeHardhatRuntimeEnvironmentOptions } from "./types/cli.js";
 import type { HardhatUserConfig } from "./types/config.js";
-import type { GlobalArguments } from "./types/global-parameters.js";
+import type { GlobalOptions } from "./types/global-options.js";
 import type { HardhatRuntimeEnvironment } from "./types/hre.js";
 
 import { HardhatRuntimeEnvironmentImplementation } from "./internal/hre.js";
@@ -9,23 +9,23 @@ import { HardhatRuntimeEnvironmentImplementation } from "./internal/hre.js";
  * Creates an instances of the Hardhat Runtime Environment.
  *
  * @param config - The user's Hardhat configuration.
- * @param userProvidedGlobalArguments - The global arguments provided by the
+ * @param userProvidedGlobalOptions - The global options provided by the
  *  user.
  * @param unsafeOptions - Options used to bypass some initialization, to avoid
  *  redoing it in the CLI. Should only be used in the official CLI.
  * @returns The Hardhat Runtime Environment.
  */
 export async function createHardhatRuntimeEnvironment(
   config: HardhatUserConfig,
-  userProvidedGlobalArguments: Partial<GlobalArguments> = {},
+  userProvidedGlobalOptions: Partial<GlobalOptions> = {},
   unsafeOptions?: UnsafeHardhatRuntimeEnvironmentOptions,
 ): Promise<HardhatRuntimeEnvironment> {
   return HardhatRuntimeEnvironmentImplementation.create(
     config,
-    userProvidedGlobalArguments,
+    userProvidedGlobalOptions,
     unsafeOptions,
   );
 }
 
 export { resolvePluginList } from "./internal/plugins/resolve-plugin-list.js";
-export { buildGlobalParameterMap } from "./internal/global-parameters.js";
+export { buildGlobalOptionsMap } from "./internal/global-options.js";

v-next/core/src/index.ts

@@ -0,0 +1,116 @@
+import type { ParameterTypeToValueType } from "../types/common.js";
+import type {
+  GlobalOptions,
+  GlobalOption,
+  GlobalOptionsMap,
+} from "../types/global-options.js";
+import type { HardhatPlugin } from "../types/plugins.js";
+
+import { HardhatError } from "@nomicfoundation/hardhat-errors";
+
+import { ParameterType } from "../types/common.js";
+
+import {
+  RESERVED_PARAMETER_NAMES,
+  isParameterValueValid,
+  isValidParamNameCasing,
+} from "./parameters.js";
+
+/**
+ * Builds a map of the global options, validating them.
+ *
+ * Note: this function can be used before initializing the HRE, so the plugins
+ * shouldn't be consider validated. Hence, we should validate the global
+ * parameters.
+ */
+export function buildGlobalOptionsMap(
+  resolvedPlugins: HardhatPlugin[],
+): GlobalOptionsMap {
+  const globalOptionsMap: GlobalOptionsMap = new Map();
+
+  for (const plugin of resolvedPlugins) {
+    if (plugin.globalOptions === undefined) {
+      continue;
+    }
+
+    for (const option of plugin.globalOptions) {
+      const existingByName = globalOptionsMap.get(option.name);
+      if (existingByName !== undefined) {
+        throw new HardhatError(
+          HardhatError.ERRORS.GENERAL.GLOBAL_OPTION_ALREADY_DEFINED,
+          {
+            plugin: plugin.id,
+            globalOption: option.name,
+            definedByPlugin: existingByName.pluginId,
+          },
+        );
+      }
+
+      const validatedGlobalOption = buildGlobalOptionDefinition(option);
+
+      const mapEntry = {
+        pluginId: plugin.id,
+        option: validatedGlobalOption,
+      };
+
+      globalOptionsMap.set(validatedGlobalOption.name, mapEntry);
+    }
+  }
+
+  return globalOptionsMap;
+}
+
+export function buildGlobalOptionDefinition<T extends ParameterType>({
+  name,
+  description,
+  parameterType,
+  defaultValue,
+}: {
+  name: string;
+  description: string;
+  parameterType?: T;
+  defaultValue: ParameterTypeToValueType<T>;
+}): GlobalOption {
+  const type = parameterType ?? ParameterType.STRING;
+
+  if (!isValidParamNameCasing(name)) {
+    throw new HardhatError(HardhatError.ERRORS.ARGUMENTS.INVALID_NAME, {
+      name,
+    });
+  }
+
+  if (RESERVED_PARAMETER_NAMES.has(name)) {
+    throw new HardhatError(HardhatError.ERRORS.ARGUMENTS.RESERVED_NAME, {
+      name,
+    });
+  }
+
+  if (!isParameterValueValid(type, defaultValue)) {
+    throw new HardhatError(
+      HardhatError.ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE,
+      {
+        value: defaultValue,
+        name: "defaultValue",
+        type: parameterType,
+      },
+    );
+  }
+
+  return {
+    name,
+    description,
+    parameterType: type,
+    defaultValue,
+  };
+}
+
+export function resolveGlobalOptions(
+  userProvidedGlobalOptions: Partial<GlobalOptions>,
+  _globalOptionsMap: GlobalOptionsMap,
+): GlobalOptions {
+  // TODO: Validate the userProvidedGlobalOptions and get the remaining ones
+  // from env variables
+
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- TODO
+  return userProvidedGlobalOptions as GlobalOptions;
+}