Accept more kind of values in revertedWithPanic

fvictorio · fvictorio · commit bf502630dc91 · 2022-05-10T18:10:54.000-03:00
diff --git a/packages/hardhat-chai-matchers/src/reverted/revertedWithPanic.ts b/packages/hardhat-chai-matchers/src/reverted/revertedWithPanic.ts
@@ -1,20 +1,23 @@
+import { BigNumber } from "ethers";
+import { normalizeToBigInt } from "hardhat/common";
 import { panicErrorCodeToReason } from "./panic";
 import { decodeReturnData, getReturnDataFromError } from "./utils";
 
 export function supportRevertedWithPanic(Assertion: Chai.AssertionStatic) {
   Assertion.addMethod(
     "revertedWithPanic",
-    function (this: any, expectedCode: unknown) {
+    function (this: any, expectedCodeArg: any) {
       const ethers = require("ethers");
 
-      // validate expected code
-      if (
-        expectedCode !== undefined &&
-        typeof expectedCode !== "number" &&
-        !ethers.BigNumber.isBigNumber(expectedCode)
-      ) {
+      let expectedCode: BigNumber | undefined;
+      try {
+        if (expectedCodeArg !== undefined) {
+          const normalizedCode = normalizeToBigInt(expectedCodeArg);
+          expectedCode = BigNumber.from(normalizedCode);
+        }
+      } catch {
         throw new TypeError(
-          "Expected a number or BigNumber as the expected panic code"
+          `Expected a number-like value as the expected panic code, but got '${expectedCodeArg}'`
         );
       }
 
diff --git a/packages/hardhat-chai-matchers/src/types.ts b/packages/hardhat-chai-matchers/src/types.ts
@@ -8,7 +8,7 @@ declare namespace Chai {
     reverted: AsyncAssertion;
     revertedWith(reason: string): AsyncAssertion;
     revertedWithoutReasonString(): AsyncAssertion;
-    revertedWithPanic(code?: number): AsyncAssertion;
+    revertedWithPanic(code?: any): AsyncAssertion;
     revertedWithCustomError(
       contract: { interface: any },
       customErrorName: string
diff --git a/packages/hardhat-chai-matchers/test/reverted/revertedWithPanic.ts b/packages/hardhat-chai-matchers/test/reverted/revertedWithPanic.ts
@@ -1,4 +1,5 @@
 import { AssertionError, expect } from "chai";
+import { BigNumber } from "ethers";
 import { ProviderError } from "hardhat/internal/core/providers/errors";
 
 import "../../src";
@@ -239,6 +240,42 @@ describe("INTEGRATION: Reverted with panic", function () {
       });
     });
 
+    describe("accepted panic code values", function () {
+      it("number", async function () {
+        await runSuccessfulAsserts({
+          matchers,
+          method: "succeeds",
+          successfulAssert: (x) => expect(x).not.to.be.revertedWithPanic(1),
+        });
+      });
+
+      it("bigint", async function () {
+        await runSuccessfulAsserts({
+          matchers,
+          method: "succeeds",
+          successfulAssert: (x) =>
+            expect(x).not.to.be.revertedWithPanic(BigInt(1)),
+        });
+      });
+
+      it("string", async function () {
+        await runSuccessfulAsserts({
+          matchers,
+          method: "succeeds",
+          successfulAssert: (x) => expect(x).not.to.be.revertedWithPanic("1"),
+        });
+      });
+
+      it("ethers's BigNumber", async function () {
+        await runSuccessfulAsserts({
+          matchers,
+          method: "succeeds",
+          successfulAssert: (x) =>
+            expect(x).not.to.be.revertedWithPanic(BigNumber.from(1)),
+        });
+      });
+    });
+
     describe("invalid values", function () {
       it("non-errors as subject", async function () {
         await expect(
@@ -249,12 +286,9 @@ describe("INTEGRATION: Reverted with panic", function () {
       it("non-number as expectation", async function () {
         const { hash } = await mineSuccessfulTransaction(this.hre);
 
-        expect(() =>
-          // @ts-expect-error
-          expect(hash).to.be.revertedWithPanic("10")
-        ).to.throw(
+        expect(() => expect(hash).to.be.revertedWithPanic("invalid")).to.throw(
           TypeError,
-          "Expected a number or BigNumber as the expected panic code"
+          "Expected a number-like value as the expected panic code, but got 'invalid'"
         );
       });
 
