@steerprotocol/sdk 1.30.8 → 2.0.0

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

@@ -1,542 +0,0 @@
-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
-  });
-});