feat: contract utils for ERC20TransferAmountEnforcer

Author: hanzel98

packages/delegation-toolkit/src/DelegationFramework/ERC20TransferAmountEnforcer/index.ts

@@ -0,0 +1,3 @@
+import * as read from './read';
+
+export { read };

packages/delegation-toolkit/src/DelegationFramework/ERC20TransferAmountEnforcer/methods/getSpentAmount.ts

@@ -0,0 +1,26 @@
+import { ERC20TransferAmountEnforcer } from '@metamask/delegation-abis';
+import type { Address, Client, Hex } from 'viem';
+import { readContract } from 'viem/actions';
+
+export type ReadGetSpentAmountParameters = {
+  client: Client;
+  contractAddress: Address;
+  delegationManager: Address;
+  delegationHash: Hex;
+};
+
+export const read = async ({
+  client,
+  contractAddress,
+  delegationManager,
+  delegationHash,
+}: ReadGetSpentAmountParameters) => {
+  const amount = await readContract(client, {
+    address: contractAddress,
+    abi: ERC20TransferAmountEnforcer.abi,
+    functionName: 'spentMap',
+    args: [delegationManager, delegationHash],
+  });
+
+  return amount;
+};

packages/delegation-toolkit/src/DelegationFramework/ERC20TransferAmountEnforcer/methods/getTermsInfo.ts

@@ -0,0 +1,27 @@
+import { ERC20TransferAmountEnforcer } from '@metamask/delegation-abis';
+import type { Address, Client, Hex } from 'viem';
+import { readContract } from 'viem/actions';
+
+export type ReadGetTermsInfoParameters = {
+  client: Client;
+  contractAddress: Address;
+  terms: Hex;
+};
+
+export const read = async ({
+  client,
+  contractAddress,
+  terms,
+}: ReadGetTermsInfoParameters) => {
+  const [allowedContract, maxTokens] = await readContract(client, {
+    address: contractAddress,
+    abi: ERC20TransferAmountEnforcer.abi,
+    functionName: 'getTermsInfo',
+    args: [terms],
+  });
+
+  return {
+    allowedContract,
+    maxTokens,
+  };
+};

packages/delegation-toolkit/src/DelegationFramework/ERC20TransferAmountEnforcer/read.ts

@@ -0,0 +1,4 @@
+import { read as getSpentAmount } from './methods/getSpentAmount';
+import { read as getTermsInfo } from './methods/getTermsInfo';
+
+export { getTermsInfo, getSpentAmount };

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

@@ -4,6 +4,7 @@ import * as EIP712 from '../DelegationFramework/EIP712';
 import * as EntryPoint from '../DelegationFramework/EntryPoint';
 import * as ERC20PeriodTransferEnforcer from '../DelegationFramework/ERC20PeriodTransferEnforcer';
 import * as ERC20StreamingEnforcer from '../DelegationFramework/ERC20StreamingEnforcer';
+import * as ERC20TransferAmountEnforcer from '../DelegationFramework/ERC20TransferAmountEnforcer';
 import * as HybridDeleGator from '../DelegationFramework/HybridDeleGator';
 import * as MultiSigDeleGator from '../DelegationFramework/MultiSigDeleGator';
 import * as MultiTokenPeriodEnforcer from '../DelegationFramework/MultiTokenPeriodEnforcer';
@@ -32,9 +33,10 @@ export {
   Pausable,
   SimpleFactory,
   ERC20PeriodTransferEnforcer,
+  ERC20StreamingEnforcer,
+  ERC20TransferAmountEnforcer,
   MultiTokenPeriodEnforcer,
   NativeTokenPeriodTransferEnforcer,
-  ERC20StreamingEnforcer,
   NativeTokenStreamingEnforcer,
 };
 

packages/delegation-toolkit/test/DelegationFramework/ERC20TransferAmountEnforcer/read.test.ts

