@steerprotocol/sdk 1.31.0 → 2.0.1

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

@@ -1,342 +0,0 @@
-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
-
-
-
-  beforeEach(() => { // Create real clients for blockchain interaction
-      publicClient = createPublicClient({
-        chain: polygon,
-        transport: http('https://polygon-bor-rpc.publicnode.com')
-      });
-
-
-      // Initialize SteerClient with real clients
-  });
-
-  describe('successful calculations', () => {
-    it('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 process Algebra AMM pools when pool state is available', async () => {
-      publicClient.readContract = jest.fn().mockResolvedValueOnce([
-        BigInt('1753088363026579664086182258483316'),
-        200101,
-        0,
-        0,
-        0,
-        true,
-      ]).mockResolvedValueOnce(18);
-
-      const result = await calculateLimitPrice(publicClient, {
-        pool: mockPoolAddress,
-        slippageBP: 500,
-        zeroForOne: true,
-        ammType: AMMType.Algebra,
-        token0: mockToken0,
-        token1: mockToken1
-      });
-
-      expect(result.success).toBe(true);
-      expect(result.status).toBe(200);
-    });
-
-    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('Contract read failed');
-    });
-
-    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 support Algebra slot0 reads when pool globalState exists', async () => {
-      publicClient.readContract = jest.fn().mockResolvedValue([
-        BigInt('1753088363026579664086182258483316'),
-        200101,
-        0,
-        0,
-        0,
-        true,
-      ]);
-      const result = await getPoolSlot0(publicClient, mockPoolAddress, AMMType.Algebra);
-
-      expect(result.success).toBe(true);
-      expect(result.status).toBe(200);
-    });
-
-    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('Contract read failed');
-    });
-  });
-}); 

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

@@ -1,325 +0,0 @@
-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';
-
-
-    beforeEach(() => { // Create real clients for blockchain interaction
-        publicClient = createPublicClient({
-            chain: polygon,
-            transport: http('https://polygon-bor-rpc.publicnode.com')
-        });
-
-        // Initialize SteerClient with real clients
-    });
-    describe('successful calculations', () => {
-        it('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(undefined);
-
-            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);
-        });
-    });
-});