hardhat 2.17.4 → 2.18.1

package/src/internal/cli/ArgumentsParser.ts

@@ -1,11 +1,14 @@
+import { TASK_HELP } from "../../builtin-tasks/task-names";
 import {
   CLIArgumentType,
   HardhatArguments,
   HardhatParamDefinitions,
   ParamDefinition,
   ParamDefinitionsMap,
+  ScopesMap,
   TaskArguments,
   TaskDefinition,
+  TasksMap,
 } from "../../types";
 import { HardhatError } from "../core/errors";
 import { ERRORS } from "../core/errors-list";
@@ -50,19 +53,20 @@ export class ArgumentsParser {
     rawCLAs: string[]
   ): {
     hardhatArguments: HardhatArguments;
-    taskName?: string;
-    unparsedCLAs: string[];
+    scopeOrTaskName: string | undefined;
+    allUnparsedCLAs: string[];
   } {
     const hardhatArguments: Partial<HardhatArguments> = {};
-    let taskName: string | undefined;
-    const unparsedCLAs: string[] = [];
+    let scopeOrTaskName: string | undefined;
+    const allUnparsedCLAs: string[] = [];
 
     for (let i = 0; i < rawCLAs.length; i++) {
       const arg = rawCLAs[i];
 
-      if (taskName === undefined) {
+      if (scopeOrTaskName === undefined) {
         if (!this._hasCLAParamNameFormat(arg)) {
-          taskName = arg;
+          scopeOrTaskName = arg;
+          allUnparsedCLAs.push(arg);
           continue;
         }
 
@@ -78,11 +82,11 @@ export class ArgumentsParser {
           i,
           hardhatParamDefinitions,
           hardhatArguments,
-          taskName
+          scopeOrTaskName
         );
       } else {
         if (!this._isCLAParamName(arg, hardhatParamDefinitions)) {
-          unparsedCLAs.push(arg);
+          allUnparsedCLAs.push(arg);
           continue;
         }
 
@@ -91,7 +95,7 @@ export class ArgumentsParser {
           i,
           hardhatParamDefinitions,
           hardhatArguments,
-          taskName
+          scopeOrTaskName
         );
       }
     }
@@ -102,11 +106,73 @@ export class ArgumentsParser {
         envVariableArguments,
         hardhatArguments
       ),
-      taskName,
-      unparsedCLAs,
+      scopeOrTaskName,
+      allUnparsedCLAs,
     };
   }
 
