@steerprotocol/sdk 1.30.8-test-algebra-plugins.2 → 1.31.0

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

@@ -51,15 +51,14 @@ describe('PoolClient', () => {
 
   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]
-    //       }
-    //     })
-    //   });
+      global.fetch = jest.fn().mockResolvedValue({
+        ok: true,
+        json: async () => ({
+          data: {
+            pools: [mockGraphQLPoolData]
+          }
+        })
+      } as any);
 
       const result = await poolClient.getTopPools(500, Protocol.QuickSwap, 137);
 
@@ -70,14 +69,14 @@ describe('PoolClient', () => {
     });
 
     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' }]
-    //       }
-    //     })
-    //   });
+      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);
 
@@ -125,47 +124,35 @@ describe('PoolClient', () => {
     });
 
     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]
-            }
-          })
+      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]
+          }
         });
-      });
-
-      // 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();
+      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 () => {
-      global.fetch = jest.fn().mockResolvedValue({
-        ok: true,
-        json: async () => ({
-          data: {
-            pools: [mockGraphQLPoolData]
-          }
-        })
+      jest.spyOn(poolClient as any, 'fetchFromGraph').mockResolvedValue({
+        success: true,
+        status: 200,
+        data: {
+          pool: mockGraphQLPoolData
+        }
       });
 
       const result = await poolClient.getPoolById(mockPoolId, Protocol.QuickSwap, 137);
@@ -176,13 +163,12 @@ describe('PoolClient', () => {
     });
 
     it('should return null when pool is not found', async () => {
-      global.fetch = jest.fn().mockResolvedValue({
-        ok: true,
-        json: async () => ({
-          data: {
-            pools: []
-          }
-        })
+      jest.spyOn(poolClient as any, 'fetchFromGraph').mockResolvedValue({
+        success: true,
+        status: 200,
+        data: {
+          pool: null
+        }
       });
 
       const result = await poolClient.getPoolById('nonexistent-pool', Protocol.QuickSwap, 137);
@@ -192,7 +178,11 @@ describe('PoolClient', () => {
     });
 
     it('should handle errors gracefully', async () => {
-      global.fetch = jest.fn().mockRejectedValue(new Error('Network Error'));
+      jest.spyOn(poolClient as any, 'fetchFromGraph').mockResolvedValue({
+        success: false,
+        status: 500,
+        error: 'Network Error'
+      });
 
       const result = await poolClient.getPoolById(mockPoolId, Protocol.QuickSwap, 137);
 
@@ -204,13 +194,12 @@ describe('PoolClient', () => {
 
   describe('fetchPoolsForToken', () => {
     it('should return pools for a specific token', async () => {
-      global.fetch = jest.fn().mockResolvedValue({
-        ok: true,
-        json: async () => ({
-          data: {
-            pools: [mockGraphQLPoolData]
-          }
-        })
+      jest.spyOn(poolClient as any, 'fetchFromGraph').mockResolvedValue({
+        success: true,
+        status: 200,
+        data: {
+          pools: [mockGraphQLPoolData]
+        }
       });
 
       const result = await poolClient.fetchPoolsForToken(mockTokenAddress, Protocol.QuickSwap, 137);
@@ -222,13 +211,12 @@ describe('PoolClient', () => {
     });
 
     it('should handle different response structures (limitPools)', async () => {
-      global.fetch = jest.fn().mockResolvedValue({
-        ok: true,
-        json: async () => ({
-          data: {
-            limitPools: [mockGraphQLPoolData]
-          }
-        })
+      jest.spyOn(poolClient as any, 'fetchFromGraph').mockResolvedValue({
+        success: true,
+        status: 200,
+        data: {
+          limitPools: [mockGraphQLPoolData]
+        }
       });
 
       const result = await poolClient.fetchPoolsForToken(mockTokenAddress, Protocol.PoolShark, 137);
@@ -238,13 +226,12 @@ describe('PoolClient', () => {
     });
 
     it('should handle different response structures (clPools)', async () => {
-      global.fetch = jest.fn().mockResolvedValue({
-        ok: true,
-        json: async () => ({
-          data: {
-            clPools: [mockGraphQLPoolData]
-          }
-        })
+      jest.spyOn(poolClient as any, 'fetchFromGraph').mockResolvedValue({
+        success: true,
+        status: 200,
+        data: {
+          clPools: [mockGraphQLPoolData]
+        }
       });
 
       const result = await poolClient.fetchPoolsForToken(mockTokenAddress, Protocol.Shadow, 137);
@@ -269,13 +256,12 @@ describe('PoolClient', () => {
         '0x7ceb23fd6f88dd20e75a2b5f7bdd5f9d92b3b2fd'
       ];
 
-      global.fetch = jest.fn().mockResolvedValue({
-        ok: true,
-        json: async () => ({
-          data: {
-            pools: [mockGraphQLPoolData]
-          }
-        })
+      jest.spyOn(poolClient as any, 'fetchFromGraph').mockResolvedValue({
+        success: true,
+        status: 200,
+        data: {
+          pools: [mockGraphQLPoolData],
+        },
       });
 
       const result = await poolClient.fetchPoolsForTokensBatch(tokenAddresses, Protocol.QuickSwap, 137, 2);
@@ -286,22 +272,20 @@ describe('PoolClient', () => {
 
     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'));
-      });
+      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);
 
@@ -310,6 +294,177 @@ describe('PoolClient', () => {
     });
   });
 
+  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', () => {
@@ -343,6 +498,10 @@ describe('PoolClient', () => {
 
     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);
@@ -374,6 +533,10 @@ describe('PoolClient', () => {
       );
 
       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);
@@ -400,6 +563,10 @@ describe('PoolClient', () => {
       
       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}`);
@@ -416,6 +583,10 @@ describe('PoolClient', () => {
       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);
@@ -463,7 +634,7 @@ describe('PoolClient', () => {
       }
     }, 45000);
 
-    it.only('should fetch specific pool by ID', async () => {
+    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);
       
@@ -482,6 +653,86 @@ describe('PoolClient', () => {
       }
     }, 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' },
@@ -539,4 +790,4 @@ describe('PoolClient', () => {
       }
     }, 120000); // 2 minute timeout for multiple chains
   });
-}); 
+});