@steerprotocol/sdk 1.26.0 → 1.28.0

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

@@ -0,0 +1,1011 @@
+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';
+
+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('should fetch all vaults with chainId filter successfully', async () => {
+      const filter = { chainId: 137 }; // 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.only('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);
+    });
+  });
+
+ 
+});