Move caveatEnforcerClient into it's own file. Add test for the factory function.

Author: jeffsmale90

packages/delegation-toolkit/src/actions/caveatEnforcerClient.ts

@@ -0,0 +1,28 @@
+import type { PublicClient } from 'viem';
+
+import type { DeleGatorEnvironment } from '../types';
+import { caveatEnforcerActions } from './getCaveatAvailableAmount';
+
+/**
+ * Type for client extended with caveat enforcer actions.
+ */
+export type CaveatEnforcerClient = PublicClient &
+  ReturnType<ReturnType<typeof caveatEnforcerActions>>;
+
+/**
+ * Create a viem client extended with caveat enforcer actions.
+ *
+ * @param params - The parameters object.
+ * @param params.client - The viem public client.
+ * @param params.environment - The delegator environment.
+ * @returns The extended client with caveat enforcer actions.
+ */
+export function createCaveatEnforcerClient({
+  client,
+  environment,
+}: {
+  client: PublicClient;
+  environment: DeleGatorEnvironment;
+}): CaveatEnforcerClient {
+  return client.extend(caveatEnforcerActions({ environment }));
+}

packages/delegation-toolkit/src/actions/getCaveatAvailableAmount.ts

@@ -380,27 +380,3 @@ export const caveatEnforcerActions =
       );
     },
   });
-
-/**
- * Type for client extended with caveat enforcer actions.
- */
-export type CaveatEnforcerClient = PublicClient &
-  ReturnType<ReturnType<typeof caveatEnforcerActions>>;
-
-/**
- * Create a viem client extended with caveat enforcer actions.
- *
- * @param params - The parameters object.
- * @param params.client - The viem public client.
- * @param params.environment - The delegator environment.
- * @returns The extended client with caveat enforcer actions.
- */
-export function createCaveatEnforcerClient({
-  client,
-  environment,
-}: {
-  client: PublicClient;
-  environment: DeleGatorEnvironment;
-}): CaveatEnforcerClient {
-  return client.extend(caveatEnforcerActions({ environment }));
-}

packages/delegation-toolkit/src/actions/index.ts

@@ -17,7 +17,6 @@ export {
   // Result types
   type PeriodTransferResult,
   type StreamingResult,
-
 } from './getCaveatAvailableAmount';
 
 export { isValid7702Implementation } from './isValid7702Implementation';

packages/delegation-toolkit/src/index.ts

@@ -62,8 +62,7 @@ export * as contracts from './contracts';
 
 export * as actions from './actions';
 
-// Export the caveat enforcer client
 export {
   createCaveatEnforcerClient,
   type CaveatEnforcerClient,
-} from './actions/getCaveatAvailableAmount';
+} from './actions/caveatEnforcerClient';

packages/delegation-toolkit/test/actions/caveatEnforcerClient.test.ts

@@ -0,0 +1,67 @@
+import { PublicClient } from 'viem';
+import { createCaveatEnforcerClient } from '../../src/actions/caveatEnforcerClient';
+import { describe, expect, it, Mocked, vi } from 'vitest';
+import { Delegation, DeleGatorEnvironment } from '../../src/types';
+import { getDelegationHashOffchain } from '../../src/utils';
+import { randomAddress } from '../utils';
+
+vi.mock(
+  '../../src/actions/getCaveatAvailableAmount',
+  async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+      ...(actual as any),
+      caveatEnforcerActions: vi.fn().mockReturnValue(() => ({})),
+    };
+  },
+);
+
+describe('caveatEnforcerClient', () => {
+  const setup = () => {
+    const client: Mocked<PublicClient> = {
+      extend: vi.fn().mockImplementation(() => ({})),
+    } as unknown as Mocked<PublicClient>;
+
+    const environment: DeleGatorEnvironment = {
+      DelegationManager: randomAddress(),
+      EntryPoint: randomAddress(),
+      SimpleFactory: randomAddress(),
+      implementations: {},
+      caveatEnforcers: {},
+    };
+
+    const delegation: Delegation = {
+      delegate: randomAddress(),
+      delegator: randomAddress(),
+      caveats: [],
+      authority: '0x0000000000000000000000000000000000000000',
+      salt: '0x0000000000000000000000000000000000000000',
+      signature: '0x0000000000000000000000000000000000000000',
+    };
+
+    const delegationHash = getDelegationHashOffchain(delegation);
+
+    return { client, environment, delegation, delegationHash };
+  };
+
+  describe('createCaveatEnforcerClient', () => {
+    it('creates a caveat enforcer client', async () => {
+      const { client, environment } = setup();
+
+      const caveatEnforcerClient = createCaveatEnforcerClient({
+        client,
+        environment,
+      });
+
+      expect(caveatEnforcerClient).toBeDefined();
+      // this is an anonymous function
+      expect(client.extend).toHaveBeenCalledWith(expect.any(Function));
+
+      const { caveatEnforcerActions: mockCaveatEnforcerActions } = await import(
+        '../../src/actions/getCaveatAvailableAmount'
+      );
+
+      expect(mockCaveatEnforcerActions).toHaveBeenCalledWith({ environment });
+    });
+  });
+});