@steerprotocol/sdk 1.31.0 → 2.0.1

package/dist/cjs/base/VaultClient.js

@@ -1,1756 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VaultClient = void 0;
-const api_sdk_1 = require("@steerprotocol/api-sdk");
-const index_js_1 = require("../const/index.js");
-const ammConfig_js_1 = require("../const/amm/configs/ammConfig.js");
-const protocol_js_1 = require("../const/amm/utils/protocol.js");
-const chain_js_1 = require("../const/chain.js");
-const subgraph_js_1 = require("../const/subgraph.js");
-const SubgraphVaultClient_js_1 = require("../utils/SubgraphVaultClient.js");
-const api_js_1 = require("../const/api.js");
-const abis_js_1 = require("../const/deployments/abis.js");
-const SubgraphClient_js_1 = require("./SubgraphClient.js");
-const index_js_2 = require("./vault/deposit/index.js");
-const index_js_3 = require("./vault/single-asset/index.js");
-const index_js_4 = require("./vault/withdraw/index.js");
-__exportStar(require("./vault/single-asset/index.js"), exports);
-const VAULT_ABI = abis_js_1.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"
-    },
-];
-/**
- * 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
- */
-class VaultClient extends SubgraphClient_js_1.SubgraphClient {
-    /**
-     * 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, walletClient, environment, version = 'v1', subgraphStudioKey) {
-        const combinedClient = publicClient;
-        super(combinedClient);
-        const apiUrl = (0, api_js_1.getApiUrl)(environment, version);
-        this.apiClient = (0, api_sdk_1.createClient)(apiUrl);
-        this.publicClient = publicClient;
-        this.walletClient = walletClient;
-        this.depositClient = new index_js_2.VaultDepositClient(publicClient, walletClient);
-        this.withdrawClient = new index_js_4.VaultWithdrawClient(publicClient, walletClient);
-        this.singleAssetDepositClient = new index_js_3.SingleAssetDepositClient(publicClient, walletClient);
-        this.subgraphVaultClient = new SubgraphVaultClient_js_1.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(chain_js_1.Protocol).find(protocolValue => this.normalizeProtocolValue(protocolValue) === normalizedProtocol);
-        return matchedProtocol || null;
-    }
-    getProtocolBeaconNames(protocol) {
-        const resolvedProtocol = this.resolveProtocolEnum(protocol);
-        if (!resolvedProtocol) {
-            return [];
-        }
-        const protocolConfig = (0, ammConfig_js_1.getAmmConfig)(this.subgraphStudioKey)[resolvedProtocol];
-        const beaconNames = [];
-        if (protocolConfig?.beaconContract) {
-            beaconNames.push(protocolConfig.beaconContract);
-        }
-        if (protocolConfig?.beaconContractSushiManaged) {
-            beaconNames.push(protocolConfig.beaconContractSushiManaged);
-        }
-        if (resolvedProtocol === chain_js_1.Protocol.Blackhole) {
-            beaconNames.push(chain_js_1.MultiPositionManagers.MultiPositionBlackholeOld);
-        }
-        const beaconAlias = (0, index_js_1.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 = (0, ammConfig_js_1.getAmmConfig)(this.subgraphStudioKey)[resolvedProtocol];
-        return protocolConfig?.beaconContract || null;
-    }
-    buildApiVaultFilter(filter) {
-        if (!filter) {
-            return undefined;
-        }
-        const { protocol, poolAddress, chainId, isActive, beaconName } = filter;
-        const apiFilter = {
-            chainId,
-            isActive,
-            beaconName,
-        };
-        if (poolAddress) {
-            apiFilter.pool = poolAddress;
-        }
-        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 = (0, index_js_1.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
-            ? (0, index_js_1.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
-        };
-    }
-    normalizeAddress(value) {
-        return value?.toLowerCase() || '';
-    }
-    normalizeSymbol(value) {
-        return value?.trim().toLowerCase() || '';
-    }
-    matchesAnyAddress(candidates, filterValues) {
-        if (filterValues.length === 0) {
-            return true;
-        }
-        const normalizedCandidates = new Set(candidates.map((candidate) => this.normalizeAddress(candidate)).filter(Boolean));
-        return filterValues.some((value) => normalizedCandidates.has(value));
-    }
-    matchesAnySymbol(candidates, filterValues) {
-        if (filterValues.length === 0) {
-            return true;
-        }
-        const normalizedCandidates = new Set(candidates.map((candidate) => this.normalizeSymbol(candidate)).filter(Boolean));
-        return filterValues.some((value) => normalizedCandidates.has(value));
-    }
-    filterVaultNodes(vaults, filter) {
-        const vaultAddress = this.normalizeAddress(filter.vaultAddress);
-        const poolAddress = this.normalizeAddress(filter.poolAddress);
-        const tokenAddressFilters = [
-            ...(filter.tokenAddress ? [filter.tokenAddress] : []),
-            ...(filter.tokenAddresses || []),
-        ]
-            .map((address) => this.normalizeAddress(address))
-            .filter(Boolean);
-        const tokenSymbolFilters = [
-            ...(filter.tokenSymbol ? [filter.tokenSymbol] : []),
-            ...(filter.tokenSymbols || []),
-        ]
-            .map((symbol) => this.normalizeSymbol(symbol))
-            .filter(Boolean);
-        return vaults.filter((vault) => {
-            if (vaultAddress && this.normalizeAddress(vault.vaultAddress) !== vaultAddress) {
-                return false;
-            }
-            if (poolAddress &&
-                !this.matchesAnyAddress([vault.pool.poolAddress, vault.pool.id], [poolAddress])) {
-                return false;
-            }
-            if (!this.matchesAnyAddress([vault.token0.address, vault.token0.id, vault.token1.address, vault.token1.id], tokenAddressFilters)) {
-                return false;
-            }
-            if (!this.matchesAnySymbol([vault.token0.symbol, vault.token1.symbol], tokenSymbolFilters)) {
-                return false;
-            }
-            return true;
-        });
-    }
-    /**
-     * Gets vaults with pagination support
-     * Fetches ALL data from both API (database) and subgraph in parallel, merges without duplicates, then paginates
-     * @param filter - Optional filter criteria
-     * @param first - Number of items to fetch (default: 50)
-     * @param after - Cursor for pagination (null for first page)
-     * @returns Promise resolving to paginated vaults data
-     *
-     * @example
-     * ```typescript
-     * // Get first 20 vaults for Ethereum
-     * const vaults = await vaultClient.getVaults({ chainId: 1 }, 20);
-     *
-     * if (vaults.success && vaults.data) {
-     *   vaults.data.edges.forEach((edge) => {
-     *     const vault = edge.node;
-     *     console.log(`Vault: ${vault.name}`);
-     *     console.log(`Pool: ${vault.pool.id}`);
-     *     console.log(`Pool Fee Tier: ${vault.pool.feeTier}`);
-     *     console.log(`Tokens: ${vault.token0.symbol}/${vault.token1.symbol}`);
-     *   });
-     * }
-     *
-     * // Get next page using cursor
-     * if (vaults.data?.pageInfo.hasNextPage) {
-     *   const nextPage = await vaultClient.getVaults(
-     *     { chainId: 1 },
-     *     20,
-     *     vaults.data.pageInfo.endCursor
-     *   );
-     * }
-     *
-     * // For additional pool details (liquidity, volume, etc.), use the PoolClient:
-     * // const poolDetails = await poolClient.getPoolById(vault.pool.id, protocol, chainId);
-     * ```
-     */
-    async getVaults(filter, first = 50, after) {
-        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 !== chain_js_1.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: null,
-                        status: response.status,
-                        success: false,
-                        error: response.error || 'Failed to fetch vaults from API'
-                    };
-                }
-                allVaults.push(...response.data.edges);
-                hasNextPage = response.data.pageInfo.hasNextPage;
-                cursor = response.data.pageInfo.endCursor;
-            }
-            return {
-                data: allVaults,
-                status: 200,
-                success: true
-            };
-        }
-        catch (error) {
-            console.warn('Failed to fetch all vaults from API:', error);
-            return {
-                data: null,
-                status: 500,
-                success: false,
-                error: error instanceof Error ? error.message : 'Failed to fetch all vaults from API'
-            };
-        }
-    }
-    /**
-     * Fetches vaults from API (database) with pagination
-     * @private
-     */
-    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,
-                        // 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
-     */
-    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;
-            }
-        }
-        // 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 {
-            // 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 = (0, index_js_1.chainIdToName)(chainId);
-            if (!chain) {
-                throw new Error(`Unsupported chainId: ${chainId}`);
-            }
-            // Get subgraph URL for this chain
-            const subgraphUrl = subgraph_js_1.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 = (0, protocol_js_1.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) => {
-                // 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;
-                if (positions && positions.length > 0) {
-                    const lowerTicks = positions.map(p => p.lowerTick);
-                    const upperTicks = positions.map(p => p.upperTick);
-                    tickRange = {
-                        minLowerTick: Math.min(...lowerTicks),
-                        maxUpperTick: Math.max(...upperTicks)
-                    };
-                }
-                return {
-                    cursor: `subgraph_${chainId}_${index}`,
-                    node: {
-                        id: vault.id,
-                        chainId: chainId,
-                        vaultAddress: vault.id,
-                        protocol: vault.beaconName || '',
-                        beaconName: vault.beaconName || '',
-                        protocolBaseType: vault.beaconName || '',
-                        name: `${vault.token0Symbol}/${vault.token1Symbol}`,
-                        feeApr: aprMap.get(vault.id.toLowerCase()),
-                        stakingApr: undefined,
-                        merklApr: undefined,
-                        positions,
-                        tickRange,
-                        fees: vault.fees0 && vault.fees1 ? {
-                            fees0: vault.fees0,
-                            fees1: vault.fees1
-                        } : undefined,
-                        pool: {
-                            id: vault.pool || '',
-                            poolAddress: vault.pool || '',
-                            feeTier: vault.feeTier || '',
-                            tick: undefined,
-                            liquidity: undefined,
-                            volumeUSD: undefined,
-                            totalValueLockedUSD: undefined
-                        },
-                        token0: {
-                            id: vault.token0,
-                            symbol: vault.token0Symbol,
-                            name: vault.token0Symbol, // Use symbol as name since subgraph doesn't provide name
-                            decimals: parseInt(vault.token0Decimals) || 18,
-                            address: vault.token0,
-                            chainId: chainId
-                        },
-                        token1: {
-                            id: vault.token1,
-                            symbol: vault.token1Symbol,
-                            name: vault.token1Symbol, // Use symbol as name since subgraph doesn't provide name
-                            decimals: parseInt(vault.token1Decimals) || 18,
-                            address: vault.token1,
-                            chainId: chainId
-                        }
-                    }
-                };
-            });
-            return {
-                data: vaultEdges,
-                status: 200,
-                success: true
-            };
-        }
-        catch (error) {
-            console.error('Subgraph vault fetch failed:', error);
-            return {
-                data: null,
-                status: 500,
-                success: false,
-                error: error instanceof Error ? error.message : 'Failed to fetch vaults from subgraph'
-            };
-        }
-    }
-    /**
-     * Fallback method to fetch vaults from subgraph with pagination
-     * @param filter - Optional filter criteria
-     * @param first - Number of items to fetch (default: 50)
-     * @param after - Cursor for pagination (null for first page)
-     * @returns Promise resolving to paginated vaults data from subgraph
-     * @private
-     */
-    async getVaultsFromSubgraph(filter, first = 50, after) {
-        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 = (0, index_js_1.chainIdToName)(chainId);
-            if (!chain) {
-                throw new Error(`Unsupported chainId: ${chainId}`);
-            }
-            // Get subgraph URL for this chain
-            const subgraphUrl = subgraph_js_1.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 = (0, protocol_js_1.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 VaultsConnection format with pagination and populate APR data
-            const vaultsConnection = this.subgraphVaultClient.transformToVaultsConnection(subgraphVaults, chainId, first, aprMap, after);
-            // Enhance vault data with APR information
-            if (vaultsConnection.edges) {
-                vaultsConnection.edges = vaultsConnection.edges.map(edge => ({
-                    ...edge,
-                    node: {
-                        ...edge.node,
-                        feeApr: aprMap.get(edge.node.vaultAddress.toLowerCase()) || edge.node.feeApr
-                    }
-                }));
-            }
-            const filteredVaultsConnection = this.applyProtocolFilter(vaultsConnection, filter?.protocol);
-            return {
-                data: filteredVaultsConnection,
-                status: 200,
-                success: true
-            };
-        }
-        catch (error) {
-            console.error('Subgraph vault fetch failed:', error);
-            throw error;
-        }
-    }
-    /**
-     * Gets tokens with pagination support
-     * @param filter - Optional filter criteria
-     * @param first - Number of items to fetch (default: 50)
-     * @param after - Cursor for pagination (null for first page)
-     * @returns Promise resolving to paginated tokens data
-     *
-     * @example
-     * ```typescript
-     * // Get first 100 tokens
-     * const tokens = await vaultClient.getTokens({ chainId: 1 }, 100);
-     *
-     * // Filter by symbol
-     * const usdcTokens = await vaultClient.getTokens({ symbol: 'USDC' });
-     * ```
-     */
-    async getTokens(filter, first = 50, after) {
-        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 = {
-                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'
-     * });
-     * ```
-     */
-    async getPools(filter, first = 50, after) {
-        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 = {
-                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)`);
-     * });
-     * ```
-     */
-    async getAllVaults(filter, batchSize = 100) {
-        try {
-            const allVaults = [];
-            let hasNextPage = true;
-            let cursor = 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
-     */
-    async getAllTokens(filter, batchSize = 100) {
-        try {
-            const allTokens = [];
-            let hasNextPage = true;
-            let cursor = 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
-     */
-    async getAllPools(filter, batchSize = 100) {
-        try {
-            const allPools = [];
-            let hasNextPage = true;
-            let cursor = null;
-            while (hasNextPage) {
-                const response = await this.getPools(filter, batchSize, cursor);
-                if (!response.success || !response.data) {
-                    return {
-                        data: null,
-                        status: response.status,
-                        success: false,
-                        error: response.error || 'Failed to fetch pools'
-                    };
-                }
-                allPools.push(...response.data.edges.map(edge => edge.node));
-                hasNextPage = response.data.pageInfo.hasNextPage;
-                cursor = response.data.pageInfo.endCursor;
-            }
-            return {
-                data: allPools,
-                status: 200,
-                success: true
-            };
-        }
-        catch (error) {
-            return {
-                data: null,
-                status: 501,
-                success: false,
-                error: 'getAllPools is not supported for this configuration'
-            };
-        }
-    }
-    /**
-     * Searches vaults by combining verified API-supported filters with local
-     * filtering over the merged vault result set for unsupported server-side fields.
-     */
-    async searchVaults(filter) {
-        const response = await this.getAllVaults(filter);
-        if (!response.success || !response.data) {
-            return response;
-        }
-        return {
-            data: this.filterVaultNodes(response.data, filter || {}),
-            status: 200,
-            success: true,
-        };
-    }
-    async getVaultByAddress(vaultAddress, filter) {
-        const response = await this.searchVaults({
-            ...filter,
-            vaultAddress,
-        });
-        if (!response.success || !response.data) {
-            return {
-                data: null,
-                status: response.status,
-                success: response.success,
-                error: response.error,
-            };
-        }
-        return {
-            data: response.data[0] || null,
-            status: 200,
-            success: true,
-        };
-    }
-    async getVaultsForPool(poolAddress, filter) {
-        return this.searchVaults({
-            ...filter,
-            poolAddress,
-        });
-    }
-    async getVaultsForToken(tokenAddressOrSymbol, filter) {
-        const normalizedValue = tokenAddressOrSymbol.trim();
-        const isAddress = /^0x[a-fA-F0-9]{40}$/.test(normalizedValue);
-        return this.searchVaults({
-            ...filter,
-            ...(isAddress
-                ? { tokenAddress: normalizedValue }
-                : { tokenSymbol: normalizedValue }),
-        });
-    }
-    /**
-     * Gets APR data for vaults from the Steer Finance API
-     * @param filter - Filter containing chainId and protocol
-     * @returns Promise resolving to APR data for vaults
-     *
-     * @example
-     * ```typescript
-     * // Get APRs for Uniswap vaults on Nibiru (chainId: 6900)
-     * const aprs = await vaultClient.getAprs({ chainId: 6900, protocol: 'Uniswap' });
-     *
-     * if (aprs.success && aprs.data) {
-     *   aprs.data.vaults.forEach(vault => {
-     *     console.log(`Vault: ${vault.vaultAddress}`);
-     *     console.log(`APR: ${vault.apr.apr}% (${vault.apr.message})`);
-     *     console.log(`Beacon: ${vault.beaconName}`);
-     *   });
-     * }
-     * ```
-     */
-    async getAprs(filter) {
-        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 = 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}%`);
-     *   });
-     * }
-     * ```
-     */
-    async getBlackholeVaultApr(params) {
-        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 = 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
-     */
-    async getLatestVaults() {
-        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(query);
-    }
-    /**
-     * Deposits tokens into a vault
-     * @param params The deposit parameters
-     */
-    async deposit(params) {
-        return this.depositClient.deposit(params);
-    }
-    /**
-     * Prepares the transaction data for depositing tokens into a vault without executing it
-     * @param params The deposit parameters
-     */
-    async prepareDepositTx(params) {
-        return this.depositClient.prepareDepositTx(params);
-    }
-    /**
-     * Gets the deposit ratio for a vault
-     * @param vaultAddress The vault address
-     */
-    async getDepositRatio(vaultAddress, zeroForOne) {
-        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
-     */
-    async withdraw(params) {
-        return this.withdrawClient.withdraw(params);
-    }
-    /**
-     * Prepares the transaction data for withdrawing tokens from a vault without executing it
-     * @param params The withdrawal parameters
-     */
-    async prepareWithdrawTx(params) {
-        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
-     */
-    async getTokensFromLp(vaultAddress, lpToken) {
-        return this.withdrawClient.getTokensFromLp(vaultAddress, lpToken);
-    }
-    /**
-     * Approves spending of tokens for a vault
-     * @param params The approval parameters
-     */
-    async approve(params) {
-        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
-     */
-    async allowance(params) {
-        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
-     */
-    async balanceOf(params) {
-        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
-     */
-    async totalSupply(vaultAddress) {
-        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
-     */
-    async decimals(vaultAddress) {
-        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
-     */
-    async symbol(vaultAddress) {
-        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
-     */
-    async name(vaultAddress) {
-        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',
-            };
-        }
-    }
-    async pool(vaultAddress) {
-        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
-     */
-    async getPoolInstance(params) {
-        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
-     */
-    async getCorrespondingTokenAmount(vaultAddress, amount, zeroForOne) {
-        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);
-     * }
-     * ```
-     */
-    async previewSingleAssetDeposit(params, poolAddress) {
-        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);
-     * }
-     * ```
-     */
-    async singleAssetDeposit(params) {
-        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
-     */
-    async prepareSingleAssetDepositTx(params) {
-        return this.singleAssetDepositClient.prepareDepositTx(params);
-    }
-    /**
-     * Validates single-asset deposit parameters
-     *
-     * @param params - Parameters to validate
-     * @throws Error if parameters are invalid
-     */
-    validateSingleAssetDepositParams(params) {
-        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);
-     * }
-     * ```
-     */
-    async calculatePendingRewards(params) {
-        try {
-            const result = await this.publicClient.readContract({
-                address: params.vaultAddress,
-                abi: REWARD_FUNCTIONS_ABI,
-                functionName: 'calculatePendingRewards',
-                args: [params.user],
-            });
-            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);
-     * }
-     * ```
-     */
-    async claimBlackholePendingRewards(params) {
-        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,
-            };
-        }
-    }
-}
-exports.VaultClient = VaultClient;
-//# sourceMappingURL=VaultClient.js.map