hardhat 2.13.0-dev.1 → 2.13.0-dev.3

package/sample-projects/typescript/scripts/deploy.ts

@@ -5,14 +5,14 @@ async function main() {
   const ONE_YEAR_IN_SECS = 365 * 24 * 60 * 60;
   const unlockTime = currentTimestampInSeconds + ONE_YEAR_IN_SECS;
 
-  const lockedAmount = ethers.utils.parseEther("1");
+  const lockedAmount = ethers.utils.parseEther("0.01");
 
   const Lock = await ethers.getContractFactory("Lock");
   const lock = await Lock.deploy(unlockTime, { value: lockedAmount });
 
   await lock.deployed();
 
-  console.log(`Lock with 1 ETH and unlock timestamp ${unlockTime} deployed to ${lock.address}`);
+  console.log(`Lock with 0.01 ETH and unlock timestamp ${unlockTime} deployed to ${lock.address}`);
 }
 
 // We recommend this pattern to be able to use async/await everywhere

package/sample-projects/typescript/tsconfig.json

@@ -5,6 +5,7 @@
     "esModuleInterop": true,
     "forceConsistentCasingInFileNames": true,
     "strict": true,
-    "skipLibCheck": true
+    "skipLibCheck": true,
+    "resolveJsonModule": true
   }
 }

package/src/builtin-tasks/compile.ts

@@ -73,6 +73,7 @@ import {
   TASK_COMPILE_SOLIDITY_RUN_SOLC,
   TASK_COMPILE_SOLIDITY_RUN_SOLCJS,
   TASK_COMPILE_REMOVE_OBSOLETE_ARTIFACTS,
+  TASK_COMPILE_TRANSFORM_IMPORT_NAME,
 } from "./task-names";
 import {
   getSolidityFilesCachePath,
@@ -90,11 +91,13 @@ type ArtifactsEmittedPerJob = Array<{
 }>;
 
 function isConsoleLogError(error: any): boolean {
+  const message = error.message;
+
   return (
     error.type === "TypeError" &&
-    typeof error.message === "string" &&
-    error.message.includes("log") &&
-    error.message.includes("type(library console)")
+    typeof message === "string" &&
+    message.includes("log") &&
+    message.includes("type(library console)")
   );
 }
 
@@ -157,6 +160,18 @@ subtask(TASK_COMPILE_SOLIDITY_READ_FILE)
     }
   );
 
