@upshiftfinance/sdk 0.0.0-stage → 0.1.0

package/lib/main.js

@@ -0,0 +1,681 @@
+"use strict";
+/**
+ * The main Upshift SDK class.
+ *
+ * @module UpshiftSDK
+ */
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpshiftSDK = void 0;
+const solana_1 = __importDefault(require("./adapters/solana"));
+const sui_1 = __importDefault(require("./adapters/sui"));
+const stellar_1 = __importDefault(require("./adapters/stellar"));
+const evm_1 = __importDefault(require("./adapters/evm"));
+const core_1 = require("./core");
+const vaults_1 = require("./modules/vaults");
+const analytics_1 = require("./core/analytics");
+const sub_accounts_1 = require("./modules/sub-accounts");
+const api_1 = require("./modules/api");
+/**
+ * Main SDK class for interacting with Upshift vaults and services.
+ * Provides unified access to EVM, Solana, Sui, and Stellar blockchain adapters.
+ */
+class UpshiftSDK extends core_1.UpshiftBase {
+    vaults;
+    subaccounts;
+    api;
+    solana;
+    sui;
+    stellar;
+    evm;
+    /**
+     * Initialize the Upshift SDK with provider configuration.
+     * Automatically sets up EVM adapter and optionally initializes Solana if RPC URL is provided.
+     */
+    constructor(baseConfig) {
+        super(baseConfig);
+        // @todo: change this later when upshift key is required
+        this.authorized = true;
+        // EVM adapter is always available. Signerless reads (balanceOf,
+        // previewDeposit, …) resolve a provider for the active network at call
+        // time so they follow switchNetwork; createProvider caches per URL+chain.
+        // A blank rpcUrl counts as "no provider" so the adapter throws its typed
+        // NO_SIGNER error instead of createProvider's raw Error.
+        this.evm = new evm_1.default(undefined, () => this.activeNetwork?.rpcUrl?.trim()
+            ? (0, core_1.createProvider)(this.activeNetwork.rpcUrl, this.activeNetwork.chainId)
+            : undefined);
+        // @solana: handle solana service initialization
+        //
+        // Two accepted entry points, treated as exclusive sources so url+network
+        // can never come from different configs:
+        //   1) `baseConfig.solana = { rpcUrl, network }` — preferred. Both fields
+        //      come from the same place; the caller controls the network.
+        //   2) `baseConfig.providers[-1] = rpcUrl` — legacy "Solana as another
+        //      EVM chain" shape. Network is derived from the URL substring.
+        //
+        // Without one of these `this.solana` stays undefined and every Solana
+        // vault is silently dropped from getVaults / getVaultPositions (the
+        // filter in modules/vaults/main.ts gates on `!!this.solanaService`).
+        const solanaConfig = (() => {
+            if (baseConfig.solana?.rpcUrl) {
+                return {
+                    rpcUrl: baseConfig.solana.rpcUrl,
+                    network: baseConfig.solana.network,
+                    commitment: baseConfig.solana.commitment,
+                };
+            }
+            const legacyRpcUrl = baseConfig.providers?.[core_1.SPECIAL_CHAINS.solana.chainId];
+            if (legacyRpcUrl) {
+                // No commitment here: `ISolanaConfig` requires `rpcUrl` + `network`, so
+                // a commitment-only `solana` object alongside this legacy path is not
+                // expressible in TypeScript. Set `solana: { rpcUrl, network,
+                // commitment }` to configure it.
+                return {
+                    rpcUrl: legacyRpcUrl,
+                    network: legacyRpcUrl.includes('devnet')
+                        ? 'devnet'
+                        : 'mainnet-beta',
+                    commitment: undefined,
+                };
+            }
+            return null;
+        })();
+        if (solanaConfig) {
+            this.solana = new solana_1.default(solanaConfig.rpcUrl, solanaConfig.network, solanaConfig.commitment);
+            (0, analytics_1.instrumentClass)(this.solana, () => core_1.SPECIAL_CHAINS.solana.chainId);
+        }
+        this.sui = new sui_1.default(baseConfig.sui);
+        // @stellar: mirror the Solana injection — the consumer may supply a keyed
+        // Soroban RPC (e.g. Alchemy) via `baseConfig.stellar`; otherwise the adapter
+        // uses its built-in public endpoints. Endpoint is injected, not hardcoded.
+        this.stellar = new stellar_1.default(baseConfig.stellar?.network, {
+            sorobanRpcUrl: baseConfig.stellar?.rpcUrl,
+        });
+        this.vaults = new vaults_1.UpshiftVaults(baseConfig, this.solana);
+        this.subaccounts = new sub_accounts_1.UpshiftSubAccounts(baseConfig);
+        this.api = new api_1.UpshiftApi(baseConfig);
+        // Instrument all SDK methods for analytics tracking
+        (0, analytics_1.instrumentClass)(this, () => this.activeNetwork?.chainId);
+        (0, analytics_1.instrumentClass)(this.evm, () => this.activeNetwork?.chainId);
+        (0, analytics_1.instrumentClass)(this.sui, () => core_1.SPECIAL_CHAINS.sui.chainId);
+        (0, analytics_1.instrumentClass)(this.stellar, () => core_1.SPECIAL_CHAINS.stellar?.chainId);
+        (0, analytics_1.instrumentClass)(this.vaults, () => this.activeNetwork?.chainId);
+        (0, analytics_1.instrumentClass)(this.subaccounts, () => this.activeNetwork?.chainId);
+        (0, analytics_1.instrumentClass)(this.api, () => this.activeNetwork?.chainId);
+    }
+    /**
+     * Get the Sub-Accounts module instance.
+     */
+    get subAccountsModule() {
+        return this.subaccounts;
+    }
+    /**
+     * Get the Vaults module instance.
+     */
+    get vaultsModule() {
+        return this.vaults;
+    }
+    /**
+     * 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() {
+        return this.api;
+    }
+    /**
+     * Switch the active network for vault operations.
+     * Updates the SDK's active chain and RPC provider.
+     */
+    switchNetwork(chainId) {
+        super.switchNetwork(chainId);
+        this.vaults.switchNetwork(chainId);
+        // Track network switch for analytics
+        (0, analytics_1.trackNetworkSwitch)(chainId);
+    }
+    /**
+     * Set the active wallet address for tracking user-specific vault data.
+     * Updates monitoring headers with the wallet address.
+     */
+    updateWallet(address) {
+        if (!address)
+            return;
+        if (this.monitoring) {
+            this.monitoring['x-user-id'] = address;
+        }
+        this.vaults.updateWallet(address);
+    }
+    /**
+     * Clear the active wallet address from the SDK state and monitoring headers.
+     */
+    clearWallet() {
+        if (this.monitoring) {
+            this.monitoring['x-user-id'] = undefined;
+        }
+        this.vaults.clearWallet();
+    }
+    /**
+     * 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
+     */
+    async getPrice(symbol) {
+        if (!this.authorized)
+            throw new Error('Not authorized.');
+        if (!symbol)
+            throw new Error(`Symbol input parameter is not defined.`);
+        return await (0, core_1.fetchTokenPrice)(symbol, null, this.keys?.coingecko);
+    }
+    /**
+     * 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
+     */
+    async getVaults(options) {
+        return await this.vaults.getVaults(options);
+    }
+    async getTotalDeposited(options) {
+        return await this.vaults.getTotalDeposited(options);
+    }
+    /**
+     * 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
+     */
+    async vaultDeposit(signer, options) {
+        return await this.vaults.vaultDeposit(signer, options);
+    }
+    /**
+     * Fetch detailed information for a specific vault.
+     * @param props - Vault address, chain ID, and optional enrichment options
+     * @returns Single vault object with full metadata
+     */
+    async getVault(props) {
+        return await this.vaults.getVault(props);
+    }
+    /**
+     * Get active loans deployed from a vault.
+     * @param props - Vault address and chain ID
+     * @returns Array of loan details including borrower, principal, APR
+     */
+    async getVaultLoans(props) {
+        return await this.vaults.getVaultLoans(props);
+    }
+    /**
+     * 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);
+     * }
+     * ```
+     */
+    async getVaultAllocations(props) {
+        return await this.vaults.getVaultAllocations(props);
+    }
+    /**
+     * 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
+     */
+    async getVaultApy(props) {
+        return await this.vaults.getVaultApy(props);
+    }
+    /**
+     * Get current or historical TVL for a vault.
+     * @param props - Vault address and optional historical parameters
+     * @returns TVL in vault's base asset units
+     */
+    async getVaultTvl(props) {
+        return await this.vaults.getVaultTvl(props);
+    }
+    /**
+     * 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
+     */
+    async getVaultHistoricalTimeseries(props) {
+        return await this.vaults.getVaultHistoricalTimeseries(props);
+    }
+    /**
+     * 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
+     */
+    async getYieldLastRealizedOn(props) {
+        return await this.vaults.getYieldLastRealizedOn(props);
+    }
+    /**
+     * 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 });
+     * ```
+     */
+    async getVaultAvailableRedemptions(props) {
+        return await this.vaults.getVaultAvailableRedemptions(props);
+    }
+    /**
+     * 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.
+     */
+    async getVaultRedemptionHistory(props) {
+        return await this.vaults.getVaultRedemptionHistory(props);
+    }
+    /**
+     * 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.
+     */
+    async getVaultPositions(props) {
+        return await this.vaults.getVaultPositions(props);
+    }
+    /**
+     * 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
+     */
+    async getVaultUserHistory(props) {
+        return await this.vaults.getUserHistory(props);
+    }
+    /**
+     * Get user's vault share transfer history from subgraph.
+     * @param props - Wallet address and optional vault/chain filters
+     * @returns Array of transfer events
+     */
+    async getVaultUserTransfers(props) {
+        return await this.vaults.getUserTransfers(props);
+    }
+    /**
+     * 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 });
+     * ```
+     */
+    async getVaultActivity(props) {
+        return await this.vaults.getVaultActivity(props);
+    }
+    /**
+     * 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);
+     * ```
+     */
+    async getSwapRouterWhitelistedTokens(chainId, options) {
+        return await this.vaults.getSwapRouterWhitelistedTokens(chainId, options);
+    }
+    /**
+     * 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);
+     * ```
+     */
+    async getSwapRouterEligibleVaults(chainId, options) {
+        return await this.vaults.getSwapRouterEligibleVaults(chainId, options);
+    }
+    /**
+     * 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 });
+     * ```
+     */
+    async getOriginInfo(options) {
+        return await this.vaults.getOriginInfo(options);
+    }
+    /**
+     * 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.
+     */
+    async getVaultUserLifetimePnl(props) {
+        return await this.vaults.getVaultUserLifetimePnl(props);
+    }
+    /**
+     * 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
+     */
+    async getVaultPnl(props) {
+        return await this.vaults.getVaultPnl(props);
+    }
+    /**
+     * Get user's staking positions for vault receipt tokens.
+     * @param props - Wallet address and optional chain ID
+     * @returns Array of staking positions with rewards
+     */
+    async getVaultStakingPositions(props) {
+        return await this.vaults.getStakingPositions(props.wallet, props.chainId);
+    }
+    /**
+     * 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.
+     */
+    async getVaultBorrowerHealthFactor(props) {
+        return await this.vaults.getVaultBorrowerHealthFactor(props?.chainId, props?.vault);
+    }
+    /**
+     * 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
+     */
+    async getUserPoints(userAddress) {
+        return await this.vaults.getUserPoints(userAddress);
+    }
+    /**
+     * 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.
+     */
+    async registerUserForPoints(userAddress, referrerAddress, chainId, signature, nonce, expiry) {
+        return await this.vaults.registerUserForPoints(userAddress, referrerAddress, chainId, signature, nonce, expiry);
+    }
+    /**
+     * Fetch the points leaderboard data.
+     * @param params - Optional parameters for pagination and sorting
+     * @returns Leaderboard response data
+     */
+    async fetchPointsLeaderboard(params) {
+        return await this.vaults.fetchPointsLeaderboard(params);
+    }
+    /**
+     * Fetch the historical unrealized-PnL series for a vault, newest first.
+     * Delegates to {@link UpshiftApi.getVaultUnrealizedPnlHistory} — see it for
+     * parameter semantics and thrown errors.
+     */
+    async getVaultUnrealizedPnlHistory(params) {
+        return await this.api.getVaultUnrealizedPnlHistory(params);
+    }
+    /**
+     * Fetch the latest unrealized-PnL snapshot for every tracked vault.
+     * Delegates to {@link UpshiftApi.getLatestUnrealizedPnl} — see it for
+     * return shape and thrown errors.
+     */
+    async getLatestUnrealizedPnl() {
+        return await this.api.getLatestUnrealizedPnl();
+    }
+    /**
+     * 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
+     */
+    async getVaultAnnualizedApy(props) {
+        return await this.vaults.getVaultAnnualizedApy(props.vault);
+    }
+    /**
+     * Get summary data for a vault (name, type, chain, recent returns).
+     * @param props - Vault address
+     * @returns Vault summary data
+     */
+    async getVaultSummary(props) {
+        return await this.vaults.getVaultSummary(props.vault);
+    }
+    /**
+     * Get withdrawal summary and pending queue for a vault.
+     * @param props - Vault address and optional chain ID
+     * @returns Withdrawal summary and pending queue
+     */
+    async getVaultWithdrawals(props) {
+        return await this.vaults.getVaultWithdrawals(props.vault, props.chainId);
+    }
+    /**
+     * 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}
+     */
+    async previewRedemption(props) {
+        return await this.vaults.previewRedemption(props);
+    }
+    /**
+     * 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'
+     * });
+     * ```
+     */
+    async getLayerZeroDeposits(props) {
+        // Runtime validation for receipt token
+        const validTokens = ['upusdc', 'coreusdc', 'earnausd'];
+        if (!validTokens.includes(props.receiptToken)) {
+            throw new Error(`Invalid receiptToken: ${props.receiptToken}. Must be 'upusdc', 'coreusdc', or 'earnausd'.`);
+        }
+        const { queryLayerZeroDeposits } = await Promise.resolve().then(() => __importStar(require('./services/layerzero/deposits')));
+        // Map receipt token to vault key
+        const vaultKeyMap = {
+            upusdc: 'upUSDC',
+            coreusdc: 'coreUSDC',
+            earnausd: 'earnAUSD',
+        };
+        const vaultKey = vaultKeyMap[props.receiptToken];
+        return await queryLayerZeroDeposits(vaultKey, props.wallet);
+    }
+    /**
+     * 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'
+     * });
+     * ```
+     */
+    async getLayerZeroRedeems(props) {
+        const { queryLayerZeroRedeems } = await Promise.resolve().then(() => __importStar(require('./services/layerzero/redeems')));
+        return await queryLayerZeroRedeems(props?.wallet);
+    }
+}
+exports.UpshiftSDK = UpshiftSDK;
+//# sourceMappingURL=main.js.map