hardhat 2.11.0-dev.0 → 2.11.0

package/src/builtin-tasks/compile.ts

@@ -1,9 +1,7 @@
 import os from "os";
 import chalk from "chalk";
-import { exec } from "child_process";
 import debug from "debug";
 import fsExtra from "fs-extra";
-import path from "path";
 import semver from "semver";
 import AggregateError from "aggregate-error";
 
@@ -28,7 +26,6 @@ import {
 import { DependencyGraph } from "../internal/solidity/dependencyGraph";
 import { Parser } from "../internal/solidity/parse";
 import { ResolvedFile, Resolver } from "../internal/solidity/resolver";
-import { glob } from "../internal/util/glob";
 import { getCompilersDir } from "../internal/util/global-dir";
 import { pluralize } from "../internal/util/strings";
 import { Artifacts, CompilerInput, CompilerOutput, SolcBuild } from "../types";
@@ -42,6 +39,7 @@ import {
 import { getFullyQualifiedName } from "../utils/contract-names";
 import { localPathToSourceName } from "../utils/source-names";
 
+import { getAllFilesMatching } from "../internal/util/fs-utils";
 import {
   TASK_COMPILE,
   TASK_COMPILE_GET_COMPILATION_TASKS,
@@ -117,7 +115,9 @@ const DEFAULT_CONCURRENCY_LEVEL = Math.max(os.cpus().length - 1, 1);
 subtask(
   TASK_COMPILE_SOLIDITY_GET_SOURCE_PATHS,
   async (_, { config }): Promise<string[]> => {
-    const paths = await glob(path.join(config.paths.sources, "**/*.sol"));
+    const paths = await getAllFilesMatching(config.paths.sources, (f) =>
+      f.endsWith(".sol")
+    );
 
     return paths;
   }
@@ -412,20 +412,6 @@ subtask(TASK_COMPILE_SOLIDITY_COMPILE_JOBS)
         }
       }
 
-      /**
-       * Downloading the same version of a compiler in parallel can cause an
-       * error. When compilation jobs are executed in parallel, there's a chance
-       * that both use the same solc version and trigger this problem. To
-       * prevent that, we pre-download all the necessary compilers before
-       * running the compilation jobs.
-       */
-      for (const solcVersion of versionList) {
-        await run(TASK_COMPILE_SOLIDITY_GET_SOLC_BUILD, {
-          solcVersion,
-          quiet: false,
-        });
-      }
-
       const { default: pMap } = await import("p-map");
       const pMapOptions = { concurrency, stopOnError: false };
       try {
@@ -544,91 +530,75 @@ subtask(TASK_COMPILE_SOLIDITY_GET_SOLC_BUILD)
       { run }
     ): Promise<SolcBuild> => {
       const compilersCache = await getCompilersDir();
-      const downloader = new CompilerDownloader(compilersCache);
+
+      const compilerPlatform = CompilerDownloader.getCompilerPlatform();
+      const downloader = CompilerDownloader.getConcurrencySafeDownloader(
+        compilerPlatform,
+        compilersCache
+      );
 
       const isCompilerDownloaded = await downloader.isCompilerDownloaded(
         solcVersion
       );
 
-      const { longVersion, platform: desiredPlatform } =
-        await downloader.getCompilerBuild(solcVersion);
+      if (!isCompilerDownloaded) {
+        await run(TASK_COMPILE_SOLIDITY_LOG_DOWNLOAD_COMPILER_START, {
+          solcVersion,
+          isCompilerDownloaded,
+          quiet,
+        });
 
-      await run(TASK_COMPILE_SOLIDITY_LOG_DOWNLOAD_COMPILER_START, {
-        solcVersion,
-        isCompilerDownloaded,
-        quiet,
-      });
+        await downloader.downloadCompiler(solcVersion);
 
-      let compilerPath: string | undefined;
-      let platform: CompilerPlatform | undefined;
-      let nativeBinaryFailed = false;
+        await run(TASK_COMPILE_SOLIDITY_LOG_DOWNLOAD_COMPILER_END, {
+          solcVersion,
+          isCompilerDownloaded,
+          quiet,
+        });
+      }
 
-      const compilerPathResult = await downloader.getDownloadedCompilerPath(
-        solcVersion
-      );
+      const compiler = await downloader.getCompiler(solcVersion);
 
-      if (compilerPathResult === undefined) {
-        if (desiredPlatform === CompilerPlatform.WASM) {
-          // if we were trying to download solcjs and it failed, there's nothing
-          // we can do
-          throw new HardhatError(ERRORS.SOLC.CANT_GET_COMPILER, {
-            version: solcVersion,
-          });
-        }
+      if (compiler !== undefined) {
+        return compiler;
+      }
 
-        nativeBinaryFailed = true;
-      } else {
-        compilerPath = compilerPathResult.compilerPath;
+      log(
+        "Native solc binary doesn't work, using solcjs instead. Try running npx hardhat clean --global"
+      );
 
-        // when using a native binary, check that it works correctly
-        // it it doesn't, force the downloader to use solcjs
-        if (compilerPathResult.platform !== CompilerPlatform.WASM) {
-          log("Checking native solc binary");
+      const wasmDownloader = CompilerDownloader.getConcurrencySafeDownloader(
+        CompilerPlatform.WASM,
+        compilersCache
+      );
 
-          const solcBinaryWorks = await checkSolcBinary(
-            compilerPathResult.compilerPath
-          );
-          if (!solcBinaryWorks) {
-            log("Native solc binary doesn't work, using solcjs instead");
-            nativeBinaryFailed = true;
-          }
-        } else {
-          platform = CompilerPlatform.WASM;
-        }
-      }
+      const isWasmCompilerDownloader =
+        await wasmDownloader.isCompilerDownloaded(solcVersion);
 
-      if (nativeBinaryFailed) {
-        const solcJsDownloader = new CompilerDownloader(compilersCache, {
-          forceSolcJs: true,
+      if (!isWasmCompilerDownloader) {
+        await run(TASK_COMPILE_SOLIDITY_LOG_DOWNLOAD_COMPILER_START, {
+          solcVersion,
+          isCompilerDownloaded,
+          quiet,
         });
 
-        const solcjsCompilerPath =
-          await solcJsDownloader.getDownloadedCompilerPath(solcVersion);
-
-        if (solcjsCompilerPath === undefined) {
-          throw new HardhatError(ERRORS.SOLC.CANT_GET_COMPILER, {
-            version: solcVersion,
-          });
-        }
+        await wasmDownloader.downloadCompiler(solcVersion);
 
-        compilerPath = solcjsCompilerPath.compilerPath;
-        platform = CompilerPlatform.WASM;
+        await run(TASK_COMPILE_SOLIDITY_LOG_DOWNLOAD_COMPILER_END, {
+          solcVersion,
+          isCompilerDownloaded,
+          quiet,
+        });
       }
 
-      await run(TASK_COMPILE_SOLIDITY_LOG_DOWNLOAD_COMPILER_END, {
-        solcVersion,
-        isCompilerDownloaded,
-        quiet,
-      });
-
-      const isSolcJs = platform === CompilerPlatform.WASM;
+      const wasmCompiler = await downloader.getCompiler(solcVersion);
 
       assertHardhatInvariant(
-        compilerPath !== undefined,
-        "A compilerPath should be defined at this point"
+        wasmCompiler !== undefined,
+        `WASM build of solc ${solcVersion} isn't working`
       );
 
-      return { compilerPath, isSolcJs, version: solcVersion, longVersion };
+      return wasmCompiler;
     }
   );
 
@@ -845,38 +815,41 @@ subtask(TASK_COMPILE_SOLIDITY_EMIT_ARTIFACTS)
         output
       );
 
-      const artifactsEmittedPerFile: ArtifactsEmittedPerFile = [];
-      for (const file of compilationJob.getResolvedFiles()) {
-        log(`Emitting artifacts for file '${file.sourceName}'`);
-        if (!compilationJob.emitsArtifacts(file)) {
-          continue;
-        }
-
-        const artifactsEmitted = [];
-        for (const [contractName, contractOutput] of Object.entries(
-          output.contracts?.[file.sourceName] ?? {}
-        )) {
-          log(`Emitting artifact for contract '${contractName}'`);
-
-          const artifact = await run(
-            TASK_COMPILE_SOLIDITY_GET_ARTIFACT_FROM_COMPILATION_OUTPUT,
-            {
-              sourceName: file.sourceName,
-              contractName,
-              contractOutput,
-            }
-          );
-
-          await artifacts.saveArtifactAndDebugFile(artifact, pathToBuildInfo);
-
-          artifactsEmitted.push(artifact.contractName);
-        }
-
-        artifactsEmittedPerFile.push({
-          file,
-          artifactsEmitted,
-        });
-      }
+      const artifactsEmittedPerFile: ArtifactsEmittedPerFile =
+        await Promise.all(
+          compilationJob
+            .getResolvedFiles()
+            .filter((f) => compilationJob.emitsArtifacts(f))
+            .map(async (file) => {
+              const artifactsEmitted = await Promise.all(
+                Object.entries(output.contracts?.[file.sourceName] ?? {}).map(
+                  async ([contractName, contractOutput]) => {
+                    log(`Emitting artifact for contract '${contractName}'`);
+                    const artifact = await run(
+                      TASK_COMPILE_SOLIDITY_GET_ARTIFACT_FROM_COMPILATION_OUTPUT,
+                      {
+                        sourceName: file.sourceName,
+                        contractName,
+                        contractOutput,
+                      }
+                    );
+
+                    await artifacts.saveArtifactAndDebugFile(
+                      artifact,
+                      pathToBuildInfo
+                    );
+
+                    return artifact.contractName;
+                  }
+                )
+              );
+
+              return {
+                file,
+                artifactsEmitted,
+              };
+            })
+        );
 
       return { artifactsEmittedPerFile };
     }
@@ -1450,6 +1423,8 @@ async function invalidateCacheMissingArtifacts(
   artifacts: Artifacts,
   resolvedFiles: ResolvedFile[]
 ): Promise<SolidityFilesCache> {
+  const paths = new Set(await artifacts.getArtifactPaths());
+
   for (const file of resolvedFiles) {
     const cacheEntry = solidityFilesCache.getEntry(file.absolutePath);
 
@@ -1458,21 +1433,23 @@ async function invalidateCacheMissingArtifacts(
     }
 
     const { artifacts: emittedArtifacts } = cacheEntry;
-
     for (const emittedArtifact of emittedArtifacts) {
-      const artifactExists = await artifacts.artifactExists(
-        getFullyQualifiedName(file.sourceName, emittedArtifact)
-      );
-      if (!artifactExists) {
+      const fqn = getFullyQualifiedName(file.sourceName, emittedArtifact);
+      const path = artifacts.formArtifactPathFromFullyQualifiedName(fqn);
+
+      if (!paths.has(path)) {
         log(
-          `Invalidate cache for '${file.absolutePath}' because artifact '${emittedArtifact}' doesn't exist`
+          `Invalidate cache for '${file.absolutePath}' because artifact '${fqn}' doesn't exist`
         );
+
         solidityFilesCache.removeEntry(file.absolutePath);
         break;
       }
     }
   }
 
+  artifacts.clearCache?.();
+
   return solidityFilesCache;
 }
 
@@ -1506,15 +1483,6 @@ function hasCompilationErrors(output: any): boolean {
   );
 }
 
-async function checkSolcBinary(solcPath: string): Promise<boolean> {
-  return new Promise((resolve) => {
-    const process = exec(`${solcPath} --version`);
-    process.on("exit", (code) => {
-      resolve(code === 0);
-    });
-  });
-}
-
 /**
  * This function returns a properly formatted Internal Compiler Error message.
  *

package/src/builtin-tasks/flatten.ts

@@ -1,5 +1,3 @@
-import * as fs from "fs";
-
 import { subtask, task, types } from "../internal/core/config/config-env";
 import { HardhatError } from "../internal/core/errors";
 import { ERRORS } from "../internal/core/errors-list";
@@ -7,6 +5,7 @@ import { DependencyGraph } from "../internal/solidity/dependencyGraph";
 import { ResolvedFile, ResolvedFilesMap } from "../internal/solidity/resolver";
 import { getPackageJson } from "../internal/util/packageInfo";
 
+import { getRealPathSync } from "../internal/util/fs-utils";
 import {
   TASK_COMPILE_SOLIDITY_GET_DEPENDENCY_GRAPH,
   TASK_COMPILE_SOLIDITY_GET_SOURCE_NAMES,
@@ -97,7 +96,7 @@ subtask(TASK_FLATTEN_GET_DEPENDENCY_GRAPH)
     const sourcePaths: string[] =
       files === undefined
         ? await run(TASK_COMPILE_SOLIDITY_GET_SOURCE_PATHS)
-        : files.map((f) => fs.realpathSync(f));
+        : files.map((f) => getRealPathSync(f));
 
     const sourceNames: string[] = await run(
       TASK_COMPILE_SOLIDITY_GET_SOURCE_NAMES,

package/src/builtin-tasks/node.ts

@@ -1,4 +1,4 @@
-import type EthereumjsUtilT from "@ignored/util";
+import type EthereumjsUtilT from "@nomicfoundation/ethereumjs-util";
 
 import chalk from "chalk";
 import debug from "debug";
@@ -52,7 +52,7 @@ function logHardhatNetworkAccounts(networkConfig: HardhatNetworkConfig) {
     networkConfig.accounts.mnemonic === HARDHAT_NETWORK_MNEMONIC;
 
   const { bufferToHex, privateToAddress, toBuffer, toChecksumAddress } =
-    require("@ignored/util") as typeof EthereumjsUtilT;
+    require("@nomicfoundation/ethereumjs-util") as typeof EthereumjsUtilT;
 
   console.log("Accounts");
   console.log("========");

package/src/builtin-tasks/test.ts

@@ -8,8 +8,8 @@ import { subtask, task } from "../internal/core/config/config-env";
 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 { glob } from "../internal/util/glob";
 import { pluralize } from "../internal/util/strings";
+import { getAllFilesMatching } from "../internal/util/fs-utils";
 
 import {
   TASK_COMPILE,
@@ -35,13 +35,17 @@ subtask(TASK_TEST_GET_TEST_FILES)
       return testFilesAbsolutePaths;
     }
 
-    const jsFiles = await glob(path.join(config.paths.tests, "**/*.js"));
+    const jsFiles = await getAllFilesMatching(config.paths.tests, (f) =>
+      f.endsWith(".js")
+    );
 
     if (!isRunningWithTypescript(config)) {
       return jsFiles;
     }
 
-    const tsFiles = await glob(path.join(config.paths.tests, "**/*.ts"));
+    const tsFiles = await getAllFilesMatching(config.paths.tests, (f) =>
+      f.endsWith(".ts")
+    );
 
     return [...jsFiles, ...tsFiles];
   });

