@steerprotocol/sdk 1.26.0 → 1.28.0

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

@@ -0,0 +1,612 @@
+import { Address, createPublicClient, createTestClient, http, parseEther, publicActions } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { foundry, polygon } from 'viem/chains';
+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
+  });
+
+  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('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'));
+    });
+  });
+
+  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('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');
+    });
+  });
+
+  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('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(true);
+      expect(result.data?.lpTokens).toBe(parseEther('1000000')); // Should get 1M LP tokens
+    });
+
+    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);
+    });
+  });
+});
+
+describe('getVaultReserves', () => {
+  let publicClient: any;
+  const mockVaultAddress = '0x1234567890123456789012345678901234567890' as `0x${string}`;
+  const mockToken0Address = '0x2345678901234567890123456789012345678901' as `0x${string}`;
+  const mockToken1Address = '0x3456789012345678901234567890123456789012' as `0x${string}`;
+
+  beforeEach(() => {
+    const testClient = createTestClient({
+      account: privateKeyToAccount("0x40199ba8875ac583658a7e936e16354f4bf1ea54dac73a2bc24fd17159ceb821"),
+      chain: foundry,
+      mode: 'anvil',
+      transport: http(),
+    }).extend(publicActions);
+
+    publicClient = testClient;
+  });
+
+  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);
+
+      expect(result.success).toBe(true);
+      expect(result.status).toBe(200);
+      expect(result.data).toEqual({
+        token0Balance: mockToken0Balance,
+        token1Balance: mockToken1Balance,
+        totalSupply: mockTotalSupply
+      });
+
+      // 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');
+    });
+  });
+
+  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);
+
+      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');
+    });
+  });
+});