@gala-chain/launchpad-mcp-server 1.22.3 → 1.23.0

package/src/tools/__tests__/liquidity-positions.test.ts

@@ -0,0 +1,673 @@
+/**
+ * Unit Tests for Liquidity Position Management MCP Tools
+ *
+ * Tests the MCP tools for managing GalaSwap liquidity positions including:
+ * - Fetching user positions (all, by ID, by token pair)
+ * - Creating liquidity positions (by price or tick)
+ * - Estimating and removing liquidity
+ * - Collecting accumulated fees
+ */
+
+import {
+  getUserLiquidityPositionsTool,
+  getLiquidityPositionByIdTool,
+  getLiquidityPositionTool,
+  addLiquidityByPriceTool,
+  addLiquidityByTicksTool,
+  estimateRemoveLiquidityTool,
+  removeLiquidityTool,
+  collectPositionFeesTool,
+} from '../dex/liquidity-positions';
+
+/**
+ * Mock LaunchpadSDK with all liquidity position methods
+ */
+const mockSdk = {
+  getSwapUserLiquidityPositions: jest.fn(),
+  getSwapLiquidityPositionById: jest.fn(),
+  getSwapLiquidityPosition: jest.fn(),
+  addSwapLiquidityByPrice: jest.fn(),
+  addSwapLiquidityByTicks: jest.fn(),
+  getSwapEstimateRemoveLiquidity: jest.fn(),
+  removeSwapLiquidity: jest.fn(),
+  collectSwapPositionFees: jest.fn(),
+  getAddress: jest.fn(() => 'eth|0x1234567890abcdef1234567890abcdef12345678'),
+};
+
+describe('Liquidity Position Management MCP Tools', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('getUserLiquidityPositionsTool', () => {
+    it('should be properly configured tool', () => {
+      expect(getUserLiquidityPositionsTool).toBeDefined();
+      expect(getUserLiquidityPositionsTool.name).toBe('gala_launchpad_get_user_liquidity_positions');
+      expect(getUserLiquidityPositionsTool.description).toContain('liquidity positions');
+    });
+
+    it('should have correct input schema', () => {
+      const schema = getUserLiquidityPositionsTool.inputSchema as any;
+      expect(schema.type).toBe('object');
+      expect(schema.properties).toHaveProperty('ownerAddress');
+      expect(schema.required).toContain('ownerAddress');
+    });
+
+    it('should return formatted positions response', async () => {
+      const mockPositions = [
+        {
+          positionId: 'pos-1',
+          ownerAddress: 'eth|0x1234567890abcdef1234567890abcdef12345678',
+          token0: 'GALA|Unit|none|none',
+          token1: 'GUSDC|Unit|none|none',
+          feeTier: 3000,
+          liquidity: '1000000000',
+          amount0: '5000',
+          amount1: '5000',
+          tickLower: -276320,
+          tickUpper: -276000,
+          feeAmount0: '50',
+          feeAmount1: '50',
+        },
+      ];
+
+      mockSdk.getSwapUserLiquidityPositions.mockResolvedValueOnce(mockPositions);
+
+      const handler = getUserLiquidityPositionsTool.handler as any;
+      const result = await handler(mockSdk, {
+        ownerAddress: 'eth|0x1234567890abcdef1234567890abcdef12345678',
+        limit: 10,
+      });
+
+      expect(result).toBeDefined();
+      expect(result.content).toBeDefined();
+      expect(result.content[0].type).toBe('text');
+      expect(result.content[0].text).toContain('1');
+    });
+
+    it('should handle empty positions list', async () => {
+      mockSdk.getSwapUserLiquidityPositions.mockResolvedValueOnce([]);
+
+      const handler = getUserLiquidityPositionsTool.handler as any;
+      const result = await handler(mockSdk, {
+        ownerAddress: 'eth|0x1234567890abcdef1234567890abcdef12345678',
+      });
+
+      expect(result).toBeDefined();
+      expect(result.content[0].text).toContain('0');
+    });
+
+    it('should handle position query errors', async () => {
+      mockSdk.getSwapUserLiquidityPositions.mockRejectedValueOnce(
+        new Error('Network error')
+      );
+
+      const handler = getUserLiquidityPositionsTool.handler as any;
+
+      try {
+        await handler(mockSdk, {
+          ownerAddress: 'eth|0x1234567890abcdef1234567890abcdef12345678',
+        });
+        throw new Error('Should have thrown error');
+      } catch (error) {
+        expect(error).toBeDefined();
+      }
+    });
+  });
+
+  describe('getLiquidityPositionByIdTool', () => {
+    it('should be properly configured tool', () => {
+      expect(getLiquidityPositionByIdTool).toBeDefined();
+      expect(getLiquidityPositionByIdTool.name).toBe('gala_launchpad_get_liquidity_position_by_id');
+      expect(getLiquidityPositionByIdTool.description).toContain('position');
+    });
+
+    it('should have correct input schema with ownerAddress and positionId', () => {
+      const schema = getLiquidityPositionByIdTool.inputSchema as any;
+      expect(schema.properties).toHaveProperty('ownerAddress');
+      expect(schema.properties).toHaveProperty('positionId');
+      expect(schema.required).toEqual(['ownerAddress', 'positionId']);
+    });
+
+    it('should return specific position by ID', async () => {
+      const mockPosition = {
+        positionId: 'pos-123',
+        ownerAddress: 'eth|0x1234567890abcdef1234567890abcdef12345678',
+        token0: 'GALA|Unit|none|none',
+        token1: 'GUSDC|Unit|none|none',
+        feeTier: 3000,
+        liquidity: '1000000000',
+        amount0: '5000',
+        amount1: '5000',
+        tickLower: -276320,
+        tickUpper: -276000,
+        feeAmount0: '50',
+        feeAmount1: '50',
+      };
+
+      mockSdk.getSwapLiquidityPositionById.mockResolvedValueOnce(mockPosition);
+
+      const handler = getLiquidityPositionByIdTool.handler as any;
+      const result = await handler(mockSdk, {
+        ownerAddress: 'eth|0x1234567890abcdef1234567890abcdef12345678',
+        positionId: 'pos-123',
+      });
+
+      expect(result).toBeDefined();
+      expect(result.content[0].text).toContain('pos-123');
+    });
+
+    it('should handle position not found error', async () => {
+      mockSdk.getSwapLiquidityPositionById.mockRejectedValueOnce(
+        new Error('Position not found')
+      );
+
+      const handler = getLiquidityPositionByIdTool.handler as any;
+
+      try {
+        await handler(mockSdk, {
+          ownerAddress: 'eth|0x1234567890abcdef1234567890abcdef12345678',
+          positionId: 'invalid-id',
+        });
+        throw new Error('Should have thrown error');
+      } catch (error) {
+        expect(error).toBeDefined();
+      }
+    });
+  });
+
+  describe('getLiquidityPositionTool', () => {
+    it('should be properly configured tool', () => {
+      expect(getLiquidityPositionTool).toBeDefined();
+      expect(getLiquidityPositionTool.name).toBe('gala_launchpad_get_liquidity_position');
+    });
+
+    it('should have correct input schema with position details', () => {
+      const schema = getLiquidityPositionTool.inputSchema as any;
+      expect(schema.properties).toHaveProperty('ownerAddress');
+      expect(schema.properties).toHaveProperty('token0');
+      expect(schema.properties).toHaveProperty('token1');
+      expect(schema.properties).toHaveProperty('fee');
+      expect(schema.properties).toHaveProperty('tickLower');
+      expect(schema.properties).toHaveProperty('tickUpper');
+    });
+
+    it('should return position by token pair and tick range', async () => {
+      const mockPosition = {
+        positionId: 'pos-456',
+        token0: 'GALA|Unit|none|none',
+        token1: 'GUSDC|Unit|none|none',
+        feeTier: 3000,
+        liquidity: '1000000000',
+      };
+
+      mockSdk.getSwapLiquidityPosition.mockResolvedValueOnce(mockPosition);
+
+      const handler = getLiquidityPositionTool.handler as any;
+      const result = await handler(mockSdk, {
+        ownerAddress: 'eth|0x1234567890abcdef1234567890abcdef12345678',
+        token0: 'GALA',
+        token1: 'GUSDC',
+        fee: 3000,
+        tickLower: -276320,
+        tickUpper: -276000,
+      });
+
+      expect(result).toBeDefined();
+      expect(result.content[0].text).toContain('GALA');
+    });
+  });
+
+  describe('estimateRemoveLiquidityTool', () => {
+    it('should be properly configured tool', () => {
+      expect(estimateRemoveLiquidityTool).toBeDefined();
+      expect(estimateRemoveLiquidityTool.name).toBe('gala_launchpad_estimate_remove_liquidity');
+      expect(estimateRemoveLiquidityTool.description).toMatch(/[Ee]stimate/);
+    });
+
+    it('should have correct input schema', () => {
+      const schema = estimateRemoveLiquidityTool.inputSchema as any;
+      expect(schema.properties).toHaveProperty('token0');
+      expect(schema.properties).toHaveProperty('token1');
+      expect(schema.properties).toHaveProperty('fee');
+      expect(schema.properties).toHaveProperty('liquidity');
+      expect(schema.properties).toHaveProperty('tickLower');
+      expect(schema.properties).toHaveProperty('tickUpper');
+    });
+
+    it('should return estimated removal amounts', async () => {
+      const mockEstimate = {
+        amount0: '5000',
+        amount1: '5000',
+        fee0: '50',
+        fee1: '50',
+      };
+
+      mockSdk.getSwapEstimateRemoveLiquidity.mockResolvedValueOnce(mockEstimate);
+
+      const handler = estimateRemoveLiquidityTool.handler as any;
+      const result = await handler(mockSdk, {
+        token0: 'GALA',
+        token1: 'GUSDC',
+        fee: 3000,
+        liquidity: '1000000000',
+        tickLower: -276320,
+        tickUpper: -276000,
+      });
+
+      expect(result).toBeDefined();
+      expect(result.content[0].text).toContain('5000');
+    });
+
+    it('should handle estimation with partial removal', async () => {
+      const mockEstimate = {
+        amount0: '2500',
+        amount1: '2500',
+        fee0: '25',
+        fee1: '25',
+      };
+
+      mockSdk.getSwapEstimateRemoveLiquidity.mockResolvedValueOnce(mockEstimate);
+
+      const handler = estimateRemoveLiquidityTool.handler as any;
+      const result = await handler(mockSdk, {
+        token0: 'GALA',
+        token1: 'GUSDC',
+        fee: 3000,
+        liquidity: '500000000', // Half the original
+        tickLower: -276320,
+        tickUpper: -276000,
+      });
+
+      expect(result).toBeDefined();
+      expect(result.content[0].text).toContain('2500');
+    });
+
+    it('should handle estimation errors', async () => {
+      mockSdk.getSwapEstimateRemoveLiquidity.mockRejectedValueOnce(
+        new Error('Invalid position')
+      );
+
+      const handler = estimateRemoveLiquidityTool.handler as any;
+
+      try {
+        await handler(mockSdk, {
+          token0: 'INVALID',
+          token1: 'INVALID',
+          fee: 3000,
+          liquidity: '1000000000',
+          tickLower: -276320,
+          tickUpper: -276000,
+        });
+        throw new Error('Should have thrown error');
+      } catch (error) {
+        expect(error).toBeDefined();
+      }
+    });
+  });
+
+  describe('addLiquidityByPriceTool', () => {
+    it('should be properly configured tool', () => {
+      expect(addLiquidityByPriceTool).toBeDefined();
+      expect(addLiquidityByPriceTool.name).toBe('gala_launchpad_add_liquidity_by_price');
+      expect(addLiquidityByPriceTool.description).toContain('price');
+    });
+
+    it('should have correct input schema with price range parameters', () => {
+      const schema = addLiquidityByPriceTool.inputSchema as any;
+      expect(schema.properties).toHaveProperty('token0');
+      expect(schema.properties).toHaveProperty('token1');
+      expect(schema.properties).toHaveProperty('fee');
+      expect(schema.properties).toHaveProperty('minPrice');
+      expect(schema.properties).toHaveProperty('maxPrice');
+      expect(schema.properties).toHaveProperty('amount0Desired');
+      expect(schema.properties).toHaveProperty('amount1Desired');
+    });
+
+    it('should create liquidity position using price range', async () => {
+      const mockResult = {
+        transactionId: 'tx-123',
+        positionId: 'pos-789',
+        token0: 'GALA',
+        token1: 'GUSDC',
+        amount0: '5000',
+        amount1: '5000',
+      };
+
+      mockSdk.addSwapLiquidityByPrice.mockResolvedValueOnce(mockResult);
+
+      const handler = addLiquidityByPriceTool.handler as any;
+      const result = await handler(mockSdk, {
+        token0: 'GALA',
+        token1: 'GUSDC',
+        fee: 3000,
+        minPrice: '0.95',
+        maxPrice: '1.05',
+        amount0Desired: '5000',
+        amount1Desired: '5000',
+      });
+
+      expect(result).toBeDefined();
+      expect(result.content[0].text).toContain('tx-123');
+    });
+
+    it('should handle slippage protection in liquidity creation', async () => {
+      const mockResult = {
+        transactionId: 'tx-456',
+        positionId: 'pos-101112',
+      };
+
+      mockSdk.addSwapLiquidityByPrice.mockResolvedValueOnce(mockResult);
+
+      const handler = addLiquidityByPriceTool.handler as any;
+      const result = await handler(mockSdk, {
+        token0: 'GALA',
+        token1: 'GUSDC',
+        fee: 3000,
+        minPrice: '0.90',
+        maxPrice: '1.10',
+        amount0Desired: '10000',
+        amount1Desired: '10000',
+        amount0Min: '9000',
+        amount1Min: '9000',
+      });
+
+      expect(result).toBeDefined();
+      expect(result.content[0].text).toContain('tx-456');
+    });
+
+    it('should handle liquidity creation errors', async () => {
+      mockSdk.addSwapLiquidityByPrice.mockRejectedValueOnce(
+        new Error('Insufficient balance')
+      );
+
+      const handler = addLiquidityByPriceTool.handler as any;
+
+      try {
+        await handler(mockSdk, {
+          token0: 'GALA',
+          token1: 'GUSDC',
+          fee: 3000,
+          minPrice: '0.95',
+          maxPrice: '1.05',
+          amount0Desired: '1000000000', // Too large
+          amount1Desired: '1000000000',
+        });
+        throw new Error('Should have thrown error');
+      } catch (error) {
+        expect(error).toBeDefined();
+      }
+    });
+  });
+
+  describe('addLiquidityByTicksTool', () => {
+    it('should be properly configured tool', () => {
+      expect(addLiquidityByTicksTool).toBeDefined();
+      expect(addLiquidityByTicksTool.name).toBe('gala_launchpad_add_liquidity_by_ticks');
+      expect(addLiquidityByTicksTool.description).toContain('tick');
+    });
+
+    it('should have correct input schema with tick parameters', () => {
+      const schema = addLiquidityByTicksTool.inputSchema as any;
+      expect(schema.properties).toHaveProperty('token0');
+      expect(schema.properties).toHaveProperty('token1');
+      expect(schema.properties).toHaveProperty('feeTier');
+      expect(schema.properties).toHaveProperty('tickLower');
+      expect(schema.properties).toHaveProperty('tickUpper');
+      expect(schema.properties).toHaveProperty('amount0Desired');
+      expect(schema.properties).toHaveProperty('amount1Desired');
+    });
+
+    it('should create liquidity position using precise tick boundaries', async () => {
+      const mockResult = {
+        transactionId: 'tx-789',
+        positionId: 'pos-131415',
+        token0: 'GALA',
+        token1: 'GUSDC',
+      };
+
+      mockSdk.addSwapLiquidityByTicks.mockResolvedValueOnce(mockResult);
+
+      const handler = addLiquidityByTicksTool.handler as any;
+      const result = await handler(mockSdk, {
+        token0: 'GALA',
+        token1: 'GUSDC',
+        feeTier: 3000,
+        tickLower: -276320,
+        tickUpper: -276000,
+        amount0Desired: '5000',
+        amount1Desired: '5000',
+      });
+
+      expect(result).toBeDefined();
+      expect(result.content[0].text).toContain('tx-789');
+    });
+  });
+
+  describe('removeLiquidityTool', () => {
+    it('should be properly configured tool', () => {
+      expect(removeLiquidityTool).toBeDefined();
+      expect(removeLiquidityTool.name).toBe('gala_launchpad_remove_liquidity');
+      expect(removeLiquidityTool.description).toMatch(/[Rr]emove/);
+    });
+
+    it('should have correct input schema with removal parameters', () => {
+      const schema = removeLiquidityTool.inputSchema as any;
+      expect(schema.properties).toHaveProperty('ownerAddress');
+      expect(schema.properties).toHaveProperty('positionId');
+      expect(schema.properties).toHaveProperty('liquidity');
+      expect(schema.properties).toHaveProperty('amount0Min');
+      expect(schema.properties).toHaveProperty('amount1Min');
+      expect(schema.properties).toHaveProperty('deadline');
+    });
+
+    it('should remove liquidity from position', async () => {
+      const mockResult = {
+        transactionId: 'tx-remove-1',
+        amount0: '5000',
+        amount1: '5000',
+        fee0: '50',
+        fee1: '50',
+      };
+
+      mockSdk.removeSwapLiquidity.mockResolvedValueOnce(mockResult);
+
+      const handler = removeLiquidityTool.handler as any;
+      const result = await handler(mockSdk, {
+        ownerAddress: 'eth|0x1234567890abcdef1234567890abcdef12345678',
+        positionId: 'pos-789',
+        liquidity: '1000000000',
+        amount0Min: '0',
+        amount1Min: '0',
+        deadline: Math.floor(Date.now() / 1000) + 3600,
+      });
+
+      expect(result).toBeDefined();
+      expect(result.content[0].text).toContain('tx-remove-1');
+    });
+
+    it('should handle partial liquidity removal', async () => {
+      const mockResult = {
+        transactionId: 'tx-remove-2',
+        amount0: '2500',
+        amount1: '2500',
+      };
+
+      mockSdk.removeSwapLiquidity.mockResolvedValueOnce(mockResult);
+
+      const handler = removeLiquidityTool.handler as any;
+      const result = await handler(mockSdk, {
+        ownerAddress: 'eth|0x1234567890abcdef1234567890abcdef12345678',
+        positionId: 'pos-789',
+        liquidity: '500000000', // Half
+        amount0Min: '0',
+        amount1Min: '0',
+        deadline: Math.floor(Date.now() / 1000) + 3600,
+      });
+
+      expect(result).toBeDefined();
+      expect(result.content[0].text).toContain('2500');
+    });
+
+    it('should handle removal errors', async () => {
+      mockSdk.removeSwapLiquidity.mockRejectedValueOnce(
+        new Error('Position not found')
+      );
+
+      const handler = removeLiquidityTool.handler as any;
+
+      try {
+        await handler(mockSdk, {
+          ownerAddress: 'eth|0x1234567890abcdef1234567890abcdef12345678',
+          positionId: 'invalid',
+          liquidity: '1000000000',
+          amount0Min: '0',
+          amount1Min: '0',
+          deadline: Math.floor(Date.now() / 1000) + 3600,
+        });
+        throw new Error('Should have thrown error');
+      } catch (error) {
+        expect(error).toBeDefined();
+      }
+    });
+  });
+
+  describe('collectPositionFeesTool', () => {
+    it('should be properly configured tool', () => {
+      expect(collectPositionFeesTool).toBeDefined();
+      expect(collectPositionFeesTool.name).toBe('gala_launchpad_collect_position_fees');
+      expect(collectPositionFeesTool.description).toContain('fees');
+    });
+
+    it('should have correct input schema with position identification', () => {
+      const schema = collectPositionFeesTool.inputSchema as any;
+      expect(schema.properties).toHaveProperty('ownerAddress');
+      expect(schema.properties).toHaveProperty('positionId');
+      expect(schema.required).toEqual(['ownerAddress', 'positionId']);
+    });
+
+    it('should collect accumulated trading fees from position', async () => {
+      const mockResult = {
+        transactionId: 'tx-collect-1',
+        feeAmount0: '50',
+        feeAmount1: '50',
+      };
+
+      mockSdk.collectSwapPositionFees.mockResolvedValueOnce(mockResult);
+
+      const handler = collectPositionFeesTool.handler as any;
+      const result = await handler(mockSdk, {
+        ownerAddress: 'eth|0x1234567890abcdef1234567890abcdef12345678',
+        positionId: 'pos-789',
+      });
+
+      expect(result).toBeDefined();
+      expect(result.content[0].text).toContain('tx-collect-1');
+    });
+
+    it('should handle fee collection when no fees accumulated', async () => {
+      const mockResult = {
+        transactionId: 'tx-collect-2',
+        feeAmount0: '0',
+        feeAmount1: '0',
+      };
+
+      mockSdk.collectSwapPositionFees.mockResolvedValueOnce(mockResult);
+
+      const handler = collectPositionFeesTool.handler as any;
+      const result = await handler(mockSdk, {
+        ownerAddress: 'eth|0x1234567890abcdef1234567890abcdef12345678',
+        positionId: 'pos-no-fees',
+      });
+
+      expect(result).toBeDefined();
+      expect(result.content[0].text).toContain('0');
+    });
+
+    it('should handle fee collection errors', async () => {
+      mockSdk.collectSwapPositionFees.mockRejectedValueOnce(
+        new Error('Cannot collect from closed position')
+      );
+
+      const handler = collectPositionFeesTool.handler as any;
+
+      try {
+        await handler(mockSdk, {
+          ownerAddress: 'eth|0x1234567890abcdef1234567890abcdef12345678',
+          positionId: 'closed-position',
+        });
+        throw new Error('Should have thrown error');
+      } catch (error) {
+        expect(error).toBeDefined();
+      }
+    });
+  });
+
+  describe('Tool Integration', () => {
+    it('should export all 8 liquidity position tools', () => {
+      expect(getUserLiquidityPositionsTool).toBeDefined();
+      expect(getLiquidityPositionByIdTool).toBeDefined();
+      expect(getLiquidityPositionTool).toBeDefined();
+      expect(addLiquidityByPriceTool).toBeDefined();
+      expect(addLiquidityByTicksTool).toBeDefined();
+      expect(estimateRemoveLiquidityTool).toBeDefined();
+      expect(removeLiquidityTool).toBeDefined();
+      expect(collectPositionFeesTool).toBeDefined();
+    });
+
+    it('should have unique tool names', () => {
+      const tools = [
+        getUserLiquidityPositionsTool,
+        getLiquidityPositionByIdTool,
+        getLiquidityPositionTool,
+        addLiquidityByPriceTool,
+        addLiquidityByTicksTool,
+        estimateRemoveLiquidityTool,
+        removeLiquidityTool,
+        collectPositionFeesTool,
+      ];
+
+      const names = tools.map((t) => t.name);
+      const uniqueNames = new Set(names);
+      expect(uniqueNames.size).toBe(8);
+    });
+
+    it('should have descriptions for all tools', () => {
+      const tools = [
+        getUserLiquidityPositionsTool,
+        getLiquidityPositionByIdTool,
+        getLiquidityPositionTool,
+        addLiquidityByPriceTool,
+        addLiquidityByTicksTool,
+        estimateRemoveLiquidityTool,
+        removeLiquidityTool,
+        collectPositionFeesTool,
+      ];
+
+      tools.forEach((tool) => {
+        expect(tool.description).toBeDefined();
+        expect(tool.description.length).toBeGreaterThan(0);
+      });
+    });
+
+    it('should have input schemas for all tools', () => {
+      const tools = [
+        getUserLiquidityPositionsTool,
+        getLiquidityPositionByIdTool,
+        getLiquidityPositionTool,
+        addLiquidityByPriceTool,
+        addLiquidityByTicksTool,
+        estimateRemoveLiquidityTool,
+        removeLiquidityTool,
+        collectPositionFeesTool,
+      ];
+
+      tools.forEach((tool) => {
+        expect(tool.inputSchema).toBeDefined();
+        const schema = tool.inputSchema as any;
+        expect(schema.type).toBe('object');
+        expect(schema.properties).toBeDefined();
+      });
+    });
+  });
+});