@steerprotocol/sdk 1.26.0 → 1.28.0

package/src/__tests__/base/PoolClient.test.ts

@@ -0,0 +1,542 @@
+import { PoolClient, GraphQLPoolData } from '../../base/PoolClient.js';
+import { ChainId, Protocol } from '../../const/chain.js';
+import { type PublicClient, type WalletClient } from 'viem';
+import { polygon, arbitrum, mainnet } from 'viem/chains';
+import { createPublicClient, http } from 'viem';
+
+// Mock data
+const mockPoolId = '0x1234567890123456789012345678901234567890';
+const mockTokenAddress = '0xabcdef1234567890123456789012345678901234567890';
+const mockChainId = 137; // Polygon
+
+const mockGraphQLPoolData: GraphQLPoolData = {
+  id: mockPoolId,
+  token0: {
+    id: '0x2791bca1f2de4661ed88a30c99a7a9449aa84174',
+    symbol: 'USDC',
+    name: 'USD Coin',
+    decimals: '6'
+  },
+  token1: {
+    id: '0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270',
+    symbol: 'WMATIC',
+    name: 'Wrapped Matic',
+    decimals: '18'
+  },
+  volumeUSD: '1000000',
+  tick: '100',
+  liquidity: '1000000000000000000',
+  feeTier: '3000',
+  volumeToken0: '500000',
+  volumeToken1: '500000'
+};
+
+describe('PoolClient', () => {
+  let poolClient: PoolClient;
+  let mockPublicClient: PublicClient;
+
+  beforeEach(() => {
+    // Setup mocks
+    mockPublicClient = {
+      chain: { id: mockChainId },
+      request: jest.fn(),
+    } as unknown as PublicClient;
+
+    // Initialize PoolClient with mocked clients
+    poolClient = new PoolClient(
+      mockPublicClient as PublicClient & WalletClient,
+      'test-subgraph-key'
+    );
+  });
+
+  describe('getTopPools', () => {
+    it('should return top pools for QuickSwap on Polygon', async () => {
+      // Mock the fetch function
+    //   global.fetch = jest.fn().mockResolvedValue({
+    //     ok: true,
+    //     json: async () => ({
+    //       data: {
+    //         pools: [mockGraphQLPoolData]
+    //       }
+    //     })
+    //   });
+
+      const result = await poolClient.getTopPools(500, Protocol.QuickSwap, 137);
+
+      expect(result.success).toBe(true);
+      expect(result.status).toBe(200);
+      expect(result.data).toHaveLength(1);
+      expect(result.data?.[0]).toEqual(mockGraphQLPoolData);
+    });
+
+    it('should return top pools for Uniswap on Mainnet', async () => {
+    //   global.fetch = jest.fn().mockResolvedValue({
+    //     ok: true,
+    //     json: async () => ({
+    //       data: {
+    //         pools: [mockGraphQLPoolData, { ...mockGraphQLPoolData, id: 'different-id' }]
+    //       }
+    //     })
+    //   });
+
+      const result = await poolClient.getTopPools(500, Protocol.Uniswap, 1);
+
+      expect(result.success).toBe(true);
+      expect(result.status).toBe(200);
+      expect(result.data).toHaveLength(2);
+    });
+
+    it('should filter out pools with invalid volumeUSD', async () => {
+      const poolsWithInvalidVolume = [
+        { ...mockGraphQLPoolData, volumeUSD: '1000000' },
+        { ...mockGraphQLPoolData, id: 'invalid-pool', volumeUSD: '0' },
+        { ...mockGraphQLPoolData, id: 'another-invalid', volumeUSD: '' }
+      ];
+
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        json: async () => ({
+          data: {
+            pools: poolsWithInvalidVolume
+          }
+        })
+      });
+
+      const result = await poolClient.getTopPools(500, Protocol.QuickSwap, 137);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toHaveLength(1);
+      expect(result.data?.[0].volumeUSD).toBe('1000000');
+    });
+
+    it('should handle GraphQL errors gracefully', async () => {
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        json: async () => ({
+          errors: [{ message: 'GraphQL Error' }]
+        })
+      });
+
+      const result = await poolClient.getTopPools(500, Protocol.QuickSwap, 137);
+
+      expect(result.success).toBe(false);
+      expect(result.status).toBe(500);
+      expect(result.error).toContain('GraphQL errors');
+    });
+
+    it('should handle rate limit errors with retry', async () => {
+      let callCount = 0;
+      global.fetch = jest.fn().mockImplementation(() => {
+        callCount++;
+        if (callCount === 1) {
+          return Promise.resolve({
+            ok: true,
+            json: async () => ({
+              error: 'You have surpassed your query allowance'
+            })
+          });
+        }
+        return Promise.resolve({
+          ok: true,
+          json: async () => ({
+            data: {
+              pools: [mockGraphQLPoolData]
+            }
+          })
+        });
+      });
+
+      // Mock setTimeout to resolve immediately
+
+      const result = await poolClient.getTopPools(500, Protocol.QuickSwap, 137);
+
+      expect(result.success).toBe(true);
+      expect(callCount).toBe(2);
+
+      jest.restoreAllMocks();
+    });
+  });
+
+  describe('getPoolById', () => {
+    it('should return pool details by ID', async () => {
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        json: async () => ({
+          data: {
+            pools: [mockGraphQLPoolData]
+          }
+        })
+      });
+
+      const result = await poolClient.getPoolById(mockPoolId, Protocol.QuickSwap, 137);
+
+      expect(result.success).toBe(true);
+      expect(result.status).toBe(200);
+      expect(result.data).toEqual(mockGraphQLPoolData);
+    });
+
+    it('should return null when pool is not found', async () => {
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        json: async () => ({
+          data: {
+            pools: []
+          }
+        })
+      });
+
+      const result = await poolClient.getPoolById('nonexistent-pool', Protocol.QuickSwap, 137);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toBeNull();
+    });
+
+    it('should handle errors gracefully', async () => {
+      global.fetch = jest.fn().mockRejectedValue(new Error('Network Error'));
+
+      const result = await poolClient.getPoolById(mockPoolId, Protocol.QuickSwap, 137);
+
+      expect(result.success).toBe(false);
+      expect(result.status).toBe(500);
+      expect(result.error).toBe('Network Error');
+    });
+  });
+
+  describe('fetchPoolsForToken', () => {
+    it('should return pools for a specific token', async () => {
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        json: async () => ({
+          data: {
+            pools: [mockGraphQLPoolData]
+          }
+        })
+      });
+
+      const result = await poolClient.fetchPoolsForToken(mockTokenAddress, Protocol.QuickSwap, 137);
+
+      expect(result.success).toBe(true);
+      expect(result.status).toBe(200);
+      expect(result.data).toHaveLength(1);
+      expect(result.data?.[0]).toEqual(mockGraphQLPoolData);
+    });
+
+    it('should handle different response structures (limitPools)', async () => {
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        json: async () => ({
+          data: {
+            limitPools: [mockGraphQLPoolData]
+          }
+        })
+      });
+
+      const result = await poolClient.fetchPoolsForToken(mockTokenAddress, Protocol.PoolShark, 137);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toHaveLength(1);
+    });
+
+    it('should handle different response structures (clPools)', async () => {
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        json: async () => ({
+          data: {
+            clPools: [mockGraphQLPoolData]
+          }
+        })
+      });
+
+      const result = await poolClient.fetchPoolsForToken(mockTokenAddress, Protocol.Shadow, 137);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toHaveLength(1);
+    });
+  });
+
+  describe('fetchPoolsForTokensBatch', () => {
+    it('should return empty array for empty token list', async () => {
+      const result = await poolClient.fetchPoolsForTokensBatch([], Protocol.QuickSwap, 137);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual([]);
+    });
+
+    it('should fetch pools for multiple tokens in batches', async () => {
+      const tokenAddresses = [
+        '0x2791bca1f2de4661ed88a30c99a7a9449aa84174',
+        '0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270',
+        '0x7ceb23fd6f88dd20e75a2b5f7bdd5f9d92b3b2fd'
+      ];
+
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        json: async () => ({
+          data: {
+            pools: [mockGraphQLPoolData]
+          }
+        })
+      });
+
+      const result = await poolClient.fetchPoolsForTokensBatch(tokenAddresses, Protocol.QuickSwap, 137, 2);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toHaveLength(3); // One pool per token
+    });
+
+    it('should handle batch processing with mixed success/failure', async () => {
+      const tokenAddresses = ['token1', 'token2'];
+      let callCount = 0;
+
+      global.fetch = jest.fn().mockImplementation(() => {
+        callCount++;
+        if (callCount === 1) {
+          return Promise.resolve({
+            ok: true,
+            json: async () => ({
+              data: {
+                pools: [mockGraphQLPoolData]
+              }
+            })
+          });
+        }
+        return Promise.reject(new Error('Token not found'));
+      });
+
+      const result = await poolClient.fetchPoolsForTokensBatch(tokenAddresses, Protocol.QuickSwap, 137);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toHaveLength(1); // Only successful fetch
+    });
+  });
+
+
+
+  describe('metrics', () => {
+    it('should track API call count', () => {
+      const initialMetrics = poolClient.getMetrics();
+      expect(initialMetrics.apiCallCount).toBe(0);
+
+      poolClient.resetMetrics();
+      const resetMetrics = poolClient.getMetrics();
+      expect(resetMetrics.apiCallCount).toBe(0);
+    });
+  });
+
+  describe('Integration Tests with Real Chain Data', () => {
+    let realPoolClient: PoolClient;
+
+    beforeAll(() => {
+      // Create real clients for blockchain interaction
+      const publicClient = createPublicClient({
+        chain: polygon,
+        transport: http()
+      });
+
+     
+      // Initialize PoolClient with real clients
+      realPoolClient = new PoolClient(
+        publicClient as unknown as PublicClient & WalletClient,
+        process.env.SUBGRAPH_STUDIO_KEY || ''
+      );
+    });
+
+    it('should fetch real top pools for QuickSwap on Polygon', async () => {
+      const result = await realPoolClient.getTopPools(10, Protocol.QuickSwap, 137);
+
+      expect(result.success).toBe(true);
+      expect(Array.isArray(result.data)).toBe(true);
+
+      if (result.data && result.data.length > 0) {
+        const pool = result.data[0];
+        expect(pool).toHaveProperty('id');
+        expect(pool).toHaveProperty('token0');
+        expect(pool).toHaveProperty('token1');
+        expect(pool).toHaveProperty('volumeUSD');
+        expect(pool).toHaveProperty('liquidity');
+        expect(pool.token0).toHaveProperty('symbol');
+        expect(pool.token1).toHaveProperty('symbol');
+
+        console.log(`QuickSwap pool found: ${pool.token0.symbol}/${pool.token1.symbol}`);
+        console.log(`Volume USD: ${pool.volumeUSD}`);
+      }
+    }, 30000);
+
+    it('should fetch real top pools for Uniswap on Mainnet', async () => {
+      const mainnetPublicClient = createPublicClient({
+        chain: mainnet,
+        transport: http()
+      });
+
+      const mainnetPoolClient = new PoolClient(
+        mainnetPublicClient as unknown as PublicClient & WalletClient,
+        process.env.SUBGRAPH_STUDIO_KEY || ''
+      );
+
+      const result = await mainnetPoolClient.getTopPools(5, Protocol.Uniswap, 1);
+
+      expect(result.success).toBe(true);
+      expect(Array.isArray(result.data)).toBe(true);
+
+      if (result.data && result.data.length > 0) {
+        const pool = result.data[0];
+        console.log(`Uniswap pool found: ${pool.token0.symbol}/${pool.token1.symbol}`);
+        console.log(`Volume USD: ${pool.volumeUSD}`);
+      }
+    }, 30000);
+
+    it('should fetch real top pools for different protocols on Arbitrum', async () => {
+      const arbitrumPublicClient = createPublicClient({
+        chain: arbitrum,
+        transport: http()
+      });
+
+      const arbitrumPoolClient = new PoolClient(
+        arbitrumPublicClient as unknown as PublicClient & WalletClient,
+        process.env.SUBGRAPH_STUDIO_KEY || ''
+      );
+
+      const protocols = [Protocol.Uniswap, Protocol.Camelot];
+      
+      for (const protocol of protocols) {
+        const result = await arbitrumPoolClient.getTopPools(5, protocol, 42161);
+        
+        expect(result.success).toBe(true);
+        console.log(`${protocol} pools on Arbitrum: ${result.data?.length || 0}`);
+        
+        if (result.data && result.data.length > 0) {
+          const pool = result.data[0];
+          console.log(`Top ${protocol} pool: ${pool.token0.symbol}/${pool.token1.symbol}`);
+        }
+      }
+    }, 60000);
+
+    it('should fetch pools for specific token addresses', async () => {
+      // USDC on Polygon
+      const usdcAddress = '0x2791bca1f2de4661ed88a30c99a7a9449aa84174';
+      
+      const result = await realPoolClient.fetchPoolsForToken(usdcAddress, Protocol.QuickSwap, 137);
+
+      expect(result.success).toBe(true);
+      expect(Array.isArray(result.data)).toBe(true);
+
+      if (result.data && result.data.length > 0) {
+        console.log(`Found ${result.data.length} pools for USDC on QuickSwap`);
+        
+        // Verify that each pool contains the USDC token
+        result.data.forEach(pool => {
+          const hasUSDC = pool.token0.id.toLowerCase() === usdcAddress.toLowerCase() ||
+                         pool.token1.id.toLowerCase() === usdcAddress.toLowerCase();
+          expect(hasUSDC).toBe(true);
+        });
+      }
+    }, 30000);
+
+    it('should fetch pools in batches for multiple tokens', async () => {
+      const tokenAddresses = [
+        '0x2791bca1f2de4661ed88a30c99a7a9449aa84174', // USDC
+        '0x0d500b1d8e8ef31e21c99d1db9a6444d3adf1270', // WMATIC
+        '0x7ceb23fd6f88dd20e75a2b5f7bdd5f9d92b3b2fd'  // WETH
+      ];
+
+      const result = await realPoolClient.fetchPoolsForTokensBatch(
+        tokenAddresses,
+        Protocol.QuickSwap,
+        137,
+        2 // Batch size of 2
+      );
+
+      expect(result.success).toBe(true);
+      expect(Array.isArray(result.data)).toBe(true);
+
+      if (result.data && result.data.length > 0) {
+        console.log(`Found ${result.data.length} total pools for ${tokenAddresses.length} tokens`);
+        
+        // Verify each pool contains at least one of our tokens
+        result.data.forEach(pool => {
+          const containsTargetToken = tokenAddresses.some(tokenAddr => 
+            pool.token0.id.toLowerCase() === tokenAddr.toLowerCase() ||
+            pool.token1.id.toLowerCase() === tokenAddr.toLowerCase()
+          );
+          expect(containsTargetToken).toBe(true);
+        });
+      }
+    }, 45000);
+
+    it.only('should fetch specific pool by ID', async () => {
+      // First get a pool ID from top pools
+      const topPoolsResult = await realPoolClient.getTopPools(1, Protocol.MachineX, ChainId.Peaq);
+      
+      if (topPoolsResult.success && topPoolsResult.data && topPoolsResult.data.length > 0) {
+        const poolId = topPoolsResult.data[0].id;
+        
+        const result = await realPoolClient.getPoolById(poolId, Protocol.MachineX, ChainId.Peaq);
+        
+        expect(result.success).toBe(true);
+        expect(result.data).toBeDefined();
+        expect(result.data?.id).toBe(poolId);
+        
+        console.log(`Successfully fetched pool by ID: ${poolId}`);
+      } else {
+        console.log('Skipping pool by ID test - no pools found');
+      }
+    }, 30000);
+
+    it('should test different protocols on their respective chains', async () => {
+      const testCases = [
+        { protocol: Protocol.QuickSwap, chainId: 137, chainName: 'Polygon' },
+        { protocol: Protocol.Uniswap, chainId: 1, chainName: 'Mainnet' },
+        { protocol: Protocol.Camelot, chainId: 42161, chainName: 'Arbitrum' },
+        { protocol: Protocol.PancakeSwap, chainId: 56, chainName: 'BSC' },
+      ];
+
+      for (const testCase of testCases) {
+        try {
+          // Create client for specific chain
+          let chain;
+          switch (testCase.chainId) {
+            case 137:
+              chain = polygon;
+              break;
+            case 42161:
+              chain = arbitrum;
+              break;
+            case 1:
+              chain = mainnet;
+              break;
+            default:
+              continue; // Skip unsupported chains in this test
+          }
+
+          const publicClient = createPublicClient({
+            chain,
+            transport: http()
+          });
+
+          const chainPoolClient = new PoolClient(
+            publicClient as unknown as PublicClient & WalletClient,
+            process.env.SUBGRAPH_STUDIO_KEY || ''
+          );
+
+          const result = await chainPoolClient.getTopPools(5, testCase.protocol, testCase.chainId);
+          
+          console.log(`${testCase.protocol} on ${testCase.chainName} (${testCase.chainId}): ${result.success ? 'SUCCESS' : 'FAILED'}`);
+          
+          if (result.success && result.data) {
+            console.log(`  Found ${result.data.length} pools`);
+            if (result.data.length > 0) {
+              console.log(`  Top pool: ${result.data[0].token0.symbol}/${result.data[0].token1.symbol}`);
+            }
+          } else {
+            console.log(`  Error: ${result.error}`);
+          }
+
+          // Don't fail the test for protocols that might not be available
+          expect(result.success).toBeDefined(); // Just ensure we got a response
+        } catch (error) {
+          console.log(`${testCase.protocol} on ${testCase.chainName}: ERROR - ${error}`);
+        }
+      }
+    }, 120000); // 2 minute timeout for multiple chains
+  });
+});