@steerprotocol/sdk 1.30.8 → 1.31.0

package/src/__tests__/base/vault/single-asset/estimateLpTokens.test.ts

@@ -1,436 +1,107 @@
-import { Address, createPublicClient, createTestClient, http, parseEther, publicActions } from 'viem';
-import { privateKeyToAccount } from 'viem/accounts';
-import { foundry, polygon } from 'viem/chains';
+import { Address, parseEther } from 'viem';
 import { estimateLpTokens, getVaultReserves } from '../../../../base/vault/single-asset/estimateLpTokens.js';
 
-// Mock the vault ABI import
-jest.mock('../../../../const/deployments/abis', () => ({
-  abis: {
-    QuickSwapUniv3MultiPositionLiquidityManager: [
-      {
-        type: 'function',
-        name: 'totalSupply',
-        inputs: [],
-        outputs: [{ name: '', type: 'uint256' }],
-        stateMutability: 'view'
-      },
-      {
-        type: 'function',
-        name: 'token0',
-        inputs: [],
-        outputs: [{ name: '', type: 'address' }],
-        stateMutability: 'view'
-      },
-      {
-        type: 'function',
-        name: 'token1',
-        inputs: [],
-        outputs: [{ name: '', type: 'address' }],
-        stateMutability: 'view'
-      }
-    ]
-  }
-}));
-
 describe('estimateLpTokens', () => {
   let publicClient: any;
   const mockVaultAddress = '0xd6bac58d87772fa3a7400f15fd121b7edc30ce3c' as Address;
-  const mockToken0Address = '0x7ceb23fd6bc0add59e62ac25578270cff1b9f619';
-  const mockToken1Address = '0xc708d6f2153933daa50b2d0758955be0a93a8fec';
 
   beforeEach(() => {
-   publicClient = createPublicClient({chain: polygon, transport: http()});
-
-
-      // Initialize SteerClient with real clients
+    publicClient = {
+      getChainId: jest.fn().mockResolvedValue(137),
+      readContract: jest.fn(),
+    };
   });
 
-  describe('successful LP token estimation', () => {
-    it.only('should estimate LP tokens for token0 deposit with balanced swap', async () => {
-
-      const params = {
-        vault: mockVaultAddress as Address,
-        originalAssets: 10000n, // Depositing 100 token0
-        swapAmount: 47197431190251602083645n, // Swapping 50 token0
-        swapResult: {
-          amount0: -47197431190251602083645n, // 50 token0 out
-          amount1: 226901274916051693072080311n, // 50 token1 in
-          sqrtPriceX96After: BigInt('79228162514264337593543950336')
-        },
-        isToken0: true
-      };
-
-      const result = await estimateLpTokens(publicClient, params);
-
-      expect(result.success).toBe(true);
-      expect(result.status).toBe(200);
-      expect(result.data).toBeDefined();
-
-      // Final amounts should be:
-      // token0: 100 - 50 + 50 = 100 (but we get 50 because 50 was swapped out)
-      // token1: 0 + 50 = 50
-      const expectedFinalAmount0 = parseEther('50'); // 100 - 50 (swapped) + 50 (from swap, but this is already deducted)
-      const expectedFinalAmount1 = parseEther('50'); // 0 + 50 (from swap)
-
-      expect(result.data?.finalAmount0).toBe(expectedFinalAmount0);
-      expect(result.data?.finalAmount1).toBe(expectedFinalAmount1);
-
-      // LP tokens calculation: min(amount0 * totalSupply / reserve0, amount1 * totalSupply / reserve1)
-      // LP0 = 50 * 1000 / 500 = 100
-      // LP1 = 50 * 1000 / 500 = 100
-      // LP = min(100, 100) = 100
-      expect(result.data?.lpTokens).toBe(parseEther('100'));
-    });
-
-    it('should estimate LP tokens for token1 deposit', async () => {
-      const mockTotalSupply = parseEther('2000');
-      const mockToken0Balance = parseEther('1000');
-      const mockToken1Balance = parseEther('800');
-
-      publicClient.readContract = jest.fn()
-        .mockResolvedValueOnce(mockTotalSupply)
-        .mockResolvedValueOnce(mockToken0Address)
-        .mockResolvedValueOnce(mockToken1Address)
-        .mockResolvedValueOnce(mockToken0Balance)
-        .mockResolvedValueOnce(mockToken1Balance);
-
-      const params = {
-        vault: mockVaultAddress,
-        originalAssets: parseEther('80'), // Depositing 80 token1
-        swapAmount: parseEther('40'), // Swapping 40 token1
-        swapResult: {
-          amount0: parseEther('60'), // 60 token0 in
-          amount1: -parseEther('40'), // 40 token1 out
-          sqrtPriceX96After: BigInt('79228162514264337593543950336')
-        },
-        isToken0: false
-      };
-
-      const result = await estimateLpTokens(publicClient, params);
-
-      expect(result.success).toBe(true);
-
-      // Final amounts should be:
-      // token0: 0 + 60 = 60
-      // token1: 80 - 40 + 40 = 80 (but we get 40 because 40 was swapped out)
-      const expectedFinalAmount0 = parseEther('60');
-      const expectedFinalAmount1 = parseEther('40'); // 80 - 40 (swapped out)
-
-      expect(result.data?.finalAmount0).toBe(expectedFinalAmount0);
-      expect(result.data?.finalAmount1).toBe(expectedFinalAmount1);
-
-      // LP calculation: min(60 * 2000 / 1000, 40 * 2000 / 800) = min(120, 100) = 100
-      expect(result.data?.lpTokens).toBe(parseEther('100'));
-    });
-
-    it('should handle first deposit (zero total supply)', async () => {
-      const mockTotalSupply = BigInt('0'); // First deposit
-      const mockToken0Balance = BigInt('0');
-      const mockToken1Balance = BigInt('0');
-
-      publicClient.readContract = jest.fn()
-        .mockResolvedValueOnce(mockTotalSupply)
-        .mockResolvedValueOnce(mockToken0Address)
-        .mockResolvedValueOnce(mockToken1Address)
-        .mockResolvedValueOnce(mockToken0Balance)
-        .mockResolvedValueOnce(mockToken1Balance);
-
-      const params = {
-        vault: mockVaultAddress,
-        originalAssets: parseEther('100'),
-        swapAmount: parseEther('50'),
-        swapResult: {
-          amount0: -parseEther('50'),
-          amount1: parseEther('100'),
-          sqrtPriceX96After: BigInt('79228162514264337593543950336')
-        },
-        isToken0: true
-      };
-
-      const result = await estimateLpTokens(publicClient, params);
-
-      expect(result.success).toBe(true);
-
-      const expectedFinalAmount0 = parseEther('50');
-      const expectedFinalAmount1 = parseEther('100');
-
-      expect(result.data?.finalAmount0).toBe(expectedFinalAmount0);
-      expect(result.data?.finalAmount1).toBe(expectedFinalAmount1);
-
-      // For first deposit, LP = sqrt(amount0 * amount1) = sqrt(50 * 100) = sqrt(5000) ≈ 70.71
-      const expectedLpTokens = BigInt('70710678118654752440'); // sqrt(50 * 100 * 10^36)
-      expect(result.data?.lpTokens).toBe(expectedLpTokens);
-    });
-
-    it('should handle imbalanced pool scenario', async () => {
-      const mockTotalSupply = parseEther('1500');
-      const mockToken0Balance = parseEther('300'); // Much less token0
-      const mockToken1Balance = parseEther('1200'); // Much more token1
-
-      publicClient.readContract = jest.fn()
-        .mockResolvedValueOnce(mockTotalSupply)
-        .mockResolvedValueOnce(mockToken0Address)
-        .mockResolvedValueOnce(mockToken1Address)
-        .mockResolvedValueOnce(mockToken0Balance)
-        .mockResolvedValueOnce(mockToken1Balance);
-
-      const params = {
-        vault: mockVaultAddress,
-        originalAssets: parseEther('100'),
-        swapAmount: parseEther('80'), // Large swap due to imbalance
-        swapResult: {
-          amount0: -parseEther('80'),
-          amount1: parseEther('40'), // Lower amount due to imbalanced pool
-          sqrtPriceX96After: BigInt('79228162514264337593543950336')
-        },
-        isToken0: true
-      };
-
-      const result = await estimateLpTokens(publicClient, params);
-
-      expect(result.success).toBe(true);
-
-      const expectedFinalAmount0 = parseEther('20'); // 100 - 80 (swapped out)
-      const expectedFinalAmount1 = parseEther('40'); // 0 + 40 (from swap)
-
-      expect(result.data?.finalAmount0).toBe(expectedFinalAmount0);
-      expect(result.data?.finalAmount1).toBe(expectedFinalAmount1);
-
-      // LP calculation: min(20 * 1500 / 300, 40 * 1500 / 1200) = min(100, 50) = 50
-      expect(result.data?.lpTokens).toBe(parseEther('50'));
-    });
-
-    it('should handle small amounts', async () => {
-      const mockTotalSupply = parseEther('1000000'); // Large pool
-      const mockToken0Balance = parseEther('500000');
-      const mockToken1Balance = parseEther('500000');
-
-      publicClient.readContract = jest.fn()
-        .mockResolvedValueOnce(mockTotalSupply)
-        .mockResolvedValueOnce(mockToken0Address)
-        .mockResolvedValueOnce(mockToken1Address)
-        .mockResolvedValueOnce(mockToken0Balance)
-        .mockResolvedValueOnce(mockToken1Balance);
-
-      const smallAmount = BigInt('1000000000000000'); // 0.001 tokens
-      const params = {
-        vault: mockVaultAddress,
-        originalAssets: smallAmount * 2n,
-        swapAmount: smallAmount,
-        swapResult: {
-          amount0: -smallAmount,
-          amount1: smallAmount,
-          sqrtPriceX96After: BigInt('79228162514264337593543950336')
-        },
-        isToken0: true
-      };
-
-      const result = await estimateLpTokens(publicClient, params);
-
-      expect(result.success).toBe(true);
-      expect(result.data?.finalAmount0).toBe(smallAmount);
-      expect(result.data?.finalAmount1).toBe(smallAmount);
-
-      // Should get proportional LP tokens
-      const expectedLpTokens = smallAmount * 2n; // 2 * 0.001 = 0.002 LP
-      expect(result.data?.lpTokens).toBe(expectedLpTokens);
+  it('estimates LP tokens for token0 deposit', async () => {
+    publicClient.readContract
+      .mockResolvedValueOnce(parseEther('1000'))
+      .mockResolvedValueOnce([parseEther('500'), parseEther('500')])
+      .mockResolvedValueOnce([parseEther('100'), parseEther('50'), parseEther('50')]);
+
+    const result = await estimateLpTokens(publicClient, {
+      vault: mockVaultAddress,
+      originalAssets: parseEther('100'),
+      swapAmount: parseEther('50'),
+      swapResult: {
+        amount0: -parseEther('50'),
+        amount1: parseEther('50'),
+        sqrtPriceX96After: 0n,
+      },
+      isToken0: true,
     });
 
-    it('should handle zero reserves (edge case)', async () => {
-      const mockTotalSupply = parseEther('1000');
-      const mockToken0Balance = BigInt('0'); // Zero reserve
-      const mockToken1Balance = parseEther('1000');
-
-      publicClient.readContract = jest.fn()
-        .mockResolvedValueOnce(mockTotalSupply)
-        .mockResolvedValueOnce(mockToken0Address)
-        .mockResolvedValueOnce(mockToken1Address)
-        .mockResolvedValueOnce(mockToken0Balance)
-        .mockResolvedValueOnce(mockToken1Balance);
-
-      const params = {
-        vault: mockVaultAddress,
-        originalAssets: parseEther('100'),
-        swapAmount: parseEther('50'),
-        swapResult: {
-          amount0: -parseEther('50'),
-          amount1: parseEther('50')
-        },
-        isToken0: true
-      };
-
-      const result = await estimateLpTokens(publicClient, params);
-
-      expect(result.success).toBe(true);
-
-      // With zero token0 reserve, LP from token0 should be 0
-      // LP = min(0, 50 * 1000 / 1000) = min(0, 50) = 0
-      expect(result.data?.lpTokens).toBe(BigInt('0'));
-    });
+    expect(result.success).toBe(true);
+    expect(result.status).toBe(200);
+    expect(result.data?.lpTokens).toBe(parseEther('100'));
+    expect(result.data?.finalAmount0).toBe(parseEther('50'));
+    expect(result.data?.finalAmount1).toBe(parseEther('50'));
+    expect(publicClient.getChainId).toHaveBeenCalledTimes(1);
   });
 
-  describe('error handling', () => {
-    it('should handle contract call errors', async () => {
-      publicClient.readContract = jest.fn().mockRejectedValue(new Error('Contract call failed'));
-
-      const params = {
-        vault: mockVaultAddress,
-        originalAssets: parseEther('100'),
-        swapAmount: parseEther('50'),
-        swapResult: {
-          amount0: -parseEther('50'),
-          amount1: parseEther('50')
-        },
-        isToken0: true
-      };
-
-      const result = await estimateLpTokens(publicClient, params);
-
-      expect(result.success).toBe(false);
-      expect(result.status).toBe(500);
-      expect(result.error).toBe('Contract call failed');
-    });
-
-    it('should handle network errors', async () => {
-      publicClient.readContract = jest.fn().mockRejectedValue(new Error('Network error'));
-
-      const params = {
-        vault: mockVaultAddress,
-        originalAssets: parseEther('100'),
-        swapAmount: parseEther('50'),
-        swapResult: {
-          amount0: -parseEther('50'),
-          amount1: parseEther('50')
-        },
-        isToken0: true
-      };
-
-      const result = await estimateLpTokens(publicClient, params);
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Network error');
+  it('estimates LP tokens for token1 deposit', async () => {
+    publicClient.readContract
+      .mockResolvedValueOnce(parseEther('1000'))
+      .mockResolvedValueOnce([parseEther('400'), parseEther('600')])
+      .mockResolvedValueOnce([parseEther('80'), parseEther('20'), parseEther('60')]);
+
+    const result = await estimateLpTokens(publicClient, {
+      vault: mockVaultAddress,
+      originalAssets: parseEther('100'),
+      swapAmount: parseEther('40'),
+      swapResult: {
+        amount0: parseEther('20'),
+        amount1: -parseEther('40'),
+        sqrtPriceX96After: 0n,
+      },
+      isToken0: false,
     });
 
-    it('should handle invalid vault address', async () => {
-      publicClient.readContract = jest.fn().mockRejectedValue(
-        new Error('Contract not found')
-      );
-
-      const params = {
-        vault: '0x0000000000000000000000000000000000000000' as Address,
-        originalAssets: parseEther('100'),
-        swapAmount: parseEther('50'),
-        swapResult: {
-          amount0: -parseEther('50'),
-          amount1: parseEther('50')
-        },
-        isToken0: true
-      };
-
-      const result = await estimateLpTokens(publicClient, params);
-
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Contract not found');
-    });
+    expect(result.success).toBe(true);
+    expect(result.data?.lpTokens).toBe(parseEther('80'));
+    expect(result.data?.finalAmount0).toBe(parseEther('20'));
+    expect(result.data?.finalAmount1).toBe(parseEther('60'));
   });
 
-  describe('edge cases and validations', () => {
-    it('should handle negative swap amounts correctly', async () => {
-      const mockTotalSupply = parseEther('1000');
-      const mockToken0Balance = parseEther('500');
-      const mockToken1Balance = parseEther('500');
-
-      publicClient.readContract = jest.fn()
-        .mockResolvedValueOnce(mockTotalSupply)
-        .mockResolvedValueOnce(mockToken0Address)
-        .mockResolvedValueOnce(mockToken1Address)
-        .mockResolvedValueOnce(mockToken0Balance)
-        .mockResolvedValueOnce(mockToken1Balance);
-
-      const params = {
-        vault: mockVaultAddress,
-        originalAssets: parseEther('100'),
-        swapAmount: parseEther('50'),
-        swapResult: {
-          amount0: parseEther('50'), // Positive amount0 (receiving)
-          amount1: -parseEther('25') // Negative amount1 (giving)
-        },
-        isToken0: false // Depositing token1, swapping to token0
-      };
-
-      const result = await estimateLpTokens(publicClient, params);
-
-      expect(result.success).toBe(true);
-
-      // For token1 deposit: finalAmount0 = 0 + |amount0| = 50
-      // finalAmount1 = originalAssets - swapAmount + |amount1| = 100 - 50 + 25 = 75
-      expect(result.data?.finalAmount0).toBe(parseEther('50'));
-      expect(result.data?.finalAmount1).toBe(parseEther('75'));
+  it('returns failure when on-chain reads fail', async () => {
+    publicClient.readContract.mockRejectedValue(new Error('Contract call failed'));
+
+    const result = await estimateLpTokens(publicClient, {
+      vault: mockVaultAddress,
+      originalAssets: parseEther('100'),
+      swapAmount: parseEther('50'),
+      swapResult: {
+        amount0: -parseEther('50'),
+        amount1: parseEther('50'),
+        sqrtPriceX96After: 0n,
+      },
+      isToken0: true,
     });
 
-    it('should handle very large numbers', async () => {
-      const largeSupply = parseEther('1000000000'); // 1 billion
-      const largeBalance = parseEther('500000000'); // 500 million
-
-      publicClient.readContract = jest.fn()
-        .mockResolvedValueOnce(largeSupply)
-        .mockResolvedValueOnce(mockToken0Address)
-        .mockResolvedValueOnce(mockToken1Address)
-        .mockResolvedValueOnce(largeBalance)
-        .mockResolvedValueOnce(largeBalance);
-
-      const params = {
-        vault: mockVaultAddress,
-        originalAssets: parseEther('1000000'), // 1 million
-        swapAmount: parseEther('500000'), // 500k
-        swapResult: {
-          amount0: -parseEther('500000'),
-          amount1: parseEther('500000')
-        },
-        isToken0: true
-      };
-
-      const result = await estimateLpTokens(publicClient, params);
+    expect(result.success).toBe(false);
+    expect(result.status).toBe(500);
+    expect(result.error).toBe('Contract call failed');
+  });
 
-      expect(result.success).toBe(true);
-      expect(result.data?.lpTokens).toBe(parseEther('1000000')); // Should get 1M LP tokens
+  it('returns failure when helper getShares reverts', async () => {
+    publicClient.readContract
+      .mockResolvedValueOnce(parseEther('1000'))
+      .mockResolvedValueOnce([parseEther('500'), parseEther('500')])
+      .mockRejectedValueOnce(new Error('getShares reverted'));
+
+    const result = await estimateLpTokens(publicClient, {
+      vault: mockVaultAddress,
+      originalAssets: parseEther('100'),
+      swapAmount: parseEther('50'),
+      swapResult: {
+        amount0: -parseEther('50'),
+        amount1: parseEther('50'),
+        sqrtPriceX96After: 0n,
+      },
+      isToken0: true,
     });
 
-    it('should handle precision with small decimals', async () => {
-      const mockTotalSupply = BigInt('1000000000000000000000'); // 1000 tokens with 18 decimals
-      const mockToken0Balance = BigInt('500000000000000000000'); // 500 tokens
-      const mockToken1Balance = BigInt('500000000000000000000'); // 500 tokens
-
-      publicClient.readContract = jest.fn()
-        .mockResolvedValueOnce(mockTotalSupply)
-        .mockResolvedValueOnce(mockToken0Address)
-        .mockResolvedValueOnce(mockToken1Address)
-        .mockResolvedValueOnce(mockToken0Balance)
-        .mockResolvedValueOnce(mockToken1Balance);
-
-      // Very small amounts to test precision
-      const params = {
-        vault: mockVaultAddress,
-        originalAssets: BigInt('1000000000000000'), // 0.001 tokens
-        swapAmount: BigInt('500000000000000'), // 0.0005 tokens
-        swapResult: {
-          amount0: -BigInt('500000000000000'),
-          amount1: BigInt('500000000000000')
-        },
-        isToken0: true
-      };
-
-      const result = await estimateLpTokens(publicClient, params);
-
-      expect(result.success).toBe(true);
-      expect(result.data?.lpTokens).toBeGreaterThan(BigInt('0'));
-      
-      // Should maintain precision
-      const expectedFinalAmount0 = BigInt('500000000000000');
-      const expectedFinalAmount1 = BigInt('500000000000000');
-      expect(result.data?.finalAmount0).toBe(expectedFinalAmount0);
-      expect(result.data?.finalAmount1).toBe(expectedFinalAmount1);
-    });
+    expect(result.success).toBe(false);
+    expect(result.error).toBe('getShares reverted');
   });
 });
 
@@ -441,172 +112,36 @@ describe('getVaultReserves', () => {
   const mockToken1Address = '0x3456789012345678901234567890123456789012' as `0x${string}`;
 
   beforeEach(() => {
-    const testClient = createTestClient({
-      account: privateKeyToAccount("0x40199ba8875ac583658a7e936e16354f4bf1ea54dac73a2bc24fd17159ceb821"),
-      chain: foundry,
-      mode: 'anvil',
-      transport: http(),
-    }).extend(publicActions);
-
-    publicClient = testClient;
+    publicClient = {
+      readContract: jest.fn(),
+    };
   });
 
-  describe('successful reserve retrieval', () => {
-    it('should get vault reserves correctly', async () => {
-      const mockTotalSupply = parseEther('1000');
-      const mockToken0Balance = parseEther('400');
-      const mockToken1Balance = parseEther('600');
-
-      publicClient.readContract = jest.fn()
-        .mockResolvedValueOnce(mockTotalSupply) // totalSupply
-        .mockResolvedValueOnce(mockToken0Address) // token0 address
-        .mockResolvedValueOnce(mockToken1Address) // token1 address
-        .mockResolvedValueOnce(mockToken0Balance) // token0 balanceOf
-        .mockResolvedValueOnce(mockToken1Balance); // token1 balanceOf
-
-      const result = await getVaultReserves(publicClient, mockVaultAddress);
+  it('gets vault reserves correctly', async () => {
+    publicClient.readContract
+      .mockResolvedValueOnce(parseEther('1000'))
+      .mockResolvedValueOnce(mockToken0Address)
+      .mockResolvedValueOnce(mockToken1Address)
+      .mockResolvedValueOnce(parseEther('400'))
+      .mockResolvedValueOnce(parseEther('600'));
 
-      expect(result.success).toBe(true);
-      expect(result.status).toBe(200);
-      expect(result.data).toEqual({
-        token0Balance: mockToken0Balance,
-        token1Balance: mockToken1Balance,
-        totalSupply: mockTotalSupply
-      });
+    const result = await getVaultReserves(publicClient, mockVaultAddress);
 
-      // Verify correct sequence of contract calls
-      expect(publicClient.readContract).toHaveBeenCalledTimes(5);
-    });
-
-    it('should handle empty vault', async () => {
-      const mockTotalSupply = BigInt('0');
-      const mockToken0Balance = BigInt('0');
-      const mockToken1Balance = BigInt('0');
-
-      publicClient.readContract = jest.fn()
-        .mockResolvedValueOnce(mockTotalSupply)
-        .mockResolvedValueOnce(mockToken0Address)
-        .mockResolvedValueOnce(mockToken1Address)
-        .mockResolvedValueOnce(mockToken0Balance)
-        .mockResolvedValueOnce(mockToken1Balance);
-
-      const result = await getVaultReserves(publicClient, mockVaultAddress);
-
-      expect(result.success).toBe(true);
-      expect(result.data?.totalSupply).toBe(BigInt('0'));
-      expect(result.data?.token0Balance).toBe(BigInt('0'));
-      expect(result.data?.token1Balance).toBe(BigInt('0'));
-    });
-
-    it('should handle very large reserves', async () => {
-      const largeTotalSupply = parseEther('1000000000'); // 1 billion
-      const largeToken0Balance = parseEther('500000000');
-      const largeToken1Balance = parseEther('750000000');
-
-      publicClient.readContract = jest.fn()
-        .mockResolvedValueOnce(largeTotalSupply)
-        .mockResolvedValueOnce(mockToken0Address)
-        .mockResolvedValueOnce(mockToken1Address)
-        .mockResolvedValueOnce(largeToken0Balance)
-        .mockResolvedValueOnce(largeToken1Balance);
-
-      const result = await getVaultReserves(publicClient, mockVaultAddress);
-
-      expect(result.success).toBe(true);
-      expect(result.data?.totalSupply).toBe(largeTotalSupply);
-      expect(result.data?.token0Balance).toBe(largeToken0Balance);
-      expect(result.data?.token1Balance).toBe(largeToken1Balance);
-    });
-  });
-
-  describe('error handling', () => {
-    it('should handle vault contract errors', async () => {
-      publicClient.readContract = jest.fn().mockRejectedValue(new Error('Vault contract error'));
-
-      const result = await getVaultReserves(publicClient, mockVaultAddress);
-
-      expect(result.success).toBe(false);
-      expect(result.status).toBe(500);
-      expect(result.error).toBe('Vault contract error');
-    });
-
-    it('should handle token contract errors', async () => {
-      publicClient.readContract = jest.fn()
-        .mockResolvedValueOnce(parseEther('1000')) // totalSupply succeeds
-        .mockResolvedValueOnce(mockToken0Address) // token0 address succeeds
-        .mockResolvedValueOnce(mockToken1Address) // token1 address succeeds
-        .mockRejectedValue(new Error('Token contract error')); // balanceOf fails
-
-      const result = await getVaultReserves(publicClient, mockVaultAddress);
-
-      expect(result.success).toBe(false);
-      expect(result.error).toBe('Token contract error');
-    });
-
-    it('should handle invalid vault address', async () => {
-      const invalidVault = '0x0000000000000000000000000000000000000000' as `0x${string}`;
-      
-      publicClient.readContract = jest.fn().mockRejectedValue(
-        new Error('Contract not found')
-      );
-
-      const result = await getVaultReserves(publicClient, invalidVault);
-
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Contract not found');
+    expect(result.success).toBe(true);
+    expect(result.data).toEqual({
+      token0Balance: parseEther('400'),
+      token1Balance: parseEther('600'),
+      totalSupply: parseEther('1000'),
     });
   });
 
-  describe('integration scenarios', () => {
-    it('should handle realistic vault data', async () => {
-      // Simulate a realistic USDC/ETH vault
-      const mockTotalSupply = parseEther('50000'); // 50k LP tokens
-      const mockUsdcBalance = BigInt('25000000000'); // 25k USDC (6 decimals)
-      const mockEthBalance = parseEther('12.5'); // 12.5 ETH (18 decimals)
-
-      publicClient.readContract = jest.fn()
-        .mockResolvedValueOnce(mockTotalSupply)
-        .mockResolvedValueOnce(mockToken0Address) // USDC
-        .mockResolvedValueOnce(mockToken1Address) // ETH
-        .mockResolvedValueOnce(mockUsdcBalance)
-        .mockResolvedValueOnce(mockEthBalance);
+  it('returns failure when vault calls fail', async () => {
+    publicClient.readContract.mockRejectedValue(new Error('Vault contract error'));
 
-      const result = await getVaultReserves(publicClient, mockVaultAddress);
+    const result = await getVaultReserves(publicClient, mockVaultAddress);
 
-      expect(result.success).toBe(true);
-      expect(result.data?.token0Balance).toBe(mockUsdcBalance);
-      expect(result.data?.token1Balance).toBe(mockEthBalance);
-      expect(result.data?.totalSupply).toBe(mockTotalSupply);
-    });
-
-    it('should handle sequential calls correctly', async () => {
-      const calls = [
-        parseEther('1000'), // totalSupply
-        mockToken0Address, // token0
-        mockToken1Address, // token1
-        parseEther('500'), // token0 balance
-        parseEther('500') // token1 balance
-      ];
-
-      publicClient.readContract = jest.fn()
-        .mockResolvedValueOnce(calls[0])
-        .mockResolvedValueOnce(calls[1])
-        .mockResolvedValueOnce(calls[2])
-        .mockResolvedValueOnce(calls[3])
-        .mockResolvedValueOnce(calls[4]);
-
-      const result = await getVaultReserves(publicClient, mockVaultAddress);
-
-      expect(result.success).toBe(true);
-      expect(publicClient.readContract).toHaveBeenCalledTimes(5);
-      
-      // Verify the correct ABI functions were called
-      const readContractCalls = (publicClient.readContract as jest.Mock).mock.calls;
-      expect(readContractCalls[0][0].functionName).toBe('totalSupply');
-      expect(readContractCalls[1][0].functionName).toBe('token0');
-      expect(readContractCalls[2][0].functionName).toBe('token1');
-      expect(readContractCalls[3][0].functionName).toBe('balanceOf');
-      expect(readContractCalls[4][0].functionName).toBe('balanceOf');
-    });
+    expect(result.success).toBe(false);
+    expect(result.status).toBe(500);
+    expect(result.error).toBe('Vault contract error');
   });
-}); 
+});