@steerprotocol/sdk 1.30.8-test-algebra-plugins.2 → 1.31.0

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

@@ -1,39 +1,54 @@
-import { createPublicClient, http, parseEther } from 'viem';
+import { createPublicClient, encodeAbiParameters, 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 mockPoolAddress = '0x45dda9cb7c25131df268515131f647d726f50608' 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 mockTokenIn = '0x2791bca1f2de4661ed88a30c99a7a9449aa84174' as const; // USDC on Polygon
+const mockTokenOut = '0x7ceb23fd6bc0add59e62ac25578270cff1b9f619' as const; // WETH on Polygon
+const mockFee = 500;
 const mockChainId = 137; // Polygon
-const mockTickSpacing = 60
+const mockTickSpacing = 10
+const mockSqrtPriceX96After = BigInt('1753087240305394106909115744048138');
+
+const encodeQuoteResult = (amountOut: bigint, sqrtPriceX96After: bigint = mockSqrtPriceX96After) =>
+  encodeAbiParameters(
+    [
+      { name: 'amountOut', type: 'uint256' },
+      { name: 'sqrtPriceX96After', type: 'uint160' },
+      { name: 'initializedTicksCrossed', type: 'uint32' },
+      { name: 'gasEstimate', type: 'uint256' },
+    ],
+    [amountOut, sqrtPriceX96After, 0, 0n],
+  );
 
 describe('simulateSwap', () => {
   let publicClient: any;
 
   beforeEach(() => {
     // Create a mock public client
-    publicClient = createPublicClient({chain: polygon, transport: http()});
+    publicClient = createPublicClient({
+      chain: polygon,
+      transport: http('https://polygon-bor-rpc.publicnode.com'),
+    });
 
     // Initialize SteerClient with real clients
   });
 
   describe('successful swaps', () => {
 
-    it.only('Shoud simulate token0 -> token1 swap', async () => {
+    it('Shoud simulate token0 -> token1 swap', async () => {
       const result = await simulateSwapWithSlippage(
         publicClient,
        {
             poolAddress: mockPoolAddress,
             recipient: mockRecipientAddress,
             zeroForOne: true,
-            amountSpecified: 77510475419970853839082n,
-            sqrtPriceLimitX96: 599370183826078430401281393n,
-            ammType: AMMType.Algebra,
+            amountSpecified: 1000000n,
+            sqrtPriceLimitX96: 1600000000000000000000000000000000n,
+            ammType: AMMType.UniswapV3,
             tokenIn: mockTokenIn,
             tokenOut: mockTokenOut,
             fee: mockFee
@@ -55,8 +70,8 @@ describe('simulateSwap', () => {
         pool: mockPoolAddress,
         recipient: mockRecipientAddress,
         zeroForOne: true,
-        amountSpecified: 47197431190251602083645n,
-        sqrtPriceLimitX96: 539371925558808122039976025185830n,
+        amountSpecified: 1000000n,
+        sqrtPriceLimitX96: 0n,
         ammType: AMMType.UniswapV3,
         tokenIn: mockTokenIn,
         tokenOut: mockTokenOut,
@@ -73,14 +88,10 @@ describe('simulateSwap', () => {
     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
+        data: encodeQuoteResult(mockAmount0),
       });
-      publicClient.encodeFunctionData = jest.fn().mockReturnValue(mockEncodedData);
-      publicClient.decodeFunctionResult = jest.fn().mockReturnValue(mockDecodedResult);
 
       const result = await simulateSwap(publicClient, {
         pool: mockPoolAddress,
@@ -96,17 +107,10 @@ describe('simulateSwap', () => {
       }, mockChainId);
 
       expect(result.success).toBe(true);
-      expect(result.data).toEqual({
+      expect(result.data).toMatchObject({
         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 () => {
@@ -120,13 +124,9 @@ describe('simulateSwap', () => {
       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
+          data: encodeQuoteResult(mockAmount1),
         });
-        publicClient.encodeFunctionData = jest.fn().mockReturnValue(mockEncodedData);
-        publicClient.decodeFunctionResult = jest.fn().mockReturnValue([mockAmount0, mockAmount1]);
 
         const result = await simulateSwap(publicClient, {
           pool: mockPoolAddress,
@@ -167,15 +167,10 @@ describe('simulateSwap', () => {
       ];
 
       for (const test of priceTests) {
-        const mockAmount0 = parseEther('10');
-        const mockAmount1 = -parseEther('5');
-        const mockEncodedData = '0x1234567890abcdef';
-
+        const mockAmount1 = parseEther('5');
         publicClient.call = jest.fn().mockResolvedValue({
-          data: mockEncodedData
+          data: encodeQuoteResult(mockAmount1),
         });
-        publicClient.encodeFunctionData = jest.fn().mockReturnValue(mockEncodedData);
-        publicClient.decodeFunctionResult = jest.fn().mockReturnValue([mockAmount0, mockAmount1]);
 
         const result = await simulateSwap(publicClient, {
           pool: mockPoolAddress,
@@ -191,17 +186,16 @@ describe('simulateSwap', () => {
         }, 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 () => {
+    it('should support Algebra AMM via protocol mapping', async () => {
+      publicClient.call = jest.fn().mockResolvedValue({
+        data: encodeQuoteResult(parseEther('10')),
+      });
+
       const result = await simulateSwap(publicClient, {
         pool: mockPoolAddress,
         recipient: mockRecipientAddress,
@@ -215,9 +209,8 @@ describe('simulateSwap', () => {
         tickSpacing: mockTickSpacing
       }, mockChainId);
 
-      expect(result.success).toBe(false);
-      expect(result.status).toBe(500);
-      expect(result.error).toContain('not yet supported');
+      expect(result.success).toBe(true);
+      expect(result.status).toBe(200);
     });
 
     it('should handle call failures', async () => {
@@ -265,14 +258,8 @@ describe('simulateSwap', () => {
     });
 
     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');
+        data: '0x1234567890abcdef',
       });
 
       const result = await simulateSwap(publicClient, {
@@ -290,7 +277,7 @@ describe('simulateSwap', () => {
 
       expect(result.success).toBe(false);
       expect(result.status).toBe(500);
-      expect(result.error).toBe('Decode failed');
+      expect(result.error).toContain('Data size of');
     });
   });
 
@@ -386,13 +373,9 @@ describe('simulateSwap', () => {
       const veryLargeAmount = BigInt('1000000000000000000000000'); // 1M tokens
       const mockAmount0 = -veryLargeAmount;
       const mockAmount1 = veryLargeAmount / 2n;
-      const mockEncodedData = '0x1234567890abcdef';
-
       publicClient.call = jest.fn().mockResolvedValue({
-        data: mockEncodedData
+        data: encodeQuoteResult(mockAmount1),
       });
-      publicClient.encodeFunctionData = jest.fn().mockReturnValue(mockEncodedData);
-      publicClient.decodeFunctionResult = jest.fn().mockReturnValue([mockAmount0, mockAmount1]);
 
       const result = await simulateSwap(publicClient, {
         pool: mockPoolAddress,
@@ -416,13 +399,9 @@ describe('simulateSwap', () => {
       const verySmallAmount = BigInt('1'); // 1 wei
       const mockAmount0 = -verySmallAmount;
       const mockAmount1 = verySmallAmount;
-      const mockEncodedData = '0x1234567890abcdef';
-
       publicClient.call = jest.fn().mockResolvedValue({
-        data: mockEncodedData
+        data: encodeQuoteResult(mockAmount1),
       });
-      publicClient.encodeFunctionData = jest.fn().mockReturnValue(mockEncodedData);
-      publicClient.decodeFunctionResult = jest.fn().mockReturnValue([mockAmount0, mockAmount1]);
 
       const result = await simulateSwap(publicClient, {
         pool: mockPoolAddress,
@@ -464,4 +443,4 @@ describe('validateSwapParams', () => {
     ammType: AMMType.UniswapV3
   };
 
-}); 
+});