@steerprotocol/sdk 1.26.0 → 1.28.0

package/src/__tests__/base/FeeManagerClient.test.ts

@@ -0,0 +1,706 @@
+import type { Address, PublicClient, WalletClient } from 'viem';
+import { FeeManagerClient } from '../../base/FeeManagerClient.js';
+
+describe('FeeManagerClient', () => {
+  let client: FeeManagerClient;
+  let publicClient: PublicClient;
+  let walletClient: WalletClient;
+
+  const feeManagerAddress: Address = '0x391cf3047db983caB8dD95B16c4e6C3918d72d23';
+
+  beforeEach(() => {
+    publicClient = {
+      readContract: jest.fn(),
+      simulateContract: jest.fn(),
+    } as unknown as PublicClient;
+
+    walletClient = {
+      getAddresses: jest.fn(),
+      writeContract: jest.fn(),
+    } as unknown as WalletClient;
+
+    client = new FeeManagerClient(feeManagerAddress, publicClient, walletClient);
+  });
+
+  it('should be instantiated correctly', () => {
+    expect(client).toBeDefined();
+    expect(client instanceof FeeManagerClient).toBe(true);
+  });
+
+  it('should have all required methods', () => {
+    expect(client.getFees).toBeDefined();
+    expect(client.getTotalFees).toBeDefined();
+    expect(client.getWithdrawer).toBeDefined();
+    expect(client.validateAdminPermission).toBeDefined();
+    expect(client.validateWithdrawerPermission).toBeDefined();
+    expect(client.setFeeAndWithdrawalPermission).toBeDefined();
+    expect(client.setDefaultFeeAndWithdrawalPermission).toBeDefined();
+    expect(client.setMigratedVaultFeeAndWithdrawalPermission).toBeDefined();
+    expect(client.setTotalFees).toBeDefined();
+    expect(client.changeFeeWithdrawer).toBeDefined();
+    expect(client.withdrawFee).toBeDefined();
+    expect(client.withdrawMultipleFees).toBeDefined();
+    expect(client.withdrawFeesFromMultipleVaults).toBeDefined();
+    expect(client.getAccruedRevenue).toBeDefined();
+    expect(client.getVaultRevenueSummary).toBeDefined();
+    expect(client.setFeeManagerAddress).toBeDefined();
+  });
+
+  it('setFeeManagerAddress should update the internal feeManagerAddress', async () => {
+    const newAddress: Address = '0x00000000000000000000000000000000000000dd';
+    client.setFeeManagerAddress(newAddress);
+
+    (publicClient.readContract as unknown as jest.Mock).mockResolvedValueOnce(500n);
+
+    const vault: Address = '0x0000000000000000000000000000000000000001';
+    await client.getTotalFees(vault);
+
+    expect(publicClient.readContract).toHaveBeenCalledWith(
+      expect.objectContaining({
+        address: newAddress,
+        functionName: 'vaultTotalFees',
+      })
+    );
+  });
+
+  describe('read methods', () => {
+    const vault: Address = '0x0000000000000000000000000000000000000001';
+    const feeIdentifier = 'STEER_FEES';
+
+    it('getFees should call readContract with getFees(vault)', async () => {
+      (publicClient.readContract as unknown as jest.Mock).mockImplementation(
+        async (args: unknown) => {
+          const call = args as { functionName: string };
+          if (call.functionName === 'getFees') {
+            return [{ feeIdentifier: 'STEER_FEES', feeValue: 123n }];
+          }
+          throw new Error('unexpected readContract call');
+        }
+      );
+
+      const res = await client.getFees(vault);
+
+      expect(res.success).toBe(true);
+      expect(res.status).toBe(200);
+      expect(res.data).toEqual([{ feeIdentifier: 'STEER_FEES', feeValue: 123n }]);
+
+      expect(publicClient.readContract).toHaveBeenCalledWith(
+        expect.objectContaining({
+          address: feeManagerAddress,
+          functionName: 'getFees',
+          args: [vault],
+        })
+      );
+    });
+
+    it('getTotalFees should call readContract with vaultTotalFees(vault)', async () => {
+      (publicClient.readContract as unknown as jest.Mock).mockImplementation(
+        async (args: unknown) => {
+          const call = args as { functionName: string };
+          if (call.functionName === 'vaultTotalFees') {
+            return 500n;
+          }
+          throw new Error('unexpected readContract call');
+        }
+      );
+
+      const res = await client.getTotalFees(vault);
+
+      expect(res.success).toBe(true);
+      expect(res.status).toBe(200);
+      expect(res.data).toBe(500n);
+
+      expect(publicClient.readContract).toHaveBeenCalledWith(
+        expect.objectContaining({
+          address: feeManagerAddress,
+          functionName: 'vaultTotalFees',
+          args: [vault],
+        })
+      );
+    });
+
+    it('getWithdrawer should call readContract with withdrawalPermissions(vault, feeIdentifier)', async () => {
+      const withdrawer: Address = '0x00000000000000000000000000000000000000aa';
+      (publicClient.readContract as unknown as jest.Mock).mockImplementation(
+        async (args: unknown) => {
+          const call = args as { functionName: string };
+          if (call.functionName === 'withdrawalPermissions') {
+            return withdrawer;
+          }
+          throw new Error('unexpected readContract call');
+        }
+      );
+
+      const res = await client.getWithdrawer(vault, feeIdentifier);
+
+      expect(res.success).toBe(true);
+      expect(res.status).toBe(200);
+      expect(res.data).toBe(withdrawer);
+
+      expect(publicClient.readContract).toHaveBeenCalledWith(
+        expect.objectContaining({
+          address: feeManagerAddress,
+          functionName: 'withdrawalPermissions',
+          args: [vault, feeIdentifier],
+        })
+      );
+    });
+
+    it('getFees should return error on readContract failure', async () => {
+      (publicClient.readContract as unknown as jest.Mock).mockRejectedValueOnce(new Error('boom'));
+
+      const res = await client.getFees(vault);
+
+      expect(res.success).toBe(false);
+      expect(res.status).toBe(500);
+      expect(res.data).toBeNull();
+      expect(res.error).toBeDefined();
+    });
+
+    it('getAccruedRevenue should call readContract with accruedFees0/1(feeIdentifier)', async () => {
+      (publicClient.readContract as unknown as jest.Mock).mockImplementation(
+        async (args: unknown) => {
+          const call = args as { functionName: string; args: string[] };
+          if (call.functionName === 'accruedFees0' && call.args[0] === feeIdentifier) {
+            return 100n;
+          }
+          if (call.functionName === 'accruedFees1' && call.args[0] === feeIdentifier) {
+            return 200n;
+          }
+          throw new Error('unexpected readContract call');
+        }
+      );
+
+      const res = await client.getAccruedRevenue(vault, feeIdentifier);
+
+      expect(res.success).toBe(true);
+      expect(res.status).toBe(200);
+      expect(res.data).toEqual({ amount0: 100n, amount1: 200n });
+
+      expect(publicClient.readContract).toHaveBeenCalledWith(
+        expect.objectContaining({
+          address: vault,
+          functionName: 'accruedFees0',
+          args: [feeIdentifier],
+        })
+      );
+      expect(publicClient.readContract).toHaveBeenCalledWith(
+        expect.objectContaining({
+          address: vault,
+          functionName: 'accruedFees1',
+          args: [feeIdentifier],
+        })
+      );
+    });
+
+    it('getVaultRevenueSummary should return accrued revenue for all vault fees', async () => {
+      (publicClient.readContract as unknown as jest.Mock).mockImplementation(
+        async (args: unknown) => {
+          const call = args as { address: Address; functionName: string; args: any[] };
+
+          // FeeManager call
+          if (call.address === feeManagerAddress && call.functionName === 'getFees') {
+            return [
+              { feeIdentifier: 'STEER_FEES', feeValue: 100n },
+              { feeIdentifier: 'STRATEGIST_FEES', feeValue: 400n },
+            ];
+          }
+
+          // Vault calls
+          if (call.address === vault) {
+            if (call.functionName === 'accruedFees0') {
+              return call.args[0] === 'STEER_FEES' ? 10n : 40n;
+            }
+            if (call.functionName === 'accruedFees1') {
+              return call.args[0] === 'STEER_FEES' ? 20n : 80n;
+            }
+          }
+
+          throw new Error(`unexpected readContract call: ${call.functionName}`);
+        }
+      );
+
+      const res = await client.getVaultRevenueSummary(vault);
+
+      expect(res.success).toBe(true);
+      expect(res.status).toBe(200);
+      expect(res.data).toEqual([
+        { feeIdentifier: 'STEER_FEES', amount0: 10n, amount1: 20n },
+        { feeIdentifier: 'STRATEGIST_FEES', amount0: 40n, amount1: 80n },
+      ]);
+    });
+  });
+
+  describe('permission validation', () => {
+    const vault: Address = '0x0000000000000000000000000000000000000001';
+    const feeIdentifier = 'STEER_FEES';
+    const account: Address = '0x00000000000000000000000000000000000000aa';
+
+    it('validateAdminPermission should return error when wallet has no accounts', async () => {
+      (walletClient.getAddresses as unknown as jest.Mock).mockResolvedValueOnce([]);
+
+      const res = await client.validateAdminPermission();
+
+      expect(res.success).toBe(false);
+      expect(res.status).toBe(500);
+      expect(res.data).toBeNull();
+      expect(res.error).toBeDefined();
+    });
+
+    it('validateWithdrawerPermission should return error when wallet has no accounts', async () => {
+      (walletClient.getAddresses as unknown as jest.Mock).mockResolvedValueOnce([]);
+
+      const res = await client.validateWithdrawerPermission(vault, feeIdentifier);
+
+      expect(res.success).toBe(false);
+      expect(res.status).toBe(500);
+      expect(res.data).toBeNull();
+      expect(res.error).toBeDefined();
+    });
+
+    it('validateAdminPermission should call readContract owner()', async () => {
+      (walletClient.getAddresses as unknown as jest.Mock).mockResolvedValueOnce([account]);
+      (publicClient.readContract as unknown as jest.Mock).mockImplementation(
+        async (args: unknown) => {
+          const call = args as { functionName: string };
+          if (call.functionName === 'owner') {
+            return account;
+          }
+          throw new Error('unexpected readContract call');
+        }
+      );
+
+      await client.validateAdminPermission();
+
+      expect(publicClient.readContract).toHaveBeenCalledWith(
+        expect.objectContaining({
+          address: feeManagerAddress,
+          functionName: 'owner',
+        })
+      );
+    });
+
+    it('validateWithdrawerPermission should call readContract withdrawalPermissions(vault, feeIdentifier)', async () => {
+      (walletClient.getAddresses as unknown as jest.Mock).mockResolvedValueOnce([account]);
+      (publicClient.readContract as unknown as jest.Mock).mockImplementation(
+        async (args: unknown) => {
+          const call = args as { functionName: string };
+          if (call.functionName === 'withdrawalPermissions') {
+            return account;
+          }
+          throw new Error('unexpected readContract call');
+        }
+      );
+
+      await client.validateWithdrawerPermission(vault, feeIdentifier);
+
+      expect(publicClient.readContract).toHaveBeenCalledWith(
+        expect.objectContaining({
+          address: feeManagerAddress,
+          functionName: 'withdrawalPermissions',
+          args: [vault, feeIdentifier],
+        })
+      );
+    });
+
+    it('validateAdminPermission should return error on readContract failure', async () => {
+      (walletClient.getAddresses as unknown as jest.Mock).mockResolvedValueOnce([account]);
+      (publicClient.readContract as unknown as jest.Mock).mockRejectedValueOnce(new Error('boom'));
+
+      const res = await client.validateAdminPermission();
+
+      expect(res.success).toBe(false);
+      expect(res.status).toBe(500);
+      expect(res.data).toBeNull();
+      expect(res.error).toBeDefined();
+    });
+
+    it('validateWithdrawerPermission should return error on readContract failure', async () => {
+      (walletClient.getAddresses as unknown as jest.Mock).mockResolvedValueOnce([account]);
+      (publicClient.readContract as unknown as jest.Mock).mockRejectedValueOnce(new Error('boom'));
+
+      const res = await client.validateWithdrawerPermission(vault, feeIdentifier);
+
+      expect(res.success).toBe(false);
+      expect(res.status).toBe(500);
+      expect(res.data).toBeNull();
+      expect(res.error).toBeDefined();
+    });
+
+    it('validateAdminPermission should return true when owner matches wallet account', async () => {
+      (walletClient.getAddresses as unknown as jest.Mock).mockResolvedValueOnce([account]);
+      (publicClient.readContract as unknown as jest.Mock).mockImplementation(
+        async (args: unknown) => {
+          const call = args as { functionName: string };
+          if (call.functionName === 'owner') {
+            return account;
+          }
+          throw new Error('unexpected readContract call');
+        }
+      );
+
+      const res = await client.validateAdminPermission();
+
+      expect(res.success).toBe(true);
+      expect(res.status).toBe(200);
+      expect(res.data).toBe(true);
+    });
+
+    it('validateAdminPermission should return false when owner differs from wallet account', async () => {
+      (walletClient.getAddresses as unknown as jest.Mock).mockResolvedValueOnce([account]);
+      (publicClient.readContract as unknown as jest.Mock).mockImplementation(
+        async (args: unknown) => {
+          const call = args as { functionName: string };
+          if (call.functionName === 'owner') {
+            return '0x00000000000000000000000000000000000000bb';
+          }
+          throw new Error('unexpected readContract call');
+        }
+      );
+
+      const res = await client.validateAdminPermission();
+
+      expect(res.success).toBe(true);
+      expect(res.status).toBe(200);
+      expect(res.data).toBe(false);
+    });
+
+    it('validateWithdrawerPermission should return false when withdrawer differs from wallet account', async () => {
+      (walletClient.getAddresses as unknown as jest.Mock).mockResolvedValueOnce([account]);
+      (publicClient.readContract as unknown as jest.Mock).mockImplementation(
+        async (args: unknown) => {
+          const call = args as { functionName: string };
+          if (call.functionName === 'withdrawalPermissions') {
+            return '0x00000000000000000000000000000000000000bb';
+          }
+          throw new Error('unexpected readContract call');
+        }
+      );
+
+      const res = await client.validateWithdrawerPermission(vault, feeIdentifier);
+
+      expect(res.success).toBe(true);
+      expect(res.status).toBe(200);
+      expect(res.data).toBe(false);
+    });
+
+    it('validateWithdrawerPermission should return true when withdrawer matches wallet account', async () => {
+      (walletClient.getAddresses as unknown as jest.Mock).mockResolvedValueOnce([account]);
+      (publicClient.readContract as unknown as jest.Mock).mockImplementation(
+        async (args: unknown) => {
+          const call = args as { functionName: string };
+          if (call.functionName === 'withdrawalPermissions') {
+            return account;
+          }
+          throw new Error('unexpected readContract call');
+        }
+      );
+
+      const res = await client.validateWithdrawerPermission(vault, feeIdentifier);
+
+      expect(res.success).toBe(true);
+      expect(res.status).toBe(200);
+      expect(res.data).toBe(true);
+    });
+  });
+
+  describe('write/config methods', () => {
+    const vault: Address = '0x0000000000000000000000000000000000000001';
+    const feeIdentifier = 'STEER_FEES';
+    const account: Address = '0x00000000000000000000000000000000000000aa';
+    const txHash = '0x00000000000000000000000000000000000000bb';
+
+    beforeEach(() => {
+      (walletClient.getAddresses as unknown as jest.Mock).mockResolvedValue([account]);
+    });
+
+    it('withdrawFee should simulate+write with provided amounts', async () => {
+      (publicClient.readContract as unknown as jest.Mock).mockImplementation(
+        async (args: unknown) => {
+          const call = args as { address: Address; functionName: string };
+          if (call.address === feeManagerAddress && call.functionName === 'withdrawalPermissions') {
+            return account;
+          }
+          throw new Error('unexpected readContract call');
+        }
+      );
+
+      (publicClient.simulateContract as unknown as jest.Mock).mockResolvedValueOnce({
+        request: { foo: 'bar' },
+      });
+      (walletClient.writeContract as unknown as jest.Mock).mockResolvedValueOnce(txHash);
+
+      const res = await client.withdrawFee({ vault, feeIdentifier, amount0: 11n, amount1: 22n });
+
+      expect(res.success).toBe(true);
+      expect(res.status).toBe(200);
+      expect(res.data).toBe(txHash);
+
+      expect(publicClient.simulateContract).toHaveBeenCalledWith(
+        expect.objectContaining({
+          address: feeManagerAddress,
+          functionName: 'withdrawFee',
+          args: [vault, feeIdentifier, 11n, 22n],
+          account,
+        })
+      );
+    });
+
+    it('withdrawMultipleFees should simulate+write with provided arrays', async () => {
+      (publicClient.readContract as unknown as jest.Mock).mockImplementation(async (args: any) => {
+        if (args.address === feeManagerAddress && args.functionName === 'withdrawalPermissions') {
+          return account;
+        }
+        throw new Error('unexpected readContract call');
+      });
+
+      (publicClient.simulateContract as unknown as jest.Mock).mockResolvedValueOnce({
+        request: { foo: 'bar' },
+      });
+      (walletClient.writeContract as unknown as jest.Mock).mockResolvedValueOnce(txHash);
+
+      const res = await client.withdrawMultipleFees({
+        vault,
+        feeIdentifiers: ['A', 'B'],
+        amounts0: [1n, 2n],
+        amounts1: [3n, 4n],
+      });
+
+      expect(res.success).toBe(true);
+      expect(res.status).toBe(200);
+      expect(res.data).toBe(txHash);
+
+      expect(publicClient.simulateContract).toHaveBeenCalledWith(
+        expect.objectContaining({
+          address: feeManagerAddress,
+          functionName: 'withdrawMultipleFees',
+          args: [vault, ['A', 'B'], [1n, 2n], [3n, 4n]],
+          account,
+        })
+      );
+    });
+
+    it('withdrawFeesFromMultipleVaults should simulate+write with 2D arrays', async () => {
+      const vault2: Address = '0x0000000000000000000000000000000000000002';
+
+      (publicClient.readContract as unknown as jest.Mock).mockImplementation(async (args: any) => {
+        if (args.address === feeManagerAddress && args.functionName === 'withdrawalPermissions') {
+          return account;
+        }
+        throw new Error('unexpected readContract call');
+      });
+
+      (publicClient.simulateContract as unknown as jest.Mock).mockResolvedValueOnce({
+        request: { foo: 'bar' },
+      });
+      (walletClient.writeContract as unknown as jest.Mock).mockResolvedValueOnce(txHash);
+
+      const res = await client.withdrawFeesFromMultipleVaults({
+        vaults: [vault, vault2],
+        feeIdentifiers: [[feeIdentifier], [feeIdentifier]],
+        amounts0: [[1n], [2n]],
+        amounts1: [[3n], [4n]],
+      });
+
+      expect(res.success).toBe(true);
+      expect(res.status).toBe(200);
+      expect(res.data).toBe(txHash);
+
+      expect(publicClient.simulateContract).toHaveBeenCalledWith(
+        expect.objectContaining({
+          address: feeManagerAddress,
+          functionName: 'withdrawFeesFromMultipleVaults',
+          args: [
+            [vault, vault2],
+            [[feeIdentifier], [feeIdentifier]],
+            [[1n], [2n]],
+            [[3n], [4n]],
+          ],
+          account,
+        })
+      );
+    });
+
+    it('setFeeAndWithdrawalPermission should return 400 if array lengths mismatch', async () => {
+      const res = await client.setFeeAndWithdrawalPermission({
+        vault,
+        feeIdentifiers: ['A', 'B'],
+        feeValues: [1n],
+        withdrawers: [account],
+      });
+
+      expect(res.success).toBe(false);
+      expect(res.status).toBe(400);
+      expect(res.data).toBeNull();
+    });
+
+    it('setFeeAndWithdrawalPermission should simulate+write when admin', async () => {
+      (publicClient.readContract as unknown as jest.Mock).mockImplementation(
+        async (args: unknown) => {
+          const call = args as { functionName: string };
+          if (call.functionName === 'owner') {
+            return account;
+          }
+          throw new Error('unexpected readContract call');
+        }
+      );
+      (publicClient.simulateContract as unknown as jest.Mock).mockResolvedValueOnce({
+        request: { foo: 'bar' },
+      });
+      (walletClient.writeContract as unknown as jest.Mock).mockResolvedValueOnce(txHash);
+
+      const res = await client.setFeeAndWithdrawalPermission({
+        vault,
+        feeIdentifiers: [feeIdentifier],
+        feeValues: [1n],
+        withdrawers: [account],
+      });
+
+      expect(res.success).toBe(true);
+      expect(res.status).toBe(200);
+      expect(res.data).toBe(txHash);
+
+      expect(publicClient.simulateContract).toHaveBeenCalledWith(
+        expect.objectContaining({
+          address: feeManagerAddress,
+          functionName: 'setFeeAndWithdrawalPermission',
+          args: [vault, [feeIdentifier], [1n], [account]],
+          account,
+        })
+      );
+
+      expect(walletClient.writeContract).toHaveBeenCalled();
+    });
+
+    it('setDefaultFeeAndWithdrawalPermission should simulate+write when admin', async () => {
+      (publicClient.readContract as unknown as jest.Mock).mockImplementation(
+        async (args: unknown) => {
+          const call = args as { functionName: string };
+          if (call.functionName === 'owner') {
+            return account;
+          }
+          throw new Error('unexpected readContract call');
+        }
+      );
+      (publicClient.simulateContract as unknown as jest.Mock).mockResolvedValueOnce({
+        request: { foo: 'bar' },
+      });
+      (walletClient.writeContract as unknown as jest.Mock).mockResolvedValueOnce(txHash);
+
+      const res = await client.setDefaultFeeAndWithdrawalPermission({
+        vault,
+        totalVaultFees: 10n,
+        feeIdentifiers: [feeIdentifier],
+        feeValues: [1n],
+        withdrawers: [account],
+      });
+
+      expect(res.success).toBe(true);
+      expect(res.status).toBe(200);
+      expect(res.data).toBe(txHash);
+
+      expect(publicClient.simulateContract).toHaveBeenCalledWith(
+        expect.objectContaining({
+          address: feeManagerAddress,
+          functionName: 'setDefaultFeeAndWithdrawalPermission',
+          args: [vault, 10n, [feeIdentifier], [1n], [account]],
+          account,
+        })
+      );
+    });
+
+    it('setMigratedVaultFeeAndWithdrawalPermission should simulate+write when admin', async () => {
+      (publicClient.readContract as unknown as jest.Mock).mockImplementation(
+        async (args: unknown) => {
+          const call = args as { functionName: string };
+          if (call.functionName === 'owner') {
+            return account;
+          }
+          throw new Error('unexpected readContract call');
+        }
+      );
+      (publicClient.simulateContract as unknown as jest.Mock).mockResolvedValueOnce({
+        request: { foo: 'bar' },
+      });
+      (walletClient.writeContract as unknown as jest.Mock).mockResolvedValueOnce(txHash);
+
+      const res = await client.setMigratedVaultFeeAndWithdrawalPermission();
+
+      expect(res.success).toBe(true);
+      expect(res.status).toBe(200);
+      expect(res.data).toBe(txHash);
+
+      expect(publicClient.simulateContract).toHaveBeenCalledWith(
+        expect.objectContaining({
+          address: feeManagerAddress,
+          functionName: 'setMigratedVaultFeeAndWithdrawalPermission',
+          args: [],
+          account,
+        })
+      );
+    });
+
+    it('setTotalFees should simulate+write when admin', async () => {
+      (publicClient.readContract as unknown as jest.Mock).mockImplementation(
+        async (args: unknown) => {
+          const call = args as { functionName: string };
+          if (call.functionName === 'owner') {
+            return account;
+          }
+          throw new Error('unexpected readContract call');
+        }
+      );
+      (publicClient.simulateContract as unknown as jest.Mock).mockResolvedValueOnce({
+        request: { foo: 'bar' },
+      });
+      (walletClient.writeContract as unknown as jest.Mock).mockResolvedValueOnce(txHash);
+
+      const res = await client.setTotalFees(vault, 123n);
+
+      expect(res.success).toBe(true);
+      expect(res.status).toBe(200);
+      expect(res.data).toBe(txHash);
+
+      expect(publicClient.simulateContract).toHaveBeenCalledWith(
+        expect.objectContaining({
+          address: feeManagerAddress,
+          functionName: 'setTotalFees',
+          args: [vault, 123n],
+          account,
+        })
+      );
+    });
+
+    it('changeFeeWithdrawer should simulate+write when admin', async () => {
+      (publicClient.readContract as unknown as jest.Mock).mockImplementation(
+        async (args: unknown) => {
+          const call = args as { functionName: string };
+          if (call.functionName === 'owner') {
+            return account;
+          }
+          throw new Error('unexpected readContract call');
+        }
+      );
+      (publicClient.simulateContract as unknown as jest.Mock).mockResolvedValueOnce({
+        request: { foo: 'bar' },
+      });
+      (walletClient.writeContract as unknown as jest.Mock).mockResolvedValueOnce(txHash);
+
+      const newWithdrawer: Address = '0x00000000000000000000000000000000000000cc';
+      const res = await client.changeFeeWithdrawer(vault, feeIdentifier, newWithdrawer);
+
+      expect(res.success).toBe(true);
+      expect(res.status).toBe(200);
+      expect(res.data).toBe(txHash);
+
+      expect(publicClient.simulateContract).toHaveBeenCalledWith(
+        expect.objectContaining({
+          address: feeManagerAddress,
+          functionName: 'changeFeeWithdrawer',
+          args: [vault, feeIdentifier, newWithdrawer],
+          account,
+        })
+      );
+    });
+  });
+});