@steerprotocol/sdk 1.30.8 → 2.0.0

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

@@ -1,1012 +0,0 @@
-import { createPublicClient, createTestClient, createWalletClient, http, publicActions, walletActions } from 'viem';
-import { privateKeyToAccount } from 'viem/accounts';
-import { avalanche, foundry, polygon, ronin } 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;
-  // let viemClient: TestClient;
-
-  beforeEach(() => {
-    const testClient = createTestClient({
-      account: privateKeyToAccount("0x40199ba8875ac583658a7e936e16354f4bf1ea54dac73a2bc24fd17159ceb821"),
-      chain: {
-        ...foundry,
-        id: 137
-      },
-      mode: 'anvil',      
-      transport: http(),
-    })
-      .extend(publicActions)
-      .extend(walletActions);
-
-    // @ts-expect-error test client is not a PublicClient
-    client = new VaultClient(testClient);
-    // viemClient = testClient;
-  });
-
-  describe('getLatestVaults', () => {
-    it('should fetch latest vaults successfully', async () => {
-      const response = await client.getLatestVaults();
-      expect(response.success).toBe(true);
-      expect(response.status).toBe(200);
-      expect(response.data).toBeDefined();
-    });
-      
-
-    it('should handle errors gracefully', async () => {
-      global.fetch = jest.fn().mockImplementationOnce(() =>
-        Promise.resolve({
-          ok: false,
-          status: 500,
-        })
-      );
-
-      const response = await client.getLatestVaults();
-      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(6);
-
-        // 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(6);
-
-        // Verify the arguments
-        const [vault, amount0, amount1, min0, min1] = response.data.args;
-        expect(vault).toBe(testVaultAddress);
-        expect(amount0).toBe(amount0Desired);
-        expect(amount1).toBe(amount1Desired);
-        // Verify min amounts are calculated correctly with slippage
-        expect(min0).toBe(amount0Desired * BigInt(990) / BigInt(1000)); // 1% slippage
-        expect(min1).toBe(amount1Desired * BigInt(990) / BigInt(1000)); // 1% slippage
-      }
-    });
-
-    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(false);
-      expect(response.status).toBe(500);
-      expect(response.error).toBeDefined();
-    });
-
-    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(amount0Min);
-        expect(amount1MinArg).toBe(amount1Min);
-      }
-    });
-
-    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(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.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 = '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) {
-        // 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()
-      });
-
-      const walletClient = createWalletClient({
-        chain: polygon,
-        transport: http(),
-
-      });
-
-      // Initialize SteerClient with real clients
-      realSteerClient = new SteerClient({
-        environment: 'production',
-        client: publicClient,
-        walletClient: walletClient
-      });
-    });
-
-    it.only('should fetch all vaults with chainId filter successfully', async () => {
-      const filter = { chainId: 1, protocol: Protocol.Sushi }; // Polygon chainId
-      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
-      };
-      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;
-      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 () => {
-      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('Integration Tests with Real Chain Data', () => {
-    // Using Polygon for testing
-    let realSteerClient: SteerClient;
-
-    beforeAll(() => {
-      // Create real clients for blockchain interaction
-      const publicClient = createPublicClient({
-        chain: avalanche,
-        transport: http()
-      });
-
-      const walletClient = createWalletClient({
-        chain: avalanche,
-        transport: http()
-      });
-
-      // 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);
-      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);
-      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
-      );
-      
-      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
-      );
-      
-      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
-        );
-        
-        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);
-  });
-
-  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: avalanche,
-        transport: http()
-      });
-
-      const walletClient = createWalletClient({
-        chain: avalanche,
-        transport: http()
-      });
-      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}`
-        });
-
-        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: avalanche,
-          transport: http()
-        });
-
-        const walletClient = createWalletClient({
-          chain: avalanche,
-          transport: http(),
-        });
-
-        // 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);
-    });
-  });
-
- 
-});