package/src/builtin-tasks/utils/solidity-files-cache.ts

@@ -57,7 +57,7 @@ export class SolidityFilesCache {
       _format: FORMAT_VERSION,
       files: {},
     };
-    if (fsExtra.existsSync(solidityFilesCachePath)) {
+    if (await fsExtra.pathExists(solidityFilesCachePath)) {
       cacheRaw = await fsExtra.readJson(solidityFilesCachePath);
     }
 
@@ -80,12 +80,13 @@ export class SolidityFilesCache {
   constructor(private _cache: Cache) {}
 
   public async removeNonExistingFiles() {
-    for (const absolutePath of Object.keys(this._cache.files)) {
-      if (!fsExtra.existsSync(absolutePath)) {
-        this.removeEntry(absolutePath);
-        continue;
-      }
-    }
+    await Promise.all(
+      Object.keys(this._cache.files).map(async (absolutePath) => {
+        if (!(await fsExtra.pathExists(absolutePath))) {
+          this.removeEntry(absolutePath);
+        }
+      })
+    );
   }
 
   public async writeToFile(solidityFilesCachePath: string) {
@@ -115,7 +116,7 @@ export class SolidityFilesCache {
     contentHash: string,
     solcConfig?: SolcConfig
   ): boolean {
-    const { isEqual }: LoDashStatic = require("lodash");
+    const isEqual = require("lodash/isEqual") as LoDashStatic["isEqual"];
 
     const cacheEntry = this.getEntry(absolutePath);