@nomicfoundation/hardhat-ethers-chai-matchers 3.0.0-next.3 → 3.0.0-next.31

package/src/index.ts

@@ -5,17 +5,10 @@ import "./type-extensions.js";
 const hardhatChaiMatchersPlugin: HardhatPlugin = {
   id: "hardhat-ethers-chai-matchers",
   hookHandlers: {
-    network: import.meta.resolve("./internal/hook-handlers/network.js"),
+    network: () => import("./internal/hook-handlers/network.js"),
   },
   npmPackage: "@nomicfoundation/hardhat-ethers-chai-matchers",
-  dependencies: [
-    async () => {
-      const { default: hardhatEthersPlugin } = await import(
-        "@nomicfoundation/hardhat-ethers"
-      );
-      return hardhatEthersPlugin;
-    },
-  ],
+  dependencies: () => [import("@nomicfoundation/hardhat-ethers")],
 };
 
 export default hardhatChaiMatchersPlugin;

package/src/internal/add-chai-matchers.ts

@@ -11,7 +11,8 @@ import { supportHexEqual } from "./matchers/hexEqual.js";
 import { supportProperAddress } from "./matchers/properAddress.js";
 import { supportProperHex } from "./matchers/properHex.js";
 import { supportProperPrivateKey } from "./matchers/properPrivateKey.js";
-import { supportReverted } from "./matchers/reverted/reverted.js";
+import { supportLegacyReverted } from "./matchers/reverted/legacyReverted.js";
+import { supportRevert } from "./matchers/reverted/revert.js";
 import { supportRevertedWith } from "./matchers/reverted/revertedWith.js";
 import { supportRevertedWithCustomError } from "./matchers/reverted/revertedWithCustomError.js";
 import { supportRevertedWithPanic } from "./matchers/reverted/revertedWithPanic.js";
