@steerprotocol/sdk 1.31.0 → 2.0.1

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

@@ -1,1412 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { createPublicClient, createWalletClient, http } from 'viem';
-import { polygon } from 'viem/chains';
-import { VaultClient } from '../../base/VaultClient.js';
-import { SteerClient } from '../../client.js';
-import { Protocol } from '../../const/index.js';
-
-describe('VaultClient', () => {
-  let client: VaultClient;
-  const zeroAddress = '0x0000000000000000000000000000000000000000';
-  const defaultAccount = '0x1111111111111111111111111111111111111111';
-  const zeroSupplyVaultAddress = '0x9999999999999999999999999999999999999999';
-  const polygonRpcUrl = 'https://polygon-bor-rpc.publicnode.com';
-  const liveVaultFixture = JSON.parse(
-    readFileSync(resolve(__dirname, '../fixtures/live/vaults.fixture.json'), 'utf8'),
-  ) as { selectedForPagination: any[] };
-
-  beforeEach(() => {
-    const mockPublicClient = {
-      chain: { id: 137 },
-      getChainId: jest.fn().mockResolvedValue(137),
-      simulateContract: jest.fn().mockImplementation(async ({ address }: { address: string }) => {
-        if (address.toLowerCase() === zeroAddress) {
-          throw new Error('simulateContract failed');
-        }
-        return { request: { to: address } };
-      }),
-      readContract: jest.fn().mockImplementation(async ({ address, functionName, args }: { address: string; functionName: string; args?: any[] }) => {
-        if (address.toLowerCase() === zeroAddress) {
-          throw new Error('readContract failed');
-        }
-        if (functionName === 'allowance') {
-          return 1_000n;
-        }
-        if (functionName === 'vaultDetailsByAddress' || functionName === 'algebraVaultDetailsByAddress') {
-          const vaultAddress = String(args?.[0] || '').toLowerCase();
-          if (vaultAddress === zeroAddress) {
-            throw new Error('Invalid vault');
-          }
-          if (vaultAddress === zeroSupplyVaultAddress.toLowerCase()) {
-            return {
-              token0Balance: 0n,
-              token1Balance: 0n,
-              totalLPTokensIssued: 0n,
-            };
-          }
-          return {
-            token0Balance: 5_000n,
-            token1Balance: 10_000n,
-            totalLPTokensIssued: 10_000n,
-          };
-        }
-        return 1_000n;
-      }),
-    };
-
-    const mockWalletClient = {
-      getAddresses: jest.fn().mockResolvedValue([defaultAccount]),
-      writeContract: jest.fn().mockImplementation(async ({ to }: { to: string }) => {
-        if (String(to).toLowerCase() === zeroAddress) {
-          throw new Error('writeContract failed');
-        }
-        return `0x${'a'.repeat(64)}` as `0x${string}`;
-      }),
-    };
-
-    client = new VaultClient(
-      mockPublicClient as any,
-      mockWalletClient as any,
-      'production',
-    );
-  });
-
-  describe('getLatestVaults', () => {
-    it('should fetch latest vaults successfully', async () => {
-      const fetchSpy = jest.spyOn(global, 'fetch').mockResolvedValueOnce({
-        ok: true,
-        status: 200,
-        json: async () => ({ vaults: liveVaultFixture.selectedForPagination.slice(0, 3) }),
-      } as any);
-      const response = await client.getLatestVaults();
-      fetchSpy.mockRestore();
-      expect(response.success).toBe(true);
-      expect(response.status).toBe(200);
-      expect(response.error).toBeUndefined();
-    });
-      
-
-    it('should handle errors gracefully', async () => {
-      const fetchSpy = jest.spyOn(global, 'fetch').mockResolvedValueOnce({
-        ok: false,
-        status: 500,
-      } as any);
-
-      const response = await client.getLatestVaults();
-      fetchSpy.mockRestore();
-      expect(response.success).toBe(false);
-      expect(response.status).toBe(500);
-      expect(response.error).toBeDefined();
-    });
-  });
-
-  describe('prepareDepositTx', () => {
-    it('should successfully prepare deposit transaction data', async () => {
-      const testVaultAddress = '0x1234567890123456789012345678901234567890';
-      const amount0Desired = BigInt('1000000000000000000'); // 1 token
-      const amount1Desired = BigInt('2000000000000000000'); // 2 tokens
-      const slippage = 0.01; // 1%
-
-      const response = await client.prepareDepositTx({
-        vaultAddress: testVaultAddress as `0x${string}`,
-        amount0Desired,
-        amount1Desired,
-        slippage
-      });
-
-      expect(response.success).toBe(true);
-      expect(response.status).toBe(200);
-      expect(response.data).toBeDefined();
-      
-      if (response.data) {
-        // Verify the structure of the transaction data
-        expect(response.data.address).toBe(testVaultAddress);
-        expect(response.data.functionName).toBe('deposit');
-        expect(response.data.abi).toBeDefined();
-        expect(response.data.args).toBeDefined();
-        expect(response.data.args.length).toBe(5);
-
-        // Verify the ABI structure
-        expect(response.data.abi[0].type).toBe('function');
-        expect(response.data.abi[0].name).toBe('deposit');
-        expect(response.data.abi[0].inputs.length).toBe(5);
-
-        // Verify the arguments
-        const [amount0, amount1, min0, min1, to] = response.data.args;
-        expect(amount0).toBe(amount0Desired);
-        expect(amount1).toBe(amount1Desired);
-        expect(min0).toBe(0n);
-        expect(min1).toBe(0n);
-        expect(to).toBe(defaultAccount);
-      }
-    });
-
-    it('should handle errors when preparing deposit transaction', async () => {
-      const invalidAddress = '0x0000000000000000000000000000000000000000';
-      const amount0Desired = BigInt('1000000000000000000');
-      const amount1Desired = BigInt('2000000000000000000');
-      const slippage = 0.01;
-
-      const response = await client.prepareDepositTx({
-        vaultAddress: invalidAddress as `0x${string}`,
-        amount0Desired,
-        amount1Desired,
-        slippage
-      });
-
-      expect(response.success).toBe(true);
-      expect(response.status).toBe(200);
-      expect(response.data?.address).toBe(invalidAddress);
-    });
-
-    it('should handle custom recipient address', async () => {
-      const testVaultAddress = '0x1234567890123456789012345678901234567890';
-      const customRecipient = '0x9876543210987654321098765432109876543210';
-      const amount0Desired = BigInt('1000000000000000000');
-      const amount1Desired = BigInt('2000000000000000000');
-      const slippage = 0.01;
-
-      const response = await client.prepareDepositTx({
-        vaultAddress: testVaultAddress as `0x${string}`,
-        amount0Desired,
-        amount1Desired,
-        slippage,
-        to: customRecipient as `0x${string}`
-      });
-
-      expect(response.success).toBe(true);
-      expect(response.status).toBe(200);
-      expect(response.data).toBeDefined();
-      
-      if (response.data) {
-        // Verify the custom recipient is used in the args
-        const [, , , , to] = response.data.args;
-        expect(to).toBe(customRecipient);
-      }
-    });
-  });
-
-  describe('withdraw', () => {
-    it('should successfully withdraw tokens', async () => {
-      const testVaultAddress = '0x1234567890123456789012345678901234567890';
-      const shares = BigInt('1000000000000000000'); // 1 share
-      const amount0Min = BigInt('500000000000000000'); // 0.5 token0
-      const amount1Min = BigInt('750000000000000000'); // 0.75 token1
-
-      const response = await client.withdraw({
-        vaultAddress: testVaultAddress as `0x${string}`,
-        shares,
-        amount0Min,
-        amount1Min
-      });
-
-      expect(response.success).toBe(true);
-      expect(response.status).toBe(200);
-      expect(response.data).toBeDefined();
-    });
-
-    it('should handle errors during withdrawal', async () => {
-      const invalidAddress = '0x0000000000000000000000000000000000000000';
-      const shares = BigInt('1000000000000000000');
-      const amount0Min = BigInt('500000000000000000');
-      const amount1Min = BigInt('750000000000000000');
-
-      const response = await client.withdraw({
-        vaultAddress: invalidAddress as `0x${string}`,
-        shares,
-        amount0Min,
-        amount1Min
-      });
-
-      expect(response.success).toBe(false);
-      expect(response.status).toBe(500);
-      expect(response.error).toBeDefined();
-    });
-
-    it('should handle custom recipient address', async () => {
-      const testVaultAddress = '0x1234567890123456789012345678901234567890';
-      const customRecipient = '0x9876543210987654321098765432109876543210';
-      const shares = BigInt('1000000000000000000');
-      const amount0Min = BigInt('500000000000000000');
-      const amount1Min = BigInt('750000000000000000');
-
-      const response = await client.withdraw({
-        vaultAddress: testVaultAddress as `0x${string}`,
-        shares,
-        amount0Min,
-        amount1Min,
-        to: customRecipient as `0x${string}`
-      });
-
-      expect(response.success).toBe(true);
-      expect(response.status).toBe(200);
-      expect(response.data).toBeDefined();
-    });
-  });
-
-  describe('prepareWithdrawTx', () => {
-    it('should successfully prepare withdraw transaction data', async () => {
-      const testVaultAddress = '0x1234567890123456789012345678901234567890';
-      const shares = BigInt('1000000000000000000'); // 1 share
-      const amount0Min = BigInt('500000000000000000'); // 0.5 token0
-      const amount1Min = BigInt('750000000000000000'); // 0.75 token1
-
-      const response = await client.prepareWithdrawTx({
-        vaultAddress: testVaultAddress as `0x${string}`,
-        shares,
-        amount0Min,
-        amount1Min
-      });
-
-      expect(response.success).toBe(true);
-      expect(response.status).toBe(200);
-      expect(response.data).toBeDefined();
-      
-      if (response.data) {
-        // Verify the structure of the transaction data
-        expect(response.data.address).toBe(testVaultAddress);
-        expect(response.data.functionName).toBe('withdraw');
-        expect(response.data.abi).toBeDefined();
-        expect(response.data.args).toBeDefined();
-        expect(response.data.args.length).toBe(4);
-
-        // Verify the ABI structure
-        expect(response.data.abi[0].type).toBe('function');
-        expect(response.data.abi[0].name).toBe('withdraw');
-        expect(response.data.abi[0].inputs.length).toBe(4);
-
-        // Verify the arguments
-        const [sharesArg, amount0MinArg, amount1MinArg] = response.data.args;
-        expect(sharesArg).toBe(shares);
-        expect(amount0MinArg).toBe(0n);
-        expect(amount1MinArg).toBe(0n);
-      }
-    });
-
-    it('should handle errors when preparing withdraw transaction', async () => {
-      const invalidAddress = '0x0000000000000000000000000000000000000000';
-      const shares = BigInt('1000000000000000000');
-      const amount0Min = BigInt('500000000000000000');
-      const amount1Min = BigInt('750000000000000000');
-
-      const response = await client.prepareWithdrawTx({
-        vaultAddress: invalidAddress as `0x${string}`,
-        shares,
-        amount0Min,
-        amount1Min
-      });
-
-      expect(response.success).toBe(true);
-      expect(response.status).toBe(200);
-      expect(response.data?.address).toBe(invalidAddress);
-    });
-
-    it('should handle custom recipient address', async () => {
-      const testVaultAddress = '0x1234567890123456789012345678901234567890';
-      const customRecipient = '0x9876543210987654321098765432109876543210';
-      const shares = BigInt('1000000000000000000');
-      const amount0Min = BigInt('500000000000000000');
-      const amount1Min = BigInt('750000000000000000');
-
-      const response = await client.prepareWithdrawTx({
-        vaultAddress: testVaultAddress as `0x${string}`,
-        shares,
-        amount0Min,
-        amount1Min,
-        to: customRecipient as `0x${string}`
-      });
-
-      expect(response.success).toBe(true);
-      expect(response.status).toBe(200);
-      expect(response.data).toBeDefined();
-      
-      if (response.data) {
-        // Verify the custom recipient is used in the args
-        const [, , , to] = response.data.args;
-        expect(to).toBe(customRecipient);
-      }
-    });
-  });
-
-  describe('approve', () => {
-    it('should successfully approve spending', async () => {
-      const testAddress = '0x1234567890123456789012345678901234567890';
-      const spender = '0x2234567890123456789012345678901234567890';
-      const amount = BigInt(1000);
-
-      const response = await client.approve({
-        vaultAddress: testAddress as `0x${string}`,
-        spender: spender as `0x${string}`,
-        amount
-      });
-
-      expect(response.success).toBe(true);
-      expect(response.status).toBe(200);
-      expect(response.data).toBeDefined();
-    });
-
-    it('should handle errors during approval', async () => {
-      const testAddress = '0x0000000000000000000000000000000000000000';
-      const spender = '0x0000000000000000000000000000000000000000';
-      const amount = BigInt(1000);
-
-      const response = await client.approve({
-        vaultAddress: testAddress as `0x${string}`,
-        spender: spender as `0x${string}`,
-        amount
-      });
-
-      expect(response.success).toBe(false);
-      expect(response.status).toBe(500);
-      expect(response.error).toBeDefined();
-    });
-  });
-
-  describe('allowance', () => {
-    it('should successfully get allowance', async () => {
-      const testAddress = '0x1234567890123456789012345678901234567890';
-      const owner = '0x3234567890123456789012345678901234567890';
-      const spender = '0x2234567890123456789012345678901234567890';
-
-      const response = await client.allowance({
-        vaultAddress: testAddress as `0x${string}`,
-        owner: owner as `0x${string}`,
-        spender: spender as `0x${string}`
-      });
-
-      expect(response.success).toBe(true);
-      expect(response.status).toBe(200);
-      expect(response.data).toBeDefined();
-    });
-
-    it('should handle errors when getting allowance', async () => {
-      const testAddress = '0x0000000000000000000000000000000000000000';
-      const owner = '0x0000000000000000000000000000000000000000';
-      const spender = '0x0000000000000000000000000000000000000000';
-
-      const response = await client.allowance({
-        vaultAddress: testAddress as `0x${string}`,
-        owner: owner as `0x${string}`,
-        spender: spender as `0x${string}`
-      });
-
-      expect(response.success).toBe(false);
-      expect(response.status).toBe(500);
-      expect(response.error).toBeDefined();
-    });
-  });
-
-  describe('getTokensFromLp', () => {
-    it('should calculate token amounts correctly for non-zero LP supply', async () => {
-      const testVaultAddress = '0x1234567890123456789012345678901234567890';
-      const lpTokenAmount = BigInt('1000000000000000000'); // 1 LP token
-
-      const response = await client.getTokensFromLp(
-        testVaultAddress as `0x${string}`,
-        lpTokenAmount
-      );
-
-      expect(response.success).toBe(true);
-      expect(response.status).toBe(200);
-      expect(response.data).toBeDefined();
-      
-      if (response.data) {
-        // Verify the structure of the response
-        expect(typeof response.data.token0Val).toBe('bigint');
-        expect(typeof response.data.token1Val).toBe('bigint');
-      }
-    });
-
-    it('should handle zero LP supply case', async () => {
-      const testVaultAddress = zeroSupplyVaultAddress;
-      const lpTokenAmount = BigInt('1000000000000000000'); // 1 LP token
-
-      const response = await client.getTokensFromLp(
-        testVaultAddress as `0x${string}`,
-        lpTokenAmount
-      );
-
-      expect(response.success).toBe(true);
-      expect(response.status).toBe(200);
-      expect(response.data).toBeDefined();
-      
-      if (response.data) {
-        // When LP supply is 0, both values should be 1
-        expect(response.data.token0Val).toBe(BigInt(1));
-        expect(response.data.token1Val).toBe(BigInt(1));
-      }
-    });
-
-    it('should handle errors gracefully', async () => {
-      const invalidAddress = '0x0000000000000000000000000000000000000000';
-      const lpTokenAmount = BigInt('1000000000000000000');
-
-      const response = await client.getTokensFromLp(
-        invalidAddress as `0x${string}`,
-        lpTokenAmount
-      );
-
-      expect(response.success).toBe(false);
-      expect(response.status).toBe(500);
-      expect(response.error).toBeDefined();
-    });
-  });
-
-  describe('getAllVaults', () => {
-    let realSteerClient: SteerClient;
-
-    beforeAll(() => {
-      // Create real clients for blockchain interaction
-      const publicClient = createPublicClient({
-        chain: polygon,
-        transport: http(polygonRpcUrl)
-      });
-
-      const walletClient = createWalletClient({
-        chain: polygon,
-        transport: http(polygonRpcUrl),
-
-      });
-
-      // Initialize SteerClient with real clients
-      realSteerClient = new SteerClient({
-        environment: 'production',
-        client: publicClient,
-        walletClient: walletClient
-      });
-    });
-
-    it('should fetch all vaults with chainId filter successfully', async () => {
-      const filter = { chainId: 137, protocol: Protocol.Sushi };
-      const response = await realSteerClient.vaults.getAllVaults(filter);
-      
-      expect(response.success).toBe(true);
-      expect(response.status).toBe(200);
-      expect(response.data).toBeDefined();
-      expect(Array.isArray(response.data)).toBe(true);
-    }, 300000);
-
-    it('should fetch all vaults with multiple filter parameters', async () => {
-      const filter = { 
-        chainId: 137,
-        protocol: 'uniswap',
-        isActive: true
-      };
-      jest.spyOn(client, 'getVaults').mockResolvedValue({
-        success: true,
-        status: 200,
-        data: {
-          edges: liveVaultFixture.selectedForPagination.slice(0, 8).map((node: any, index: number) => ({ node, cursor: `fixture_${index}` })),
-          pageInfo: { hasNextPage: false, endCursor: null },
-          totalCount: 8,
-        },
-      } as any);
-      const response = await client.getAllVaults(filter);
-      
-      expect(response.success).toBe(true);
-      expect(response.status).toBe(200);
-      expect(response.data).toBeDefined();
-      expect(Array.isArray(response.data)).toBe(true);
-    });
-
-    it('should fetch all vaults with custom batch size', async () => {
-      const filter = { chainId: 137 };
-      const batchSize = 50;
-      jest.spyOn(client, 'getVaults').mockResolvedValue({
-        success: true,
-        status: 200,
-        data: {
-          edges: liveVaultFixture.selectedForPagination.slice(0, 5).map((node: any, index: number) => ({ node, cursor: `fixture_${index}` })),
-          pageInfo: { hasNextPage: false, endCursor: null },
-          totalCount: 5,
-        },
-      } as any);
-      const response = await client.getAllVaults(filter, batchSize);
-      
-      expect(response.success).toBe(true);
-      expect(response.status).toBe(200);
-      expect(response.data).toBeDefined();
-      expect(Array.isArray(response.data)).toBe(true);
-    });
-
-    it('should fetch all vaults without filter', async () => {
-      jest.spyOn(client, 'getVaults').mockResolvedValue({
-        success: true,
-        status: 200,
-        data: {
-          edges: liveVaultFixture.selectedForPagination.slice(0, 10).map((node: any, index: number) => ({ node, cursor: `fixture_${index}` })),
-          pageInfo: { hasNextPage: false, endCursor: null },
-          totalCount: 10,
-        },
-      } as any);
-      const response = await client.getAllVaults();
-      
-      expect(response.success).toBe(true);
-      expect(response.status).toBe(200);
-      expect(response.data).toBeDefined();
-      expect(Array.isArray(response.data)).toBe(true);
-    });
-
-    it('should handle errors gracefully when API fails', async () => {
-      // Mock the getVaults method to simulate API failure
-      const originalGetVaults = client.getVaults;
-      client.getVaults = jest.fn().mockResolvedValue({
-        success: false,
-        status: 500,
-        error: 'API Error',
-        data: null
-      });
-
-      const filter = { chainId: 137 };
-      const response = await client.getAllVaults(filter);
-      
-      expect(response.success).toBe(false);
-      expect(response.status).toBe(500);
-      expect(response.error).toBeDefined();
-      expect(response.data).toBeNull();
-
-      // Restore original method
-      client.getVaults = originalGetVaults;
-    });
-
-    it('should handle pagination correctly when fetching multiple pages', async () => {
-      // Mock getVaults to return paginated responses
-      const mockPage1 = {
-        success: true,
-        status: 200,
-        data: {
-          edges: [
-            { node: { id: 'vault1', name: 'Test Vault 1', protocolBaseType: 'uniswap' } },
-            { node: { id: 'vault2', name: 'Test Vault 2', protocolBaseType: 'uniswap' } }
-          ],
-          pageInfo: {
-            hasNextPage: true,
-            hasPreviousPage: false,
-            startCursor: 'cursor1',
-            endCursor: 'cursor2'
-          }
-        }
-      };
-
-      const mockPage2 = {
-        success: true,
-        status: 200,
-        data: {
-          edges: [
-            { node: { id: 'vault3', name: 'Test Vault 3', protocolBaseType: 'sushi' } }
-          ],
-          pageInfo: {
-            hasNextPage: false,
-            hasPreviousPage: true,
-            startCursor: 'cursor2',
-            endCursor: 'cursor3'
-          }
-        }
-      };
-
-      const originalGetVaults = client.getVaults;
-      client.getVaults = jest.fn()
-        .mockResolvedValueOnce(mockPage1)
-        .mockResolvedValueOnce(mockPage2);
-
-      const filter = { chainId: 137 };
-      const response = await client.getAllVaults(filter);
-      
-      expect(response.success).toBe(true);
-      expect(response.status).toBe(200);
-      expect(response.data).toBeDefined();
-      expect(response.data?.length).toBe(3); // Should have all vaults from both pages
-      expect(response.data?.[0].id).toBe('vault1');
-      expect(response.data?.[1].id).toBe('vault2');
-      expect(response.data?.[2].id).toBe('vault3');
-
-      // Verify getVaults was called twice with correct parameters
-      expect(client.getVaults).toHaveBeenCalledTimes(2);
-      expect(client.getVaults).toHaveBeenNthCalledWith(1, filter, 100, null);
-      expect(client.getVaults).toHaveBeenNthCalledWith(2, filter, 100, 'cursor2');
-
-      // Restore original method
-      client.getVaults = originalGetVaults;
-    });
-
-    it('should handle exception during fetching', async () => {
-      // Mock getVaults to throw an exception
-      const originalGetVaults = client.getVaults;
-      client.getVaults = jest.fn().mockRejectedValue(new Error('Network error'));
-
-      const filter = { chainId: 137 };
-      const response = await client.getAllVaults(filter);
-      
-      expect(response.success).toBe(false);
-      expect(response.status).toBe(500);
-      expect(response.error).toBe('Network error');
-      expect(response.data).toBeNull();
-
-      // Restore original method
-      client.getVaults = originalGetVaults;
-    });
-  });
-
-  describe('searchVaults', () => {
-    const mockVaults = [
-      {
-        id: 'vault-1',
-        chainId: 1,
-        vaultAddress: '0x1111111111111111111111111111111111111111',
-        protocol: 'uniswap',
-        beaconName: 'beacon-1',
-        protocolBaseType: 'uniswap',
-        name: 'USDC/WETH',
-        pool: {
-          id: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-1',
-          poolAddress: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
-          feeTier: '3000',
-        },
-        token0: {
-          id: 'token-0',
-          symbol: 'USDC',
-          name: 'USD Coin',
-          decimals: 6,
-          address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
-          chainId: 1,
-        },
-        token1: {
-          id: 'token-1',
-          symbol: 'WETH',
-          name: 'Wrapped Ether',
-          decimals: 18,
-          address: '0xC02aaA39B223FE8D0A0E5C4F27eAD9083C756Cc2',
-          chainId: 1,
-        },
-      },
-      {
-        id: 'vault-2',
-        chainId: 1,
-        vaultAddress: '0x2222222222222222222222222222222222222222',
-        protocol: 'sushi',
-        beaconName: 'beacon-2',
-        protocolBaseType: 'sushi',
-        name: 'WBTC/USDT',
-        pool: {
-          id: '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb-1',
-          poolAddress: '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
-          feeTier: '500',
-        },
-        token0: {
-          id: 'token-2',
-          symbol: 'WBTC',
-          name: 'Wrapped BTC',
-          decimals: 8,
-          address: '0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599',
-          chainId: 1,
-        },
-        token1: {
-          id: 'token-3',
-          symbol: 'USDT',
-          name: 'Tether',
-          decimals: 6,
-          address: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
-          chainId: 1,
-        },
-      },
-    ];
-
-    it('maps raw poolAddress into the API vault filter and ignores local-only fields', () => {
-      const apiFilter = (client as any).buildApiVaultFilter({
-        chainId: 1,
-        protocol: 'uniswap',
-        poolAddress: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
-        vaultAddress: '0x1111111111111111111111111111111111111111',
-        tokenAddress: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
-        tokenSymbol: 'USDC',
-      });
-
-      expect(apiFilter).toMatchObject({
-        chainId: 1,
-        pool: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
-      });
-      expect(apiFilter).not.toHaveProperty('vaultAddress');
-      expect(apiFilter).not.toHaveProperty('tokenAddress');
-      expect(apiFilter).not.toHaveProperty('tokenSymbol');
-    });
-
-    it('filters by vault address locally', async () => {
-      jest.spyOn(client, 'getAllVaults').mockResolvedValue({
-        success: true,
-        status: 200,
-        data: mockVaults as any,
-      });
-
-      const response = await client.searchVaults({
-        vaultAddress: '0x1111111111111111111111111111111111111111',
-      });
-
-      expect(response.success).toBe(true);
-      expect(response.data).toHaveLength(1);
-      expect(response.data?.[0].id).toBe('vault-1');
-    });
-
-    it('filters by pool address using raw address, not composite pool id', async () => {
-      jest.spyOn(client, 'getAllVaults').mockResolvedValue({
-        success: true,
-        status: 200,
-        data: mockVaults as any,
-      });
-
-      const response = await client.searchVaults({
-        poolAddress: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
-      });
-
-      expect(response.success).toBe(true);
-      expect(response.data).toHaveLength(1);
-      expect(response.data?.[0].id).toBe('vault-1');
-    });
-
-    it('matches token address on either side', async () => {
-      jest.spyOn(client, 'getAllVaults').mockResolvedValue({
-        success: true,
-        status: 200,
-        data: mockVaults as any,
-      });
-
-      const response = await client.searchVaults({
-        tokenAddress: '0xc02aaA39B223FE8D0A0E5C4F27eAD9083C756Cc2',
-      });
-
-      expect(response.success).toBe(true);
-      expect(response.data).toHaveLength(1);
-      expect(response.data?.[0].id).toBe('vault-1');
-    });
-
-    it('matches token symbol case-insensitively without calling token lookup APIs', async () => {
-      jest.spyOn(client, 'getAllVaults').mockResolvedValue({
-        success: true,
-        status: 200,
-        data: mockVaults as any,
-      });
-      const getAllTokensSpy = jest.spyOn(client, 'getAllTokens');
-
-      const response = await client.searchVaults({
-        tokenSymbol: 'usdt',
-      });
-
-      expect(response.success).toBe(true);
-      expect(response.data).toHaveLength(1);
-      expect(response.data?.[0].id).toBe('vault-2');
-      expect(getAllTokensSpy).not.toHaveBeenCalled();
-    });
-
-    it('supports array-based token address and symbol filters', async () => {
-      jest.spyOn(client, 'getAllVaults').mockResolvedValue({
-        success: true,
-        status: 200,
-        data: mockVaults as any,
-      });
-
-      const byAddress = await client.searchVaults({
-        tokenAddresses: ['0x2260fac5e5542a773aa44fbcfedf7c193bc2c599'],
-      });
-      const bySymbol = await client.searchVaults({
-        tokenSymbols: ['weth'],
-      });
-
-      expect(byAddress.success).toBe(true);
-      expect(byAddress.data).toHaveLength(1);
-      expect(byAddress.data?.[0].id).toBe('vault-2');
-      expect(bySymbol.success).toBe(true);
-      expect(bySymbol.data).toHaveLength(1);
-      expect(bySymbol.data?.[0].id).toBe('vault-1');
-    });
-
-    it('propagates getAllVaults failures from searchVaults', async () => {
-      jest.spyOn(client, 'getAllVaults').mockResolvedValue({
-        success: false,
-        status: 500,
-        data: null,
-        error: 'vault fetch failed',
-      });
-
-      const response = await client.searchVaults({
-        vaultAddress: '0x1111111111111111111111111111111111111111',
-      });
-
-      expect(response.success).toBe(false);
-      expect(response.status).toBe(500);
-      expect(response.error).toBe('vault fetch failed');
-    });
-
-    it('provides thin helper methods on top of searchVaults', async () => {
-      jest.spyOn(client, 'searchVaults').mockResolvedValue({
-        success: true,
-        status: 200,
-        data: [mockVaults[0]] as any,
-      });
-
-      const byAddress = await client.getVaultByAddress('0x1111111111111111111111111111111111111111');
-      const forPool = await client.getVaultsForPool('0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa');
-      const forToken = await client.getVaultsForToken('USDC');
-
-      expect(byAddress.success).toBe(true);
-      expect(byAddress.data?.id).toBe('vault-1');
-      expect(forPool.success).toBe(true);
-      expect(forPool.data).toHaveLength(1);
-      expect(forToken.success).toBe(true);
-      expect(forToken.data).toHaveLength(1);
-    });
-
-    it('returns null when getVaultByAddress finds no match', async () => {
-      jest.spyOn(client, 'searchVaults').mockResolvedValue({
-        success: true,
-        status: 200,
-        data: [],
-      });
-
-      const response = await client.getVaultByAddress('0x9999999999999999999999999999999999999999');
-
-      expect(response.success).toBe(true);
-      expect(response.data).toBeNull();
-    });
-
-    it('routes address tokens through tokenAddress in getVaultsForToken', async () => {
-      const searchVaultsSpy = jest.spyOn(client, 'searchVaults').mockResolvedValue({
-        success: true,
-        status: 200,
-        data: [mockVaults[0]] as any,
-      });
-
-      await client.getVaultsForToken('0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48');
-
-      expect(searchVaultsSpy).toHaveBeenCalledWith({
-        tokenAddress: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
-      });
-    });
-  });
-
-  describe('Integration Tests with Real Chain Data', () => {
-    // Using Polygon for testing
-    let realSteerClient: SteerClient;
-
-    beforeAll(() => {
-      // Create real clients for blockchain interaction
-      const publicClient = createPublicClient({
-        chain: polygon,
-        transport: http(polygonRpcUrl)
-      });
-
-      const walletClient = createWalletClient({
-        chain: polygon,
-        transport: http(polygonRpcUrl)
-      });
-
-      // Initialize SteerClient with real clients
-      realSteerClient = new SteerClient({
-        environment: 'production',
-        client: publicClient,
-        walletClient: walletClient
-      });
-    });
-
-    it('should calculate token amounts from LP tokens for a real vault', async () => {
-      // Test with a known vault on Polygon
-      const testVault = "0x777f8dcee1e1e55afc5aeed241fd94f48fc3a355" as `0x${string}`;
-      const lpTokenAmount = BigInt('1000000000000000000'); // 1 LP token
-
-      const response = await realSteerClient.vaults.getTokensFromLp(testVault, lpTokenAmount);
-      if (!response.success || !response.data) {
-        console.warn(`Skipping getTokensFromLp live assertion: ${response.error ?? 'no data'}`);
-        return;
-      }
-      expect(response.success).toBe(true);
-      expect(response.data).toBeDefined();
-      
-      if (response.data) {
-        // Log the calculated amounts for verification
-        console.log('Token0 amount for 1 LP token:', response.data.token0Val.toString());
-        console.log('Token1 amount for 1 LP token:', response.data.token1Val.toString());
-
-        // Verify the structure and types
-        expect(typeof response.data.token0Val).toBe('bigint');
-        expect(typeof response.data.token1Val).toBe('bigint');
-      }
-    }, 30000); // Increased timeout for real API calls
-
-    it('should handle token calculations for vault with no liquidity', async () => {
-      // Test with a known new/empty vault on Polygon
-      const emptyVault = '0x7b85fa7540b75fb214df632f9357eebe48f76edb' as `0x${string}`;
-      const lpTokenAmount = BigInt('1000000000000000000'); // 1 LP token
-      
-      const response = await realSteerClient.vaults.getTokensFromLp(emptyVault, lpTokenAmount);
-      if (!response.success || !response.data) {
-        console.warn(`Skipping empty-vault live assertion: ${response.error ?? 'no data'}`);
-        return;
-      }
-      expect(response.success).toBe(true);
-      expect(response.data).toBeDefined();
-      
-      if (response.data) {
-        // Log the calculated amounts for verification
-        console.log('Token0 amount for empty vault:', response.data.token0Val.toString());
-        console.log('Token1 amount for empty vault:', response.data.token1Val.toString());
-
-        // For empty vault, both values should be 1
-        expect(response.data.token0Val).toBe(BigInt(1));
-        expect(response.data.token1Val).toBe(BigInt(1));
-      }
-    }, 30000);
-
-    it('should calculate corresponding token amount for real vault - zeroForOne true', async () => {
-      // Test with a known vault on Polygon
-      const testVault = '0x616ae107237ce398bf32f08fd6048dd904ed8efb' as `0x${string}`;
-      const token0Amount = BigInt('2222322000000'); // 1 token0
-      
-      const response = await realSteerClient.vaults.getCorrespondingTokenAmount(
-        testVault, 
-        token0Amount, 
-        false // zeroForOne = true, calculating token1 amount for given token0
-      );
-      if (!response.success || response.data === null) {
-        console.warn(`Skipping corresponding-token (false) live assertion: ${response.error ?? 'no data'}`);
-        return;
-      }
-      
-      expect(response.success).toBe(true);
-      expect(response.data).toBeDefined();
-      expect(typeof response.data).toBe('bigint');
-      
-      if (response.data) {
-        console.log('Token1 amount for 1 token0 (zeroForOne=true):', response.data.toString());
-        // The corresponding amount should be greater than 0 for an active vault
-        expect(response.data).toBeGreaterThan(BigInt(0));
-      }
-    }, 30000);
-
-    it('should calculate corresponding token amount for real vault - zeroForOne false', async () => {
-      // Test with a known vault on Polygon
-      const testVault = '0x0fe4cbd6ce903ec1ea8e743972660aecab6badf7' as `0x${string}`;
-      const token1Amount = BigInt('1000000000000000000'); // 1 token1
-      
-      const response = await realSteerClient.vaults.getCorrespondingTokenAmount(
-        testVault, 
-        token1Amount, 
-        false // zeroForOne = false, calculating token0 amount for given token1
-      );
-      if (!response.success || response.data === null) {
-        console.warn(`Skipping corresponding-token (false) live assertion: ${response.error ?? 'no data'}`);
-        return;
-      }
-      
-      expect(response.success).toBe(true);
-      expect(response.data).toBeDefined();
-      expect(typeof response.data).toBe('bigint');
-      
-      if (response.data) {
-        console.log('Token0 amount for 1 token1 (zeroForOne=false):', response.data.toString());
-        // The corresponding amount should be greater than 0 for an active vault
-        expect(response.data).toBeGreaterThan(BigInt(0));
-      }
-    }, 30000);
-
-    it('should handle corresponding token amount calculation with different amounts', async () => {
-      // Test with a known vault on Polygon
-      const testVault = '0x0fe4cbd6ce903ec1ea8e743972660aecab6badf7' as `0x${string}`;
-      
-      // Test with multiple amounts to verify proportional scaling
-      const amounts = [
-        BigInt('500000000000000000'),  // 0.5 tokens
-        BigInt('1000000000000000000'), // 1 token
-        BigInt('2000000000000000000')  // 2 tokens
-      ];
-      
-      const results: bigint[] = [];
-      
-      for (const amount of amounts) {
-        const response = await realSteerClient.vaults.getCorrespondingTokenAmount(
-          testVault, 
-          amount, 
-          true // zeroForOne = true
-        );
-        if (!response.success || response.data === null) {
-          console.warn(`Skipping scaling live assertion: ${response.error ?? 'no data'}`);
-          return;
-        }
-        
-        expect(response.success).toBe(true);
-        expect(response.data).toBeDefined();
-        expect(typeof response.data).toBe('bigint');
-        
-        if (response.data) {
-          results.push(response.data);
-          console.log(`Token1 amount for ${amount.toString()} token0:`, response.data.toString());
-        }
-      }
-      
-      // Verify that the amounts scale proportionally (approximately)
-      if (results.length === 3) {
-        // The ratio between results should be approximately the same as the ratio between input amounts
-        // Allow for some rounding differences in the calculations
-        const ratio1 = Number(results[1]) / Number(results[0]); // Should be ~2
-        const ratio2 = Number(results[2]) / Number(results[1]); // Should be ~2
-        
-        expect(ratio1).toBeGreaterThan(1.9);
-        expect(ratio1).toBeLessThan(2.1);
-        expect(ratio2).toBeGreaterThan(1.9);
-        expect(ratio2).toBeLessThan(2.1);
-      }
-    }, 45000);
-
-    it('should handle errors gracefully for invalid vault address in getCorrespondingTokenAmount', async () => {
-      const invalidVault = '0x0000000000000000000000000000000000000000' as `0x${string}`;
-      const amount = BigInt('1000000000000000000');
-      
-      const response = await realSteerClient.vaults.getCorrespondingTokenAmount(
-        invalidVault, 
-        amount, 
-        true
-      );
-      
-      expect(response.success).toBe(false);
-      expect(response.status).toBe(500);
-      expect(response.error).toBeDefined();
-      expect(response.data).toBeNull();
-    }, 30000);
-
-    it('should search real vaults and helper methods by discovered addresses', async () => {
-      const fixtureVaults = liveVaultFixture.selectedForPagination.slice(0, 25);
-      jest.spyOn(realSteerClient.vaults, 'getAllVaults').mockResolvedValue({
-        success: true,
-        status: 200,
-        data: fixtureVaults as any,
-      });
-
-      const referenceVault = fixtureVaults[0];
-      const vaultAddress = referenceVault.vaultAddress;
-      const poolAddress = referenceVault.pool.poolAddress;
-      const tokenAddress = referenceVault.token0.address;
-      const tokenSymbol = referenceVault.token0.symbol;
-
-      const searchByVault = await realSteerClient.vaults.searchVaults({
-        chainId: referenceVault.chainId,
-        protocol: referenceVault.protocol,
-        vaultAddress,
-      });
-      const getByAddress = await realSteerClient.vaults.getVaultByAddress(vaultAddress, {
-        chainId: referenceVault.chainId,
-        protocol: referenceVault.protocol,
-      });
-      const getForPool = await realSteerClient.vaults.getVaultsForPool(poolAddress, {
-        chainId: referenceVault.chainId,
-        protocol: referenceVault.protocol,
-      });
-      const getForTokenAddress = await realSteerClient.vaults.getVaultsForToken(tokenAddress, {
-        chainId: referenceVault.chainId,
-        protocol: referenceVault.protocol,
-      });
-      const getForTokenSymbol = await realSteerClient.vaults.getVaultsForToken(tokenSymbol, {
-        chainId: referenceVault.chainId,
-        protocol: referenceVault.protocol,
-      });
-
-      expect(searchByVault.success).toBe(true);
-      expect(getByAddress.success).toBe(true);
-      expect(getForPool.success).toBe(true);
-      expect(getForTokenAddress.success).toBe(true);
-      expect(getForTokenSymbol.success).toBe(true);
-
-      expect(searchByVault.data?.some((vault) => vault.id === referenceVault.id)).toBe(true);
-      expect(getByAddress.data?.id).toBe(referenceVault.id);
-      expect(getForPool.data?.some((vault) => vault.id === referenceVault.id)).toBe(true);
-
-      if (getForTokenAddress.data && getForTokenAddress.data.length > 0) {
-        const matchesAddress = getForTokenAddress.data.some((vault) =>
-          [vault.token0.address, vault.token1.address]
-            .map((address) => address.toLowerCase())
-            .includes(tokenAddress.toLowerCase()),
-        );
-        expect(matchesAddress).toBe(true);
-      }
-
-      if (getForTokenSymbol.data && getForTokenSymbol.data.length > 0) {
-        const matchesSymbol = getForTokenSymbol.data.some((vault) =>
-          [vault.token0.symbol, vault.token1.symbol]
-            .map((symbol) => symbol.toLowerCase())
-            .includes(tokenSymbol.toLowerCase()),
-        );
-        expect(matchesSymbol).toBe(true);
-      }
-    }, 120000);
-  });
-
-  describe('Reward Management', () => {
-    describe('calculatePendingRewards', () => {
-      it('should successfully calculate pending rewards', async () => {
-        const testVaultAddress = '0x1234567890123456789012345678901234567890';
-        const userAddress = '0x2234567890123456789012345678901234567890';
-
-        // Mock the readContract call to return reward data
-        const mockRewards = [BigInt('1000000000000000000'), BigInt('500000000000000000')]; // 1 reward, 0.5 extraReward
-        jest.spyOn(client['publicClient'], 'readContract').mockResolvedValueOnce(mockRewards);
-
-        const response = await client.calculatePendingRewards({
-          vaultAddress: testVaultAddress as `0x${string}`,
-          user: userAddress as `0x${string}`
-        });
-
-        expect(response.success).toBe(true);
-        expect(response.status).toBe(200);
-        expect(response.data).toBeDefined();
-        
-        if (response.data) {
-          expect(response.data.rewards).toBe(BigInt('1000000000000000000'));
-          expect(response.data.extraRewards).toBe(BigInt('500000000000000000'));
-        }
-      });
-
-      it('should return zero values when calculatePendingRewards function reverts', async () => {
-        const testVaultAddress = '0x1234567890123456789012345678901234567890';
-        const userAddress = '0x2234567890123456789012345678901234567890';
-
-        // Mock the readContract call to throw an error (simulating revert)
-        jest.spyOn(client['publicClient'], 'readContract').mockRejectedValueOnce(
-          new Error('Contract function reverted')
-        );
-
-        const response = await client.calculatePendingRewards({
-          vaultAddress: testVaultAddress as `0x${string}`,
-          user: userAddress as `0x${string}`
-        });
-
-        expect(response.success).toBe(true);
-        expect(response.status).toBe(200);
-        expect(response.data).toBeDefined();
-        
-        if (response.data) {
-          expect(response.data.rewards).toBe(BigInt(0));
-          expect(response.data.extraRewards).toBe(BigInt(0));
-        }
-      });
-
-      it('should handle various reward amounts correctly', async () => {
-        const testVaultAddress = '0x1234567890123456789012345678901234567890';
-        const userAddress = '0x2234567890123456789012345678901234567890';
-
-        const testCases = [
-          [BigInt(0), BigInt(0)], // No rewards
-          [BigInt('999999999999999999'), BigInt('1')], // Almost 1 token rewards
-          [BigInt('1000000000000000000000'), BigInt('2000000000000000000000')], // Large rewards
-        ];
-
-        for (const [rewards, extraRewards] of testCases) {
-          jest.spyOn(client['publicClient'], 'readContract').mockResolvedValueOnce([rewards, extraRewards]);
-
-          const response = await client.calculatePendingRewards({
-            vaultAddress: testVaultAddress as `0x${string}`,
-            user: userAddress as `0x${string}`
-          });
-
-          expect(response.success).toBe(true);
-          expect(response.data?.rewards).toBe(rewards);
-          expect(response.data?.extraRewards).toBe(extraRewards);
-        }
-      });
-    });
-
-    describe('claimPendingRewards', () => {
-      let realSteerClient: SteerClient;
-      const publicClient = createPublicClient({
-        chain: polygon,
-        transport: http(polygonRpcUrl)
-      });
-
-      const walletClient = createWalletClient({
-        chain: polygon,
-        transport: http(polygonRpcUrl)
-      });
-      realSteerClient = new SteerClient({
-        environment: 'production',
-        client: publicClient,
-        walletClient: walletClient
-      });
-
-      it('should successfully claim pending rewards', async () => {
-        const testVaultAddress = '0x5c1d454f08975c554f6b70a84fd8859fbdfcc069';
-        // Mock the simulateContract and writeContract calls
-
-        const response = await realSteerClient.vaults.claimBlackholePendingRewards({
-          vaultAddress: testVaultAddress as `0x${string}`
-        });
-
-        if (!response.success) {
-          console.warn(`Skipping claimPendingRewards live assertion: ${response.error ?? 'unknown error'}`);
-          return;
-        }
-        expect(response.success).toBe(true);
-        expect(response.status).toBe(200);
-      });
-
-      it('should return zero values when claimBlackHolePendingRewards function reverts', async () => {
-        const testVaultAddress = '0x1234567890123456789012345678901234567890';
-
-        // Mock the simulateContract call to throw an error (simulating revert)
-        jest.spyOn(client['publicClient'], 'simulateContract').mockRejectedValueOnce(
-          new Error('Contract function reverted')
-        );
-
-        const response = await client.claimBlackholePendingRewards({
-          vaultAddress: testVaultAddress as `0x${string}`
-        });
-
-        expect(response.success).toBe(true);
-        expect(response.status).toBe(200);
-        expect(response.data).toBeDefined();
-        
-        if (response.data && typeof response.data === 'object' && 'rewards' in response.data) {
-          expect(response.data.rewards).toBe(BigInt(0));
-          expect(response.data.extraRewards).toBe(BigInt(0));
-        }
-      });
-
-      it('should handle wallet client errors gracefully', async () => {
-        const testVaultAddress = '0x1234567890123456789012345678901234567890';
-
-        // Mock successful simulation but failed transaction
-        jest.spyOn(client['publicClient'], 'simulateContract').mockResolvedValueOnce({
-          request: {
-            address: testVaultAddress,
-            abi: expect.any(Array),
-            functionName: 'claimBlackHolePendingRewards',
-            args: []
-          }
-        } as any);
-
-        jest.spyOn(client['walletClient'], 'writeContract').mockRejectedValueOnce(
-          new Error('Transaction failed')
-        );
-
-        const response = await client.claimBlackholePendingRewards({
-          vaultAddress: testVaultAddress as `0x${string}`
-        });
-
-        expect(response.success).toBe(true);
-        expect(response.status).toBe(200);
-        expect(response.data).toBeDefined();
-        
-        if (response.data && typeof response.data === 'object' && 'rewards' in response.data) {
-          expect(response.data.rewards).toBe(BigInt(0));
-          expect(response.data.extraRewards).toBe(BigInt(0));
-        }
-      });
-
-      it('should handle missing wallet account gracefully', async () => {
-        const testVaultAddress = '0x1234567890123456789012345678901234567890';
-
-        // Mock getAddresses to return empty array
-        jest.spyOn(client['walletClient'], 'getAddresses').mockResolvedValueOnce([]);
-
-        const response = await client.claimBlackholePendingRewards({
-          vaultAddress: testVaultAddress as `0x${string}`
-        });
-
-        expect(response.success).toBe(true);
-        expect(response.status).toBe(200);
-        expect(response.data).toBeDefined();
-        
-        if (response.data && typeof response.data === 'object' && 'rewards' in response.data) {
-          expect(response.data.rewards).toBe(BigInt(0));
-          expect(response.data.extraRewards).toBe(BigInt(0));
-        }
-      });
-    });
-
-    describe('Integration Tests for Reward Functions', () => {
-      let realSteerClient: SteerClient;
-
-      beforeAll(() => {
-        // Create real clients for blockchain interaction
-        const publicClient = createPublicClient({
-          chain: polygon,
-          transport: http(polygonRpcUrl)
-        });
-
-        const walletClient = createWalletClient({
-          chain: polygon,
-          transport: http(polygonRpcUrl),
-        });
-
-        // Initialize SteerClient with real clients
-        realSteerClient = new SteerClient({
-          environment: 'production',
-          client: publicClient,
-          walletClient: walletClient
-        });
-      });
-
-      it('should calculate pending rewards for real vault', async () => {
-        // Using a real vault address on Polygon for testing
-        const testVault = "0xa49c49d120ecfbd1f40d3e16bad63b2caf149926" as `0x${string}`;
-        const userAddress = "0xCD88431107B72b1a1aa13DE27Ab894e27C7D1a61" as `0x${string}`;
-
-        const response = await realSteerClient.vaults.calculatePendingRewards({
-          vaultAddress: testVault,
-          user: userAddress
-        });
-
-        expect(response.success).toBe(true);
-        expect(response.status).toBe(200);
-        expect(response.data).toBeDefined();
-        
-        if (response.data) {
-          // The function should return bigint values (even if zero)
-          expect(typeof response.data.rewards).toBe('bigint');
-          expect(typeof response.data.extraRewards).toBe('bigint');
-          
-          console.log('Pending rewards:', response.data.rewards.toString());
-          console.log('Pending extra rewards:', response.data.extraRewards.toString());
-        }
-      }, 30000);
-
-      it('should handle reward calculation for vault without reward function', async () => {
-        // Using a vault that likely doesn't have the reward function
-        const testVault = "0x0fe4cbd6ce903ec1ea8e743972660aecab6badf7" as `0x${string}`;
-        const userAddress = "0x1234567890123456789012345678901234567890" as `0x${string}`;
-
-        const response = await realSteerClient.vaults.calculatePendingRewards({
-          vaultAddress: testVault,
-          user: userAddress
-        });
-
-        expect(response.success).toBe(true);
-        expect(response.status).toBe(200);
-        expect(response.data).toBeDefined();
-        
-        if (response.data) {
-          // Should return zero values when function doesn't exist or reverts
-          expect(response.data.rewards).toBe(BigInt(0));
-          expect(response.data.extraRewards).toBe(BigInt(0));
-        }
-      }, 30000);
-
-      it('should handle claim rewards for vault without claim function', async () => {
-        // Note: This test won't actually send a transaction since we don't have a real private key
-        // But it will test the error handling path
-        const testVault = "0x0fe4cbd6ce903ec1ea8e743972660aecab6badf7" as `0x${string}`;
-
-        const response = await realSteerClient.vaults.claimBlackholePendingRewards({
-          vaultAddress: testVault
-        });
-
-        expect(response.success).toBe(true);
-        expect(response.status).toBe(200);
-        expect(response.data).toBeDefined();
-        
-        if (response.data && typeof response.data === 'object' && 'rewards' in response.data) {
-          // Should return zero values when function doesn't exist or reverts
-          expect(response.data.rewards).toBe(BigInt(0));
-          expect(response.data.extraRewards).toBe(BigInt(0));
-        }
-      }, 30000);
-    });
-  });
-
- 
-});