@boostxyz/sdk 0.0.0-alpha.16 → 0.0.0-alpha.18

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@boostxyz/sdk",
-  "version": "0.0.0-alpha.16",
+  "version": "0.0.0-alpha.18",
   "license": "GPL-3.0-or-later",
   "type": "module",
   "files": [
     "dist",
     "src"
   ],
-  "repository": "https://github.com/rabbitholegg/boost-protocol",
+  "repository": "https://github.com/boostxyz/boost-protocol",
   "author": "Boost Team<boost-team@boost.xyz>",
   "access": "public",
   "private": false,
@@ -97,6 +97,12 @@
       "node": "./dist/Deployable/DeployableTarget.js",
       "types": "./dist/Deployable/DeployableTarget.d.ts"
     },
+    "./Deployable/DeployableTargetWithRBAC": {
+      "require": "./dist/Deployable/DeployableTargetWithRBAC.cjs",
+      "import": "./dist/Deployable/DeployableTargetWithRBAC.js",
+      "node": "./dist/Deployable/DeployableTargetWithRBAC.js",
+      "types": "./dist/Deployable/DeployableTargetWithRBAC.d.ts"
+    },
     "./Deployable/Contract": {
       "require": "./dist/Deployable/Contract.cjs",
       "import": "./dist/Deployable/Contract.js",
@@ -189,11 +195,12 @@
     }
   },
   "dependencies": {
-    "@boostxyz/signatures": "0.0.0-alpha.5"
+    "ts-pattern": "5.4.0",
+    "@boostxyz/signatures": "0.0.0-alpha.6"
   },
   "optionalDependencies": {
-    "@boostxyz/evm": "0.0.0-alpha.4",
-    "@boostxyz/signatures": "0.0.0-alpha.5"
+    "@boostxyz/evm": "0.0.0-alpha.6",
+    "@boostxyz/signatures": "0.0.0-alpha.6"
   },
   "peerDependencies": {
     "@wagmi/core": "2.x",

package/src/Actions/ContractAction.ts

@@ -17,7 +17,6 @@ import {
   encodeAbiParameters,
   parseAbiParameters,
 } from 'viem';
-import {} from '../../dist/deployments.json';
 import type {
   DeployableOptions,
   GenericDeployableParams,
@@ -117,7 +116,7 @@ export class ContractAction<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof contractActionAbi, 'chainId'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<bigint>}
    */
   public async chainId(
@@ -136,7 +135,7 @@ export class ContractAction<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof contractActionAbi, 'target'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<`0x${string}`>}
    */
   public async target(params?: ReadParams<typeof contractActionAbi, 'target'>) {
@@ -154,7 +153,7 @@ export class ContractAction<
    * @example `function mint(address to, uint256 amount)`
    * @public
    * @async
-   * @param {?ReadParams<typeof contractActionAbi, 'selector'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<`0x${string}`>}
    */
   public async selector(
@@ -173,7 +172,7 @@ export class ContractAction<
    *
    * @public
    * @async
-   * @param {?ReadParams<typeof contractActionAbi, 'value'>} [params]
+   * @param {?ReadParams} [params]
    * @returns {Promise<bigint>}
    */
   public async value(params?: ReadParams<typeof contractActionAbi, 'value'>) {
@@ -191,7 +190,7 @@ export class ContractAction<
    * @public
    * @async
    * @param {Hex} data
-   * @param {?WriteParams<typeof contractActionAbi, 'execute'>} [params]
+   * @param {?WriteParams} [params]
    * @returns {Promise<readonly [boolean, `0x${string}`]>}
    */
   public async execute(
@@ -207,8 +206,8 @@ export class ContractAction<
    * @public
    * @async
    * @param {Hex} data
-   * @param {?WriteParams<typeof contractActionAbi, 'execute'>} [params]
-   * @returns {unknown}
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: readonly [boolean, `0x${string}`]; }>}
    */
   public async executeRaw(
     data: Hex,
@@ -234,8 +233,8 @@ export class ContractAction<
    * @public
    * @async
    * @param {Hex} calldata
-   * @param {?ReadParams<typeof contractActionAbi, 'prepare'>} [params]
-   * @returns {unknown}
+   * @param {?ReadParams} [params]
+   * @returns {Promise<`0x${string}`>}
    */
   public async prepare(
     calldata: Hex,

package/src/Actions/ERC721MintAction.ts

@@ -15,7 +15,6 @@ import {
   encodeAbiParameters,
   toHex,
 } from 'viem';
-import {} from '../../dist/deployments.json';
 import type {
   DeployableOptions,
   GenericDeployableParams,
@@ -97,8 +96,8 @@ export class ERC721MintAction extends ContractAction<
    * @public
    * @async
    * @param {bigint} token
-   * @param {?ReadParams<typeof erc721MintActionAbi, 'validated'>} [params]
-   * @returns {unknown}
+   * @param {?ReadParams} [params]
+   * @returns {Promise<boolean>}
    */
   public async validated(
     token: bigint,
@@ -119,8 +118,8 @@ export class ERC721MintAction extends ContractAction<
    * @public
    * @async
    * @param {Hex} data
-   * @param {?WriteParams<typeof erc721MintActionAbi, 'execute'>} [params]
-   * @returns {unknown}
+   * @param {?WriteParams} [params]
+   * @returns {Promise<readonly [boolean, `0x${string}`]>}
    */
   public override async execute(
     data: Hex,
@@ -135,8 +134,8 @@ export class ERC721MintAction extends ContractAction<
    * @public
    * @async
    * @param {Hex} data
-   * @param {?WriteParams<typeof erc721MintActionAbi, 'execute'>} [params]
-   * @returns {unknown}
+   * @param {?WriteParams} [params]
+   * @returns {Promise<{ hash: `0x${string}`; result: readonly [boolean, `0x${string}`]; }>}
    */
   public override async executeRaw(
     data: Hex,
@@ -162,8 +161,8 @@ export class ERC721MintAction extends ContractAction<
    * @public
    * @async
    * @param {Hex} data
-   * @param {?ReadParams<typeof erc721MintActionAbi, 'prepare'>} [params]
-   * @returns {unknown}
+   * @param {?ReadParams} [params]
+   * @returns {Promise<`0x${string}`>}
    */
   public override async prepare(
     data: Hex,
@@ -185,8 +184,8 @@ export class ERC721MintAction extends ContractAction<
    * @async
    * @param {Address} holder - The holder
    * @param {BigInt} tokenId - The token ID
-   * @param {?WriteParams<typeof erc721MintActionAbi, 'validate'>} [params]
-   * @returns {Promise<{ hash: `0x${string}`; result: boolean; }>} - True if the action has been validated for the user
+   * @param {?WriteParams} [params]
+   * @returns {Promise<boolean>} - True if the action has been validated for the user
    */
   protected async validate(
     holder: Address,
@@ -203,7 +202,7 @@ export class ERC721MintAction extends ContractAction<
    * @async
    * @param {Address} holder - The holder
    * @param {BigInt} tokenId - The token ID
-   * @param {?WriteParams<typeof erc721MintActionAbi, 'validate'>} [params]
+   * @param {?WriteParams} [params]
    * @returns {Promise<{ hash: `0x${string}`; result: boolean; }>} - True if the action has been validated for the user
    */
   protected async validateRaw(
@@ -280,7 +279,7 @@ export function prepareERC721MintActionValidate(
  * @param {Address} param0.target - The target contract address
  * @param {Hex} param0.selector - The selector for the function to be called
  * @param {bigint} param0.value - The native token value to send with the function call
- * @returns {*}
+ * @returns {Hex}
  */
 export function prepareERC721MintActionPayload({
   chainId,

package/src/Actions/EventAction.test.ts

@@ -11,6 +11,7 @@ import {
   pad,
   parseEther,
   toHex,
+  zeroAddress,
 } from 'viem';
 import { beforeAll, beforeEach, describe, expect, test } from 'vitest';
 import type { MockERC20 } from '@boostxyz/test/MockERC20';
@@ -32,16 +33,19 @@ import {
   FilterType,
   PrimitiveType,
   SignatureType,
+  Criteria,
 } from "./EventAction";
 
 let fixtures: Fixtures,
   erc721: MockERC721,
   erc20: MockERC20,
   stringEmitterFixtures: StringEmitterFixtures;
+let chainId: number;
 
 beforeAll(async () => {
   fixtures = await loadFixture(deployFixtures(defaultOptions));
   stringEmitterFixtures = await loadFixture(deployStringEmitterMock);
+  chainId = defaultOptions.config.chains[0].id;
 });
 
 function basicErc721TransferAction(
@@ -55,7 +59,7 @@ function basicErc721TransferAction(
       ] as Hex,
       fieldIndex: 1,
       targetContract: erc721.assertValidAddress(),
-      chainid: defaultOptions.config.chains[0].id,
+      chainid: chainId,
     },
     actionSteps: [
       {
@@ -64,7 +68,7 @@ function basicErc721TransferAction(
         ] as Hex,
         signatureType: SignatureType.EVENT,
         targetContract: erc721.assertValidAddress(),
-        chainid: defaultOptions.config.chains[0].id,
+        chainid: chainId,
         actionParameter: {
           filterType: FilterType.EQUAL,
           fieldType: PrimitiveType.ADDRESS,
@@ -88,14 +92,13 @@ function cloneEventAction(fixtures: Fixtures, erc721: MockERC721) {
 function basicErc721MintFuncAction(
   erc721: MockERC721,
 ): EventActionPayloadSimple {
-  console.log(funcSelectors["mint(address)"] as Hex);
   return {
     actionClaimant: {
       signatureType: SignatureType.FUNC,
       signature: funcSelectors["mint(address)"] as Hex,
       fieldIndex: 0,
       targetContract: erc721.assertValidAddress(),
-      chainid: defaultOptions.config.chains[0].id,
+      chainid: chainId,
     },
     actionSteps: [
       {
@@ -103,7 +106,7 @@ function basicErc721MintFuncAction(
         signatureType: SignatureType.FUNC,
         actionType: 0,
         targetContract: erc721.assertValidAddress(),
-        chainid: defaultOptions.config.chains[0].id,
+        chainid: chainId,
         actionParameter: {
           filterType: FilterType.EQUAL,
           fieldType: PrimitiveType.ADDRESS,
@@ -122,7 +125,7 @@ function basicErc20MintFuncAction(erc20: MockERC20): EventActionPayloadSimple {
       signature: funcSelectors["mint(address to, uint256 amount)"] as Hex,
       fieldIndex: 0,
       targetContract: erc20.assertValidAddress(),
-      chainid: defaultOptions.config.chains[0].id,
+      chainid: chainId,
     },
     actionSteps: [
       {
@@ -130,7 +133,7 @@ function basicErc20MintFuncAction(erc20: MockERC20): EventActionPayloadSimple {
         signatureType: SignatureType.FUNC,
         actionType: 0,
         targetContract: erc20.assertValidAddress(),
-        chainid: defaultOptions.config.chains[0].id,
+        chainid: chainId,
         actionParameter: {
           filterType: FilterType.EQUAL,
           fieldType: PrimitiveType.ADDRESS,
@@ -156,7 +159,7 @@ function indexedStringErc721TransferAction(
       ] as Hex,
       fieldIndex: 1,
       targetContract: erc721.assertValidAddress(),
-      chainid: defaultOptions.config.chains[0].id,
+      chainid: chainId,
     },
     actionSteps: [
       {
@@ -166,7 +169,7 @@ function indexedStringErc721TransferAction(
         signatureType: SignatureType.EVENT,
         actionType: 0,
         targetContract: stringEmitterAddress,
-        chainid: defaultOptions.config.chains[0].id,
+        chainid: chainId,
         actionParameter: {
           filterType,
           fieldType: PrimitiveType.STRING,
@@ -192,7 +195,7 @@ function stringErc721TransferAction(
       ] as Hex,
       fieldIndex: 1,
       targetContract: erc721.assertValidAddress(),
-      chainid: defaultOptions.config.chains[0].id,
+      chainid: chainId,
     },
     actionSteps: [
       {
@@ -200,7 +203,7 @@ function stringErc721TransferAction(
         signatureType: SignatureType.EVENT,
         actionType: 0,
         targetContract: stringEmitterAddress,
-        chainid: defaultOptions.config.chains[0].id,
+        chainid: chainId,
         actionParameter: {
           filterType,
           fieldType: PrimitiveType.STRING,
@@ -248,6 +251,20 @@ function cloneStringEventAction(
   };
 }
 
+function createMockCriteria(
+  filterType: FilterType,
+  fieldType: PrimitiveType,
+  filterData: Hex,
+  fieldIndex: number = 0
+): Criteria {
+  return {
+    filterType,
+    fieldType,
+    filterData,
+    fieldIndex,
+  };
+}
+
 describe("EventAction Event Selector", () => {
   beforeEach(async () => {
     erc721 = await loadFixture(fundErc721(defaultOptions));
@@ -291,7 +308,7 @@ describe("EventAction Event Selector", () => {
       const action = await loadFixture(cloneEventAction(fixtures, erc721));
       const steps = await action.getActionSteps();
       expect(steps.length).toBe(1);
-      const step = steps[0];
+      const step = steps[0]!;
       step.targetContract = step.targetContract.toUpperCase() as Hex;
       step.actionParameter.filterData =
         step.actionParameter.filterData.toUpperCase() as Hex;
@@ -334,7 +351,7 @@ describe("EventAction Event Selector", () => {
       const action = await loadFixture(cloneEventAction(fixtures, erc721));
       const steps = await action.getActionSteps();
       expect(steps.length).toBe(1);
-      const step = steps[0];
+      const step = steps[0]!;
       step.targetContract = step.targetContract.toUpperCase() as Hex;
       step.actionParameter.filterData =
         step.actionParameter.filterData.toUpperCase() as Hex;
@@ -374,20 +391,16 @@ describe("EventAction Event Selector", () => {
       });
     });
 
-    test("with no logs, does not validate", async () => {
-      const action = await loadFixture(cloneEventAction(fixtures, erc721));
-      expect(await action.validateActionSteps()).toBe(false);
-    });
-
     test("with a correct log, validates", async () => {
       const action = await loadFixture(cloneEventAction(fixtures, erc721));
       const recipient = accounts[1].account;
       await erc721.approve(recipient, 1n);
-      await erc721.transferFrom(defaultOptions.account.address, recipient, 1n);
-      expect(await action.validateActionSteps()).toBe(true);
+      const { hash } = await erc721.transferFromRaw(defaultOptions.account.address, recipient, 1n);
+      expect(await action.validateActionSteps({ hash, chainId })).toBe(true);
     });
 
     test("can supply your own logs to validate against", async () => {
+      const hash = "0xff0e6ab0c4961ec14b7b40afec83ed7d7a77582683512a262e641d21f82efea5"
       const logs: EventLogs = [
         {
           eventName: "Transfer",
@@ -415,7 +428,7 @@ describe("EventAction Event Selector", () => {
         },
       ];
       const action = await loadFixture(cloneEventAction(fixtures, erc721));
-      expect(await action.validateActionSteps({ logs })).toBe(true);
+      expect(await action.validateActionSteps({ hash, chainId, logs })).toBe(true);
     });
 
     describe("string event actions", () => {
@@ -432,8 +445,8 @@ describe("EventAction Event Selector", () => {
           ),
         );
 
-        await stringEmitterFixtures.emitIndexedString("Hello world");
-        await expect(() => action.validateActionSteps()).rejects.toThrowError(
+        const hash = await stringEmitterFixtures.emitIndexedString("Hello world");
+        await expect(() => action.validateActionSteps({ hash, chainId })).rejects.toThrowError(
           /Parameter is not transparently stored onchain/,
         );
       });
@@ -449,8 +462,8 @@ describe("EventAction Event Selector", () => {
             ),
           ),
         );
-        await stringEmitterFixtures.emitString("Hello world");
-        expect(await action.validateActionSteps()).toBe(true);
+        const hash = await stringEmitterFixtures.emitString("Hello world");
+        expect(await action.validateActionSteps({ hash, chainId })).toBe(true);
       });
       test("can parse and validate regex for an emitted string event", async () => {
         const action = await loadFixture(
@@ -465,13 +478,134 @@ describe("EventAction Event Selector", () => {
           ),
         );
 
-        await stringEmitterFixtures.emitString("Hello world");
-        expect(await action.validateActionSteps()).toBe(true);
+        const hash = await stringEmitterFixtures.emitString("Hello world");
+        expect(await action.validateActionSteps({ hash, chainId })).toBe(true);
       });
     });
   });
 });
 
+describe("validateFieldAgainstCriteria unit tests", () => {
+  let action: EventAction
+  beforeAll(async () => {
+      action = await loadFixture(cloneEventAction(fixtures, erc721));
+  });
+  const mockAddress = '0x1234567890abcdef1234567890abcdef12345678';
+  const mockInput = { decodedArgs: ['not used'] };
+
+  test('should return true for EQUAL filter type with ADDRESS field type', () => {
+    const mockCriteria = createMockCriteria(FilterType.EQUAL, PrimitiveType.ADDRESS, mockAddress);
+    const result = action.validateFieldAgainstCriteria(mockCriteria, mockAddress, mockInput);
+    expect(result).toBe(true);
+  });
+
+  test('should return true for EQUAL filter type with UINT field type', () => {
+    const mockCriteria = createMockCriteria(FilterType.EQUAL, PrimitiveType.UINT, '0xc8');
+    const result = action.validateFieldAgainstCriteria(mockCriteria, 200n, mockInput);
+    expect(result).toBe(true);
+  });
+  test('should return true for EQUAL filter type with STRING field type when values match', () => {
+    // Decoded value: 'hello'
+    const mockCriteria = createMockCriteria(FilterType.EQUAL, PrimitiveType.STRING, '0x68656c6c6f');
+    const result = action.validateFieldAgainstCriteria(mockCriteria, 'hello', mockInput);
+    expect(result).toBe(true);
+  });
+
+  test('should return false for EQUAL filter type with STRING field type when values do not match', () => {
+    // Decoded value: 'hello'
+    const mockCriteria = createMockCriteria(FilterType.EQUAL, PrimitiveType.STRING, '0x68656c6c6f');
+    const result = action.validateFieldAgainstCriteria(mockCriteria, 'world', mockInput);
+    expect(result).toBe(false);
+  });
+
+  test('should return true for EQUAL filter type with BYTES field type when values match', () => {
+    // Decoded value: '0x68656c6c6f' (hex for 'hello')
+    const mockCriteria = createMockCriteria(FilterType.EQUAL, PrimitiveType.BYTES, '0x68656c6c6f');
+    const result = action.validateFieldAgainstCriteria(mockCriteria, '0x68656c6c6f', mockInput);
+    expect(result).toBe(true);
+  });
+
+  test('should return false for EQUAL filter type with BYTES field type when values do not match', () => {
+    // Decoded value: '0x68656c6c6f' (hex for 'hello')
+    const mockCriteria = createMockCriteria(FilterType.EQUAL, PrimitiveType.BYTES, '0x68656c6c6f');
+    const result = action.validateFieldAgainstCriteria(mockCriteria, '0x776f726c64', mockInput); // hex for 'world'
+    expect(result).toBe(false);
+  });
+
+  test('should return false for NOT_EQUAL filter type with ADDRESS field type', () => {
+    const mockCriteria = createMockCriteria(FilterType.NOT_EQUAL, PrimitiveType.ADDRESS, mockAddress);
+    const result = action.validateFieldAgainstCriteria(mockCriteria, zeroAddress, mockInput);
+    expect(result).toBe(true);
+  });
+
+  test('should return true for NOT_EQUAL filter type with UINT field type', () => {
+    const mockCriteria = createMockCriteria(FilterType.NOT_EQUAL, PrimitiveType.UINT, '0xc9');
+    const result = action.validateFieldAgainstCriteria(mockCriteria, 200n, mockInput);
+    expect(result).toBe(true);
+  });
+
+  test('should throw InvalidNumericalCriteriaError for GREATER_THAN filter type with non-uint field type', () => {
+    const mockCriteria = createMockCriteria(FilterType.GREATER_THAN, PrimitiveType.STRING, '0x100');
+    expect(() => action.validateFieldAgainstCriteria(mockCriteria, '200', mockInput)).toThrow('non-numerical criteria');
+  });
+
+  test('should return true for GREATER_THAN filter type with UINT field type', () => {
+    const mockCriteria = createMockCriteria(FilterType.GREATER_THAN, PrimitiveType.UINT, '0x64');
+    const result = action.validateFieldAgainstCriteria(mockCriteria, 200n, mockInput);
+    expect(result).toBe(true);
+  });
+
+  test('should return true for CONTAINS filter type with STRING field type', () => {
+    // Decoded value: 'hello'
+    const mockCriteria = createMockCriteria(FilterType.CONTAINS, PrimitiveType.STRING, '0x68656c6c6f');
+    const result = action.validateFieldAgainstCriteria(mockCriteria, 'hello world', mockInput);
+    expect(result).toBe(true);
+  });
+
+  test('should return true for CONTAINS filter type with BYTES field type', () => {
+    const mockCriteria = createMockCriteria(FilterType.CONTAINS, PrimitiveType.BYTES, '0xbeef');
+    const result = action.validateFieldAgainstCriteria(mockCriteria, '0xdeadbeef', mockInput);
+    expect(result).toBe(true);
+  });
+
+  test('should throw FieldValueNotComparableError for CONTAINS filter type with non-string/bytes field type', () => {
+    // Decoded value: 123
+    const mockCriteria = createMockCriteria(FilterType.CONTAINS, PrimitiveType.UINT, '0x7b');
+    expect(() => action.validateFieldAgainstCriteria(mockCriteria, 123n, mockInput)).toThrow(/only .* bytes or string/);
+  });
+
+  test('should throw UnrecognizedFilterTypeError for unrecognized filter type', () => {
+    const mockCriteria = createMockCriteria(6 as FilterType, PrimitiveType.STRING, '0x74657374'); // Decoded value: 'test'
+    expect(() => action.validateFieldAgainstCriteria(mockCriteria, 'test', mockInput)).toThrow('Invalid FilterType');
+  });
+
+  test('should return true for LESS_THAN filter type with UINT field type', () => {
+    // Decoded value: 200
+    const mockCriteria = createMockCriteria(FilterType.LESS_THAN, PrimitiveType.UINT, '0xc8');
+    const result = action.validateFieldAgainstCriteria(mockCriteria, 100n, mockInput);
+    expect(result).toBe(true);
+  });
+
+  test('should return false for LESS_THAN filter type with UINT field type when value is greater', () => {
+    // Decoded value: 100
+    const mockCriteria = createMockCriteria(FilterType.LESS_THAN, PrimitiveType.UINT, '0x64');
+    const result = action.validateFieldAgainstCriteria(mockCriteria, 200n, mockInput);
+    expect(result).toBe(false);
+  });
+
+  test('should throw InvalidNumericalCriteriaError for LESS_THAN filter type with non-uint field type', () => {
+    // Decoded value: 100
+    const mockCriteria = createMockCriteria(FilterType.LESS_THAN, PrimitiveType.STRING, '0x64');
+    expect(() => action.validateFieldAgainstCriteria(mockCriteria, '50', mockInput)).toThrow('non-numerical');
+  });
+
+  test('should throw InvalidNumericalCriteriaError for LESS_THAN filter type with ADDRESS field type', () => {
+    const mockCriteria = createMockCriteria(FilterType.LESS_THAN, PrimitiveType.ADDRESS, '0x1234567890abcdef1234567890abcdef12345678');
+    expect(() => action.validateFieldAgainstCriteria(mockCriteria, '0x1234567890abcdef1234567890abcdef12345678', mockInput)).toThrow('non-numerical');
+  });
+
+})
+
 describe("EventAction Func Selector", () => {
   beforeEach(async () => {
     erc721 = await loadFixture(fundErc721(defaultOptions));
@@ -490,42 +624,29 @@ describe("EventAction Func Selector", () => {
   test("validates function action step with correct hash", async () => {
     const action = await loadFixture(cloneFunctionAction(fixtures, erc721));
     const actionSteps = await action.getActionSteps();
+    const actionStep = actionSteps[0]!
     const recipient = accounts[1].account;
     const { hash } = await erc721.mintRaw(recipient, {
       value: parseEther(".1"),
     });
 
     expect(
-      await action.isActionFunctionValid(actionSteps[0], {
-        hash,
-      }),
+      await action.isActionStepValid(actionStep, { hash, chainId })
     ).toBe(true);
   });
 
-  test("throws an error when hash is missing", async () => {
-    const action = await loadFixture(cloneFunctionAction(fixtures, erc721));
-    const actionSteps = await action.getActionSteps();
-    try {
-      await action.isActionFunctionValid(actionSteps[0], {});
-    } catch (e) {
-      expect(e).toBeInstanceOf(Error);
-      expect((e as Error).message).toBe(
-        "Hash is required for function validation",
-      );
-    }
-  });
-
   test("validates function step with EQUAL filter", async () => {
     const action = await loadFixture(cloneFunctionAction(fixtures, erc721));
     const actionSteps = await action.getActionSteps();
-
+    const actionStep = actionSteps[0]!
     const recipient = accounts[1].account;
     const { hash } = await erc721.mintRaw(recipient, {
       value: parseEther(".1"),
     });
 
-    const criteriaMatch = await action.isActionFunctionValid(actionSteps[0], {
+    const criteriaMatch = await action.isActionStepValid(actionStep, {
       hash,
+      chainId,
     });
 
     expect(criteriaMatch).toBe(true);
@@ -534,10 +655,11 @@ describe("EventAction Func Selector", () => {
   test("fails validation with incorrect function signature", async () => {
     const action = await loadFixture(cloneFunctionAction(fixtures, erc721));
     const actionSteps = await action.getActionSteps();
+    const actionStep = actionSteps[0]!;
     const recipient = accounts[1].account;
 
     const invalidStep = {
-      ...actionSteps[0],
+      ...actionStep,
       signature: funcSelectors["mint(address to, uint256 amount)"] as Hex, // Intentional mismatch
     };
 
@@ -546,7 +668,7 @@ describe("EventAction Func Selector", () => {
     });
 
     try {
-      await action.isActionFunctionValid(invalidStep, { hash });
+      await action.isActionStepValid(invalidStep, { hash, chainId });
     } catch (e) {
       expect(e).toBeInstanceOf(Error);
       expect((e as Error).message).toContain(
@@ -558,15 +680,17 @@ describe("EventAction Func Selector", () => {
   test("validates against NOT_EQUAL filter criteria", async () => {
     const action = await loadFixture(cloneFunctionAction(fixtures, erc721));
     const actionSteps = await action.getActionSteps();
-    actionSteps[0].actionParameter.filterType = FilterType.NOT_EQUAL;
+    const actionStep = actionSteps[0]!;
+    actionStep.actionParameter.filterType = FilterType.NOT_EQUAL;
     const recipient = accounts[2].account;
     const { hash } = await erc721.mintRaw(recipient, {
       value: parseEther(".1"),
     });
 
     expect(
-      await action.isActionFunctionValid(actionSteps[0], {
+      await action.isActionStepValid(actionStep, {
         hash,
+        chainId,
       }),
     ).toBe(true);
   });
@@ -574,8 +698,9 @@ describe("EventAction Func Selector", () => {
   test("validates GREATER_THAN criteria for numeric values", async () => {
     const action = await loadFixture(cloneFunctionAction20(fixtures, erc20));
     const actionSteps = await action.getActionSteps();
+    const actionStep = actionSteps[0]!;
 
-    actionSteps[0].actionParameter = {
+    actionStep.actionParameter = {
       filterType: FilterType.GREATER_THAN,
       fieldType: PrimitiveType.UINT,
       fieldIndex: 1,
@@ -587,8 +712,9 @@ describe("EventAction Func Selector", () => {
     const { hash } = await erc20.mintRaw(address, value);
 
     expect(
-      await action.isActionFunctionValid(actionSteps[0], {
+      await action.isActionStepValid(actionStep, {
         hash,
+        chainId,
       }),
     ).toBe(true);
   });
@@ -596,7 +722,8 @@ describe("EventAction Func Selector", () => {
   test("validates LESS_THAN criteria for numeric values", async () => {
     const action = await loadFixture(cloneFunctionAction20(fixtures, erc20));
     const actionSteps = await action.getActionSteps();
-    actionSteps[0].actionParameter = {
+    const actionStep = actionSteps[0]!;
+    actionStep.actionParameter = {
       filterType: FilterType.LESS_THAN,
       fieldType: PrimitiveType.UINT,
       fieldIndex: 1,
@@ -608,8 +735,9 @@ describe("EventAction Func Selector", () => {
     const { hash } = await erc20.mintRaw(address, value);
 
     expect(
-      await action.isActionFunctionValid(actionSteps[0], {
+      await action.isActionStepValid(actionStep, {
         hash,
+        chainId,
       }),
     ).toBe(true);
   });
@@ -624,6 +752,7 @@ describe("EventAction Func Selector", () => {
     expect(
       await action.validateActionSteps({
         hash,
+        chainId,
       }),
     ).toBe(true);
   });