@steerprotocol/sdk 1.31.0 → 2.0.0

package/src/base/VaultClient.ts

@@ -1,2294 +0,0 @@
-import { createClient } from '@steerprotocol/api-sdk';
-import { Pool as PoolV3 } from "@uniswap/v3-sdk";
-import type { Address, Hash, PublicClient, WalletClient } from 'viem';
-import { chainIdToName, getBeaconNameByProtocol, getProtocolTypeByBeacon } from '../const/index.js';
-import { getAmmConfig } from '../const/amm/configs/ammConfig.js';
-import { getProtocolsForChainId } from '../const/amm/utils/protocol.js';
-import { ChainId, MultiPositionManagers, Protocol } from '../const/chain.js';
-import { steerSubgraphConfig } from '../const/subgraph.js';
-import { SubgraphVaultClient } from '../utils/SubgraphVaultClient.js';
-import { getApiUrl } from '../const/api.js';
-import { abis } from '../const/deployments/abis.js';
-import { SteerResponse, VaultDetailsResponse } from '../types.js';
-import { SubgraphClient } from './SubgraphClient.js';
-import { VaultDepositClient } from './vault/deposit/index.js';
-import { PoolInstanceParams, VaultDepositParams } from './vault/deposit/types.js';
-import { SingleAssetDepositClient } from './vault/single-asset/index.js';
-import type {
-  SingleAssetDepositParams,
-  SingleAssetDepositPreview
-} from './vault/single-asset/types.js';
-import { VaultWithdrawClient } from './vault/withdraw/index.js';
-import { TokensFromLpResponse, VaultWithdrawParams } from './vault/withdraw/types.js';
-export * from "./vault/single-asset/index.js";
-
-const VAULT_ABI = abis.QuickSwapUniv3MultiPositionLiquidityManager;
-
-// Custom ABI for reward functions
-const REWARD_FUNCTIONS_ABI = [
-  {
-    "type": "function",
-    "name": "calculatePendingRewards",
-    "inputs": [
-      {
-        "name": "user",
-        "type": "address",
-        "internalType": "address"
-      }
-    ],
-    "outputs": [
-      {
-        "name": "rewards",
-        "type": "uint256",
-        "internalType": "uint256"
-      },
-      {
-        "name": "extraRewards",
-        "type": "uint256",
-        "internalType": "uint256"
-      }
-    ],
-    "stateMutability": "view"
-  },
-  {
-    "inputs": [],
-    "name": "claimUserRewards",
-    "outputs": [
-      {
-        "internalType": "uint256",
-        "name": "",
-        "type": "uint256"
-      },
-      {
-        "internalType": "uint256",
-        "name": "",
-        "type": "uint256"
-      }
-    ],
-    "stateMutability": "nonpayable",
-    "type": "function"
-  },
-  
-] as const;
-
-export interface VaultApproveParams {
-  vaultAddress: Address;
-  spender: Address;
-  amount: bigint;
-}
-
-export interface VaultAllowanceParams {
-  vaultAddress: Address;
-  owner: Address;
-  spender: Address;
-}
-
-export interface VaultBalanceParams {
-  vaultAddress: Address;
-  account: Address;
-}
-
-// Pagination interfaces matching API SDK types
-export interface ApiPageInfo {
-  hasNextPage: boolean;
-  endCursor: string | null;
-}
-
-export interface VaultNode {
-  id: string;
-  chainId: number;
-  vaultAddress: string;
-  protocol: string;
-  beaconName: string;
-  protocolBaseType: string;
-  name: string;
-  feeApr?: number;
-  stakingApr?: number;
-  merklApr?: number;
-  /** Raw positions from the subgraph. Only available when sourced from subgraph. */
-  positions?: {
-    id: string;
-    upperTick: number;
-    lowerTick: number;
-    relativeWeight: string;
-  }[];
-  /** Computed tick range across all current positions (min lower / max upper). Only available when sourced from subgraph. */
-  tickRange?: {
-    minLowerTick: number;
-    maxUpperTick: number;
-  };
-  /** Cumulative fees collected by the vault. Only available when sourced from subgraph. */
-  fees?: {
-    fees0: string;
-    fees1: string;
-  };
-  pool: {
-    poolAddress: string;
-    id: string;
-    feeTier: string;
-    tick?: string;
-    liquidity?: string;
-    volumeUSD?: string;
-    totalValueLockedUSD?: string;
-  };
-  token0: {
-    id: string;
-    symbol: string;
-    name: string;
-    decimals: number;
-    address: string;
-    chainId: number;
-  };
-  token1: {
-    id: string;
-    symbol: string;
-    name: string;
-    decimals: number;
-    address: string;
-    chainId: number;
-  };
-}
-
-export interface VaultEdge {
-  cursor: string;
-  node: VaultNode;
-}
-
-export interface VaultsConnection {
-  edges: readonly VaultEdge[];
-  pageInfo: ApiPageInfo;
-  totalCount: number;
-}
-
-export interface TokenNode {
-  id: string;
-  symbol: string;
-  name: string;
-  decimals: number;
-  chainId: number;
-  address: string;
-}
-
-export interface TokenEdge {
-  cursor: string;
-  node: TokenNode;
-}
-
-export interface TokensConnection {
-  edges: readonly TokenEdge[];
-  pageInfo: ApiPageInfo;
-  totalCount: number;
-}
-
-export interface PoolNode {
-  id: string;
-  chainId: number;
-  feeTier: string;
-  token0: {
-    id: string;
-    symbol: string;
-    name: string;
-    decimals: number;
-    address: string;
-    chainId: number;
-  };
-  token1: {
-    id: string;
-    symbol: string;
-    name: string;
-    decimals: number;
-    address: string;
-    chainId: number;
-  };
-}
-
-export interface PoolEdge {
-  cursor: string;
-  node: PoolNode;
-}
-
-export interface PoolsConnection {
-  edges: readonly PoolEdge[];
-  pageInfo: ApiPageInfo;
-  totalCount: number;
-}
-
-export interface VaultFilter {
-  chainId?: number;
-  protocol?: string;
-  isActive?: boolean;
-  beaconName?: string;
-  poolAddress?: string;
-  vaultAddress?: string;
-  tokenAddress?: string;
-  tokenAddresses?: string[];
-  tokenSymbol?: string;
-  tokenSymbols?: string[];
-}
-
-// API-specific filter that excludes protocol field
-export interface ApiVaultFilter {
-  chainId?: number;
-  isActive?: boolean;
-  beaconName?: string;
-  pool?: string;
-}
-
-export interface TokenFilter {
-  chainId?: number;
-  symbol?: string;
-}
-
-export interface PoolFilter {
-  chainId?: number;
-  protocol?: string;
-  minLiquidity?: string;
-}
-
-export interface VaultApr {
-  apr: {
-    apr: number;
-    message: string;
-  };
-  beaconName: string;
-  vaultAddress: string;
-}
-
-export interface AprResponse {
-  vaults: VaultApr[];
-}
-
-export interface AprFilter {
-  chainId: number;
-  protocol: string;
-}
-
-export interface PendingRewardsParams {
-  vaultAddress: Address;
-  user: Address;
-}
-
-export interface PendingRewardsResponse {
-  rewards: bigint;
-  extraRewards: bigint;
-}
-
-export interface ClaimRewardsParams {
-  vaultAddress: Address;
-}
-
-export interface BlackholeAprDetailedParams {
-  vaultAddress: Address;
-  chainId: number;
-}
-
-export interface BlackholeSnapshotAnalysis {
-  period: number;
-  fromTimestamp: number;
-  toTimestamp: number;
-  fromDate: string;
-  toDate: string;
-  durationSeconds: number;
-  durationHours: number;
-  tvlUSD: number;
-  feesUSD: number;
-  apr: number;
-}
-
-export interface BlackholeAprDetailedResponse {
-  vaultAddress: string;
-  beaconName: string;
-  apr: {
-    apr: number;
-    message: string;
-  };
-  snapshotAnalysis: BlackholeSnapshotAnalysis[];
-}
-
-/**
- * Client for interacting with Steer Protocol's Vault system.
- * This client provides functionality for vault operations, deposit/withdraw, and comprehensive data fetching.
- * 
- * **Features:**
- * - Vault data includes associated pool information (pool address, fee tier) along with token details
- * - Full pagination support for all data fetching methods
- * - API client integration for efficient data retrieval
- * - Backward compatibility with subgraph queries
- * 
- * **Available API Client Methods:**
- * - `getVaults()` - Get vaults with pagination and filtering
- * - `getTokens()` - Get tokens with pagination and filtering
- * - `getPools()` - Get pools with pagination and filtering
- * - `getAllVaults()` - Get all vaults (auto-pagination)
- * - `getAllTokens()` - Get all tokens (auto-pagination)
- * - `getAllPools()` - Get all pools (auto-pagination)
- * 
- * @example
- * ```typescript
- * import { createPublicClient, createWalletClient, http } from 'viem';
- * import { mainnet } from 'viem/chains';
- * import { VaultClient } from '@steerprotocol/sdk';
- * 
- * // Create viem clients
- * const publicClient = createPublicClient({
- *   chain: mainnet,
- *   transport: http()
- * });
- * 
- * const walletClient = createWalletClient({
- *   chain: mainnet,
- *   transport: http()
- * });
- * 
- * // Initialize the Vault client
- * const vaultClient = new VaultClient(publicClient, walletClient, 'production');
- * 
- * // Get vaults with pagination - includes pool information
- * const vaults = await vaultClient.getVaults({ chainId: 1 }, 10, null);
- * 
- * if (vaults.success && vaults.data) {
- *   vaults.data.edges.forEach((edge) => {
- *     const vault = edge.node;
- *     console.log(`${vault.token0.symbol}/${vault.token1.symbol} vault`);
- *     console.log(`Pool: ${vault.pool.id} (${vault.pool.feeTier} fee tier)`);
- *     console.log(`Protocol: ${vault.protocol} (${vault.beaconName})`);
- *   });
- * }
- * 
- * // Get all tokens for a chain
- * const allTokens = await vaultClient.getAllTokens({ chainId: 1 });
- * 
- * // Get pools with specific filters
- * const pools = await vaultClient.getPools({ 
- *   chainId: 1, 
- *   protocol: 'uniswap-v3' 
- * });
- * 
- * // Traditional vault operations
- * const depositTx = await vaultClient.deposit(depositParams);
- * const withdrawTx = await vaultClient.withdraw(withdrawParams);
- * ```
- * 
- * @group Client
- */
-export class VaultClient extends SubgraphClient {
-  protected readonly apiClient: ReturnType<typeof createClient>;
-  protected readonly publicClient: PublicClient;
-  protected readonly walletClient: WalletClient;
-  private readonly depositClient: VaultDepositClient;
-  private readonly withdrawClient: VaultWithdrawClient;
-  public readonly singleAssetDepositClient: SingleAssetDepositClient;
-  private readonly subgraphVaultClient: SubgraphVaultClient;
-  private readonly subgraphStudioKey: string;
-
-  /**
-   * Creates a new instance of VaultClient
-   * @param publicClient - The public client for reading from the blockchain
-   * @param walletClient - The wallet client for writing to the blockchain
-   * @param environment - The environment to use ('production' or 'development')
-   * @param version - Optional API version to use (defaults to 'v1')
-   * @param subgraphStudioKey - Optional subgraph studio key for protocol data fetching
-   */
-  constructor(
-    publicClient: PublicClient, 
-    walletClient: WalletClient,
-    environment: 'production' | 'development',
-    version: 'v1' = 'v1',
-    subgraphStudioKey?: string
-  ) {
-    const combinedClient = publicClient as PublicClient & WalletClient;
-    super(combinedClient);
-    
-    const apiUrl = getApiUrl(environment, version);
-    this.apiClient = createClient(apiUrl);
-    this.publicClient = publicClient;
-    this.walletClient = walletClient;
-    this.depositClient = new VaultDepositClient(publicClient, walletClient);
-    this.withdrawClient = new VaultWithdrawClient(publicClient, walletClient);
-    this.singleAssetDepositClient = new SingleAssetDepositClient(publicClient, walletClient);
-    this.subgraphVaultClient = new SubgraphVaultClient();
-    this.subgraphStudioKey = subgraphStudioKey || '';
-  }
-
-  private normalizeProtocolValue(value: string): string {
-    return value.toLowerCase().replace(/[^a-z0-9]/g, '');
-  }
-
-  private resolveProtocolEnum(protocol?: string): Protocol | null {
-    if (!protocol) {
-      return null;
-    }
-
-    const normalizedProtocol = this.normalizeProtocolValue(protocol);
-    const matchedProtocol = Object.values(Protocol).find(
-      protocolValue => this.normalizeProtocolValue(protocolValue) === normalizedProtocol
-    );
-
-    return matchedProtocol || null;
-  }
-
-  private getProtocolBeaconNames(protocol?: string): string[] {
-    const resolvedProtocol = this.resolveProtocolEnum(protocol);
-    if (!resolvedProtocol) {
-      return [];
-    }
-
-    const protocolConfig = getAmmConfig(this.subgraphStudioKey)[resolvedProtocol];
-    const beaconNames: string[] = [];
-
-    if (protocolConfig?.beaconContract) {
-      beaconNames.push(protocolConfig.beaconContract);
-    }
-
-    if (protocolConfig?.beaconContractSushiManaged) {
-      beaconNames.push(protocolConfig.beaconContractSushiManaged);
-    }
-
-    if (resolvedProtocol === Protocol.Blackhole) {
-      beaconNames.push(MultiPositionManagers.MultiPositionBlackholeOld);
-    }
-
-    const beaconAlias = getBeaconNameByProtocol(resolvedProtocol);
-    if (beaconAlias) {
-      beaconNames.push(beaconAlias);
-    }
-
-    return [...new Set(beaconNames.filter(name => name.length > 0))];
-  }
-
-  private getPrimaryProtocolBeaconName(protocol?: string): string | null {
-    const resolvedProtocol = this.resolveProtocolEnum(protocol);
-    if (!resolvedProtocol) {
-      return null;
-    }
-
-    const protocolConfig = getAmmConfig(this.subgraphStudioKey)[resolvedProtocol];
-    return protocolConfig?.beaconContract || null;
-  }
-
-  private buildApiVaultFilter(filter?: VaultFilter): ApiVaultFilter | undefined {
-    if (!filter) {
-      return undefined;
-    }
-
-    const { protocol, poolAddress, chainId, isActive, beaconName } = filter;
-    const apiFilter: ApiVaultFilter = {
-      chainId,
-      isActive,
-      beaconName,
-    };
-
-    if (poolAddress) {
-      apiFilter.pool = poolAddress;
-    }
-
-    if (!apiFilter.beaconName && protocol) {
-      const primaryBeaconName = this.getPrimaryProtocolBeaconName(protocol);
-      if (primaryBeaconName) {
-        apiFilter.beaconName = primaryBeaconName;
-      }
-    }
-
-    return apiFilter;
-  }
-
-  private vaultMatchesProtocolFilter(
-    vault: VaultNode,
-    protocolFilter: string,
-    resolvedProtocol: Protocol | null
-  ): boolean {
-    const normalizedFilter = this.normalizeProtocolValue(protocolFilter);
-    const normalizedBeaconName = this.normalizeProtocolValue(vault.beaconName);
-    const resolvedVaultProtocol = getProtocolTypeByBeacon(vault.beaconName);
-
-    const directCandidates = [vault.protocol, vault.protocolBaseType, resolvedVaultProtocol || ''];
-    const hasDirectMatch = directCandidates.some(candidate => {
-      if (!candidate) {
-        return false;
-      }
-      return this.normalizeProtocolValue(candidate) === normalizedFilter;
-    });
-
-    if (hasDirectMatch) {
-      return true;
-    }
-
-    const expectedBeacon = resolvedProtocol
-      ? getBeaconNameByProtocol(resolvedProtocol)
-      : protocolFilter;
-    const normalizedExpectedBeacon = this.normalizeProtocolValue(expectedBeacon);
-
-    return normalizedExpectedBeacon.length > 0 && normalizedBeaconName.includes(normalizedExpectedBeacon);
-  }
-
-  private applyProtocolFilter(vaultsConnection: VaultsConnection, protocol?: string): VaultsConnection {
-    if (!protocol) {
-      return vaultsConnection;
-    }
-
-    const resolvedProtocol = this.resolveProtocolEnum(protocol);
-    const filteredEdges = vaultsConnection.edges.filter(edge =>
-      this.vaultMatchesProtocolFilter(edge.node, protocol, resolvedProtocol)
-    );
-
-    return {
-      ...vaultsConnection,
-      edges: filteredEdges
-    };
-  }
-
-  private normalizeAddress(value?: string): string {
-    return value?.toLowerCase() || '';
-  }
-
-  private normalizeSymbol(value?: string): string {
-    return value?.trim().toLowerCase() || '';
-  }
-
-  private matchesAnyAddress(candidates: Array<string | undefined>, filterValues: string[]): boolean {
-    if (filterValues.length === 0) {
-      return true;
-    }
-
-    const normalizedCandidates = new Set(
-      candidates.map((candidate) => this.normalizeAddress(candidate)).filter(Boolean),
-    );
-
-    return filterValues.some((value) => normalizedCandidates.has(value));
-  }
-
-  private matchesAnySymbol(candidates: Array<string | undefined>, filterValues: string[]): boolean {
-    if (filterValues.length === 0) {
-      return true;
-    }
-
-    const normalizedCandidates = new Set(
-      candidates.map((candidate) => this.normalizeSymbol(candidate)).filter(Boolean),
-    );
-
-    return filterValues.some((value) => normalizedCandidates.has(value));
-  }
-
-  private filterVaultNodes(vaults: VaultNode[], filter: VaultFilter): VaultNode[] {
-    const vaultAddress = this.normalizeAddress(filter.vaultAddress);
-    const poolAddress = this.normalizeAddress(filter.poolAddress);
-    const tokenAddressFilters = [
-      ...(filter.tokenAddress ? [filter.tokenAddress] : []),
-      ...(filter.tokenAddresses || []),
-    ]
-      .map((address) => this.normalizeAddress(address))
-      .filter(Boolean);
-    const tokenSymbolFilters = [
-      ...(filter.tokenSymbol ? [filter.tokenSymbol] : []),
-      ...(filter.tokenSymbols || []),
-    ]
-      .map((symbol) => this.normalizeSymbol(symbol))
-      .filter(Boolean);
-
-    return vaults.filter((vault) => {
-      if (vaultAddress && this.normalizeAddress(vault.vaultAddress) !== vaultAddress) {
-        return false;
-      }
-
-      if (
-        poolAddress &&
-        !this.matchesAnyAddress([vault.pool.poolAddress, vault.pool.id], [poolAddress])
-      ) {
-        return false;
-      }
-
-      if (
-        !this.matchesAnyAddress(
-          [vault.token0.address, vault.token0.id, vault.token1.address, vault.token1.id],
-          tokenAddressFilters,
-        )
-      ) {
-        return false;
-      }
-
-      if (
-        !this.matchesAnySymbol(
-          [vault.token0.symbol, vault.token1.symbol],
-          tokenSymbolFilters,
-        )
-      ) {
-        return false;
-      }
-
-      return true;
-    });
-  }
-
-  /**
-   * Gets vaults with pagination support
-   * Fetches ALL data from both API (database) and subgraph in parallel, merges without duplicates, then paginates
-   * @param filter - Optional filter criteria
-   * @param first - Number of items to fetch (default: 50)
-   * @param after - Cursor for pagination (null for first page)
-   * @returns Promise resolving to paginated vaults data
-   * 
-   * @example
-   * ```typescript
-   * // Get first 20 vaults for Ethereum
-   * const vaults = await vaultClient.getVaults({ chainId: 1 }, 20);
-   * 
-   * if (vaults.success && vaults.data) {
-   *   vaults.data.edges.forEach((edge) => {
-   *     const vault = edge.node;
-   *     console.log(`Vault: ${vault.name}`);
-   *     console.log(`Pool: ${vault.pool.id}`);
-   *     console.log(`Pool Fee Tier: ${vault.pool.feeTier}`);
-   *     console.log(`Tokens: ${vault.token0.symbol}/${vault.token1.symbol}`);
-   *   });
-   * }
-   * 
-   * // Get next page using cursor
-   * if (vaults.data?.pageInfo.hasNextPage) {
-   *   const nextPage = await vaultClient.getVaults(
-   *     { chainId: 1 }, 
-   *     20, 
-   *     vaults.data.pageInfo.endCursor
-   *   );
-   * }
-   * 
-   * // For additional pool details (liquidity, volume, etc.), use the PoolClient:
-   * // const poolDetails = await poolClient.getPoolById(vault.pool.id, protocol, chainId);
-   * ```
-   */
-  public async getVaults(
-    filter?: VaultFilter,
-    first: number = 50,
-    after?: string | null
-  ): Promise<SteerResponse<VaultsConnection>> {
-    const apiFilter = this.buildApiVaultFilter(filter);
-
-    // Fetch ALL vaults from both sources in parallel (no pagination at source level)
-    const [apiResult, subgraphResult] = await Promise.allSettled([
-      this.getAllVaultsFromApi(apiFilter),
-      filter?.chainId !== ChainId.Avalanche ? this.getAllVaultsFromSubgraph(filter) : Promise.reject(new Error('Avalanche not supported'))
-    ]);
-
-    // Extract successful results
-    const apiVaults: VaultEdge[] = apiResult.status === 'fulfilled' && apiResult.value.success && apiResult.value.data 
-      ? apiResult.value.data
-      : [];
-    
-    const subgraphVaults: VaultEdge[] = subgraphResult.status === 'fulfilled' && subgraphResult.value.success && subgraphResult.value.data 
-      ? subgraphResult.value.data
-      : [];
-
-    // If both failed, return error
-    if (apiVaults.length === 0 && subgraphVaults.length === 0) {
-      const apiError = apiResult.status === 'rejected' ? apiResult.reason : null;
-      const subgraphError = subgraphResult.status === 'rejected' ? subgraphResult.reason : null;
-      
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: `Both API and subgraph failed. API: ${apiError?.message || 'Unknown error'}. Subgraph: ${subgraphError?.message || 'Unknown error'}`
-      };
-    }
-
-    // Merge results and remove duplicates based on vaultAddress
-    const mergedVaults = this.mergeVaultResults(apiVaults, subgraphVaults);
-
-    // Apply protocol filter to merged results
-    const filteredVaults = mergedVaults.filter(edge => 
-      !filter?.protocol || this.vaultMatchesProtocolFilter(edge.node, filter.protocol, this.resolveProtocolEnum(filter.protocol))
-    );
-
-    // Apply pagination to the complete merged and filtered dataset
-    const paginatedVaults = this.paginateVaults(filteredVaults, first, after);
-
-    return {
-      data: paginatedVaults,
-      status: 200,
-      success: true
-    };
-  }
-
-  /**
-   * Fetches ALL vaults from API (database) by auto-paginating
-   * @private
-   */
-  private async getAllVaultsFromApi(
-    apiFilter?: ApiVaultFilter
-  ): Promise<SteerResponse<VaultEdge[]>> {
-    try {
-      const allVaults: VaultEdge[] = [];
-      let hasNextPage = true;
-      let cursor: string | null = null;
-      const batchSize = 100; // Fetch in batches of 100
-
-      while (hasNextPage) {
-        const response = await this.getVaultsFromApi(apiFilter, batchSize, cursor);
-        
-        if (!response.success || !response.data) {
-          // If we already have some vaults, return them; otherwise return error
-          if (allVaults.length > 0) {
-            break;
-          }
-          return {
-            data: null,
-            status: response.status,
-            success: false,
-            error: response.error || 'Failed to fetch vaults from API'
-          };
-        }
-
-        allVaults.push(...response.data.edges);
-        hasNextPage = response.data.pageInfo.hasNextPage;
-        cursor = response.data.pageInfo.endCursor;
-      }
-
-      return {
-        data: allVaults,
-        status: 200,
-        success: true
-      };
-    } catch (error) {
-      console.warn('Failed to fetch all vaults from API:', error);
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Failed to fetch all vaults from API'
-      };
-    }
-  }
-
-  /**
-   * Fetches vaults from API (database) with pagination
-   * @private
-   */
-  private async getVaultsFromApi(
-    apiFilter?: ApiVaultFilter,
-    first: number = 50,
-    after?: string | null
-  ): Promise<SteerResponse<VaultsConnection>> {
-    try {
-      const response = await this.apiClient.vaults({
-        filter: apiFilter,
-        first,
-        after
-      });
-
-      if (!response.data?.vaults) {
-        return {
-          data: null,
-          status: response.status,
-          success: false,
-          error: 'No data returned from API'
-        };
-      }
-
-      // Transform the response to match our interface
-      const transformedData: VaultsConnection = {
-        edges: response.data.vaults.edges.map(edge => ({
-          cursor: edge.cursor,
-          node: {
-            id: edge.node.id,
-            chainId: edge.node.chainId,
-            vaultAddress: edge.node.vaultAddress,
-            protocol: edge.node.protocol,
-            beaconName: edge.node.beaconName,
-            protocolBaseType: edge.node.protocolBaseType,
-            name: edge.node.name || '',
-            feeApr: edge.node.feeApr || undefined,
-            stakingApr: edge.node.stakingApr || undefined,
-            merklApr: edge.node.merklApr || undefined,
-            pool: {
-              id: edge.node.pool?.id || '',
-              poolAddress: edge.node.pool?.poolAddress || '',
-              feeTier: edge.node.pool?.feeTier || '',
-              tick: undefined, // Not available in API response
-              liquidity: undefined, // Not available in API response
-              volumeUSD: undefined, // Not available in API response
-              totalValueLockedUSD: undefined // Not available in API response
-            },
-            token0: {
-              id: edge.node.token0?.id || '',
-              symbol: edge.node.token0?.symbol || '',
-              name: edge.node.token0?.name || '',
-              decimals: edge.node.token0?.decimals || 0,
-              address: edge.node.token0?.address || '',
-              chainId: edge.node.token0?.chainId || 0
-            },
-            token1: {
-              id: edge.node.token1?.id || '',
-              symbol: edge.node.token1?.symbol || '',
-              name: edge.node.token1?.name || '',
-              decimals: edge.node.token1?.decimals || 0,
-              address: edge.node.token1?.address || '',
-              chainId: edge.node.token1?.chainId || 0
-            }
-          }
-        })),
-        pageInfo: {
-          hasNextPage: response.data.vaults.pageInfo.hasNextPage,
-          endCursor: response.data.vaults.pageInfo.endCursor ?? null
-        },
-        totalCount: response.data.vaults.totalCount
-      };
-
-      return {
-        data: transformedData,
-        status: response.status,
-        success: true
-      };
-    } catch (error) {
-      console.warn('API client failed:', error);
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'API request failed'
-      };
-    }
-  }
-
-  /**
-   * Merges vault results from API and subgraph, removing duplicates
-   * Prioritizes API data when duplicates are found
-   * Generates consistent cursors for the merged dataset
-   * @private
-   */
-  private mergeVaultResults(apiVaults: VaultEdge[], subgraphVaults: VaultEdge[]): VaultEdge[] {
-    const vaultMap = new Map<string, VaultEdge>();
-
-    // Add API vaults first (they take priority)
-    apiVaults.forEach(edge => {
-      const key = edge.node.vaultAddress.toLowerCase();
-      vaultMap.set(key, edge);
-    });
-
-    // Add subgraph vaults only if not already present
-    subgraphVaults.forEach(edge => {
-      const key = edge.node.vaultAddress.toLowerCase();
-      if (!vaultMap.has(key)) {
-        vaultMap.set(key, edge);
-      } else {
-        // Merge additional data from subgraph if available (like pool details)
-        const existing = vaultMap.get(key)!;
-        const merged: VaultEdge = {
-          ...existing,
-          node: {
-            ...existing.node,
-            // Merge pool data - prefer subgraph data for pool details if API doesn't have it
-            pool: {
-              id: existing.node.pool.id || edge.node.pool.id,
-              poolAddress: existing.node.pool.poolAddress || edge.node.pool.poolAddress,
-              feeTier: existing.node.pool.feeTier || edge.node.pool.feeTier,
-              tick: existing.node.pool.tick || edge.node.pool.tick,
-              liquidity: existing.node.pool.liquidity || edge.node.pool.liquidity,
-              volumeUSD: existing.node.pool.volumeUSD || edge.node.pool.volumeUSD,
-              totalValueLockedUSD: existing.node.pool.totalValueLockedUSD || edge.node.pool.totalValueLockedUSD
-            },
-            // Prefer API APR data, but use subgraph if API doesn't have it
-            feeApr: existing.node.feeApr ?? edge.node.feeApr,
-            stakingApr: existing.node.stakingApr ?? edge.node.stakingApr,
-            merklApr: existing.node.merklApr ?? edge.node.merklApr,
-            // Subgraph-only fields: always take from subgraph when available
-            positions: existing.node.positions ?? edge.node.positions,
-            tickRange: existing.node.tickRange ?? edge.node.tickRange,
-            fees: existing.node.fees ?? edge.node.fees,
-          }
-        };
-        vaultMap.set(key, merged);
-      }
-    });
-
-    // Convert to array and regenerate cursors for consistent pagination
-    const mergedArray = Array.from(vaultMap.values());
-    return mergedArray.map((edge, index) => ({
-      ...edge,
-      cursor: `merged_${edge.node.chainId}_${index}_${edge.node.vaultAddress.toLowerCase()}`
-    }));
-  }
-
-  /**
-   * Applies pagination to vault results
-   * @private
-   */
-  private paginateVaults(vaults: VaultEdge[], first: number, after?: string | null): VaultsConnection {
-    let startIndex = 0;
-
-    // If cursor is provided, find the starting position
-    if (after) {
-      const cursorIndex = vaults.findIndex(edge => edge.cursor === after);
-      if (cursorIndex !== -1) {
-        startIndex = cursorIndex + 1;
-      }
-    }
-
-    // Get the slice of vaults for this page
-    const paginatedEdges = vaults.slice(startIndex, startIndex + first);
-    const hasNextPage = startIndex + first < vaults.length;
-    const endCursor = paginatedEdges.length > 0 ? paginatedEdges[paginatedEdges.length - 1].cursor : null;
-
-    return {
-      edges: paginatedEdges,
-      pageInfo: {
-        hasNextPage,
-        endCursor
-      },
-      totalCount: vaults.length
-    };
-  }
-
-  /**
-   * Fetches ALL vaults from subgraph (no pagination)
-   * @param filter - Optional filter criteria
-   * @returns Promise resolving to all vaults data from subgraph
-   * @private
-   */
-  private async getAllVaultsFromSubgraph(
-    filter?: VaultFilter
-  ): Promise<SteerResponse<VaultEdge[]>> {
-    try {
-      // Extract chainId from filter
-      const chainId = filter?.chainId;
-      if (!chainId) {
-        throw new Error('ChainId is required for subgraph');
-      }
-
-      // Get chain enum from chainId
-      const chain = chainIdToName(chainId);
-      
-      if (!chain) { 
-        throw new Error(`Unsupported chainId: ${chainId}`);
-      }
-
-      // Get subgraph URL for this chain
-      const subgraphUrl = steerSubgraphConfig[chain];
-      if (!subgraphUrl) {
-        throw new Error(`No subgraph configured for chain: ${chain}`);
-      }
-
-      const beaconNames = this.getProtocolBeaconNames(filter?.protocol);
-
-      if (filter?.beaconName) {
-        beaconNames.push(filter.beaconName);
-      }
-
-      const uniqueBeaconNames = [...new Set(beaconNames.filter(name => name.length > 0))];
-
-      // Fetch all vaults from subgraph
-      const subgraphVaults = await this.subgraphVaultClient.getAllVaultsFromSubgraph({
-        subgraphUrl,
-        chainId,
-        showDeprecated: false,
-        showCurrentProtocol: uniqueBeaconNames.length > 0,
-        beaconNames: uniqueBeaconNames
-      });
-
-      // Get all supported protocols for this chain
-      const supportedProtocols = getProtocolsForChainId(chainId, this.subgraphStudioKey);
-      
-      // Fetch APR data for all protocols in parallel
-      const aprPromises = supportedProtocols.map(protocol => 
-        this.getAprs({ chainId, protocol }).catch(error => {
-          console.warn(`Failed to fetch APR for protocol ${protocol}:`, error);
-          return { success: false, data: null };
-        })
-      );
-
-      const aprResults = await Promise.all(aprPromises);
-      
-      // Create a map of vault address to APR for quick lookup
-      const aprMap = new Map<string, number>();
-      aprResults && aprResults.forEach(aprResult => {
-        if (aprResult.success && aprResult.data) {
-          aprResult?.data?.vaults && aprResult.data.vaults.forEach(vaultApr => {
-            aprMap.set(vaultApr.vaultAddress.toLowerCase(), vaultApr.apr.apr);
-          });
-        }
-      });
-
-      // Transform to VaultEdge array with APR data
-      const vaultEdges: VaultEdge[] = subgraphVaults.map((vault, index) => {
-        // Parse positions and compute tick range
-        const positions = vault.positions?.map(pos => ({
-          id: pos.id,
-          upperTick: parseInt(pos.upperTick),
-          lowerTick: parseInt(pos.lowerTick),
-          relativeWeight: pos.relativeWeight
-        }));
-
-        // Compute tick range from positions
-        let tickRange: { minLowerTick: number; maxUpperTick: number } | undefined;
-        if (positions && positions.length > 0) {
-          const lowerTicks = positions.map(p => p.lowerTick);
-          const upperTicks = positions.map(p => p.upperTick);
-          tickRange = {
-            minLowerTick: Math.min(...lowerTicks),
-            maxUpperTick: Math.max(...upperTicks)
-          };
-        }
-
-        return {
-          cursor: `subgraph_${chainId}_${index}`,
-          node: {
-            id: vault.id,
-            chainId: chainId,
-            vaultAddress: vault.id,
-            protocol: vault.beaconName || '',
-            beaconName: vault.beaconName || '',
-            protocolBaseType: vault.beaconName || '',
-            name: `${vault.token0Symbol}/${vault.token1Symbol}`,
-            feeApr: aprMap.get(vault.id.toLowerCase()),
-            stakingApr: undefined,
-            merklApr: undefined,
-            positions,
-            tickRange,
-            fees: vault.fees0 && vault.fees1 ? {
-              fees0: vault.fees0,
-              fees1: vault.fees1
-            } : undefined,
-            pool: {
-              id: vault.pool || '',
-              poolAddress: vault.pool || '',
-              feeTier: vault.feeTier || '',
-              tick: undefined,
-              liquidity: undefined,
-              volumeUSD: undefined,
-              totalValueLockedUSD: undefined
-            },
-            token0: {
-              id: vault.token0,
-              symbol: vault.token0Symbol,
-              name: vault.token0Symbol, // Use symbol as name since subgraph doesn't provide name
-              decimals: parseInt(vault.token0Decimals) || 18,
-              address: vault.token0,
-              chainId: chainId
-            },
-            token1: {
-              id: vault.token1,
-              symbol: vault.token1Symbol,
-              name: vault.token1Symbol, // Use symbol as name since subgraph doesn't provide name
-              decimals: parseInt(vault.token1Decimals) || 18,
-              address: vault.token1,
-              chainId: chainId
-            }
-          }
-        };
-      });
-
-      return {
-        data: vaultEdges,
-        status: 200,
-        success: true
-      };
-
-    } catch (error) {
-      console.error('Subgraph vault fetch failed:', error);
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Failed to fetch vaults from subgraph'
-      };
-    }
-  }
-
-  /**
-   * Fallback method to fetch vaults from subgraph with pagination
-   * @param filter - Optional filter criteria
-   * @param first - Number of items to fetch (default: 50)
-   * @param after - Cursor for pagination (null for first page)
-   * @returns Promise resolving to paginated vaults data from subgraph
-   * @private
-   */
-  private async getVaultsFromSubgraph(
-    filter?: VaultFilter,
-    first: number = 50,
-    after?: string | null
-  ): Promise<SteerResponse<VaultsConnection>> {
-    try {
-      // Extract chainId from filter
-      const chainId = filter?.chainId;
-      if (!chainId) {
-        throw new Error('ChainId is required for subgraph fallback');
-      }
-
-      // Get chain enum from chainId
-
-      const chain = chainIdToName(chainId);
-      
-      if (!chain) { 
-        throw new Error(`Unsupported chainId: ${chainId}`);
-      }
-
-      // Get subgraph URL for this chain
-      const subgraphUrl = steerSubgraphConfig[chain];
-      if (!subgraphUrl) {
-        throw new Error(`No subgraph configured for chain: ${chain}`);
-      }
-
-      const beaconNames = this.getProtocolBeaconNames(filter?.protocol);
-
-      if (filter?.beaconName) {
-        beaconNames.push(filter.beaconName);
-      }
-
-      const uniqueBeaconNames = [...new Set(beaconNames.filter(name => name.length > 0))];
-
-      // Fetch all vaults from subgraph
-      const subgraphVaults = await this.subgraphVaultClient.getAllVaultsFromSubgraph({
-        subgraphUrl,
-        chainId,
-        showDeprecated: false,
-        showCurrentProtocol: uniqueBeaconNames.length > 0,
-        beaconNames: uniqueBeaconNames
-      });
-
-      // Get all supported protocols for this chain
-      const supportedProtocols = getProtocolsForChainId(chainId, this.subgraphStudioKey);
-      
-      // Fetch APR data for all protocols in parallel
-      const aprPromises = supportedProtocols.map(protocol => 
-        this.getAprs({ chainId, protocol }).catch(error => {
-          console.warn(`Failed to fetch APR for protocol ${protocol}:`, error);
-          return { success: false, data: null };
-        })
-      );
-
-      const aprResults = await Promise.all(aprPromises);
-      
-      // Create a map of vault address to APR for quick lookup
-      const aprMap = new Map<string, number>();
-      aprResults && aprResults.forEach(aprResult => {
-        if (aprResult.success && aprResult.data) {
-          aprResult?.data?.vaults && aprResult.data.vaults.forEach(vaultApr => {
-            aprMap.set(vaultApr.vaultAddress.toLowerCase(), vaultApr.apr.apr);
-          });
-        }
-      });
-
-      // Transform to VaultsConnection format with pagination and populate APR data
-      const vaultsConnection = this.subgraphVaultClient.transformToVaultsConnection(
-        subgraphVaults,
-        chainId,
-        first,
-        aprMap,
-        after
-      );
-
-      // Enhance vault data with APR information
-      if (vaultsConnection.edges) {
-        vaultsConnection.edges = vaultsConnection.edges.map(edge => ({
-          ...edge,
-          node: {
-            ...edge.node,
-            feeApr: aprMap.get(edge.node.vaultAddress.toLowerCase()) || edge.node.feeApr
-          }
-        }));
-      }
-
-      const filteredVaultsConnection = this.applyProtocolFilter(vaultsConnection, filter?.protocol);
-
-      return {
-        data: filteredVaultsConnection,
-        status: 200,
-        success: true
-      };
-
-    } catch (error) {
-      console.error('Subgraph vault fetch failed:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * Gets tokens with pagination support
-   * @param filter - Optional filter criteria
-   * @param first - Number of items to fetch (default: 50)
-   * @param after - Cursor for pagination (null for first page)
-   * @returns Promise resolving to paginated tokens data
-   * 
-   * @example
-   * ```typescript
-   * // Get first 100 tokens
-   * const tokens = await vaultClient.getTokens({ chainId: 1 }, 100);
-   * 
-   * // Filter by symbol
-   * const usdcTokens = await vaultClient.getTokens({ symbol: 'USDC' });
-   * ```
-   */
-  public async getTokens(
-    filter?: TokenFilter,
-    first: number = 50,
-    after?: string | null
-  ): Promise<SteerResponse<TokensConnection>> {
-    try {
-      const response = await this.apiClient.tokens({
-        filter,
-        first,
-        after
-      });
-
-      if (!response.data?.tokens) {
-        return {
-          data: null,
-          status: response.status,
-          success: true
-        };
-      }
-
-      // Transform the response to match our interface
-      const transformedData: TokensConnection = {
-        edges: response.data.tokens.edges.map(edge => ({
-          cursor: edge.cursor,
-          node: {
-            id: edge.node.id,
-            symbol: edge.node.symbol,
-            name: edge.node.name,
-            decimals: edge.node.decimals,
-            chainId: edge.node.chainId,
-            address: edge.node.address
-          }
-        })),
-        pageInfo: {
-          hasNextPage: response.data.tokens.pageInfo.hasNextPage,
-          endCursor: response.data.tokens.pageInfo.endCursor ?? null
-        },
-        totalCount: response.data.tokens.totalCount
-      };
-
-      return {
-        data: transformedData,
-        status: response.status,
-        success: true
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 501,
-        success: false,
-        error: 'getTokens is not supported for this configuration'
-      };
-    }
-  }
-
-  /**
-   * Gets pools with pagination support
-   * @param filter - Optional filter criteria
-   * @param first - Number of items to fetch (default: 50)
-   * @param after - Cursor for pagination (null for first page)
-   * @returns Promise resolving to paginated pools data
-   * 
-   * @example
-   * ```typescript
-   * // Get first 50 pools for Ethereum
-   * const pools = await vaultClient.getPools({ chainId: 1 }, 50);
-   * 
-   * // Filter by minimum liquidity
-   * const liquidPools = await vaultClient.getPools({ 
-   *   chainId: 1, 
-   *   minLiquidity: '1000000' 
-   * });
-   * ```
-   */
-  public async getPools(
-    filter?: PoolFilter,
-    first: number = 50,
-    after?: string | null
-  ): Promise<SteerResponse<PoolsConnection>> {
-    try {
-      const response = await this.apiClient.pools({
-        filter,
-        first,
-        after
-      });
-
-      if (!response.data?.pools) {
-        return {
-          data: null,
-          status: response.status,
-          success: true
-        };
-      }
-
-      // Transform the response to match our interface
-      const transformedData: PoolsConnection = {
-        edges: response.data.pools.edges.map(edge => ({
-          cursor: edge.cursor,
-          node: {
-            id: edge.node.id,
-            chainId: edge.node.chainId,
-            feeTier: edge.node.feeTier,
-            token0: {
-              id: edge.node.token0?.id || '',
-              symbol: edge.node.token0?.symbol || '',
-              name: edge.node.token0?.name || '',
-              decimals: edge.node.token0?.decimals || 0,
-              address: edge.node.token0?.address || '',
-              chainId: edge.node.token0?.chainId || 0
-            },
-            token1: {
-              id: edge.node.token1?.id || '',
-              symbol: edge.node.token1?.symbol || '',
-              name: edge.node.token1?.name || '',
-              decimals: edge.node.token1?.decimals || 0,
-              address: edge.node.token1?.address || '',
-              chainId: edge.node.token1?.chainId || 0
-            }
-          }
-        })),
-        pageInfo: {
-          hasNextPage: response.data.pools.pageInfo.hasNextPage,
-          endCursor: response.data.pools.pageInfo.endCursor ?? null
-        },
-        totalCount: response.data.pools.totalCount
-      };
-
-      return {
-        data: transformedData,
-        status: response.status,
-        success: true
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 501,
-        success: false,
-        error: 'getPools is not supported for this configuration'
-      };
-    }
-  }
-
-  /**
-   * Gets all vaults by fetching all pages automatically
-   * @param filter - Optional filter criteria
-   * @param batchSize - Number of items to fetch per batch (default: 100)
-   * @returns Promise resolving to all vaults data (includes pool information)
-   * 
-   * @example
-   * ```typescript
-   * // Get all vaults for a specific chain
-   * const allVaults = await vaultClient.getAllVaults({ chainId: 1 });
-   * console.log(`Found ${allVaults.data?.length} vaults`);
-   * 
-   * // Access pool information for each vault
-   * allVaults.data?.forEach(vault => {
-   *   console.log(`Vault ${vault.name}: Pool ${vault.pool.id} (${vault.pool.feeTier} fee)`);
-   * });
-   * ```
-   */
-  public async getAllVaults(
-    filter?: VaultFilter,
-    batchSize: number = 100
-  ): Promise<SteerResponse<VaultNode[]>> {
-    try {
-      const allVaults: VaultNode[] = [];
-      let hasNextPage = true;
-      let cursor: string | null = null;
-
-      while (hasNextPage) {
-        const response = await this.getVaults(filter, batchSize, cursor);
-        
-        if (!response.success || !response.data) {
-          return {
-            data: null,
-            status: response.status,
-            success: false,
-            error: response.error || 'Failed to fetch vaults'
-          };
-        }
-
-        allVaults.push(...response.data.edges.map(edge => edge.node));
-        hasNextPage = response.data.pageInfo.hasNextPage;
-        cursor = response.data.pageInfo.endCursor;
-      }
-
-      return {
-        data: allVaults,
-        status: 200,
-        success: true
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred'
-      };
-    }
-  }
-
-  /**
-   * Gets all tokens by fetching all pages automatically
-   * @param filter - Optional filter criteria
-   * @param batchSize - Number of items to fetch per batch (default: 100)
-   * @returns Promise resolving to all tokens data
-   */
-  public async getAllTokens(
-    filter?: TokenFilter,
-    batchSize: number = 100
-  ): Promise<SteerResponse<TokenNode[]>> {
-    try {
-      const allTokens: TokenNode[] = [];
-      let hasNextPage = true;
-      let cursor: string | null = null;
-
-      while (hasNextPage) {
-        const response = await this.getTokens(filter, batchSize, cursor);
-        
-        if (!response.success || !response.data) {
-          return {
-            data: null,
-            status: response.status,
-            success: false,
-            error: response.error || 'Failed to fetch tokens'
-          };
-        }
-
-        allTokens.push(...response.data.edges.map(edge => edge.node));
-        hasNextPage = response.data.pageInfo.hasNextPage;
-        cursor = response.data.pageInfo.endCursor;
-      }
-
-      return {
-        data: allTokens,
-        status: 200,
-        success: true
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred'
-      };
-    }
-  }
-
-  /**
-   * Gets all pools by fetching all pages automatically
-   * @param filter - Optional filter criteria
-   * @param batchSize - Number of items to fetch per batch (default: 100)
-   * @returns Promise resolving to all pools data
-   */
-  public async getAllPools(
-    filter?: PoolFilter,
-    batchSize: number = 100
-  ): Promise<SteerResponse<PoolNode[]>> {
-    try {
-      const allPools: PoolNode[] = [];
-      let hasNextPage = true;
-      let cursor: string | null = null;
-
-      while (hasNextPage) {
-        const response = await this.getPools(filter, batchSize, cursor);
-        
-        if (!response.success || !response.data) {
-          return {
-            data: null,
-            status: response.status,
-            success: false,
-            error: response.error || 'Failed to fetch pools'
-          };
-        }
-
-        allPools.push(...response.data.edges.map(edge => edge.node));
-        hasNextPage = response.data.pageInfo.hasNextPage;
-        cursor = response.data.pageInfo.endCursor;
-      }
-
-      return {
-        data: allPools,
-        status: 200,
-        success: true
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 501,
-        success: false,
-        error: 'getAllPools is not supported for this configuration'
-      };
-    }
-  }
-
-  /**
-   * Searches vaults by combining verified API-supported filters with local
-   * filtering over the merged vault result set for unsupported server-side fields.
-   */
-  public async searchVaults(
-    filter?: VaultFilter,
-  ): Promise<SteerResponse<VaultNode[]>> {
-    const response = await this.getAllVaults(filter);
-
-    if (!response.success || !response.data) {
-      return response;
-    }
-
-    return {
-      data: this.filterVaultNodes(response.data, filter || {}),
-      status: 200,
-      success: true,
-    };
-  }
-
-  public async getVaultByAddress(
-    vaultAddress: string,
-    filter?: VaultFilter,
-  ): Promise<SteerResponse<VaultNode | null>> {
-    const response = await this.searchVaults({
-      ...filter,
-      vaultAddress,
-    });
-
-    if (!response.success || !response.data) {
-      return {
-        data: null,
-        status: response.status,
-        success: response.success,
-        error: response.error,
-      };
-    }
-
-    return {
-      data: response.data[0] || null,
-      status: 200,
-      success: true,
-    };
-  }
-
-  public async getVaultsForPool(
-    poolAddress: string,
-    filter?: VaultFilter,
-  ): Promise<SteerResponse<VaultNode[]>> {
-    return this.searchVaults({
-      ...filter,
-      poolAddress,
-    });
-  }
-
-  public async getVaultsForToken(
-    tokenAddressOrSymbol: string,
-    filter?: VaultFilter,
-  ): Promise<SteerResponse<VaultNode[]>> {
-    const normalizedValue = tokenAddressOrSymbol.trim();
-    const isAddress = /^0x[a-fA-F0-9]{40}$/.test(normalizedValue);
-
-    return this.searchVaults({
-      ...filter,
-      ...(isAddress
-        ? { tokenAddress: normalizedValue }
-        : { tokenSymbol: normalizedValue }),
-    });
-  }
-
-  /**
-   * Gets APR data for vaults from the Steer Finance API
-   * @param filter - Filter containing chainId and protocol
-   * @returns Promise resolving to APR data for vaults
-   * 
-   * @example
-   * ```typescript
-   * // Get APRs for Uniswap vaults on Nibiru (chainId: 6900)
-   * const aprs = await vaultClient.getAprs({ chainId: 6900, protocol: 'Uniswap' });
-   * 
-   * if (aprs.success && aprs.data) {
-   *   aprs.data.vaults.forEach(vault => {
-   *     console.log(`Vault: ${vault.vaultAddress}`);
-   *     console.log(`APR: ${vault.apr.apr}% (${vault.apr.message})`);
-   *     console.log(`Beacon: ${vault.beaconName}`);
-   *   });
-   * }
-   * ```
-   */
-  public async getAprs(filter: AprFilter): Promise<SteerResponse<AprResponse>> {
-    try {
-      const { chainId, protocol } = filter;
-      
-      // Build the API URL
-      const apiUrl = `https://api.steer.finance/getAprs?chainId=${chainId}&dexName=${protocol}`;
-      
-      const response = await fetch(apiUrl, {
-        method: 'GET',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-      });
-
-      if (!response.ok) {
-        return {
-          data: null,
-          status: response.status,
-          success: false,
-          error: `API request failed: ${response.statusText}`
-        };
-      }
-
-      const data: AprResponse = await response.json();
-
-      return {
-        data,
-        status: response.status,
-        success: true
-      };
-
-    } catch (error) {
-      return {
-        data: null,
-        status: 501,
-        success: false,
-        error: 'getAprs is not supported for this configuration'
-      };
-    }
-  }
-
-  /**
-   * Gets detailed APR data for a specific Blackhole vault from the Steer Finance API
-   * This includes snapshot analysis with historical APR data over different time periods
-   * 
-   * @param params - Parameters containing vault address and chain ID
-   * @returns Promise resolving to detailed APR data including snapshot analysis
-   * 
-   * @example
-   * ```typescript
-   * // Get detailed APR for a Blackhole vault on Avalanche
-   * const aprDetails = await vaultClient.getBlackholeAprDetailed({
-   *   vaultAddress: '0x5c1d454f08975c554f6b70a84fd8859fbdfcc069',
-   *   chainId: 43114
-   * });
-   * 
-   * if (aprDetails.success && aprDetails.data) {
-   *   console.log(`Vault: ${aprDetails.data.vaultAddress}`);
-   *   console.log(`Beacon: ${aprDetails.data.beaconName}`);
-   *   console.log(`Current APR: ${aprDetails.data.apr.apr}% (${aprDetails.data.apr.message})`);
-   *   
-   *   // Access snapshot analysis
-   *   aprDetails.data.snapshotAnalysis.forEach(snapshot => {
-   *     console.log(`Period ${snapshot.period}:`);
-   *     console.log(`  Duration: ${snapshot.durationHours} hours`);
-   *     console.log(`  TVL: $${snapshot.tvlUSD}`);
-   *     console.log(`  Fees: $${snapshot.feesUSD}`);
-   *     console.log(`  APR: ${snapshot.apr}%`);
-   *   });
-   * }
-   * ```
-   */
-  public async getBlackholeVaultApr(params: BlackholeAprDetailedParams): Promise<SteerResponse<BlackholeAprDetailedResponse>> {
-    try {
-      const { vaultAddress, chainId } = params;
-      
-      // Build the API URL
-      const apiUrl = `https://api.steer.finance/blackhole/apr-detailed?vaultAddress=${vaultAddress}&chainId=${chainId}`;
-      
-      const response = await fetch(apiUrl, {
-        method: 'GET',
-        headers: {
-          'Content-Type': 'application/json',
-        },
-      });
-
-      if (!response.ok) {
-        return {
-          data: null,
-          status: response.status,
-          success: false,
-          error: `API request failed: ${response.statusText}`
-        };
-      }
-
-      const data: BlackholeAprDetailedResponse = await response.json();
-
-      return {
-        data,
-        status: response.status,
-        success: true
-      };
-
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Failed to fetch Blackhole APR details'
-      };
-    }
-  }
-
-  /**
-   * Gets the latest vaults from the subgraph
-   */
-  public async getLatestVaults<T>(): Promise<SteerResponse<T>> {
-    const query = `      
-        query latestVaults{
-            vaults(first: 250, skip: 0, orderBy: createdAt, orderDirection: desc, where: {
-                gasUsed_gt: 0
-            } ) {
-                id
-                beaconName
-                createdAt
-                gasUsed
-                token1Symbol
-                token0Symbol
-                token0
-                token1
-                token0Name
-                token1Name
-                strategyToken {
-                  id
-                  name
-                  creator {
-                    id
-                  }
-                }
-            }
-        }
-    `;
-
-    return this.executeSubgraphQuery<T>(query);
-  }
-
-  /**
-   * Deposits tokens into a vault
-   * @param params The deposit parameters
-   */
-  public async deposit(params: VaultDepositParams): Promise<SteerResponse<Hash>> {
-    return this.depositClient.deposit(params);
-  }
-
-  /**
-   * Prepares the transaction data for depositing tokens into a vault without executing it
-   * @param params The deposit parameters
-   */
-  public async prepareDepositTx(params: VaultDepositParams): Promise<SteerResponse<{
-    address: Address;
-    abi: {
-      type: string;
-      inputs: {
-        name: string;
-        internalType: string;
-        type: string;
-      }[];
-      name: string;
-      outputs:  {
-        internalType: string;
-        name: string;
-        type: string;
-      }[];
-      stateMutability: string;
-    }[];
-    functionName: string;
-    args: readonly [Address, bigint, bigint, bigint, bigint, Address] | readonly [bigint, bigint, bigint, bigint, Address];
-  }>> {
-    return this.depositClient.prepareDepositTx(params);
-  }
-
-  /**
-   * Gets the deposit ratio for a vault
-   * @param vaultAddress The vault address
-   */
-  public async getDepositRatio(vaultAddress: Address, zeroForOne: boolean): Promise<SteerResponse<VaultDetailsResponse>> {
-    try {
-      const ratioResponse = await this.depositClient.getDepositRatio(vaultAddress, zeroForOne);
-      if (!ratioResponse.success || !ratioResponse.data) {
-        throw new Error(ratioResponse.error || 'Failed to get deposit ratio');
-      }
-
-      return {
-        data: {
-          details: ratioResponse.data.vaultDetails,
-          ratio: ratioResponse.data.ratio,
-        },
-        status: 200,
-        success: true
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred'
-      };
-    }
-  }
-
-  /**
-   * Withdraws tokens from a vault
-   * @param params The withdrawal parameters
-   */
-  public async withdraw(params: VaultWithdrawParams): Promise<SteerResponse<Hash>> {
-    return this.withdrawClient.withdraw(params);
-  }
-
-  /**
-   * Prepares the transaction data for withdrawing tokens from a vault without executing it
-   * @param params The withdrawal parameters
-   */
-  public async prepareWithdrawTx(params: VaultWithdrawParams): Promise<SteerResponse<{
-    address: Address;
-    abi: {
-      type: string;
-      inputs: {
-        name: string;
-        internalType: string;
-        type: string;
-      }[];
-      name: string;
-      outputs: never[];
-      stateMutability: string;
-    }[];
-    functionName: string;
-    args: readonly [
-      bigint,
-      bigint,
-      bigint,
-      Address
-    ];
-  }>> {
-    return this.withdrawClient.prepareWithdrawTx(params);
-  }
-
-  /**
-   * Calculates the amount of tokens that would be received for a given amount of LP tokens
-   * @param vaultAddress The vault address
-   * @param lpToken The amount of LP tokens to calculate for
-   */
-  public async getTokensFromLp(
-    vaultAddress: Address,
-    lpToken: bigint
-  ): Promise<SteerResponse<TokensFromLpResponse>> {
-    return this.withdrawClient.getTokensFromLp(vaultAddress, lpToken);
-  }
-
-  /**
-   * Approves spending of tokens for a vault
-   * @param params The approval parameters
-   */
-  public async approve(params: VaultApproveParams): Promise<SteerResponse<Hash>> {
-    try {
-      const account = await this.walletClient.getAddresses();
-      if (!account[0]) throw new Error('No account found');
-
-      const { request } = await this.publicClient.simulateContract({
-        address: params.vaultAddress,
-        abi: VAULT_ABI,
-        functionName: 'approve',
-        args: [params.spender, params.amount],
-        account: account[0],
-      });
-
-      const hash = await this.walletClient.writeContract(request);
-
-      return {
-        data: hash,
-        status: 200,
-        success: true,
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred',
-      };
-    }
-  }
-
-  /**
-   * Gets the allowance for a vault token
-   * @param params The allowance parameters
-   */
-  public async allowance(params: VaultAllowanceParams): Promise<SteerResponse<bigint>> {
-    try {
-      const allowance = await this.publicClient.readContract({
-        address: params.vaultAddress,
-        abi: VAULT_ABI,
-        functionName: 'allowance',
-        args: [params.owner, params.spender],
-      });
-
-      return {
-        data: allowance,
-        status: 200,
-        success: true,
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred',
-      };
-    }
-  }
-
-  /**
-   * Gets the balance of a vault token for an account
-   * @param params The balance parameters
-   */
-  public async balanceOf(params: VaultBalanceParams): Promise<SteerResponse<bigint>> {
-    try {
-      const balance = await this.publicClient.readContract({
-        address: params.vaultAddress,
-        abi: VAULT_ABI,
-        functionName: 'balanceOf',
-        args: [params.account],
-      });
-
-      return {
-        data: balance,
-        status: 200,
-        success: true,
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred',
-      };
-    }
-  }
-
-  /**
-   * Gets the total supply of a vault token
-   * @param vaultAddress The vault address
-   */
-  public async totalSupply(vaultAddress: Address): Promise<SteerResponse<bigint>> {
-    try {
-      const totalSupply = await this.publicClient.readContract({
-        address: vaultAddress,
-        abi: VAULT_ABI,
-        functionName: 'totalSupply',
-      });
-
-      return {
-        data: totalSupply,
-        status: 200,
-        success: true,
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred',
-      };
-    }
-  }
-
-  /**
-   * Gets the decimals of a vault token
-   * @param vaultAddress The vault address
-   */
-  public async decimals(vaultAddress: Address): Promise<SteerResponse<number>> {
-    try {
-      const decimals = await this.publicClient.readContract({
-        address: vaultAddress,
-        abi: VAULT_ABI,
-        functionName: 'decimals',
-      });
-
-      return {
-        data: decimals,
-        status: 200,
-        success: true,
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred',
-      };
-    }
-  }
-
-  /**
-   * Gets the symbol of a vault token
-   * @param vaultAddress The vault address
-   */
-  public async symbol(vaultAddress: Address): Promise<SteerResponse<string>> {
-    try {
-      const result = await this.publicClient.readContract({
-        address: vaultAddress,
-        abi: VAULT_ABI,
-        functionName: 'symbol',
-      });
-
-      return {
-        data: result,
-        status: 200,
-        success: true,
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred',
-      };
-    }
-  }
-
-  /**
-   * Gets the name of a vault token
-   * @param vaultAddress The vault address
-   */
-  public async name(vaultAddress: Address): Promise<SteerResponse<string>> {
-    try {
-      const result = await this.publicClient.readContract({
-        address: vaultAddress,
-        abi: VAULT_ABI,
-        functionName: 'name',
-      });
-
-      return {
-        data: result,
-        status: 200,
-        success: true,
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred',
-      };
-    }
-  }
-
-  public async pool(vaultAddress: Address): Promise<SteerResponse<Address>> {
-    try {
-      const pool = await this.publicClient.readContract({
-        address: vaultAddress,
-        abi: VAULT_ABI,
-        functionName: 'pool',
-      });
-
-      return {
-        data: pool,
-        status: 200,
-        success: true,
-      };
-    } catch (error) {
-      return {
-        data: null,
-        status: 500,
-        success: false,
-        error: error instanceof Error ? error.message : 'Unknown error occurred',
-      };
-    }
-  }
-
-  /**
-   * Gets a pool instance for a vault
-   * @param params The pool instance parameters
-   */
-  public async getPoolInstance(params: PoolInstanceParams): Promise<SteerResponse<PoolV3>> {
-    return this.depositClient.getPoolInstance(params);
-  }
-
-  /**
-   * Gets the corresponding token amount based on the provided token amount and ratio
-   * @param vaultAddress The vault address
-   * @param amount The amount of token to calculate the corresponding amount for
-   * @param zeroForOne If true, calculates token1 amount for given token0, if false calculates token0 amount for given token1
-   */
-  public async getCorrespondingTokenAmount(
-    vaultAddress: Address,
-    amount: bigint,
-    zeroForOne: boolean
-  ): Promise<SteerResponse<bigint>> {
-    return this.depositClient.getCorrespondingTokenAmount(vaultAddress, amount, zeroForOne);
-  }
-
-  // Single-Asset Deposit Methods
-
-  /**
-   * Previews a single-asset deposit by running all simulation steps
-   * This allows users to see the expected outcome before executing the transaction
-   * 
-   * @param params - Single-asset deposit parameters
-   * @param poolAddress - Address of the pool (must be provided separately)
-   * @returns Promise resolving to the complete deposit preview
-   * 
-   * @example
-   * ```typescript
-   * const preview = await vaultClient.previewSingleAssetDeposit({
-   *   assets: parseEther('100'),
-   *   receiver: userAddress,
-   *   vault: vaultAddress,
-   *   isToken0: true,
-   *   depositSlippagePercent: 5n,
-   *   swapSlippageBP: 500,
-   *   ammType: AMMType.UniswapV3,
-   *   singleAssetDepositContract: contractAddress
-   * }, poolAddress);
-   * 
-   * if (preview.success) {
-   *   console.log('Expected LP tokens:', preview.data.lpEstimation.lpTokens);
-   *   console.log('Swap amount:', preview.data.swapAmount);
-   * }
-   * ```
-   */
-  public async previewSingleAssetDeposit(
-    params: SingleAssetDepositParams,
-    poolAddress: Address
-  ): Promise<SteerResponse<SingleAssetDepositPreview>> {
-    return this.singleAssetDepositClient.previewDeposit(params, poolAddress);
-  }
-
-  /**
-   * Executes a single-asset deposit transaction
-   * 
-   * @param params - Single-asset deposit parameters
-   * @returns Promise resolving to the transaction hash
-   * 
-   * @example
-   * ```typescript
-   * const result = await vaultClient.singleAssetDeposit({
-   *   assets: parseEther('100'),
-   *   receiver: userAddress,
-   *   vault: vaultAddress,
-   *   isToken0: true,
-   *   depositSlippagePercent: 5n,
-   *   swapSlippageBP: 500,
-   *   ammType: AMMType.UniswapV3,
-   *   singleAssetDepositContract: contractAddress
-   * });
-   * 
-   * if (result.success) {
-   *   console.log('Transaction hash:', result.data);
-   * }
-   * ```
-   */
-  public async singleAssetDeposit(params: SingleAssetDepositParams): Promise<SteerResponse<Hash>> {
-    return this.singleAssetDepositClient.deposit(params);
-  }
-
-  /**
-   * Prepares a single-asset deposit transaction without executing it
-   * Useful for batching transactions or custom execution logic
-   * 
-   * @param params - Single-asset deposit parameters
-   * @returns Promise resolving to the prepared transaction data
-   */
-  public async prepareSingleAssetDepositTx(params: SingleAssetDepositParams) {
-    return this.singleAssetDepositClient.prepareDepositTx(params);
-  }
-
-  /**
-   * Validates single-asset deposit parameters
-   * 
-   * @param params - Parameters to validate
-   * @throws Error if parameters are invalid
-   */
-  public validateSingleAssetDepositParams(params: SingleAssetDepositParams): void {
-    return this.singleAssetDepositClient.validateDepositParams(params);
-  }
-
-  // Reward Management Methods
-
-  /**
-   * Calculates pending rewards for a user from a vault
-   * This is a view function that doesn't modify state
-   * 
-   * @param params - Parameters containing vault address and user address
-   * @returns Promise resolving to pending rewards data or zero values if function reverts
-   * 
-   * @example
-   * ```typescript
-   * const pendingRewards = await vaultClient.calculatePendingRewards({
-   *   vaultAddress: '0x123...',
-   *   user: '0xabc...'
-   * });
-   * 
-   * if (pendingRewards.success && pendingRewards.data) {
-   *   console.log('Rewards:', pendingRewards.data.rewards);
-   *   console.log('Extra Rewards:', pendingRewards.data.extraRewards);
-   * }
-   * ```
-   */
-  public async calculatePendingRewards(params: PendingRewardsParams): Promise<SteerResponse<PendingRewardsResponse>> {
-    try {
-      const result = await this.publicClient.readContract({
-        address: params.vaultAddress,
-        abi: REWARD_FUNCTIONS_ABI,
-        functionName: 'calculatePendingRewards',
-        args: [params.user],
-      }) as [bigint, bigint];
-
-      return {
-        data: {
-          rewards: result[0],
-          extraRewards: result[1]
-        },
-        status: 200,
-        success: true,
-      };
-    } catch (error) {
-      // If the function reverts or doesn't exist, return zero values
-      console.warn('calculatePendingRewards failed, returning zero values:', error);
-      return {
-        data: {
-          rewards: 0n,
-          extraRewards: 0n
-        },
-        status: 200,
-        success: true,
-      };
-    }
-  }
-
-  /**
-   * Claims pending rewards from a vault using the claimBlackHolePendingRewards function
-   * 
-   * @param params - Parameters containing vault address
-   * @returns Promise resolving to transaction hash or zero values if function reverts
-   * 
-   * @example
-   * ```typescript
-   * const claimResult = await vaultClient.claimPendingRewards({
-   *   vaultAddress: '0x123...'
-   * });
-   * 
-   * if (claimResult.success && claimResult.data) {
-   *   console.log('Claim transaction hash:', claimResult.data);
-   * }
-   * ```
-   */
-  public async claimBlackholePendingRewards(params: ClaimRewardsParams): Promise<SteerResponse<Hash | PendingRewardsResponse>> {
-    try {
-      const account = await this.walletClient.getAddresses();
-      if (!account[0]) throw new Error('No account found');
-
-      const { request } = await this.publicClient.simulateContract({
-        address: params.vaultAddress,
-        abi: REWARD_FUNCTIONS_ABI,
-        functionName: 'claimUserRewards',
-        args: [],
-        account: account[0],
-      });
-
-      const hash = await this.walletClient.writeContract(request);
-
-      return {
-        data: hash,
-        status: 200,
-        success: true,
-      };
-    } catch (error) {
-      console.error('claimBlackHolePendingRewards failed, error:', error);
-      // If the function reverts or doesn't exist, return zero values instead of transaction hash
-      console.warn('claimBlackHolePendingRewards failed, returning zero values:', error);
-      return {
-        data: {
-          rewards: 0n,
-          extraRewards: 0n
-        },
-        status: 200,
-        success: true,
-      };
-    }
-  }
-
-}