hardhat 2.6.8 → 2.8.0

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

@@ -6,10 +6,14 @@ import path from "path";
 import {
   HardhatConfig,
   HardhatNetworkAccountsConfig,
+  HardhatNetworkChainConfig,
+  HardhatNetworkChainsConfig,
   HardhatNetworkConfig,
   HardhatNetworkForkingConfig,
   HardhatNetworkMiningConfig,
   HardhatNetworkMiningUserConfig,
+  HardhatNetworkMempoolConfig,
+  HardhatNetworkMempoolUserConfig,
   HardhatNetworkUserConfig,
   HardhatUserConfig,
   HDAccountsUserConfig,
@@ -29,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";
 
@@ -148,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);
@@ -169,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,
@@ -179,6 +210,7 @@ function resolveHardhatNetworkConfig(
     gas,
     initialDate,
     minGasPrice,
+    chains,
   };
 
   // We do it this way because ts gets lost otherwise
@@ -228,10 +260,12 @@ function resolveHttpNetworkConfig(
 function resolveMiningConfig(
   userConfig: HardhatNetworkMiningUserConfig | undefined
 ): HardhatNetworkMiningConfig {
+  const mempool = resolveMempoolConfig(userConfig?.mempool);
   if (userConfig === undefined) {
     return {
       auto: true,
       interval: 0,
+      mempool,
     };
   }
 
@@ -241,6 +275,7 @@ function resolveMiningConfig(
     return {
       auto: true,
       interval: 0,
+      mempool,
     };
   }
 
@@ -248,6 +283,7 @@ function resolveMiningConfig(
     return {
       auto: false,
       interval,
+      mempool,
     };
   }
 
@@ -255,6 +291,7 @@ function resolveMiningConfig(
     return {
       auto,
       interval: 0,
+      mempool,
     };
   }
 
@@ -262,9 +299,30 @@ function resolveMiningConfig(
   return {
     auto: auto!,
     interval: interval!,
+    mempool,
   };
 }
 
+function resolveMempoolConfig(
+  userConfig: HardhatNetworkMempoolUserConfig | undefined
+): HardhatNetworkMempoolConfig {
+  if (userConfig === undefined) {
+    return {
+      order: "priority",
+    };
+  }
+
+  if (userConfig.order === undefined) {
+    return {
+      order: "priority",
+    };
+  }
+
+  return {
+    order: userConfig.order,
+  } as HardhatNetworkMempoolConfig;
+}
+
 function resolveSolidityConfig(userConfig: HardhatUserConfig): SolidityConfig {
   const userSolidityConfig = userConfig.solidity ?? DEFAULT_SOLC_VERSION;
 

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

@@ -3,6 +3,7 @@ import { Context, getFunctionName, ValidationError } from "io-ts/lib";
 import { Reporter } from "io-ts/lib/Reporter";
 
 import {
+  HARDHAT_MEMPOOL_SUPPORTED_ORDERS,
   HARDHAT_NETWORK_NAME,
   HARDHAT_NETWORK_SUPPORTED_HARDFORKS,
 } from "../../constants";
@@ -11,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 {
@@ -53,6 +55,59 @@ function getErrorMessage(path: string, value: any, expectedType: string) {
   )} for ${path} - Expected a value of type ${expectedType}.`;
 }
 
+function getPrivateKeyError(index: number, network: string, message: string) {
+  return `Invalid account: #${index} for network: ${network} - ${message}`;
+}
+
+function validatePrivateKey(
+  privateKey: unknown,
+  index: number,
+  network: string,
+  errors: string[]
+) {
+  if (typeof privateKey !== "string") {
+    errors.push(
+      getPrivateKeyError(
+        index,
+        network,
+        `Expected string, received ${typeof privateKey}`
+      )
+    );
+  } else {
+    // private key validation
+    const pkWithPrefix = /^0x/.test(privateKey)
+      ? privateKey
+      : `0x${privateKey}`;
+
+    // 32 bytes = 64 characters + 2 char prefix = 66
+    if (pkWithPrefix.length < 66) {
+      errors.push(
+        getPrivateKeyError(
+          index,
+          network,
+          "private key too short, expected 32 bytes"
+        )
+      );
+    } else if (pkWithPrefix.length > 66) {
+      errors.push(
+        getPrivateKeyError(
+          index,
+          network,
+          "private key too long, expected 32 bytes"
+        )
+      );
+    } else if (hexString.decode(pkWithPrefix).isLeft()) {
+      errors.push(
+        getPrivateKeyError(
+          index,
+          network,
+          "invalid hex character(s) found in string"
+        )
+      );
+    }
+  }
+}
+
 export function failure(es: ValidationError[]): string[] {
   return es.map(getMessage);
 }
@@ -91,6 +146,27 @@ export const hexString = new t.Type<string>(
   t.identity
 );
 
+function isAddress(v: unknown): v is string {
+  if (typeof v !== "string") {
+    return false;
+  }
+
+  const trimmed = v.trim();
+
+  return (
+    trimmed.match(HEX_STRING_REGEX) !== null &&
+    trimmed.startsWith("0x") &&
+    trimmed.length === 42
+  );
+}
+
+export const address = new t.Type<string>(
+  "address",
+  isAddress,
+  (u, c) => (isAddress(u) ? t.success(u) : t.failure(u, c)),
+  t.identity
+);
+
 export const decimalString = new t.Type<string>(
   "decimal string",
   isDecimalString,
@@ -117,12 +193,73 @@ 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,
   blockNumber: optional(t.number),
 });
 
+const HardhatNetworkMempoolConfig = t.type({
+  order: optional(
+    t.keyof(
+      fromEntries(
+        HARDHAT_MEMPOOL_SUPPORTED_ORDERS.map((order) => [order, null])
+      )
+    )
+  ),
+});
+
+const HardhatNetworkMiningConfig = t.type({
+  auto: optional(t.boolean),
+  interval: optional(t.union([t.number, t.tuple([t.number, t.number])])),
+  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),
@@ -149,6 +286,9 @@ const HardhatNetworkConfig = t.type({
   initialDate: optional(t.string),
   loggingEnabled: optional(t.boolean),
   forking: optional(HardhatNetworkForkingConfig),
+  mining: optional(HardhatNetworkMiningConfig),
+  coinbase: optional(address),
+  chains: optional(HardhatNetworkChainsConfig),
 });
 
 const HDAccountsConfig = t.type({
@@ -224,7 +364,7 @@ export function validateConfig(config: any) {
 }
 
 export function getValidationErrors(config: any): string[] {
-  const errors = [];
+  const errors: string[] = [];
 
   // These can't be validated with io-ts
   if (config !== undefined && typeof config.networks === "object") {
@@ -237,8 +377,7 @@ export function getValidationErrors(config: any): string[] {
       }
 
       // Validating the accounts with io-ts leads to very confusing errors messages
-      const configExceptAccounts = { ...hardhatNetwork };
-      delete configExceptAccounts.accounts;
+      const { accounts, ...configExceptAccounts } = hardhatNetwork;
 
       const netConfigResult = HardhatNetworkConfig.decode(configExceptAccounts);
       if (netConfigResult.isLeft()) {
@@ -251,31 +390,37 @@ export function getValidationErrors(config: any): string[] {
         );
       }
 
-      if (Array.isArray(hardhatNetwork.accounts)) {
-        for (const account of hardhatNetwork.accounts) {
-          if (typeof account.privateKey !== "string") {
+      // manual validation of accounts
+      if (Array.isArray(accounts)) {
+        for (const [index, account] of accounts.entries()) {
+          if (typeof account !== "object") {
             errors.push(
-              getErrorMessage(
-                `HardhatConfig.networks.${HARDHAT_NETWORK_NAME}.accounts[].privateKey`,
-                account.privateKey,
-                "string"
+              getPrivateKeyError(
+                index,
+                HARDHAT_NETWORK_NAME,
+                `Expected object, received ${typeof account}`
               )
             );
+            continue;
           }
 
-          if (typeof account.balance !== "string") {
+          const { privateKey, balance } = account;
+
+          validatePrivateKey(privateKey, index, HARDHAT_NETWORK_NAME, errors);
+
+          if (typeof balance !== "string") {
             errors.push(
               getErrorMessage(
                 `HardhatConfig.networks.${HARDHAT_NETWORK_NAME}.accounts[].balance`,
-                account.balance,
+                balance,
                 "string"
               )
             );
-          } else if (decimalString.decode(account.balance).isLeft()) {
+          } else if (decimalString.decode(balance).isLeft()) {
             errors.push(
               getErrorMessage(
                 `HardhatConfig.networks.${HARDHAT_NETWORK_NAME}.accounts[].balance`,
-                account.balance,
+                balance,
                 "decimal(wei)"
               )
             );
@@ -319,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>(
@@ -340,7 +508,9 @@ export function getValidationErrors(config: any): string[] {
         }
       }
 
-      const netConfigResult = HttpNetworkConfig.decode(netConfig);
+      const { accounts, ...configExceptAccounts } = netConfig;
+
+      const netConfigResult = HttpNetworkConfig.decode(configExceptAccounts);
       if (netConfigResult.isLeft()) {
         errors.push(
           getErrorMessage(
@@ -350,6 +520,38 @@ export function getValidationErrors(config: any): string[] {
           )
         );
       }
+
+      // manual validation of accounts
+      if (Array.isArray(accounts)) {
+        accounts.forEach((privateKey, index) =>
+          validatePrivateKey(privateKey, index, networkName, errors)
+        );
+      } else if (typeof accounts === "object") {
+        const hdConfigResult = HDAccountsConfig.decode(accounts);
+        if (hdConfigResult.isLeft()) {
+          errors.push(
+            getErrorMessage(
+              `HardhatConfig.networks.${networkName}`,
+              accounts,
+              "HttpNetworkHDAccountsConfig"
+            )
+          );
+        }
+      } else if (typeof accounts === "string") {
+        if (accounts !== "remote") {
+          errors.push(
+            `Invalid 'accounts' entry for network '${networkName}': expected an array of accounts or the string 'remote', but got the string '${accounts}'`
+          );
+        }
+      } else if (accounts !== undefined) {
+        errors.push(
+          getErrorMessage(
+            `HardhatConfig.networks.${networkName}.accounts`,
+            accounts,
+            '"remote" | string[] | HttpNetworkHDAccountsConfig | undefined'
+          )
+        );
+      }
     }
   }
 

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,18 +36,81 @@ export const defaultHardhatNetworkParams: Omit<
   HardhatNetworkConfig,
   "gas" | "initialDate"
 > = {
-  hardfork: "london",
+  hardfork: "arrowGlacier",
   blockGasLimit: 30_000_000,
   gasPrice: HARDHAT_NETWORK_DEFAULT_GAS_PRICE,
   chainId: 31337,
   throwOnTransactionFailures: true,
   throwOnCallFailures: true,
   allowUnlimitedContractSize: false,
-  mining: { auto: true, interval: 0 },
+  mining: {
+    auto: true,
+    interval: 0,
+    mempool: {
+      order: "priority",
+    },
+  },
   accounts: defaultHardhatNetworkHdAccountsConfigParams,
   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/errors-list.ts

@@ -571,7 +571,7 @@ Please double check how you invoked Hardhat or ran your task.`,
     },
     MISSING_TASK_ARGUMENT: {
       number: 306,
-      message: "Missing task argument %param%",
+      message: "The '%param%' parameter expects a value, but none was passed.",
       title: "Missing task argument",
       description: `You tried to run a task, but one of its required arguments was missing. 
 
@@ -884,7 +884,7 @@ Please use a newer, supported version.`,
   ARTIFACTS: {
     NOT_FOUND: {
       number: 700,
-      message: 'Artifact for contract "%contractName%" not found.',
+      message: 'Artifact for contract "%contractName%" not found. %suggestion%',
       title: "Artifact not found",
       description: `Tried to import a nonexistent artifact.
 

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/jsonrpc/types/output/log.ts

@@ -6,6 +6,7 @@ import { rpcAddress, rpcData, rpcHash, rpcQuantity } from "../base-types";
 export type RpcLog = t.TypeOf<typeof rpcLog>;
 export const rpcLog = t.type(
   {
+    logIndex: nullable(rpcQuantity),
     transactionIndex: nullable(rpcQuantity),
     transactionHash: nullable(rpcHash),
     blockHash: nullable(rpcHash),

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;
     }
   },