@steerprotocol/sdk 1.26.0 → 1.28.0

package/src/base/VaultClient.ts

@@ -0,0 +1,1642 @@
+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 } from '../const';
+import { getProtocolsForChainId } from '../const/amm/utils/protocol';
+import { ChainId, MultiPositionManagers, Protocol } from '../const/chain';
+import { steerSubgraphConfig } from '../const/subgraph';
+import { SubgraphVaultClient } from '../utils/SubgraphVaultClient';
+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;
+  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;
+}
+
+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 || '';
+  }
+
+  /**
+   * Gets vaults 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 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>> {
+
+    
+
+    if (filter?.chainId !== ChainId.Avalanche) {
+      try {
+        // First try the API client
+        const response = await this.apiClient.vaults({
+          filter,
+          first,
+          after
+        });
+
+        if (response.data?.vaults) {
+          // 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 (apiError) {
+        console.warn('API client failed, falling back to subgraph:', apiError);
+      }
+  }
+
+    // Fallback to subgraph if API fails or returns no data
+    try {
+      return await this.getVaultsFromSubgraph(filter, first, after);
+    } catch (subgraphError) {
+      console.error('Both API and subgraph failed:', subgraphError);
+      return {
+        data: null,
+        status: 500,
+        success: false,
+        error: subgraphError instanceof Error ? subgraphError.message : 'Both API and subgraph requests failed'
+      };
+    }
+  }
+
+  /**
+   * Fallback method to fetch vaults from subgraph
+   * @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 = [];
+
+      if (filter?.protocol) {
+        const beacon = getBeaconNameByProtocol(filter.protocol as Protocol);
+        beaconNames.push(beacon);
+
+        if (filter?.protocol === Protocol.Blackhole) {
+          beaconNames.push(MultiPositionManagers.MultiPositionBlackholeOld);
+        }
+      }
+
+      if (filter?.beaconName) {
+        beaconNames.push(filter.beaconName);
+      }
+
+      // Fetch all vaults from subgraph
+      const subgraphVaults = await this.subgraphVaultClient.getAllVaultsFromSubgraph({
+        subgraphUrl,
+        chainId,
+        showDeprecated: false,
+        showCurrentProtocol: false,
+        beaconNames: beaconNames
+      });
+
+      // 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
+          }
+        }));
+      }
+
+      return {
+        data: vaultsConnection,
+        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'
+      };
+    }
+  }
+
+  /**
+   * 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,
+      };
+    }
+  }
+
+}