@@ -0,0 +1,184 @@
+import { createPublicClient, http, type Address, type Hex } from 'viem';
+import { sepolia } from 'viem/chains';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+import * as ERC20TransferAmountEnforcer from '../../../src/DelegationFramework/ERC20TransferAmountEnforcer';
+import { randomAddress, randomBytes } from '../../utils';
+
+// Helper function to generate random bytes32
+const randomBytes32 = (): Hex => randomBytes(32);
+
+// Mock the readContract function
+vi.mock('viem/actions', () => ({
+  readContract: vi.fn(),
+}));
+
+describe('ERC20TransferAmountEnforcer read functions', () => {
+  let client: any;
+  let contractAddress: Address;
+  let delegationManager: Address;
+  let delegationHash: Hex;
+  let terms: Hex;
+
+  beforeEach(() => {
+    client = createPublicClient({
+      chain: sepolia,
+      transport: http(),
+    });
+    contractAddress = randomAddress();
+    delegationManager = randomAddress();
+    delegationHash = randomBytes32();
+    terms =
+      '0x1234567890123456789012345678901234567890000000000000000000000000000000000000000000000000000000000001';
+
+    vi.clearAllMocks();
+  });
+
+  describe('getTermsInfo', () => {
+    it('should call readContract with correct parameters and return terms info', async () => {
+      const mockAllowedContract = randomAddress();
+      const mockMaxTokens = 1000000n;
+
+      const { readContract } = await import('viem/actions');
+      vi.mocked(readContract).mockResolvedValue([
+        mockAllowedContract,
+        mockMaxTokens,
+      ]);
+
+      const result = await ERC20TransferAmountEnforcer.read.getTermsInfo({
+        client,
+        contractAddress,
+        terms,
+      });
+
+      expect(readContract).toHaveBeenCalledWith(client, {
+        address: contractAddress,
+        abi: expect.any(Array),
+        functionName: 'getTermsInfo',
+        args: [terms],
+      });
+
+      expect(result).toEqual({
+        allowedContract: mockAllowedContract,
+        maxTokens: mockMaxTokens,
+      });
+    });
+
+    it('should handle different terms values', async () => {
+      const mockAllowedContract = randomAddress();
+      const mockMaxTokens = 500000n;
+      const differentTerms =
+        '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd000000000000000000000000000000000000000000000000000000000000002';
+
+      const { readContract } = await import('viem/actions');
+      vi.mocked(readContract).mockResolvedValue([
+        mockAllowedContract,
+        mockMaxTokens,
+      ]);
+
+      const result = await ERC20TransferAmountEnforcer.read.getTermsInfo({
+        client,
+        contractAddress,
+        terms: differentTerms,
+      });
+
+      expect(readContract).toHaveBeenCalledWith(client, {
+        address: contractAddress,
+        abi: expect.any(Array),
+        functionName: 'getTermsInfo',
+        args: [differentTerms],
+      });
+
+      expect(result).toEqual({
+        allowedContract: mockAllowedContract,
+        maxTokens: mockMaxTokens,
+      });
+    });
+  });
+
+  describe('getSpentAmount', () => {
+    it('should call readContract with correct parameters and return spent amount', async () => {
+      const mockSpentAmount = 250000n;
+
+      const { readContract } = await import('viem/actions');
+      vi.mocked(readContract).mockResolvedValue(mockSpentAmount);
+
+      const result = await ERC20TransferAmountEnforcer.read.getSpentAmount({
+        client,
+        contractAddress,
+        delegationManager,
+        delegationHash,
+      });
+
+      expect(readContract).toHaveBeenCalledWith(client, {
+        address: contractAddress,
+        abi: expect.any(Array),
+        functionName: 'spentMap',
+        args: [delegationManager, delegationHash],
+      });
+
+      expect(result).toBe(mockSpentAmount);
+    });
+
+    it('should handle zero spent amount', async () => {
+      const mockSpentAmount = 0n;
+
+      const { readContract } = await import('viem/actions');
+      vi.mocked(readContract).mockResolvedValue(mockSpentAmount);
+
+      const result = await ERC20TransferAmountEnforcer.read.getSpentAmount({
+        client,
+        contractAddress,
+        delegationManager,
+        delegationHash,
+      });
+
+      expect(readContract).toHaveBeenCalledWith(client, {
+        address: contractAddress,
+        abi: expect.any(Array),
+        functionName: 'spentMap',
+        args: [delegationManager, delegationHash],
+      });
+
+      expect(result).toBe(mockSpentAmount);
+    });
+
+    it('should handle different delegation parameters', async () => {
+      const differentDelegationManager = randomAddress();
+      const differentDelegationHash = randomBytes32();
+      const mockSpentAmount = 750000n;
+
+      const { readContract } = await import('viem/actions');
+      vi.mocked(readContract).mockResolvedValue(mockSpentAmount);
+
+      const result = await ERC20TransferAmountEnforcer.read.getSpentAmount({
+        client,
+        contractAddress,
+        delegationManager: differentDelegationManager,
+        delegationHash: differentDelegationHash,
+      });
+
+      expect(readContract).toHaveBeenCalledWith(client, {
+        address: contractAddress,
+        abi: expect.any(Array),
+        functionName: 'spentMap',
+        args: [differentDelegationManager, differentDelegationHash],
+      });
+
+      expect(result).toBe(mockSpentAmount);
+    });
+  });
+
+  describe('API structure', () => {
+    it('should export the expected functions', () => {
+      expect(ERC20TransferAmountEnforcer.read.getTermsInfo).toBeDefined();
+      expect(ERC20TransferAmountEnforcer.read.getSpentAmount).toBeDefined();
+      expect(typeof ERC20TransferAmountEnforcer.read.getTermsInfo).toBe(
+        'function',
+      );
+      expect(typeof ERC20TransferAmountEnforcer.read.getSpentAmount).toBe(
+        'function',
+      );
+    });
+  });
+});

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

@@ -80,9 +80,10 @@ describe('Caveat Enforcer Client', () => {
       },
       caveatEnforcers: {
         ERC20PeriodTransferEnforcer: randomAddress(),
+        ERC20StreamingEnforcer: randomAddress(),
+        ERC20TransferAmountEnforcer: randomAddress(),
         MultiTokenPeriodEnforcer: randomAddress(),
         NativeTokenPeriodTransferEnforcer: randomAddress(),
-        ERC20StreamingEnforcer: randomAddress(),
         NativeTokenStreamingEnforcer: randomAddress(),
         // Add other enforcers as needed
       },