+  public parseScopeAndTaskNames(
+    allUnparsedCLAs: string[],
+    taskDefinitions: TasksMap,
+    scopeDefinitions: ScopesMap
+  ): {
+    scopeName?: string;
+    taskName: string;
+    unparsedCLAs: string[];
+  } {
+    const [firstCLA, secondCLA] = allUnparsedCLAs;
+
+    if (allUnparsedCLAs.length === 0) {
+      return {
+        taskName: TASK_HELP,
+        unparsedCLAs: [],
+      };
+    } else if (allUnparsedCLAs.length === 1) {
+      if (scopeDefinitions[firstCLA] !== undefined) {
+        // this is a bit of a hack, but it's the easiest way to print
+        // the help of a scope when no task is specified
+        return {
+          taskName: TASK_HELP,
+          unparsedCLAs: [firstCLA],
+        };
+      } else if (taskDefinitions[firstCLA] !== undefined) {
+        return {
+          taskName: firstCLA,
+          unparsedCLAs: allUnparsedCLAs.slice(1),
+        };
+      } else {
+        throw new HardhatError(ERRORS.ARGUMENTS.UNRECOGNIZED_TASK, {
+          task: firstCLA,
+        });
+      }
+    } else {
+      const scopeDefinition = scopeDefinitions[firstCLA];
+      if (scopeDefinition !== undefined) {
+        if (scopeDefinition.tasks[secondCLA] !== undefined) {
+          return {
+            scopeName: firstCLA,
+            taskName: secondCLA,
+            unparsedCLAs: allUnparsedCLAs.slice(2),
+          };
+        } else {
+          throw new HardhatError(ERRORS.ARGUMENTS.UNRECOGNIZED_SCOPED_TASK, {
+            scope: firstCLA,
+            task: secondCLA,
+          });
+        }
+      } else if (taskDefinitions[firstCLA] !== undefined) {
+        return {
+          taskName: firstCLA,
+          unparsedCLAs: allUnparsedCLAs.slice(1),
+        };
+      } else {
+        throw new HardhatError(ERRORS.ARGUMENTS.UNRECOGNIZED_TASK, {
+          task: firstCLA,
+        });
+      }
+    }
+  }
+
   public parseTaskArguments(
     taskDefinition: TaskDefinition,
     rawCLAs: string[]
@@ -207,7 +273,7 @@ export class ArgumentsParser {
     index: number,
     paramDefinitions: ParamDefinitionsMap,
     parsedArguments: TaskArguments,
-    taskName?: string
+    scopeOrTaskName?: string
   ) {
     const claArg = rawCLAs[index];
     const paramName = ArgumentsParser.cLAToParamName(claArg);
@@ -228,7 +294,7 @@ export class ArgumentsParser {
       if (value === undefined) {
         throw new HardhatError(ERRORS.ARGUMENTS.MISSING_TASK_ARGUMENT, {
           param: ArgumentsParser.paramNameToCLA(paramName),
-          task: taskName ?? "help",
+          task: scopeOrTaskName ?? "help",
         });
       }
 

package/src/internal/cli/HelpPrinter.ts

@@ -2,6 +2,9 @@ import {
   HardhatParamDefinitions,
   ParamDefinition,
   ParamDefinitionsMap,
+  ScopeDefinition,
+  ScopesMap,
+  TaskDefinition,
   TasksMap,
 } from "../../types";
 import { HardhatError } from "../core/errors";
@@ -15,55 +18,69 @@ export class HelpPrinter {
     private readonly _executableName: string,
     private readonly _version: string,
     private readonly _hardhatParamDefinitions: HardhatParamDefinitions,
-    private readonly _tasks: TasksMap
+    private readonly _tasks: TasksMap,
+    private readonly _scopes: ScopesMap
   ) {}
 
   public printGlobalHelp(includeSubtasks = false) {
     console.log(`${this._programName} version ${this._version}\n`);
 
     console.log(
-      `Usage: ${this._executableName} [GLOBAL OPTIONS] <TASK> [TASK OPTIONS]\n`
+      `Usage: ${this._executableName} [GLOBAL OPTIONS] [SCOPE] <TASK> [TASK OPTIONS]\n`
     );
 
     console.log("GLOBAL OPTIONS:\n");
 
-    this._printParamDetails(this._hardhatParamDefinitions);
+    let length = this._printParamDetails(this._hardhatParamDefinitions);
 
     console.log("\n\nAVAILABLE TASKS:\n");
 
-    const tasksToShow: TasksMap = {};
-    for (const [taskName, taskDefinition] of Object.entries(this._tasks)) {
-      if (includeSubtasks || !taskDefinition.isSubtask) {
-        tasksToShow[taskName] = taskDefinition;
-      }
-    }
-
-    const nameLength = Object.keys(tasksToShow)
-      .map((n) => n.length)
-      .reduce((a, b) => Math.max(a, b), 0);
+    length = this._printTasks(this._tasks, includeSubtasks, length);
 
-    for (const name of Object.keys(tasksToShow).sort()) {
-      const { description = "" } = this._tasks[name];
+    if (Object.keys(this._scopes).length > 0) {
+      console.log("\n\nAVAILABLE TASK SCOPES:\n");
 
-      console.log(`  ${name.padEnd(nameLength)}\t${description}`);
+      this._printScopes(this._scopes, length);
     }
 
     console.log("");
 
     console.log(
-      `To get help for a specific task run: npx ${this._executableName} help [task]\n`
+      `To get help for a specific task run: npx ${this._executableName} help [SCOPE] <TASK>\n`
     );
   }
 
-  public printTaskHelp(taskName: string) {
-    const taskDefinition = this._tasks[taskName];
+  public printScopeHelp(
+    scopeDefinition: ScopeDefinition,
+    includeSubtasks = false
+  ) {
+    const name = scopeDefinition.name;
+    const description = scopeDefinition.description ?? "";
+
+    console.log(`${this._programName} version ${this._version}`);
 
-    if (taskDefinition === undefined) {
-      throw new HardhatError(ERRORS.ARGUMENTS.UNRECOGNIZED_TASK, {
-        task: taskName,
+    console.log(
+      `\nUsage: hardhat [GLOBAL OPTIONS] ${name} <TASK> [TASK OPTIONS]`
+    );
+
+    console.log(`\nAVAILABLE TASKS:\n`);
+
+    if (this._scopes[name] === undefined) {
+      throw new HardhatError(ERRORS.ARGUMENTS.UNRECOGNIZED_SCOPE, {
+        scope: name,
       });
     }
 
+    this._printTasks(this._scopes[name].tasks, includeSubtasks);
+
+    console.log(`\n${name}: ${description}`);
+
+    console.log(
+      `\nFor global options help run: ${this._executableName} help\n`
+    );
+  }
+
+  public printTaskHelp(taskDefinition: TaskDefinition) {
     const {
       description = "",
       name,
@@ -78,8 +95,11 @@ export class HelpPrinter {
       positionalParamDefinitions
     );
 
+    const scope =
+      taskDefinition.scope !== undefined ? `${taskDefinition.scope} ` : "";
+
     console.log(
-      `Usage: ${this._executableName} [GLOBAL OPTIONS] ${name}${paramsList}${positionalParamsList}\n`
+      `Usage: ${this._executableName} [GLOBAL OPTIONS] ${scope}${name}${paramsList}${positionalParamsList}\n`
     );
 
     if (Object.keys(paramDefinitions).length > 0) {
@@ -103,6 +123,49 @@ export class HelpPrinter {
     console.log(`For global options help run: ${this._executableName} help\n`);
   }
 
+  private _printTasks(
+    tasksMap: TasksMap,
+    includeSubtasks: boolean,
+    length: number = 0
+  ) {
+    const taskNameList = Object.entries(tasksMap)
+      .filter(
+        ([, taskDefinition]) => includeSubtasks || !taskDefinition.isSubtask
+      )
+      .map(([taskName]) => taskName)
+      .sort();
+
+    const nameLength = taskNameList
+      .map((n) => n.length)
+      .reduce((a, b) => Math.max(a, b), length);
+
+    for (const name of taskNameList) {
+      const { description = "" } = tasksMap[name];
+
+      console.log(`  ${name.padEnd(nameLength)}\t${description}`);
+    }
+
+    return nameLength;
+  }
+
+  private _printScopes(scopesMap: ScopesMap, length: number) {
+    const scopeNamesList = Object.entries(scopesMap)
+      .map(([scopeName]) => scopeName)
+      .sort();
+
+    const nameLength = scopeNamesList
+      .map((n) => n.length)
+      .reduce((a, b) => Math.max(a, b), length);
+
+    for (const name of scopeNamesList) {
+      const { description = "" } = scopesMap[name];
+
+      console.log(`  ${name.padEnd(nameLength)}\t${description}`);
+    }
+
+    return nameLength;
+  }
+
   private _getParamValueDescription<T>(paramDefinition: ParamDefinition<T>) {
     return `<${paramDefinition.type.name.toUpperCase()}>`;
   }
@@ -162,7 +225,7 @@ export class HelpPrinter {
     return paramsList;
   }
 
-  private _printParamDetails(paramDefinitions: ParamDefinitionsMap) {
+  private _printParamDetails(paramDefinitions: ParamDefinitionsMap): number {
     const paramsNameLength = Object.keys(paramDefinitions)
       .map((n) => ArgumentsParser.paramNameToCLA(n).length)
       .reduce((a, b) => Math.max(a, b), 0);
@@ -185,6 +248,8 @@ export class HelpPrinter {
 
       console.log(msg);
     }
+
+    return paramsNameLength;
   }
 
   private _printPositionalParamDetails(

package/src/internal/cli/cli.ts

@@ -127,15 +127,12 @@ async function main() {
 
     const argumentsParser = new ArgumentsParser();
 
-    const {
-      hardhatArguments,
-      taskName: parsedTaskName,
-      unparsedCLAs,
-    } = argumentsParser.parseHardhatArguments(
-      HARDHAT_PARAM_DEFINITIONS,
-      envVariableArguments,
-      process.argv.slice(2)
-    );
+    const { hardhatArguments, scopeOrTaskName, allUnparsedCLAs } =
+      argumentsParser.parseHardhatArguments(
+        HARDHAT_PARAM_DEFINITIONS,
+        envVariableArguments,
+        process.argv.slice(2)
+      );
 
     if (hardhatArguments.verbose) {
       Reporter.setVerbose(true);
@@ -160,13 +157,13 @@ async function main() {
     // The code marked with the tag #INIT-DEP can be deleted after HarhatV3 is out.
 
     // Create a new Hardhat project
-    if (parsedTaskName === "init") {
+    if (scopeOrTaskName === "init") {
       return await createNewProject();
     }
     // #INIT-DEP - START OF DEPRECATED CODE
     else {
       if (
-        parsedTaskName === undefined &&
+        scopeOrTaskName === undefined &&
         hardhatArguments.config === undefined &&
         !isCwdInsideProject()
       ) {
@@ -213,21 +210,29 @@ async function main() {
       }
     }
 
-    let taskName = parsedTaskName ?? TASK_HELP;
-
-    const showEmptyConfigWarning = true;
-    const showSolidityConfigWarnings = taskName === TASK_COMPILE;
-
     const ctx = HardhatContext.createHardhatContext();
 
     const { resolvedConfig, userConfig } = loadConfigAndTasks(
       hardhatArguments,
       {
-        showEmptyConfigWarning,
-        showSolidityConfigWarnings,
+        showEmptyConfigWarning: true,
+        showSolidityConfigWarnings: scopeOrTaskName === TASK_COMPILE,
       }
     );
 
+    const envExtenders = ctx.environmentExtenders;
+    const providerExtenders = ctx.providerExtenders;
+    const taskDefinitions = ctx.tasksDSL.getTaskDefinitions();
+    const scopesDefinitions = ctx.tasksDSL.getScopesDefinitions();
+
+    // eslint-disable-next-line prefer-const
+    let { scopeName, taskName, unparsedCLAs } =
+      argumentsParser.parseScopeAndTaskNames(
+        allUnparsedCLAs,
+        taskDefinitions,
+        scopesDefinitions
+      );
+
     let telemetryConsent: boolean | undefined = hasConsentedTelemetry();
 
     const isHelpCommand = hardhatArguments.help || taskName === TASK_HELP;
@@ -252,22 +257,34 @@ async function main() {
       Reporter.setEnabled(true);
     }
 
-    const envExtenders = ctx.environmentExtenders;
-    const providerExtenders = ctx.providerExtenders;
-    const taskDefinitions = ctx.tasksDSL.getTaskDefinitions();
-
     const [abortAnalytics, hitPromise] = await analytics.sendTaskHit();
 
     let taskArguments: TaskArguments;
 
     // --help is a also special case
     if (hardhatArguments.help && taskName !== TASK_HELP) {
-      taskArguments = { task: taskName };
+      // we "move" the task and scope names to the task arguments,
+      // and run the help task
+      if (scopeName !== undefined) {
+        taskArguments = { scopeOrTask: scopeName, task: taskName };
+      } else {
+        taskArguments = { scopeOrTask: taskName };
+      }
       taskName = TASK_HELP;
+      scopeName = undefined;
     } else {
-      const taskDefinition = taskDefinitions[taskName];
+      const taskDefinition = ctx.tasksDSL.getTaskDefinition(
+        scopeName,
+        taskName
+      );
 
       if (taskDefinition === undefined) {
+        if (scopeName !== undefined) {
+          throw new HardhatError(ERRORS.ARGUMENTS.UNRECOGNIZED_SCOPED_TASK, {
+            scope: scopeName,
+            task: taskName,
+          });
+        }
         throw new HardhatError(ERRORS.ARGUMENTS.UNRECOGNIZED_TASK, {
           task: taskName,
         });
@@ -289,6 +306,7 @@ async function main() {
       resolvedConfig,
       hardhatArguments,
       taskDefinitions,
+      scopesDefinitions,
       envExtenders,
       ctx.experimentalHardhatNetworkMessageTraceHooks,
       userConfig,
@@ -300,7 +318,7 @@ async function main() {
     try {
       const timestampBeforeRun = new Date().getTime();
 
-      await env.run(taskName, taskArguments);
+      await env.run({ scope: scopeName, task: taskName }, taskArguments);
 
       const timestampAfterRun = new Date().getTime();
 

package/src/internal/cli/project-creation.ts

@@ -30,35 +30,51 @@ import { Dependencies, PackageManager } from "./types";
 enum Action {
   CREATE_JAVASCRIPT_PROJECT_ACTION = "Create a JavaScript project",
   CREATE_TYPESCRIPT_PROJECT_ACTION = "Create a TypeScript project",
+  CREATE_TYPESCRIPT_VIEM_PROJECT_ACTION = "Create a TypeScript project (with Viem)",
   CREATE_EMPTY_HARDHAT_CONFIG_ACTION = "Create an empty hardhat.config.js",
   QUIT_ACTION = "Quit",
 }
 
 type SampleProjectTypeCreationAction =
   | Action.CREATE_JAVASCRIPT_PROJECT_ACTION
-  | Action.CREATE_TYPESCRIPT_PROJECT_ACTION;
+  | Action.CREATE_TYPESCRIPT_PROJECT_ACTION
+  | Action.CREATE_TYPESCRIPT_VIEM_PROJECT_ACTION;
 
 const HARDHAT_PACKAGE_NAME = "hardhat";
 
-const PROJECT_DEPENDENCIES: Dependencies = {
+const PROJECT_DEPENDENCIES: Dependencies = {};
+
+const ETHERS_PROJECT_DEPENDENCIES: Dependencies = {
   "@nomicfoundation/hardhat-toolbox": "^3.0.0",
 };
 
+const VIEM_PROJECT_DEPENDENCIES: Dependencies = {
+  "@nomicfoundation/hardhat-toolbox-viem": "^1.0.0",
+};
+
 const PEER_DEPENDENCIES: Dependencies = {
   hardhat: "^2.14.0",
   "@nomicfoundation/hardhat-network-helpers": "^1.0.0",
-  "@nomicfoundation/hardhat-chai-matchers": "^2.0.0",
-  "@nomicfoundation/hardhat-ethers": "^3.0.0",
   "@nomicfoundation/hardhat-verify": "^1.0.0",
   chai: "^4.2.0",
-  ethers: "^6.4.0",
   "hardhat-gas-reporter": "^1.0.8",
   "solidity-coverage": "^0.8.0",
+};
+
+const ETHERS_PEER_DEPENDENCIES: Dependencies = {
+  "@nomicfoundation/hardhat-chai-matchers": "^2.0.0",
+  "@nomicfoundation/hardhat-ethers": "^3.0.0",
+  ethers: "^6.4.0",
   "@typechain/hardhat": "^8.0.0",
   typechain: "^8.1.0",
   "@typechain/ethers-v6": "^0.4.0",
 };
 
+const VIEM_PEER_DEPENDENCIES: Dependencies = {
+  "@nomicfoundation/hardhat-viem": "^1.0.0",
+  viem: "^1.15.1",
+};
+
 const TYPESCRIPT_DEPENDENCIES: Dependencies = {};
 
 const TYPESCRIPT_PEER_DEPENDENCIES: Dependencies = {
@@ -69,6 +85,15 @@ const TYPESCRIPT_PEER_DEPENDENCIES: Dependencies = {
   typescript: ">=4.5.0",
 };
 
+const TYPESCRIPT_ETHERS_PEER_DEPENDENCIES: Dependencies = {
+  typescript: ">=4.5.0",
+};
+
+const TYPESCRIPT_VIEM_PEER_DEPENDENCIES: Dependencies = {
+  "@types/chai-as-promised": "^7.1.6",
+  typescript: "~5.0.4",
+};
+
 // generated with the "colossal" font
 function printAsciiLogo() {
   console.log(
@@ -130,6 +155,8 @@ async function copySampleProject(
         false,
         "Shouldn't try to create a TypeScript project in an ESM based project"
       );
+    } else if (projectType === Action.CREATE_TYPESCRIPT_VIEM_PROJECT_ACTION) {
+      sampleProjectName = "typescript-viem";
     } else {
       sampleProjectName = "typescript";
     }
@@ -262,26 +289,36 @@ async function getAction(isEsm: boolean): Promise<Action> {
         type: "select",
         message: "What do you want to do?",
         initial: 0,
-        choices: Object.values(Action).map((a: Action) => {
-          let message: string;
-          if (isEsm) {
-            if (a === Action.CREATE_EMPTY_HARDHAT_CONFIG_ACTION) {
-              message = a.replace(".js", ".cjs");
-            } else if (a === Action.CREATE_TYPESCRIPT_PROJECT_ACTION) {
-              message = `${a} (not available for ESM projects)`;
+        choices: Object.values(Action)
+          .filter((a: Action) => {
+            if (isEsm && a === Action.CREATE_TYPESCRIPT_VIEM_PROJECT_ACTION) {
+              // we omit the viem option for ESM projects to avoid showing
+              // two disabled options
+              return false;
+            }
+
+            return true;
+          })
+          .map((a: Action) => {
+            let message: string;
+            if (isEsm) {
+              if (a === Action.CREATE_EMPTY_HARDHAT_CONFIG_ACTION) {
+                message = a.replace(".js", ".cjs");
+              } else if (a === Action.CREATE_TYPESCRIPT_PROJECT_ACTION) {
+                message = `${a} (not available for ESM projects)`;
+              } else {
+                message = a;
+              }
             } else {
               message = a;
             }
-          } else {
-            message = a;
-          }
-
-          return {
-            name: a,
-            message,
-            value: a,
-          };
-        }),
+
+            return {
+              name: a,
+              message,
+              value: a,
+            };
+          }),
       },
     ]);
 
@@ -588,12 +625,13 @@ async function getDependencies(
     !(await doesNpmAutoInstallPeerDependencies());
 
   const shouldInstallTypescriptDependencies =
-    projectType === Action.CREATE_TYPESCRIPT_PROJECT_ACTION;
+    projectType === Action.CREATE_TYPESCRIPT_PROJECT_ACTION ||
+    projectType === Action.CREATE_TYPESCRIPT_VIEM_PROJECT_ACTION;
 
   const shouldInstallTypescriptPeerDependencies =
     shouldInstallTypescriptDependencies && shouldInstallPeerDependencies;
 
-  return {
+  const commonDependencies: Dependencies = {
     [HARDHAT_PACKAGE_NAME]: `^${(await getPackageJson()).version}`,
     ...PROJECT_DEPENDENCIES,
     ...(shouldInstallPeerDependencies ? PEER_DEPENDENCIES : {}),
@@ -602,4 +640,33 @@ async function getDependencies(
       ? TYPESCRIPT_PEER_DEPENDENCIES
       : {}),
   };
+
+  // At the moment, the default toolbox is the ethers based toolbox
+  const shouldInstallDefaultToolbox =
+    projectType !== Action.CREATE_TYPESCRIPT_VIEM_PROJECT_ACTION;
+
+  const ethersToolboxDependencies: Dependencies = {
+    ...ETHERS_PROJECT_DEPENDENCIES,
+    ...(shouldInstallPeerDependencies ? ETHERS_PEER_DEPENDENCIES : {}),
+    ...(shouldInstallTypescriptPeerDependencies
+      ? TYPESCRIPT_ETHERS_PEER_DEPENDENCIES
+      : {}),
+  };
+
+  const viemToolboxDependencies: Dependencies = {
+    ...VIEM_PROJECT_DEPENDENCIES,
+    ...(shouldInstallPeerDependencies ? VIEM_PEER_DEPENDENCIES : {}),
+    ...(shouldInstallTypescriptPeerDependencies
+      ? TYPESCRIPT_VIEM_PEER_DEPENDENCIES
+      : {}),
+  };
+
+  const toolboxDependencies: Dependencies = shouldInstallDefaultToolbox
+    ? ethersToolboxDependencies
+    : viemToolboxDependencies;
+
+  return {
+    ...commonDependencies,
+    ...toolboxDependencies,
+  };
 }

package/src/internal/core/config/config-env.ts

@@ -1,6 +1,7 @@
 import {
   ActionType,
   ConfigExtender,
+  ConfigurableScopeDefinition,
   ConfigurableTaskDefinition,
   EnvironmentExtender,
   ExperimentalHardhatNetworkMessageTraceHook,
@@ -116,6 +117,16 @@ export function subtask<TaskArgumentsT extends TaskArguments>(
 // Backwards compatibility alias
 export const internalTask = subtask;
 
+export function scope(
+  name: string,
+  description?: string
+): ConfigurableScopeDefinition {
+  const ctx = HardhatContext.getHardhatContext();
+  const dsl = ctx.tasksDSL;
+
+  return dsl.scope(name, description);
+}
+
 export const types = argumentTypes;
 
 /**