@steerprotocol/sdk 1.29.3 → 1.30.1

package/src/base/VaultClient.ts

@@ -1,7 +1,8 @@
 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 { chainIdToName, getBeaconNameByProtocol, getProtocolTypeByBeacon } from '../const';
+import { getAmmConfig } from '../const/amm/configs/ammConfig.js';
 import { getProtocolsForChainId } from '../const/amm/utils/protocol';
 import { ChainId, MultiPositionManagers, Protocol } from '../const/chain';
 import { steerSubgraphConfig } from '../const/subgraph';
@@ -104,6 +105,23 @@ export interface VaultNode {
   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;
@@ -202,6 +220,13 @@ export interface VaultFilter {
   beaconName?: string;
 }
 
+// API-specific filter that excludes protocol field
+export interface ApiVaultFilter {
+  chainId?: number;
+  isActive?: boolean;
+  beaconName?: string;
+}
+
 export interface TokenFilter {
   chainId?: number;
   symbol?: string;
@@ -378,8 +403,128 @@ export class VaultClient extends SubgraphClient {
     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, ...rest } = filter;
+    const apiFilter: ApiVaultFilter = { ...rest };
+
+    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
+    };
+  }
+
   /**
    * 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)
@@ -418,95 +563,440 @@ export class VaultClient extends SubgraphClient {
     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'}`
+      };
+    }
 
-    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
-          };
+    // 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: transformedData,
+            data: null,
             status: response.status,
-            success: true
+            success: false,
+            error: response.error || 'Failed to fetch vaults from API'
           };
         }
-      } catch (apiError) {
-        console.warn('API client failed, falling back to subgraph:', apiError);
+
+        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'
+      };
+    }
   }
 
-    // Fallback to subgraph if API fails or returns no data
+  /**
+   * Fetches vaults from API (database) with pagination
+   * @private
+   */
+  private async getVaultsFromApi(
+    apiFilter?: ApiVaultFilter,
+    first: number = 50,
+    after?: string | null
+  ): Promise<SteerResponse<VaultsConnection>> {
     try {
-      return await this.getVaultsFromSubgraph(filter, first, after);
-    } catch (subgraphError) {
-      console.error('Both API and subgraph failed:', subgraphError);
+      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: subgraphError instanceof Error ? subgraphError.message : 'Both API and subgraph requests failed'
+        error: error instanceof Error ? error.message : 'API request failed'
       };
     }
   }
 
   /**
-   * Fallback method to fetch vaults from subgraph
+   * 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)
@@ -539,28 +1029,21 @@ export class VaultClient extends SubgraphClient {
         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);
-        }
-      }
+      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: false,
-        beaconNames: beaconNames
+        showCurrentProtocol: uniqueBeaconNames.length > 0,
+        beaconNames: uniqueBeaconNames
       });
 
       // Get all supported protocols for this chain
@@ -606,8 +1089,10 @@ export class VaultClient extends SubgraphClient {
         }));
       }
 
+      const filteredVaultsConnection = this.applyProtocolFilter(vaultsConnection, filter?.protocol);
+
       return {
-        data: vaultsConnection,
+        data: filteredVaultsConnection,
         status: 200,
         success: true
       };