@steerprotocol/sdk 1.26.0 → 1.28.0

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

@@ -0,0 +1,324 @@
+import { createPublicClient, http } from 'viem';
+import { polygon } from 'viem/chains';
+import { calculateLimitPrice, getPoolSlot0 } from '../../../../base/vault/single-asset/calculateLimitPrice.js';
+import { AMMType } from '../../../../base/vault/single-asset/types.js';
+
+// Mock the UniswapV3PoolABI import
+
+describe('calculateLimitPrice', () => {
+  let publicClient: any;
+  const mockPoolAddress = '0xba2d4a755982eefbd24c52cea01c9ff5d3813bd4';
+  const mockToken0 = '0x7ceb23fd6bc0add59e62ac25578270cff1b9f619'; // USDC on Polygon
+  const mockToken1 = '0xd1a718f77ab5d22e3955050658d7f65ae857a85e'; // WETH on Polygon
+
+
+
+  beforeAll(() => { // Create real clients for blockchain interaction
+      publicClient = createPublicClient({chain: polygon, transport: http()});
+
+
+      // Initialize SteerClient with real clients
+  });
+
+  describe('successful calculations', () => {
+    it.only('should calculate limit price for token0 → token1 swap (zeroForOne: true)', async () => {
+      const result = await calculateLimitPrice(publicClient, {
+        pool: mockPoolAddress,
+        slippageBP: 500, // 5% slippage
+        zeroForOne: true,
+        ammType: AMMType.UniswapV3,
+        token0: mockToken0,
+        token1: mockToken1
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.status).toBe(200);
+      expect(result.data).toBeDefined();
+
+      // For zeroForOne = true, we want a lower limit (subtract slippage)
+      // Expected: currentSqrtPrice * 9500 / 10000
+      // const expectedSqrtPrice = (currentSqrtPrice * 9500n) / 10000/n;
+      // expect(result.data).toBe(expectedSqrtPrice);
+    });
+
+    it('should calculate limit price for token1 → token0 swap (zeroForOne: false)', async () => {
+
+
+      const result = await calculateLimitPrice(publicClient, {
+        pool: mockPoolAddress,
+        slippageBP: 300, // 3% slippage
+        zeroForOne: false,
+        ammType: AMMType.UniswapV3,
+        token0: mockToken0,
+        token1: mockToken1
+      });
+
+      expect(result.success).toBe(true);
+      
+      // For zeroForOne = false, we want an upper limit (add slippage)
+      // Expected: currentSqrtPrice * 10300 / 10000
+    });
+
+    it('should handle different slippage values', async () => {
+      const currentSqrtPrice = BigInt('158456325028528675187087900672'); // ~4.0 price
+      const mockSlot0 = [currentSqrtPrice, 0, 0, 0, 0, 0, true];
+
+      publicClient.readContract = jest.fn()
+        .mockResolvedValueOnce(mockSlot0) // For slot0 call
+        .mockResolvedValueOnce(18) // For decimals call
+        .mockResolvedValueOnce(mockSlot0) // For slot0 call
+        .mockResolvedValueOnce(18) // For decimals call
+        .mockResolvedValueOnce(mockSlot0) // For slot0 call
+        .mockResolvedValueOnce(18) // For decimals call
+        .mockResolvedValueOnce(mockSlot0) // For slot0 call
+        .mockResolvedValueOnce(18); // For decimals call
+
+      // Test different slippage values
+      const slippageTests = [
+        { slippageBP: 100 }, // 1%
+        { slippageBP: 500 }, // 5%
+        { slippageBP: 1000 }, // 10%
+        { slippageBP: 50 }, // 0.5%
+      ];
+
+      for (const test of slippageTests) {
+        const result = await calculateLimitPrice(publicClient, {
+          pool: mockPoolAddress,
+          slippageBP: test.slippageBP,
+          zeroForOne: true,
+          ammType: AMMType.UniswapV3,
+          token0: mockToken0,
+          token1: mockToken1
+        });
+
+        expect(result.success).toBe(true);
+      }
+    });
+
+    it('should handle high price scenarios', async () => {
+      const highSqrtPrice = BigInt('2505414483750479251993726816896'); // Very high price
+      const mockSlot0 = [highSqrtPrice, 0, 0, 0, 0, 0, true];
+
+      publicClient.readContract = jest.fn()
+        .mockResolvedValueOnce(mockSlot0) // For slot0 call
+        .mockResolvedValueOnce(18); // For decimals call
+
+      const result = await calculateLimitPrice(publicClient, {
+        pool: mockPoolAddress,
+        slippageBP: 500,
+        zeroForOne: false, // Adding slippage for upper limit
+        ammType: AMMType.UniswapV3,
+        token0: mockToken0,
+        token1: mockToken1
+      });
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should handle low price scenarios', async () => {
+      const lowSqrtPrice = BigInt('100000000000000000000000'); // Very low price
+      const mockSlot0 = [lowSqrtPrice, 0, 0, 0, 0, 0, true];
+
+      publicClient.readContract = jest.fn()
+        .mockResolvedValueOnce(mockSlot0) // For slot0 call
+        .mockResolvedValueOnce(18); // For decimals call
+
+      const result = await calculateLimitPrice(publicClient, {
+        pool: mockPoolAddress,
+        slippageBP: 1000,
+        zeroForOne: true,
+        ammType: AMMType.UniswapV3,
+        token0: mockToken0,
+        token1: mockToken1
+      });
+
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe('error handling', () => {
+    it('should reject unsupported AMM types', async () => {
+      const result = await calculateLimitPrice(publicClient, {
+        pool: mockPoolAddress,
+        slippageBP: 500,
+        zeroForOne: true,
+        ammType: AMMType.Algebra,
+        token0: mockToken0,
+        token1: mockToken1
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.status).toBe(500);
+      expect(result.error).toContain('AMM type 1 not yet supported');
+    });
+
+    it('should handle contract read failures', async () => {
+      publicClient.readContract = jest.fn().mockRejectedValue(new Error('Contract read failed'));
+
+      const result = await calculateLimitPrice(publicClient, {
+        pool: mockPoolAddress,
+        slippageBP: 500,
+        zeroForOne: true,
+        ammType: AMMType.UniswapV3,
+        token0: mockToken0,
+        token1: mockToken1
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.status).toBe(500);
+      expect(result.error).toContain('Failed to calculate limit price');
+    });
+
+    it('should handle zero slippage', async () => {
+      const result = await calculateLimitPrice(publicClient, {
+        pool: mockPoolAddress,
+        slippageBP: 0,
+        zeroForOne: true,
+        ammType: AMMType.UniswapV3,
+        token0: mockToken0,
+        token1: mockToken1
+      });
+
+      expect(result.success).toBe(true);
+    });
+
+    it('should handle invalid pool address', async () => {
+      publicClient.readContract = jest.fn().mockRejectedValue(new Error('Invalid address'));
+
+      const result = await calculateLimitPrice(publicClient, {
+        pool: '0x0000000000000000000000000000000000000000',
+        slippageBP: 500,
+        zeroForOne: true,
+        ammType: AMMType.UniswapV3,
+        token0: mockToken0,
+        token1: mockToken1
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.status).toBe(500);
+    });
+  });
+
+  describe('integration tests', () => {
+    it('should test calculateLimitPrice with realistic slippage scenarios', async () => {
+      // Test with real pool if available
+      try {
+        const result = await calculateLimitPrice(publicClient, {
+          pool: mockPoolAddress,
+          slippageBP: 500, // 5% slippage
+          zeroForOne: true,
+          ammType: AMMType.UniswapV3,
+          token0: mockToken0,
+          token1: mockToken1
+        });
+
+        if (result.success) {
+          expect(result.data).toBeDefined();
+          expect(typeof result.data).toBe('bigint');
+        }
+      } catch (error) {
+        // If network unavailable, test should still pass
+        console.log('Network test skipped:', error);
+      }
+    });
+
+    it('should test different scenarios', async () => {
+      const scenarios = [
+        { slippageBP: 50, zeroForOne: true },   // 0.5% slippage, token0 → token1
+        { slippageBP: 100, zeroForOne: false }, // 1% slippage, token1 → token0
+        { slippageBP: 1000, zeroForOne: true }, // 10% slippage, token0 → token1
+      ];
+
+      for (const scenario of scenarios) {
+        try {
+          const result = await calculateLimitPrice(publicClient, {
+            pool: mockPoolAddress,
+            slippageBP: scenario.slippageBP,
+            zeroForOne: scenario.zeroForOne,
+            ammType: AMMType.UniswapV3,
+            token0: mockToken0,
+            token1: mockToken1
+          });
+
+          if (result.success) {
+            expect(result.data).toBeDefined();
+          }
+        } catch (error) {
+          console.log(`Scenario ${JSON.stringify(scenario)} failed:`, error);
+        }
+      }
+    });
+
+    it('should handle both swap directions', async () => {
+      const directions = [true, false]; // zeroForOne values
+
+      for (const zeroForOne of directions) {
+        try {
+          const result = await calculateLimitPrice(publicClient, {
+            pool: mockPoolAddress,
+            slippageBP: 300,
+            zeroForOne,
+            ammType: AMMType.UniswapV3,
+            token0: mockToken0,
+            token1: mockToken1
+          });
+
+          if (result.success) {
+            expect(result.data).toBeDefined();
+            expect(typeof result.data).toBe('bigint');
+          }
+        } catch (error) {
+          console.log(`Direction ${zeroForOne} failed:`, error);
+        }
+      }
+    });
+  });
+
+  describe('getPoolSlot0', () => {
+    it('should return pool slot0 data for UniswapV3', async () => {
+      const mockSlot0 = [
+        BigInt('158456325028528675187087900672'), // sqrtPriceX96
+        12345, // tick
+        1, // observationIndex
+        100, // observationCardinality
+        100, // observationCardinalityNext
+        0, // feeProtocol
+        true // unlocked
+      ];
+
+      publicClient.readContract = jest.fn().mockResolvedValue(mockSlot0);
+
+      const result = await getPoolSlot0(publicClient, mockPoolAddress, AMMType.UniswapV3);
+
+      expect(result.success).toBe(true);
+      expect(result.status).toBe(200);
+      expect(result.data).toEqual({
+        sqrtPriceX96: BigInt('158456325028528675187087900672'),
+        tick: 12345,
+        observationIndex: 1,
+        observationCardinality: 100,
+        observationCardinalityNext: 100,
+        feeProtocol: 0,
+        unlocked: true
+      });
+    });
+
+    it('should reject unsupported AMM types for slot0', async () => {
+      const result = await getPoolSlot0(publicClient, mockPoolAddress, AMMType.Algebra);
+
+      expect(result.success).toBe(false);
+      expect(result.status).toBe(500);
+      expect(result.error).toContain('AMM type 1 not yet supported');
+    });
+
+    it('should handle contract read failures for slot0', async () => {
+      publicClient.readContract = jest.fn().mockRejectedValue(new Error('Contract read failed'));
+
+      const result = await getPoolSlot0(publicClient, mockPoolAddress, AMMType.UniswapV3);
+
+      expect(result.success).toBe(false);
+      expect(result.status).toBe(500);
+      expect(result.error).toContain('Failed to get pool slot0 data');
+    });
+  });
+}); 

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

@@ -0,0 +1,322 @@
+import {
+    createPublicClient,
+    http,
+    parseEther
+} from 'viem';
+import { polygon } from 'viem/chains';
+import { calculateSwapAmount } from '../../../../base/vault/single-asset/calculateSwapAmount.js';
+import { AMMType } from '../../../../base/vault/single-asset/types.js';
+
+// Mock the singleTokenDepositAbi import
+jest.mock('../../../../const/abis/singleTokenDeposit', () => ({
+    singleTokenDepositAbi: [
+        {
+            type: 'function',
+            name: 'calculateSwapAmount',
+            inputs: [
+                {
+                    name: 'depositAmount',
+                    type: 'uint256'
+                },
+                {
+                    name: 'isToken0',
+                    type: 'bool'
+                },
+                {
+                    name: 'vault',
+                    type: 'address'
+                },
+                {
+                    name: 'pool',
+                    type: 'address'
+                }, {
+                    name: 'ammType',
+                    type: 'uint8'
+                }
+            ],
+            outputs: [
+                {
+                    name: '',
+                    type: 'uint256'
+                }, {
+                    name: '',
+                    type: 'uint160'
+                }
+            ],
+            stateMutability: 'view'
+        }
+    ]
+}));
+
+describe('calculateSwapAmount', () => {
+    let publicClient: any;
+    const mockVaultAddress = '0xea102e191687b47d23f1239c6bca03389fd98a32';
+    const mockPoolAddress = '0xba2d4a755982eefbd24c52cea01c9ff5d3813bd4';
+    const mockContractAddress = '0x9903C4ED61A71d0d5C322097adfF752d6339F871';
+
+
+    beforeAll(() => { // Create real clients for blockchain interaction
+        publicClient = createPublicClient({chain: polygon, transport: http()});
+
+        // Initialize SteerClient with real clients
+    });
+    describe('successful calculations', () => {
+        it.only('should calculate swap amount for token0 deposit', async () => {
+
+            const result = await calculateSwapAmount(publicClient, {
+                depositAmount: parseEther('100000'),
+                isToken0: true,
+                vault: mockVaultAddress,
+                pool: mockPoolAddress,
+                ammType: AMMType.UniswapV3,
+                singleAssetDepositContract: mockContractAddress
+            });
+
+            expect(result.success).toBe(true);
+            expect(result.status).toBe(200);
+            // expect(result.data).toEqual({swapAmount: parseEther('25'), sqrtPrice: BigInt('1000000000000000000')});
+
+            // Verify contract call parameters
+        });
+
+        it('should calculate swap amount for token1 deposit', async () => {
+
+
+            const result = await calculateSwapAmount(publicClient, {
+                depositAmount: parseEther('100000'),
+                isToken0: false,
+                vault: mockVaultAddress,
+                pool: mockPoolAddress,
+                ammType: AMMType.UniswapV3,
+                singleAssetDepositContract: mockContractAddress
+            });
+
+            expect(result.success).toBe(true);
+
+            // Verify the isToken0 parameter is false
+            // expect(publicClient.readContract).toHaveBeenCalledWith(expect.objectContaining({
+            //     args: expect.arrayContaining([false])
+            // }));
+        });
+
+        it('should handle different AMM types', async () => {
+            const mockSwapAmount = parseEther('20');
+            const mockSqrtPrice = BigInt('1500000000000000000');
+
+            publicClient.readContract = jest.fn().mockResolvedValue([mockSwapAmount, mockSqrtPrice]);
+
+            const result = await calculateSwapAmount(publicClient, {
+                depositAmount: parseEther('50'),
+                isToken0: true,
+                vault: mockVaultAddress,
+                pool: mockPoolAddress,
+                ammType: AMMType.Algebra,
+                singleAssetDepositContract: mockContractAddress
+            });
+
+            expect(result.success).toBe(true);
+            expect(publicClient.readContract).toHaveBeenCalledWith(expect.objectContaining({
+                args: expect.arrayContaining(
+                    [AMMType.Algebra]
+                )
+            }));
+        });
+
+        it('should handle small deposit amounts', async () => {
+            const mockSwapAmount = BigInt('1000000000000000'); // 0.001 ETH
+            const mockSqrtPrice = BigInt('1000000000000000000');
+
+            publicClient.readContract = jest.fn().mockResolvedValue([mockSwapAmount, mockSqrtPrice]);
+
+            const result = await calculateSwapAmount(publicClient, {
+                depositAmount: BigInt('10000000000000000'), // 0.01 ETH
+                isToken0: true,
+                vault: mockVaultAddress,
+                pool: mockPoolAddress,
+                ammType: AMMType.UniswapV3,
+                singleAssetDepositContract: mockContractAddress
+            });
+
+            expect(result.success).toBe(true);
+            expect(result.data ?. swapAmount).toBe(mockSwapAmount);
+        });
+
+        it('should handle large deposit amounts', async () => {
+            const mockSwapAmount = parseEther('500'); // 50% of 1000 tokens
+            const mockSqrtPrice = BigInt('3000000000000000000');
+
+            publicClient.readContract = jest.fn().mockResolvedValue([mockSwapAmount, mockSqrtPrice]);
+
+            const result = await calculateSwapAmount(publicClient, {
+                depositAmount: parseEther('1000'),
+                isToken0: false,
+                vault: mockVaultAddress,
+                pool: mockPoolAddress,
+                ammType: AMMType.UniswapV3,
+                singleAssetDepositContract: mockContractAddress
+            });
+
+            expect(result.success).toBe(true);
+            expect(result.data ?. swapAmount).toBe(mockSwapAmount);
+        });
+    });
+
+    describe('error handling', () => {
+        it('should handle contract call errors', async () => {
+            const errorMessage = 'Contract call failed';
+            publicClient.readContract = jest.fn().mockRejectedValue(new Error(errorMessage));
+
+            const result = await calculateSwapAmount(publicClient, {
+                depositAmount: parseEther('100'),
+                isToken0: true,
+                vault: mockVaultAddress,
+                pool: mockPoolAddress,
+                ammType: AMMType.UniswapV3,
+                singleAssetDepositContract: mockContractAddress
+            });
+
+            expect(result.success).toBe(false);
+            expect(result.status).toBe(500);
+            expect(result.error).toBe(errorMessage);
+            expect(result.data).toBeNull();
+        });
+
+        it('should handle network errors', async () => {
+            publicClient.readContract = jest.fn().mockRejectedValue(new Error('Network error'));
+
+            const result = await calculateSwapAmount(publicClient, {
+                depositAmount: parseEther('100'),
+                isToken0: true,
+                vault: mockVaultAddress,
+                pool: mockPoolAddress,
+                ammType: AMMType.UniswapV3,
+                singleAssetDepositContract: mockContractAddress
+            });
+
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Network error');
+        });
+
+        it('should handle invalid contract response', async () => { // Mock invalid response (not an array)
+            publicClient.readContract = jest.fn().mockResolvedValue('invalid response');
+
+            const result = await calculateSwapAmount(publicClient, {
+                depositAmount: parseEther('100'),
+                isToken0: true,
+                vault: mockVaultAddress,
+                pool: mockPoolAddress,
+                ammType: AMMType.UniswapV3,
+                singleAssetDepositContract: mockContractAddress
+            });
+
+            expect(result.success).toBe(false);
+            expect(result.status).toBe(500);
+        });
+
+        it('should handle contract revert', async () => {
+            publicClient.readContract = jest.fn().mockRejectedValue(new Error('execution reverted: Insufficient liquidity'));
+
+            const result = await calculateSwapAmount(publicClient, {
+                depositAmount: parseEther('1000000'), // Very large amount
+                isToken0: true,
+                vault: mockVaultAddress,
+                pool: mockPoolAddress,
+                ammType: AMMType.UniswapV3,
+                singleAssetDepositContract: mockContractAddress
+            });
+
+            expect(result.success).toBe(false);
+            expect(result.error).toContain('Insufficient liquidity');
+        });
+    });
+
+    describe('parameter validation', () => {
+        it('should handle zero deposit amount', async () => {
+            const mockSwapAmount = BigInt('0');
+            const mockSqrtPrice = BigInt('1000000000000000000');
+
+            publicClient.readContract = jest.fn().mockResolvedValue([mockSwapAmount, mockSqrtPrice]);
+
+            const result = await calculateSwapAmount(publicClient, {
+                depositAmount: BigInt('0'),
+                isToken0: true,
+                vault: mockVaultAddress,
+                pool: mockPoolAddress,
+                ammType: AMMType.UniswapV3,
+                singleAssetDepositContract: mockContractAddress
+            });
+
+            expect(result.success).toBe(true);
+            expect(result.data ?. swapAmount).toBe(BigInt('0'));
+        });
+
+        it('should handle all AMM types', async () => {
+            const mockSwapAmount = parseEther('25');
+            const mockSqrtPrice = BigInt('1000000000000000000');
+
+            publicClient.readContract = jest.fn().mockResolvedValue([mockSwapAmount, mockSqrtPrice]);
+
+            // Test all AMM types
+            const ammTypes = [
+                AMMType.UniswapV3,
+                AMMType.Algebra,
+                AMMType.AlgebraDirectional,
+                AMMType.AlgebraVE33,
+                AMMType.AlgebraIntegral
+            ];
+
+            for (const ammType of ammTypes) {
+                const result = await calculateSwapAmount(publicClient, {
+                    depositAmount: parseEther('100'),
+                    isToken0: true,
+                    vault: mockVaultAddress,
+                    pool: mockPoolAddress,
+                    ammType,
+                    singleAssetDepositContract: mockContractAddress
+                });
+
+                expect(result.success).toBe(true);
+            }
+        });
+    });
+
+    describe('integration scenarios', () => {
+        it('should handle balanced pool scenario', async () => { // When pool is balanced, swap amount should be around 50%
+            const mockSwapAmount = parseEther('50');
+            const mockSqrtPrice = BigInt('1000000000000000000');
+
+            publicClient.readContract = jest.fn().mockResolvedValue([mockSwapAmount, mockSqrtPrice]);
+
+            const result = await calculateSwapAmount(publicClient, {
+                depositAmount: parseEther('100'),
+                isToken0: true,
+                vault: mockVaultAddress,
+                pool: mockPoolAddress,
+                ammType: AMMType.UniswapV3,
+                singleAssetDepositContract: mockContractAddress
+            });
+
+            expect(result.success).toBe(true);
+            expect(result.data ?. swapAmount).toBe(mockSwapAmount);
+        });
+
+        it('should handle imbalanced pool scenario', async () => { // When pool is imbalanced, swap amount might be very different
+            const mockSwapAmount = parseEther('80'); // 80% needs to be swapped
+            const mockSqrtPrice = BigInt('500000000000000000');
+
+            publicClient.readContract = jest.fn().mockResolvedValue([mockSwapAmount, mockSqrtPrice]);
+
+            const result = await calculateSwapAmount(publicClient, {
+                depositAmount: parseEther('100'),
+                isToken0: true,
+                vault: mockVaultAddress,
+                pool: mockPoolAddress,
+                ammType: AMMType.UniswapV3,
+                singleAssetDepositContract: mockContractAddress
+            });
+
+            expect(result.success).toBe(true);
+            expect(result.data ?. swapAmount).toBe(mockSwapAmount);
+        });
+    });
+});