hardhat 2.13.0-dev.2 → 2.13.0-dev.3

package/sample-projects/javascript-esm/test/Lock.js

@@ -0,0 +1,123 @@
+import { time, loadFixture } from "@nomicfoundation/hardhat-network-helpers";
+import { anyValue } from "@nomicfoundation/hardhat-chai-matchers/withArgs.js";
+import { expect } from "chai";
+
+describe("Lock", function () {
+  // We define a fixture to reuse the same setup in every test.
+  // We use loadFixture to run this setup once, snapshot that state,
+  // and reset Hardhat Network to that snapshot in every test.
+  async function deployOneYearLockFixture() {
+    const ONE_YEAR_IN_SECS = 365 * 24 * 60 * 60;
+    const ONE_GWEI = 1_000_000_000;
+
+    const lockedAmount = ONE_GWEI;
+    const unlockTime = (await time.latest()) + ONE_YEAR_IN_SECS;
+
+    // Contracts are deployed using the first signer/account by default
+    const [owner, otherAccount] = await ethers.getSigners();
+
+    const Lock = await ethers.getContractFactory("Lock");
+    const lock = await Lock.deploy(unlockTime, { value: lockedAmount });
+
+    return { lock, unlockTime, lockedAmount, owner, otherAccount };
+  }
+
+  describe("Deployment", function () {
+    it("Should set the right unlockTime", async function () {
+      const { lock, unlockTime } = await loadFixture(deployOneYearLockFixture);
+
+      expect(await lock.unlockTime()).to.equal(unlockTime);
+    });
+
+    it("Should set the right owner", async function () {
+      const { lock, owner } = await loadFixture(deployOneYearLockFixture);
+
+      expect(await lock.owner()).to.equal(owner.address);
+    });
+
+    it("Should receive and store the funds to lock", async function () {
+      const { lock, lockedAmount } = await loadFixture(
+        deployOneYearLockFixture
+      );
+
+      expect(await ethers.provider.getBalance(lock.address)).to.equal(
+        lockedAmount
+      );
+    });
+
+    it("Should fail if the unlockTime is not in the future", async function () {
+      // We don't use the fixture here because we want a different deployment
+      const latestTime = await time.latest();
+      const Lock = await ethers.getContractFactory("Lock");
+      await expect(Lock.deploy(latestTime, { value: 1 })).to.be.revertedWith(
+        "Unlock time should be in the future"
+      );
+    });
+  });
+
+  describe("Withdrawals", function () {
+    describe("Validations", function () {
+      it("Should revert with the right error if called too soon", async function () {
+        const { lock } = await loadFixture(deployOneYearLockFixture);
+
+        await expect(lock.withdraw()).to.be.revertedWith(
+          "You can't withdraw yet"
+        );
+      });
+
+      it("Should revert with the right error if called from another account", async function () {
+        const { lock, unlockTime, otherAccount } = await loadFixture(
+          deployOneYearLockFixture
+        );
+
+        // We can increase the time in Hardhat Network
+        await time.increaseTo(unlockTime);
+
+        // We use lock.connect() to send a transaction from another account
+        await expect(lock.connect(otherAccount).withdraw()).to.be.revertedWith(
+          "You aren't the owner"
+        );
+      });
+
+      it("Shouldn't fail if the unlockTime has arrived and the owner calls it", async function () {
+        const { lock, unlockTime } = await loadFixture(
+          deployOneYearLockFixture
+        );
+
+        // Transactions are sent using the first signer by default
+        await time.increaseTo(unlockTime);
+
+        await expect(lock.withdraw()).not.to.be.reverted;
+      });
+    });
+
+    describe("Events", function () {
+      it("Should emit an event on withdrawals", async function () {
+        const { lock, unlockTime, lockedAmount } = await loadFixture(
+          deployOneYearLockFixture
+        );
+
+        await time.increaseTo(unlockTime);
+
+        await expect(lock.withdraw())
+          .to.emit(lock, "Withdrawal")
+          .withArgs(lockedAmount, anyValue); // We accept any value as `when` arg
+      });
+    });
+
+    describe("Transfers", function () {
+      it("Should transfer the funds to the owner", async function () {
+        const { lock, unlockTime, lockedAmount, owner } = await loadFixture(
+          deployOneYearLockFixture
+        );
+
+        await time.increaseTo(unlockTime);
+
+        await expect(lock.withdraw()).to.changeEtherBalances(
+          [owner, lock],
+          [lockedAmount, -lockedAmount]
+        );
+      });
+    });
+  });
+});

package/sample-projects/typescript/hardhat.config.ts

@@ -2,7 +2,7 @@ import { HardhatUserConfig } from "hardhat/config";
 import "@nomicfoundation/hardhat-toolbox";
 
 const config: HardhatUserConfig = {
-  solidity: "0.8.17",
+  solidity: "0.8.18",
 };
 
 export default config;

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,13 +755,17 @@ 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)
+          )
+        );
       }
     }
 

package/src/builtin-tasks/flatten.ts

@@ -124,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);
       });