Fix tests

Author: jeffsmale90

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

@@ -5,9 +5,10 @@ import * as ERC20StreamingEnforcer from '../DelegationFramework/ERC20StreamingEn
 import * as MultiTokenPeriodEnforcer from '../DelegationFramework/MultiTokenPeriodEnforcer';
 import * as NativeTokenPeriodTransferEnforcer from '../DelegationFramework/NativeTokenPeriodTransferEnforcer';
 import * as NativeTokenStreamingEnforcer from '../DelegationFramework/NativeTokenStreamingEnforcer';
-import { hashDelegation } from '../delegation';
 import type { DeleGatorEnvironment, Delegation } from '../types';
 
+import { hashDelegation } from '@metamask/delegation-core';
+
 /**
  * Parameters for all caveat enforcer actions.
  */
@@ -48,11 +49,15 @@ function findMatchingCaveat(
   );
 
   if (matchingCaveats.length === 0) {
-    throw new Error(`No caveat found with enforcer matching ${enforcerAddress}`);
+    throw new Error(
+      `No caveat found with enforcer matching ${enforcerAddress}`,
+    );
   }
 
   if (matchingCaveats.length > 1) {
-    throw new Error(`Multiple caveats found with enforcer matching ${enforcerAddress}`);
+    throw new Error(
+      `Multiple caveats found with enforcer matching ${enforcerAddress}`,
+    );
   }
 
   const [{ terms, args }] = matchingCaveats;
@@ -177,7 +182,10 @@ export async function getMultiTokenPeriodEnforcerAvailableAmount(
   );
 
   const delegationHash = hashDelegation(params.delegation);
