hardhat 2.6.6 → 2.7.1

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";
@@ -53,6 +54,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 +145,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,
@@ -123,6 +198,22 @@ const HardhatNetworkForkingConfig = t.type({
   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),
+});
+
 const commonNetworkConfigFields = {
   chainId: optional(t.number),
   from: optional(t.string),
@@ -149,6 +240,8 @@ const HardhatNetworkConfig = t.type({
   initialDate: optional(t.string),
   loggingEnabled: optional(t.boolean),
   forking: optional(HardhatNetworkForkingConfig),
+  mining: optional(HardhatNetworkMiningConfig),
+  coinbase: optional(address),
 });
 
 const HDAccountsConfig = t.type({
@@ -224,7 +317,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 +330,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 +343,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)"
               )
             );
@@ -340,7 +438,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 +450,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

@@ -7,7 +7,7 @@ export const DEFAULT_SOLC_VERSION = "0.7.3";
 export const HARDHAT_NETWORK_DEFAULT_GAS_PRICE = "auto";
 export const HARDHAT_NETWORK_DEFAULT_MAX_PRIORITY_FEE_PER_GAS = 1e9;
 export const HARDHAT_NETWORK_DEFAULT_INITIAL_BASE_FEE_PER_GAS = 1e9;
-const HARDHAT_NETWORK_MNEMONIC =
+export const HARDHAT_NETWORK_MNEMONIC =
   "test test test test test test test test test test test junk";
 export const DEFAULT_HARDHAT_NETWORK_BALANCE = "10000000000000000000000";
 
@@ -35,14 +35,20 @@ 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,
@@ -69,6 +75,7 @@ export const defaultSolcOutputSelection = {
       "evm.bytecode",
       "evm.deployedBytecode",
       "evm.methodIdentifiers",
+      "metadata",
     ],
     "": ["ast"],
   },

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

@@ -360,6 +360,15 @@ Please double check your transactions' parameters.`,
 Please double check your transactions' parameters.`,
       shouldBeReported: false,
     },
+    PERSONALSIGN_MISSING_ADDRESS_PARAM: {
+      number: 116,
+      message: 'Missing "address" param when calling personal_sign.',
+      title: "Missing `address` param when calling personal_sign.",
+      description: `You called \`personal_sign\` with incorrect parameters.
+
+Please check that you are sending an \`address\` parameter.`,
+      shouldBeReported: false,
+    },
   },
   TASK_DEFINITIONS: {
     PARAM_AFTER_VARIADIC: {
@@ -562,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. 
 
@@ -861,11 +870,21 @@ To start the JSON-RPC server, retry the command without the --network parameter.
 if the URL of the JSON-RPC wasn't set.`,
       shouldBeReported: false,
     },
+    COMPILE_TASK_UNSUPPORTED_SOLC_VERSION: {
+      number: 608,
+      message: `Version %version% is not supported by Hardhat.
+
+The first supported version is %firstSupportedVersion%`,
+      title: "Unsupported solc version",
+      description: `This version of solidity is not supported by Hardhtat.
+Please use a newer, supported version.`,
+      shouldBeReported: true,
+    },
   },
   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;
     }
   },
 

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/params/hardhat-params.ts

@@ -78,8 +78,8 @@ export const HARDHAT_PARAM_DEFINITIONS: HardhatParamDefinitions = {
   tsconfig: {
     name: "tsconfig",
     defaultValue: undefined,
-    description: "Reserved hardhat argument -- Has no effect.",
-    type: types.string,
+    description: "A TypeScript config file.",
+    type: types.inputFile,
     isOptional: true,
     isFlag: false,
     isVariadic: false,

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

@@ -74,6 +74,25 @@ export class LocalAccountsProvider extends ProviderWrapperWithChainId {
       }
     }
 
+    if (args.method === "personal_sign") {
+      if (params.length > 0) {
+        const [data, address] = validateParams(params, rpcData, rpcAddress);
+
+        if (data !== undefined) {
+          if (address === undefined) {
+            throw new HardhatError(
+              ERRORS.NETWORK.PERSONALSIGN_MISSING_ADDRESS_PARAM
+            );
+          }
+
+          const privateKey = this._getPrivateKeyForAddress(address);
+          const messageHash = hashPersonalMessage(toBuffer(data));
+          const signature = ecsign(messageHash, privateKey);
+          return toRpcSig(signature.v, signature.r, signature.s);
+        }
+      }
+    }
+
     if (args.method === "eth_signTypedData_v4") {
       const [address, data] = validateParams(params, rpcAddress, t.any);
 
@@ -85,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
           );
@@ -200,7 +219,7 @@ export class LocalAccountsProvider extends ProviderWrapperWithChainId {
   private _getPrivateKeyForAddressOrNull(address: Buffer): Buffer | null {
     try {
       return this._getPrivateKeyForAddress(address);
-    } catch (e) {
+    } catch {
       return null;
     }
   }
@@ -234,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" })
@@ -328,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

@@ -13,7 +13,10 @@ import type {
 } from "../../../types";
 import { HARDHAT_NETWORK_NAME } from "../../constants";
 import { ModulesLogger } from "../../hardhat-network/provider/modules/logger";
-import { ForkConfig } from "../../hardhat-network/provider/node-types";
+import {
+  ForkConfig,
+  MempoolOrder,
+} from "../../hardhat-network/provider/node-types";
 import { getForkCacheDirPath } from "../../hardhat-network/provider/utils/disk-cache";
 import { parseDateString } from "../../util/date";
 
@@ -88,6 +91,8 @@ export function createProvider(
       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,
       new ModulesLogger(hardhatNetConfig.loggingEnabled),
       accounts,
       artifacts,
@@ -97,7 +102,8 @@ export function createProvider(
         : undefined,
       experimentalHardhatNetworkMessageTraceHooks,
       forkConfig,
-      paths !== undefined ? getForkCacheDirPath(paths) : undefined
+      paths !== undefined ? getForkCacheDirPath(paths) : undefined,
+      hardhatNetConfig.coinbase
     );
   } else {
     const HttpProvider = importProvider<

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
@@ -142,7 +144,7 @@ export class AutomaticGasPriceProvider extends ProviderWrapper {
   public static readonly EIP1559_BASE_FEE_MAX_FULL_BLOCKS_PREFERENCE: number = 3;
 
   // See eth_feeHistory for an explanation of what this means
-  public static readonly EIP1559_REWARD_PERCENTILE: number = 0.5;
+  public static readonly EIP1559_REWARD_PERCENTILE: number = 50;
 
   private _nodeHasFeeHistory?: boolean;
   private _nodeSupportsEIP1559?: boolean;
@@ -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 };
       },