hardhat 3.8.0 → 3.9.1

package/src/config.ts

@@ -7,6 +7,9 @@ import type { HardhatUserConfig } from "./types/config.js";
 
 import { throwUsingHardhat2PluginError } from "./internal/using-hardhat2-plugin-errors.js";
 
+const DEFINE_PLUGIN_MIGRATION_HINT =
+  "To migrate a plugin to Hardhat 3, export a plugin object with definePlugin from hardhat/plugins and register hook handlers in its hookHandlers field.";
+
 /**
  * Defines a Hardhat user config.
  *
@@ -42,33 +45,42 @@ export function defineConfig(config: HardhatUserConfig): HardhatUserConfig {
  * @deprecated This function is part of the Hardhat 2 plugin API.
  */
 export function extendConfig(..._args: any): any {
-  throwUsingHardhat2PluginError();
+  throwUsingHardhat2PluginError("extendConfig", DEFINE_PLUGIN_MIGRATION_HINT);
 }
 
 /**
  * @deprecated This function is part of the Hardhat 2 plugin API.
  */
 export function extendEnvironment(..._args: any): any {
-  throwUsingHardhat2PluginError();
+  throwUsingHardhat2PluginError(
+    "extendEnvironment",
+    DEFINE_PLUGIN_MIGRATION_HINT,
+  );
 }
 
 /**
  * @deprecated This function is part of the Hardhat 2 plugin API.
  */
 export function extendProvider(..._args: any): any {
-  throwUsingHardhat2PluginError();
+  throwUsingHardhat2PluginError("extendProvider", DEFINE_PLUGIN_MIGRATION_HINT);
 }
 
 /**
  * @deprecated This function is part of the Hardhat 2 plugin API.
  */
 export function scope(..._args: any): any {
-  throwUsingHardhat2PluginError();
+  throwUsingHardhat2PluginError(
+    "scope",
+    "To migrate tasks to Hardhat 3, define them with task or emptyTask from hardhat/config and include them in a plugin exported with definePlugin from hardhat/plugins.",
+  );
 }
 
 /**
  * @deprecated This function is part of the Hardhat 2 plugin API.
  */
 export function subtask(..._args: any): any {
-  throwUsingHardhat2PluginError();
+  throwUsingHardhat2PluginError(
+    "subtask",
+    "To migrate subtasks to Hardhat 3, define them as nested tasks with task or emptyTask from hardhat/config and include them in a plugin exported with definePlugin from hardhat/plugins.",
+  );
 }

package/src/hhu.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+
+import { exitIfNodeVersionNotSupported } from "./internal/cli/node-version.js";
+
+// We enable the sourcemaps before loading main, so that everything except this
+// small file is loaded with sourcemaps enabled.
+process.setSourceMapsEnabled(true);
+
+// We check the Node.js version before loading main, so that if there is some
+// unsupported js syntax or Node API elsewhere, we get to exit with a clear
+// error before crashing.
+exitIfNodeVersionNotSupported();
+
+// eslint-disable-next-line no-restricted-syntax -- Allow top-level await here
+const { main } = await import("./internal/cli/hhu.js");
+
+// eslint-disable-next-line no-restricted-syntax -- We do want TLA here
+await main(process.argv.slice(2));

package/src/internal/builtin-plugins/artifacts/hook-handlers/hre.ts

@@ -4,6 +4,11 @@ import type {
   StringWithArtifactContractNamesAutocompletion,
 } from "../../../../types/artifacts.js";
 import type { HardhatRuntimeEnvironmentHooks } from "../../../../types/hooks.js";