+/**
+ * This task transform the string literal in an import directive.
+ * By default it does nothing, but it can be overriden by plugins.
+ */
+subtask(TASK_COMPILE_TRANSFORM_IMPORT_NAME)
+  .addParam("importName", undefined, undefined, types.string)
+  .setAction(
+    async ({ importName }: { importName: string }): Promise<string> => {
+      return importName;
+    }
+  );
+
 /**
  * Receives a list of source names and returns a dependency graph. This task
  * is responsible for both resolving dependencies (like getting files from
@@ -178,7 +193,9 @@ subtask(TASK_COMPILE_SOLIDITY_GET_DEPENDENCY_GRAPH)
         config.paths.root,
         parser,
         (absolutePath: string) =>
-          run(TASK_COMPILE_SOLIDITY_READ_FILE, { absolutePath })
+          run(TASK_COMPILE_SOLIDITY_READ_FILE, { absolutePath }),
+        (importName: string) =>
+          run(TASK_COMPILE_TRANSFORM_IMPORT_NAME, { importName })
       );
 
       const resolvedFiles = await Promise.all(
@@ -738,17 +755,21 @@ subtask(TASK_COMPILE_SOLIDITY_LOG_COMPILATION_ERRORS)
 
     for (const error of output.errors) {
       if (error.severity === "error") {
-        const errorMessage =
+        const errorMessage: string =
           getFormattedInternalCompilerErrorMessage(error) ??
           error.formattedMessage;
 
-        console.error(chalk.red(errorMessage));
+        console.error(errorMessage.replace(/^\w+:/, (t) => chalk.red.bold(t)));
       } else {
-        console.warn(chalk.yellow(error.formattedMessage));
+        console.warn(
+          (error.formattedMessage as string).replace(/^\w+:/, (t) =>
+            chalk.yellow.bold(t)
+          )
+        );
       }
     }
 
-    const hasConsoleErrors = output.errors.some(isConsoleLogError);
+    const hasConsoleErrors: boolean = output.errors.some(isConsoleLogError);
     if (hasConsoleErrors) {
       console.error(
         chalk.red(
@@ -1478,9 +1499,7 @@ function needsCompilation(
 }
 
 function hasCompilationErrors(output: any): boolean {
-  return (
-    output.errors && output.errors.some((x: any) => x.severity === "error")
-  );
+  return output.errors?.some((x: any) => x.severity === "error");
 }
 
 /**

package/src/builtin-tasks/flatten.ts

@@ -19,12 +19,23 @@ function getSortedFiles(dependenciesGraph: DependencyGraph) {
   const tsort = require("tsort");
   const graph = tsort();
 
+  // sort the graph entries to make the results deterministic
+  const dependencies = dependenciesGraph
+    .entries()
+    .sort(([a], [b]) => a.sourceName.localeCompare(b.sourceName));
+
   const filesMap: ResolvedFilesMap = {};
-  const resolvedFiles = dependenciesGraph.getResolvedFiles();
+  const resolvedFiles = dependencies.map(([file, _deps]) => file);
+
   resolvedFiles.forEach((f) => (filesMap[f.sourceName] = f));
 
-  for (const [from, deps] of dependenciesGraph.entries()) {
-    for (const to of deps) {
+  for (const [from, deps] of dependencies) {
+    // sort the dependencies to make the results deterministic
+    const sortedDeps = [...deps].sort((a, b) =>
+      a.sourceName.localeCompare(b.sourceName)
+    );
+
+    for (const to of sortedDeps) {
       graph.add(to.sourceName, from.sourceName);
     }
   }
@@ -113,7 +124,10 @@ subtask(TASK_FLATTEN_GET_DEPENDENCY_GRAPH)
     return dependencyGraph;
   });
 
-task(TASK_FLATTEN, "Flattens and prints contracts and their dependencies")
+task(
+  TASK_FLATTEN,
+  "Flattens and prints contracts and their dependencies. If no file is passed, all the contracts in the project will be flattened."
+)
   .addOptionalVariadicPositionalParam(
     "files",
     "The files to flatten",

package/src/builtin-tasks/help.ts

@@ -2,7 +2,6 @@ import { HelpPrinter } from "../internal/cli/HelpPrinter";
 import { HARDHAT_EXECUTABLE_NAME, HARDHAT_NAME } from "../internal/constants";
 import { task } from "../internal/core/config/config-env";
 import { HARDHAT_PARAM_DEFINITIONS } from "../internal/core/params/hardhat-params";
-import { getPackageJson } from "../internal/util/packageInfo";
 
 import { TASK_HELP } from "./task-names";
 
@@ -11,21 +10,21 @@ task(TASK_HELP, "Prints this message")
     "task",
     "An optional task to print more info about"
   )
-  .setAction(async ({ task: taskName }: { task?: string }, { tasks }) => {
-    const packageJson = await getPackageJson();
+  .setAction(
+    async ({ task: taskName }: { task?: string }, { tasks, version }) => {
+      const helpPrinter = new HelpPrinter(
+        HARDHAT_NAME,
+        HARDHAT_EXECUTABLE_NAME,
+        version,
+        HARDHAT_PARAM_DEFINITIONS,
+        tasks
+      );
 
-    const helpPrinter = new HelpPrinter(
-      HARDHAT_NAME,
-      HARDHAT_EXECUTABLE_NAME,
-      packageJson.version,
-      HARDHAT_PARAM_DEFINITIONS,
-      tasks
-    );
+      if (taskName !== undefined) {
+        helpPrinter.printTaskHelp(taskName);
+        return;
+      }
 
-    if (taskName !== undefined) {
-      helpPrinter.printTaskHelp(taskName);
-      return;
+      helpPrinter.printGlobalHelp();
     }
-
-    helpPrinter.printGlobalHelp();
-  });
+  );

package/src/builtin-tasks/task-names.ts

@@ -12,6 +12,8 @@ export const TASK_COMPILE_SOLIDITY_GET_SOURCE_PATHS =
 export const TASK_COMPILE_SOLIDITY_GET_SOURCE_NAMES =
   "compile:solidity:get-source-names";
 export const TASK_COMPILE_SOLIDITY_READ_FILE = "compile:solidity:read-file";
+export const TASK_COMPILE_TRANSFORM_IMPORT_NAME =
+  "compile:solidity:transform-import-name";
 export const TASK_COMPILE_SOLIDITY_GET_DEPENDENCY_GRAPH =
   "compile:solidity:get-dependency-graph";
 export const TASK_COMPILE_SOLIDITY_GET_COMPILATION_JOBS =

package/src/builtin-tasks/test.ts

@@ -5,11 +5,14 @@ import path from "path";
 
 import { HARDHAT_NETWORK_NAME } from "../internal/constants";
 import { subtask, task } from "../internal/core/config/config-env";
+import { HardhatError } from "../internal/core/errors";
+import { ERRORS } from "../internal/core/errors-list";
 import { isRunningWithTypescript } from "../internal/core/typescript-support";
 import { getForkCacheDirPath } from "../internal/hardhat-network/provider/utils/disk-cache";
 import { showForkRecommendationsBannerIfNecessary } from "../internal/hardhat-network/provider/utils/fork-recomendations-banner";
 import { pluralize } from "../internal/util/strings";
 import { getAllFilesMatching } from "../internal/util/fs-utils";
+import { getProjectPackageJson } from "../internal/util/packageInfo";
 
 import {
   TASK_COMPILE,
@@ -35,8 +38,9 @@ subtask(TASK_TEST_GET_TEST_FILES)
       return testFilesAbsolutePaths;
     }
 
-    const jsFiles = await getAllFilesMatching(config.paths.tests, (f) =>
-      f.endsWith(".js")
+    const jsFiles = await getAllFilesMatching(
+      config.paths.tests,
+      (f) => f.endsWith(".js") || f.endsWith(".cjs") || f.endsWith(".mjs")
     );
 
     if (!isRunningWithTypescript(config)) {
@@ -52,6 +56,7 @@ subtask(TASK_TEST_GET_TEST_FILES)
 
 subtask(TASK_TEST_SETUP_TEST_ENVIRONMENT, async () => {});
 
+let testsAlreadyRun = false;
 subtask(TASK_TEST_RUN_MOCHA_TESTS)
   .addFlag("parallel", "Run tests in parallel")
   .addFlag("bail", "Stop running tests after the first test failure")
@@ -99,6 +104,29 @@ subtask(TASK_TEST_RUN_MOCHA_TESTS)
       const mocha = new Mocha(mochaConfig);
       taskArgs.testFiles.forEach((file) => mocha.addFile(file));
 
+      // if the project is of type "module" or if there's some ESM test file,
+      // we call loadFilesAsync to enable Mocha's ESM support
+      const projectPackageJson = await getProjectPackageJson();
+      const isTypeModule = projectPackageJson.type === "module";
+      const hasEsmTest = taskArgs.testFiles.some((file) =>
+        file.endsWith(".mjs")
+      );
+      if (isTypeModule || hasEsmTest) {
+        // Because of the way the ESM cache works, loadFilesAsync doesn't work
+        // correctly if used twice within the same process, so we throw an error
+        // in that case
+        if (testsAlreadyRun) {
+          throw new HardhatError(
+            ERRORS.BUILTIN_TASKS.TEST_TASK_ESM_TESTS_RUN_TWICE
+          );
+        }
+        testsAlreadyRun = true;
+
+        // This instructs Mocha to use the more verbose file loading infrastructure
+        // which supports both ESM and CJS
+        await mocha.loadFilesAsync();
+      }
+
       const testFailures = await new Promise<number>((resolve) => {
         mocha.run(resolve);
       });