@steerprotocol/sdk 1.31.0 → 2.0.1

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

@@ -1,793 +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 () => {
-      global.fetch = jest.fn().mockResolvedValue({
-        ok: true,
-        json: async () => ({
-          data: {
-            pools: [mockGraphQLPoolData]
-          }
-        })
-      } as any);
-
-      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', volumeUSD: '2000000' }]
-          }
-        })
-      } as any);
-
-      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 () => {
-      const fetchFromGraphSpy = jest.spyOn(poolClient as any, 'fetchFromGraph')
-        .mockResolvedValueOnce({
-          success: false,
-          status: 500,
-          error: 'You have surpassed your query allowance'
-        })
-        .mockResolvedValueOnce({
-          success: true,
-          status: 200,
-          data: {
-            pools: [mockGraphQLPoolData]
-          }
-        });
-      const result = await poolClient.getTopPools(500, Protocol.QuickSwap, 137);
-
-      expect(result.success).toBe(false);
-      expect(fetchFromGraphSpy).toHaveBeenCalledTimes(1);
-      expect(result.error).toContain('query allowance');
-    });
-  });
-
-  describe('getPoolById', () => {
-    it('should return pool details by ID', async () => {
-      jest.spyOn(poolClient as any, 'fetchFromGraph').mockResolvedValue({
-        success: true,
-        status: 200,
-        data: {
-          pool: 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 () => {
-      jest.spyOn(poolClient as any, 'fetchFromGraph').mockResolvedValue({
-        success: true,
-        status: 200,
-        data: {
-          pool: null
-        }
-      });
-
-      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 () => {
-      jest.spyOn(poolClient as any, 'fetchFromGraph').mockResolvedValue({
-        success: false,
-        status: 500,
-        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 () => {
-      jest.spyOn(poolClient as any, 'fetchFromGraph').mockResolvedValue({
-        success: true,
-        status: 200,
-        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 () => {
-      jest.spyOn(poolClient as any, 'fetchFromGraph').mockResolvedValue({
-        success: true,
-        status: 200,
-        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 () => {
-      jest.spyOn(poolClient as any, 'fetchFromGraph').mockResolvedValue({
-        success: true,
-        status: 200,
-        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'
-      ];
-
-      jest.spyOn(poolClient as any, 'fetchFromGraph').mockResolvedValue({
-        success: true,
-        status: 200,
-        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'];
-      jest.spyOn(poolClient as any, 'fetchFromGraph')
-        .mockResolvedValueOnce({
-          success: true,
-          status: 200,
-          data: {
-            pools: [mockGraphQLPoolData],
-          },
-        })
-        .mockResolvedValueOnce({
-          success: false,
-          status: 500,
-          data: null,
-          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('searchPools', () => {
-    it('returns validation error when chainId or protocol is missing', async () => {
-      const missingProtocol = await poolClient.searchPools({
-        chainId: 137,
-        tokenAddress: mockTokenAddress,
-      });
-      const missingChain = await poolClient.searchPools({
-        protocol: Protocol.QuickSwap,
-        tokenAddress: mockTokenAddress,
-      });
-
-      expect(missingProtocol.success).toBe(false);
-      expect(missingProtocol.status).toBe(400);
-      expect(missingProtocol.error).toContain('chainId and protocol');
-      expect(missingChain.success).toBe(false);
-      expect(missingChain.status).toBe(400);
-    });
-
-    it('delegates exact pool-address search to getPoolById', async () => {
-      const getPoolByIdSpy = jest
-        .spyOn(poolClient, 'getPoolById')
-        .mockResolvedValue({ success: true, status: 200, data: mockGraphQLPoolData });
-
-      const result = await poolClient.searchPools({
-        chainId: 137,
-        protocol: Protocol.QuickSwap,
-        poolAddress: mockPoolId.toUpperCase(),
-      });
-
-      expect(getPoolByIdSpy).toHaveBeenCalledWith(
-        mockPoolId.toLowerCase(),
-        Protocol.QuickSwap,
-        137,
-      );
-      expect(result.success).toBe(true);
-      expect(result.data).toEqual([mockGraphQLPoolData]);
-    });
-
-    it('delegates token-address search to fetchPoolsForToken', async () => {
-      const fetchPoolsForTokenSpy = jest
-        .spyOn(poolClient, 'fetchPoolsForToken')
-        .mockResolvedValue({ success: true, status: 200, data: [mockGraphQLPoolData] });
-
-      const result = await poolClient.searchPools({
-        chainId: 137,
-        protocol: Protocol.QuickSwap,
-        tokenAddress: mockTokenAddress.toUpperCase(),
-      });
-
-      expect(fetchPoolsForTokenSpy).toHaveBeenCalledWith(
-        mockTokenAddress.toLowerCase(),
-        Protocol.QuickSwap,
-        137,
-      );
-      expect(result.success).toBe(true);
-      expect(result.data).toEqual([mockGraphQLPoolData]);
-    });
-
-    it('delegates batch token-address search to fetchPoolsForTokensBatch', async () => {
-      const fetchPoolsForTokensBatchSpy = jest
-        .spyOn(poolClient, 'fetchPoolsForTokensBatch')
-        .mockResolvedValue({ success: true, status: 200, data: [mockGraphQLPoolData] });
-
-      const result = await poolClient.searchPools({
-        chainId: 137,
-        protocol: Protocol.QuickSwap,
-        tokenAddresses: [mockTokenAddress.toUpperCase()],
-      });
-
-      expect(fetchPoolsForTokensBatchSpy).toHaveBeenCalledWith(
-        [mockTokenAddress.toLowerCase()],
-        Protocol.QuickSwap,
-        137,
-      );
-      expect(result.success).toBe(true);
-      expect(result.data).toEqual([mockGraphQLPoolData]);
-    });
-
-    it('falls back to local symbol filtering and dedupes mixed matches', async () => {
-      jest.spyOn(poolClient, 'getTopPools').mockResolvedValue({
-        success: true,
-        status: 200,
-        data: [
-          mockGraphQLPoolData,
-          { ...mockGraphQLPoolData, id: '0x2222222222222222222222222222222222222222' },
-        ],
-      });
-      jest.spyOn(poolClient, 'fetchPoolsForToken').mockResolvedValue({
-        success: true,
-        status: 200,
-        data: [mockGraphQLPoolData],
-      });
-
-      const result = await poolClient.searchPools({
-        chainId: 137,
-        protocol: Protocol.QuickSwap,
-        tokenAddress: mockTokenAddress,
-        tokenSymbol: 'usdc',
-      });
-
-      expect(result.success).toBe(true);
-      expect(result.data).toHaveLength(2);
-      expect(result.data?.map((pool) => pool.id)).toEqual([
-        mockGraphQLPoolData.id,
-        '0x2222222222222222222222222222222222222222',
-      ]);
-    });
-
-    it('applies minVolumeUSD and limit after collecting mixed results', async () => {
-      jest.spyOn(poolClient, 'getTopPools').mockResolvedValue({
-        success: true,
-        status: 200,
-        data: [
-          mockGraphQLPoolData,
-          {
-            ...mockGraphQLPoolData,
-            id: '0x3333333333333333333333333333333333333333',
-            volumeUSD: '50',
-          },
-          {
-            ...mockGraphQLPoolData,
-            id: '0x4444444444444444444444444444444444444444',
-            volumeUSD: '2000000',
-          },
-        ],
-      });
-
-      const result = await poolClient.searchPools({
-        chainId: 137,
-        protocol: Protocol.QuickSwap,
-        tokenSymbol: 'USDC',
-        minVolumeUSD: 1000,
-        limit: 1,
-      });
-
-      expect(result.success).toBe(true);
-      expect(result.data).toHaveLength(1);
-      expect(result.data?.[0].id).toBe(mockGraphQLPoolData.id);
-    });
-
-    it('propagates symbol fallback failures', async () => {
-      jest.spyOn(poolClient, 'getTopPools').mockResolvedValue({
-        success: false,
-        status: 500,
-        data: null,
-        error: 'subgraph unavailable',
-      });
-
-      const result = await poolClient.searchPools({
-        chainId: 137,
-        protocol: Protocol.QuickSwap,
-        tokenSymbol: 'USDC',
-      });
-
-      expect(result.success).toBe(false);
-      expect(result.status).toBe(500);
-      expect(result.error).toBe('subgraph unavailable');
-    });
-
-    it('returns validation error for empty search filters', async () => {
-      const result = await poolClient.searchPools({
-        chainId: 137,
-        protocol: Protocol.QuickSwap,
-      });
-
-      expect(result.success).toBe(false);
-      expect(result.status).toBe(400);
-      expect(result.error).toContain('requires at least one');
-    });
-  });
-
-
-
-  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);
-      if (!result.success) {
-        console.log(`Skipping QuickSwap live pool assertion: ${result.error}`);
-        return;
-      }
-
-      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);
-      if (!result.success) {
-        console.log(`Skipping Uniswap mainnet live pool assertion: ${result.error}`);
-        return;
-      }
-
-      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);
-        if (!result.success) {
-          console.log(`Skipping ${protocol} arbitrum live pool assertion: ${result.error}`);
-          continue;
-        }
-        
-        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);
-      if (!result.success) {
-        console.log(`Skipping token-address live pool assertion: ${result.error}`);
-        return;
-      }
-
-      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('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 search real pools by exact pool address', async () => {
-      const topPoolsResult = await realPoolClient.getTopPools(1, Protocol.QuickSwap, 137);
-
-      if (!topPoolsResult.success) {
-        console.log(
-          `Skipping pool-address search test - top pools lookup failed: ${topPoolsResult.error}`,
-        );
-        return;
-      }
-      if (!topPoolsResult.data || topPoolsResult.data.length === 0) {
-        console.log('Skipping pool-address search test - no pools found');
-        return;
-      }
-
-      const poolId = topPoolsResult.data[0].id;
-      const searchResult = await realPoolClient.searchPools({
-        chainId: 137,
-        protocol: Protocol.QuickSwap,
-        poolAddress: poolId,
-      });
-
-      expect(searchResult.success).toBe(true);
-      expect(Array.isArray(searchResult.data)).toBe(true);
-
-      if (searchResult.data && searchResult.data.length > 0) {
-        expect(searchResult.data[0].id.toLowerCase()).toBe(poolId.toLowerCase());
-      }
-    }, 30000);
-
-    it('should search real pools by token symbol and token address', async () => {
-      const topPoolsResult = await realPoolClient.getTopPools(10, Protocol.QuickSwap, 137);
-
-      if (!topPoolsResult.success) {
-        console.log(`Skipping token search test - top pools lookup failed: ${topPoolsResult.error}`);
-        return;
-      }
-      if (!topPoolsResult.data || topPoolsResult.data.length === 0) {
-        console.log('Skipping token search test - no pools found');
-        return;
-      }
-
-      const referencePool = topPoolsResult.data[0];
-      const tokenSymbol = referencePool.token0.symbol;
-      const tokenAddress = referencePool.token0.id;
-
-      const symbolSearchResult = await realPoolClient.searchPools({
-        chainId: 137,
-        protocol: Protocol.QuickSwap,
-        tokenSymbol,
-      });
-      const addressSearchResult = await realPoolClient.searchPools({
-        chainId: 137,
-        protocol: Protocol.QuickSwap,
-        tokenAddress,
-      });
-
-      expect(symbolSearchResult.success).toBe(true);
-      expect(Array.isArray(symbolSearchResult.data)).toBe(true);
-      expect(addressSearchResult.success).toBe(true);
-      expect(Array.isArray(addressSearchResult.data)).toBe(true);
-
-      if (symbolSearchResult.data && symbolSearchResult.data.length > 0) {
-        const hasSymbolMatch = symbolSearchResult.data.some((pool) =>
-          [pool.token0.symbol, pool.token1.symbol]
-            .map((symbol) => symbol.toLowerCase())
-            .includes(tokenSymbol.toLowerCase()),
-        );
-        expect(hasSymbolMatch).toBe(true);
-      }
-
-      if (addressSearchResult.data && addressSearchResult.data.length > 0) {
-        const allContainToken = addressSearchResult.data.every((pool) =>
-          [pool.token0.id, pool.token1.id]
-            .map((id) => id.toLowerCase())
-            .includes(tokenAddress.toLowerCase()),
-        );
-        expect(allContainToken).toBe(true);
-      }
-    }, 45000);
-
-    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
-  });
-});