Merge pull request #7064 from NomicFoundation/add-predicates-to-viem-assertions

Support predicates on viem-assertions

Author: antico5

.changeset/lovely-dodos-tell.md

@@ -0,0 +1,5 @@
+---
+"@nomicfoundation/hardhat-viem-assertions": patch
+---
+
+Support predicates on viem-assertions ([#7038](https://github.com/NomicFoundation/hardhat/issues/7038))

v-next/hardhat-viem-assertions/package.json

@@ -14,7 +14,8 @@
   "types": "dist/src/index.d.ts",
   "exports": {
     ".": "./dist/src/index.js",
-    "./types": "./dist/src/types.js"
+    "./types": "./dist/src/types.js",
+    "./predicates": "./dist/src/predicates.js"
   },
   "keywords": [
     "ethereum",

v-next/hardhat-viem-assertions/src/internal/assertions/emit/emit-with-args.ts

@@ -14,7 +14,9 @@ import type {
 import assert from "node:assert/strict";
 
 import { assertHardhatInvariant } from "@nomicfoundation/hardhat-errors";
-import { deepEqual } from "@nomicfoundation/hardhat-utils/lang";
+
+import { stringifyArgs } from "../../helpers.js";
+import { isArgumentMatch } from "../../predicates.js";
 
 import { handleEmit } from "./core.js";
 
@@ -51,7 +53,7 @@ export async function emitWithArgs<
   const parsedLogs = await handleEmit(viem, contractFn, contract, eventName);
 
   for (const { args: logArgs } of parsedLogs) {
-    let emittedArgs: unknown[] = [];
+    let emittedArgs: any[] = [];
 
     if (logArgs === undefined) {
       if (expectedArgs.length === 0) {
@@ -80,17 +82,36 @@ export async function emitWithArgs<
       }
     }
 
-    if ((await deepEqual(emittedArgs, expectedArgs)) === true) {
+    if (await isArgumentMatch(emittedArgs, expectedArgs)) {
       return;
     }
 
     if (parsedLogs.length === 1) {
       // Provide additional error details only if a single event was emitted
-      assert.deepEqual(
-        emittedArgs,
-        expectedArgs,
-        "The event arguments do not match the expected ones.",
-      );
+
+      if (expectedArgs.some((arg) => typeof arg === "function")) {
+        // If there are predicate matchers, we can't use the built-in deepEqual with diff
+        const displayExpectedArgs = expectedArgs.map((expectedArg) => {
+          if (typeof expectedArg === "function") {
+            const hasName =
+              expectedArg.name !== undefined && expectedArg.name !== "";
+            return `<${hasName ? expectedArg.name : "predicate"}>`;
+          } else {
+            return expectedArg;
+          }
+        });
+
+        assert.fail(
+          `The event arguments do not match the expected ones:\nExpected: ${stringifyArgs(displayExpectedArgs)}\nEmitted: ${stringifyArgs(emittedArgs)}`,
+        );
+      } else {
+        // Otherwise, we can use it
+        assert.deepEqual(
+          emittedArgs,
+          expectedArgs,
+          "The event arguments do not match the expected ones.",
+        );
+      }
     }
   }
 

v-next/hardhat-viem-assertions/src/internal/assertions/revert/revert-with-custom-error-with-args.ts

@@ -6,6 +6,9 @@ import type { ReadContractReturnType, WriteContractReturnType } from "viem";
 
 import assert from "node:assert/strict";
 
+import { stringifyArgs } from "../../helpers.js";
+import { isArgumentMatch } from "../../predicates.js";
+
 import { handleRevertWithCustomError } from "./handle-revert-with-custom-error.js";
 
 export async function revertWithCustomErrorWithArgs<
@@ -14,17 +17,34 @@ export async function revertWithCustomErrorWithArgs<
   contractFn: Promise<ReadContractReturnType | WriteContractReturnType>,
   contract: ContractReturnType<ContractName>,
   customErrorName: string,
-  args: any[],
+  expectedArgs: any[],
 ): Promise<void> {
   const errorArgs = await handleRevertWithCustomError(
     contractFn,
     contract,
     customErrorName,
   );
 
-  assert.deepEqual(
-    errorArgs,
-    args,
-    `The function was expected to revert with arguments "${args.join(", ")}", but it reverted with arguments "${errorArgs.join(", ")}".`,
-  );
+  if (await isArgumentMatch(errorArgs, expectedArgs)) {
+    return;
+  }
+
+  // No match, then show error
+  if (expectedArgs.some((arg) => typeof arg === "function")) {
+    // If there are predicate matchers, we can't use the built-in deepEqual with diff
+    const displayExpectedArgs = expectedArgs.map((expectedArg) =>
+      typeof expectedArg === "function" ? "<predicate>" : expectedArg,
+    );
+
+    assert.fail(
+      `The error arguments do not match the expected ones:\nExpected: ${stringifyArgs(displayExpectedArgs)}\nRaised: ${stringifyArgs(errorArgs)}`,
+    );
+  } else {
+    // Otherwise, we can use it
+    assert.deepEqual(
+      errorArgs,
+      expectedArgs,
+      `The function was expected to revert with arguments "${expectedArgs.join(", ")}", but it reverted with arguments "${errorArgs.join(", ")}".`,
+    );
+  }
 }

v-next/hardhat-viem-assertions/src/internal/helpers.ts

@@ -0,0 +1,8 @@
+/**
+ * This is a JSON.stringify function with a custom replacer that stringifies bigints as strings.
+ */
+export function stringifyArgs(obj: any): string {
+  return JSON.stringify(obj, (key, value) =>
+    typeof value === "bigint" ? value.toString() : value,
+  );
+}

v-next/hardhat-viem-assertions/src/internal/predicates.ts

@@ -0,0 +1,42 @@
+import assert from "node:assert/strict";
+
+import { ensureError } from "@nomicfoundation/hardhat-utils/error";
+import { deepEqual } from "@nomicfoundation/hardhat-utils/lang";
+
+export function anyValue() {
+  return true;
+}
+
+export async function isArgumentMatch(
+  actualArgs: any[],
+  expectedArgs: any[],
+): Promise<boolean> {
+  assert.ok(
+    actualArgs.length === expectedArgs.length,
+    `${actualArgs.length} arguments emitted, but ${expectedArgs.length} expected`,
+  );
+
+  for (let index = 0; index < actualArgs.length; index++) {
+    const emittedArg = actualArgs[index];
+    const expectedArg = expectedArgs[index];
+
+    if (typeof expectedArg === "function") {
+      try {
+        if (expectedArg(emittedArg) !== true) {
+          return false;
+        }
+      } catch (e) {
+        ensureError(e);
+        assert.fail(
+          `The predicate of index ${index} threw when called: ${e.message}`,
+        );
+      }
+    } else {
+      if (!(await deepEqual(emittedArg, expectedArg))) {
+        return false;
+      }
+    }
+  }
+
+  return true;
+}

v-next/hardhat-viem-assertions/src/predicates.ts

@@ -0,0 +1 @@
+export { anyValue } from "./internal/predicates.js";

v-next/hardhat-viem-assertions/test/fixture-projects/hardhat-project/contracts/Events.sol

@@ -1,6 +1,11 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.24;
 
+struct TestStruct {
+  uint a;
+  uint b;
+}
+
 contract Events {
   event WithoutArgs();
   event WithIntArg(int i);
@@ -11,6 +16,9 @@ contract Events {
   event SameEventDifferentArgs(uint u, uint v);
   event SameEventDifferentArgs(uint u, string s);
   event SameEventDifferentArgs(uint u, uint v, string s);
+  event WithString(string s);
+  event WithArray(uint[] a);
+  event WithStruct(TestStruct a);
 
   constructor() {}
 
@@ -47,4 +55,16 @@ contract Events {
   function emitSameEventDifferentArgs3(uint u, uint v, string memory s) public {
     emit SameEventDifferentArgs(u, v, s);
   }
+
+  function emitString(string memory s) public {
+    emit WithString(s);
+  }
+
+  function emitArray(uint[] memory a) public {
+    emit WithArray(a);
+  }
+
+  function emitStruct(TestStruct memory a) public {
+    emit WithStruct(a);
+  }
 }

v-next/hardhat-viem-assertions/test/fixture-projects/hardhat-project/contracts/Revert.sol

@@ -1,6 +1,11 @@
 // SPDX-License-Identifier: MIT
 pragma solidity ^0.8.24;
 
+struct TestStruct {
+  uint a;
+  uint b;
+}
+
 contract Revert {
   //
   // Custom errors
@@ -9,6 +14,8 @@ contract Revert {
   error CustomErrorWithInt(int);
   error CustomErrorWithUintAndString(uint, string);
   error CustomErrorWithUintAndStringNamedParam(uint u, uint v, string s);
+  error CustomErrorWithArray(uint[]);
+  error CustomErrorWithStruct(TestStruct);
 
   function alwaysRevert() external pure {
     revert("Intentional revert for testing purposes");
@@ -38,6 +45,14 @@ contract Revert {
   ) external pure {
     revert CustomErrorWithUintAndStringNamedParam(u, v, s);
   }
+
+  function revertWithCustomErrorWithArray(uint[] memory a) external pure {
+    revert CustomErrorWithArray(a);
+  }
+
+  function revertWithCustomErrorWithStruct(TestStruct memory a) external pure {
+    revert CustomErrorWithStruct(a);
+  }
 }
 
 contract RevertWithNestedError {