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

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

@@ -10,6 +10,7 @@ import {
   HardhatArguments,
   HardhatConfig,
   HardhatUserConfig,
+  SolcConfig,
 } from "../../../types";
 import { HardhatContext } from "../../context";
 import { findClosestPackageJson } from "../../util/packageInfo";
@@ -19,14 +20,27 @@ import { getUserConfigPath } from "../project-structure";
 
 import { SUPPORTED_SOLIDITY_VERSION_RANGE } from "../../hardhat-network/stack-traces/constants";
 import { resolveConfig } from "./config-resolution";
-import { validateConfig } from "./config-validation";
+import { validateConfig, validateResolvedConfig } from "./config-validation";
 import { DEFAULT_SOLC_VERSION } from "./default-config";
 
 const log = debug("hardhat:core:config");
 
 function importCsjOrEsModule(filePath: string): any {
-  const imported = require(filePath);
-  return imported.default !== undefined ? imported.default : imported;
+  try {
+    const imported = require(filePath);
+    return imported.default !== undefined ? imported.default : imported;
+  } catch (e: any) {
+    if (e.code === "ERR_REQUIRE_ESM") {
+      throw new HardhatError(
+        ERRORS.GENERAL.ESM_PROJECT_WITHOUT_CJS_CONFIG,
+        {},
+        e
+      );
+    }
+
+    // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+    throw e;
+  }
 }
 
 export function resolveConfigPath(configPath: string | undefined) {
@@ -108,6 +122,8 @@ export function loadConfigAndTasks(
     extender(resolved, frozenUserConfig);
   }
 
+  validateResolvedConfig(resolved);
+
   if (showSolidityConfigWarnings) {
     checkUnsupportedSolidityConfig(resolved);
     checkUnsupportedRemappings(resolved);
@@ -165,6 +181,8 @@ export function analyzeModuleNotFoundError(error: any, configPath: string) {
   const throwingFile = stackTrace
     .filter((x) => x.file !== null)
     .map((x) => x.file!)
+    // ignore frames related to source map support
+    .filter((x) => !x.includes(path.join("@cspotcode", "source-map-support")))
     .find((x) => path.isAbsolute(x));
 
   if (throwingFile === null || throwingFile === undefined) {
@@ -269,17 +287,15 @@ Learn more about compiler configuration at https://hardhat.org/config
 }
 
 function checkUnsupportedSolidityConfig(resolvedConfig: HardhatConfig) {
-  const compilerVersions = resolvedConfig.solidity.compilers.map(
-    (x) => x.version
-  );
-  const overrideVersions = Object.values(resolvedConfig.solidity.overrides).map(
-    (x) => x.version
-  );
-  const solcVersions = [...compilerVersions, ...overrideVersions];
+  const configuredCompilers = getConfiguredCompilers(resolvedConfig.solidity);
+  const solcVersions = configuredCompilers.map((x) => x.version);
 
   const unsupportedVersions: string[] = [];
   for (const solcVersion of solcVersions) {
-    if (!semver.satisfies(solcVersion, SUPPORTED_SOLIDITY_VERSION_RANGE)) {
+    if (
+      !semver.satisfies(solcVersion, SUPPORTED_SOLIDITY_VERSION_RANGE) &&
+      !unsupportedVersions.includes(solcVersion)
+    ) {
       unsupportedVersions.push(solcVersion);
     }
   }
@@ -318,3 +334,11 @@ Learn more about compiler configuration at https://hardhat.org/config
     );
   }
 }
+
+export function getConfiguredCompilers(
+  solidityConfig: HardhatConfig["solidity"]
+): SolcConfig[] {
+  const compilerVersions = solidityConfig.compilers;
+  const overrideVersions = Object.values(solidityConfig.overrides);
+  return [...compilerVersions, ...overrideVersions];
+}

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

@@ -1,3 +1,5 @@
+import type { HardhatConfig as HardhatConfigT } from "../../../types";
+
 import * as t from "io-ts";
 import { Context, getFunctionName, ValidationError } from "io-ts/lib";
 import { Reporter } from "io-ts/lib/Reporter";
@@ -573,3 +575,21 @@ export function getValidationErrors(config: any): string[] {
   const ioTsErrors = DotPathReporter.report(result);
   return [...errors, ...ioTsErrors];
 }
+
+export function validateResolvedConfig(resolvedConfig: HardhatConfigT) {
+  const solcConfigs = [
+    ...resolvedConfig.solidity.compilers,
+    ...Object.values(resolvedConfig.solidity.overrides),
+  ];
+  const runs = solcConfigs
+    .filter(({ settings }) => settings?.optimizer?.runs !== undefined)
+    .map(({ settings }) => settings?.optimizer?.runs);
+
+  for (const run of runs) {
+    if (run >= 2 ** 32) {
+      throw new HardhatError(ERRORS.GENERAL.INVALID_CONFIG, {
+        errors: "The number of optimizer runs exceeds the maximum of 2**32 - 1",
+      });
+    }
+  }
+}

package/src/internal/core/config/extenders.ts

@@ -1,22 +1,13 @@
-import { ArtifactsExtender, EnvironmentExtender } from "../../../types";
+import { EnvironmentExtender } from "../../../types";
 
 export class ExtenderManager {
-  private readonly _environmentExtenders: EnvironmentExtender[] = [];
-  private readonly _artifactsExtenders: ArtifactsExtender[] = [];
+  private readonly _extenders: EnvironmentExtender[] = [];
 
-  public addEnvironmentExtender(environmentExtender: EnvironmentExtender) {
-    this._environmentExtenders.push(environmentExtender);
+  public add(extender: EnvironmentExtender) {
+    this._extenders.push(extender);
   }
 
-  public addArtifactsExtender(artifactsExtender: ArtifactsExtender) {
-    this._artifactsExtenders.push(artifactsExtender);
-  }
-
-  public getEnvironmentExtenders(): EnvironmentExtender[] {
-    return this._environmentExtenders;
-  }
-
-  public getArtifactsExtenders(): ArtifactsExtender[] {
-    return this._artifactsExtenders;
+  public getExtenders(): EnvironmentExtender[] {
+    return this._extenders;
   }
 }

package/src/internal/core/errors-list.ts

@@ -252,6 +252,23 @@ To avoid it, please delete both your node_modules and package-lock.json, and rei
 Note that you don't need to do this every time you install a new dependency, but please make sure to delete your node_modules every time you delete your package-lock.json.`,
       shouldBeReported: false,
     },
+    ESM_PROJECT_WITHOUT_CJS_CONFIG: {
+      number: 19,
+      message: `Your project is an ESM project (you have "type": "module" set in your package.json) but your Hardhat config file uses the .js extension.
+
+Rename the file to use the .cjs to fix this problem.`,
+      title: "Hardhat config with .js extension in an ESM project",
+      description:
+        "Your project is an ESM project but your Hardhat config uses the .js extension. Hardhat config files cannot be an ES module. To fix this, rename your Hardhat config to use the .cjs extension.",
+      shouldBeReported: false,
+    },
+    ESM_TYPESCRIPT_PROJECT_CREATION: {
+      number: 20,
+      message: `Your project is an ESM project (you have "type": "module" set in your package.json) and you are trying to initialize a TypeScript project. This is not supported yet.`,
+      title: "Initializing a TypeScript sample project in an ESM project",
+      description: `Your project is an ESM project (you have "type": "module" set in your package.json) and you are trying to initialize a TypeScript project. This is not supported yet.`,
+      shouldBeReported: false,
+    },
   },
   NETWORK: {
     CONFIG_NOT_FOUND: {
@@ -819,6 +836,16 @@ Try installing the library using npm.`,
 Use a relative import instead of referencing the package's name.`,
       shouldBeReported: false,
     },
+    IMPORTED_MAPPED_FILE_NOT_FOUND: {
+      number: 413,
+      message:
+        "File %importName% => %imported%, imported from %from%, not found.",
+      title: "Imported mapped file not found",
+      description: `One of your source files imported a nonexistent or not installed file.
+
+Please double check your imports and installed libraries.`,
+      shouldBeReported: false,
+    },
   },
   SOLC: {
     INVALID_VERSION: {
@@ -933,7 +960,7 @@ We recommend not using this kind of dependency.`,
       number: 604,
       message: "Error running JSON-RPC server: %error%",
       title: "Error running JSON-RPC server",
-      description: `There was error while starting the JSON-RPC HTTP server.`,
+      description: `There was an error while starting the JSON-RPC HTTP server.`,
       shouldBeReported: false,
     },
     JSONRPC_UNSUPPORTED_NETWORK: {
@@ -973,6 +1000,14 @@ The first supported version is %firstSupportedVersion%`,
 Please use a newer, supported version.`,
       shouldBeReported: true,
     },
+    TEST_TASK_ESM_TESTS_RUN_TWICE: {
+      number: 609,
+      message: `Your project uses ESM and you've programmatically run your tests twice. This is not supported yet.`,
+      title: "Running tests twice in an ESM project",
+      description:
+        'You have run your tests twice programmatically and your project is an ESM project (you have `"type": "module"` in your `package.json`, or some of your files have the `.mjs` extension). This is not supported by Mocha yet.',
+      shouldBeReported: true,
+    },
   },
   ARTIFACTS: {
     NOT_FOUND: {
@@ -1068,15 +1103,6 @@ Please [report it](https://github.com/nomiclabs/hardhat/issues/new) to help us i
       title: "Inferred artifact path doesn't exist",
       description: `The inferred artifact path doesn't exist.
 
-Please [report it](https://github.com/nomiclabs/hardhat/issues/new) to help us improve Hardhat.`,
-      shouldBeReported: true,
-    },
-    NO_SUPPORTED_ARTIFACT_SOURCE: {
-      number: 904,
-      message: "No configured artifact source can handle method %method%",
-      title: "No configured artifact source can handle the request",
-      description: `No configured artifact source can handle the requested method.
-
 Please [report it](https://github.com/nomiclabs/hardhat/issues/new) to help us improve Hardhat.`,
       shouldBeReported: true,
     },

package/src/internal/core/project-structure.ts

@@ -6,12 +6,15 @@ import { getPackageRoot } from "../util/packageInfo";
 
 import { HardhatError } from "./errors";
 import { ERRORS } from "./errors-list";
+
 const JS_CONFIG_FILENAME = "hardhat.config.js";
+const CJS_CONFIG_FILENAME = "hardhat.config.cjs";
 const TS_CONFIG_FILENAME = "hardhat.config.ts";
 
 export function isCwdInsideProject() {
   return (
     findUp.sync(TS_CONFIG_FILENAME) !== null ||
+    findUp.sync(CJS_CONFIG_FILENAME) !== null ||
     findUp.sync(JS_CONFIG_FILENAME) !== null
   );
 }
@@ -22,6 +25,11 @@ export function getUserConfigPath() {
     return tsConfigPath;
   }
 
+  const cjsConfigPath = findUp.sync(CJS_CONFIG_FILENAME);
+  if (cjsConfigPath !== null) {
+    return cjsConfigPath;
+  }
+
   const pathToConfigFile = findUp.sync(JS_CONFIG_FILENAME);
   if (pathToConfigFile === null) {
     throw new HardhatError(ERRORS.GENERAL.NOT_INSIDE_PROJECT);

package/src/internal/core/providers/construction.ts

@@ -86,31 +86,36 @@ export function createProvider(
       require("../../hardhat-network/provider/utils/disk-cache") as typeof DiskCacheT;
 
     eip1193Provider = new HardhatNetworkProvider(
-      hardhatNetConfig.hardfork,
-      HARDHAT_NETWORK_NAME,
-      hardhatNetConfig.chainId,
-      hardhatNetConfig.chainId,
-      hardhatNetConfig.blockGasLimit,
-      hardhatNetConfig.initialBaseFeePerGas,
-      hardhatNetConfig.minGasPrice,
-      hardhatNetConfig.throwOnTransactionFailures,
-      hardhatNetConfig.throwOnCallFailures,
-      hardhatNetConfig.mining.auto,
-      hardhatNetConfig.mining.interval,
-      // This cast is valid because of the config validation and resolution
-      hardhatNetConfig.mining.mempool.order as MempoolOrder,
-      hardhatNetConfig.chains,
+      {
+        chainId: hardhatNetConfig.chainId,
+        networkId: hardhatNetConfig.chainId,
+        hardfork: hardhatNetConfig.hardfork,
+        blockGasLimit: hardhatNetConfig.blockGasLimit,
+        initialBaseFeePerGas: hardhatNetConfig.initialBaseFeePerGas,
+        minGasPrice: hardhatNetConfig.minGasPrice,
+        throwOnTransactionFailures: hardhatNetConfig.throwOnTransactionFailures,
+        throwOnCallFailures: hardhatNetConfig.throwOnCallFailures,
+        automine: hardhatNetConfig.mining.auto,
+        intervalMining: hardhatNetConfig.mining.interval,
+        // This cast is valid because of the config validation and resolution
+        mempoolOrder: hardhatNetConfig.mining.mempool.order as MempoolOrder,
+        chains: hardhatNetConfig.chains,
+        coinbase: hardhatNetConfig.coinbase,
+        genesisAccounts: accounts,
+        allowUnlimitedContractSize: hardhatNetConfig.allowUnlimitedContractSize,
+        allowBlocksWithSameTimestamp:
+          hardhatNetConfig.allowBlocksWithSameTimestamp ?? false,
+        initialDate:
+          hardhatNetConfig.initialDate !== undefined
+            ? parseDateString(hardhatNetConfig.initialDate)
+            : undefined,
+        experimentalHardhatNetworkMessageTraceHooks,
+        forkConfig,
+        forkCachePath:
+          paths !== undefined ? getForkCacheDirPath(paths) : undefined,
+      },
       new ModulesLogger(hardhatNetConfig.loggingEnabled),
-      accounts,
-      artifacts,
-      hardhatNetConfig.allowUnlimitedContractSize,
-      hardhatNetConfig.initialDate !== undefined
-        ? parseDateString(hardhatNetConfig.initialDate)
-        : undefined,
-      experimentalHardhatNetworkMessageTraceHooks,
-      forkConfig,
-      paths !== undefined ? getForkCacheDirPath(paths) : undefined,
-      hardhatNetConfig.coinbase
+      artifacts
     );
   } else {
     const HttpProvider = importProvider<

package/src/internal/core/providers/http.ts

@@ -1,4 +1,4 @@
-import type { Dispatcher, Pool as PoolT } from "undici";
+import type * as Undici from "undici";
 
 import { EventEmitter } from "events";
 
@@ -17,6 +17,7 @@ import {
 import { getHardhatVersion } from "../../util/packageInfo";
 import { HardhatError } from "../errors";
 import { ERRORS } from "../errors-list";
+import { shouldUseProxy } from "../../util/proxy";
 
 import { ProviderError } from "./errors";
 
@@ -33,7 +34,7 @@ const hardhatVersion = getHardhatVersion();
 
 export class HttpProvider extends EventEmitter implements EIP1193Provider {
   private _nextRequestId = 1;
-  private _dispatcher: Dispatcher;
+  private _dispatcher: Undici.Dispatcher;
   private _path: string;
   private _authHeader: string | undefined;
 
@@ -42,11 +43,11 @@ export class HttpProvider extends EventEmitter implements EIP1193Provider {
     private readonly _networkName: string,
     private readonly _extraHeaders: { [name: string]: string } = {},
     private readonly _timeout = 20000,
-    client: Dispatcher | undefined = undefined
+    client: Undici.Dispatcher | undefined = undefined
   ) {
     super();
 
-    const { Pool } = require("undici") as { Pool: typeof PoolT };
+    const { Pool, ProxyAgent } = require("undici") as typeof Undici;
 
     const url = new URL(this._url);
     this._path = url.pathname;
@@ -59,6 +60,10 @@ export class HttpProvider extends EventEmitter implements EIP1193Provider {
           ).toString("base64")}`;
     try {
       this._dispatcher = client ?? new Pool(url.origin);
+
+      if (process.env.http_proxy !== undefined && shouldUseProxy(url.origin)) {
+        this._dispatcher = new ProxyAgent(process.env.http_proxy);
+      }
     } catch (e) {
       if (e instanceof TypeError && e.message === "Invalid URL") {
         e.message += ` ${url.origin}`;
@@ -73,10 +78,6 @@ export class HttpProvider extends EventEmitter implements EIP1193Provider {
   }
 
   public async request(args: RequestArguments): Promise<unknown> {
-    // We create the error here to capture the stack traces at this point,
-    // the async call that follows would probably loose of the stack trace
-    const error = new ProviderError("HttpProviderError", -1);
-
     const jsonRpcRequest = this._getJsonRpcRequest(
       args.method,
       args.params as any[]
@@ -84,8 +85,10 @@ export class HttpProvider extends EventEmitter implements EIP1193Provider {
     const jsonRpcResponse = await this._fetchJsonRpcResponse(jsonRpcRequest);
 
     if (isErrorResponse(jsonRpcResponse)) {
-      error.message = jsonRpcResponse.error.message;
-      error.code = jsonRpcResponse.error.code;
+      const error = new ProviderError(
+        jsonRpcResponse.error.message,
+        jsonRpcResponse.error.code
+      );
       error.data = jsonRpcResponse.error.data;
       // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
       throw error;
@@ -109,7 +112,7 @@ export class HttpProvider extends EventEmitter implements EIP1193Provider {
   ): Promise<any[]> {
     // We create the errors here to capture the stack traces at this point,
     // the async call that follows would probably loose of the stack trace
-    const error = new ProviderError("HttpProviderError", -1);
+    const stackSavingError = new ProviderError("HttpProviderError", -1);
 
     // we need this to sort the responses
     const idToIndexMap: Record<string, number> = {};
@@ -124,8 +127,11 @@ export class HttpProvider extends EventEmitter implements EIP1193Provider {
 
     for (const response of jsonRpcResponses) {
       if (isErrorResponse(response)) {
-        error.message = response.error.message;
-        error.code = response.error.code;
+        const error = new ProviderError(
+          response.error.message,
+          response.error.code,
+          stackSavingError
+        );
         error.data = response.error.data;
         // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
         throw error;
@@ -163,22 +169,30 @@ export class HttpProvider extends EventEmitter implements EIP1193Provider {
     request: JsonRpcRequest | JsonRpcRequest[],
     retryNumber = 0
   ): Promise<JsonRpcResponse | JsonRpcResponse[]> {
+    const { request: sendRequest } = await import("undici");
+    const url = new URL(this._url);
+
+    const headers: { [name: string]: string } = {
+      "Content-Type": "application/json",
+      "User-Agent": `hardhat ${hardhatVersion}`,
+      ...this._extraHeaders,
+    };
+
+    if (this._authHeader !== undefined) {
+      headers.Authorization = this._authHeader;
+    }
+
     try {
-      const response = await this._dispatcher.request({
+      const response = await sendRequest(url, {
+        dispatcher: this._dispatcher,
         method: "POST",
-        path: this._path,
         body: JSON.stringify(request),
         maxRedirections: 10,
         headersTimeout:
           process.env.DO_NOT_SET_THIS_ENV_VAR____IS_HARDHAT_CI !== undefined
             ? 0
             : this._timeout,
-        headers: {
-          "Content-Type": "application/json",
-          "User-Agent": `hardhat ${hardhatVersion ?? "(unknown version)"}`,
-          Authorization: this._authHeader,
-          ...this._extraHeaders,
-        },
+        headers,
       });
 
       if (this._isRateLimitResponse(response)) {
@@ -194,8 +208,6 @@ export class HttpProvider extends EventEmitter implements EIP1193Provider {
           return await this._retry(request, seconds, retryNumber);
         }
 
-        const url = new URL(this._url);
-
         // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
         throw new ProviderError(
           `Too Many Requests error received from ${url.hostname}`,
@@ -255,16 +267,16 @@ export class HttpProvider extends EventEmitter implements EIP1193Provider {
     return true;
   }
 
-  private _isRateLimitResponse(response: Dispatcher.ResponseData) {
+  private _isRateLimitResponse(response: Undici.Dispatcher.ResponseData) {
     return response.statusCode === TOO_MANY_REQUEST_STATUS;
   }
 
   private _getRetryAfterSeconds(
-    response: Dispatcher.ResponseData
+    response: Undici.Dispatcher.ResponseData
   ): number | undefined {
     const header = response.headers["retry-after"];
 
-    if (header === undefined || header === null) {
+    if (header === undefined || header === null || Array.isArray(header)) {
       return undefined;
     }