@steerprotocol/sdk 1.31.0 → 2.0.1

package/dist/types/base/VaultClient.d.ts

@@ -1,808 +0,0 @@
-import { createClient } from '@steerprotocol/api-sdk';
-import { Pool as PoolV3 } from "@uniswap/v3-sdk";
-import type { Address, Hash, PublicClient, WalletClient } from 'viem';
-import { SteerResponse, VaultDetailsResponse } from '../types.js';
-import { SubgraphClient } from './SubgraphClient.js';
-import { PoolInstanceParams, VaultDepositParams } from './vault/deposit/types.js';
-import { SingleAssetDepositClient } from './vault/single-asset/index.js';
-import type { SingleAssetDepositParams, SingleAssetDepositPreview } from './vault/single-asset/types.js';
-import { TokensFromLpResponse, VaultWithdrawParams } from './vault/withdraw/types.js';
-export * from "./vault/single-asset/index.js";
-export interface VaultApproveParams {
-    vaultAddress: Address;
-    spender: Address;
-    amount: bigint;
-}
-export interface VaultAllowanceParams {
-    vaultAddress: Address;
-    owner: Address;
-    spender: Address;
-}
-export interface VaultBalanceParams {
-    vaultAddress: Address;
-    account: Address;
-}
-export interface ApiPageInfo {
-    hasNextPage: boolean;
-    endCursor: string | null;
-}
-export interface VaultNode {
-    id: string;
-    chainId: number;
-    vaultAddress: string;
-    protocol: string;
-    beaconName: string;
-    protocolBaseType: string;
-    name: string;
-    feeApr?: number;
-    stakingApr?: number;
-    merklApr?: number;
-    /** Raw positions from the subgraph. Only available when sourced from subgraph. */
-    positions?: {
-        id: string;
-        upperTick: number;
-        lowerTick: number;
-        relativeWeight: string;
-    }[];
-    /** Computed tick range across all current positions (min lower / max upper). Only available when sourced from subgraph. */
-    tickRange?: {
-        minLowerTick: number;
-        maxUpperTick: number;
-    };
-    /** Cumulative fees collected by the vault. Only available when sourced from subgraph. */
-    fees?: {
-        fees0: string;
-        fees1: string;
-    };
-    pool: {
-        poolAddress: string;
-        id: string;
-        feeTier: string;
-        tick?: string;
-        liquidity?: string;
-        volumeUSD?: string;
-        totalValueLockedUSD?: string;
-    };
-    token0: {
-        id: string;
-        symbol: string;
-        name: string;
-        decimals: number;
-        address: string;
-        chainId: number;
-    };
-    token1: {
-        id: string;
-        symbol: string;
-        name: string;
-        decimals: number;
-        address: string;
-        chainId: number;
-    };
-}
-export interface VaultEdge {
-    cursor: string;
-    node: VaultNode;
-}
-export interface VaultsConnection {
-    edges: readonly VaultEdge[];
-    pageInfo: ApiPageInfo;
-    totalCount: number;
-}
-export interface TokenNode {
-    id: string;
-    symbol: string;
-    name: string;
-    decimals: number;
-    chainId: number;
-    address: string;
-}
-export interface TokenEdge {
-    cursor: string;
-    node: TokenNode;
-}
-export interface TokensConnection {
-    edges: readonly TokenEdge[];
-    pageInfo: ApiPageInfo;
-    totalCount: number;
-}
-export interface PoolNode {
-    id: string;
-    chainId: number;
-    feeTier: string;
-    token0: {
-        id: string;
-        symbol: string;
-        name: string;
-        decimals: number;
-        address: string;
-        chainId: number;
-    };
-    token1: {
-        id: string;
-        symbol: string;
-        name: string;
-        decimals: number;
-        address: string;
-        chainId: number;
-    };
-}
-export interface PoolEdge {
-    cursor: string;
-    node: PoolNode;
-}
-export interface PoolsConnection {
-    edges: readonly PoolEdge[];
-    pageInfo: ApiPageInfo;
-    totalCount: number;
-}
-export interface VaultFilter {
-    chainId?: number;
-    protocol?: string;
-    isActive?: boolean;
-    beaconName?: string;
-    poolAddress?: string;
-    vaultAddress?: string;
-    tokenAddress?: string;
-    tokenAddresses?: string[];
-    tokenSymbol?: string;
-    tokenSymbols?: string[];
-}
-export interface ApiVaultFilter {
-    chainId?: number;
-    isActive?: boolean;
-    beaconName?: string;
-    pool?: string;
-}
-export interface TokenFilter {
-    chainId?: number;
-    symbol?: string;
-}
-export interface PoolFilter {
-    chainId?: number;
-    protocol?: string;
-    minLiquidity?: string;
-}
-export interface VaultApr {
-    apr: {
-        apr: number;
-        message: string;
-    };
-    beaconName: string;
-    vaultAddress: string;
-}
-export interface AprResponse {
-    vaults: VaultApr[];
-}
-export interface AprFilter {
-    chainId: number;
-    protocol: string;
-}
-export interface PendingRewardsParams {
-    vaultAddress: Address;
-    user: Address;
-}
-export interface PendingRewardsResponse {
-    rewards: bigint;
-    extraRewards: bigint;
-}
-export interface ClaimRewardsParams {
-    vaultAddress: Address;
-}
-export interface BlackholeAprDetailedParams {
-    vaultAddress: Address;
-    chainId: number;
-}
-export interface BlackholeSnapshotAnalysis {
-    period: number;
-    fromTimestamp: number;
-    toTimestamp: number;
-    fromDate: string;
-    toDate: string;
-    durationSeconds: number;
-    durationHours: number;
-    tvlUSD: number;
-    feesUSD: number;
-    apr: number;
-}
-export interface BlackholeAprDetailedResponse {
-    vaultAddress: string;
-    beaconName: string;
-    apr: {
-        apr: number;
-        message: string;
-    };
-    snapshotAnalysis: BlackholeSnapshotAnalysis[];
-}
-/**
- * Client for interacting with Steer Protocol's Vault system.
- * This client provides functionality for vault operations, deposit/withdraw, and comprehensive data fetching.
- *
- * **Features:**
- * - Vault data includes associated pool information (pool address, fee tier) along with token details
- * - Full pagination support for all data fetching methods
- * - API client integration for efficient data retrieval
- * - Backward compatibility with subgraph queries
- *
- * **Available API Client Methods:**
- * - `getVaults()` - Get vaults with pagination and filtering
- * - `getTokens()` - Get tokens with pagination and filtering
- * - `getPools()` - Get pools with pagination and filtering
- * - `getAllVaults()` - Get all vaults (auto-pagination)
- * - `getAllTokens()` - Get all tokens (auto-pagination)
- * - `getAllPools()` - Get all pools (auto-pagination)
- *
- * @example
- * ```typescript
- * import { createPublicClient, createWalletClient, http } from 'viem';
- * import { mainnet } from 'viem/chains';
- * import { VaultClient } from '@steerprotocol/sdk';
- *
- * // Create viem clients
- * const publicClient = createPublicClient({
- *   chain: mainnet,
- *   transport: http()
- * });
- *
- * const walletClient = createWalletClient({
- *   chain: mainnet,
- *   transport: http()
- * });
- *
- * // Initialize the Vault client
- * const vaultClient = new VaultClient(publicClient, walletClient, 'production');
- *
- * // Get vaults with pagination - includes pool information
- * const vaults = await vaultClient.getVaults({ chainId: 1 }, 10, null);
- *
- * if (vaults.success && vaults.data) {
- *   vaults.data.edges.forEach((edge) => {
- *     const vault = edge.node;
- *     console.log(`${vault.token0.symbol}/${vault.token1.symbol} vault`);
- *     console.log(`Pool: ${vault.pool.id} (${vault.pool.feeTier} fee tier)`);
- *     console.log(`Protocol: ${vault.protocol} (${vault.beaconName})`);
- *   });
- * }
- *
- * // Get all tokens for a chain
- * const allTokens = await vaultClient.getAllTokens({ chainId: 1 });
- *
- * // Get pools with specific filters
- * const pools = await vaultClient.getPools({
- *   chainId: 1,
- *   protocol: 'uniswap-v3'
- * });
- *
- * // Traditional vault operations
- * const depositTx = await vaultClient.deposit(depositParams);
- * const withdrawTx = await vaultClient.withdraw(withdrawParams);
- * ```
- *
- * @group Client
- */
-export declare class VaultClient extends SubgraphClient {
-    protected readonly apiClient: ReturnType<typeof createClient>;
-    protected readonly publicClient: PublicClient;
-    protected readonly walletClient: WalletClient;
-    private readonly depositClient;
-    private readonly withdrawClient;
-    readonly singleAssetDepositClient: SingleAssetDepositClient;
-    private readonly subgraphVaultClient;
-    private readonly subgraphStudioKey;
-    /**
-     * Creates a new instance of VaultClient
-     * @param publicClient - The public client for reading from the blockchain
-     * @param walletClient - The wallet client for writing to the blockchain
-     * @param environment - The environment to use ('production' or 'development')
-     * @param version - Optional API version to use (defaults to 'v1')
-     * @param subgraphStudioKey - Optional subgraph studio key for protocol data fetching
-     */
-    constructor(publicClient: PublicClient, walletClient: WalletClient, environment: 'production' | 'development', version?: 'v1', subgraphStudioKey?: string);
-    private normalizeProtocolValue;
-    private resolveProtocolEnum;
-    private getProtocolBeaconNames;
-    private getPrimaryProtocolBeaconName;
-    private buildApiVaultFilter;
-    private vaultMatchesProtocolFilter;
-    private applyProtocolFilter;
-    private normalizeAddress;
-    private normalizeSymbol;
-    private matchesAnyAddress;
-    private matchesAnySymbol;
-    private filterVaultNodes;
-    /**
-     * 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);
-     * ```
-     */
-    getVaults(filter?: VaultFilter, first?: number, after?: string | null): Promise<SteerResponse<VaultsConnection>>;
-    /**
-     * Fetches ALL vaults from API (database) by auto-paginating
-     * @private
-     */
-    private getAllVaultsFromApi;
-    /**
-     * Fetches vaults from API (database) with pagination
-     * @private
-     */
-    private getVaultsFromApi;
-    /**
-     * Merges vault results from API and subgraph, removing duplicates
-     * Prioritizes API data when duplicates are found
-     * Generates consistent cursors for the merged dataset
-     * @private
-     */
-    private mergeVaultResults;
-    /**
-     * Applies pagination to vault results
-     * @private
-     */
-    private paginateVaults;
-    /**
-     * Fetches ALL vaults from subgraph (no pagination)
-     * @param filter - Optional filter criteria
-     * @returns Promise resolving to all vaults data from subgraph
-     * @private
-     */
-    private getAllVaultsFromSubgraph;
-    /**
-     * Fallback method to fetch vaults from subgraph with pagination
-     * @param filter - Optional filter criteria
-     * @param first - Number of items to fetch (default: 50)
-     * @param after - Cursor for pagination (null for first page)
-     * @returns Promise resolving to paginated vaults data from subgraph
-     * @private
-     */
-    private getVaultsFromSubgraph;
-    /**
-     * 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' });
-     * ```
-     */
-    getTokens(filter?: TokenFilter, first?: number, after?: string | null): Promise<SteerResponse<TokensConnection>>;
-    /**
-     * 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'
-     * });
-     * ```
-     */
-    getPools(filter?: PoolFilter, first?: number, after?: string | null): Promise<SteerResponse<PoolsConnection>>;
-    /**
-     * 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)`);
-     * });
-     * ```
-     */
-    getAllVaults(filter?: VaultFilter, batchSize?: number): Promise<SteerResponse<VaultNode[]>>;
-    /**
-     * 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
-     */
-    getAllTokens(filter?: TokenFilter, batchSize?: number): Promise<SteerResponse<TokenNode[]>>;
-    /**
-     * 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
-     */
-    getAllPools(filter?: PoolFilter, batchSize?: number): Promise<SteerResponse<PoolNode[]>>;
-    /**
-     * Searches vaults by combining verified API-supported filters with local
-     * filtering over the merged vault result set for unsupported server-side fields.
-     */
-    searchVaults(filter?: VaultFilter): Promise<SteerResponse<VaultNode[]>>;
-    getVaultByAddress(vaultAddress: string, filter?: VaultFilter): Promise<SteerResponse<VaultNode | null>>;
-    getVaultsForPool(poolAddress: string, filter?: VaultFilter): Promise<SteerResponse<VaultNode[]>>;
-    getVaultsForToken(tokenAddressOrSymbol: string, filter?: VaultFilter): Promise<SteerResponse<VaultNode[]>>;
-    /**
-     * 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}`);
-     *   });
-     * }
-     * ```
-     */
-    getAprs(filter: AprFilter): Promise<SteerResponse<AprResponse>>;
-    /**
-     * 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}%`);
-     *   });
-     * }
-     * ```
-     */
-    getBlackholeVaultApr(params: BlackholeAprDetailedParams): Promise<SteerResponse<BlackholeAprDetailedResponse>>;
-    /**
-     * Gets the latest vaults from the subgraph
-     */
-    getLatestVaults<T>(): Promise<SteerResponse<T>>;
-    /**
-     * Deposits tokens into a vault
-     * @param params The deposit parameters
-     */
-    deposit(params: VaultDepositParams): Promise<SteerResponse<Hash>>;
-    /**
-     * Prepares the transaction data for depositing tokens into a vault without executing it
-     * @param params The deposit parameters
-     */
-    prepareDepositTx(params: VaultDepositParams): Promise<SteerResponse<{
-        address: Address;
-        abi: {
-            type: string;
-            inputs: {
-                name: string;
-                internalType: string;
-                type: string;
-            }[];
-            name: string;
-            outputs: {
-                internalType: string;
-                name: string;
-                type: string;
-            }[];
-            stateMutability: string;
-        }[];
-        functionName: string;
-        args: readonly [Address, bigint, bigint, bigint, bigint, Address] | readonly [bigint, bigint, bigint, bigint, Address];
-    }>>;
-    /**
-     * Gets the deposit ratio for a vault
-     * @param vaultAddress The vault address
-     */
-    getDepositRatio(vaultAddress: Address, zeroForOne: boolean): Promise<SteerResponse<VaultDetailsResponse>>;
-    /**
-     * Withdraws tokens from a vault
-     * @param params The withdrawal parameters
-     */
-    withdraw(params: VaultWithdrawParams): Promise<SteerResponse<Hash>>;
-    /**
-     * Prepares the transaction data for withdrawing tokens from a vault without executing it
-     * @param params The withdrawal parameters
-     */
-    prepareWithdrawTx(params: VaultWithdrawParams): Promise<SteerResponse<{
-        address: Address;
-        abi: {
-            type: string;
-            inputs: {
-                name: string;
-                internalType: string;
-                type: string;
-            }[];
-            name: string;
-            outputs: never[];
-            stateMutability: string;
-        }[];
-        functionName: string;
-        args: readonly [
-            bigint,
-            bigint,
-            bigint,
-            Address
-        ];
-    }>>;
-    /**
-     * 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
-     */
-    getTokensFromLp(vaultAddress: Address, lpToken: bigint): Promise<SteerResponse<TokensFromLpResponse>>;
-    /**
-     * Approves spending of tokens for a vault
-     * @param params The approval parameters
-     */
-    approve(params: VaultApproveParams): Promise<SteerResponse<Hash>>;
-    /**
-     * Gets the allowance for a vault token
-     * @param params The allowance parameters
-     */
-    allowance(params: VaultAllowanceParams): Promise<SteerResponse<bigint>>;
-    /**
-     * Gets the balance of a vault token for an account
-     * @param params The balance parameters
-     */
-    balanceOf(params: VaultBalanceParams): Promise<SteerResponse<bigint>>;
-    /**
-     * Gets the total supply of a vault token
-     * @param vaultAddress The vault address
-     */
-    totalSupply(vaultAddress: Address): Promise<SteerResponse<bigint>>;
-    /**
-     * Gets the decimals of a vault token
-     * @param vaultAddress The vault address
-     */
-    decimals(vaultAddress: Address): Promise<SteerResponse<number>>;
-    /**
-     * Gets the symbol of a vault token
-     * @param vaultAddress The vault address
-     */
-    symbol(vaultAddress: Address): Promise<SteerResponse<string>>;
-    /**
-     * Gets the name of a vault token
-     * @param vaultAddress The vault address
-     */
-    name(vaultAddress: Address): Promise<SteerResponse<string>>;
-    pool(vaultAddress: Address): Promise<SteerResponse<Address>>;
-    /**
-     * Gets a pool instance for a vault
-     * @param params The pool instance parameters
-     */
-    getPoolInstance(params: PoolInstanceParams): Promise<SteerResponse<PoolV3>>;
-    /**
-     * 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
-     */
-    getCorrespondingTokenAmount(vaultAddress: Address, amount: bigint, zeroForOne: boolean): Promise<SteerResponse<bigint>>;
-    /**
-     * 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);
-     * }
-     * ```
-     */
-    previewSingleAssetDeposit(params: SingleAssetDepositParams, poolAddress: Address): Promise<SteerResponse<SingleAssetDepositPreview>>;
-    /**
-     * 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);
-     * }
-     * ```
-     */
-    singleAssetDeposit(params: SingleAssetDepositParams): Promise<SteerResponse<Hash>>;
-    /**
-     * 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
-     */
-    prepareSingleAssetDepositTx(params: SingleAssetDepositParams): Promise<{
-        data: {
-            address: string | undefined;
-            abi: ({
-                type: string;
-                inputs: never[];
-                stateMutability: string;
-                name?: undefined;
-                outputs?: undefined;
-                anonymous?: undefined;
-            } | {
-                type: string;
-                name: string;
-                inputs: {
-                    name: string;
-                    type: string;
-                    internalType: string;
-                }[];
-                outputs: {
-                    name: string;
-                    type: string;
-                    internalType: string;
-                }[];
-                stateMutability: string;
-                anonymous?: undefined;
-            } | {
-                type: string;
-                name: string;
-                inputs: {
-                    name: string;
-                    type: string;
-                    indexed: boolean;
-                    internalType: string;
-                }[];
-                anonymous: boolean;
-                stateMutability?: undefined;
-                outputs?: undefined;
-            } | {
-                type: string;
-                name: string;
-                inputs: {
-                    name: string;
-                    type: string;
-                    internalType: string;
-                }[];
-                stateMutability?: undefined;
-                outputs?: undefined;
-                anonymous?: undefined;
-            })[];
-            functionName: "deposit";
-            args: readonly [bigint, `0x${string}`, `0x${string}`, boolean, bigint, number, import("./vault/single-asset/types.js").AMMType];
-        };
-        status: number;
-        success: boolean;
-        error?: undefined;
-    } | {
-        data: null;
-        status: number;
-        success: boolean;
-        error: string;
-    }>;
-    /**
-     * Validates single-asset deposit parameters
-     *
-     * @param params - Parameters to validate
-     * @throws Error if parameters are invalid
-     */
-    validateSingleAssetDepositParams(params: SingleAssetDepositParams): void;
-    /**
-     * 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);
-     * }
-     * ```
-     */
-    calculatePendingRewards(params: PendingRewardsParams): Promise<SteerResponse<PendingRewardsResponse>>;
-    /**
-     * 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);
-     * }
-     * ```
-     */
-    claimBlackholePendingRewards(params: ClaimRewardsParams): Promise<SteerResponse<Hash | PendingRewardsResponse>>;
-}
-//# sourceMappingURL=VaultClient.d.ts.map