@gala-chain/launchpad-mcp-server 1.22.0 → 1.22.2

package/src/tools/__tests__/dex-tools.test.ts

@@ -1,562 +0,0 @@
-/**
- * Unit Tests for DEX Trading MCP Tools
- *
- * Tests the MCP tools for DEX trading operations including:
- * - Swap quote generation (exact input/output)
- * - Swap execution with slippage protection
- * - User asset queries
- * - Pool information retrieval
- */
-
-import {
-  getSwapQuoteExactInputTool,
-  getSwapQuoteExactOutputTool,
-  executeSwapTool,
-  getSwapUserAssetsTool,
-  getSwapPoolInfoTool,
-} from '../dex/index';
-
-/**
- * Mock LaunchpadSDK
- */
-const mockSdk = {
-  getSwapQuoteExactInput: jest.fn(),
-  getSwapQuoteExactOutput: jest.fn(),
-  executeSwap: jest.fn(),
-  getSwapUserAssets: jest.fn(),
-  getSwapPoolInfo: jest.fn(),
-  getAddress: jest.fn(() => 'eth|0x1234567890abcdef1234567890abcdef12345678'),
-};
-
-describe('DEX Trading MCP Tools', () => {
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('getSwapQuoteExactInputTool', () => {
-    it('should be properly configured tool', () => {
-      expect(getSwapQuoteExactInputTool).toBeDefined();
-      expect(getSwapQuoteExactInputTool.name).toBe('gala_launchpad_get_swap_quote_exact_input');
-      expect(getSwapQuoteExactInputTool.description).toContain('exact input');
-    });
-
-    it('should have correct input schema', () => {
-      const schema = getSwapQuoteExactInputTool.inputSchema as any;
-      expect(schema.type).toBe('object');
-      expect(schema.properties).toHaveProperty('fromToken');
-      expect(schema.properties).toHaveProperty('toToken');
-      expect(schema.properties).toHaveProperty('amount');
-      expect(schema.required).toEqual(['fromToken', 'toToken', 'amount']);
-    });
-
-    it('should return formatted quote response', async () => {
-      const mockQuote = {
-        fromToken: 'GALA',
-        toToken: 'GUSDC',
-        inputAmount: '100',
-        estimatedOutput: '95.5',
-        feeTier: 3000,
-        priceImpact: 0.005,
-        executionPrice: 0.955,
-      };
-
-      mockSdk.getSwapQuoteExactInput.mockResolvedValueOnce(mockQuote);
-
-      const handler = getSwapQuoteExactInputTool.handler as any;
-      const result = await handler(mockSdk, {
-        fromToken: 'GALA',
-        toToken: 'GUSDC',
-        amount: '100',
-      });
-
-      expect(result).toBeDefined();
-      expect(result.content).toBeDefined();
-      expect(result.content[0].type).toBe('text');
-      expect(result.content[0].text).toContain('GALA');
-    });
-
-    it('should handle quote errors gracefully', async () => {
-      mockSdk.getSwapQuoteExactInput.mockRejectedValueOnce(
-        new Error('Pool not found')
-      );
-
-      const handler = getSwapQuoteExactInputTool.handler as any;
-
-      try {
-        await handler(mockSdk, {
-          fromToken: 'GALA',
-          toToken: 'INVALID',
-          amount: '100',
-        });
-        throw new Error('Should have thrown error');
-      } catch (error) {
-        expect(error).toBeDefined();
-      }
-    });
-  });
-
-  describe('getSwapQuoteExactOutputTool', () => {
-    it('should be properly configured tool', () => {
-      expect(getSwapQuoteExactOutputTool).toBeDefined();
-      expect(getSwapQuoteExactOutputTool.name).toBe('gala_launchpad_get_swap_quote_exact_output');
-      expect(getSwapQuoteExactOutputTool.description).toContain('exact output');
-    });
-
-    it('should have correct input schema', () => {
-      const schema = getSwapQuoteExactOutputTool.inputSchema as any;
-      expect(schema.required).toEqual(['fromToken', 'toToken', 'amount']);
-    });
-
-    it('should return formatted quote for desired output', async () => {
-      const mockQuote = {
-        fromToken: 'GALA',
-        toToken: 'GUSDC',
-        inputAmount: '104.7',
-        estimatedOutput: '100',
-        feeTier: 3000,
-        priceImpact: 0.006,
-        executionPrice: 0.954,
-      };
-
-      mockSdk.getSwapQuoteExactOutput.mockResolvedValueOnce(mockQuote);
-
-      const handler = getSwapQuoteExactOutputTool.handler as any;
-      const result = await handler(mockSdk, {
-        fromToken: 'GALA',
-        toToken: 'GUSDC',
-        amount: '100',
-      });
-
-      expect(result).toBeDefined();
-      expect(result.content[0].text).toContain('100');
-    });
-  });
-
-  describe('executeSwapTool', () => {
-    it('should be properly configured tool', () => {
-      expect(executeSwapTool).toBeDefined();
-      expect(executeSwapTool.name).toBe('gala_launchpad_execute_swap');
-      expect(executeSwapTool.description).toContain('Execute a token swap');
-    });
-
-    it('should have correct input schema with required fields', () => {
-      const schema = executeSwapTool.inputSchema as any;
-      expect(schema.properties).toHaveProperty('fromToken');
-      expect(schema.properties).toHaveProperty('toToken');
-      expect(schema.properties).toHaveProperty('inputAmount');
-      expect(schema.properties).toHaveProperty('estimatedOutput');
-      expect(schema.properties).toHaveProperty('feeTier');
-      expect(schema.required).toEqual([
-        'fromToken',
-        'toToken',
-        'inputAmount',
-        'estimatedOutput',
-        'feeTier',
-      ]);
-    });
-
-    it('should have default slippage tolerance', () => {
-      const schema = executeSwapTool.inputSchema as any;
-      expect(schema.properties.slippageTolerance.default).toBe(0.01);
-    });
-
-    it('should validate wallet before execution', async () => {
-      mockSdk.getAddress.mockImplementationOnce(() => {
-        throw new Error('Wallet not configured');
-      });
-
-      const handler = executeSwapTool.handler as any;
-
-      const result = await handler(mockSdk, {
-        fromToken: 'GALA',
-        toToken: 'GUSDC',
-        inputAmount: '100',
-        estimatedOutput: '95.5',
-        feeTier: 3000,
-      });
-
-      // The error should be wrapped by withErrorHandling
-      expect(result).toBeDefined();
-      // Check for error response structure
-      expect(result.content).toBeDefined();
-    });
-
-    it('should execute swap with default slippage', async () => {
-      const mockResult = {
-        transactionId: 'tx-123',
-        status: 'COMPLETED',
-        fromToken: 'GALA',
-        toToken: 'GUSDC',
-        inputAmount: '100',
-        outputAmount: '95.5',
-        feeTier: 3000,
-        slippageTolerance: 0.01,
-        timestamp: new Date(),
-      };
-
-      mockSdk.executeSwap.mockResolvedValueOnce(mockResult);
-
-      const handler = executeSwapTool.handler as any;
-      const result = await handler(mockSdk, {
-        fromToken: 'GALA',
-        toToken: 'GUSDC',
-        inputAmount: '100',
-        estimatedOutput: '95.5',
-        feeTier: 3000,
-      });
-
-      expect(result).toBeDefined();
-      expect(result.content[0].text).toContain('tx-123');
-    });
-
-    it('should execute swap with custom slippage tolerance', async () => {
-      const mockResult = {
-        transactionId: 'tx-456',
-        status: 'COMPLETED',
-        fromToken: 'GALA',
-        toToken: 'GUSDC',
-        inputAmount: '100',
-        outputAmount: '93.5',
-        feeTier: 3000,
-        slippageTolerance: 0.05,
-        timestamp: new Date(),
-      };
-
-      mockSdk.executeSwap.mockResolvedValueOnce(mockResult);
-
-      const handler = executeSwapTool.handler as any;
-      const result = await handler(mockSdk, {
-        fromToken: 'GALA',
-        toToken: 'GUSDC',
-        inputAmount: '100',
-        estimatedOutput: '95.5',
-        feeTier: 3000,
-        slippageTolerance: 0.05,
-      });
-
-      expect(result).toBeDefined();
-      expect(mockSdk.executeSwap).toHaveBeenCalledWith(
-        'GALA',
-        'GUSDC',
-        '100',
-        '95.5',
-        3000,
-        0.05
-      );
-    });
-
-    it('should handle swap execution errors', async () => {
-      mockSdk.executeSwap.mockRejectedValueOnce(
-        new Error('Insufficient balance')
-      );
-
-      const handler = executeSwapTool.handler as any;
-
-      const result = await handler(mockSdk, {
-        fromToken: 'GALA',
-        toToken: 'GUSDC',
-        inputAmount: '100',
-        estimatedOutput: '95.5',
-        feeTier: 3000,
-      });
-
-      // The error should be wrapped by withErrorHandling
-      expect(result).toBeDefined();
-      // Check for error response structure
-      expect(result.content).toBeDefined();
-    });
-  });
-
-  describe('getSwapUserAssetsTool', () => {
-    it('should be properly configured tool', () => {
-      expect(getSwapUserAssetsTool).toBeDefined();
-      expect(getSwapUserAssetsTool.name).toBe('gala_launchpad_get_swap_user_assets');
-      expect(getSwapUserAssetsTool.description).toContain('token assets');
-    });
-
-    it('should have correct input schema', () => {
-      const schema = getSwapUserAssetsTool.inputSchema as any;
-      expect(schema.properties).toHaveProperty('walletAddress');
-      expect(schema.required).toEqual(['walletAddress']);
-    });
-
-    it('should return formatted asset list', async () => {
-      const mockAssets = [
-        { symbol: 'GALA', balance: '1000', decimals: 8 },
-        { symbol: 'GUSDC', balance: '500.5', decimals: 6 },
-      ];
-
-      mockSdk.getSwapUserAssets.mockResolvedValueOnce(mockAssets);
-
-      const handler = getSwapUserAssetsTool.handler as any;
-      const result = await handler(mockSdk, {
-        walletAddress: 'eth|0x1234567890abcdef1234567890abcdef12345678',
-      });
-
-      expect(result).toBeDefined();
-      expect(result.content[0].text).toContain('GALA');
-      expect(result.content[0].text).toContain('GUSDC');
-      expect(result.content[0].text).toContain('2 assets');
-    });
-
-    it('should handle empty asset list', async () => {
-      mockSdk.getSwapUserAssets.mockResolvedValueOnce([]);
-
-      const handler = getSwapUserAssetsTool.handler as any;
-      const result = await handler(mockSdk, {
-        walletAddress: 'eth|0xnewwallet',
-      });
-
-      expect(result).toBeDefined();
-      expect(result.content[0].text).toContain('0 assets');
-    });
-
-    it('should handle asset query errors', async () => {
-      mockSdk.getSwapUserAssets.mockRejectedValueOnce(
-        new Error('Invalid wallet address')
-      );
-
-      const handler = getSwapUserAssetsTool.handler as any;
-
-      try {
-        await handler(mockSdk, {
-          walletAddress: 'eth|invalid',
-        });
-        fail('Should have thrown error');
-      } catch (error) {
-        expect(error).toBeDefined();
-      }
-    });
-  });
-
-  describe('getSwapPoolInfoTool', () => {
-    it('should be properly configured tool', () => {
-      expect(getSwapPoolInfoTool).toBeDefined();
-      expect(getSwapPoolInfoTool.name).toBe('gala_launchpad_get_swap_pool_info');
-      expect(getSwapPoolInfoTool.description).toContain('liquidity');
-    });
-
-    it('should have correct input schema', () => {
-      const schema = getSwapPoolInfoTool.inputSchema as any;
-      expect(schema.properties).toHaveProperty('tokenA');
-      expect(schema.properties).toHaveProperty('tokenB');
-      expect(schema.required).toEqual(['tokenA', 'tokenB']);
-    });
-
-    it('should return formatted pool information', async () => {
-      const mockPoolInfo = {
-        tokenA: 'GALA',
-        tokenB: 'GUSDC',
-        liquidity: '50000000',
-        feeTiers: [500, 3000, 10000],
-        swapCount: 1250,
-      };
-
-      mockSdk.getSwapPoolInfo.mockResolvedValueOnce(mockPoolInfo);
-
-      const handler = getSwapPoolInfoTool.handler as any;
-      const result = await handler(mockSdk, {
-        tokenA: 'GALA',
-        tokenB: 'GUSDC',
-      });
-
-      expect(result).toBeDefined();
-      expect(result.content[0].text).toContain('50000000');
-      expect(result.content[0].text).toContain('5%');
-      expect(result.content[0].text).toContain('30%');
-      expect(result.content[0].text).toContain('100%');
-    });
-
-    it('should handle multiple fee tiers', async () => {
-      const mockPoolInfo = {
-        tokenA: 'GALA',
-        tokenB: 'GUSDC',
-        liquidity: '100000000',
-        feeTiers: [100, 500, 3000, 10000],
-        swapCount: 5000,
-      };
-
-      mockSdk.getSwapPoolInfo.mockResolvedValueOnce(mockPoolInfo);
-
-      const handler = getSwapPoolInfoTool.handler as any;
-      const result = await handler(mockSdk, {
-        tokenA: 'GALA',
-        tokenB: 'GUSDC',
-      });
-
-      expect(result).toBeDefined();
-      expect(result.content[0].text).toContain('4 fee tiers');
-    });
-
-    it('should handle pool not found errors', async () => {
-      mockSdk.getSwapPoolInfo.mockRejectedValueOnce(
-        new Error('Pool not found')
-      );
-
-      const handler = getSwapPoolInfoTool.handler as any;
-
-      try {
-        await handler(mockSdk, {
-          tokenA: 'UNKNOWN',
-          tokenB: 'INVALID',
-        });
-        fail('Should have thrown error');
-      } catch (error) {
-        expect(error).toBeDefined();
-      }
-    });
-  });
-
-  describe('Tool Input Validation', () => {
-    it('should have valid input schemas for all tools', () => {
-      const tools = [
-        getSwapQuoteExactInputTool,
-        getSwapQuoteExactOutputTool,
-        executeSwapTool,
-        getSwapUserAssetsTool,
-        getSwapPoolInfoTool,
-      ];
-
-      tools.forEach((tool) => {
-        expect(tool.inputSchema).toBeDefined();
-        const schema = tool.inputSchema as any;
-        expect(schema.type).toBe('object');
-        expect(schema.properties).toBeDefined();
-        expect(schema.required).toBeDefined();
-        expect(Array.isArray(schema.required)).toBe(true);
-      });
-    });
-
-    it('should define token symbol schema correctly', () => {
-      const schema = getSwapQuoteExactInputTool.inputSchema as any;
-      const fromTokenSchema = schema.properties.fromToken;
-
-      expect(fromTokenSchema.type).toBe('string');
-      expect(fromTokenSchema.minLength).toBeGreaterThan(0);
-      expect(fromTokenSchema.maxLength).toBeGreaterThan(0);
-    });
-
-    it('should define amount schema correctly', () => {
-      const schema = getSwapQuoteExactInputTool.inputSchema as any;
-      const amountSchema = schema.properties.amount;
-
-      expect(amountSchema).toBeDefined();
-      // Should accept numeric strings
-      expect(amountSchema.type).toBe('string');
-    });
-  });
-
-  describe('Error Response Formatting', () => {
-    it('should return error response with proper structure', async () => {
-      mockSdk.getSwapQuoteExactInput.mockRejectedValueOnce(
-        new Error('Network error')
-      );
-
-      const handler = getSwapQuoteExactInputTool.handler as any;
-
-      try {
-        await handler(mockSdk, {
-          fromToken: 'GALA',
-          toToken: 'GUSDC',
-          amount: '100',
-        });
-      } catch (error) {
-        expect(error).toBeDefined();
-        expect((error as Error).message).toContain('Network');
-      }
-    });
-  });
-
-  describe('Tool Metadata', () => {
-    it('should have descriptive tool names', () => {
-      expect(getSwapQuoteExactInputTool.name).toMatch(/^gala_launchpad_/);
-      expect(getSwapQuoteExactOutputTool.name).toMatch(/^gala_launchpad_/);
-      expect(executeSwapTool.name).toMatch(/^gala_launchpad_/);
-      expect(getSwapUserAssetsTool.name).toMatch(/^gala_launchpad_/);
-      expect(getSwapPoolInfoTool.name).toMatch(/^gala_launchpad_/);
-    });
-
-    it('should have clear descriptions', () => {
-      const tools = [
-        getSwapQuoteExactInputTool,
-        getSwapQuoteExactOutputTool,
-        executeSwapTool,
-        getSwapUserAssetsTool,
-        getSwapPoolInfoTool,
-      ];
-
-      tools.forEach((tool) => {
-        expect(tool.description).toBeDefined();
-        expect(tool.description.length).toBeGreaterThan(10);
-      });
-    });
-  });
-
-  describe('Real-World Scenarios', () => {
-    it('should handle typical buy token workflow', async () => {
-      // Step 1: Get quote
-      const mockQuote = {
-        fromToken: 'GALA',
-        toToken: 'GUSDC',
-        inputAmount: '100',
-        estimatedOutput: '95.5',
-        feeTier: 3000,
-        priceImpact: 0.005,
-        executionPrice: 0.955,
-      };
-
-      mockSdk.getSwapQuoteExactInput.mockResolvedValueOnce(mockQuote);
-      const quoteHandler = getSwapQuoteExactInputTool.handler as any;
-      const quoteResult = await quoteHandler(mockSdk, {
-        fromToken: 'GALA',
-        toToken: 'GUSDC',
-        amount: '100',
-      });
-
-      expect(quoteResult).toBeDefined();
-
-      // Step 2: Execute swap
-      const mockSwapResult = {
-        transactionId: 'tx-123',
-        status: 'COMPLETED',
-        fromToken: 'GALA',
-        toToken: 'GUSDC',
-        inputAmount: '100',
-        outputAmount: '95.5',
-        feeTier: 3000,
-        slippageTolerance: 0.01,
-        timestamp: new Date(),
-      };
-
-      mockSdk.executeSwap.mockResolvedValueOnce(mockSwapResult);
-      const swapHandler = executeSwapTool.handler as any;
-      const swapResult = await swapHandler(mockSdk, {
-        fromToken: 'GALA',
-        toToken: 'GUSDC',
-        inputAmount: '100',
-        estimatedOutput: '95.5',
-        feeTier: 3000,
-      });
-
-      expect(swapResult).toBeDefined();
-    });
-
-    it('should handle portfolio view workflow', async () => {
-      const mockAssets = [
-        { symbol: 'GALA', balance: '5000', decimals: 8 },
-        { symbol: 'GUSDC', balance: '2500.75', decimals: 6 },
-        { symbol: 'anime', balance: '1000000', decimals: 8 },
-      ];
-
-      mockSdk.getSwapUserAssets.mockResolvedValueOnce(mockAssets);
-
-      const handler = getSwapUserAssetsTool.handler as any;
-      const result = await handler(mockSdk, {
-        walletAddress: 'eth|0xwalletaddress',
-      });
-
-      expect(result).toBeDefined();
-      expect(result.content[0].text).toContain('3 assets');
-    });
-  });
-});