+import type { ArtifactManagerImplementation as ArtifactManagerImplementationT } from "../artifact-manager.js";
+
+let ArtifactManagerImplementation:
+  | typeof ArtifactManagerImplementationT
+  | undefined;
 
 class LazyArtifactManager implements ArtifactManager {
   readonly #artifactsPath: string;
@@ -85,10 +90,13 @@ class LazyArtifactManager implements ArtifactManager {
   }
 
   async #getArtifactManager(): Promise<ArtifactManager> {
-    if (this.#artifactManager === undefined) {
-      const { ArtifactManagerImplementation } = await import(
+    if (ArtifactManagerImplementation === undefined) {
+      ({ ArtifactManagerImplementation } = await import(
         "../artifact-manager.js"
-      );
+      ));
+    }
+
+    if (this.#artifactManager === undefined) {
       this.#artifactManager = new ArtifactManagerImplementation(
         this.#artifactsPath,
       );

package/src/internal/builtin-plugins/coverage/config.ts

@@ -0,0 +1,28 @@
+import type { HardhatUserConfig } from "../../../config.js";
+import type { CoverageConfig } from "../../../types/config.js";
+import type { HardhatUserConfigValidationError } from "../../../types/hooks.js";
+
+import { validateUserConfigZodType } from "@nomicfoundation/hardhat-zod-utils";
+import { z } from "zod";
+
+const userConfigType = z.object({
+  coverage: z
+    .object({
+      skipFiles: z.array(z.string()).optional(),
+    })
+    .optional(),
+});
+
+export function validateCoverageUserConfig(
+  userConfig: unknown,
+): HardhatUserConfigValidationError[] {
+  return validateUserConfigZodType(userConfig, userConfigType);
+}
+
+export function resolveCoverageConfig(
+  userConfig: HardhatUserConfig,
+): CoverageConfig {
+  return {
+    skipFiles: userConfig.coverage?.skipFiles ?? [],
+  };
+}

package/src/internal/builtin-plugins/coverage/hook-handlers/config.ts

@@ -0,0 +1,30 @@
+import type { ConfigHooks } from "../../../../types/hooks.js";
+
+import {
+  resolveCoverageConfig,
+  validateCoverageUserConfig,
+} from "../config.js";
+
+export default async (): Promise<Partial<ConfigHooks>> => {
+  const handlers: Partial<ConfigHooks> = {
+    validateUserConfig: async (userConfig) =>
+      validateCoverageUserConfig(userConfig),
+    resolveUserConfig: async (
+      userConfig,
+      resolveConfigurationVariable,
+      next,
+    ) => {
+      const resolvedConfig = await next(
+        userConfig,
+        resolveConfigurationVariable,
+      );
+
+      return {
+        ...resolvedConfig,
+        coverage: resolveCoverageConfig(userConfig),
+      };
+    },
+  };
+
+  return handlers;
+};

package/src/internal/builtin-plugins/coverage/hook-handlers/solidity.ts

@@ -8,6 +8,8 @@ import { HardhatError } from "@nomicfoundation/hardhat-errors";
 import { createDebug } from "@nomicfoundation/hardhat-utils/debug";
 import { ensureError } from "@nomicfoundation/hardhat-utils/error";
 
+import { matchesAnyGlob } from "../../../utils/glob.js";
+import { toUserSourceName } from "../../solidity/source-names.js";
 import { getCoverageManager } from "../helpers/accessors.js";
 import { instrumentSolidityFileForCompilationJob } from "../instrumentation.js";
 
@@ -22,12 +24,23 @@ export default async (): Promise<Partial<SolidityHooks>> => ({
     solcVersion,
     next,
   ) => {
+    // This hook runs on every project file of every build. Coverage is the
+    // only reason to preprocess them, so when it is off we pass the file
+    // through untouched and keep the common path free of the work below.
+    if (!context.globalOptions.coverage) {
+      return await next(context, sourceName, fsPath, fileContent, solcVersion);
+    }
+
     // NOTE: We do not want to instrument the test project files as we don't
     // want to report coverage for them.
-
     const isTestSource = (await context.solidity.getScope(fsPath)) === "tests";
 
-    if (context.globalOptions.coverage && !isTestSource) {
+    const isSkipped = matchesAnyGlob(
+      toUserSourceName(sourceName),
+      context.config.coverage.skipFiles,
+    );
+
+    if (!isTestSource && !isSkipped) {
       try {
         const { source, metadata } = instrumentSolidityFileForCompilationJob({
           compilationJobSolcVersion: solcVersion,

package/src/internal/builtin-plugins/coverage/index.ts

@@ -16,6 +16,7 @@ const hardhatPlugin: HardhatPlugin = definePlugin({
   ],
   hookHandlers: {
     clean: () => import("./hook-handlers/clean.js"),
+    config: () => import("./hook-handlers/config.js"),
     hre: () => import("./hook-handlers/hre.js"),
     solidity: () => import("./hook-handlers/solidity.js"),
     test: () => import("./hook-handlers/test.js"),

package/src/internal/builtin-plugins/coverage/type-extensions.ts

@@ -3,3 +3,27 @@ declare module "../../../types/global-options.js" {
     coverage: boolean;
   }
 }
+
+declare module "../../../types/config.js" {
+  export interface CoverageUserConfig {
+    /**
+     * Globs of Solidity source files to exclude from coverage instrumentation.
+     * A project file whose project-relative source name matches any of these
+     * globs is not instrumented during a `--coverage` run, and so does not
+     * appear in coverage reports.
+     */
+    skipFiles?: string[];
+  }
+
+  export interface HardhatUserConfig {
+    coverage?: CoverageUserConfig;
+  }
+
+  export interface CoverageConfig {
+    skipFiles: string[];
+  }
+
+  export interface HardhatConfig {
+    coverage: CoverageConfig;
+  }
+}

package/src/internal/builtin-plugins/gas-analytics/function-gas-snapshots.ts

@@ -64,7 +64,7 @@ export interface FunctionGasSnapshotChange {
 export interface FunctionGasSnapshotCheckResult {
   passed: boolean;
   comparison: FunctionGasSnapshotComparison;
-  written: boolean;
+  noBaseline: boolean;
 }
 
 export function getFunctionGasSnapshotsPath(basePath: string): string {
@@ -323,16 +323,17 @@ export async function checkFunctionGasSnapshots(
     previousFunctionGasSnapshots = await readFunctionGasSnapshots(basePath);
   } catch (error) {
     if (error instanceof FileNotFoundError) {
-      await writeFunctionGasSnapshots(basePath, functionGasSnapshots);
-
+      // Running a check without a stored snapshot is a mistake: fail so it's
+      // caught, but only when this run actually produced something to check.
+      const noBaseline = functionGasSnapshots.length > 0;
       return {
-        passed: true,
+        passed: !noBaseline,
         comparison: {
           added: [],
           removed: [],
           changed: [],
         },
-        written: true,
+        noBaseline,
       };
     }
 
@@ -344,59 +345,54 @@ export async function checkFunctionGasSnapshots(
     functionGasSnapshots,
   );
 
-  // Update snapshots when functions are added or removed (but not changed)
-  const hasAddedOrRemoved =
-    comparison.added.length > 0 || comparison.removed.length > 0;
-  if (comparison.changed.length === 0 && hasAddedOrRemoved) {
-    await writeFunctionGasSnapshots(basePath, functionGasSnapshots);
-  }
-
   return {
     passed: comparison.changed.length === 0,
     comparison,
-    written: hasAddedOrRemoved,
+    noBaseline: false,
   };
 }
 
 export function logFunctionGasSnapshotsSection(
   result: FunctionGasSnapshotCheckResult,
   logger: typeof console.log = console.log,
+  isFiltered = false,
 ): void {
-  const { comparison, written } = result;
+  const { comparison, noBaseline } = result;
   const changedLength = comparison.changed.length;
-  const addedLength = comparison.added.length;
-  const removedLength = comparison.removed.length;
   const hasChanges = changedLength > 0;
+  // On a filtered run (--grep or specific files), added and missing snapshots
+  // are mostly artifacts of the filter rather than real differences, so we
+  // don't report them.
+  const addedLength = isFiltered ? 0 : comparison.added.length;
+  const removedLength = isFiltered ? 0 : comparison.removed.length;
   const hasAdded = addedLength > 0;
   const hasRemoved = removedLength > 0;
   const hasAnyDifferences = hasChanges || hasAdded || hasRemoved;
-  const isFirstTimeWrite = written && !hasAnyDifferences;
 
   // Nothing to report
-  if (!isFirstTimeWrite && !hasAnyDifferences) {
+  if (!noBaseline && !hasAnyDifferences) {
     return;
   }
 
-  logger(
-    formatSectionHeader("Function gas snapshots", {
-      changedLength,
-      addedLength,
-      removedLength,
-    }),
-  );
-
-  if (isFirstTimeWrite) {
-    logger();
+  if (noBaseline) {
     logger(
       styleText(
-        "green",
-        "  No existing snapshots found. Function gas snapshots written successfully",
+        "yellow",
+        "Function gas snapshots: no snapshot found. Run your tests with --snapshot to create one.",
       ),
     );
     logger();
     return;
   }
 
+  logger(
+    formatSectionHeader("Function gas snapshots", {
+      changedLength,
+      addedLength,
+      removedLength,
+    }),
+  );
+
   if (hasChanges) {
     logger();
     printFunctionGasSnapshotChanges(comparison.changed, logger);
@@ -404,7 +400,9 @@ export function logFunctionGasSnapshotsSection(
 
   if (hasAdded) {
     logger();
-    logger(`  Added ${comparison.added.length} function(s):`);
+    logger(
+      `  ${comparison.added.length} function(s) produced by this run are not in the snapshot:`,
+    );
     const addedLines = stringifyFunctionGasSnapshots(comparison.added).split(
       "\n",
     );
@@ -415,7 +413,9 @@ export function logFunctionGasSnapshotsSection(
 
   if (hasRemoved) {
     logger();
-    logger(`  Removed ${comparison.removed.length} function(s):`);
+    logger(
+      `  ${comparison.removed.length} stored function(s) were not produced by this run:`,
+    );
     const removedLines = stringifyFunctionGasSnapshots(
       comparison.removed,
     ).split("\n");

package/src/internal/builtin-plugins/gas-analytics/snapshot-cheatcodes.ts

@@ -78,7 +78,7 @@ export interface SnapshotCheatcodesComparison {
 export interface SnapshotCheatcodesCheckResult {
   passed: boolean;
   comparison: SnapshotCheatcodesComparison;
-  written: boolean;
+  noBaseline: boolean;
   renamedGroups: RenamedSnapshotGroup[];
 }
 
@@ -363,20 +363,17 @@ export async function checkSnapshotCheatcodes(
     previousSnapshotCheatcodes = await readSnapshotCheatcodes(basePath);
   } catch (error) {
     if (error instanceof FileNotFoundError) {
-      // Only write if there are cheatcodes to save
-      const written = snapshotCheatcodes.size > 0;
-      if (written) {
-        await writeSnapshotCheatcodes(basePath, snapshotCheatcodes);
-      }
-
+      // Running a check without stored snapshots is a mistake: fail so it's
+      // caught, but only when this run actually produced something to check.
+      const noBaseline = snapshotCheatcodes.size > 0;
       return {
-        passed: true,
+        passed: !noBaseline,
         comparison: {
           added: [],
           removed: [],
           changed: [],
         },
-        written,
+        noBaseline,
         renamedGroups,
       };
     }
@@ -389,17 +386,10 @@ export async function checkSnapshotCheatcodes(
     snapshotCheatcodes,
   );
 
-  // Update snapshots when functions are added or removed (but not changed)
-  const hasAddedOrRemoved =
-    comparison.added.length > 0 || comparison.removed.length > 0;
-  if (comparison.changed.length === 0 && hasAddedOrRemoved) {
-    await writeSnapshotCheatcodes(basePath, snapshotCheatcodes);
-  }
-
   return {
     passed: comparison.changed.length === 0,
     comparison,
-    written: hasAddedOrRemoved,
+    noBaseline: false,
     renamedGroups,
   };
 }
@@ -407,42 +397,44 @@ export async function checkSnapshotCheatcodes(
 export function logSnapshotCheatcodesSection(
   result: SnapshotCheatcodesCheckResult,
   logger: typeof console.log = console.log,
+  isFiltered = false,
 ): void {
-  const { comparison, written } = result;
+  const { comparison, noBaseline } = result;
   const changedLength = comparison.changed.length;
-  const addedLength = comparison.added.length;
-  const removedLength = comparison.removed.length;
   const hasChanges = changedLength > 0;
+  // On a filtered run (--grep or specific files), added and missing snapshots
+  // are mostly artifacts of the filter rather than real differences, so we
+  // don't report them.
+  const addedLength = isFiltered ? 0 : comparison.added.length;
+  const removedLength = isFiltered ? 0 : comparison.removed.length;
   const hasAdded = addedLength > 0;
   const hasRemoved = removedLength > 0;
   const hasAnyDifferences = hasChanges || hasAdded || hasRemoved;
-  const isFirstTimeWrite = written && !hasAnyDifferences;
 
   // Nothing to report
-  if (!isFirstTimeWrite && !hasAnyDifferences) {
+  if (!noBaseline && !hasAnyDifferences) {
     return;
   }
 
-  logger(
-    formatSectionHeader("Snapshot cheatcodes", {
-      changedLength,
-      addedLength,
-      removedLength,
-    }),
-  );
-
-  if (isFirstTimeWrite) {
-    logger();
+  if (noBaseline) {
     logger(
       styleText(
-        "green",
-        "  No existing snapshots found. Snapshot cheatcodes written successfully",
+        "yellow",
+        "Snapshot cheatcodes: no snapshots found. Run your tests with --snapshot to create one.",
       ),
     );
     logger();
     return;
   }
 
+  logger(
+    formatSectionHeader("Snapshot cheatcodes", {
+      changedLength,
+      addedLength,
+      removedLength,
+    }),
+  );
+
   if (hasChanges) {
     logger();
     printSnapshotCheatcodeChanges(comparison.changed, logger);
@@ -450,7 +442,9 @@ export function logSnapshotCheatcodesSection(
 
   if (hasAdded) {
     logger();
-    logger(`  Added ${comparison.added.length} snapshot(s):`);
+    logger(
+      `  ${comparison.added.length} snapshot(s) produced by this run are not in the snapshot:`,
+    );
     const addedLines = stringifySnapshotCheatcodes(comparison.added).split(
       "\n",
     );
@@ -461,7 +455,9 @@ export function logSnapshotCheatcodesSection(
 
   if (hasRemoved) {
     logger();
-    logger(`  Removed ${comparison.removed.length} snapshot(s):`);
+    logger(
+      `  ${comparison.removed.length} stored snapshot(s) were not produced by this run:`,
+    );
     const removedLines = stringifySnapshotCheatcodes(comparison.removed).split(
       "\n",
     );

package/src/internal/builtin-plugins/gas-analytics/tasks/solidity-test/task-action.ts

@@ -31,6 +31,9 @@ import {
 interface GasAnalyticsTestActionArguments {
   snapshot: boolean;
   snapshotCheck: boolean;
+  // Forwarded from the base `test solidity` task; used to detect scoped runs.
+  grep?: string;
+  testFiles?: string[];
 }
 
 export interface SnapshotResult {
@@ -74,7 +77,11 @@ const runSolidityTests: TaskOverrideActionFunction<
       rootPath,
       suiteResults,
     );
-    logSnapshotCheckResult(snapshotCheckResult);
+    // On a scoped run, added/missing snapshots are expected, so don't report
+    // them (they'd be noise from the filter, not real differences).
+    const isFiltered =
+      args.grep !== undefined || (args.testFiles?.length ?? 0) > 0;
+    logSnapshotCheckResult(snapshotCheckResult, console.log, isFiltered);
     snapshotCheckPassed =
       snapshotCheckResult.functionGasSnapshotsCheck.passed &&
       snapshotCheckResult.snapshotCheatcodesCheck.passed;
@@ -141,6 +148,7 @@ export async function handleSnapshotCheck(
 export function logSnapshotCheckResult(
   { functionGasSnapshotsCheck, snapshotCheatcodesCheck }: SnapshotCheckResult,
   logger: typeof console.log = console.log,
+  isFiltered = false,
 ): void {
   logger(
     functionGasSnapshotsCheck.passed && snapshotCheatcodesCheck.passed
@@ -148,23 +156,28 @@ export function logSnapshotCheckResult(
       : styleText("red", "Snapshot check failed"),
   );
 
+  // On a filtered run, added/removed aren't reported, so they don't count
+  // towards a section having output (which drives the spacing below).
+  const showAddedRemoved = !isFiltered;
   const functionGasHasOutput =
-    functionGasSnapshotsCheck.written ||
+    functionGasSnapshotsCheck.noBaseline ||
     functionGasSnapshotsCheck.comparison.changed.length > 0 ||
-    functionGasSnapshotsCheck.comparison.added.length > 0 ||
-    functionGasSnapshotsCheck.comparison.removed.length > 0;
+    (showAddedRemoved &&
+      (functionGasSnapshotsCheck.comparison.added.length > 0 ||
+        functionGasSnapshotsCheck.comparison.removed.length > 0));
   const snapshotCheatcodesHasOutput =
-    snapshotCheatcodesCheck.written ||
+    snapshotCheatcodesCheck.noBaseline ||
     snapshotCheatcodesCheck.comparison.changed.length > 0 ||
-    snapshotCheatcodesCheck.comparison.added.length > 0 ||
-    snapshotCheatcodesCheck.comparison.removed.length > 0;
+    (showAddedRemoved &&
+      (snapshotCheatcodesCheck.comparison.added.length > 0 ||
+        snapshotCheatcodesCheck.comparison.removed.length > 0));
 
   // Add an extra newline if function gas snapshots have output
   if (functionGasHasOutput) {
     logger();
   }
 
-  logFunctionGasSnapshotsSection(functionGasSnapshotsCheck, logger);
+  logFunctionGasSnapshotsSection(functionGasSnapshotsCheck, logger, isFiltered);
 
   // Add an extra newline if only snapshot cheatcodes have output
   // (logFunctionGasSnapshotsSection adds one if it has output)
@@ -172,7 +185,7 @@ export function logSnapshotCheckResult(
     logger();
   }
 
-  logSnapshotCheatcodesSection(snapshotCheatcodesCheck, logger);
+  logSnapshotCheatcodesSection(snapshotCheatcodesCheck, logger, isFiltered);
 
   // Add an extra newline if only the rename warnings have output
   // (logSnapshotCheatcodesSection adds one if it has output)

package/src/internal/builtin-plugins/hhu/index.ts

@@ -0,0 +1,13 @@
+import type { HardhatPlugin } from "../../../types/plugins.js";
+
+import { definePlugin } from "../../../plugins.js";
+
+import { generateTasks } from "./tasks/index.js";
+
+const hardhatPlugin: HardhatPlugin = definePlugin({
+  id: "builtin:hhu",
+  tasks: generateTasks({ prefixWithUtils: true }),
+  npmPackage: "hardhat",
+});
+
+export default hardhatPlugin;

package/src/internal/builtin-plugins/hhu/tasks/constants/index.ts

@@ -0,0 +1,18 @@
+import type { UtilsTaskDefinition } from "../../types.js";
+
+import { emptyTask, task } from "../../../../core/config.js";
+import { buildUtilsTask } from "../utils-task.js";
+
+export function constants(prefix: string[]): UtilsTaskDefinition[] {
+  const constantsTask = emptyTask(
+    [...prefix, "constants"],
+    "Commonly used Ethereum constants",
+  ).build();
+
+  const zeroAddressTask = buildUtilsTask(
+    task([...prefix, "constants", "zero-address"], "Print the zero address"),
+    async () => await import("./zero-address.js"),
+  );
+
+  return [constantsTask, zeroAddressTask];
+}

package/src/internal/builtin-plugins/hhu/tasks/constants/zero-address.ts

@@ -0,0 +1,9 @@
+import type { NewUtilsTaskActionFunction } from "../../types.js";
+
+const zeroAddress = "0x0000000000000000000000000000000000000000";
+
+const zeroAddressAction: NewUtilsTaskActionFunction = async () => {
+  console.log(zeroAddress);
+};
+
+export default zeroAddressAction;

package/src/internal/builtin-plugins/hhu/tasks/convert/index.ts

@@ -0,0 +1,40 @@
+import type { UtilsTaskDefinition } from "../../types.js";
+
+import { ArgumentType } from "../../../../../types/arguments.js";
+import { emptyTask, task } from "../../../../core/config.js";
+import { buildUtilsTask } from "../utils-task.js";
+
+export function convert(prefix: string[]): UtilsTaskDefinition[] {
+  const convertTask = emptyTask(
+    [...prefix, "convert"],
+    "Convert values between common Ethereum representations",
+  ).build();
+
+  const padTask = buildUtilsTask(
+    task(
+      [...prefix, "convert", "pad"],
+      "Pad a hex string to a given byte length",
+    )
+      .addPositionalArgument({
+        name: "value",
+        description: "The hex string to pad",
+      })
+      .addOption({
+        name: "length",
+        description: "The target length, in bytes",
+        type: ArgumentType.INT,
+        defaultValue: 32,
+      })
+      .addFlag({
+        name: "left",
+        description: "Pad to the left (default)",
+      })
+      .addFlag({
+        name: "right",
+        description: "Pad to the right",
+      }),
+    async () => await import("./pad.js"),
+  );
+
+  return [convertTask, padTask];
+}