-  const { terms, args } = findMatchingCaveat(params.delegation, enforcerAddress);
+  const { terms, args } = findMatchingCaveat(
+    params.delegation,
+    enforcerAddress,
+  );
 
   return MultiTokenPeriodEnforcer.read.getAvailableAmount({
     client,

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

@@ -1,22 +1,27 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { createPublicClient, http } from 'viem';
 import { mainnet } from 'viem/chains';
-import { hashDelegation } from '@metamask/delegation-core';
+import { getDelegationHashOffchain } from '../../src/delegation';
+import type { DeleGatorEnvironment, Delegation } from '../../src/types';
 import {
   createCaveatEnforcerClient,
   type CaveatEnforcerClient,
-  type DeleGatorEnvironment,
-  type Delegation,
-} from '../../src';
+} from '../../src/actions/getCaveatAvailableAmount';
 
 // Mock the contract read functions
-vi.mock('../../src/DelegationFramework/MultiTokenPeriodEnforcer/methods/getAvailableAmount', () => ({
-  read: vi.fn(),
-}));
-
-vi.mock('../../src/DelegationFramework/ERC20PeriodTransferEnforcer/methods/getAvailableAmount', () => ({
-  read: vi.fn(),
-}));
+vi.mock(
+  '../../src/DelegationFramework/MultiTokenPeriodEnforcer/methods/getAvailableAmount',
+  () => ({
+    read: vi.fn(),
+  }),
+);
+
+vi.mock(
+  '../../src/DelegationFramework/ERC20PeriodTransferEnforcer/methods/getAvailableAmount',
+  () => ({
+    read: vi.fn(),
+  }),
+);
 
 describe('CaveatEnforcerClient', () => {
   let client: CaveatEnforcerClient;
@@ -36,10 +41,13 @@ describe('CaveatEnforcerClient', () => {
       implementations: {},
       caveatEnforcers: {
         MultiTokenPeriodEnforcer: '0x4567890123456789012345678901234567890123',
-        ERC20PeriodTransferEnforcer: '0x5678901234567890123456789012345678901234',
+        ERC20PeriodTransferEnforcer:
+          '0x5678901234567890123456789012345678901234',
         ERC20StreamingEnforcer: '0x6789012345678901234567890123456789012345',
-        NativeTokenPeriodTransferEnforcer: '0x7890123456789012345678901234567890123456',
-        NativeTokenStreamingEnforcer: '0x8901234567890123456789012345678901234567',
+        NativeTokenPeriodTransferEnforcer:
+          '0x7890123456789012345678901234567890123456',
+        NativeTokenStreamingEnforcer:
+          '0x8901234567890123456789012345678901234567',
       },
     };
 
@@ -51,7 +59,8 @@ describe('CaveatEnforcerClient', () => {
     delegation = {
       delegate: '0x1111111111111111111111111111111111111111',
       delegator: '0x2222222222222222222222222222222222222222',
-      authority: '0x0000000000000000000000000000000000000000000000000000000000000000',
+      authority:
+        '0x0000000000000000000000000000000000000000000000000000000000000000',
       caveats: [
         {
           enforcer: '0x4567890123456789012345678901234567890123',
@@ -72,30 +81,32 @@ describe('CaveatEnforcerClient', () => {
         currentPeriod: 1n,
       };
 
-      const { read } = await import('../../src/DelegationFramework/MultiTokenPeriodEnforcer/methods/getAvailableAmount');
+      const { read } = await import(
+        '../../src/DelegationFramework/MultiTokenPeriodEnforcer/methods/getAvailableAmount'
+      );
       vi.mocked(read).mockResolvedValue(mockResult);
 
       const result = await client.getMultiTokenPeriodEnforcerAvailableAmount({
         delegation,
       });
 
+      const delegationHash = getDelegationHashOffchain(delegation);
+
       expect(result).toEqual(mockResult);
       expect(read).toHaveBeenCalledWith({
         client: expect.any(Object),
         contractAddress: environment.caveatEnforcers.MultiTokenPeriodEnforcer,
-        delegationHash: hashDelegation(delegation),
+        delegationHash,
         delegationManager: environment.DelegationManager,
-        terms: delegation.caveats[0].terms,
-        args: delegation.caveats[0].args,
+        terms: delegation.caveats[0]?.terms,
+        args: delegation.caveats[0]?.args,
       });
     });
-
-
   });
 
   describe('getErc20PeriodTransferEnforcerAvailableAmount with delegation', () => {
     it('should successfully get available amount using client', async () => {
-      const delegationWithErc20Caveat = {
+      const delegationWithErc20Caveat: Delegation = {
         ...delegation,
         caveats: [
           {
@@ -112,33 +123,48 @@ describe('CaveatEnforcerClient', () => {
         currentPeriod: 1n,
       };
 
-      const { read } = await import('../../src/DelegationFramework/ERC20PeriodTransferEnforcer/methods/getAvailableAmount');
+      const { read } = await import(
+        '../../src/DelegationFramework/ERC20PeriodTransferEnforcer/methods/getAvailableAmount'
+      );
       vi.mocked(read).mockResolvedValue(mockResult);
 
-      const result = await client.getErc20PeriodTransferEnforcerAvailableAmount({
-        delegation: delegationWithErc20Caveat,
-      });
+      const result = await client.getErc20PeriodTransferEnforcerAvailableAmount(
+        {
+          delegation: delegationWithErc20Caveat,
+        },
+      );
+
+      const delegationHash = getDelegationHashOffchain(
+        delegationWithErc20Caveat,
+      );
 
       expect(result).toEqual(mockResult);
       expect(read).toHaveBeenCalledWith({
         client: expect.any(Object),
-        contractAddress: environment.caveatEnforcers.ERC20PeriodTransferEnforcer,
-        delegationHash: hashDelegation(delegationWithErc20Caveat),
+        contractAddress:
+          environment.caveatEnforcers.ERC20PeriodTransferEnforcer,
+        delegationHash,
         delegationManager: environment.DelegationManager,
-        terms: delegationWithErc20Caveat.caveats[0].terms,
+        terms: delegationWithErc20Caveat.caveats[0]?.terms,
       });
     });
   });
 
-
-
   describe('Client type', () => {
     it('should have all expected methods', () => {
-      expect(client).toHaveProperty('getMultiTokenPeriodEnforcerAvailableAmount');
-      expect(client).toHaveProperty('getErc20PeriodTransferEnforcerAvailableAmount');
+      expect(client).toHaveProperty(
+        'getMultiTokenPeriodEnforcerAvailableAmount',
+      );
+      expect(client).toHaveProperty(
+        'getErc20PeriodTransferEnforcerAvailableAmount',
+      );
       expect(client).toHaveProperty('getErc20StreamingEnforcerAvailableAmount');
-      expect(client).toHaveProperty('getNativeTokenPeriodTransferEnforcerAvailableAmount');
-      expect(client).toHaveProperty('getNativeTokenStreamingEnforcerAvailableAmount');
+      expect(client).toHaveProperty(
+        'getNativeTokenPeriodTransferEnforcerAvailableAmount',
+      );
+      expect(client).toHaveProperty(
+        'getNativeTokenStreamingEnforcerAvailableAmount',
+      );
     });
 
     it('should still have base client methods', () => {
@@ -147,4 +173,4 @@ describe('CaveatEnforcerClient', () => {
       expect(client).toHaveProperty('readContract');
     });
   });
-});
+});