@steerprotocol/sdk 1.26.0 → 1.28.0

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

@@ -0,0 +1,467 @@
+import { createPublicClient, http, parseEther } from 'viem';
+import { polygon } from 'viem/chains';
+import { determineSwapDirection, simulateSwap, simulateSwapWithSlippage, validateSwapParams } from '../../../../base/vault/single-asset/simulateSwap.js';
+import { AMMType } from '../../../../base/vault/single-asset/types.js';
+
+// Mock addresses for testing
+const mockPoolAddress = '0x479e1b71a702a595e19b6d5932cd5c863ab57ee0' as const;
+const mockRecipientAddress = '0x9876543210987654321098765432109876543210' as const;
+const mockTokenIn = '0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270' as const; // USDC on Polygon
+const mockTokenOut = '0x7ceb23fd6bc0add59e62ac25578270cff1b9f619' as const; // WMATIC on Polygon
+const mockFee = 3000;
+const mockChainId = 137; // Polygon
+const mockTickSpacing = 60
+
+describe('simulateSwap', () => {
+  let publicClient: any;
+
+  beforeEach(() => {
+    // Create a mock public client
+    publicClient = createPublicClient({chain: polygon, transport: http()});
+
+    // Initialize SteerClient with real clients
+  });
+
+  describe('successful swaps', () => {
+
+    it.only('Shoud simulate token0 -> token1 swap', async () => {
+      const result = await simulateSwapWithSlippage(
+        publicClient,
+       {
+            poolAddress: mockPoolAddress,
+            recipient: mockRecipientAddress,
+            zeroForOne: true,
+            amountSpecified: 77510475419970853839082n,
+            sqrtPriceLimitX96: 599370183826078430401281393n,
+            ammType: AMMType.Algebra,
+            tokenIn: mockTokenIn,
+            tokenOut: mockTokenOut,
+            fee: mockFee
+          },
+        137
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.status).toBe(200);
+
+
+
+    })
+
+    it('should simulate token0 → token1 swap', async () => {
+
+      // Mock the call function
+      const result = await simulateSwap(publicClient, {
+        pool: mockPoolAddress,
+        recipient: mockRecipientAddress,
+        zeroForOne: true,
+        amountSpecified: 47197431190251602083645n,
+        sqrtPriceLimitX96: 539371925558808122039976025185830n,
+        ammType: AMMType.UniswapV3,
+        tokenIn: mockTokenIn,
+        tokenOut: mockTokenOut,
+        fee: mockFee,
+        tickSpacing: mockTickSpacing
+      }, mockChainId);
+
+        expect(result.success).toBe(true);
+        expect(result.status).toBe(200);
+
+     
+    });
+
+    it('should simulate token1 → token0 swap', async () => {
+      const mockAmount0 = parseEther('40'); // Positive means token0 coming in
+      const mockAmount1 = -parseEther('20'); // Negative means token1 going out
+      const mockEncodedData = '0xabcdef1234567890';
+      const mockDecodedResult = [mockAmount0, mockAmount1];
+
+      publicClient.call = jest.fn().mockResolvedValue({
+        data: mockEncodedData
+      });
+      publicClient.encodeFunctionData = jest.fn().mockReturnValue(mockEncodedData);
+      publicClient.decodeFunctionResult = jest.fn().mockReturnValue(mockDecodedResult);
+
+      const result = await simulateSwap(publicClient, {
+        pool: mockPoolAddress,
+        recipient: mockRecipientAddress,
+        zeroForOne: false,
+        amountSpecified: parseEther('20'),
+        sqrtPriceLimitX96: BigInt('158456325028528675187087900672'),
+        ammType: AMMType.UniswapV3,
+        tokenIn: mockTokenOut,
+        tokenOut: mockTokenIn,
+        fee: mockFee,
+        tickSpacing: mockTickSpacing
+      }, mockChainId);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual({
+        amount0: mockAmount0,
+        amount1: mockAmount1
+      });
+
+      // Verify zeroForOne is false
+      expect(publicClient.encodeFunctionData).toHaveBeenCalledWith(
+        expect.objectContaining({
+          args: expect.arrayContaining([false])
+        })
+      );
+    });
+
+    it('should handle different amount specifications', async () => {
+      const amounts = [
+        parseEther('1'),     // Small amount
+        parseEther('100'),   // Medium amount
+        parseEther('10000'), // Large amount
+        BigInt('1000000000000000') // Very small amount (0.001 ETH)
+      ];
+
+      for (const amount of amounts) {
+        const mockAmount0 = -amount;
+        const mockAmount1 = amount * 2n; // 2:1 ratio
+        const mockEncodedData = '0x1234567890abcdef';
+
+        publicClient.call = jest.fn().mockResolvedValue({
+          data: mockEncodedData
+        });
+        publicClient.encodeFunctionData = jest.fn().mockReturnValue(mockEncodedData);
+        publicClient.decodeFunctionResult = jest.fn().mockReturnValue([mockAmount0, mockAmount1]);
+
+        const result = await simulateSwap(publicClient, {
+          pool: mockPoolAddress,
+          recipient: mockRecipientAddress,
+          zeroForOne: true,
+          amountSpecified: amount,
+          sqrtPriceLimitX96: BigInt('79228162514264337593543950336'),
+          ammType: AMMType.UniswapV3,
+          tokenIn: mockTokenIn,
+          tokenOut: mockTokenOut,
+          fee: mockFee,
+          tickSpacing: mockTickSpacing
+        }, mockChainId);
+
+        expect(result.success).toBe(true);
+        expect(result.data?.amount0).toBe(mockAmount0);
+        expect(result.data?.amount1).toBe(mockAmount1);
+      }
+    });
+
+    it('should handle different price limits', async () => {
+      const priceTests = [
+        {
+          name: 'low price limit',
+          sqrtPriceLimitX96: BigInt('25054144837504792519937268'),
+          zeroForOne: true
+        },
+        {
+          name: 'normal price limit',
+          sqrtPriceLimitX96: BigInt('79228162514264337593543950336'),
+          zeroForOne: true
+        },
+        {
+          name: 'high price limit',
+          sqrtPriceLimitX96: BigInt('2505414483750479251993726816896'),
+          zeroForOne: false
+        }
+      ];
+
+      for (const test of priceTests) {
+        const mockAmount0 = parseEther('10');
+        const mockAmount1 = -parseEther('5');
+        const mockEncodedData = '0x1234567890abcdef';
+
+        publicClient.call = jest.fn().mockResolvedValue({
+          data: mockEncodedData
+        });
+        publicClient.encodeFunctionData = jest.fn().mockReturnValue(mockEncodedData);
+        publicClient.decodeFunctionResult = jest.fn().mockReturnValue([mockAmount0, mockAmount1]);
+
+        const result = await simulateSwap(publicClient, {
+          pool: mockPoolAddress,
+          recipient: mockRecipientAddress,
+          zeroForOne: test.zeroForOne,
+          amountSpecified: parseEther('5'),
+          sqrtPriceLimitX96: test.sqrtPriceLimitX96,
+          ammType: AMMType.UniswapV3,
+          tokenIn: test.zeroForOne ? mockTokenIn : mockTokenOut,
+          tokenOut: test.zeroForOne ? mockTokenOut : mockTokenIn,
+          fee: mockFee,
+          tickSpacing: mockTickSpacing
+        }, mockChainId);
+
+        expect(result.success).toBe(true);
+        expect(publicClient.encodeFunctionData).toHaveBeenCalledWith(
+          expect.objectContaining({
+            args: expect.arrayContaining([test.sqrtPriceLimitX96])
+          })
+        );
+      }
+    });
+  });
+
+  describe('error handling', () => {
+    it('should reject unsupported AMM types', async () => {
+      const result = await simulateSwap(publicClient, {
+        pool: mockPoolAddress,
+        recipient: mockRecipientAddress,
+        zeroForOne: true,
+        amountSpecified: parseEther('25'),
+        sqrtPriceLimitX96: BigInt('79228162514264337593543950336'),
+        ammType: AMMType.Algebra, // Not supported yet
+        tokenIn: mockTokenIn,
+        tokenOut: mockTokenOut,
+        fee: mockFee,
+        tickSpacing: mockTickSpacing
+      }, mockChainId);
+
+      expect(result.success).toBe(false);
+      expect(result.status).toBe(500);
+      expect(result.error).toContain('not yet supported');
+    });
+
+    it('should handle call failures', async () => {
+      publicClient.call = jest.fn().mockRejectedValue(new Error('Call failed'));
+
+      const result = await simulateSwap(publicClient, {
+        pool: mockPoolAddress,
+        recipient: mockRecipientAddress,
+        zeroForOne: true,
+        amountSpecified: parseEther('25'),
+        sqrtPriceLimitX96: BigInt('79228162514264337593543950336'),
+        ammType: AMMType.UniswapV3,
+        tokenIn: mockTokenIn,
+        tokenOut: mockTokenOut,
+        fee: mockFee,
+        tickSpacing: mockTickSpacing
+      }, mockChainId);
+
+      expect(result.success).toBe(false);
+      expect(result.status).toBe(500);
+      expect(result.error).toBe('Call failed');
+    });
+
+    it('should handle no data returned', async () => {
+      publicClient.call = jest.fn().mockResolvedValue({
+        data: null
+      });
+
+      const result = await simulateSwap(publicClient, {
+        pool: mockPoolAddress,
+        recipient: mockRecipientAddress,
+        zeroForOne: true,
+        amountSpecified: parseEther('25'),
+        sqrtPriceLimitX96: BigInt('79228162514264337593543950336'),
+        ammType: AMMType.UniswapV3,
+        tokenIn: mockTokenIn,
+        tokenOut: mockTokenOut,
+        fee: mockFee,
+        tickSpacing: mockTickSpacing
+      }, mockChainId);
+
+      expect(result.success).toBe(false);
+      expect(result.status).toBe(500);
+      expect(result.error).toContain('No data returned from quoter simulation');
+    });
+
+    it('should handle decode errors', async () => {
+      const mockEncodedData = '0x1234567890abcdef';
+      
+      publicClient.call = jest.fn().mockResolvedValue({
+        data: mockEncodedData
+      });
+      publicClient.encodeFunctionData = jest.fn().mockReturnValue(mockEncodedData);
+      publicClient.decodeFunctionResult = jest.fn().mockImplementation(() => {
+        throw new Error('Decode failed');
+      });
+
+      const result = await simulateSwap(publicClient, {
+        pool: mockPoolAddress,
+        recipient: mockRecipientAddress,
+        zeroForOne: true,
+        amountSpecified: parseEther('25'),
+        sqrtPriceLimitX96: BigInt('79228162514264337593543950336'),
+        ammType: AMMType.UniswapV3,
+        tokenIn: mockTokenIn,
+        tokenOut: mockTokenOut,
+        fee: mockFee,
+        tickSpacing: mockTickSpacing
+      }, mockChainId);
+
+      expect(result.success).toBe(false);
+      expect(result.status).toBe(500);
+      expect(result.error).toBe('Decode failed');
+    });
+  });
+
+  describe('parameter validation', () => {
+    it('should validate all parameters', () => {
+      expect(() => {
+        validateSwapParams({
+          pool: mockPoolAddress,
+          recipient: mockRecipientAddress,
+          zeroForOne: true,
+          amountSpecified: parseEther('10'),
+          sqrtPriceLimitX96: BigInt('79228162514264337593543950336'),
+          ammType: AMMType.UniswapV3,
+          tokenIn: mockTokenIn,
+          tokenOut: mockTokenOut,
+          fee: mockFee,
+          tickSpacing: mockTickSpacing
+        });
+      }).not.toThrow();
+    });
+
+    it('should reject invalid pool address', () => {
+      expect(() => {
+        validateSwapParams({
+          pool: '0x0000000000000000000000000000000000000000',
+          recipient: mockRecipientAddress,
+          zeroForOne: true,
+          amountSpecified: parseEther('10'),
+          sqrtPriceLimitX96: BigInt('79228162514264337593543950336'),
+          ammType: AMMType.UniswapV3,
+          tokenIn: mockTokenIn,
+          tokenOut: mockTokenOut,
+          fee: mockFee,
+          tickSpacing: mockTickSpacing
+        });
+      }).toThrow('Invalid pool address');
+    });
+
+    it('should reject zero amounts', () => {
+      expect(() => {
+        validateSwapParams({
+          pool: mockPoolAddress,
+          recipient: mockRecipientAddress,
+          zeroForOne: true,
+          amountSpecified: 0n,
+          sqrtPriceLimitX96: BigInt('79228162514264337593543950336'),
+          ammType: AMMType.UniswapV3,
+          tokenIn: mockTokenIn,
+          tokenOut: mockTokenOut,
+          fee: mockFee,
+          tickSpacing: mockTickSpacing
+        });
+      }).toThrow('Amount specified must be greater than 0');
+    });
+
+    it('should reject invalid token addresses', () => {
+      expect(() => {
+        validateSwapParams({
+          pool: mockPoolAddress,
+          recipient: mockRecipientAddress,
+          zeroForOne: true,
+          amountSpecified: parseEther('10'),
+          sqrtPriceLimitX96: BigInt('79228162514264337593543950336'),
+          ammType: AMMType.UniswapV3,
+          tokenIn: '0x0000000000000000000000000000000000000000',
+          tokenOut: mockTokenOut,
+          fee: mockFee,
+          tickSpacing: mockTickSpacing
+        });
+      }).toThrow('Invalid tokenIn address');
+    });
+
+    it('should reject invalid fee', () => {
+      expect(() => {
+        validateSwapParams({
+          pool: mockPoolAddress,
+          recipient: mockRecipientAddress,
+          zeroForOne: true,
+          amountSpecified: parseEther('10'),
+          sqrtPriceLimitX96: BigInt('79228162514264337593543950336'),
+          ammType: AMMType.UniswapV3,
+          tokenIn: mockTokenIn,
+          tokenOut: mockTokenOut,
+          fee: 0,
+          tickSpacing: mockTickSpacing
+        });
+      }).toThrow('Pool fee must be greater than 0');
+    });
+  });
+
+  describe('edge cases', () => {
+    it('should handle very large amounts', async () => {
+      const veryLargeAmount = BigInt('1000000000000000000000000'); // 1M tokens
+      const mockAmount0 = -veryLargeAmount;
+      const mockAmount1 = veryLargeAmount / 2n;
+      const mockEncodedData = '0x1234567890abcdef';
+
+      publicClient.call = jest.fn().mockResolvedValue({
+        data: mockEncodedData
+      });
+      publicClient.encodeFunctionData = jest.fn().mockReturnValue(mockEncodedData);
+      publicClient.decodeFunctionResult = jest.fn().mockReturnValue([mockAmount0, mockAmount1]);
+
+      const result = await simulateSwap(publicClient, {
+        pool: mockPoolAddress,
+        recipient: mockRecipientAddress,
+        zeroForOne: true,
+        amountSpecified: veryLargeAmount,
+        sqrtPriceLimitX96: BigInt('79228162514264337593543950336'),
+        ammType: AMMType.UniswapV3,
+        tokenIn: mockTokenIn,
+        tokenOut: mockTokenOut,
+        fee: mockFee,
+        tickSpacing: mockTickSpacing
+      }, mockChainId);
+
+      expect(result.success).toBe(true);
+      expect(result.data?.amount0).toBe(mockAmount0);
+      expect(result.data?.amount1).toBe(mockAmount1);
+    });
+
+    it('should handle very small amounts', async () => {
+      const verySmallAmount = BigInt('1'); // 1 wei
+      const mockAmount0 = -verySmallAmount;
+      const mockAmount1 = verySmallAmount;
+      const mockEncodedData = '0x1234567890abcdef';
+
+      publicClient.call = jest.fn().mockResolvedValue({
+        data: mockEncodedData
+      });
+      publicClient.encodeFunctionData = jest.fn().mockReturnValue(mockEncodedData);
+      publicClient.decodeFunctionResult = jest.fn().mockReturnValue([mockAmount0, mockAmount1]);
+
+      const result = await simulateSwap(publicClient, {
+        pool: mockPoolAddress,
+        recipient: mockRecipientAddress,
+        zeroForOne: true,
+        amountSpecified: verySmallAmount,
+        sqrtPriceLimitX96: BigInt('79228162514264337593543950336'),
+        ammType: AMMType.UniswapV3,
+        tokenIn: mockTokenIn,
+        tokenOut: mockTokenOut,
+        fee: mockFee,
+        tickSpacing: mockTickSpacing
+      }, mockChainId);
+
+      expect(result.success).toBe(true);
+      expect(result.data?.amount0).toBe(mockAmount0);
+      expect(result.data?.amount1).toBe(mockAmount1);
+    });
+  });
+});
+
+describe('determineSwapDirection', () => {
+  it('should return true when depositing token0', () => {
+    expect(determineSwapDirection(true)).toBe(true);
+  });
+
+  it('should return false when depositing token1', () => {
+    expect(determineSwapDirection(false)).toBe(false);
+  });
+});
+
+describe('validateSwapParams', () => {
+  const validParams = {
+    pool: '0x1234567890123456789012345678901234567890',
+    recipient: '0x2345678901234567890123456789012345678901',
+    zeroForOne: true,
+    amountSpecified: parseEther('100'),
+    sqrtPriceLimitX96: BigInt('79228162514264337593543950336'),
+    ammType: AMMType.UniswapV3
+  };
+
+});