@steerprotocol/sdk 1.29.2 → 1.30.0

package/dist/esm/base/VaultClient.js

@@ -1,5 +1,6 @@
 import { createClient } from '@steerprotocol/api-sdk';
-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';
@@ -145,8 +146,95 @@ export class VaultClient extends SubgraphClient {
         this.subgraphVaultClient = new SubgraphVaultClient();
         this.subgraphStudioKey = subgraphStudioKey || '';
     }
+    normalizeProtocolValue(value) {
+        return value.toLowerCase().replace(/[^a-z0-9]/g, '');
+    }
+    resolveProtocolEnum(protocol) {
+        if (!protocol) {
+            return null;
+        }
+        const normalizedProtocol = this.normalizeProtocolValue(protocol);
+        const matchedProtocol = Object.values(Protocol).find(protocolValue => this.normalizeProtocolValue(protocolValue) === normalizedProtocol);
+        return matchedProtocol || null;
+    }
+    getProtocolBeaconNames(protocol) {
+        const resolvedProtocol = this.resolveProtocolEnum(protocol);
+        if (!resolvedProtocol) {
+            return [];
+        }
+        const protocolConfig = getAmmConfig(this.subgraphStudioKey)[resolvedProtocol];
+        const beaconNames = [];
+        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))];
+    }
+    getPrimaryProtocolBeaconName(protocol) {
+        const resolvedProtocol = this.resolveProtocolEnum(protocol);
+        if (!resolvedProtocol) {
+            return null;
+        }
+        const protocolConfig = getAmmConfig(this.subgraphStudioKey)[resolvedProtocol];
+        return protocolConfig?.beaconContract || null;
+    }
+    buildApiVaultFilter(filter) {
+        if (!filter) {
+            return undefined;
+        }
+        const { protocol, ...rest } = filter;
+        const apiFilter = { ...rest };
+        if (!apiFilter.beaconName && protocol) {
+            const primaryBeaconName = this.getPrimaryProtocolBeaconName(protocol);
+            if (primaryBeaconName) {
+                apiFilter.beaconName = primaryBeaconName;
+            }
+        }
+        return apiFilter;
+    }
+    vaultMatchesProtocolFilter(vault, protocolFilter, resolvedProtocol) {
+        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);
+    }
+    applyProtocolFilter(vaultsConnection, protocol) {
+        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)
@@ -181,90 +269,359 @@ export class VaultClient extends SubgraphClient {
      * ```
      */
     async getVaults(filter, first = 50, after) {
-        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 = {
-                        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
-                    };
+        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 = apiResult.status === 'fulfilled' && apiResult.value.success && apiResult.value.data
+            ? apiResult.value.data
+            : [];
+        const subgraphVaults = 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
+     */
+    async getAllVaultsFromApi(apiFilter) {
+        try {
+            const allVaults = [];
+            let hasNextPage = true;
+            let cursor = 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'
                     };
                 }
+                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
+     */
+    async getVaultsFromApi(apiFilter, first = 50, after) {
+        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 = {
+                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
+     */
+    mergeVaultResults(apiVaults, subgraphVaults) {
+        const vaultMap = new Map();
+        // 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 = {
+                    ...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
+                    }
+                };
+                vaultMap.set(key, merged);
             }
-            catch (apiError) {
-                console.warn('API client failed, falling back to subgraph:', apiError);
+        });
+        // 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
+     */
+    paginateVaults(vaults, first, after) {
+        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;
             }
         }
-        // Fallback to subgraph if API fails or returns no data
+        // 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
+     */
+    async getAllVaultsFromSubgraph(filter) {
         try {
-            return await this.getVaultsFromSubgraph(filter, first, after);
+            // 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();
+            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 = subgraphVaults.map((vault, index) => ({
+                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,
+                    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 (subgraphError) {
-            console.error('Both API and subgraph failed:', subgraphError);
+        catch (error) {
+            console.error('Subgraph vault fetch 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 : 'Failed to fetch vaults from subgraph'
             };
         }
     }
     /**
-     * Fallback method 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)
@@ -288,24 +645,18 @@ export class VaultClient extends SubgraphClient {
             if (!subgraphUrl) {
                 throw new Error(`No subgraph configured for chain: ${chain}`);
             }
-            const beaconNames = [];
-            if (filter?.protocol) {
-                const beacon = getBeaconNameByProtocol(filter.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
             const supportedProtocols = getProtocolsForChainId(chainId, this.subgraphStudioKey);
@@ -336,8 +687,9 @@ export class VaultClient extends SubgraphClient {
                     }
                 }));
             }
+            const filteredVaultsConnection = this.applyProtocolFilter(vaultsConnection, filter?.protocol);
             return {
-                data: vaultsConnection,
+                data: filteredVaultsConnection,
                 status: 200,
                 success: true
             };