[Chai-matchers] Add polling mechanism when automine is not available

.changeset/brave-tigers-wave.md

@@ -0,0 +1,5 @@
+---
+"@nomicfoundation/hardhat-ethers": patch
+---
+
+Added `HardhatEthersProvider.waitForTransaction` to provide polling support for `non-automining` networks ([#7952](https://github.com/NomicFoundation/hardhat/issues/7952)).

.changeset/honest-spies-play.md

@@ -0,0 +1,5 @@
+---
+"@nomicfoundation/hardhat-ethers-chai-matchers": patch
+---
+
+Added support to `hardhat-ethers-chai-matchers` for networks that do not support `automine` ([7952](https://github.com/NomicFoundation/hardhat/issues/7952)).

.peer-bumps.json

@@ -6,5 +6,11 @@
     "v-next/hardhat/templates",
     "v-next/config"
   ],
-  "bumps": []
+  "bumps": [
+    {
+      "package": "@nomicfoundation/hardhat-ethers-chai-matchers",
+      "peer": "@nomicfoundation/hardhat-ethers",
+      "reason": "Requires waitForTransaction implementation from hardhat-ethers for non-automining network support (#7952)"
+    }
+  ]
 }

v-next/example-project/test/mocha/mocha-test.ts

@@ -40,3 +40,51 @@ describe("Rocket test", () => {
     expect(await rocket.status()).to.equal("lift-off");
   });
 });
+
+describe("Matchers without automining", () => {
+  it("emit should wait for the tx to be mined", async () => {
+    const { ethers, provider } = await hre.network.connect();
+
+    const Rocket = await ethers.getContractFactory("Rocket");
+    const rocket = await Rocket.deploy("Apollo 11");
+
+    await provider.request({ method: "evm_setAutomine", params: [false] });
+
+    try {
+      const tx = await rocket.launch();
+      const emitPromise = expect(tx).to.emit(rocket, "LaunchWithoutArgs");
+
+      await provider.request({ method: "hardhat_mine", params: [] });
+      await emitPromise;
+    } finally {
+      await provider.request({ method: "evm_setAutomine", params: [true] });
+    }
+  });
+
+  it("revert should wait for the tx to be mined", async () => {
+    const { ethers, provider } = await hre.network.connect();
+
+    const FailingContract = await ethers.getContractFactory("FailingContract");
+    const failing = await FailingContract.deploy();
+
+    await provider.request({ method: "evm_setAutomine", params: [false] });
+
+    try {
+      // Send the tx manually because fail() is pure, which makes ethers
+      // use staticCall instead of sending a real transaction.
+      const [signer] = await ethers.getSigners();
+      const tx = await signer.sendTransaction({
+        to: await failing.getAddress(),
+        data: failing.interface.encodeFunctionData("fail"),
+        gasLimit: 1_000_000,
+      });
+
+      const revertPromise = expect(tx).to.be.revert(ethers);
+
+      await provider.request({ method: "hardhat_mine", params: [] });
+      await revertPromise;
+    } finally {
+      await provider.request({ method: "evm_setAutomine", params: [true] });
+    }
+  });
+});

v-next/hardhat-ethers-chai-matchers/src/internal/matchers/emit.ts

@@ -6,13 +6,16 @@ import type { Transaction } from "ethers/transaction";
 
 import util from "node:util";
 
+import { isHash } from "@nomicfoundation/hardhat-utils/eth";
 import { assert as chaiAssert, AssertionError } from "chai";
 
 import { ASSERTION_ABORTED, EMIT_MATCHER } from "../constants.js";
 import { assertArgsArraysEqual, assertIsNotNull } from "../utils/asserts.js";
 import { buildAssert } from "../utils/build-assert.js";
 import { preventAsyncMatcherChaining } from "../utils/prevent-chaining.js";
 