@@ -37,7 +38,8 @@ function hardhatChaiMatchers(
   supportChangeEtherBalance(chai.Assertion, chaiUtils);
   supportChangeEtherBalances(chai.Assertion, chaiUtils);
   supportChangeTokenBalance(chai.Assertion, chaiUtils);
-  supportReverted(chai.Assertion, chaiUtils);
+  supportLegacyReverted(chai.Assertion, chaiUtils);
+  supportRevert(chai.Assertion, chaiUtils);
   supportRevertedWith(chai.Assertion, chaiUtils);
   supportRevertedWithCustomError(chai.Assertion, chaiUtils);
   supportRevertedWithPanic(chai.Assertion, chaiUtils);

package/src/internal/constants.ts

@@ -6,7 +6,8 @@ export const CHANGE_ETHER_BALANCES_MATCHER = "changeEtherBalances";
 export const CHANGE_TOKEN_BALANCE_MATCHER = "changeTokenBalance";
 export const CHANGE_TOKEN_BALANCES_MATCHER = "changeTokenBalances";
 export const EMIT_MATCHER = "emit";
-export const REVERTED_MATCHER = "reverted";
+export const LEGACY_REVERTED_MATCHER = "reverted";
+export const REVERT_MATCHER = "revert";
 export const REVERTED_WITH_MATCHER = "revertedWith";
 export const REVERTED_WITH_CUSTOM_ERROR_MATCHER = "revertedWithCustomError";
 export const REVERTED_WITH_PANIC_MATCHER = "revertedWithPanic";

package/src/internal/matchers/big-number.ts

@@ -121,7 +121,7 @@ function overwriteBigNumberFunction(
         return lhs <= rhs;
       } else {
         throw new HardhatError(
-          HardhatError.ERRORS.CHAI_MATCHERS.UNKNOWN_COMPARISON_OPERATION,
+          HardhatError.ERRORS.CHAI_MATCHERS.GENERAL.UNKNOWN_COMPARISON_OPERATION,
           {
             method,
           },
@@ -272,7 +272,7 @@ function deepEqualComparator(a: any, b: any): boolean | null {
     const normalizedA = toBigInt(a);
     const normalizedB = toBigInt(b);
     return normalizedA === normalizedB;
-  } catch (e) {
+  } catch (_error) {
     // use default comparator
     return null;
   }

package/src/internal/matchers/changeEtherBalance.ts

@@ -1,11 +1,10 @@
 import type { BalanceChangeOptions } from "../utils/balance.js";
+import type { HardhatEthers } from "@nomicfoundation/hardhat-ethers/types";
 import type { Addressable } from "ethers/address";
 import type { TransactionResponse } from "ethers/providers";
 import type { BigNumberish } from "ethers/utils";
-import type { EthereumProvider } from "hardhat/types/providers";
 
 import { assertHardhatInvariant } from "@nomicfoundation/hardhat-errors";
-import { numberToHexString } from "@nomicfoundation/hardhat-utils/hex";
 import { isObject } from "@nomicfoundation/hardhat-utils/lang";
 import { toBigInt } from "ethers/utils";
 
@@ -26,7 +25,7 @@ export function supportChangeEtherBalance(
     CHANGE_ETHER_BALANCE_MATCHER,
     function (
       this: any,
-      provider: EthereumProvider,
+      ethers: HardhatEthers,
       account: Addressable | string,
       balanceChange: BigNumberish | ((change: bigint) => boolean),
       options?: BalanceChangeOptions,
@@ -64,7 +63,7 @@ export function supportChangeEtherBalance(
       };
 
       const derivedPromise = Promise.all([
-        getBalanceChange(provider, subject, account, options),
+        getBalanceChange(ethers, subject, account, options),
         getAddressOf(account),
       ]).then(checkBalanceChange);
       this.then = derivedPromise.then.bind(derivedPromise);
@@ -76,7 +75,7 @@ export function supportChangeEtherBalance(
 }
 
 export async function getBalanceChange(
-  provider: EthereumProvider,
+  ethers: HardhatEthers,
   transaction:
     | TransactionResponse
     | Promise<TransactionResponse>
@@ -96,10 +95,9 @@ export async function getBalanceChange(
   assertIsNotNull(txReceipt, "txReceipt");
   const txBlockNumber = txReceipt.blockNumber;
 
-  const block = await provider.request({
-    method: "eth_getBlockByHash",
-    params: [txReceipt.blockHash, false],
-  });
+  const block = await ethers.provider.getBlock(txReceipt.blockHash, false);
+
+  assertHardhatInvariant(block !== null, "The block doesn't exist");
 
   assertHardhatInvariant(
     isObject(block) &&
@@ -110,15 +108,15 @@ export async function getBalanceChange(
 
   const address = await getAddressOf(account);
 
-  const balanceAfterHex = await provider.request({
-    method: "eth_getBalance",
-    params: [address, numberToHexString(txBlockNumber)],
-  });
+  const balanceAfterHex = await ethers.provider.getBalance(
+    address,
+    txBlockNumber,
+  );
 
-  const balanceBeforeHex = await provider.request({
-    method: "eth_getBalance",
-    params: [address, numberToHexString(txBlockNumber - 1)],
-  });
+  const balanceBeforeHex = await ethers.provider.getBalance(
+    address,
+    txBlockNumber - 1,
+  );
 
   assertCanBeConvertedToBigint(balanceAfterHex);
   assertCanBeConvertedToBigint(balanceBeforeHex);

package/src/internal/matchers/changeEtherBalances.ts

@@ -1,7 +1,7 @@
 import type { BalanceChangeOptions } from "../utils/balance.js";
+import type { HardhatEthers } from "@nomicfoundation/hardhat-ethers/types";
 import type { Addressable } from "ethers/address";
 import type { TransactionResponse } from "ethers/providers";
-import type { EthereumProvider } from "hardhat/types/providers";
 
 import { HardhatError } from "@nomicfoundation/hardhat-errors";
 import { toBigInt } from "ethers/utils";
@@ -22,7 +22,7 @@ export function supportChangeEtherBalances(
     CHANGE_ETHER_BALANCES_MATCHER,
     function (
       this: any,
-      provider: EthereumProvider,
+      ethers: HardhatEthers,
       accounts: Array<Addressable | string>,
       balanceChanges: bigint[] | ((changes: bigint[]) => boolean),
       options?: BalanceChangeOptions,
@@ -99,7 +99,7 @@ export function supportChangeEtherBalances(
       };
 
       const derivedPromise = Promise.all([
-        getBalanceChanges(provider, subject, accounts, options),
+        getBalanceChanges(ethers, subject, accounts, options),
         getAddresses(accounts),
       ]).then(checkBalanceChanges);
       this.then = derivedPromise.then.bind(derivedPromise);
@@ -121,7 +121,7 @@ function validateInput(
       accounts.length !== balanceChanges.length
     ) {
       throw new HardhatError(
-        HardhatError.ERRORS.CHAI_MATCHERS.ACCOUNTS_NUMBER_DIFFERENT_FROM_BALANCE_CHANGES,
+        HardhatError.ERRORS.CHAI_MATCHERS.GENERAL.ACCOUNTS_NUMBER_DIFFERENT_FROM_BALANCE_CHANGES,
         {
           accounts: accounts.length,
           balanceChanges: balanceChanges.length,
@@ -137,7 +137,7 @@ function validateInput(
 }
 
 export async function getBalanceChanges(
-  provider: EthereumProvider,
+  ethers: HardhatEthers,
   transaction: TransactionResponse | Promise<TransactionResponse>,
   accounts: Array<Addressable | string>,
   options?: BalanceChangeOptions,
@@ -148,12 +148,8 @@ export async function getBalanceChanges(
   assertIsNotNull(txReceipt, "txReceipt");
   const txBlockNumber = txReceipt.blockNumber;
 
-  const balancesAfter = await getBalances(provider, accounts, txBlockNumber);
-  const balancesBefore = await getBalances(
-    provider,
-    accounts,
-    txBlockNumber - 1,
-  );
+  const balancesAfter = await getBalances(ethers, accounts, txBlockNumber);
+  const balancesBefore = await getBalances(ethers, accounts, txBlockNumber - 1);
 
   const txFees = await getTxFees(accounts, txResponse, options);
 

package/src/internal/matchers/changeTokenBalance.ts

@@ -1,3 +1,4 @@
+import type { HardhatEthers } from "@nomicfoundation/hardhat-ethers/types";
 import type {
   Addressable,
   BaseContract,
@@ -6,7 +7,6 @@ import type {
   ContractTransactionResponse,
 } from "ethers";
 import type { TransactionResponse } from "ethers/providers";
-import type { EthereumProvider } from "hardhat/types/providers";
 
 import {
   assertHardhatInvariant,
@@ -43,7 +43,7 @@ export function supportChangeTokenBalance(
     CHANGE_TOKEN_BALANCE_MATCHER,
     function (
       this: any,
-      provider: EthereumProvider,
+      ethers: HardhatEthers,
       token: Token,
       account: Addressable | string,
       balanceChange: bigint | ((change: bigint) => boolean),
@@ -87,7 +87,7 @@ export function supportChangeTokenBalance(
       };
 
       const derivedPromise = Promise.all([
-        getBalanceChange(provider, subject, token, account),
+        getBalanceChange(ethers, subject, token, account),
         getAddressOf(account),
         getTokenDescription(token),
       ]).then(checkBalanceChange);
@@ -103,7 +103,7 @@ export function supportChangeTokenBalance(
     CHANGE_TOKEN_BALANCES_MATCHER,
     function (
       this: any,
-      provider: EthereumProvider,
+      ethers: HardhatEthers,
       token: Token,
       accounts: Array<Addressable | string>,
       balanceChanges: bigint[] | ((changes: bigint[]) => boolean),
@@ -126,7 +126,7 @@ export function supportChangeTokenBalance(
 
       const balanceChangesPromise = Promise.all(
         accounts.map((account) =>
-          getBalanceChange(provider, subject, token, account),
+          getBalanceChange(ethers, subject, token, account),
         ),
       );
       const addressesPromise = Promise.all(accounts.map(getAddressOf));
@@ -191,7 +191,7 @@ function validateInput(
       accounts.length !== balanceChanges.length
     ) {
       throw new HardhatError(
-        HardhatError.ERRORS.CHAI_MATCHERS.ACCOUNTS_NUMBER_DIFFERENT_FROM_BALANCE_CHANGES,
+        HardhatError.ERRORS.CHAI_MATCHERS.GENERAL.ACCOUNTS_NUMBER_DIFFERENT_FROM_BALANCE_CHANGES,
         {
           accounts: accounts.length,
           balanceChanges: balanceChanges.length,
@@ -209,7 +209,7 @@ function validateInput(
 function checkToken(token: unknown, method: string) {
   if (!isObject(token) || token === null || !("interface" in token)) {
     throw new HardhatError(
-      HardhatError.ERRORS.CHAI_MATCHERS.FIRST_ARGUMENT_MUST_BE_A_CONTRACT_INSTANCE,
+      HardhatError.ERRORS.CHAI_MATCHERS.GENERAL.FIRST_ARGUMENT_MUST_BE_A_CONTRACT_INSTANCE,
       {
         method,
       },
@@ -223,13 +223,13 @@ function checkToken(token: unknown, method: string) {
     token.interface.getFunction("balanceOf") === null
   ) {
     throw new HardhatError(
-      HardhatError.ERRORS.CHAI_MATCHERS.CONTRACT_IS_NOT_AN_ERC20_TOKEN,
+      HardhatError.ERRORS.CHAI_MATCHERS.GENERAL.CONTRACT_IS_NOT_AN_ERC20_TOKEN,
     );
   }
 }
 
 export async function getBalanceChange(
-  provider: EthereumProvider,
+  ethers: HardhatEthers,
   transaction: TransactionResponse | Promise<TransactionResponse>,
   token: Token,
   account: Addressable | string,
@@ -240,15 +240,12 @@ export async function getBalanceChange(
   assertIsNotNull(txReceipt, "txReceipt");
   const txBlockNumber = txReceipt.blockNumber;
 
-  const block = await provider.request({
-    method: "eth_getBlockByHash",
-    params: [txReceipt.blockHash, false],
-  });
+  const block = await ethers.provider.getBlock(txReceipt.blockHash, false);
+
+  assertHardhatInvariant(block !== null, "The block doesn't exist");
 
   assertHardhatInvariant(
-    isObject(block) &&
-      Array.isArray(block.transactions) &&
-      block.transactions.length === 1,
+    Array.isArray(block.transactions) && block.transactions.length === 1,
     "There should be only 1 transaction in the block",
   );
 
@@ -277,10 +274,10 @@ async function getTokenDescription(token: Token): Promise<string> {
     let tokenDescription = `<token at ${tokenAddress}>`;
     try {
       tokenDescription = await token.symbol();
-    } catch (e) {
+    } catch (_error) {
       try {
         tokenDescription = await token.name();
-      } catch (e2) {}
+      } catch (_error2) {}
     }
 
     tokenDescriptionsCache[tokenAddress] = tokenDescription;

package/src/internal/matchers/emit.ts

@@ -31,7 +31,7 @@ async function waitForPendingTransaction(
 
   if (hash === null) {
     throw new HardhatError(
-      HardhatError.ERRORS.CHAI_MATCHERS.INVALID_TRANSACTION,
+      HardhatError.ERRORS.CHAI_MATCHERS.GENERAL.INVALID_TRANSACTION,
       { transaction: JSON.stringify(tx) },
     );
   }
@@ -90,13 +90,13 @@ export function supportEmit(
         const contractAddress = contract.target;
         if (typeof contractAddress !== "string") {
           throw new HardhatError(
-            HardhatError.ERRORS.CHAI_MATCHERS.CONTRACT_TARGET_MUST_BE_A_STRING,
+            HardhatError.ERRORS.CHAI_MATCHERS.GENERAL.CONTRACT_TARGET_MUST_BE_A_STRING,
           );
         }
 
         if (args.length > 0) {
           throw new HardhatError(
-            HardhatError.ERRORS.CHAI_MATCHERS.EMIT_EXPECTS_TWO_ARGUMENTS,
+            HardhatError.ERRORS.CHAI_MATCHERS.GENERAL.EMIT_EXPECTS_TWO_ARGUMENTS,
           );
         }
 
@@ -125,7 +125,7 @@ export function supportEmit(
 
         if (contract.runner === null || contract.runner.provider === null) {
           throw new HardhatError(
-            HardhatError.ERRORS.CHAI_MATCHERS.CONTRACT_RUNNER_PROVIDER_NOT_NULL,
+            HardhatError.ERRORS.CHAI_MATCHERS.GENERAL.CONTRACT_RUNNER_PROVIDER_NOT_NULL,
           );
         }
 

package/src/internal/matchers/reverted/legacyReverted.ts

@@ -0,0 +1,19 @@
+import { HardhatError } from "@nomicfoundation/hardhat-errors";
+
+import { LEGACY_REVERTED_MATCHER } from "../../constants.js";
+
+export function supportLegacyReverted(
+  Assertion: Chai.AssertionStatic,
+  _chaiUtils: Chai.ChaiUtils,
+): void {
+  Assertion.addProperty(LEGACY_REVERTED_MATCHER, function () {
+    // We handle the promise rejection, if any
+    if (this._obj instanceof Promise) {
+      this._obj.catch(() => {});
+    }
+
+    throw new HardhatError(
+      HardhatError.ERRORS.CHAI_MATCHERS.GENERAL.DEPRECATED_REVERTED_MATCHER,
+    );
+  });
+}

package/src/internal/matchers/reverted/{reverted.ts → revert.ts}

@@ -3,7 +3,7 @@ import type { HardhatEthers } from "@nomicfoundation/hardhat-ethers/types";
 import { HardhatError } from "@nomicfoundation/hardhat-errors";
 import { numberToHexString } from "@nomicfoundation/hardhat-utils/hex";
 
-import { REVERTED_MATCHER } from "../../constants.js";
+import { REVERT_MATCHER } from "../../constants.js";
 import { assertIsNotNull } from "../../utils/asserts.js";
 import { buildAssert } from "../../utils/build-assert.js";
 import { preventAsyncMatcherChaining } from "../../utils/prevent-chaining.js";
@@ -14,24 +14,24 @@ import {
   parseBytes32String,
 } from "./utils.js";
 
-export function supportReverted(
+export function supportRevert(
   Assertion: Chai.AssertionStatic,
   chaiUtils: Chai.ChaiUtils,
 ): void {
   Assertion.addMethod(
-    REVERTED_MATCHER,
+    REVERT_MATCHER,
     function (this: any, ethers: HardhatEthers) {
       // capture negated flag before async code executes; see buildAssert's jsdoc
       const negated = this.__flags.negate;
 
       const subject: unknown = this._obj;
 
-      preventAsyncMatcherChaining(this, REVERTED_MATCHER, chaiUtils);
+      preventAsyncMatcherChaining(this, REVERT_MATCHER, chaiUtils);
 
       // Check if the received value can be linked to a transaction, and then
       // get the receipt of that transaction and check its status.
       //
-      // If the value doesn't correspond to a transaction, then the `reverted`
+      // If the value doesn't correspond to a transaction, then the `revert`
       // assertion is false.
       const onSuccess = async (value: unknown) => {
         const assert = buildAssert(negated, onSuccess);
@@ -41,7 +41,7 @@ export function supportReverted(
 
           if (!isValidTransactionHash(hash)) {
             throw new HardhatError(
-              HardhatError.ERRORS.CHAI_MATCHERS.EXPECTED_VALID_TRANSACTION_HASH,
+              HardhatError.ERRORS.CHAI_MATCHERS.GENERAL.EXPECTED_VALID_TRANSACTION_HASH,
               {
                 hash,
               },
@@ -75,10 +75,10 @@ export function supportReverted(
         } else {
           // If the subject of the assertion is not connected to a transaction
           // (hash, receipt, etc.), then the assertion fails.
-          // Since we use `false` here, this means that `.not.to.be.reverted`
+          // Since we use `false` here, this means that `.not.to.be.revert`
           // assertions will pass instead of always throwing a validation error.
           // This allows users to do things like:
-          //   `expect(c.callStatic.f()).to.not.be.reverted`
+          //   `expect(c.callStatic.f()).to.not.be.revert`
           assert(false, "Expected transaction to be reverted");
         }
       };

package/src/internal/matchers/reverted/revertedWith.ts

@@ -27,7 +27,7 @@ export function supportRevertedWith(
         Promise.resolve(this._obj).catch(() => {});
 
         throw new HardhatError(
-          HardhatError.ERRORS.CHAI_MATCHERS.EXPECT_STRING_OR_REGEX_AS_REVERT_REASON,
+          HardhatError.ERRORS.CHAI_MATCHERS.GENERAL.EXPECT_STRING_OR_REGEX_AS_REVERT_REASON,
         );
       }
 

package/src/internal/matchers/reverted/revertedWithCustomError.ts

@@ -161,14 +161,14 @@ function validateInput(
     if (typeof contract === "string" || contract?.interface === undefined) {
       // discard subject since it could potentially be a rejected promise
       throw new HardhatError(
-        HardhatError.ERRORS.CHAI_MATCHERS.FIRST_ARGUMENT_MUST_BE_A_CONTRACT,
+        HardhatError.ERRORS.CHAI_MATCHERS.GENERAL.FIRST_ARGUMENT_MUST_BE_A_CONTRACT,
       );
     }
 
     // validate custom error name
     if (typeof expectedCustomErrorName !== "string") {
       throw new HardhatError(
-        HardhatError.ERRORS.CHAI_MATCHERS.STRING_EXPECTED_AS_CUSTOM_ERROR_NAME,
+        HardhatError.ERRORS.CHAI_MATCHERS.GENERAL.STRING_EXPECTED_AS_CUSTOM_ERROR_NAME,
       );
     }
 
@@ -178,7 +178,7 @@ function validateInput(
     // check that interface contains the given custom error
     if (expectedCustomError === null) {
       throw new HardhatError(
-        HardhatError.ERRORS.CHAI_MATCHERS.CONTRACT_DOES_NOT_HAVE_CUSTOM_ERROR,
+        HardhatError.ERRORS.CHAI_MATCHERS.GENERAL.CONTRACT_DOES_NOT_HAVE_CUSTOM_ERROR,
         {
           customErrorName: expectedCustomErrorName,
         },
@@ -187,7 +187,7 @@ function validateInput(
 
     if (args.length > 0) {
       throw new HardhatError(
-        HardhatError.ERRORS.CHAI_MATCHERS.REVERT_INVALID_ARGUMENTS_LENGTH,
+        HardhatError.ERRORS.CHAI_MATCHERS.GENERAL.REVERT_INVALID_ARGUMENTS_LENGTH,
       );
     }
 
@@ -215,7 +215,7 @@ export async function revertedWithCustomErrorWithArgs(
 
   if (customErrorAssertionData === undefined) {
     throw new HardhatError(
-      HardhatError.ERRORS.CHAI_MATCHERS.WITH_ARGS_FORBIDDEN,
+      HardhatError.ERRORS.CHAI_MATCHERS.GENERAL.WITH_ARGS_FORBIDDEN,
     );
   }
 

package/src/internal/matchers/reverted/revertedWithPanic.ts

@@ -30,7 +30,7 @@ export function supportRevertedWithPanic(
         Promise.resolve(this._obj).catch(() => {});
 
         throw new HardhatError(
-          HardhatError.ERRORS.CHAI_MATCHERS.PANIC_CODE_EXPECTED,
+          HardhatError.ERRORS.CHAI_MATCHERS.GENERAL.PANIC_CODE_EXPECTED,
           {
             panicCode: expectedCodeArg,
           },

package/src/internal/matchers/reverted/utils.ts

@@ -78,11 +78,14 @@ export function decodeReturnData(returnData: string): DecodedReturnData {
     } catch (e) {
       ensureError(e);
 
-      throw new HardhatError(HardhatError.ERRORS.CHAI_MATCHERS.DECODING_ERROR, {
-        encodedData: encodedReason,
-        type: "string",
-        reason: e.message,
-      });
+      throw new HardhatError(
+        HardhatError.ERRORS.CHAI_MATCHERS.GENERAL.DECODING_ERROR,
+        {
+          encodedData: encodedReason,
+          type: "string",
+          reason: e.message,
+        },
+      );
     }
 
     return {
@@ -97,11 +100,14 @@ export function decodeReturnData(returnData: string): DecodedReturnData {
     } catch (e) {
       ensureError(e);
 
-      throw new HardhatError(HardhatError.ERRORS.CHAI_MATCHERS.DECODING_ERROR, {
-        encodedData: encodedReason,
-        type: "uint256",
-        reason: e.message,
-      });
+      throw new HardhatError(
+        HardhatError.ERRORS.CHAI_MATCHERS.GENERAL.DECODING_ERROR,
+        {
+          encodedData: encodedReason,
+          type: "uint256",
+          reason: e.message,
+        },
+      );
     }
 
     const description = panicErrorCodeToReason(code) ?? "unknown panic code";

package/src/internal/matchers/withArgs.ts

@@ -105,7 +105,7 @@ function validateInput(
   try {
     if (Boolean(this.__flags.negate)) {
       throw new HardhatError(
-        HardhatError.ERRORS.CHAI_MATCHERS.WITH_ARGS_CANNOT_BE_COMBINED_WITH_NOT,
+        HardhatError.ERRORS.CHAI_MATCHERS.GENERAL.WITH_ARGS_CANNOT_BE_COMBINED_WITH_NOT,
       );
     }
 
@@ -116,13 +116,13 @@ function validateInput(
 
     if (!emitCalled && !revertedWithCustomErrorCalled) {
       throw new HardhatError(
-        HardhatError.ERRORS.CHAI_MATCHERS.WITH_ARGS_WRONG_COMBINATION,
+        HardhatError.ERRORS.CHAI_MATCHERS.GENERAL.WITH_ARGS_WRONG_COMBINATION,
       );
     }
 
     if (emitCalled && revertedWithCustomErrorCalled) {
       throw new HardhatError(
-        HardhatError.ERRORS.CHAI_MATCHERS.WITH_ARGS_COMBINED_WITH_INCOMPATIBLE_ASSERTIONS,
+        HardhatError.ERRORS.CHAI_MATCHERS.GENERAL.WITH_ARGS_COMBINED_WITH_INCOMPATIBLE_ASSERTIONS,
       );
     }
 

package/src/internal/utils/account.ts

@@ -16,7 +16,7 @@ export async function getAddressOf(
   }
 
   throw new HardhatError(
-    HardhatError.ERRORS.CHAI_MATCHERS.EXPECTED_STRING_OR_ADDRESSABLE,
+    HardhatError.ERRORS.CHAI_MATCHERS.GENERAL.EXPECTED_STRING_OR_ADDRESSABLE,
     {
       account,
     },

package/src/internal/utils/asserts.ts

@@ -119,7 +119,7 @@ function innerAssertArgEqual(
     if (actualArg.hash !== undefined && actualArg._isIndexed === true) {
       if (assertionType !== "event") {
         throw new HardhatError(
-          HardhatError.ERRORS.CHAI_MATCHERS.INDEXED_EVENT_FORBIDDEN,
+          HardhatError.ERRORS.CHAI_MATCHERS.GENERAL.INDEXED_EVENT_FORBIDDEN,
         );
       }
 

package/src/internal/utils/balance.ts

@@ -1,8 +1,7 @@
+import type { HardhatEthers } from "@nomicfoundation/hardhat-ethers/types";
 import type { Addressable } from "ethers";
-import type { EthereumProvider } from "hardhat/types/providers";
 
 import { toBigInt } from "@nomicfoundation/hardhat-utils/bigint";
-import { numberToHexString } from "@nomicfoundation/hardhat-utils/hex";
 
 import { getAddressOf } from "./account.js";
 import { assertCanBeConvertedToBigint } from "./asserts.js";
@@ -18,19 +17,15 @@ export function getAddresses(
 }
 
 export async function getBalances(
-  provider: EthereumProvider,
+  ethers: HardhatEthers,
   accounts: Array<Addressable | string>,
-  blockNumber?: number,
+  blockNumber: number,
 ): Promise<bigint[]> {
   return Promise.all(
     accounts.map(async (account) => {
       const address = await getAddressOf(account);
 
-      const result = await provider.request({
-        method: "eth_getBalance",
-        params: [address, numberToHexString(blockNumber ?? 0)],
-      });
-
+      const result = await ethers.provider.getBalance(address, blockNumber);
       assertCanBeConvertedToBigint(result);
 
       return toBigInt(result);

package/src/internal/utils/build-assert.ts

@@ -28,7 +28,7 @@ export function buildAssert(negated: boolean, ssfi: Ssfi) {
     if (!negated && !condition) {
       if (messageFalse === undefined) {
         throw new HardhatError(
-          HardhatError.ERRORS.CHAI_MATCHERS.ASSERTION_WITHOUT_ERROR_MESSAGE,
+          HardhatError.ERRORS.CHAI_MATCHERS.GENERAL.ASSERTION_WITHOUT_ERROR_MESSAGE,
         );
       }
 
@@ -41,7 +41,7 @@ export function buildAssert(negated: boolean, ssfi: Ssfi) {
     if (negated && condition) {
       if (messageTrue === undefined) {
         throw new HardhatError(
-          HardhatError.ERRORS.CHAI_MATCHERS.ASSERTION_WITHOUT_ERROR_MESSAGE,
+          HardhatError.ERRORS.CHAI_MATCHERS.GENERAL.ASSERTION_WITHOUT_ERROR_MESSAGE,
         );
       }
 

package/src/internal/utils/prevent-chaining.ts

@@ -24,7 +24,7 @@ export function preventAsyncMatcherChaining(
   }
 
   throw new HardhatError(
-    HardhatError.ERRORS.CHAI_MATCHERS.MATCHER_CANNOT_BE_CHAINED_AFTER,
+    HardhatError.ERRORS.CHAI_MATCHERS.GENERAL.MATCHER_CANNOT_BE_CHAINED_AFTER,
     {
       matcher: matcherName,
       previousMatcher: previousMatcherName,