@upshiftfinance/sdk 0.0.0-stage → 0.1.0

package/lib/main.d.ts

@@ -0,0 +1,596 @@
+/**
+ * The main Upshift SDK class.
+ *
+ * @module UpshiftSDK
+ */
+import SolanaAdapter from './adapters/solana';
+import SuiAdapter from './adapters/sui';
+import StellarAdapter from './adapters/stellar';
+import EVMAdapter from './adapters/evm';
+import type { IAddress, IChainId, IVaultHistoricalParams } from './types';
+import { UpshiftBase, type IUpshiftBase } from './core';
+import { UpshiftVaults, type IGetVaultsOptions, type IVaultBaseOptions, type IVaultCustomOptions } from './modules/vaults';
+import type { Signer, Wallet } from 'ethers';
+import type { IContractWriteOptions } from './modules/vaults/write.actions';
+import { UpshiftSubAccounts } from './modules/sub-accounts';
+import { UpshiftApi } from './modules/api';
+/**
+ * Main SDK class for interacting with Upshift vaults and services.
+ * Provides unified access to EVM, Solana, Sui, and Stellar blockchain adapters.
+ */
+export declare class UpshiftSDK extends UpshiftBase {
+    private vaults;
+    private subaccounts;
+    private api;
+    solana: SolanaAdapter;
+    sui: SuiAdapter;
+    stellar: StellarAdapter;
+    evm: EVMAdapter;
+    /**
+     * Initialize the Upshift SDK with provider configuration.
+     * Automatically sets up EVM adapter and optionally initializes Solana if RPC URL is provided.
+     */
+    constructor(baseConfig: IUpshiftBase);
+    /**
+     * Get the Sub-Accounts module instance.
+     */
+    get subAccountsModule(): UpshiftSubAccounts;
+    /**
+     * Get the Vaults module instance.
+     */
+    get vaultsModule(): UpshiftVaults;
+    /**
+     * Get the backend API module instance ({@link UpshiftApi}) — read-only
+     * access to backend-computed data with no on-chain equivalent: the
+     * unrealized-PnL series and the transparency dashboard (position snapshot,
+     * backing series, smoothed APY, allocations, fee config, governance).
+     */
+    get apiModule(): UpshiftApi;
+    /**
+     * Switch the active network for vault operations.
+     * Updates the SDK's active chain and RPC provider.
+     */
+    switchNetwork(chainId: IChainId): void;
+    /**
+     * Set the active wallet address for tracking user-specific vault data.
+     * Updates monitoring headers with the wallet address.
+     */
+    updateWallet(address: IAddress): void;
+    /**
+     * Clear the active wallet address from the SDK state and monitoring headers.
+     */
+    clearWallet(): void;
+    /**
+     * Pricing and Market Data
+     */
+    /**
+     * Get the current USD price of a token by symbol or contract address.
+     * Falls back to CoinGecko if primary price source fails.
+     *
+     * @param symbol - Token symbol or contract address
+     * @returns Current price in USD
+     */
+    getPrice(symbol: string): Promise<number>;
+    /**
+     * Vault Data and Operations
+     */
+    /**
+     * Fetch all available vaults across configured networks.
+     * Optionally filter by chain IDs and include loan/allocation data.
+     * @param options - Configuration for filtering and enriching vault data —
+     * see {@link IGetVaultsOptions} for the full surface (`includeClosed`
+     * portfolio mode, `maxRetries`/`baseDelay` retry tuning)
+     * @returns Array of vault objects with metadata and optional position data
+     */
+    getVaults(options?: IGetVaultsOptions): Promise<import("./types").IVault[]>;
+    getTotalDeposited(options?: {
+        loadSubaccounts?: boolean;
+        loadSnapshots?: boolean;
+    }): Promise<number>;
+    /**
+     * Deposit into a vault with an explicit signer. When `depositAsset` differs
+     * from the vault's underlying asset the deposit goes through the vault's
+     * multi-asset `deposit`, permit path, or configured adapter. It never swaps
+     * (use `evm.swapRouterDeposit` for that); with `attribution.originCode` set,
+     * eligible deposits go through the SwapRouter (see `evm.getDepositRoute`).
+     * @param signer - ethers Signer or Wallet that sends the transaction
+     * @param options - Vault address (`target`), depositor `wallet`, `amount`, and optional `depositAsset`, `wait`, `isDepositWithPermit`
+     * @returns Deposit transaction hash
+     */
+    vaultDeposit(signer: Signer | Wallet, options: IContractWriteOptions): Promise<string>;
+    /**
+     * Fetch detailed information for a specific vault.
+     * @param props - Vault address, chain ID, and optional enrichment options
+     * @returns Single vault object with full metadata
+     */
+    getVault(props: {
+        vault: IAddress;
+        chainId?: IChainId;
+        options?: IVaultCustomOptions;
+        loadSubaccounts?: boolean;
+        loadSnapshots?: boolean;
+    }): Promise<import("./types").IVault>;
+    /**
+     * Get active loans deployed from a vault.
+     * @param props - Vault address and chain ID
+     * @returns Array of loan details including borrower, principal, APR
+     */
+    getVaultLoans(props: {
+        vault: IAddress;
+        chainId?: IChainId;
+    }): Promise<import("./types").IVaultLoan[]>;
+    /**
+     * Get vault asset allocations across DeFi protocols, CeFi, and OTC positions.
+     *
+     * This is the data behind the "Vault Exposure" section of the Upshift app —
+     * a partner rendering that section in their own frontend needs only this
+     * call. Read `exposurePerCategory` for the pre-bucketed view the UI renders
+     * (`supplying` / `borrowing` / `wallet` / `lending` legs plus per-category
+     * USD totals) and `netValue` for the headline figure; the raw `defi` /
+     * `cefi` / `otc` arrays back the drill-downs. See the "Rendering the Vault
+     * Exposure section" guide in the vaults docs for a faithful reproduction.
+     *
+     * Stellar vaults resolve their DeFi exposure through the Untangled portfolio
+     * API instead of DeBank — one extra HTTP call, covering the idle buffer,
+     * Stellar protocol positions, custody wallets and bridged capital. If that
+     * call fails the exposure legs come back empty rather than throwing, so CeFi,
+     * OTC and loan allocations still resolve.
+     *
+     * @param props - Vault address and chain ID
+     * @returns Detailed breakdown of vault allocations by category
+     * @example
+     * ```ts
+     * const { exposurePerCategory, netValue } = await sdk.getVaultAllocations({
+     *   vault: '0xcd69123b3FBBfC666E1f6a501da27B564C00De54',
+     *   chainId: 1,
+     * });
+     * for (const item of exposurePerCategory?.supplying ?? []) {
+     *   console.log(item.protocol, item.symbol, item.amount);
+     * }
+     * ```
+     */
+    getVaultAllocations(props: {
+        vault: IAddress;
+        chainId?: IChainId;
+    }): Promise<import("./types").IVaultAllocations | {
+        status: number;
+        message: string;
+    }>;
+    /**
+     * Get current or historical APY for a vault.
+     *
+     * @deprecated use getVaultHistoricalTimeseries instead
+     *
+     * @param props - Vault address and optional historical lookback period
+     * @returns APY data including rewards breakdown
+     */
+    getVaultApy(props: {
+        vault: IAddress;
+        historical?: {
+            daysAgo?: number;
+        };
+    }): Promise<{
+        value: number;
+        timestamp: string;
+    }[]>;
+    /**
+     * Get current or historical TVL for a vault.
+     * @param props - Vault address and optional historical parameters
+     * @returns TVL in vault's base asset units
+     */
+    getVaultTvl(props: {
+        vault: IAddress;
+        historical?: IVaultHistoricalParams;
+        chainId?: IChainId;
+    }): Promise<{
+        value: import("./types").INormalizedNumber;
+        timestamp: string;
+    }[]>;
+    /**
+     * Get historical timeseries data for a vault.
+     * @param props - Vault address and optional number of days
+     * @returns Historical timeseries data with TVL, APY, PnL, share price, and other metrics
+     */
+    getVaultHistoricalTimeseries(props: {
+        vault: IAddress;
+        nDays?: number;
+    }): Promise<import("./types").IHistoricalTimeseriesResponse>;
+    /**
+     * Get the timestamp when yield was last realized for a vault.
+     * @param props - Vault address and optional chain ID
+     * @returns Timestamp (Unix timestamp in seconds) when yield was last realized
+     */
+    getYieldLastRealizedOn(props: {
+        vault: IAddress;
+        chainId?: IChainId;
+    }): Promise<number>;
+    /**
+     * Get redemption requests that are ready to be claimed.
+     *
+     * For a Solana vault, `wallet` is the holder's base58 address and the result
+     * lists their withdrawal-queue requests: waiting (`AWAITING_COOLDOWN`) and
+     * past-window (`EXPIRED`, cancel-only) ones in `availableRedemptions`, and
+     * claimable ones (`READY_TO_CLAIM`) in `pendingRedemptions`, each with
+     * `estimatedAssets`, the net payout at the current share price. Without a
+     * Solana wallet, or for a vault with no queue, both lists are empty. Solana
+     * RPC: the vault state, one `getAccountInfo` for the queue, and, when it
+     * exists, one `getProgramAccounts` and one `getMultipleAccountsInfo` (the
+     * vault state, share mint and payout accounts, read together).
+     *
+     * @param props - Vault address, chain ID, and optional wallet filter
+     * @returns Array of available redemption requests with amounts and timestamps
+     * @example
+     * ```ts
+     * const { availableRedemptions, pendingRedemptions } =
+     *   await sdk.getVaultAvailableRedemptions({ vault: solanaVault, wallet: holder });
+     * ```
+     */
+    getVaultAvailableRedemptions(props: {
+        vault: IAddress;
+        chainId?: IChainId;
+        wallet?: IAddress;
+        verbose?: boolean;
+    }): Promise<{
+        processedWithdrawals: import("./types").ISubgraphWithdrawProccessed[];
+        requestedWithdrawals: import("./types").ISubgraphWithdrawRequest[];
+        availableRedemptions: import("./types").IVaultAvailableRedemption[];
+        pendingRedemptions: import("./types").IVaultAvailableRedemption[];
+    }>;
+    /**
+     * Get historical redemption requests for a vault (settled, cancelled,
+     * pending-but-out-of-window), optionally filtered to one wallet.
+     *
+     * @param props - Vault address, chain ID, optional wallet, and an
+     *   optional `lookbackBlocks` for how far back to scan.
+     * @returns Historical redemption records, newest first.
+     */
+    getVaultRedemptionHistory(props: {
+        vault: IAddress;
+        chainId?: IChainId;
+        wallet?: IAddress;
+        lookbackBlocks?: number;
+    }): Promise<import("./types").IVaultRedemptionHistoryItem[]>;
+    /**
+     * Get user positions across vaults including shares and claimable redemptions.
+     * Supports both EVM and Solana vaults.
+     * @param props - Wallet address, chain ID, and optional vault filter
+     * @returns Array of positions with balances and pending redemptions
+     * @throws {@link UpshiftValidationError} (`INVALID_ADDRESS`) when `suiWallet`
+     *   is not a Sui address.
+     */
+    getVaultPositions(props: {
+        vault?: IAddress;
+        wallet?: IAddress;
+        chainId?: IChainId;
+        showAllVaults?: boolean;
+        solanaWallet?: string;
+        stellarWallet?: string;
+        /**
+         * Sui wallet address (`0x` + 64 hex chars). Validated now; Sui positions
+         * are not read yet, so passing it does not add Sui vaults to the result.
+         */
+        suiWallet?: string;
+        options?: IVaultBaseOptions;
+    }): Promise<import("./types").IVaultPosition[]>;
+    /**
+     * Get user's historical vault interactions including deposits and withdrawals.
+     * @param props - Wallet address and optional vault/chain filters
+     * @returns Array of historical transactions with amounts and timestamps
+     */
+    getVaultUserHistory(props: {
+        wallet: IAddress;
+        chainId?: IChainId;
+        vault?: IAddress;
+        options?: IVaultBaseOptions;
+    }): Promise<import("./types").IVaultUserHistoryItem[]>;
+    /**
+     * Get user's vault share transfer history from subgraph.
+     * @param props - Wallet address and optional vault/chain filters
+     * @returns Array of transfer events
+     */
+    getVaultUserTransfers(props: {
+        wallet: IAddress;
+        chainId?: IChainId;
+        vault?: IAddress;
+        options?: IVaultBaseOptions;
+    }): Promise<{
+        id: string;
+        value: string;
+        to: string;
+        from: string;
+        pool: string;
+        block: number;
+        timestamp: number;
+        transactionHash: string;
+    }[]>;
+    /**
+     * Get a vault's deposit/withdrawal activity across every participant.
+     *
+     * The vault-wide counterpart to {@link UpshiftSDK.getVaultUserHistory} — use
+     * it to answer flow questions ("how many deposits in the last 7 days", "net
+     * flow this week") that point-in-time TVL cannot. Reads from the Goldsky
+     * subgraph, paginated so busy vaults are not truncated; a `sinceTs` window
+     * keeps short lookbacks cheap.
+     * @param props - Vault address, optional chain id, optional `sinceTs`/`untilTs`
+     * Unix-second bounds, and an optional `types` filter.
+     * @returns Array of activity items (oldest-first) with normalized amounts,
+     * actor addresses, event type, and transaction hashes.
+     * @throws If `vault` is not a valid address or no chain id can be resolved.
+     * @example
+     * ```ts
+     * const weekAgo = Math.floor(Date.now() / 1000) - 7 * 86_400;
+     * const items = await sdk.getVaultActivity({ vault, chainId: 143, sinceTs: weekAgo });
+     * ```
+     */
+    getVaultActivity(props: {
+        vault: IAddress;
+        chainId?: IChainId;
+        sinceTs?: number;
+        untilTs?: number;
+        types?: ('withdraw-request' | 'deposit' | 'withdraw-processed' | 'redeem')[];
+    }): Promise<import("./types").IVaultUserHistoryItem[]>;
+    /**
+     * Resolve the ERC-20 tokens currently whitelisted for the `SwapRouter` on a
+     * chain — the any-token set a deposit UI can offer as swap-and-deposit inputs.
+     *
+     * Delegates to {@link UpshiftVaults.getSwapRouterWhitelistedTokens}, which
+     * reconstructs the set from the router's `TokenEnabled` events and verifies
+     * each against the on-chain `whitelistedTokens` mapping (not enumerable).
+     * Returns `[]` when no router is deployed on `chainId` or no provider is
+     * configured for it.
+     *
+     * @param chainId - EVM chain ID to resolve the allowlist for.
+     * @param options - Optional `fromBlock` to override the deploy-block scan floor.
+     * @returns Checksummed whitelisted token addresses; `[]` when unavailable.
+     * @throws UpshiftSDKError when an `eth_getLogs` scan chunk fails.
+     * @example
+     * ```ts
+     * const tokens = await upshiftSdk.getSwapRouterWhitelistedTokens(1);
+     * ```
+     */
+    getSwapRouterWhitelistedTokens(chainId: number, options?: {
+        fromBlock?: number;
+    }): Promise<IAddress[]>;
+    /**
+     * Resolve the vaults that offer the any-token `SwapRouter` deposit surface
+     * (swap tokens) on a chain — every vault the Upshift API marks
+     * `swaps_enabled`.
+     *
+     * Delegates to {@link UpshiftVaults.getSwapRouterEligibleVaults}. Returns
+     * `[]` when no router is deployed on `chainId`. App-level policy (e.g.
+     * OVault exclusions) remains the caller's responsibility.
+     *
+     * @param chainId - EVM chain ID to resolve eligible vaults for.
+     * @param options - Kept for compatibility; `fromBlock` is no longer read.
+     * @returns Checksummed `swaps_enabled` vault addresses; `[]` when unavailable.
+     * @throws When the Upshift API vault-list request fails.
+     * @example
+     * ```ts
+     * const vaults = await upshiftSdk.getSwapRouterEligibleVaults(1);
+     * ```
+     */
+    getSwapRouterEligibleVaults(chainId: number, options?: {
+        fromBlock?: number;
+    }): Promise<IAddress[]>;
+    /**
+     * Read a SwapRouter origin code's on-chain registration (registered, fee in
+     * bps, collector). Delegates to {@link UpshiftVaults.getOriginInfo}.
+     * @param options - `chainId` and the `bytes32` `originCode` to look up.
+     * @returns `{ registered, originFeeBps, collector }`.
+     * @throws UpshiftValidationError when no provider is configured for `chainId`
+     *   or `originCode` is malformed.
+     * @example
+     * ```ts
+     * const { registered } = await upshiftSdk.getOriginInfo({ chainId: 1, originCode });
+     * ```
+     */
+    getOriginInfo(options: {
+        chainId: number;
+        originCode: `0x${string}`;
+    }): Promise<import("./types").IOriginInfo>;
+    /**
+     * Get lifetime PnL for a user in a specific vault.
+     * Calculates realized and unrealized PnL based on deposit/withdrawal history and current position.
+     * @param props - Vault address, wallet address, and optional chain ID
+     * @returns Lifetime PnL data including realized and unrealized PnL in both native token and USD
+     * @throws {@link UpshiftHistoryUnavailableError} (`HISTORY_UNAVAILABLE`) when a
+     *   live position has no indexed deposits, withdrawals or priceable share
+     *   transfers.
+     * @throws {@link UpshiftPriceUnavailableError} (`PRICE_UNAVAILABLE`) when the
+     *   vault's underlying asset has no USD price — the USD fields are never
+     *   computed from a stand-in price.
+     */
+    getVaultUserLifetimePnl(props: {
+        vault: IAddress;
+        wallet: IAddress;
+        chainId?: IChainId;
+    }): Promise<import("./types").IVaultUserLifetimePnl>;
+    /**
+     * Get PnL for a vault (vault-level, not user-specific).
+     * Returns the vault's overall profit and loss across all users.
+     * @param props - Vault address and optional chain ID
+     * @returns Vault PnL in USD and notional value
+     */
+    getVaultPnl(props: {
+        vault: IAddress;
+        chainId?: IChainId;
+    }): Promise<import("./types").IVaultPnl>;
+    /**
+     * Get user's staking positions for vault receipt tokens.
+     * @param props - Wallet address and optional chain ID
+     * @returns Array of staking positions with rewards
+     */
+    getVaultStakingPositions(props: {
+        wallet?: IAddress;
+        chainId?: IChainId;
+    }): Promise<import("./types").IActiveStakingPosition[]>;
+    /**
+     * Get the borrower's health factor by vault.
+     *
+     * Pass `vault` whenever the caller knows which pool it cares about — it
+     * skips the all-vaults cross-chain fanout and only reads the loans for
+     * that one pool. The response map is keyed by **lowercased** vault
+     * address; look entries up with `address.toLowerCase()`.
+     *
+     * @param props.chainId Optional chain to scope the read to.
+     * @param props.vault Optional vault address. When provided alongside
+     *   `chainId`, only that vault's borrower-health-factor data is fetched.
+     * @returns Object containing the borrower's health factor by vault.
+     */
+    getVaultBorrowerHealthFactor(props?: {
+        chainId?: IChainId;
+        vault?: IAddress;
+    }): Promise<Record<string, import("./types").IVaultBorrowerHealthFactor[]> | Record<string, import("./types").IVaultBorrowerHealthFactor[]>[]>;
+    /**
+     * Get user points from the backend API.
+     * This fetches processed points data directly from the backend,
+     * removing the need for client-side points calculation.
+     * @param userAddress - User wallet address
+     * @returns Points data from the backend API
+     */
+    getUserPoints(userAddress: IAddress): Promise<any>;
+    /**
+     * Register a user for the points program, authenticated by a wallet signature.
+     *
+     * The caller produces a personal_sign signature over a canonical message
+     * containing the user address, referrer (or `"none"`), chain, nonce, and
+     * expiry — see `UpshiftVaults.registerUserForPoints` for the exact template.
+     *
+     * @param userAddress - EVM wallet address being registered.
+     * @param referrerAddress - Optional EVM referrer address.
+     * @param chainId - Chain on which the wallet signed; powers the EIP-1271
+     *   fallback for smart-contract wallets and pins the signature cross-chain.
+     * @param signature - 0x-prefixed personal_sign signature over the canonical message.
+     * @param nonce - Single-use random string (8–128 chars).
+     * @param expiry - Unix seconds; must be in the future, within the backend's TTL.
+     * @returns Raw `Response` from the backend.
+     */
+    registerUserForPoints(userAddress: IAddress, referrerAddress: IAddress | undefined, chainId: number, signature: string, nonce: string, expiry: number): Promise<Response>;
+    /**
+     * Fetch the points leaderboard data.
+     * @param params - Optional parameters for pagination and sorting
+     * @returns Leaderboard response data
+     */
+    fetchPointsLeaderboard(params?: {
+        page?: number;
+        perPage?: number;
+        sortBy?: 'streakDays' | 'totalPoints';
+    }): Promise<any>;
+    /**
+     * Fetch the historical unrealized-PnL series for a vault, newest first.
+     * Delegates to {@link UpshiftApi.getVaultUnrealizedPnlHistory} — see it for
+     * parameter semantics and thrown errors.
+     */
+    getVaultUnrealizedPnlHistory(params: {
+        vault: string;
+        limit?: number;
+    }): Promise<import("./types").IUnrealizedPnlSnapshot[]>;
+    /**
+     * Fetch the latest unrealized-PnL snapshot for every tracked vault.
+     * Delegates to {@link UpshiftApi.getLatestUnrealizedPnl} — see it for
+     * return shape and thrown errors.
+     */
+    getLatestUnrealizedPnl(): Promise<import("./types").IUnrealizedPnlSnapshot[]>;
+    /**
+     * Get annualized APY metrics for a vault.
+     *
+     * Supported Vaults: cUSDO, tETH, wstETH, rsETH
+     *
+     * @deprecated The `hgETH30dLiquidAPY` and `hgETH7dLiquidAPY` response fields are deprecated.
+     * These fields will be removed in the next major release.
+     * Use `liquidAPY30Day` and `liquidAPY7Day` fields instead.
+     *
+     * @param props - Vault address
+     * @returns Annualized APY data including liquidity APY
+     */
+    getVaultAnnualizedApy(props: {
+        vault: IAddress;
+    }): Promise<import("./types").IVaultAnnualizedApy>;
+    /**
+     * Get summary data for a vault (name, type, chain, recent returns).
+     * @param props - Vault address
+     * @returns Vault summary data
+     */
+    getVaultSummary(props: {
+        vault: IAddress;
+    }): Promise<import("./types").IVaultSummary>;
+    /**
+     * Get withdrawal summary and pending queue for a vault.
+     * @param props - Vault address and optional chain ID
+     * @returns Withdrawal summary and pending queue
+     */
+    getVaultWithdrawals(props: {
+        vault: IAddress;
+        chainId?: IChainId;
+    }): Promise<import("./types").IVaultWithdrawals>;
+    /**
+     * Preview the amount of assets that would be received for redeeming shares (queued redemption).
+     * @param props - Vault contract address, shares amount, and optional chain ID
+     * @returns The amount of assets as {@link INormalizedNumber}
+     */
+    previewRedemption(props: {
+        vault: IAddress;
+        sharesAmount: string | bigint | number;
+        chainId?: IChainId;
+    }): Promise<import("./types").INormalizedNumber>;
+    /**
+     * Query LayerZero USDC deposits from the august-layerzero subgraphs.
+     * Returns all deposits or filters by sender wallet address if provided.
+     *
+     * **Important Notes:**
+     * - Only deposit transactions are tracked (not withdrawals or other operations)
+     * - Sender and recipient addresses are stored in bytes32 format in the subgraph
+     * - Timestamps are available from the subgraph
+     *
+     * **Supported Vaults:**
+     * - `upusdc`: 0x80E1048eDE66ec4c364b4F22C8768fc657FF6A42
+     * - `coreusdc`: 0xE9B725010A9E419412ed67d0fA5f3A5f40159D32
+     * - `earnausd`: 0x36eDbF0C834591BFdfCaC0Ef9605528c75c406aA
+     *
+     * @param props - Receipt token type ('upusdc', 'coreusdc', or 'earnausd') and optional wallet address to filter by sender
+     * @returns Array of deposit events with the following structure:
+     * - `assetAmt`: Amount of assets deposited (as string)
+     * - `shareAmt`: Amount of shares received (as string)
+     * - `sender`: Sender address in bytes32 format
+     * - `recipient`: Recipient address in bytes32 format
+     * - `dstEid`: Destination endpoint ID (LayerZero chain identifier)
+     * - `transactionHash_`: Transaction hash
+     *
+     * @throws Error if receipt token is invalid or GraphQL request fails
+     *
+     * @example
+     * ```typescript
+     * // Get all coreUSDC deposits
+     * const allDeposits = await sdk.getLayerZeroDeposits({
+     *   receiptToken: 'coreusdc'
+     * });
+     *
+     * // Get deposits for a specific wallet
+     * const userDeposits = await sdk.getLayerZeroDeposits({
+     *   receiptToken: 'upusdc',
+     *   wallet: '0xb0280B58F541131b29D1B33319CD440a99eA0305'
+     * });
+     * ```
+     */
+    getLayerZeroDeposits(props: {
+        receiptToken: 'upusdc' | 'coreusdc' | 'earnausd';
+        wallet?: IAddress;
+    }): Promise<import("./services/layerzero/deposits").ILayerZeroDeposit[]>;
+    /**
+     * Get LayerZero redeems for earnAUSD vault
+     *
+     * @example
+     * ```typescript
+     * // Get all earnAUSD redeems
+     * const allRedeems = await sdk.getLayerZeroRedeems();
+     *
+     * // Get redeems for a specific wallet
+     * const userRedeems = await sdk.getLayerZeroRedeems({
+     *   wallet: '0x2de1DCB8EaAd40fAd327fa3eE3F48774b8e20649'
+     * });
+     * ```
+     */
+    getLayerZeroRedeems(props?: {
+        wallet?: IAddress;
+    }): Promise<import("./services/layerzero/redeems").ILayerZeroRedeem[]>;
+}