+import { parseBytes32String } from "./reverted/utils.js";
+
 export const EMIT_CALLED = "emitAssertionCalled";
 
 async function waitForPendingTransaction(
@@ -32,7 +35,20 @@ async function waitForPendingTransaction(
     chaiAssert.fail(`"${JSON.stringify(tx)}" is not a valid transaction`);
   }
 
-  return provider.getTransactionReceipt(hash);
+  if (typeof tx === "string") {
+    if (!isHash(hash)) {
+      chaiAssert.fail(`Expected a valid transaction hash, but got "${hash}"`);
+    }
+
+    // If the input is a raw string that is also a valid bytes32-encoded
+    // string, it might not be a real tx hash. Do a one-shot check to
+    // avoid polling forever.
+    if (isBytes32String(hash)) {
+      return provider.getTransactionReceipt(hash);
+    }
+  }
+
+  return provider.waitForTransaction(hash);
 }
 
 export function supportEmit(
@@ -229,3 +245,12 @@ const tryAssertArgsArraysEqual = (
     } emitted "${eventName}" events`,
   );
 };
+
+function isBytes32String(v: string): boolean {
+  try {
+    parseBytes32String(v);
+    return true;
+  } catch {
+    return false;
+  }
+}

v-next/hardhat-ethers-chai-matchers/src/internal/matchers/reverted/revert.ts

@@ -1,5 +1,6 @@
 import type { HardhatEthers } from "@nomicfoundation/hardhat-ethers/types";
 
+import { isHash } from "@nomicfoundation/hardhat-utils/eth";
 import { numberToHexString } from "@nomicfoundation/hardhat-utils/hex";
 import { assert as chaiAssert } from "chai";
 
@@ -39,22 +40,40 @@ export function supportRevert(
         if (isTransactionResponse(value) || typeof value === "string") {
           const hash = typeof value === "string" ? value : value.hash;
 
-          if (!isValidTransactionHash(hash)) {
+          if (!isHash(hash)) {
             chaiAssert.fail(
               `Expected a valid transaction hash, but got "${hash}"`,
             );
           }
 
-          const receipt = await getTransactionReceipt(ethers, hash);
+          // If the input is a raw string that is also a valid bytes32-encoded
+          // string, it might not be a real tx hash. Do a one-shot check to
+          // avoid polling forever.
+          if (typeof value === "string" && isBytes32String(hash)) {
+            const oneShotReceipt =
+              await ethers.provider.getTransactionReceipt(hash);
+
+            if (oneShotReceipt === null) {
+              assert(
+                false,
+                "Expected transaction to be reverted",
+                "Expected transaction NOT to be reverted",
+              );
 
-          if (receipt === null) {
-            // If the receipt is null, maybe the string is a bytes32 string
-            if (isBytes32String(hash)) {
-              assert(false, "Expected transaction to be reverted");
               return;
             }
+
+            assert(
+              oneShotReceipt.status === 0,
+              "Expected transaction to be reverted",
+              "Expected transaction NOT to be reverted",
+            );
+
+            return;
           }
 
+          const receipt = await waitForTransactionReceipt(ethers, hash);
+
           assertIsNotNull(
             receipt,
             "Transaction's receipt cannot be fetched from the network",
@@ -126,8 +145,8 @@ export function supportRevert(
   );
 }
 
-async function getTransactionReceipt(ethers: HardhatEthers, hash: string) {
-  return ethers.provider.getTransactionReceipt(hash);
+async function waitForTransactionReceipt(ethers: HardhatEthers, hash: string) {
+  return ethers.provider.waitForTransaction(hash);
 }
 
 function isTransactionResponse(x: unknown): x is { hash: string } {
@@ -151,10 +170,6 @@ function isTransactionReceipt(x: unknown): x is { status: number } {
   return false;
 }
 
-function isValidTransactionHash(x: string): boolean {
-  return /0x[0-9a-fA-F]{64}/.test(x);
-}
-
 function isBytes32String(v: string): boolean {
   try {
     parseBytes32String(v);

v-next/hardhat-ethers-chai-matchers/src/internal/matchers/reverted/utils.ts

@@ -79,7 +79,7 @@ export function decodeReturnData(returnData: string): DecodedReturnData {
 
       try {
         chaiAssert.fail(
-          `There was an error decoding "${encodedReason}" as a "string. Reason: ${cause.message}"`,
+          `There was an error decoding "${encodedReason}" as "string". Reason: ${cause.message}`,
         );
       } catch (e) {
         ensureError(e);

v-next/hardhat-ethers-chai-matchers/test/matchers/events.ts

@@ -5,6 +5,7 @@ import type {
   OverrideEventContract,
 } from "../helpers/contracts.js";
 import type { HardhatEthers } from "@nomicfoundation/hardhat-ethers/types";
+import type { EthereumProvider } from "hardhat/types/providers";
 
 import { before, beforeEach, describe, it } from "node:test";
 
@@ -896,6 +897,28 @@ describe(".to.emit (contract events)", { timeout: 60000 }, () => {
       await expect(tx.hash).to.emit(contract, "WithoutArgs");
     });
 
+    it("With an invalid transaction hash string", async () => {
+      await assertRejects(
+        () => expect("0x123").to.emit(contract, "WithoutArgs"),
+        (e) =>
+          e.message.includes(
+            'Expected a valid transaction hash, but got "0x123"',
+          ),
+        "Expected invalid transaction hash error message",
+      );
+    });
+
+    it("With a bytes32-encoded string that is not a real tx hash", async () => {
+      await expect(
+        expect(
+          "0x3230323400000000000000000000000000000000000000000000000000000000",
+        ).to.emit(contract, "WithoutArgs"),
+      ).to.be.eventually.rejectedWith(
+        AssertionError,
+        "Transaction's receipt cannot be fetched from the network",
+      );
+    });
+
     describe("When event is overloaded", () => {
       it("should fail when the event name is ambiguous", async () => {
         await expect(
@@ -919,5 +942,59 @@ describe(".to.emit (contract events)", { timeout: 60000 }, () => {
         );
       });
     });
+
+    describe("When automining is disabled", () => {
+      let provider: EthereumProvider;
+
+      before(async () => {
+        ({ provider } = await initEnvironment("events"));
+      });
+
+      it("should wait for the tx to be mined and detect the event", async () => {
+        await provider.request({
+          method: "evm_setAutomine",
+          params: [false],
+        });
+
+        try {
+          const tx = contract.emitWithoutArgs();
+
+          const emitPromise = expect(tx).to.emit(contract, "WithoutArgs");
+
+          await provider.request({ method: "hardhat_mine", params: [] });
+
+          await emitPromise;
+        } finally {
+          await provider.request({
+            method: "evm_setAutomine",
+            params: [true],
+          });
+        }
+      });
+
+      it("should wait for the tx to be mined and verify event args", async () => {
+        await provider.request({
+          method: "evm_setAutomine",
+          params: [false],
+        });
+
+        try {
+          const tx = contract.emitUint(1);
+
+          const emitPromise = expect(tx)
+            .to.emit(contract, "WithUintArg")
+            .withArgs(1);
+
+          await provider.request({ method: "hardhat_mine", params: [] });
+
+          await emitPromise;
+        } finally {
+          await provider.request({
+            method: "evm_setAutomine",
+            params: [true],
+          });
+        }
+      });
+    });
   }
 });

v-next/hardhat-ethers-chai-matchers/test/matchers/reverted/revert.ts

@@ -470,5 +470,31 @@ describe("INTEGRATION: Revert", { timeout: 60000 }, () => {
         expect.fail("Expected an exception but none was thrown");
       });
     });
+
+    describe("When automining is disabled", () => {
+      it("should wait for the tx to be mined and detect the revert", async () => {
+        await provider.request({
+          method: "evm_setAutomine",
+          params: [false],
+        });
+
+        try {
+          const tx = await matchers.revertsWithoutReason({
+            gasLimit: 1_000_000,
+          });
+
+          const revertPromise = expect(tx).to.be.revert(ethers);
+
+          await provider.request({ method: "hardhat_mine", params: [] });
+
+          await revertPromise;
+        } finally {
+          await provider.request({
+            method: "evm_setAutomine",
+            params: [true],
+          });
+        }
+      });
+    });
   }
 });