hardhat 2.6.8 → 2.8.0

package/src/internal/hardhat-network/provider/node.ts

@@ -27,6 +27,8 @@ import {
 import EventEmitter from "events";
 
 import { CompilerInput, CompilerOutput } from "../../../types";
+import { HardforkHistoryConfig } from "../../../types/config";
+import { HARDHAT_NETWORK_SUPPORTED_HARDFORKS } from "../../constants";
 import {
   HARDHAT_NETWORK_DEFAULT_INITIAL_BASE_FEE_PER_GAS,
   HARDHAT_NETWORK_DEFAULT_MAX_PRIORITY_FEE_PER_GAS,
@@ -82,6 +84,7 @@ import {
   GatherTracesResult,
   GenesisAccount,
   isForkedNodeConfig,
+  MempoolOrder,
   MineBlockResult,
   NodeConfig,
   RunCallResult,
@@ -115,10 +118,6 @@ const log = debug("hardhat:core:hardhat-network:node");
 
 const ethSigUtil = require("eth-sig-util");
 
-export const COINBASE_ADDRESS = Address.fromString(
-  "0xc014ba5ec014ba5ec014ba5ec014ba5ec014ba5e"
-);
-
 /* eslint-disable @nomiclabs/hardhat-internal-rules/only-hardhat-error */
 
 export class HardhatNode extends EventEmitter {
@@ -132,6 +131,9 @@ export class HardhatNode extends EventEmitter {
       allowUnlimitedContractSize,
       tracingConfig,
       minGasPrice,
+      mempoolOrder,
+      networkId,
+      chainId,
     } = config;
 
     let common: Common;
@@ -140,6 +142,8 @@ export class HardhatNode extends EventEmitter {
     let initialBlockTimeOffset: BN | undefined;
     let nextBlockBaseFeePerGas: BN | undefined;
     let forkNetworkId: number | undefined;
+    let forkBlockNum: number | undefined;
+    let hardforkActivations: HardforkHistoryConfig = new Map();
 
     const initialBaseFeePerGasConfig =
       config.initialBaseFeePerGas !== undefined
@@ -154,6 +158,7 @@ export class HardhatNode extends EventEmitter {
       common = await makeForkCommon(config);
 
       forkNetworkId = forkClient.getNetworkId();
+      forkBlockNum = forkBlockNumber.toNumber();
 
       this._validateHardforks(
         config.forkConfig.blockNumber,
@@ -191,6 +196,10 @@ export class HardhatNode extends EventEmitter {
           }
         }
       }
+
+      if (config.chains.has(forkNetworkId)) {
+        hardforkActivations = config.chains.get(forkNetworkId)!.hardforkHistory;
+      }
     } else {
       const hardhatStateManager = new HardhatStateManager();
       await hardhatStateManager.initializeGenesisAccounts(genesisAccounts);
@@ -242,9 +251,15 @@ export class HardhatNode extends EventEmitter {
       automine,
       minGasPrice,
       initialBlockTimeOffset,
+      mempoolOrder,
+      config.coinbase,
       genesisAccounts,
+      networkId,
+      chainId,
+      hardforkActivations,
       tracingConfig,
       forkNetworkId,
+      forkBlockNum,
       nextBlockBaseFeePerGas
     );
 
@@ -268,7 +283,7 @@ The hardfork must be at least spuriousDragon, but ${common.hardfork()} was given
       let upstreamCommon: Common;
       try {
         upstreamCommon = new Common({ chain: remoteChainId });
-      } catch (error) {
+      } catch {
         // If ethereumjs doesn't have a common it will throw and we won't have
         // info about the activation block of each hardfork, so we don't run
         // this validation.
@@ -315,9 +330,15 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     private _automine: boolean,
     private _minGasPrice: BN,
     private _blockTimeOffsetSeconds: BN = new BN(0),
+    private _mempoolOrder: MempoolOrder,
+    private _coinbase: string,
     genesisAccounts: GenesisAccount[],
+    private readonly _configNetworkId: number,
+    private readonly _configChainId: number,
+    private readonly _hardforkActivations: HardforkHistoryConfig,
     tracingConfig?: TracingConfig,
     private _forkNetworkId?: number,
+    private _forkBlockNumber?: number,
     nextBlockBaseFee?: BN
   ) {
     super();
@@ -367,7 +388,9 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         error
       );
 
-      Reporter.reportError(error);
+      if (error instanceof Error) {
+        Reporter.reportError(error);
+      }
     }
   }
 
@@ -434,16 +457,21 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     try {
       result = await this._mineBlockWithPendingTxs(blockTimestamp);
     } catch (err) {
-      if (err?.message.includes("sender doesn't have enough funds")) {
-        throw new InvalidInputError(err.message, err);
-      }
+      if (err instanceof Error) {
+        if (err?.message.includes("sender doesn't have enough funds")) {
+          throw new InvalidInputError(err.message, err);
+        }
 
-      // Some network errors are HardhatErrors, and can end up here when forking
-      if (HardhatError.isHardhatError(err)) {
-        throw err;
+        // Some network errors are HardhatErrors, and can end up here when forking
+        if (HardhatError.isHardhatError(err)) {
+          throw err;
+        }
+
+        throw new TransactionExecutionError(err);
       }
 
-      throw new TransactionExecutionError(err);
+      // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+      throw err;
     }
 
     await this._saveBlockAsSuccessfullyRun(result.block, result.blockResult);
@@ -473,7 +501,10 @@ Hardhat Network's forking functionality only works with blocks from at least spu
       blockNumberOrPending
     );
 
-    if (call.gasPrice !== undefined || !this.isEip1559Active()) {
+    if (
+      call.gasPrice !== undefined ||
+      !this.isEip1559Active(blockNumberOrPending)
+    ) {
       txParams = {
         gasPrice: new BN(0),
         nonce,
@@ -697,7 +728,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
   }
 
   public getCoinbaseAddress(): Address {
-    return COINBASE_ADDRESS;
+    return Address.fromString(this._coinbase);
   }
 
   public async getStorageAt(
@@ -870,6 +901,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
       irregularStatesByBlockNumber: this._irregularStatesByBlockNumber,
       userProvidedNextBlockBaseFeePerGas:
         this.getUserProvidedNextBlockBaseFeePerGas(),
+      coinbase: this.getCoinbaseAddress().toString(),
     };
 
     this._irregularStatesByBlockNumber = new Map(
@@ -924,6 +956,8 @@ Hardhat Network's forking functionality only works with blocks from at least spu
       this._resetUserProvidedNextBlockBaseFeePerGas();
     }
 
+    this._coinbase = snapshot.coinbase;
+
     // We delete this and the following snapshots, as they can only be used
     // once in Ganache
     this._snapshots.splice(snapshotIndex);
@@ -1209,7 +1243,10 @@ Hardhat Network's forking functionality only works with blocks from at least spu
             "this._forkNetworkId should exist if the blockchain is an instance of ForkBlockchain"
           );
 
-          const common = getCommonForTracing(this._forkNetworkId, blockNumber);
+          const common = this._getCommonForTracing(
+            this._forkNetworkId,
+            blockNumber
+          );
 
           vm = new VM({
             common,
@@ -1349,6 +1386,10 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     };
   }
 
+  public async setCoinbase(coinbase: Address) {
+    this._coinbase = coinbase.toString();
+  }
+
   private _getGasUsedRatio(block: Block): number {
     const FLOATS_PRECISION = 100_000;
 
@@ -1499,7 +1540,12 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     try {
       sender = tx.getSenderAddress(); // verifies signature as a side effect
     } catch (e) {
-      throw new InvalidInputError(e.message);
+      if (e instanceof Error) {
+        throw new InvalidInputError(e.message);
+      }
+
+      // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+      throw e;
     }
 
     // validate nonce
@@ -1579,6 +1625,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
       const pendingTxs = this._txPool.getPendingTransactions();
       const transactionQueue = new TransactionQueue(
         pendingTxs,
+        this._mempoolOrder,
         headerData.baseFeePerGas
       );
 
@@ -2129,6 +2176,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     const initialStateRoot = await this._stateManager.getStateRoot();
 
     let blockContext: Block | undefined;
+    let originalCommon: Common | undefined;
 
     try {
       if (blockNumberOrPending === "pending") {
@@ -2163,7 +2211,7 @@ Hardhat Network's forking functionality only works with blocks from at least spu
       // eth_call. This will make the BASEFEE option also return 0, which
       // shouldn't. See: https://github.com/nomiclabs/hardhat/issues/1688
       if (
-        this.isEip1559Active() &&
+        this.isEip1559Active(blockNumberOrPending) &&
         (blockContext.header.baseFeePerGas === undefined || forceBaseFeeZero)
       ) {
         blockContext = Block.fromBlockData(blockContext, {
@@ -2174,6 +2222,17 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         (blockContext.header as any).baseFeePerGas = new BN(0);
       }
 
+      originalCommon = (this._vm as any)._common;
+      (this._vm as any)._common = new Common({
+        chain: {
+          // eslint-disable-next-line @typescript-eslint/dot-notation
+          ...this._vm._common["_chainParams"],
+          chainId: this._forkNetworkId ?? this._configChainId,
+          networkId: this._forkNetworkId ?? this._configNetworkId,
+        },
+        hardfork: this._selectHardfork(blockContext.header.number),
+      });
+
       return await this._vm.runTx({
         block: blockContext,
         tx,
@@ -2182,6 +2241,9 @@ Hardhat Network's forking functionality only works with blocks from at least spu
         skipBlockGasLimitValidation: true,
       });
     } finally {
+      if (originalCommon !== undefined) {
+        (this._vm as any)._common = originalCommon;
+      }
       await this._stateManager.setStateRoot(initialStateRoot);
     }
   }
@@ -2277,7 +2339,16 @@ Hardhat Network's forking functionality only works with blocks from at least spu
     );
   }
 
-  public isEip1559Active(): boolean {
+  public isEip1559Active(blockNumberOrPending?: BN | "pending"): boolean {
+    if (
+      blockNumberOrPending !== undefined &&
+      blockNumberOrPending !== "pending"
+    ) {
+      return this._vm._common.hardforkGteHardfork(
+        this._selectHardfork(blockNumberOrPending),
+        "london"
+      );
+    }
     return this._vm._common.gteHardfork("london");
   }
 
@@ -2287,7 +2358,10 @@ Hardhat Network's forking functionality only works with blocks from at least spu
   ): Promise<
     { gasPrice: BN } | { maxFeePerGas: BN; maxPriorityFeePerGas: BN }
   > {
-    if (!this.isEip1559Active() || callParams.gasPrice !== undefined) {
+    if (
+      !this.isEip1559Active(blockNumberOrPending) ||
+      callParams.gasPrice !== undefined
+    ) {
       return { gasPrice: callParams.gasPrice ?? (await this.getGasPrice()) };
     }
 
@@ -2317,18 +2391,71 @@ Hardhat Network's forking functionality only works with blocks from at least spu
 
     return { maxFeePerGas, maxPriorityFeePerGas };
   }
-}
 
-function getCommonForTracing(networkId: number, blockNumber: number): Common {
-  try {
-    const common = new Common({ chain: networkId });
+  private _selectHardfork(blockNumber: BN): string {
+    if (
+      this._forkBlockNumber === undefined ||
+      blockNumber.gte(new BN(this._forkBlockNumber))
+    ) {
+      return this._vm._common.hardfork() as HardforkName;
+    }
 
-    common.setHardfork(common.activeHardfork(blockNumber));
+    if (this._hardforkActivations.size === 0) {
+      throw new InternalError(
+        `No known hardfork for execution on historical block ${blockNumber.toString()} (relative to fork block number ${
+          this._forkBlockNumber
+        }). The node was not configured with a hardfork activation history.  See http://hardhat.org/hardhat-network/guides/mainnet-forking.html#using-a-custom-hardfork-history`
+      );
+    }
 
-    return common;
-  } catch (e) {
-    throw new InternalError(
-      `Network id ${networkId} does not correspond to a network that Hardhat can trace`
+    /** search this._hardforkActivations for the highest block number that
+     * isn't higher than blockNumber, and then return that found block number's
+     * associated hardfork name. */
+    const hardforkHistory: Array<[name: string, block: number]> = Array.from(
+      this._hardforkActivations.entries()
+    );
+    const [hardfork, activationBlock] = hardforkHistory.reduce(
+      ([highestHardfork, highestBlock], [thisHardfork, thisBlock]) =>
+        thisBlock > highestBlock && new BN(thisBlock).lte(blockNumber)
+          ? [thisHardfork, thisBlock]
+          : [highestHardfork, highestBlock]
     );
+    if (hardfork === undefined || blockNumber.ltn(activationBlock)) {
+      throw new InternalError(
+        `Could not find a hardfork to run for block ${blockNumber}, after having looked for one in the HardhatNode's hardfork activation history, which was: ${JSON.stringify(
+          hardforkHistory
+        )}. For more information, see https://hardhat.org/hardhat-network/reference/#config`
+      );
+    }
+
+    if (!HARDHAT_NETWORK_SUPPORTED_HARDFORKS.includes(hardfork)) {
+      throw new InternalError(
+        `Tried to run a call or transaction in the context of a block whose hardfork is "${hardfork}", but Hardhat Network only supports the following hardforks: ${HARDHAT_NETWORK_SUPPORTED_HARDFORKS.join(
+          ", "
+        )}`
+      );
+    }
+
+    return hardfork;
+  }
+
+  private _getCommonForTracing(networkId: number, blockNumber: number): Common {
+    try {
+      const common = new Common({
+        chain: {
+          // eslint-disable-next-line @typescript-eslint/dot-notation
+          ...Common["_getChainParams"]("mainnet"),
+          chainId: networkId,
+          networkId,
+        },
+        hardfork: this._selectHardfork(new BN(blockNumber)),
+      });
+
+      return common;
+    } catch {
+      throw new InternalError(
+        `Network id ${networkId} does not correspond to a network that Hardhat can trace`
+      );
+    }
   }
 }

package/src/internal/hardhat-network/provider/output.ts

@@ -292,18 +292,18 @@ export function getRpcReceiptOutputsFromLocalBlockExecution(
 ): RpcReceiptOutput[] {
   const receipts: RpcReceiptOutput[] = [];
 
-  let cumulativeGasUsed = new BN(0);
+  let blockLogIndex = 0;
 
   for (let i = 0; i < runBlockResult.results.length; i += 1) {
     const tx = block.transactions[i];
     const { createdAddress, gasUsed } = runBlockResult.results[i];
     const receipt = runBlockResult.receipts[i];
 
-    cumulativeGasUsed = cumulativeGasUsed.add(new BN(receipt.gasUsed));
-
-    const logs = receipt.logs.map((log, logIndex) =>
-      getRpcLogOutput(log, tx, block, i, logIndex)
-    );
+    const logs = receipt.logs.map((log) => {
+      const result = getRpcLogOutput(log, tx, block, i, blockLogIndex);
+      blockLogIndex += 1;
+      return result;
+    });
 
     const rpcReceipt: RpcReceiptOutput = {
       transactionHash: bufferToRpcData(tx.hash()),
@@ -312,7 +312,7 @@ export function getRpcReceiptOutputsFromLocalBlockExecution(
       blockNumber: numberToRpcQuantity(new BN(block.header.number)),
       from: bufferToRpcData(tx.getSenderAddress().toBuffer()),
       to: tx.to === undefined ? null : bufferToRpcData(tx.to.toBuffer()),
-      cumulativeGasUsed: numberToRpcQuantity(cumulativeGasUsed),
+      cumulativeGasUsed: numberToRpcQuantity(new BN(receipt.gasUsed)),
       gasUsed: numberToRpcQuantity(gasUsed),
       contractAddress:
         createdAddress !== undefined
@@ -395,7 +395,7 @@ export function remoteReceiptToRpcReceiptOutput(
   };
 }
 
-export function toRpcLogOutput(log: RpcLog, index?: number): RpcLogOutput {
+export function toRpcLogOutput(log: RpcLog): RpcLogOutput {
   return {
     removed: false,
     address: bufferToRpcData(log.address),
@@ -403,7 +403,7 @@ export function toRpcLogOutput(log: RpcLog, index?: number): RpcLogOutput {
     blockNumber:
       log.blockNumber !== null ? numberToRpcQuantity(log.blockNumber) : null,
     data: bufferToRpcData(log.data),
-    logIndex: index !== undefined ? numberToRpcQuantity(index) : null,
+    logIndex: log.logIndex !== null ? numberToRpcQuantity(log.logIndex) : null,
     transactionIndex:
       log.transactionIndex !== null
         ? numberToRpcQuantity(log.transactionIndex)

package/src/internal/hardhat-network/provider/provider.ts

@@ -11,6 +11,7 @@ import type {
   BoundExperimentalHardhatNetworkMessageTraceHook,
   EIP1193Provider,
   EthSubscription,
+  HardhatNetworkChainsConfig,
   RequestArguments,
 } from "../../../types";
 import {
@@ -40,6 +41,7 @@ import {
   ForkConfig,
   GenesisAccount,
   IntervalMiningConfig,
+  MempoolOrder,
   NodeConfig,
   TracingConfig,
 } from "./node-types";
@@ -54,6 +56,8 @@ const PRIVATE_RPC_METHODS = new Set([
 
 /* eslint-disable @nomiclabs/hardhat-internal-rules/only-hardhat-error */
 
+export const DEFAULT_COINBASE = "0xc014ba5ec014ba5ec014ba5ec014ba5ec014ba5e";
+
 export class HardhatNetworkProvider
   extends EventEmitter
   implements EIP1193Provider
@@ -81,6 +85,8 @@ export class HardhatNetworkProvider
     private readonly _throwOnCallFailures: boolean,
     private readonly _automine: boolean,
     private readonly _intervalMining: IntervalMiningConfig,
+    private readonly _mempoolOrder: MempoolOrder,
+    private readonly _chains: HardhatNetworkChainsConfig,
     private readonly _logger: ModulesLogger,
     private readonly _genesisAccounts: GenesisAccount[] = [],
     private readonly _artifacts?: Artifacts,
@@ -88,7 +94,8 @@ export class HardhatNetworkProvider
     private readonly _initialDate?: Date,
     private readonly _experimentalHardhatNetworkMessageTraceHooks: BoundExperimentalHardhatNetworkMessageTraceHook[] = [],
     private _forkConfig?: ForkConfig,
-    private readonly _forkCachePath?: string
+    private readonly _forkCachePath?: string,
+    private readonly _coinbase = DEFAULT_COINBASE
   ) {
     super();
   }
@@ -159,7 +166,7 @@ export class HardhatNetworkProvider
       this._logger.printFailedMethod(method);
       this._logger.printLogs();
 
-      if (!this._logger.isLoggedError(err)) {
+      if (err instanceof Error && !this._logger.isLoggedError(err)) {
         if (ProviderError.isProviderError(err)) {
           this._logger.printEmptyLine();
           this._logger.printErrorMessage(err.message);
@@ -227,6 +234,7 @@ export class HardhatNetworkProvider
       allowUnlimitedContractSize: this._allowUnlimitedContractSize,
       tracingConfig: await this._makeTracingConfig(),
       initialBaseFeePerGas: this._initialBaseFeePerGas,
+      mempoolOrder: this._mempoolOrder,
       hardfork: this._hardfork,
       networkName: this._networkName,
       chainId: this._chainId,
@@ -235,6 +243,8 @@ export class HardhatNetworkProvider
       forkConfig: this._forkConfig,
       forkCachePath:
         this._forkConfig !== undefined ? this._forkCachePath : undefined,
+      coinbase: this._coinbase,
+      chains: this._chains,
     };
 
     const [common, node] = await HardhatNode.create(config);

package/src/internal/hardhat-network/provider/transactions/ReadOnlyValidEIP1559Transaction.ts

@@ -57,7 +57,7 @@ export class ReadOnlyValidEIP1559Transaction extends FeeMarketEIP1559Transaction
   constructor(sender: Address, data: FeeMarketEIP1559TxData = {}) {
     const fakeCommon = new Common({
       chain: "mainnet",
-      hardfork: "london",
+      hardfork: "london", // TODO: consider chaning this to ["latest hardfork"]
     });
 
     // this class should only be used with txs in a hardfork that

package/src/internal/hardhat-network/stack-traces/solidity-errors.ts

@@ -36,7 +36,7 @@ export async function wrapWithSolidityErrorsCorrection(
 
   try {
     return await f();
-  } catch (error) {
+  } catch (error: any) {
     if (error.stackTrace === undefined) {
       // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
       throw error;

package/src/internal/hardhat-network/stack-traces/vm-tracer.ts

@@ -160,7 +160,7 @@ export class VMTracer {
       if (this._throwErrors) {
         next(error);
       } else {
-        this._lastError = error;
+        this._lastError = error as Error;
         next();
       }
     }
@@ -187,7 +187,7 @@ export class VMTracer {
       if (this._throwErrors) {
         next(error);
       } else {
-        this._lastError = error;
+        this._lastError = error as Error;
         next();
       }
     }
@@ -219,7 +219,7 @@ export class VMTracer {
       if (this._throwErrors) {
         next(error);
       } else {
-        this._lastError = error;
+        this._lastError = error as Error;
         next();
       }
     }

package/src/internal/reset.ts

@@ -29,7 +29,7 @@ export function resetHardhatContext() {
 function unloadModule(path: string) {
   try {
     delete require.cache[require.resolve(path)];
-  } catch (err) {
+  } catch {
     // module wasn't loaded
   }
 }

package/src/internal/sentry/subprocess.ts

@@ -36,7 +36,7 @@ async function main() {
   let event: any;
   try {
     event = JSON.parse(serializedEvent);
-  } catch (error) {
+  } catch {
     log(
       "HARDHAT_SENTRY_EVENT env variable doesn't have a valid JSON, exiting: %o",
       serializedEvent
@@ -62,7 +62,7 @@ async function main() {
         `There was an error anonymizing an event: ${anonymizedEvent.value}`
       );
     }
-  } catch (error) {
+  } catch (error: any) {
     log("Couldn't capture event %o, got error %O", event, error);
     Sentry.captureMessage(
       `There was an error capturing an event: ${error.message}`

package/src/internal/solidity/compiler/downloader.ts

@@ -141,25 +141,40 @@ export class CompilerDownloader {
         platform: compilerBuild.platform,
       };
     } catch (e) {
-      if (HardhatError.isHardhatError(e)) {
-        throw e;
+      if (e instanceof Error) {
+        if (HardhatError.isHardhatError(e)) {
+          throw e;
+        }
+        console.warn(
+          chalk.yellow(
+            `There was an unexpected problem downloading the compiler: ${e.message}`
+          )
+        );
       }
-      console.warn(
-        chalk.yellow(
-          `There was an unexpected problem downloading the compiler: ${e.message}`
-        )
-      );
     }
   }
 
   public async getCompilersList(
-    platform: CompilerPlatform
+    platform: CompilerPlatform,
+    pendingRetries: number = 3
   ): Promise<CompilersList> {
     if (!(await this.compilersListExists(platform))) {
       await this.downloadCompilersList(platform);
     }
 
-    return fsExtra.readJson(this.getCompilersListPath(platform));
+    try {
+      return await fsExtra.readJSON(this.getCompilersListPath(platform));
+    } catch (error) {
+      // if parsing throws a syntax error, redownload and parse once more
+      if (!(error instanceof SyntaxError) || pendingRetries === 0) {
+        // eslint-disable-next-line @nomiclabs/hardhat-internal-rules/only-hardhat-error
+        throw error;
+      }
+
+      // remove the malformed list and retry
+      await fsExtra.remove(this.getCompilersListPath(platform));
+      return this.getCompilersList(platform, pendingRetries - 1);
+    }
   }
 
   public async getCompilerBuild(version: string): Promise<CompilerBuild> {
@@ -168,7 +183,7 @@ export class CompilerDownloader {
     if (await this._versionExists(version, platform)) {
       try {
         return await this._getCompilerBuildByPlatform(version, platform);
-      } catch (e) {
+      } catch {
         log("Couldn't download native compiler, using solcjs instead");
       }
     }
@@ -182,7 +197,7 @@ export class CompilerDownloader {
         getCompilerListURL(platform),
         this.getCompilersListPath(platform)
       );
-    } catch (error) {
+    } catch (error: any) {
       throw new HardhatError(
         ERRORS.SOLC.VERSION_LIST_DOWNLOAD_FAILED,
         {},
@@ -212,7 +227,7 @@ export class CompilerDownloader {
         {
           remoteVersion: compilerBuild.version,
         },
-        error
+        error as Error
       );
     }
   }

package/src/internal/solidity/resolver.ts

@@ -227,7 +227,7 @@ export class Resolver {
           {
             library: libraryName,
           },
-          error
+          error as Error
         );
       }
     }

package/src/internal/util/abi-helpers.ts

@@ -21,7 +21,7 @@ export class AbiHelpers {
       const selectorHex = abi.Interface.getSighash(fragment);
 
       return Buffer.from(selectorHex.slice(2), "hex");
-    } catch (e) {
+    } catch {
       return;
     }
   }