@steerprotocol/sdk 1.31.0 → 2.0.1

package/src/base/PoolClient.ts

@@ -1,877 +0,0 @@
-import type { PublicClient, WalletClient } from 'viem';
-import { PoolData, SteerResponse } from '../types.js';
-import { SubgraphClient } from './SubgraphClient.js';
-import { 
-  Protocol, 
-  Chain
-} from '../const/chain.js';
-import { 
-  chainIdToName, 
-  getProtocolSubgraphURL
-} from '../const/index.js';
-import { isAlgebraProtocol } from '../const/protocol.js';
-import { getTopPoolsQuery, getTokenPoolsQueryByAddress, getPoolDetailsQuery } from '../utils/PoolQueryAdapter.js';
-
-/**
- * GraphQL token data interface representing token information from subgraph responses
- * @interface GraphQLTokenData
- */
-export interface GraphQLTokenData {
-  /** Token symbol (e.g., "ETH", "USDC") */
-  symbol: string;
-  /** Token contract address */
-  id: string;
-  /** Number of decimal places for the token */
-  decimals: string;
-  /** Human-readable token name */
-  name: string;
-}
-
-/**
- * GraphQL pool data interface representing pool information from subgraph responses
- * @interface GraphQLPoolData
- */
-export interface GraphQLPoolData {
-  /** Pool contract address */
-  id: string;
-  /** First token in the pool */
-  token0: GraphQLTokenData;
-  /** Second token in the pool */
-  token1: GraphQLTokenData;
-  /** 24-hour trading volume in USD */
-  volumeUSD: string;
-  /** Current tick of the pool */
-  tick: string;
-  /** Total liquidity in the pool */
-  liquidity: string;
-  /** Fee tier for the pool (optional) */
-  feeTier?: string;
-  /** 24-hour volume of token0 (optional) */
-  volumeToken0?: string;
-  /** 24-hour volume of token1 (optional) */
-  volumeToken1?: string;
-  /** Total value locked in ETH (optional) */
-  totalValueLockedETH?: string;
-  /** Alternative field name for volume USD (optional) */
-  volumeUsd?: string;
-  /** Alternative field name for TVL in ETH (optional) */
-  totalValueLockedEth?: string;
-}
-
-/**
- * Filter criteria for querying pools
- * @interface PoolFilter
- */
-export interface PoolFilter {
-  /** Chain ID to filter pools by */
-  chainId?: number;
-  /** Protocol to filter pools by */
-  protocol?: Protocol;
-  /** Exact pool address/id to look up */
-  poolAddress?: string;
-  /** Minimum volume in USD to filter pools */
-  minVolumeUSD?: number;
-  /** Token address to find pools containing this token */
-  tokenAddress?: string;
-  /** Multiple token addresses to find pools for */
-  tokenAddresses?: string[];
-  /** Token symbol to find pools containing this token */
-  tokenSymbol?: string;
-  /** Multiple token symbols to find pools for */
-  tokenSymbols?: string[];
-  /** Maximum number of pools to return */
-  limit?: number;
-}
-
-// GraphQL response interfaces (currently unused but kept for future use)
-// interface GraphQLResponse<T> {
-//   data: T;
-//   errors?: Array<{ message: string }>;
-// }
-
-/**
- * Response interface for top pools query
- * @interface TopPoolsResponse
- * @internal
- */
-interface TopPoolsResponse {
-  /** Standard pools array */
-  pools: GraphQLPoolData[];
-  /** Limit pools array (used by some protocols) */
-  limitPools?: GraphQLPoolData[];
-  /** CL pools array (used by some protocols) */
-  clPools?: GraphQLPoolData[];
-}
-
-/**
- * Response interface for pool details query
- * @interface PoolDetailsResponse
- * @internal
- */
-interface PoolDetailsResponse {
-  /** Single pool data */
-  pool: GraphQLPoolData;
-  /** Single limit pool data (used by some protocols) */
-  limitPool?: GraphQLPoolData;
-  /** Single CL pool data (used by some protocols) */
-  clPool?: GraphQLPoolData;
-}
-
-/**
- * Response interface for pools by token query
- * @interface PoolsByTokenResponse
- * @internal
- */
-interface PoolsByTokenResponse {
-  /** Standard pools array */
-  pools?: GraphQLPoolData[];
-  /** Limit pools array (used by some protocols) */
-  limitPools?: GraphQLPoolData[];
-  /** Token pools array (used by some protocols) */
-  tokenPools?: GraphQLPoolData[];
-  /** CL pools array (used by some protocols) */
-  clPools?: GraphQLPoolData[];
-}
-
-/**
- * Client for fetching pool data from various DEX protocol subgraphs
- * 
- * @example
- * ```typescript
- * import { createPublicClient, createWalletClient, http } from 'viem';
- * import { mainnet } from 'viem/chains';
- * import { PoolClient } from '@steerprotocol/sdk';
- * 
- * const client = createPublicClient({
- *   chain: mainnet,
- *   transport: http()
- * }) as PublicClient & WalletClient;
- * 
- * const poolClient = new PoolClient(client, 'your-subgraph-studio-key');
- * 
- * // Fetch top pools
- * const topPools = await poolClient.getTopPools(100, Protocol.UniswapV3, 1);
- * ```
- * 
- * @extends SubgraphClient
- * @group Pool
- */
-export class PoolClient extends SubgraphClient {
-  /** Public client for blockchain interactions */
-  protected readonly publicClient: PublicClient;
-  /** Default timeout for GraphQL queries in milliseconds */
-  private readonly defaultTimeout: number = 60000;
-  /** Counter for tracking API call metrics */
-  private apiCallCount: number = 0;
-  /** Subgraph Studio API key for rate limiting */
-  private readonly subgraphStudioKey: string;
-
-  /**
-   * Creates a new PoolClient instance
-   * 
-   * @param client - Combined public and wallet client for blockchain interactions
-   * @param subgraphStudioKey - Optional Subgraph Studio API key for higher rate limits
-   * 
-   * @example
-   * ```typescript
-   * const poolClient = new PoolClient(client, 'your-api-key');
-   * ```
-   */
-  constructor(
-    client: PublicClient & WalletClient,
-    subgraphStudioKey: string = ''
-  ) {
-    super(client);
-    this.publicClient = client;
-    this.subgraphStudioKey = subgraphStudioKey;
-  }
-
-  /**
-   * Resets the API call counter for metrics tracking
-   * 
-   * @example
-   * ```typescript
-   * poolClient.resetMetrics();
-   * ```
-   */
-  public resetMetrics(): void {
-    this.apiCallCount = 0;
-  }
-
-  /**
-   * Gets current metrics for monitoring API usage
-   * 
-   * @returns Object containing current metrics
-   * 
-   * @example
-   * ```typescript
-   * const metrics = poolClient.getMetrics();
-   * console.log(`API calls made: ${metrics.apiCallCount}`);
-   * ```
-   */
-  public getMetrics(): { apiCallCount: number } {
-    return {
-      apiCallCount: this.apiCallCount,
-    };
-  }
-
-  private normalizeAddress(value?: string): string {
-    return value?.toLowerCase() || '';
-  }
-
-  private normalizeSymbol(value?: string): string {
-    return value?.trim().toLowerCase() || '';
-  }
-
-  private dedupePools(pools: GraphQLPoolData[]): GraphQLPoolData[] {
-    const seen = new Set<string>();
-    const deduped: GraphQLPoolData[] = [];
-
-    pools.forEach((pool) => {
-      const key = this.normalizeAddress(pool.id);
-      if (!key || seen.has(key)) {
-        return;
-      }
-
-      seen.add(key);
-      deduped.push(pool);
-    });
-
-    return deduped;
-  }
-
-  private filterPoolsBySymbols(
-    pools: GraphQLPoolData[],
-    symbols: string[],
-  ): GraphQLPoolData[] {
-    if (symbols.length === 0) {
-      return pools;
-    }
-
-    const normalizedSymbols = new Set(
-      symbols.map((symbol) => this.normalizeSymbol(symbol)).filter(Boolean),
-    );
-
-    return pools.filter((pool) => {
-      const token0Symbol = this.normalizeSymbol(pool.token0?.symbol);
-      const token1Symbol = this.normalizeSymbol(pool.token1?.symbol);
-
-      return normalizedSymbols.has(token0Symbol) || normalizedSymbols.has(token1Symbol);
-    });
-  }
-
-  private applyPoolSearchResultFilters(
-    pools: GraphQLPoolData[],
-    filter: PoolFilter,
-  ): GraphQLPoolData[] {
-    let filteredPools = this.dedupePools(pools);
-
-    if (typeof filter.minVolumeUSD === 'number') {
-      filteredPools = filteredPools.filter((pool) => {
-        const volumeUSD = parseFloat(pool.volumeUSD || pool.volumeUsd || '0');
-        return !Number.isNaN(volumeUSD) && volumeUSD >= filter.minVolumeUSD!;
-      });
-    }
-
-    if (typeof filter.limit === 'number' && filter.limit >= 0) {
-      filteredPools = filteredPools.slice(0, filter.limit);
-    }
-
-    return filteredPools;
-  }
-
-  private async searchPoolsBySymbols(
-    filter: Required<Pick<PoolFilter, 'chainId' | 'protocol'>> & PoolFilter,
-    symbols: string[],
-  ): Promise<SteerResponse<GraphQLPoolData[]>> {
-    // Symbol relation filtering is not portable across all supported AMM subgraphs.
-    // Use bounded top-pools fetch plus local symbol filtering as the baseline path.
-    const boundedLimit = Math.min(Math.max(filter.limit ?? 200, 1), 500);
-    const topPools = await this.getTopPools(boundedLimit, filter.protocol, filter.chainId);
-
-    if (!topPools.success || !topPools.data) {
-      return topPools;
-    }
-
-    const symbolMatches = this.filterPoolsBySymbols(topPools.data, symbols);
-
-    return {
-      data: this.applyPoolSearchResultFilters(symbolMatches, filter),
-      status: 200,
-      success: true,
-    };
-  }
-
-  /**
-   * Fetches data from GraphQL endpoint with retry logic for rate limits
-   * 
-   * @param query - GraphQL query string
-   * @param variables - Variables for the GraphQL query
-   * @param protocol - Protocol to query
-   * @param chainId - Chain ID to query
-   * @returns Promise containing the response data
-   * 
-   * @throws {Error} When subgraph endpoint is not available
-   * @throws {Error} When rate limit is exceeded after max retries
-   * @throws {Error} When GraphQL query times out
-   * 
-   * @internal
-   */
-  private async fetchFromGraph<T>(
-    query: string,
-    variables: Record<string, unknown>,
-    protocol: Protocol,
-    chainId: number
-  ): Promise<SteerResponse<T>> {
-    try {
-      const chainName = chainIdToName(chainId);
-      const endpoint = getProtocolSubgraphURL(protocol, chainName as Chain, this.subgraphStudioKey);
-
-      if (!endpoint) {
-        throw new Error(`No subgraph endpoint available for protocol ${protocol} on chain ${chainName}`);
-      }
-
-      const MAX_RETRIES = 3;
-      const RETRY_DELAY_MS = 11000;
-
-      const fetchWithRetry = async (retries = 0): Promise<T> => {
-        const response = await fetch(endpoint, {
-          method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-          },
-          body: JSON.stringify({ query, variables }),
-        });
-
-        const data = await response.json() as { data: T; error?: string; errors?: Array<{ message: string }> };
-
-        if (data.error && typeof data.error === "string" && data.error.includes("surpassed your query allowance")) {
-          if (retries < MAX_RETRIES) {
-            console.warn(`Rate limit hit for ${endpoint}, retrying in ${RETRY_DELAY_MS / 1000}s (attempt ${retries + 1})`);
-            await new Promise(res => setTimeout(res, RETRY_DELAY_MS));
-            return fetchWithRetry(retries + 1);
-          } else {
-            throw new Error(`Rate limit exceeded after ${MAX_RETRIES} retries: ${data.error}`);
-          }
-        }
-
-        if (data.error) {
-          throw new Error(`GraphQL endpoint error: ${data.error}`);
-        }
-
-        if (data.errors) {
-          throw new Error(`GraphQL errors: ${JSON.stringify(data.errors)}`);
-        }
-
-        return data.data;
-      };
-
-      this.apiCallCount++;
-      console.log("Total API calls:", this.apiCallCount);
-
-      const timeoutPromise = new Promise<never>((_, reject) => {
-        setTimeout(
-          () => reject(new Error("GraphQL query timeout")),
-          this.defaultTimeout
-        );
-      });
-
-      const data = await Promise.race([fetchWithRetry(), timeoutPromise]);
-
-      return {
-        data: data as T,
-        status: 200,
-        success: true,
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred',
-      };
-    }
-  }
-
-  /**
-   * Fetches the top pools for a specific protocol by trading volume
-   * 
-   * @param count - Number of pools to fetch (default: 500)
-   * @param protocol - Protocol to fetch pools from
-   * @param chainId - Chain ID to fetch pools from
-   * @returns Promise containing an array of top pools
-   * 
-   * @example
-   * ```typescript
-   * // Get top 100 Uniswap V3 pools on Ethereum
-   * const topPools = await poolClient.getTopPools(100, Protocol.UniswapV3, 1);
-   * if (topPools.success) {
-   *   console.log(`Found ${topPools.data.length} pools`);
-   * }
-   * ```
-   * 
-   * @throws {Error} When failed to fetch pools from subgraph
-   */
-  public async getTopPools(
-    count: number = 500,
-    protocol: Protocol,
-    chainId: number
-  ): Promise<SteerResponse<GraphQLPoolData[]>> {
-    try {
-      const isAlgebraPool = isAlgebraProtocol(protocol);
-      const query = getTopPoolsQuery(protocol, isAlgebraPool);
-
-      console.log(`[Chain ${chainId}] [Protocol ${protocol}] 📊 Fetching top ${count} pools from the subgraph...`);
-
-      const response = await this.fetchFromGraph<TopPoolsResponse>(
-        query,
-        { limit: count },
-        protocol,
-        chainId
-      );
-
-      if (!response.success || !response.data) {
-        throw new Error(response.error || 'Failed to fetch pools');
-      }
-
-      const pools = response.data.pools || response.data.limitPools || response.data.clPools || [];
-      
-      console.log(`[Chain ${chainId}] [Protocol ${protocol}] ✅ Received ${pools.length} pools from the subgraph`);
-
-      // Filter out pools with invalid volumeUSD
-      const validPools = pools.filter(pool => {
-        const volumeUSD = parseFloat(pool.volumeUSD || pool.volumeUsd || "0");
-        return !isNaN(volumeUSD) && volumeUSD > 0;
-      });
-
-      console.log(`[Chain ${chainId}] [Protocol ${protocol}] ✅ Found ${validPools.length} valid pools with positive volumeUSD`);
-
-      return {
-        data: validPools,
-        status: 200,
-        success: true,
-      };
-    } catch (error) {
-      console.error(`[Chain ${chainId}] [Protocol ${protocol}] Error in getTopPools:`, error);
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred',
-      };
-    }
-  }
-
-  /**
-   * Fetches detailed information for a specific pool by its ID
-   * 
-   * @param poolId - Pool contract address to fetch
-   * @param protocol - Protocol the pool belongs to
-   * @param chainId - Chain ID where the pool exists
-   * @returns Promise containing pool details or null if not found
-   * 
-   * @example
-   * ```typescript
-   * // Get specific pool details
-   * const poolDetails = await poolClient.getPoolById(
-   *   '0x88e6a0c2ddd26feeb64f039a2c41296fcb3f5640',
-   *   Protocol.UniswapV3,
-   *   1
-   * );
-   * if (poolDetails.success && poolDetails.data) {
-   *   console.log(`Pool: ${poolDetails.data.token0.symbol}/${poolDetails.data.token1.symbol}`);
-   * }
-   * ```
-   * 
-   * @throws {Error} When failed to fetch pool from subgraph
-   */
-  public async getPoolById(
-    poolId: string,
-    protocol: Protocol,
-    chainId: number
-  ): Promise<SteerResponse<GraphQLPoolData | null>> {
-    try {
-
-      const isAlgebraPool = isAlgebraProtocol(protocol);
-      const query = getPoolDetailsQuery(isAlgebraPool, protocol);
-
-    
-      const response = await this.fetchFromGraph<PoolDetailsResponse>(
-        query,
-        { pool: poolId },
-        protocol,
-        chainId
-      );
-
-      if (!response.success || !response.data) {
-        throw new Error(response.error || 'Failed to fetch pool');
-      }
-
-      const pool = response.data.pool || response.data.clPool || response.data.limitPool || null;
-
-
-      return {
-        data: pool,
-        status: 200,
-        success: true,
-      };
-    } catch (error) {
-      console.error(`Error fetching pool ${poolId}:`, error);
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred',
-      };
-    }
-  }
-
-  /**
-   * Fetches pools containing multiple tokens in batches for better performance
-   * 
-   * @param tokenAddresses - Array of token contract addresses
-   * @param protocol - Protocol to fetch pools from
-   * @param chainId - Chain ID to fetch pools from
-   * @param batchSize - Number of tokens to process in each batch (default: 10)
-   * @returns Promise containing all pools found for the tokens
-   * 
-   * @example
-   * ```typescript
-   * // Get pools for multiple tokens
-   * const tokenAddresses = [
-   *   '0xa0b86a33e6f8b07b71c3a39ef77a6b6e8f1b7b7e', // USDC
-   *   '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2'  // WETH
-   * ];
-   * const pools = await poolClient.fetchPoolsForTokensBatch(
-   *   tokenAddresses,
-   *   Protocol.UniswapV3,
-   *   1,
-   *   5
-   * );
-   * ```
-   * 
-   * @throws {Error} When batch processing fails
-   */
-  public async fetchPoolsForTokensBatch(
-    tokenAddresses: string[],
-    protocol: Protocol,
-    chainId: number,
-    batchSize: number = 10
-  ): Promise<SteerResponse<GraphQLPoolData[]>> {
-    try {
-      if (tokenAddresses.length === 0) {
-        return {
-          data: [],
-          status: 200,
-          success: true,
-        };
-      }
-
-      console.log(`\n🔍 Batch Pool Fetch Summary:`);
-      console.log(`📥 Total tokens to process: ${tokenAddresses.length}`);
-
-      const isAlgebraPool = isAlgebraProtocol(protocol);
-      const normalizedAddresses = tokenAddresses.map(addr => addr.toLowerCase());
-
-      // Split into chunks
-      const chunkSize = batchSize;
-      const addressChunks = [];
-      for (let i = 0; i < normalizedAddresses.length; i += chunkSize) {
-        addressChunks.push(normalizedAddresses.slice(i, i + chunkSize));
-      }
-
-      console.log(`📦 Processing ${addressChunks.length} chunks of max ${chunkSize} tokens each`);
-
-      const allPools: GraphQLPoolData[] = [];
-
-      // Process chunks in parallel
-      const results = await Promise.all(
-        addressChunks.map(async (chunk, chunkIndex) => {
-          console.log(`\n🔄 Processing chunk ${chunkIndex + 1}/${addressChunks.length} with ${chunk.length} tokens`);
-
-          const chunkResults = await Promise.all(
-            chunk.map(async (token) => {
-              try {
-                const query = getTokenPoolsQueryByAddress(isAlgebraPool, protocol);
-                const queryStartTime = performance.now();
-                
-                const response = await this.fetchFromGraph<PoolsByTokenResponse>(
-                  query,
-                  { token },
-                  protocol,
-                  chainId
-                );
-
-                const queryTime = performance.now() - queryStartTime;
-                console.log(`⏱️ GraphQL query for token ${token.slice(0, 6)}... completed in ${queryTime.toFixed(2)}ms`);
-
-                if (!response.success || !response.data) {
-                  console.error(`❌ No pools found for token: ${token} on chainId: ${chainId}`);
-                  return [];
-                }
-
-                // Extract pools from different possible response structures
-                let pools: GraphQLPoolData[] = [];
-                if (response.data.pools) {
-                  pools = response.data.pools;
-                } else if (response.data.clPools) {
-                  pools = response.data.clPools;
-                } else if (response.data.limitPools) {
-                  pools = response.data.limitPools;
-                } else if (response.data.tokenPools) {
-                  pools = response.data.tokenPools;
-                }
-
-                if (pools.length === 0) {
-                  console.error(`❌ No pools found for token: ${token} on chainId: ${chainId}`);
-                  return [];
-                }
-
-                return pools;
-              } catch (error) {
-                console.error(`❌ Error fetching pools for token: ${token} on chainId: ${chainId}`, error);
-                return [];
-              }
-            })
-          );
-
-          return chunkResults.flat();
-        })
-      );
-
-      // Flatten all results
-      allPools.push(...results.flat());
-
-      return {
-        data: allPools,
-        status: 200,
-        success: true,
-      };
-    } catch (error) {
-      console.error("Error in fetchPoolsForTokensBatch:", error);
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred',
-      };
-    }
-  }
-
-  /**
-   * Fetches all pools containing a specific token
-   * 
-   * @param tokenAddress - Token contract address
-   * @param protocol - Protocol to fetch pools from
-   * @param chainId - Chain ID to fetch pools from
-   * @returns Promise containing pools that include the specified token
-   * 
-   * @example
-   * ```typescript
-   * // Get all USDC pools on Uniswap V3
-   * const usdcPools = await poolClient.fetchPoolsForToken(
-   *   '0xa0b86a33e6f8b07b71c3a39ef77a6b6e8f1b7b7e',
-   *   Protocol.UniswapV3,
-   *   1
-   * );
-   * if (usdcPools.success) {
-   *   console.log(`Found ${usdcPools.data.length} USDC pools`);
-   * }
-   * ```
-   * 
-   * @throws {Error} When failed to fetch pools for token
-   */
-  public async fetchPoolsForToken(
-    tokenAddress: string,
-    protocol: Protocol,
-    chainId: number
-  ): Promise<SteerResponse<GraphQLPoolData[]>> {
-    try {
-      const isAlgebraPool = isAlgebraProtocol(protocol);
-      const query = getTokenPoolsQueryByAddress(isAlgebraPool, protocol);
-
-      const response = await this.fetchFromGraph<PoolsByTokenResponse>(
-        query,
-        { token: tokenAddress.toLowerCase() },
-        protocol,
-        chainId
-      );
-
-      if (!response.success || !response.data) {
-        throw new Error(response.error || 'Failed to fetch pools for token');
-      }
-
-      // Extract pools from different possible response structures
-      let pools: GraphQLPoolData[] = [];
-      if (response.data.pools) {
-        pools = response.data.pools;
-      } else if (response.data.limitPools) {
-        pools = response.data.limitPools;
-      } else if (response.data.tokenPools) {
-        pools = response.data.tokenPools;
-      } else if (response.data.clPools) {
-        pools = response.data.clPools;
-      }
-
-      return {
-        data: pools,
-        status: 200,
-        success: true,
-      };
-    } catch (error) {
-      console.error(`Error fetching pools for token ${tokenAddress}:`, error);
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred',
-      };
-    }
-  }
-
-  /**
-   * Filters pools based on validity criteria such as tick range and liquidity
-   * 
-   * @param pools - Array of pools to filter
-   * @returns Array of valid pools that meet the criteria
-   * 
-   * @example
-   * ```typescript
-   * const validPools = poolClient.filterValidPools(allPools);
-   * console.log(`Filtered down to ${validPools.length} valid pools`);
-   * ```
-   */
-  public filterValidPools(pools: PoolData[]): PoolData[] {
-    return pools.filter(pool => {
-      // Check for required fields
-      if (!pool.id || !pool.tick || !pool.liquidity) {
-        return false;
-      }
-
-      // Parse values
-      const tick = parseInt(pool.tick);
-      const liquidity = parseFloat(pool.liquidity);
-
-      // Check for valid tick range and liquidity
-      const TICK_MIN = -887272;
-      const TICK_MAX = 887272;
-      const TICK_EDGE_THRESHOLD = 1;
-
-      if (
-        isNaN(tick) ||
-        isNaN(liquidity) ||
-        liquidity <= 0 ||
-        tick <= TICK_MIN + TICK_EDGE_THRESHOLD ||
-        tick >= TICK_MAX - TICK_EDGE_THRESHOLD
-      ) {
-        return false;
-      }
-
-      return true;
-    });
-  }
-
-  /**
-   * Searches pools using exact-address lookups where supported and local symbol
-   * filtering as a portable fallback.
-   *
-   * Symbol-based matching is best-effort because not every downstream AMM
-   * subgraph exposes portable nested token-symbol filters.
-   */
-  public async searchPools(
-    filter: PoolFilter,
-  ): Promise<SteerResponse<GraphQLPoolData[]>> {
-    const { chainId, protocol } = filter;
-
-    if (!chainId || !protocol) {
-      return {
-        data: null,
-        status: 400,
-        success: false,
-        error: 'searchPools requires both chainId and protocol',
-      };
-    }
-
-    const normalizedPoolAddress = this.normalizeAddress(filter.poolAddress);
-    const normalizedTokenAddress = this.normalizeAddress(filter.tokenAddress);
-    const normalizedTokenAddresses = (filter.tokenAddresses || [])
-      .map((address) => this.normalizeAddress(address))
-      .filter(Boolean);
-    const tokenSymbols = [
-      ...(filter.tokenSymbol ? [filter.tokenSymbol] : []),
-      ...(filter.tokenSymbols || []),
-    ].filter(Boolean);
-
-    if (
-      !normalizedPoolAddress &&
-      !normalizedTokenAddress &&
-      normalizedTokenAddresses.length === 0 &&
-      tokenSymbols.length === 0
-    ) {
-      return {
-        data: null,
-        status: 400,
-        success: false,
-        error: 'searchPools requires at least one of poolAddress, tokenAddress, tokenAddresses, tokenSymbol, or tokenSymbols',
-      };
-    }
-
-    const collectedPools: GraphQLPoolData[] = [];
-
-    if (normalizedPoolAddress) {
-      const exactPool = await this.getPoolById(normalizedPoolAddress, protocol, chainId);
-      if (!exactPool.success) {
-        return {
-          data: null,
-          status: exactPool.status,
-          success: false,
-          error: exactPool.error,
-        };
-      }
-
-      if (exactPool.data) {
-        collectedPools.push(exactPool.data);
-      }
-    }
-
-    if (normalizedTokenAddress) {
-      const tokenPools = await this.fetchPoolsForToken(normalizedTokenAddress, protocol, chainId);
-      if (!tokenPools.success) {
-        return tokenPools;
-      }
-
-      collectedPools.push(...(tokenPools.data || []));
-    }
-
-    if (normalizedTokenAddresses.length > 0) {
-      const batchPools = await this.fetchPoolsForTokensBatch(
-        normalizedTokenAddresses,
-        protocol,
-        chainId,
-      );
-      if (!batchPools.success) {
-        return batchPools;
-      }
-
-      collectedPools.push(...(batchPools.data || []));
-    }
-
-    if (tokenSymbols.length > 0) {
-      const symbolPools = await this.searchPoolsBySymbols(
-        { ...filter, chainId, protocol },
-        tokenSymbols,
-      );
-      if (!symbolPools.success) {
-        return symbolPools;
-      }
-
-      collectedPools.push(...(symbolPools.data || []));
-    }
-
-    return {
-      data: this.applyPoolSearchResultFilters(collectedPools, filter),
-      status: 200,
-      success: true,
-    };
-  }
-}