hardhat 2.7.0 → 2.8.1

package/src/internal/cli/autocomplete.ts

@@ -185,7 +185,7 @@ async function getCompletionData(): Promise<CompletionData | undefined> {
     process.env.TS_NODE_TRANSPILE_ONLY = "1";
     require("../../register");
     hre = (global as any).hre;
-  } catch (e) {
+  } catch {
     return undefined;
   }
   const filesAfterRequire = Object.keys(require.cache);
@@ -233,7 +233,7 @@ function arePreviousMtimesCorrect(mtimes: Mtimes): boolean {
     return Object.entries(mtimes).every(
       ([file, mtime]) => fs.statSync(file).mtime.valueOf() === mtime
     );
-  } catch (e) {
+  } catch {
     return false;
   }
 }
@@ -264,7 +264,7 @@ async function getCachedCompletionData(
     try {
       const cachedCompletionData = fs.readJsonSync(cachedCompletionDataPath);
       return cachedCompletionData;
-    } catch (e) {
+    } catch {
       // remove the file if it seems invalid
       fs.unlinkSync(cachedCompletionDataPath);
       return undefined;

package/src/internal/cli/bootstrap.ts

@@ -34,5 +34,5 @@ const childProcess = fork(`${__dirname}/cli`, process.argv.slice(2), {
 });
 
 childProcess.once("close", (status) => {
-  process.exit(status);
+  process.exit(status as number);
 });

package/src/internal/cli/cli.ts

@@ -126,10 +126,13 @@ async function main() {
 
     let taskName = parsedTaskName ?? TASK_HELP;
 
+    const showEmptyConfigWarning = true;
     const showSolidityConfigWarnings = taskName === TASK_COMPILE;
 
     const ctx = HardhatContext.createHardhatContext();
+
     const config = loadConfigAndTasks(hardhatArguments, {
+      showEmptyConfigWarning,
       showSolidityConfigWarnings,
     });
 
@@ -234,7 +237,7 @@ async function main() {
     console.log("");
 
     try {
-      Reporter.reportError(error);
+      Reporter.reportError(error as Error);
     } catch (e) {
       log("Couldn't report error to sentry: %O", e);
     }

package/src/internal/cli/project-creation.ts

@@ -69,11 +69,11 @@ const ADVANCED_TYPESCRIPT_SAMPLE_PROJECT_DEPENDENCIES: Dependencies = {
   "@typescript-eslint/eslint-plugin": "^4.29.1",
   "@typescript-eslint/parser": "^4.29.1",
   "@types/chai": "^4.2.21",
-  "@types/node": "^16.4.13",
+  "@types/node": "^12.0.0",
   "@types/mocha": "^9.0.0",
   "ts-node": "^10.1.0",
   typechain: "^5.1.2", // a workaround. see https://github.com/nomiclabs/hardhat/issues/1672#issuecomment-894497156
-  typescript: "^4.3.5",
+  typescript: "^4.5.2",
 };
 
 const SAMPLE_PROJECT_DEPENDENCIES: {
@@ -447,7 +447,7 @@ export async function createProject() {
     `\n${emoji("✨ ")}${chalk.cyan("Project created")}${emoji(" ✨")}`
   );
 
-  console.log("See the README.txt file for some example tasks you can run.");
+  console.log("See the README.md file for some example tasks you can run.");
 }
 
 function createConfirmationPrompt(name: string, message: string) {

package/src/internal/constants.ts

@@ -18,6 +18,7 @@ export const HARDHAT_NETWORK_SUPPORTED_HARDFORKS = [
   "muirGlacier",
   "berlin",
   "london",
+  "arrowGlacier",
 ];
 
 export const HARDHAT_MEMPOOL_SUPPORTED_ORDERS = <const>["fifo", "priority"];

package/src/internal/context.ts

@@ -10,7 +10,7 @@ import { ERRORS } from "./core/errors-list";
 import { TasksDSL } from "./core/tasks/dsl";
 import { getRequireCachedFiles } from "./util/platform";
 
-export type GlobalWithHardhatContext = NodeJS.Global & {
+export type GlobalWithHardhatContext = typeof global & {
   __hardhatContext: HardhatContext;
 };
 

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

@@ -38,7 +38,16 @@ export function resolveConfigPath(configPath: string | undefined) {
 
 export function loadConfigAndTasks(
   hardhatArguments?: Partial<HardhatArguments>,
-  { showSolidityConfigWarnings } = { showSolidityConfigWarnings: false }
+  {
+    showEmptyConfigWarning = false,
+    showSolidityConfigWarnings = false,
+  }: {
+    showEmptyConfigWarning?: boolean;
+    showSolidityConfigWarnings?: boolean;
+  } = {
+    showEmptyConfigWarning: false,
+    showSolidityConfigWarnings: false,
+  }
 ): HardhatConfig {
   let configPath =
     hardhatArguments !== undefined ? hardhatArguments.config : undefined;
@@ -73,6 +82,10 @@ export function loadConfigAndTasks(
     ctx.setConfigLoadingAsFinished();
   }
 
+  if (showEmptyConfigWarning) {
+    checkEmptyConfig(userConfig, { showSolidityConfigWarnings });
+  }
+
   validateConfig(userConfig);
 
   if (showSolidityConfigWarnings) {
@@ -215,18 +228,35 @@ function readPackageJson(packageName: string): PackageJson | undefined {
     );
 
     return require(packageJsonPath);
-  } catch (error) {
+  } catch {
     return undefined;
   }
 }
 
+function checkEmptyConfig(
+  userConfig: any,
+  { showSolidityConfigWarnings }: { showSolidityConfigWarnings: boolean }
+) {
+  if (userConfig === undefined || Object.keys(userConfig).length === 0) {
+    let warning = `Hardhat config is returning an empty config object, check the export from the config file if this is unexpected.\n`;
+
+    // This 'learn more' section is also printed by the solidity config warning,
+    // so we need to check to avoid printing it twice
+    if (!showSolidityConfigWarnings) {
+      warning += `\nLearn more about configuring Hardhat at https://hardhat.org/config\n`;
+    }
+
+    console.warn(chalk.yellow(warning));
+  }
+}
+
 function checkMissingSolidityConfig(userConfig: any) {
   if (userConfig.solidity === undefined) {
     console.warn(
       chalk.yellow(
         `Solidity compiler is not configured. Version ${DEFAULT_SOLC_VERSION} will be used by default. Add a 'solidity' entry to your configuration to suppress this warning.
 
-Learn more about compiler configuration at https://hardhat.org/config"
+Learn more about compiler configuration at https://hardhat.org/config
 `
       )
     );

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

@@ -6,6 +6,8 @@ import path from "path";
 import {
   HardhatConfig,
   HardhatNetworkAccountsConfig,
+  HardhatNetworkChainConfig,
+  HardhatNetworkChainsConfig,
   HardhatNetworkConfig,
   HardhatNetworkForkingConfig,
   HardhatNetworkMiningConfig,
@@ -31,6 +33,7 @@ import {
   SolidityUserConfig,
 } from "../../../types";
 import { HARDHAT_NETWORK_NAME } from "../../constants";
+import { HardforkName } from "../../util/hardforks";
 import { fromEntries } from "../../util/lang";
 import { assertHardhatInvariant } from "../errors";
 
@@ -150,9 +153,11 @@ function resolveHardhatNetworkConfig(
         }
       : undefined;
 
-  const blockNumber = hardhatNetworkConfig?.forking?.blockNumber;
-  if (blockNumber !== undefined && forking !== undefined) {
-    forking.blockNumber = hardhatNetworkConfig?.forking?.blockNumber;
+  if (forking !== undefined) {
+    const blockNumber = hardhatNetworkConfig?.forking?.blockNumber;
+    if (blockNumber !== undefined) {
+      forking.blockNumber = hardhatNetworkConfig?.forking?.blockNumber;
+    }
   }
 
   const mining = resolveMiningConfig(hardhatNetworkConfig.mining);
@@ -171,6 +176,30 @@ function resolveHardhatNetworkConfig(
   const initialDate =
     hardhatNetworkConfig.initialDate ?? new Date().toISOString();
 
+  const chains: HardhatNetworkChainsConfig = new Map(
+    defaultHardhatNetworkParams.chains
+  );
+  if (hardhatNetworkConfig.chains !== undefined) {
+    for (const [chainId, userChainConfig] of Object.entries(
+      hardhatNetworkConfig.chains
+    )) {
+      const chainConfig: HardhatNetworkChainConfig = {
+        hardforkHistory: new Map(),
+      };
+      if (userChainConfig.hardforkHistory !== undefined) {
+        for (const [name, block] of Object.entries(
+          userChainConfig.hardforkHistory
+        )) {
+          chainConfig.hardforkHistory.set(
+            name as HardforkName,
+            block as number
+          );
+        }
+      }
+      chains.set(parseInt(chainId, 10), chainConfig);
+    }
+  }
+
   const config = {
     ...clonedDefaultHardhatNetworkParams,
     ...hardhatNetworkConfig,
@@ -181,6 +210,7 @@ function resolveHardhatNetworkConfig(
     gas,
     initialDate,
     minGasPrice,
+    chains,
   };
 
   // We do it this way because ts gets lost otherwise

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

@@ -12,6 +12,7 @@ import { fromEntries } from "../../util/lang";
 import { HardhatError } from "../errors";
 import { ERRORS } from "../errors-list";
 import { hardforkGte, HardforkName } from "../../util/hardforks";
+import { HardhatNetworkChainUserConfig } from "../../../types/config";
 import { defaultHardhatNetworkParams } from "./default-config";
 
 function stringify(v: any): string {
@@ -192,6 +193,21 @@ const HardhatNetworkHDAccountsConfig = t.type({
   ...commonHDAccountsFields,
 });
 
+const Integer = new t.Type<number>(
+  "Integer",
+  (num: unknown): num is number => typeof num === "number",
+  (u, c) => {
+    try {
+      return typeof u === "string"
+        ? t.success(parseInt(u, 10))
+        : t.failure(u, c);
+    } catch {
+      return t.failure(u, c);
+    }
+  },
+  t.identity
+);
+
 const HardhatNetworkForkingConfig = t.type({
   enabled: optional(t.boolean),
   url: t.string,
@@ -214,6 +230,36 @@ const HardhatNetworkMiningConfig = t.type({
   mempool: optional(HardhatNetworkMempoolConfig),
 });
 
+function isValidHardforkName(name: string) {
+  return Object.values(HardforkName).includes(name as HardforkName);
+}
+
+const HardforkNameType = new t.Type<HardforkName>(
+  Object.values(HardforkName)
+    .map((v) => `"${v}"`)
+    .join(" | "),
+  (name: unknown): name is HardforkName =>
+    typeof name === "string" && isValidHardforkName(name),
+  (u, c) => {
+    return typeof u === "string" && isValidHardforkName(u)
+      ? t.success(u as HardforkName)
+      : t.failure(u, c);
+  },
+  t.identity
+);
+
+const HardhatNetworkHardforkHistory = t.record(
+  HardforkNameType,
+  t.number,
+  "HardhatNetworkHardforkHistory"
+);
+
+const HardhatNetworkChainConfig = t.type({
+  hardforkHistory: HardhatNetworkHardforkHistory,
+});
+
+const HardhatNetworkChainsConfig = t.record(Integer, HardhatNetworkChainConfig);
+
 const commonNetworkConfigFields = {
   chainId: optional(t.number),
   from: optional(t.string),
@@ -242,6 +288,7 @@ const HardhatNetworkConfig = t.type({
   forking: optional(HardhatNetworkForkingConfig),
   mining: optional(HardhatNetworkMiningConfig),
   coinbase: optional(address),
+  chains: optional(HardhatNetworkChainsConfig),
 });
 
 const HDAccountsConfig = t.type({
@@ -417,6 +464,29 @@ export function getValidationErrors(config: any): string[] {
           );
         }
       }
+
+      if (hardhatNetwork.chains !== undefined) {
+        Object.entries(hardhatNetwork.chains).forEach((chainEntry) => {
+          const [chainId, chainConfig] = chainEntry as [
+            string,
+            HardhatNetworkChainUserConfig
+          ];
+          const { hardforkHistory } = chainConfig;
+          if (hardforkHistory !== undefined) {
+            Object.keys(hardforkHistory).forEach((hardforkName) => {
+              if (!HARDHAT_NETWORK_SUPPORTED_HARDFORKS.includes(hardforkName)) {
+                errors.push(
+                  getErrorMessage(
+                    `HardhatConfig.networks.${HARDHAT_NETWORK_NAME}.chains[${chainId}].hardforkHistory`,
+                    hardforkName,
+                    `"${HARDHAT_NETWORK_SUPPORTED_HARDFORKS.join('" | "')}"`
+                  )
+                );
+              }
+            });
+          }
+        });
+      }
     }
 
     for (const [networkName, netConfig] of Object.entries<any>(

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

@@ -1,6 +1,7 @@
 import { BN } from "ethereumjs-util";
 
 import { HardhatNetworkConfig } from "../../../types";
+import { HardforkName } from "../../util/hardforks";
 import { HARDHAT_NETWORK_NAME } from "../../constants";
 
 export const DEFAULT_SOLC_VERSION = "0.7.3";
@@ -35,7 +36,7 @@ export const defaultHardhatNetworkParams: Omit<
   HardhatNetworkConfig,
   "gas" | "initialDate"
 > = {
-  hardfork: "london",
+  hardfork: "arrowGlacier",
   blockGasLimit: 30_000_000,
   gasPrice: HARDHAT_NETWORK_DEFAULT_GAS_PRICE,
   chainId: 31337,
@@ -53,6 +54,63 @@ export const defaultHardhatNetworkParams: Omit<
   loggingEnabled: false,
   gasMultiplier: DEFAULT_GAS_MULTIPLIER,
   minGasPrice: new BN(0),
+  chains: new Map([
+    [
+      // block numbers below were taken from https://github.com/ethereumjs/ethereumjs-monorepo/tree/master/packages/common/src/chains
+      1, // mainnet
+      {
+        hardforkHistory: new Map([
+          [HardforkName.BYZANTIUM, 4370000],
+          [HardforkName.CONSTANTINOPLE, 7280000],
+          [HardforkName.PETERSBURG, 7280000],
+          [HardforkName.ISTANBUL, 9069000],
+          [HardforkName.MUIR_GLACIER, 9200000],
+          [HardforkName.BERLIN, 12244000],
+          [HardforkName.LONDON, 12965000],
+        ]),
+      },
+    ],
+    [
+      3, // ropsten
+      {
+        hardforkHistory: new Map([
+          [HardforkName.BYZANTIUM, 1700000],
+          [HardforkName.CONSTANTINOPLE, 4230000],
+          [HardforkName.PETERSBURG, 4939394],
+          [HardforkName.ISTANBUL, 6485846],
+          [HardforkName.MUIR_GLACIER, 7117117],
+          [HardforkName.BERLIN, 9812189],
+          [HardforkName.LONDON, 10499401],
+        ]),
+      },
+    ],
+    [
+      4, // rinkeby
+      {
+        hardforkHistory: new Map([
+          [HardforkName.BYZANTIUM, 1035301],
+          [HardforkName.CONSTANTINOPLE, 3660663],
+          [HardforkName.PETERSBURG, 4321234],
+          [HardforkName.ISTANBUL, 5435345],
+          [HardforkName.BERLIN, 8290928],
+          [HardforkName.LONDON, 8897988],
+        ]),
+      },
+    ],
+    [
+      42, // kovan
+      {
+        hardforkHistory: new Map([
+          [HardforkName.BYZANTIUM, 5067000],
+          [HardforkName.CONSTANTINOPLE, 9200000],
+          [HardforkName.PETERSBURG, 10255201],
+          [HardforkName.ISTANBUL, 14111141],
+          [HardforkName.BERLIN, 24770900],
+          [HardforkName.LONDON, 26741100],
+        ]),
+      },
+    ],
+  ]),
 };
 
 export const defaultHttpNetworkParams = {

package/src/internal/core/execution-mode.ts

@@ -22,7 +22,7 @@ export function isHardhatInstalledLocallyOrLinked(configPath?: string) {
     return (
       fs.realpathSync(resolvedPackageJson) === fs.realpathSync(thisPackageJson)
     );
-  } catch (_) {
+  } catch {
     return false;
   }
 }

package/src/internal/core/params/argumentTypes.ts

@@ -185,14 +185,19 @@ export const inputFile: CLIArgumentType<string> = {
         throw new Error(`${strValue} is a directory, not a file`);
       }
     } catch (error) {
-      throw new HardhatError(
-        ERRORS.ARGUMENTS.INVALID_INPUT_FILE,
-        {
-          name: argName,
-          value: strValue,
-        },
-        error
-      );
+      if (error instanceof Error) {
+        throw new HardhatError(
+          ERRORS.ARGUMENTS.INVALID_INPUT_FILE,
+          {
+            name: argName,
+            value: strValue,
+          },
+          error
+        );
+      }
+
+      // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+      throw error;
     }
 
     return strValue;
@@ -212,15 +217,20 @@ export const inputFile: CLIArgumentType<string> = {
       inputFile.parse(argName, value);
     } catch (error) {
       // the input value is considered invalid, throw error.
-      throw new HardhatError(
-        ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE,
-        {
-          value,
-          name: argName,
-          type: inputFile.name,
-        },
-        error
-      );
+      if (error instanceof Error) {
+        throw new HardhatError(
+          ERRORS.ARGUMENTS.INVALID_VALUE_FOR_TYPE,
+          {
+            value,
+            name: argName,
+            type: inputFile.name,
+          },
+          error
+        );
+      }
+
+      // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+      throw error;
     }
   },
 };
@@ -231,14 +241,19 @@ export const json: CLIArgumentType<any> = {
     try {
       return JSON.parse(strValue);
     } catch (error) {
-      throw new HardhatError(
-        ERRORS.ARGUMENTS.INVALID_JSON_ARGUMENT,
-        {
-          param: argName,
-          error: error.message,
-        },
-        error
-      );
+      if (error instanceof Error) {
+        throw new HardhatError(
+          ERRORS.ARGUMENTS.INVALID_JSON_ARGUMENT,
+          {
+            param: argName,
+            error: error.message,
+          },
+          error
+        );
+      }
+
+      // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+      throw error;
     }
   },
 

package/src/internal/core/params/env-variables.ts

@@ -48,14 +48,19 @@ export function getEnvHardhatArguments(
       try {
         envArgs[paramName] = definition.type.parse(paramName, rawValue);
       } catch (error) {
-        throw new HardhatError(
-          ERRORS.ARGUMENTS.INVALID_ENV_VAR_VALUE,
-          {
-            varName: envVarName,
-            value: rawValue,
-          },
-          error
-        );
+        if (error instanceof Error) {
+          throw new HardhatError(
+            ERRORS.ARGUMENTS.INVALID_ENV_VAR_VALUE,
+            {
+              varName: envVarName,
+              value: rawValue,
+            },
+            error
+          );
+        }
+
+        // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+        throw error;
       }
     } else {
       envArgs[paramName] = definition.defaultValue;

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

@@ -104,7 +104,7 @@ export class LocalAccountsProvider extends ProviderWrapperWithChainId {
       if (typeof data === "string") {
         try {
           typedMessage = JSON.parse(data);
-        } catch (error) {
+        } catch {
           throw new HardhatError(
             ERRORS.NETWORK.ETHSIGN_TYPED_DATA_V4_INVALID_DATA_PARAM
           );
@@ -219,7 +219,7 @@ export class LocalAccountsProvider extends ProviderWrapperWithChainId {
   private _getPrivateKeyForAddressOrNull(address: Buffer): Buffer | null {
     try {
       return this._getPrivateKeyForAddress(address);
-    } catch (e) {
+    } catch {
       return null;
     }
   }
@@ -253,6 +253,7 @@ export class LocalAccountsProvider extends ProviderWrapperWithChainId {
       gasLimit: transactionRequest.gas,
     };
 
+    // TODO: consider changing instances of "london" below to ["latest hardfork"]
     const common =
       chains.names[chainId] !== undefined
         ? new Common({ chain: chainId, hardfork: "london" })
@@ -347,7 +348,7 @@ abstract class SenderProvider extends ProviderWrapper {
     return this._wrappedProvider.request(args);
   }
 
-  protected abstract async _getSender(): Promise<string | undefined>;
+  protected abstract _getSender(): Promise<string | undefined>;
 }
 
 export class AutomaticSenderProvider extends SenderProvider {

package/src/internal/core/providers/backwards-compatibility.ts

@@ -56,7 +56,7 @@ export class BackwardsCompatibilityProviderAdapter
         method: request.method,
         params: request.params,
       });
-    } catch (error) {
+    } catch (error: any) {
       if (error.code === undefined) {
         // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
         throw error;

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

@@ -12,7 +12,7 @@ export abstract class ProviderWrapperWithChainId extends ProviderWrapper {
     if (this._chainId === undefined) {
       try {
         this._chainId = await this._getChainIdFromEthChainId();
-      } catch (error) {
+      } catch {
         // If eth_chainId fails we default to net_version
         this._chainId = await this._getChainIdFromEthNetVersion();
       }

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

@@ -93,6 +93,7 @@ export function createProvider(
       hardhatNetConfig.mining.interval,
       // This cast is valid because of the config validation and resolution
       hardhatNetConfig.mining.mempool.order as MempoolOrder,
+      hardhatNetConfig.chains,
       new ModulesLogger(hardhatNetConfig.loggingEnabled),
       accounts,
       artifacts,

package/src/internal/core/providers/gas-providers.ts

@@ -86,9 +86,11 @@ abstract class MultipliedGasEstimationProvider extends ProviderWrapper {
 
       return numberToRpcQuantity(gas);
     } catch (error) {
-      if (error.message.toLowerCase().includes("execution error")) {
-        const blockGasLimit = await this._getBlockGasLimit();
-        return numberToRpcQuantity(blockGasLimit);
+      if (error instanceof Error) {
+        if (error.message.toLowerCase().includes("execution error")) {
+          const blockGasLimit = await this._getBlockGasLimit();
+          return numberToRpcQuantity(blockGasLimit);
+        }
       }
 
       // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
@@ -277,7 +279,7 @@ export class AutomaticGasPriceProvider extends ProviderWrapper {
 
         maxPriorityFeePerGas: rpcQuantityToBN(response.reward[0][0]),
       };
-    } catch (_error) {
+    } catch {
       this._nodeHasFeeHistory = false;
 
       return undefined;

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

@@ -171,7 +171,7 @@ export class HttpProvider extends EventEmitter implements EIP1193Provider {
       }
 
       return parseJsonResponse(await response.text());
-    } catch (error) {
+    } catch (error: any) {
       if (error.code === "ECONNREFUSED") {
         throw new HardhatError(
           ERRORS.NETWORK.NODE_IS_NOT_RUNNING,

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

@@ -11,7 +11,7 @@ export abstract class ProviderWrapper
     super(_wrappedProvider);
   }
 
-  public abstract async request(args: RequestArguments): Promise<unknown>;
+  public abstract request(args: RequestArguments): Promise<unknown>;
 
   protected _getParams<ParamsT extends any[] = any[]>(
     args: RequestArguments

package/src/internal/core/runtime-environment.ts

@@ -266,7 +266,9 @@ export class Environment implements HardhatRuntimeEnvironment {
             values[paramName] = resolvedArgumentValue;
           }
         } catch (error) {
-          errors.push(error);
+          if (HardhatError.isHardhatError(error)) {
+            errors.push(error);
+          }
         }
         return { errors, values };
       },