@augustdigital/sdk 8.5.0 → 8.6.1

package/lib/sdk.d.ts

@@ -1,6 +1,6 @@
 import type { Abi } from 'abitype';
 import type { AbiParametersToPrimitiveTypes } from 'abitype';
-import { AnchorProvider } from '@coral-xyz/anchor';
+import type { AnchorProvider } from '@coral-xyz/anchor';
 import type { BaseContract } from 'ethers';
 import { Connection } from '@solana/web3.js';
 import type { ContractTransaction } from 'ethers';
@@ -21,10 +21,10 @@ import { JsonRpcProvider } from 'ethers';
 import { LRUCache } from 'lru-cache';
 import type { Overrides } from 'ethers';
 import { Program } from '@coral-xyz/anchor';
-import { Provider } from 'ethers';
+import type { Provider } from 'ethers';
 import { PublicKey } from '@solana/web3.js';
 import type { Result } from 'ethers';
-import { SendTransactionOptions } from '@solana/wallet-adapter-base';
+import type { SendTransactionOptions } from '@solana/wallet-adapter-base';
 import type * as Sentry from '@sentry/browser';
 import { Signer } from 'ethers';
 import { Transaction } from '@solana/web3.js';
@@ -15219,7 +15219,7 @@ export declare class AugustBase {
  * ```
  */
 /** Stable error codes attached to SDK errors. */
-export declare type AugustErrorCode = 'AUTH_MISSING_KEY' | 'AUTH_INVALID_KEY' | 'AUTH_FORBIDDEN' | 'AUTH_UNAUTHORIZED' | 'INVALID_URL' | 'INVALID_INPUT' | 'INVALID_CHAIN' | 'INVALID_ADDRESS' | 'NETWORK_ERROR' | 'TIMEOUT' | 'RATE_LIMITED' | 'SERVER_ERROR' | 'UNKNOWN';
+export declare type AugustErrorCode = 'AUTH_MISSING_KEY' | 'AUTH_INVALID_KEY' | 'AUTH_FORBIDDEN' | 'AUTH_UNAUTHORIZED' | 'INVALID_URL' | 'INVALID_INPUT' | 'INVALID_CHAIN' | 'INVALID_ADDRESS' | 'ACCOUNT_NOT_FUNDED' | 'NETWORK_ERROR' | 'TIMEOUT' | 'RATE_LIMITED' | 'SERVER_ERROR' | 'UNKNOWN';
 
 /** Options accepted by every SDK error constructor. */
 export declare interface AugustErrorOptions {
@@ -15301,7 +15301,7 @@ declare class AugustSDK extends AugustBase {
      * @param symbol - Token symbol or contract address
      * @returns Current price in USD
      */
-    getPrice(symbol: string): Promise<any>;
+    getPrice(symbol: string): Promise<number>;
     /**
      * Vault Data and Operations
      */
@@ -15868,7 +15868,7 @@ export declare class AugustTimeoutError extends AugustSDKError {
 
 /** Caller-side input failed validation. */
 export declare class AugustValidationError extends AugustSDKError {
-    constructor(code: Extract<AugustErrorCode, 'INVALID_URL' | 'INVALID_INPUT' | 'INVALID_CHAIN' | 'INVALID_ADDRESS'>, message: string, options?: AugustErrorOptions);
+    constructor(code: Extract<AugustErrorCode, 'INVALID_URL' | 'INVALID_INPUT' | 'INVALID_CHAIN' | 'INVALID_ADDRESS' | 'ACCOUNT_NOT_FUNDED'>, message: string, options?: AugustErrorOptions);
 }
 
 /**
@@ -16381,21 +16381,23 @@ declare let cacheStats: {
 };
 
 /**
- * Calculate weighted average for array of objects
- * @param {Array<Object>} data - Array of objects with values
- * @param {string} valueProperty - Property name containing the value to average
- * @param {string} [weightProperty] - Optional property to base weights on
- * @returns {number} Weighted average
+ * Calculate weighted average for array of objects.
+ * @param data - Array of objects with values
+ * @param valueProperty - Property name containing the value to average
+ * @param weightProperty - Optional property to base weights on
+ * @returns Weighted average
  */
-export declare function calculateWeightedAverage(data?: Array<any>, valueProperty?: string, weightProperty?: string): any;
+export declare function calculateWeightedAverage<T extends Record<string, unknown>>(data?: T[], valueProperty?: string, weightProperty?: string): number;
 
 /**
- * Calculate weights based on a specific property in array of objects
- * @param {Array<Object>} data - Array of objects to calculate weights for
- * @param {string} weightProperty - Property name to base weights on
- * @returns {Array<Object>} Original data with weights added
+ * Calculate weights based on a specific property in array of objects.
+ * @param data - Array of objects to calculate weights for
+ * @param weightProperty - Property name to base weights on
+ * @returns Original data with each item's `weight` added
  */
-export declare function calculateWeights(data?: Array<any>, weightProperty?: string): any[];
+export declare function calculateWeights<T extends Record<string, unknown>>(data?: T[], weightProperty?: string): Array<T & {
+    weight: number;
+}>;
 
 /**
  * Check if a user can deposit from their current chain.
@@ -17072,8 +17074,8 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
   /**
    * Make unauthenticated requests to August public API endpoints.
    * Used for fetching vault metadata and public market data.
-   * @param relativeUrl Endpoint path relative to public API base URL
-   * @param options Request configuration including method and headers
+   * @param relativeUrl - Endpoint path relative to public API base URL
+   * @param options - Request configuration including method and headers
    * @returns Response object if successful
    * @throws Error with correlation ID if request fails
    */
@@ -17082,9 +17084,9 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
   /**
    * Make authenticated requests using Bearer token authentication.
    * Typically used for user-specific operations requiring OAuth tokens.
-   * @param bearerToken OAuth bearer token
-   * @param relativeUrl Endpoint path relative to base URL
-   * @param options Request configuration including method and headers
+   * @param bearerToken - OAuth bearer token
+   * @param relativeUrl - Endpoint path relative to base URL
+   * @param options - Request configuration including method and headers
    * @returns Response object if successful
    * @throws Error with correlation ID if request fails
    */
@@ -17093,9 +17095,9 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
   /**
    * Make authenticated requests to August backend services using API key.
    * Automatically logs errors with correlation IDs for debugging.
-   * @param apiKey August API key for authentication
-   * @param relativeUrl Endpoint path relative to base URL
-   * @param options Request configuration including method and headers
+   * @param apiKey - August API key for authentication
+   * @param relativeUrl - Endpoint path relative to base URL
+   * @param options - Request configuration including method and headers
    * @returns Response object if successful
    * @throws Error with correlation ID if request fails
    */
@@ -17117,8 +17119,8 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
 
   /**
    * Fetch the points leaderboard data.
-   * @param params Optional parameters for pagination and sorting
-   * @param options Request options including headers
+   * @param params - Optional parameters for pagination and sorting
+   * @param options - Request options including headers
    * @returns Leaderboard response data
    */
   export declare function fetchPointsLeaderboard({ params, options, }: {
@@ -17188,8 +17190,8 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
            /**
             * Fetch tokenized vault configurations from backend API.
             * Results are cached to reduce API calls. Optionally filter by specific vault address.
-            * @param pool Optional vault address to filter results
-            * @param headers Monitoring headers for request tracking
+            * @param pool - Optional vault address to filter results
+            * @param headers - Monitoring headers for request tracking
             * @returns Array of tokenized vault configurations
             */
            export declare function fetchTokenizedVault(pool: VaultAddress, headers?: IWSMonitorHeaders, loadSubaccounts?: boolean, loadSnapshots?: boolean): Promise<ITokenizedVault[]>;
@@ -17197,9 +17199,9 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
            /**
             * Fetch active loans for a specific vault from backend API.
             * Results are cached per vault and chain to reduce API calls.
-            * @param pool Vault address
-            * @param chainId Network chain ID
-            * @param headers Monitoring headers for request tracking
+            * @param pool - Vault address
+            * @param chainId - Network chain ID
+            * @param headers - Monitoring headers for request tracking
             * @returns Array of active loan objects
             */
            export declare function fetchTokenizedVaultLoans(pool: VaultAddress, chainId: number, headers?: IWSMonitorHeaders): Promise<IWSVaultLoan[]>;
@@ -17207,9 +17209,9 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
            /**
             * Fetch tokenized vault configurations from backend API.
             * Results are cached to reduce API calls. Optionally filter by specific vault address.
-            * @param pool Optional vault address to filter results
-            * @param headers Monitoring headers for request tracking
-            * @param loadSubaccounts Optional flag to load subaccounts and EOA operators (defaults to true on API)
+            * @param pool - Optional vault address to filter results
+            * @param headers - Monitoring headers for request tracking
+            * @param loadSubaccounts - Optional flag to load subaccounts and EOA operators (defaults to true on API)
             * @returns Array of tokenized vault configurations
             */
            export declare function fetchTokenizedVaults(pool?: IAddress, headers?: IWSMonitorHeaders, loadSubaccounts?: boolean, loadSnapshots?: boolean): Promise<ITokenizedVault[]>;
@@ -17217,9 +17219,9 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
            /**
             * Fetch subaccount loans for a specific tokenized vault (lending pool).
             * Retrieves all active subaccount loan data from the backend.
-            * @param pool Vault address
-            * @param chainId Network chain ID
-            * @param headers Monitoring headers for request tracking
+            * @param pool - Vault address
+            * @param chainId - Network chain ID
+            * @param headers - Monitoring headers for request tracking
             * @returns Array of active subaccount loan objects
             */
            export declare function fetchTokenizedVaultSubaccountLoans(pool: VaultAddress, chainId: number, headers?: IWSMonitorHeaders): Promise<IWSVaultLoan[]>;
@@ -17228,19 +17230,19 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
             * Fetch current USD price for a token symbol or vault LP token.
             * For vault LP tokens, calculates share price using totalAssets/totalSupply ratio.
             * Falls back to CoinGecko if primary source fails.
-            * @param symbol Token symbol or contract address
-            * @param provider Optional web3 provider for on-chain price calculations
-            * @param coinGeckoKey Optional CoinGecko API key for fallback pricing
-            * @param headers Monitoring headers for request tracking
+            * @param symbol - Token symbol or contract address
+            * @param provider - Optional web3 provider for on-chain price calculations
+            * @param coinGeckoKey - Optional CoinGecko API key for fallback pricing
+            * @param headers - Monitoring headers for request tracking
             * @returns Token price in USD
             */
-           export declare function fetchTokenPrice(symbol: string, provider?: IContractRunner, coinGeckoKey?: string, headers?: IWSMonitorHeaders): Promise<any>;
+           export declare function fetchTokenPrice(symbol: string, provider?: IContractRunner, coinGeckoKey?: string, headers?: IWSMonitorHeaders): Promise<number>;
 
            /**
             * Fetch token price by contract address and chain ID from August price server.
-            * @param address Token contract address
-            * @param chainId Network chain ID
-            * @param headers Optional monitoring headers for request tracking
+            * @param address - Token contract address
+            * @param chainId - Network chain ID
+            * @param headers - Optional monitoring headers for request tracking
             * @returns Token price in USD, or 0 if not found
             */
            export declare function fetchTokenPriceByAddress(address: VaultAddress, chainId: number, headers?: IWSMonitorHeaders): Promise<number>;
@@ -17256,9 +17258,9 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
            /**
             * Fetch historical timeseries data for a specific vault.
             * Returns TVL, APY, PnL, and share price data over time.
-            * @param vaultAddress Vault contract address
-            * @param nDays Number of days of historical data to fetch (default 30, min 1)
-            * @param headers Monitoring headers for request tracking
+            * @param vaultAddress - Vault contract address
+            * @param nDays - Number of days of historical data to fetch (default 30, min 1)
+            * @param headers - Monitoring headers for request tracking
             * @returns Historical timeseries data with date keys
             */
            export declare function fetchVaultHistoricalTimeseries(vaultAddress: IAddress, nDays?: number, headers?: IWSMonitorHeaders): Promise<IHistoricalTimeseriesResponse>;
@@ -17402,8 +17404,8 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
             * look up entries without worrying about EIP-55 checksum casing in either the
             * backend response or the caller's input.
             *
-            * @param options Standard vault options — `rpcUrl` should match `vault`'s chain.
-            * @param vault Optional vault address to scope the fetch to.
+            * @param options - Standard vault options — `rpcUrl` should match `vault`'s chain.
+            * @param vault - Optional vault address to scope the fetch to.
             * @returns Map of lowercased vault address → array of borrower-health-factor rows.
             */
            export declare function getHealthFactorOfBorrowersByVault({ options, vault, }: {
@@ -17505,10 +17507,10 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
 
            /**
             * Preview the amount of assets that would be received for redeeming shares (queued redemption).
-            * @param vault Vault contract address
-            * @param sharesAmount Amount of shares to redeem (human-readable, raw bigint, or string)
-            * @param options RPC configuration
-            * @returns The amount of assets as INormalizedNumber { normalized, raw }
+            * @param vault - Vault contract address
+            * @param sharesAmount - Amount of shares to redeem (human-readable, raw bigint, or string)
+            * @param options - RPC configuration
+            * @returns The amount of assets as an INormalizedNumber with `normalized` and `raw` fields
             */
            export declare function getPreviewRedemption({ vault, sharesAmount, options, }: {
                vault: IAddress;
@@ -17686,8 +17688,8 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
            /**
             * Fetch user points from the backend API endpoint.
             * This replaces client-side points calculation with server-side processing.
-            * @param userAddress User wallet address (EVM or Solana)
-            * @param options Request options including headers
+            * @param userAddress - User wallet address (EVM or Solana)
+            * @param options - Request options including headers
             * @returns Points data from the backend API
             */
            export declare function getUserPoints({ userAddress, options, }: {
@@ -17714,10 +17716,10 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
             * Fetch comprehensive vault data including on-chain state and backend metadata.
             * Routes to appropriate chain adapter (EVM v1/v2, Solana, or Stellar) based on vault version.
             * Optionally enriches with loan and allocation data.
-            * @param vault Vault contract address (EVM hex, Stellar C-address, or Solana program ID)
-            * @param loans Include active loan data
-            * @param allocations Include DeFi/CeFi allocation breakdowns
-            * @param options RPC and service configuration
+            * @param vault - Vault contract address (EVM hex, Stellar C-address, or Solana program ID)
+            * @param loans - Include active loan data
+            * @param allocations - Include DeFi/CeFi allocation breakdowns
+            * @param options - RPC and service configuration
             * @returns Complete vault object with optional enrichments
             */
            export declare function getVault({ vault, loans, allocations, options, loadSubaccounts, loadSnapshots, }: {
@@ -17741,8 +17743,8 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
             * Fetch comprehensive vault asset allocation breakdown.
             * Includes DeFi protocols (via DeBank), CeFi balances, OTC positions, and loans.
             * Categorizes exposures by borrowing, supplying, lending, and wallet holdings.
-            * @param vault Vault address
-            * @param options RPC configuration
+            * @param vault - Vault address
+            * @param options - RPC configuration
             * @returns Detailed allocation data with exposure categorization
             */
            export declare function getVaultAllocations(vault: IAddress, options: IVaultBaseOptions): Promise<IVaultAllocations>;
@@ -17756,8 +17758,8 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
             * These fields will be removed on 2026-01-01.
             * Use `liquidAPY30Day` and `liquidAPY7Day` fields instead.
             *
-            * @param vault Vault contract address
-            * @param options Request options including headers
+            * @param vault - Vault contract address
+            * @param options - Request options including headers
             * @returns Annualized APY data including liquidity APY
             */
            export declare function getVaultAnnualizedApy({ vault, options, }: {
@@ -17802,8 +17804,8 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
             * `health_factor: undefined` so callers can render an explicit empty state
             * rather than a perpetual loading skeleton.
             *
-            * @param vault Vault address to scope the fetch to.
-            * @param options Standard vault options — `rpcUrl` must point at `vault`'s chain.
+            * @param vault - Vault address to scope the fetch to.
+            * @param options - Standard vault options — `rpcUrl` must point at `vault`'s chain.
             * @returns Array of `IVaultBorrowerHealthFactor`, one entry per active loan.
             */
            export declare function getVaultBorrowerHealthFactor({ vault, options, }: {
@@ -17847,10 +17849,10 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
 
            /**
             * Fetch pending redemptions for a vault with liquidity analysis.
-            * @param vault Vault contract address
-            * @param pastDays Number of past days to include (default 7, min 1, max 30)
-            * @param futureDays Number of future days to include (default 14, min 1, max 30)
-            * @param options Request options including headers
+            * @param vault - Vault contract address
+            * @param pastDays - Number of past days to include (default 7, min 1, max 30)
+            * @param futureDays - Number of future days to include (default 14, min 1, max 30)
+            * @param options - Request options including headers
             * @returns Pending redemptions grouped by date with liquidity summary
             */
            export declare function getVaultPendingRedemptions({ vault, pastDays, futureDays, options, }: {
@@ -17864,8 +17866,8 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
             * Calculate PnL for a vault (vault-level, not user-specific).
             * Returns the vault's overall profit and loss across all users.
             *
-            * @param vault Vault contract address
-            * @param options RPC configuration and service options
+            * @param vault - Vault contract address
+            * @param options - RPC configuration and service options
             * @returns Vault PnL in USD and notional value
             */
            export declare function getVaultPnl({ vault, options, }: {
@@ -17892,9 +17894,18 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
            }): Promise<IVaultRedemptionHistoryItem[]>;
 
            /**
-            * Get the rewards for the vault
-            * @param tokenizedVault - The tokenized vault
-            * @returns The rewards
+            * Get the rewards for the vault.
+            *
+            * Builds the display-facing rewards summary from the raw tokenized-vault
+            * rewards array. In addition to the legacy `additionalPoints` string list, it
+            * emits `additionalPointsDetailed`, which pairs each label with its
+            * backend-provided `img_url`. Consumers (e.g. the Upshift app) resolve a
+            * reward's logo from this `imgUrl` first, falling back to a bundled asset only
+            * when it is absent — so a newly-added reward with a backend logo (e.g.
+            * "Cores") renders its icon without any client-side keyword mapping.
+            *
+            * @param tokenizedVault - The tokenized vault.
+            * @returns The rewards summary, including `additionalPointsDetailed`.
             */
            export declare function getVaultRewards(tokenizedVault: ITokenizedVault): {
                points: string;
@@ -17904,6 +17915,13 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                    value: number;
                }[];
                additionalPoints: string[];
+               additionalPointsDetailed: {
+                   id: string;
+                   label: string;
+                   text: string;
+                   imgUrl: string;
+                   multiplier: number;
+               }[];
            };
 
            /**
@@ -17913,8 +17931,8 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
 
            /**
             * Fetch summary data for a vault (name, type, chain, recent returns).
-            * @param vault Vault contract address
-            * @param options Request options including headers
+            * @param vault - Vault contract address
+            * @param options - Request options including headers
             * @returns Vault summary data
             */
            export declare function getVaultSummary({ vault, options, }: {
@@ -17941,9 +17959,9 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
             * 2. Fetch user's current assets (balanceOf * sharePrice via convertToAssets)
             * 3. Calculate PnL = assets withdrawn + current assets - assets deposited
             *
-            * @param vault Vault contract address
-            * @param wallet User wallet address
-            * @param options RPC configuration and service options
+            * @param vault - Vault contract address
+            * @param wallet - User wallet address
+            * @param options - RPC configuration and service options
             * @returns Lifetime PnL data in both native token and USD
             */
            export declare function getVaultUserLifetimePnl({ vault, wallet, options, }: {
@@ -17959,9 +17977,9 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
 
            /**
             * Fetch withdrawal summary and pending queue for a vault.
-            * @param vault Vault contract address
-            * @param chain Chain identifier (e.g., chain ID as string)
-            * @param options Request options including headers
+            * @param vault - Vault contract address
+            * @param chain - Chain identifier (e.g., chain ID as string)
+            * @param options - Request options including headers
             * @returns Withdrawal summary and pending queue
             */
            export declare function getVaultWithdrawals({ vault, chain, options, }: {
@@ -18000,13 +18018,13 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
             * - `'ready_to_claim'` — Claimable date has passed (within the lookback window) but no processed event found.
             * - `'pending'` — Claimable date is still in the future.
             *
-            * @param params - Query parameters
-            * @param params.vault - Vault address to query
-            * @param params.receiver - (Optional) Filter by receiver address
-            * @param params.lookbackBlocks - (Optional) On-chain log lookback window in blocks.
-            *   Defaults to a chain-specific value (e.g. 150,000 for Ethereum, 3,456,000 for Monad).
-            *   Increasing this scans more history but requires more RPC calls.
-            * @param params.options - Standard vault query options (provider, RPC URL, etc.)
+            * @param params - Query parameters:
+            *   - `vault` — Vault address to query.
+            *   - `receiver` — (Optional) Filter by receiver address.
+            *   - `lookbackBlocks` — (Optional) On-chain log lookback window in blocks.
+            *     Defaults to a chain-specific value (e.g. 150,000 for Ethereum, 3,456,000 for Monad).
+            *     Increasing this scans more history but requires more RPC calls.
+            *   - `options` — Standard vault query options (provider, RPC URL, etc.).
             * @returns Array of withdrawal requests with status and claimable dates
             *
             * @example
@@ -18051,8 +18069,8 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
            /**
             * Fetch the timestamp when yield was last realized for a vault.
             * Returns the assetsUpdatedOn timestamp from the vault contract.
-            * @param vault Vault contract address
-            * @param options RPC configuration
+            * @param vault - Vault contract address
+            * @param options - RPC configuration
             * @returns Timestamp (Unix timestamp in seconds) when yield was last realized
             */
            export declare function getYieldLastRealizedOn({ vault, options, }: {
@@ -18822,7 +18840,7 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
            export declare type IFetchAugustOptions = {
                method?: IFetchAugustMethods;
                headers?: Record<string, string>;
-               data?: any;
+               data?: unknown;
                server?: keyof typeof WEBSERVER_URL;
                /** Caller-supplied AbortSignal; combined with the default timeout. */
                signal?: AbortSignal;
@@ -18993,7 +19011,7 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
             * only refresh user identity and the cached API-key hash.
             *
             * @param config - Analytics configuration. Pass `tracesSampleRate` to
-            *   override the Phase 1/2 default of `1.0`.
+            *   override the default of `0.1`.
             * @param environment - Current environment (DEV or PROD).
             * @param walletAddress - Optional wallet address for user identification.
             * @param apiKey - Optional API key (hashed for identification).
@@ -19387,6 +19405,34 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
 
            export declare function isEarlierThanNow(startTime: Date): boolean;
 
+           /**
+            * Is this error a routine on-chain read revert rather than a real failure?
+            *
+            * Reading a function a contract doesn't implement, or an address that holds no
+            * (or incompatible) bytecode, reverts — a normal outcome when the SDK probes
+            * heterogeneous vaults. Matches ethers' `CALL_EXCEPTION` code and the
+            * message variants emitted by ethers and viem (`missing revert data`,
+            * `execution reverted`, `call revert exception`, and the bare `reverted`
+            * phrasing such as `the contract function "totalAssets" reverted`).
+            *
+            * Scope note: callers apply this on **read** paths only. A reverted *write*
+            * (a tx that failed on-chain) is a genuine error and is intentionally not
+            * demoted by this predicate's use in `write.actions`.
+            *
+            * @param error - The caught value, of unknown type.
+            * @returns `true` when the failure is an expected/benign contract revert.
+            *
+            * @example
+            * ```ts
+            * try { return await vaultContract.maxDepositAmount(); }
+            * catch (e) {
+            *   logChainError('maxDeposit', e, isExpectedRevertError(e));
+            *   throw e;
+            * }
+            * ```
+            */
+           export declare function isExpectedRevertError(error: unknown): boolean;
+
            /**
             * Whether a vault's receipt token is hub-only (no cross-chain withdraw).
             * The deposit UI must not offer a spoke share destination for these vaults.
@@ -19624,6 +19670,15 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                type: 'withdraw-request' | 'deposit' | 'withdraw-processed';
                decimals?: number;
                isInstant?: boolean;
+               /**
+                * Deposit asset token address, when known. Pre-deposit vaults accept
+                * multiple deposit assets with differing decimals (e.g. USDS at 18,
+                * USDC at 6), so `amount` cannot be normalized with the vault's own
+                * decimals alone — consumers (notably lifetime PnL) key off this address
+                * to resolve the correct per-asset decimals and USD price. Absent for
+                * single-asset vaults, where the vault `decimals` is correct.
+                */
+               assetIn?: IAddress;
            }
 
            export declare interface ISubgraphWithdraw extends ISubgraphBase {
@@ -19649,6 +19704,27 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                ownerAddr: IAddress;
            }
 
+           /**
+            * Is this error a wallet/user rejection of a transaction or signature request?
+            *
+            * Detects ethers v6's `ACTION_REJECTED` code, the EIP-1193 `4001`
+            * ("User rejected the request") code (top-level or nested), and the common
+            * human-readable phrasings as a fallback for providers that omit a code.
+            *
+            * @param error - The caught value, of unknown type.
+            * @returns `true` when the failure was the user declining in their wallet.
+            *
+            * @example
+            * ```ts
+            * try { await vault.deposit(...); }
+            * catch (e) {
+            *   if (isUserRejectionError(e)) return; // user cancelled — not an error
+            *   throw e;
+            * }
+            * ```
+            */
+           export declare function isUserRejectionError(error: unknown): boolean;
+
            /**
             * Signer Compatibility Helpers
             *
@@ -19726,6 +19802,15 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                 * in `[0, 10_000)` — 10_000 disables protection entirely and is rejected.
                 */
                slippageBps?: number;
+               /**
+                * Optional aggregator contract-method filter. When set, the aggregator is
+                * constrained to this single method (ParaSwap's `/prices`
+                * `includeContractMethods`), so the returned calldata's leading 4-byte
+                * selector is deterministic — required when the on-chain SwapRouter only
+                * authorizes one selector per router. When omitted, the aggregator picks the
+                * optimal method freely and the selector may vary between quotes.
+                */
+               contractMethod?: string;
                /** Aggregator partner key. Defaults to `'august'`. */
                partner?: string;
                /** Aggregator partner-fee receiver. Defaults to the August partner address. */
@@ -20389,6 +20474,27 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                transactionHash?: string;
            };
 
+           /**
+            * A single reward paired with its backend-provided logo.
+            *
+            * `id` is the reward's stable backend identifier ({@link ITokenizedVaultReward.id})
+            * and is the key consumers should join on — it is unique even when two rewards
+            * share a multiplier and text. `label` is display-only: it mirrors the
+            * corresponding {@link IVaultRewards.additionalPoints} string (and so carries a
+            * leading space when `multiplier === 1`, e.g. `" Cores"`), so it is fine to
+            * print but must not be treated as a unique key.
+            *
+            * `imgUrl` is `null` when the backend has no logo for the reward, in which
+            * case consumers fall back to a bundled asset.
+            */
+           export declare type IVaultRewardDetail = {
+               id: string;
+               label: string;
+               text: string;
+               imgUrl: string | null;
+               multiplier: number;
+           };
+
            export declare type IVaultRewards = {
                points: string;
                multiplier: number;
@@ -20397,6 +20503,12 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                    timestamp: number;
                }[];
                additionalPoints: string[];
+               /**
+                * Optional so this addition is non-breaking for external code that
+                * constructs an {@link IVaultRewards}. `getVaultRewards` always populates it;
+                * readers should treat an absent value as an empty list.
+                */
+               additionalPointsDetailed?: IVaultRewardDetail[];
            };
 
            export declare interface IVaultStrategist {
@@ -21009,6 +21121,26 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
 
            export declare function loanStateToReadable(loanState: number | bigint): "PREAPPROVED" | "FUNDING_REQUIRED" | "FUNDED" | "ACTIVE" | "CANCELLED" | "MATURED" | "CLOSED";
 
+           /**
+            * Log a caught chain error at the severity its category warrants, without
+            * swallowing it. When `isBenign` is `true` the failure is recorded as a `warn`
+            * (a Sentry breadcrumb that rides along with the next real issue, not a billed
+            * standalone issue); otherwise it is logged at `error` (a Sentry issue). The
+            * caller is still responsible for re-throwing — this only routes telemetry.
+            *
+            * Pass the benign decision explicitly (via {@link isUserRejectionError} or
+            * {@link isExpectedRevertError}) so the call site documents *why* the demotion
+            * is safe and each path opts into only the category that applies to it.
+            *
+            * @param tag - Low-cardinality call-site label (e.g. `'deposit'`), used as the
+            *   Sentry breadcrumb/issue grouping key.
+            * @param error - The caught value, of unknown type.
+            * @param isBenign - `true` to demote to `warn`; `false` to keep at `error`.
+            * @param context - Optional structured context attached to the log entry. It is
+            *   sanitized by the logger before transport.
+            */
+           export declare function logChainError(tag: string, error: unknown, isBenign: boolean, context?: Record<string, unknown>): void;
+
            export declare const Logger: {
                setLogger: typeof setLogger;
                setStructuredLogger: typeof setStructuredLogger;
@@ -21145,10 +21277,10 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
            /**
             * Arrays
             */
-           export declare function orderObjArrByDate(objectArray: any[], options?: {
+           export declare function orderObjArrByDate<T extends Record<string, unknown>>(objectArray: T[], options?: {
                key?: string;
                order?: 'asc' | 'desc';
-           }): any[];
+           }): T[];
 
            /**
             * 32-byte origin codes registered on the `SwapRouter` via `addOrigin`.
@@ -21276,9 +21408,9 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
             * Execute multiple promises with retry logic and allow partial failures.
             * Unlike Promise.all, continues execution if some promises fail.
             * Failed promises return null to maintain array index alignment.
-            * @param promises Array of promises to execute
-            * @param maxRetries Maximum retry attempts per promise
-            * @param baseDelay Initial delay for exponential backoff
+            * @param promises - Array of promises to execute
+            * @param maxRetries - Maximum retry attempts per promise
+            * @param baseDelay - Initial delay for exponential backoff
             * @returns Array of results with null for failed promises
             */
            export declare function promiseSettle<T>(promises: Promise<T>[], maxRetries?: number, baseDelay?: number): Promise<T[]>;
@@ -21330,24 +21462,24 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
             * expires: {expiry}
             * ```
             *
-            * @param userAddress EVM wallet address being registered. Must match the
+            * @param userAddress - EVM wallet address being registered. Must match the
             *   signer that produced `signature`. Lowercased before being embedded in
             *   the canonical message.
-            * @param referrerAddress Optional EVM address that referred this user.
+            * @param referrerAddress - Optional EVM address that referred this user.
             *   Lowercased when embedded; the literal string `"none"` is used when
             *   absent. Tampering with this field after signing produces 401.
-            * @param chainId Chain on which the wallet signed. For smart-contract wallets
+            * @param chainId - Chain on which the wallet signed. For smart-contract wallets
             *   (Safe etc.) this is the chain whose RPC the backend will use to run the
             *   EIP-1271 `isValidSignature` check; for EOAs it still pins the signature
             *   to a chain so it can't be replayed cross-chain. Must be one of the chains
             *   Upshift supports (see backend `SUPPORTED_REGISTRATION_CHAINS`).
-            * @param signature `0x`-prefixed hex of the personal_sign signature over
+            * @param signature - `0x`-prefixed hex of the personal_sign signature over
             *   the canonical message. Single-use: replays within ~10 min are rejected.
-            * @param nonce Caller-generated random string (8–128 chars). Pair with
+            * @param nonce - Caller-generated random string (8–128 chars). Pair with
             *   `userAddress` to form the single-use key in the backend's nonce store.
-            * @param expiry Unix timestamp (seconds). Must be in the future and within
+            * @param expiry - Unix timestamp (seconds). Must be in the future and within
             *   the backend's TTL window (currently 10 min).
-            * @param options Request options (headers).
+            * @param options - Request options (headers).
             * @returns Raw `Response` from the backend. 200 on success, 401 for
             *   expired / replayed / mismatched-signer / tampered-referrer, 422 for an
             *   unsupported `chainId`.
@@ -21417,12 +21549,13 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
             export declare const REWARD_DISTRIBUTOR_ADDRESS: (chainId: number) => string[];
 
             /**
-             * @function round formats any type number value to a standard
+             * Formats any numeric value (number, string, or bigint) to a standardized string.
              *
-             * @param value amount to be formatted
-             * @param options.showing amount of decimals to cut off at
-             * @param options.usd if wanting to display USD value
-             * @param options.decimals if passing type bigint, how many decimals to parse to
+             * @param value - amount to be formatted
+             * @param options - formatting options:
+             *   `showing` is the number of decimals to cut off at (or `'all'`);
+             *   `usd` toggles USD-value display;
+             *   `decimals` is how many decimals to parse to when `value` is a bigint.
              *
              * @returns standardized string type value
              */
@@ -22275,7 +22408,7 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
              * call with no arguments) to clear the override and fall back to the
              * compiled-in `REQUEST_TIMEOUT_MS`.
              *
-             * @param ms Positive number of milliseconds to wait before aborting, or
+             * @param ms - Positive number of milliseconds to wait before aborting, or
              *   `null` to clear.
              */
             export declare function setSdkRequestTimeout(ms?: number | null): void;
@@ -22597,1109 +22730,1187 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                  */
                 vaultRedeem(params: Omit<IStellarRedeemParams, 'network'>): Promise<string>;
                 /**
-                 * Submit a signed Soroban transaction and poll until confirmed.
-                 * @returns Transaction hash on success
-                 */
-                submitTransaction(signedXdr: string): Promise<string>;
-                /**
-                 * Get user's vault share balance.
+                 * Submit a signed Soroban transaction and poll until the network confirms it.
                  *
-                 * @returns The position `{ shares, decimals, decimalsFromFallback }`, or null
-                 * if the balance read fails. When `decimalsFromFallback` is `true` the
-                 * `decimals()` read failed and `decimals` is the fallback (7) — callers sizing
-                 * a redeem MUST refuse rather than trust it (see AUGUST-6381).
-                 */
-                getUserPosition(vaultAddress: string, walletAddress: string): Promise<IStellarUserPosition | null>;
-                /**
-                 * Preview how many vault shares a deposit amount would yield.
-                 * @param vaultAddress  Stellar contract ID (C… address)
-                 * @param rawAmount     Deposit amount in the deposit token's smallest unit
-                 * @returns Raw share amount as a string, or null if query fails.
-                 */
-                convertToShares(vaultAddress: string, rawAmount: string): Promise<string | null>;
-            }
-
-            declare namespace StellarConstants {
-                export {
-                    STELLAR_CHAIN_ID,
-                    STELLAR_CHAIN,
-                    SOROBAN_RPC_URLS,
-                    NETWORK_PASSPHRASES,
-                    STELLAR_FALLBACK_DECIMALS,
-                    TX_TIMEOUT_SECONDS,
-                    QUERY_TIMEOUT_SECONDS,
-                    MAX_FEE_STROOPS,
-                    POLL_INTERVAL_MS,
-                    POLL_INTERVAL_MAX_MS,
-                    POLL_INTERVAL_BACKOFF,
-                    MAX_POLL_ATTEMPTS
-                }
-            }
-
-            declare namespace StellarGetters {
-                export {
-                    getStellarVault,
-                    getStellarUserPosition,
-                    convertToShares
-                }
-            }
-
-            declare namespace StellarSubmit {
-                export {
-                    submitStellarTransaction
-                }
-            }
-
-            /**
-             * @deprecated
-             * Replaced by SUBGRAPH_VAULT_URLS which are subgraphs deployed on Goldsky.
-             */
-            export declare const SUBGRAPH_POOL_URLS: (apiKey: string, chainId?: number, pool?: IAddress) => {
-                1: string;
-                8453: string;
-                43114: string;
-                42161: string;
-                56: string;
-            } | {
-                999: string;
-            };
-
-            /**
-             * Subgraph URLs
-             * @deprecated use getVaultMetadata to fetch subgraph URLs from the backend
-             */
-            export declare const SUBGRAPH_VAULT_URLS: Record<VaultSymbols, string>;
-
-            /**
-             * Submit a signed Soroban transaction and poll until confirmed.
-             *
-             * @param signedXdr Base64-encoded XDR of the signed transaction
-             * @param network Stellar network name
-             * @returns Transaction hash on success
-             */
-            declare function submitStellarTransaction(signedXdr: string, network: IStellarNetwork): Promise<string>;
-
-            /**
-             * Sui Adapter for August SDK
-             *
-             * @example
-             * To access the Sui adapter instance
-             * ```
-             * const sdk = new AugustSDK()
-             * sdk.sui.getEmberVaults()
-             * ```
-             */
-            declare class SuiAdapter {
-                private _apiBaseUrl;
-                private _chainId;
-                constructor(apiBaseUrl?: string, chainId?: number);
-                get apiBaseUrl(): string;
-                get chainId(): number;
-                getEmberVaults(options?: IFetchEmberVaultsOptions): Promise<IEmberVault[]>;
-                getEmberTVL(limit?: number): Promise<number>;
-                convertFromE9(value: string | number): number;
-                calculateUtilization(current: string | number, maximum: string | number): number;
-                isSuiAddress(address: string): boolean;
-                isSuiVault(chainId: number): boolean;
-                transformEmberVaultToIVault(emberVault: IEmberVault): IVault;
-                transformEmberVaultsToIVaults(emberVaults: IEmberVault[]): IVault[];
-            }
-
-            /**
-             * Address of the `SwapRouter` periphery contract on each supported chain.
-             *
-             * Missing keys mean no SwapRouter is deployed on that chain — callers
-             * should fall back to legacy adapter paths.
-             *
-             * @see {@link getSwapRouterAddress} for the typed lookup helper.
-             */
-            export declare const SWAP_ROUTER_ADDRESSES: Readonly<Record<number, IAddress>>;
-
-            /**
-             * Maximum number of swap legs the contract accepts in a single
-             * `swapAndDeposit` call. Mirrors the on-chain `MAX_SWAPS` constant; reading
-             * the on-chain value at call time would add an RPC for no gain.
-             *
-             * Kept here so the SDK can reject oversize inputs at the boundary rather
-             * than wait for the on-chain `TooManySwaps` revert.
-             */
-            export declare const SWAP_ROUTER_MAX_SWAPS = 9;
-
-            /**
-             * Wrapped-native ERC-20 per chain that has a SwapRouter deployment. Mirrors
-             * the on-chain `wrappedNativeTokenAddress()` view to avoid an extra RPC on
-             * every dispatch. Used to validate that native-token deposits target a
-             * vault whose reference asset is the wrapped native — the only configuration
-             * the contract's `depositNativeToken` / `swapAndDepositNativeToken` accept.
-             */
-            export declare const SWAP_ROUTER_WRAPPED_NATIVE: Readonly<Record<number, IAddress>>;
-
-            /**
-             * Swap one or more whitelisted ERC-20s into a vault's reference asset via
-             * the on-chain SwapRouter, then deposit the proceeds into the vault.
-             *
-             * Approval is sent automatically when the caller's allowance on each
-             * `swaps[i].tokenIn` against the SwapRouter is below `amountIn`.
-             *
-             * @param signer - ethers `Signer` or `Wallet` with the EOA that holds the input tokens.
-             * @param options - {@link ISwapAndDepositOptions}.
-             * @returns The transaction hash of the `swapAndDeposit` call.
-             *
-             * @throws {@link AugustValidationError} for unsupported chains, invalid
-                 * addresses, empty/oversized swap arrays.
-                 * @throws {@link AugustSDKError} on unrecoverable contract or RPC failure.
-                     *
-                     * @example
-                     * ```ts
-                     * const quote = await fetchSwapQuote({
-                     *   chainId: 1,
-                     *   srcToken: WBTC,
-                     *   srcDecimals: 8,
-                     *   destToken: USDC,
-                     *   destDecimals: 6,
-                     *   amount: 100_000_000n,
-                     *   receiver: SWAP_ROUTER_ADDRESSES[1]!,
-                     * });
-                     * const hash = await swapAndDeposit(signer, {
-                     *   chainId: 1,
-                     *   vault: '0x8AcA0841993ef4C87244d519166e767f49362C21',
-                     *   receiver: wallet,
-                     *   swaps: [{
-                     *     tokenIn: WBTC,
-                     *     tokenOut: USDC,
-                     *     amountIn: 100_000_000n,
-                     *     minAmountOut: quote.minAmountOut,
-                     *     router: quote.router,
-                     *     payload: quote.payload,
-                     *   }],
-                     * });
-                     * ```
-                     */
-                 export declare function swapAndDeposit(signer: Signer | Wallet, options: ISwapAndDepositOptions): Promise<string>;
-
-                 /**
-                  * Numeric vault-type tag used by the on-chain `SwapRouter` to branch between
-                  * the ERC-4626 (`deposit(uint256, address)`) and multi-asset
-                  * (`deposit(address, uint256, address)`) deposit interfaces.
-                  *
-                  * Values match the contract's `VAULT_TYPE_ERC4626` / `VAULT_TYPE_TOKENIZED_VAULT_V2`
-                  * constants exactly. Set by an admin per-vault via `enableVault` and looked
-                  * up via `vaultInfo(vaultAddr).vaultType`. SDK callers normally do not pass
-                  * this — the router resolves it internally.
-                  */
-                 export declare enum SwapRouterVaultType {
-                     ERC4626 = 1,
-                     TokenizedVaultV2 = 2
-                 }
-
-                 /**
-                  * Table of Contents
-                  * - Formatters
-                  * - Datetime
-                  * - Arrays
-                  * - Caching
-                  */
-                 export declare function toNormalizedBn(value: string | bigint | number, decimals?: number | bigint): INormalizedNumber;
-
-                 /**
-                  * Formatters
-                  */
-                 export declare function toTitleCase(str: string, type?: 'camel'): string;
-
-                 /**
-                  * Track API response times and status.
-                  *
-                  * @param endpoint - The API endpoint called
-                  * @param method - HTTP method used
-                  * @param startTime - Start timestamp from performance.now()
-                  * @param status - HTTP response status code (0 for network errors)
-                  * @param server - Server identifier (production, staging, etc.)
-                  */
-                 export declare function trackApiCall(endpoint: string, method: string, startTime: number, status: number, server: string): void;
-
-                 /**
-                  * Track chain/network switches for usage distribution analysis.
-                  *
-                  * @param chainId - The chain ID being switched to
-                  */
-                 export declare function trackNetworkSwitch(chainId: number): void;
-
-                 export declare function truncate(s: string, amount?: number): string;
-
-                 /* Excluded from this release type: tryRecoverTxHash */
-
-                 /**
-                  * Vault addresses to exclude from `getTotalDeposited` TVL aggregation.
-                  * Addresses are lowercased so EVM, Solana, Sui and Stellar vaults can be
-                  * checked uniformly (don't wrap them with `getAddress` — non-EVM addresses
-                  * would throw). Add an address here to drop its `latest_reported_tvl` from
-                  * the headline number — e.g. closed pre-deposit vaults, test vaults, or
-                  * migrated v1 pools that are double-counted by a v2 successor.
-                  */
-                 export declare const TVL_EXCLUDED_VAULTS: ReadonlySet<string>;
-
-                 /**
-                  * Validity window for a submitted Soroban invocation (seconds).
-                  *
-                  * This becomes the transaction's `maxTime`. Validators reject a tx whose
-                  * `maxTime` has passed (`txTOO_LATE`), so the window must outlast the slowest
-                  * realistic sign-then-submit path: hardware wallets, careful manual review,
-                  * and institutional approval flows (e.g. Fordefi) that don't sign instantly.
-                  * 10 minutes comfortably covers those while staying well inside the Soroban
-                  * footprint/ledger-entry TTL, so the simulated footprint can't go stale first.
-                  *
-                  * The window is anchored to the *network* clock (see `getNetworkCloseTime` in
-                  * soroban.ts), not the signer's `Date.now()`, so a skewed device clock can't
-                  * make the deadline expire early.
-                  */
-                 declare const TX_TIMEOUT_SECONDS = 600;
-
-                 export declare type TypedContract<TAbi extends Abi> = Omit<BaseContract, 'getFunction' | 'getEvent'> & {
-                     [Method in ExtractAbiFunctionNames<TAbi>]: TypedContractFunction<TAbi, Method>;
-                 } & {
-                     /**
-                      * Return the function for a given name. This is useful when a contract
-                      * method name conflicts with a JavaScript name such as ``prototype`` or
-                      * when using a Contract programatically.
-                      */
-                     getFunction<T extends ExtractAbiFunctionNames<TAbi>>(key: T | TypedFragment<TAbi, T>): TypedContractFunction<TAbi, T>;
-                     /**
-                      * Return the event for a given name. This is useful when a contract
-                      * event name conflicts with a JavaScript name such as ``prototype`` or
-                      * when using a Contract programatically.
-                      */
-                     getEvent<T extends ExtractAbiEventNames<TAbi>>(key: T | EventFragment): TypedContractEvent<TAbi, T>;
-                     /**
-                      * All the Events available on this contract.
-                      */
-                     filters: {
-                         [EventName in ExtractAbiEventNames<TAbi>]: TypedContractEvent<TAbi, EventName>;
-                     };
-                 };
-
-                 export declare interface TypedContractEvent<TAbi extends Abi, TEventName extends string, TEvent extends ExtractAbiEvents<TAbi> = ExtractAbiEvent<TAbi, TEventName>, TEventArgs extends readonly unknown[] = AsArray<Partial<AbiParametersToPrimitiveTypes<TEvent['inputs']>>>> {
-                     (...args: [...TEventArgs]): DeferredTopicFilter;
-                     /**
-                      * The name of the Contract event.
-                      */
-                     name: TEventName;
-                     /**
-                      * The fragment of the Contract event. This will throw on ambiguous
-                      * method names.
-                      */
-                     fragment: EventFragment;
-                     /**
-                      * Returns the fragment constrained by %%args%%. This can be used to
-                      * resolve ambiguous event names.
-                      */
-                     getFragment(...args: [...TEventArgs]): EventFragment;
-                 }
-
-                 export declare interface TypedContractFunction<TAbi extends Abi, TFunctionName extends string, TFunction extends ExtractAbiFunctions<TAbi> = ExtractAbiFunction<TAbi, TFunctionName>, TInputArgs extends readonly unknown[] = AsArray<AbiParametersToPrimitiveTypes<TFunction['inputs']>>, TResult = TypedContractFunctionResult<TAbi, TFunctionName>, TFragment = TypedFragment<TAbi, TFunctionName>> {
-                     (...args: [...TInputArgs, overrides?: Overrides]): Promise<TFunction['stateMutability'] extends 'view' | 'pure' ? TResult : ContractTransactionResponse>;
-                     /**
-                      * The name of the Contract method.
-                      */
-                     name: TFunctionName;
-                     /**
-                      * The fragment of the Contract method. This will throw on ambiguous
-                      * method names.
-                      */
-                     fragment: TFragment;
-                     /**
-                      * Returns the fragment constrained by %%args%%. This can be used to
-                      * resolve ambiguous method names.
-                      */
-                     getFragment(...args: [...TInputArgs]): TFragment;
-                     /**
-                      * Returns a populated transaction that can be used to perform the
-                      * contract method with %%args%%.
-                      */
-                     populateTransaction(...args: [...TInputArgs, overrides?: Overrides]): Promise<ContractTransaction>;
+                 * Submits on the network this adapter was constructed with, so `signedXdr`
+                 * must be signed for that same network.
+                 *
+                 * @param signedXdr - Base64-encoded XDR of the signed transaction.
+                 * @returns The transaction hash once the network confirms it as successful.
+                 * @throws {@link AugustTimeoutError} when the transaction is not confirmed
+                     *   within the poll budget (`MAX_POLL_ATTEMPTS`).
+                     * @throws {@link AugustSDKError} when the RPC rejects the submission or the
+                         *   transaction confirms as failed. Its `context` carries `{ network, status }`
+                         *   plus, when the result XDR decodes, a `resultCode` string holding the
+                         *   transaction-level reason (e.g. `"txBadSeq"`, `"txTooLate"`); `resultCode`
+                         *   is `undefined` when the code cannot be decoded.
+                         * @example
+                         * ```ts
+                         * try {
+                         *   const hash = await adapter.submitTransaction(signedXdr);
+                         * } catch (err) {
+                         *   if (err instanceof AugustSDKError && err.context?.resultCode === 'txBadSeq') {
+                         *     // stale sequence number — rebuild the transaction and resubmit
+                         *   }
+                         * }
+                         * ```
+                         */
+                     submitTransaction(signedXdr: string): Promise<string>;
                      /**
-                      * Call the contract method with %%args%% and return the value.
+                      * Get user's vault share balance.
                       *
-                      * If the return value is a single type, it will be dereferenced and
-                      * returned directly, otherwise the full Result will be returned.
+                      * @returns The position `{ shares, decimals, decimalsFromFallback }`, or null
+                      * if the balance read fails. When `decimalsFromFallback` is `true` the
+                      * `decimals()` read failed and `decimals` is the fallback (7) — callers sizing
+                      * a redeem MUST refuse rather than trust it (see AUGUST-6381).
                       */
-                     staticCall(...args: [...TInputArgs, overrides?: Overrides]): Promise<TResult>;
+                     getUserPosition(vaultAddress: string, walletAddress: string): Promise<IStellarUserPosition | null>;
                      /**
-                      * Send a transaction for the contract method with %%args%%.
+                      * Preview how many vault shares a deposit amount would yield.
+                      * @param vaultAddress  Stellar contract ID (C… address)
+                      * @param rawAmount     Deposit amount in the deposit token's smallest unit
+                      * @returns Raw share amount as a string, or null if query fails.
                       */
-                     send(...args: [...TInputArgs, overrides?: Overrides]): Promise<ContractTransactionResponse>;
-                     /**
-                      * Estimate the gas to send the contract method with %%args%%.
-                      */
-                     estimateGas(...args: [...TInputArgs, overrides?: Overrides]): Promise<bigint>;
-                     /**
-                      * Call the contract method with %%args%% and return the Result
-                      * without any dereferencing.
-                      */
-                     staticCallResult(...args: [...TInputArgs, overrides?: Overrides]): Promise<Result>;
+                     convertToShares(vaultAddress: string, rawAmount: string): Promise<string | null>;
                  }
 
-                 export declare type TypedContractFunctionResult<TAbi extends Abi, TFunctionName extends string, TOutputArgs = AbiParametersToPrimitiveTypes<ExtractAbiFunction<TAbi, TFunctionName>['outputs']>> = TOutputArgs extends readonly [] ? void : TOutputArgs extends readonly [infer Arg] ? Arg : TOutputArgs;
-
-                 export declare type TypedFragment<TAbi extends Abi, TFunctionName extends string, TFunction extends ExtractAbiFunctions<TAbi> = ExtractAbiFunction<TAbi, TFunctionName>> = Omit<FunctionFragment, 'inputs' | 'outputs' | 'stateMutability' | 'name' | 'type'> & {
-                     name: TFunction['name'];
-                     type: TFunction['type'];
-                     inputs: TFunction['inputs'];
-                     outputs: TFunction['outputs'];
-                     stateMutability: TFunction['stateMutability'];
-                 };
-
-                 export declare function unixToDate(epoch: number): Date;
-
-                 /**
-                  * Update the current user identity in Sentry.
-                  * Called when wallet address changes.
-                  *
-                  * @param walletAddress - New wallet address (or undefined to clear)
-                  * @param environment - Current environment
-                  */
-                 export declare function updateUser(walletAddress?: string, environment?: IEnv): void;
-
-                 /* Excluded from this release type: validateAmountPrecision */
-
-                 /**
-                  * Vault adapter configurations mapping vault addresses to their adapter settings
-                  */
-                 export declare const VAULT_ADAPTER_CONFIGS: Record<IAddress, IVaultAdapterConfig>;
-
-                 export declare const VAULT_ADDRESSES: Record<"musd" | "predlp" | "sentusd" | "pregrid" | "repouscc" | "earnxrp" | "tivkbtc" | "tivusdt0" | "supermon" | "earnmon" | "k3europ" | "wmon/ausd" | "wbtc/ausd" | "earnausd_monad" | "sausd" | "farmbold" | "sentuscc" | "sentbtc" | "svusdc" | "apusdc" | "testwethtsa" | "tacusr" | "upinjusdt" | "tac-teth" | "upausd" | "taccbbtc" | "xupusdc" | "uptbtc" | "gteth" | "ageth" | "upusdc" | "hgeth" | "upssylva" | "hbbtc" | "hbhype" | "upazt" | "susdt" | "upedge" | "coreusdc" | "upcusdo" | "shifteth" | "upsusde" | "uplbtc" | "upavax" | "tacrseth" | "earnausd" | "alpineusdcflagship" | "alpinecoinshiftusdc" | "upbtc" | "upstrbtc" | "maxiusr" | "upgammausdc" | "xhype" | "wildusd" | "alpinebtc" | "prenusd" | "upyzusd" | "upnusd" | "hlpe" | "nemo eth yield", `0x${string}`>;
-
-                 /**
-                  * Hardcoded subaccount addresses for specific vaults allocations
-                  */
-                 export declare const VAULT_ALLOCATION_SUBACCOUNTS: {
-                     AgoraAUSD: {
-                         address: IAddress;
-                         subaccount: IAddress;
-                         useDebank: boolean;
-                     };
-                     earnAUSD: {
-                         address: IAddress;
-                         subaccount: IAddress;
-                         useDebank: boolean;
-                     };
-                 };
-
-                 /**
-                  * The functions to call on the vault contract
-                  * @returns The functions to call
-                  */
-                 export declare const VAULT_FUNCTIONS_V1: IPoolFunctions[];
-
-                 export declare const VAULT_FUNCTIONS_V2: IPoolFunctions[];
-
-                 export declare const VAULT_FUNCTIONS_V2_RECEIPT: IPoolFunctions[];
-
-                 export declare const VAULT_FUNCTIONS_V2_WHITELISTED_ASSETS: IPoolFunctions[];
-
-                 /**
-                  * Vault Symbols Mapping
-                  * @deprecated use getVaultMetadata to fetch vault symbols from the backend
-                  */
-                 export declare const VAULT_SYMBOLS: Record<IAddress, string>;
-
-                 /**
-                  * Vault Symbols Reverse Mapping
-                  * @deprecated use getVaultMetadata to fetch vault symbols from the backend
-                  */
-                 export declare const VAULT_SYMBOLS_REVERSE: Record<VaultSymbols, IAddress>;
-
-                 /**
-                  * Address type for vault contracts across all supported chains.
-                  * EVM vaults use `0x`-prefixed hex addresses, Solana vaults use base58,
-                  * and Stellar vaults use 56-character base32 addresses (G/C prefix).
-                  *
-                  * Use this instead of `IAddress` when the address may belong to any chain.
-                  */
-                 export declare type VaultAddress = string;
-
-                 /**
-                  * allowance checks user's current allowance per pool
-                  * @param signer - signer / provider object
-                  * @param options - object including pool contract address, user wallet address
-                  * @returns normalized number object of the user's current allowance
-                  */
-                 export declare function vaultAllowance(signer: IContractRunner, options: IContractWriteOptions): Promise<INormalizedNumber>;
-
-                 /**
-                  * Approve a vault (or the appropriate adapter wrapper) to spend a token
-                  * ahead of a separate deposit call. Spender routing mirrors
-                  * {@link vaultDeposit} (multi-asset → vault, adapter → wrapper, standard →
-                  * vault). Returns `undefined` when the existing allowance already covers
-                  * `amount` **or** when the deposit asset is native.
-                  *
-                  * @returns Transaction hash when an approval was sent, `undefined` when
-                  *   the existing allowance already covers `amount` or the deposit asset is
-                  *   native (no ERC-20 allowance applies). Use {@link approve} for a
-                  *   discriminated `ApproveResult` if you need to tell those two cases apart.
-                  * @throws AugustValidationError on invalid wallet/target/amount.
-                  *
-                  * @example
-                  * ```ts
-                  * const hash = await augustSdk.evm.vaultApprove({
-                  *   target: '0x...',         // vault contract address
-                  *   wallet: walletAddress,
-                  *   amount: '100',           // 100 of the deposit token (UI units)
-                  *   wait: true,              // wait for the approval to confirm
-                  * });
-                  * if (hash) console.log('approve tx', hash);
-                  * // hash === undefined means the on-chain allowance already covers the
-                  * // amount, or the deposit asset is native (msg.value, no allowance).
-                  * ```
-                  */
-                 export declare function vaultApprove(signer: Signer | Wallet, options: IContractWriteOptions): Promise<string | undefined>;
-
-                 /**
-                  * Deposit underlying token into the specified vault. Auto-routes to the
-                  * correct contract path (single-asset ERC-4626, EVM-2 multi-asset,
-                  * Paraswap adapter, native-token wrapper, depositWithPermit) based on the
-                  * vault version and `depositAsset`.
-                  *
-                  * Amounts are encoded against the **deposit token's** decimals, not the
-                  * vault's share decimals. The SDK reads the appropriate decimals via the
-                  * vault metadata and the asset's ERC-20.
-                  *
-                  * Approval is handled automatically: if the existing allowance doesn't
-                  * cover `amount`, an `approve` is sent and **always waited for** (regardless
-                  * of the caller's `wait` flag) so the deposit tx can't be re-ordered ahead
-                  * of the approval on Monad-style RPCs.
-                  *
-                  * @param signer ethers Signer / Wallet (or viem WalletClient via {@link setSigner})
-                  * @param options Vault address, wallet, amount, optional `depositAsset` for
-                  *   adapter routes, optional `wait` to wait for the deposit receipt.
-                  * @returns Deposit transaction hash.
-                  * @throws AugustValidationError on invalid wallet/target/amount or missing
-                  *   adapter config when `depositAsset` differs from the vault underlying.
-                  * @throws AugustSDKError when the deposit submission or on-chain call fails.
-                  *
-                  * @example
-                  * ```ts
-                  * const hash = await augustSdk.evm.vaultDeposit({
-                  *   target: '0xE9B725010A9E419412ed67d0fA5f3A5f40159D32', // vault
-                  *   wallet: walletAddress,
-                  *   amount: '100',         // 100 USDC (UI units)
-                  *   wait: true,            // wait for the deposit receipt
-                  * });
-                  * ```
-                  *
-                  * @example Adapter deposit (different deposit asset than the vault's underlying)
-                  * ```ts
-                  * await augustSdk.evm.vaultDeposit({
-                  *   target: vaultAddress,
-                  *   wallet: walletAddress,
-                  *   amount: '0.5',
-                  *   depositAsset: WETH_ADDRESS,   // swap WETH -> vault underlying via the adapter
-                  *   chainId: 1,
-                  * });
-                  * ```
-                  */
-                 export declare function vaultDeposit(signer: Signer | Wallet, options: IContractWriteOptions): Promise<string>;
-
-                 /**
-                  * Check if vault has adapter support
-                  */
-                 export declare function vaultHasAdapter(vaultAddress: IAddress): boolean;
-
-                 declare const vaultIdl: {
-                     address: string;
-                     metadata: {
-                         name: string;
-                         version: string;
-                         spec: string;
-                         description: string;
-                     };
-                     instructions: ({
-                         name: string;
-                         docs: string[];
-                         discriminator: number[];
-                         accounts: ({
-                             name: string;
-                             writable: boolean;
-                             pda: {
-                                 seeds: {
-                                     kind: string;
-                                     value: number[];
-                                 }[];
-                             };
-                             signer?: undefined;
-                             address?: undefined;
-                         } | {
-                             name: string;
-                             signer: boolean;
-                             writable?: undefined;
-                             pda?: undefined;
-                             address?: undefined;
-                         } | {
-                             name: string;
-                             writable: boolean;
-                             pda?: undefined;
-                             signer?: undefined;
-                             address?: undefined;
-                         } | {
-                             name: string;
-                             address: string;
-                             writable?: undefined;
-                             pda?: undefined;
-                             signer?: undefined;
-                         })[];
-                         args: any[];
-                     } | {
-                         name: string;
-                         docs: string[];
-                         discriminator: number[];
-                         accounts: ({
-                             name: string;
-                             writable: boolean;
-                             signer: boolean;
-                             docs?: undefined;
-                             pda?: undefined;
-                             address?: undefined;
-                         } | {
-                             name: string;
-                             docs: string[];
-                             writable: boolean;
-                             signer: boolean;
-                             pda?: undefined;
-                             address?: undefined;
-                         } | {
-                             name: string;
-                             docs: string[];
-                             writable: boolean;
-                             pda: {
-                                 seeds: {
-                                     kind: string;
-                                     value: number[];
-                                 }[];
-                                 program?: undefined;
-                             };
-                             signer?: undefined;
-                             address?: undefined;
-                         } | {
-                             name: string;
-                             docs: string[];
-                             writable: boolean;
-                             signer?: undefined;
-                             pda?: undefined;
-                             address?: undefined;
-                         } | {
-                             name: string;
-                             writable: boolean;
-                             pda: {
-                                 seeds: ({
-                                     kind: string;
-                                     value: number[];
-                                     path?: undefined;
-                                 } | {
-                                     kind: string;
-                                     path: string;
-                                     value?: undefined;
-                                 })[];
-                                 program: {
-                                     kind: string;
-                                     value: number[];
-                                 };
-                             };
-                             signer?: undefined;
-                             docs?: undefined;
-                             address?: undefined;
-                         } | {
-                             name: string;
-                             address: string;
-                             writable?: undefined;
-                             signer?: undefined;
-                             docs?: undefined;
-                             pda?: undefined;
-                         })[];
-                         args: {
-                             name: string;
-                             type: string;
-                         }[];
-                     } | {
-                         name: string;
-                         docs: string[];
-                         discriminator: number[];
-                         accounts: ({
-                             name: string;
-                             writable: boolean;
-                             pda: {
-                                 seeds: ({
-                                     kind: string;
-                                     value: number[];
-                                     path?: undefined;
-                                 } | {
-                                     kind: string;
-                                     path: string;
-                                     value?: undefined;
-                                 })[];
-                             };
-                             signer?: undefined;
-                         } | {
-                             name: string;
-                             writable: boolean;
-                             pda?: undefined;
-                             signer?: undefined;
-                         } | {
-                             name: string;
-                             writable: boolean;
-                             signer: boolean;
-                             pda?: undefined;
-                         } | {
-                             name: string;
-                             writable?: undefined;
-                             pda?: undefined;
-                             signer?: undefined;
-                         })[];
-                         args: {
-                             name: string;
-                             type: string;
-                         }[];
-                     } | {
-                         name: string;
-                         docs: string[];
-                         discriminator: number[];
-                         accounts: ({
-                             name: string;
-                             writable: boolean;
-                             pda: {
-                                 seeds: ({
-                                     kind: string;
-                                     value: number[];
-                                     path?: undefined;
-                                 } | {
-                                     kind: string;
-                                     path: string;
-                                     value?: undefined;
-                                 })[];
-                             };
-                             signer?: undefined;
-                             address?: undefined;
-                         } | {
-                             name: string;
-                             writable?: undefined;
-                             pda?: undefined;
-                             signer?: undefined;
-                             address?: undefined;
-                         } | {
-                             name: string;
-                             writable: boolean;
-                             signer: boolean;
-                             pda?: undefined;
-                             address?: undefined;
-                         } | {
-                             name: string;
-                             address: string;
-                             writable?: undefined;
-                             pda?: undefined;
-                             signer?: undefined;
-                         })[];
-                         args: {
-                             name: string;
-                             type: string;
-                         }[];
-                     } | {
-                         name: string;
-                         docs: string[];
-                         discriminator: number[];
-                         accounts: ({
-                             name: string;
-                             writable: boolean;
-                             pda: {
-                                 seeds: {
-                                     kind: string;
-                                     value: number[];
-                                 }[];
-                             };
-                             signer?: undefined;
-                             address?: undefined;
-                         } | {
-                             name: string;
-                             signer: boolean;
-                             writable?: undefined;
-                             pda?: undefined;
-                             address?: undefined;
-                         } | {
-                             name: string;
-                             writable: boolean;
-                             signer: boolean;
-                             pda?: undefined;
-                             address?: undefined;
-                         } | {
-                             name: string;
-                             address: string;
-                             writable?: undefined;
-                             pda?: undefined;
-                             signer?: undefined;
-                         })[];
-                         args: {
-                             name: string;
-                             type: string;
-                         }[];
-                     } | {
-                         name: string;
-                         docs: string[];
-                         discriminator: number[];
-                         accounts: ({
-                             name: string;
-                             writable: boolean;
-                             pda: {
-                                 seeds: ({
-                                     kind: string;
-                                     value: number[];
-                                     path?: undefined;
-                                 } | {
-                                     kind: string;
-                                     path: string;
-                                     value?: undefined;
-                                 })[];
-                                 program?: undefined;
-                             };
-                             signer?: undefined;
-                         } | {
-                             name: string;
-                             writable: boolean;
-                             pda: {
-                                 seeds: ({
-                                     kind: string;
-                                     path: string;
-                                     value?: undefined;
-                                 } | {
-                                     kind: string;
-                                     value: number[];
-                                     path?: undefined;
-                                 })[];
-                                 program: {
-                                     kind: string;
-                                     value: number[];
-                                 };
-                             };
-                             signer?: undefined;
-                         } | {
-                             name: string;
-                             writable: boolean;
-                             pda?: undefined;
-                             signer?: undefined;
-                         } | {
-                             name: string;
-                             signer: boolean;
-                             writable?: undefined;
-                             pda?: undefined;
-                         } | {
-                             name: string;
-                             writable?: undefined;
-                             pda?: undefined;
-                             signer?: undefined;
-                         })[];
-                         args: {
-                             name: string;
-                             type: string;
-                         }[];
-                     })[];
-                     accounts: {
-                         name: string;
-                         discriminator: number[];
-                     }[];
-                     events: {
-                         name: string;
-                         discriminator: number[];
-                     }[];
-                     errors: {
-                         code: number;
-                         name: string;
-                         msg: string;
-                     }[];
-                     types: ({
-                         name: string;
-                         serialization: string;
-                         repr: {
-                             kind: string;
-                         };
-                         type: {
-                             kind: string;
-                             fields: {
-                                 name: string;
-                                 type: string;
-                             }[];
-                         };
-                     } | {
-                         name: string;
-                         type: {
-                             kind: string;
-                             fields: ({
-                                 name: string;
-                                 type: string;
-                             } | {
-                                 name: string;
-                                 type: {
-                                     array: (string | number)[];
-                                 };
-                             })[];
-                         };
-                         serialization?: undefined;
-                         repr?: undefined;
-                     })[];
-                 };
-
-                 /**
-                  * @TODO
-                  * @description withdraw funds from the specified pool including accrued rewards
-                  * @param signer signer / wallet object
-                  * @param options object including pool contract address, user wallet address, and more
-                  * @returns claim tx hash
-                  */
-                 export declare function vaultRedeem(signer: Signer | Wallet, options: IContractWriteOptions & {
-                     year: string;
-                     month: string;
-                     day: string;
-                     receiverIndex: string;
-                 }): Promise<string>;
-
-                 export declare enum VaultRedemptionStatus {
-                     AWAITING_COOLDOWN = "awaiting_cooldown",
-                     READY_TO_CLAIM = "ready_to_claim"
+                 declare namespace StellarConstants {
+                     export {
+                         STELLAR_CHAIN_ID,
+                         STELLAR_CHAIN,
+                         SOROBAN_RPC_URLS,
+                         NETWORK_PASSPHRASES,
+                         STELLAR_FALLBACK_DECIMALS,
+                         TX_TIMEOUT_SECONDS,
+                         QUERY_TIMEOUT_SECONDS,
+                         MAX_FEE_STROOPS,
+                         POLL_INTERVAL_MS,
+                         POLL_INTERVAL_MAX_MS,
+                         POLL_INTERVAL_BACKOFF,
+                         MAX_POLL_ATTEMPTS
+                     }
                  }
 
-                 /**
-                  * Request to redeem vault shares. For EVM-1 vaults this queues a standard
-                  * redemption (claimable later via `vaultRedeem`); for EVM-2 vaults this
-                  * also handles the receipt-token allowance automatically. Pass
-                  * `isInstantRedeem: true` for vaults that support instant settlement.
-                  *
-                  * Approval of the receipt token (EVM-2) is always waited on before the
-                  * redeem call, regardless of the caller's `wait` flag.
-                  *
-                  * @param signer ethers Signer / Wallet (or viem WalletClient via {@link setSigner})
-                  * @param options Vault address, wallet, amount, optional `isInstantRedeem`,
-                  *   optional `wait` to wait for the redeem receipt.
-                  * @returns Redeem transaction hash.
-                  * @throws AugustValidationError on invalid wallet/target/amount.
-                  * @throws AugustSDKError when the redeem submission or on-chain call fails.
-                  *
-                  * @example
-                  * ```ts
-                  * const hash = await augustSdk.evm.vaultRequestRedeem({
-                  *   target: vaultAddress,
-                  *   wallet: walletAddress,
-                  *   amount: '10',           // 10 shares (UI units)
-                  *   wait: true,
-                  * });
-                  * ```
-                  *
-                  * @example Instant redemption
-                  * ```ts
-                  * await augustSdk.evm.vaultRequestRedeem({
-                  *   target: vaultAddress,
-                  *   wallet: walletAddress,
-                  *   amount: '10',
-                  *   isInstantRedeem: true,
-                  * });
-                  * ```
-                  */
-                 export declare function vaultRequestRedeem(signer: Signer | Wallet, options: IContractWriteOptions): Promise<string>;
-
-                 /**
-                  * Vault addresses registered on a `SwapRouter` via `enableVault`. The
-                  * presence of a vault here is the signal to route its deposits through the
-                  * SwapRouter rather than the legacy adapter path.
-                  *
-                  * Entries mirror the on-chain `vaultInfo[addr].referenceAsset != 0` state of
-                  * the `SwapRouter` deployment. Verify against the deployed contract before
-                  * adding a new entry — a vault that is not registered on-chain will revert
-                  * with `InvalidVault` at deposit time.
-                  *
-                  * Lowercase comparison is required when checking — use
-                  * {@link vaultUsesSwapRouter} rather than reading this set directly.
-                  */
-                 export declare const VAULTS_USING_SWAP_ROUTER: ReadonlySet<string>;
-
-                 /**
-                  * Vault Receipt Symbol Mapping
-                  * @deprecated use getVaultMetadata to fetch vault symbols from the backend
-                  */
-                 declare type VaultSymbols = 'predlp' | 'sentusd' | 'pregrid' | 'repouscc' | 'earnxrp' | 'tivkbtc' | 'tivusdt0' | 'supermon' | 'earnmon' | 'k3europ' | 'wmon/ausd' | 'wbtc/ausd' | 'earnausd_monad' | 'sausd' | 'farmbold' | 'sentuscc' | 'sentbtc' | 'svusdc' | 'apusdc' | 'testwethtsa' | 'tacusr' | 'upinjusdt' | 'tac-teth' | 'upausd' | 'taccbbtc' | 'xupusdc' | 'uptbtc' | 'gteth' | 'ageth' | 'upusdc' | 'hgeth' | 'upssylva' | 'hbbtc' | 'hbhype' | 'upazt' | 'susdt' | 'upedge' | 'coreusdc' | 'upcusdo' | 'shifteth' | 'upsusde' | 'uplbtc' | 'upavax' | 'tacrseth' | 'musd' | 'earnausd' | 'alpineusdcflagship' | 'alpinecoinshiftusdc' | 'upbtc' | 'upstrbtc' | 'maxiusr' | 'upgammausdc' | 'xhype' | 'wildusd' | 'alpinebtc' | 'prenusd' | 'upyzusd' | 'upnusd' | 'hlpe' | 'nemo eth yield';
-
-                 /**
-                  * Whether a vault has been registered on a `SwapRouter` and should route
-                  * its deposits through it. Address comparison is case-insensitive.
-                  *
-                  * @param vaultAddress - August vault address.
-                  * @returns `true` when the vault is in {@link VAULTS_USING_SWAP_ROUTER}.
-                  */
-                 export declare function vaultUsesSwapRouter(vaultAddress: IAddress): boolean;
-
-                 export declare function verifyAugustKey(key: string): Promise<boolean>;
-
-                 export declare function verifyInfuraKey(key: string): Promise<boolean>;
-
-                 /**
-                  * Convert a viem WalletClient to an ethers-compatible Signer
-                  * Uses the walletClient as a provider and wraps it for ethers compatibility
-                  * @param walletClient Viem WalletClient from wagmi or viem
-                  * @returns Ethers Signer that can be used with the SDK
-                  */
-                 export declare function viemToEthersSigner(walletClient: any): Promise<Signer | Wallet>;
-
-                 /**
-                  * @param walletClient a wagmi-derived client (from useWalletClient)
-                  * @returns An ethers JsonRpcSigner object used in sdk.evm.setSigner
-                  */
-                 export declare function walletClientToSigner(walletClient: WalletClient): Promise<ethers.JsonRpcSigner>;
-
-                 export declare const WEBSERVER_ENDPOINTS: {
-                     default: {
-                         hello: string;
-                         protected: string;
-                     };
-                     auth: {
-                         verify: string;
-                         sign: string;
-                         login: string;
-                         nonce: string;
-                         refresh: string;
-                     };
-                     subaccount: {
-                         rewards: (subaccount: IAddress) => string;
-                         tokens: (subaccount: IAddress) => string;
-                         twap: {
-                             create: (subaccount: IAddress) => string;
-                             stop: (subaccount: IAddress, id: string) => string;
-                             fills: (subaccount: IAddress, id: string) => string;
-                         };
-                         debank: (subaccount: IAddress) => string;
-                         health_factor: (subaccount: IAddress) => string;
-                         summary: (subaccount: IAddress) => string;
-                         batch: (subaccount: IAddress) => string;
-                         loans: (subaccount: IAddress, side?: "BORROWER" | "LENDER" | "BOTH", active?: boolean) => string;
-                         cefi: (subaccount: IAddress) => string;
-                         otc_positions: (subaccount: IAddress) => string;
-                         _: (subaccount: IAddress) => string;
-                     };
-                     users: {
-                         get: string;
-                     };
-                     prices: (symbol: string) => string;
-                     metrics: {
-                         pnl: (subaccount: IAddress, startTime?: string, endTime?: string) => string;
-                     };
-                     public: {
-                         integrations: {
-                             morpho: {
-                                 apy: (subaccount: IAddress, vaultAddress: IAddress) => string;
-                             };
-                         };
-                         tokenizedVault: {
-                             loans: (vaultAddress: VaultAddress, chainId: number, active: boolean) => string;
-                             subaccountLoans: (vaultAddress: VaultAddress, chainId: number, active: boolean) => string;
-                             list: string;
-                             byVaultAddress: (vaultAddress: VaultAddress) => string;
-                             historicalApy: (vaultAddress: IAddress) => string;
-                             historicalTimeseries: (vaultAddress: IAddress, nDays?: number) => string;
-                             annualizedApy: (vaultAddress: IAddress) => string;
-                             summary: (vaultAddress: IAddress) => string;
-                             withdrawals: (chain: string, vaultAddress: IAddress) => string;
-                             debank: (vaultAddress: IAddress) => string;
-                         };
-                         points: {
-                             byUserAddress: (userAddress: IAddress) => string;
-                             register: string;
-                             leaderboard: string;
-                         };
-                         vaults: {
-                             pendingRedemptions: (vaultAddress: IAddress) => string;
-                         };
-                         pnl: {
-                             unrealizedHistory: (vaultAddress: VaultAddress, limit?: number) => string;
-                             unrealizedLatest: string;
-                         };
-                     };
-                     upshift: {
-                         vaults: {
-                             metadata: string;
-                         };
-                     };
-                 };
-
-                 export declare const WEBSERVER_URL: {
-                     production: string;
-                     staging: string;
-                     development: string;
-                     localhost: string;
-                     qa: string;
-                     public: string;
-                     upshift: string;
-                 };
+                 declare namespace StellarGetters {
+                     export {
+                         getStellarVault,
+                         getStellarUserPosition,
+                         convertToShares
+                     }
+                 }
 
-                 /**
-                  * Withdrawal request with computed claimable date and current processing status.
-                  * The unique identifier is (receiver, claimableDate).
-                  *
-                  * @interface WithdrawalRequestStatus
-                  */
-                 export declare interface WithdrawalRequestStatus {
-                     /** Transaction hash of the withdrawal request */
-                     transactionHash: string;
-                     /** Block timestamp when the withdrawal was requested (seconds, UTC) */
-                     requestTimestamp: number;
-                     /** Shares amount being redeemed */
-                     shares: bigint;
-                     /** Receiver address for the withdrawal */
-                     receiver: string;
-                     /** Computed claimable date in UTC (year, month, day) */
-                     claimableDate: {
-                         year: number;
-                         month: number;
-                         day: number;
-                     };
-                     /** Epoch timestamp when this withdrawal becomes claimable */
-                     claimableEpoch: number;
-                     /** Current status of the withdrawal */
-                     status: 'pending' | 'ready_to_claim' | 'processed';
-                     /** Transaction hash of the processing transaction (if processed) */
-                     processedTransactionHash?: string;
-                     /** Assets received (if processed) */
-                     assetsReceived?: bigint;
+                 declare namespace StellarSubmit {
+                     export {
+                         submitStellarTransaction
+                     }
                  }
 
                  /**
-                  * Higher-order function to wrap SDK methods with performance tracking.
-                  * Tracks method calls, timing, chain usage, and errors.
-                  *
-                  * @param methodName - Name of the method being wrapped
-                  * @param method - The original async method
-                  * @param getChainId - Function to get current chain ID
-                  * @returns Wrapped method with tracking
+                  * @deprecated
+                  * Replaced by SUBGRAPH_VAULT_URLS which are subgraphs deployed on Goldsky.
                   */
-                 export declare function withMethodTracking<T extends (...args: unknown[]) => Promise<unknown>>(methodName: string, method: T, getChainId?: () => number | undefined): T;
+                 export declare const SUBGRAPH_POOL_URLS: (apiKey: string, chainId?: number, pool?: IAddress) => {
+                     1: string;
+                     8453: string;
+                     43114: string;
+                     42161: string;
+                     56: string;
+                 } | {
+                     999: string;
+                 };
 
                  /**
-                  * Wrap async operations with exponential backoff retry logic.
-                  * Retries on network errors with increasing delays between attempts.
-                  * @param fn Async function to execute with retry logic
-                  * @param maxRetries Maximum number of retry attempts
-                  * @param baseDelay Initial delay in milliseconds (doubles each retry)
-                  * @param shouldRetry Custom function to determine if error is retryable
-                  * @returns Result of successful function execution
-                  * @throws Last error if all retries exhausted
+                  * Subgraph URLs
+                  * @deprecated use getVaultMetadata to fetch subgraph URLs from the backend
                   */
-                 export declare function withRetry<T>(fn: () => Promise<T>, maxRetries?: number, baseDelay?: number, shouldRetry?: (error: Error) => boolean): Promise<T>;
+                 export declare const SUBGRAPH_VAULT_URLS: Record<VaultSymbols, string>;
 
                  /**
-                  * Higher-order function to wrap synchronous SDK methods with tracking.
-                  * Uses breadcrumbs for tracking since spans require async context.
+                  * Submit a signed Soroban transaction and poll until confirmed.
                   *
-                  * @param methodName - Name of the method being wrapped
-                  * @param method - The original sync method
-                  * @param getChainId - Function to get current chain ID
-                  * @returns Wrapped method with tracking
-                  */
-                 export declare function withSyncMethodTracking<T extends (...args: unknown[]) => unknown>(methodName: string, method: T, getChainId?: () => number | undefined): T;
-
-                 export declare const WRAPPER_ADAPTOR: {
-                     43114: IAddress;
-                     1: IAddress;
-                 };
-
-                 export { }
+                  * @param signedXdr - Base64-encoded XDR of the signed transaction
+                  * @param network - Stellar network name
+                  * @returns The transaction hash once the network confirms it as successful
+                  * @throws {@link AugustTimeoutError} when the transaction is not confirmed
+                      *   within the poll budget (`MAX_POLL_ATTEMPTS`).
+                      * @throws {@link AugustSDKError} when the RPC rejects the submission or the
+                          *   transaction confirms as failed. Its `context` carries `{ network, status }`
+                          *   plus, when the result XDR decodes, a `resultCode` string holding the
+                          *   transaction-level reason (e.g. `"txBadSeq"`, `"txTooLate"`); `resultCode`
+                          *   is `undefined` when the code cannot be decoded.
+                          * @example
+                          * ```ts
+                          * try {
+                          *   const hash = await submitStellarTransaction(signedXdr, 'mainnet');
+                          * } catch (err) {
+                          *   if (err instanceof AugustSDKError && err.context?.resultCode === 'txBadSeq') {
+                          *     // stale sequence number — rebuild the transaction and resubmit
+                          *   }
+                          * }
+                          * ```
+                          */
+                      declare function submitStellarTransaction(signedXdr: string, network: IStellarNetwork): Promise<string>;
+
+                      /**
+                       * Sui Adapter for August SDK
+                       *
+                       * @example
+                       * To access the Sui adapter instance
+                       * ```
+                       * const sdk = new AugustSDK()
+                       * sdk.sui.getEmberVaults()
+                       * ```
+                       */
+                      declare class SuiAdapter {
+                          private _apiBaseUrl;
+                          private _chainId;
+                          constructor(apiBaseUrl?: string, chainId?: number);
+                          get apiBaseUrl(): string;
+                          get chainId(): number;
+                          getEmberVaults(options?: IFetchEmberVaultsOptions): Promise<IEmberVault[]>;
+                          getEmberTVL(limit?: number): Promise<number>;
+                          convertFromE9(value: string | number): number;
+                          calculateUtilization(current: string | number, maximum: string | number): number;
+                          isSuiAddress(address: string): boolean;
+                          isSuiVault(chainId: number): boolean;
+                          transformEmberVaultToIVault(emberVault: IEmberVault): IVault;
+                          transformEmberVaultsToIVaults(emberVaults: IEmberVault[]): IVault[];
+                      }
+
+                      /**
+                       * Address of the `SwapRouter` periphery contract on each supported chain.
+                       *
+                       * Missing keys mean no SwapRouter is deployed on that chain — callers
+                       * should fall back to legacy adapter paths.
+                       *
+                       * @see {@link getSwapRouterAddress} for the typed lookup helper.
+                       */
+                      export declare const SWAP_ROUTER_ADDRESSES: Readonly<Record<number, IAddress>>;
+
+                      /**
+                       * The DEX aggregator whitelisted on each chain's `SwapRouter` via
+                       * `enableRouter`, plus the single aggregator contract method every swap leg is
+                       * pinned to and that method's 4-byte selector.
+                       *
+                       * This is the single source of truth tying the off-chain swap-leg builder to
+                       * the on-chain router whitelist. The two MUST agree or `swapAndDeposit` reverts
+                       * with `InvalidRouter()` (router not whitelisted) or `InvalidNotWhitelisted()`
+                       * (selector not authorized). It is consumed in three places:
+                       *
+                       * - `dispatchViaSwapRouter` asks {@link fetchSwapQuote} to pin the aggregator to
+                       *   `contractMethod`, then asserts the returned quote's `router` and payload
+                       *   selector match this entry before broadcasting — failing closed rather than
+                       *   letting the user pay gas for a transaction the contract will reject.
+                       * - The CI check `scripts/verify-swap-router-aggregator.mjs` asserts the
+                       *   deployed `SwapRouter` actually has `tokenTransferProxies[router] != 0` and
+                       *   `isAuthorizedSelector(router, selector) == true` for every entry here, so
+                       *   config drift is caught at release time, not by a user's failed deposit.
+                       *
+                       * Pinning to one generic method matters: the aggregator otherwise picks a route
+                       * method per quote (e.g. a direct `swapExactAmountInOnUniswapV3`) that varies
+                       * with market conditions, producing a different selector each time. Pinning
+                       * collapses that to one stable selector so the on-chain whitelist needs only
+                       * that selector and never drifts as routing changes.
+                       *
+                       * `router` is the address the aggregator's calldata targets (ParaSwap v6.2
+                       * pulls tokens to the Augustus contract itself, so the SwapRouter's
+                       * `tokenTransferProxies[router]` is the router address). `selector` is
+                       * `bytes4(keccak256("<contractMethod>(...)"))`. Verify both against the
+                       * deployed router before adding a chain — a wrong value reverts at deposit time.
+                       */
+                      export declare const SWAP_ROUTER_DEX_AGGREGATOR: Readonly<Record<number, {
+                          router: IAddress;
+                          contractMethod: string;
+                          selector: `0x${string}`;
+                      }>>;
+
+                      /**
+                       * Maximum number of swap legs the contract accepts in a single
+                       * `swapAndDeposit` call. Mirrors the on-chain `MAX_SWAPS` constant; reading
+                       * the on-chain value at call time would add an RPC for no gain.
+                       *
+                       * Kept here so the SDK can reject oversize inputs at the boundary rather
+                       * than wait for the on-chain `TooManySwaps` revert.
+                       */
+                      export declare const SWAP_ROUTER_MAX_SWAPS = 9;
+
+                      /**
+                       * Wrapped-native ERC-20 per chain that has a SwapRouter deployment. Mirrors
+                       * the on-chain `wrappedNativeTokenAddress()` view to avoid an extra RPC on
+                       * every dispatch. Used to validate that native-token deposits target a
+                       * vault whose reference asset is the wrapped native — the only configuration
+                       * the contract's `depositNativeToken` / `swapAndDepositNativeToken` accept.
+                       */
+                      export declare const SWAP_ROUTER_WRAPPED_NATIVE: Readonly<Record<number, IAddress>>;
+
+                      /**
+                       * Swap one or more whitelisted ERC-20s into a vault's reference asset via
+                       * the on-chain SwapRouter, then deposit the proceeds into the vault.
+                       *
+                       * Approval is sent automatically when the caller's allowance on each
+                       * `swaps[i].tokenIn` against the SwapRouter is below `amountIn`.
+                       *
+                       * @param signer - ethers `Signer` or `Wallet` with the EOA that holds the input tokens.
+                       * @param options - {@link ISwapAndDepositOptions}.
+                       * @returns The transaction hash of the `swapAndDeposit` call.
+                       *
+                       * @throws {@link AugustValidationError} for unsupported chains, invalid
+                           * addresses, empty/oversized swap arrays.
+                           * @throws {@link AugustSDKError} on unrecoverable contract or RPC failure.
+                               *
+                               * @example
+                               * ```ts
+                               * const quote = await fetchSwapQuote({
+                               *   chainId: 1,
+                               *   srcToken: WBTC,
+                               *   srcDecimals: 8,
+                               *   destToken: USDC,
+                               *   destDecimals: 6,
+                               *   amount: 100_000_000n,
+                               *   receiver: SWAP_ROUTER_ADDRESSES[1]!,
+                               * });
+                               * const hash = await swapAndDeposit(signer, {
+                               *   chainId: 1,
+                               *   vault: '0x8AcA0841993ef4C87244d519166e767f49362C21',
+                               *   receiver: wallet,
+                               *   swaps: [{
+                               *     tokenIn: WBTC,
+                               *     tokenOut: USDC,
+                               *     amountIn: 100_000_000n,
+                               *     minAmountOut: quote.minAmountOut,
+                               *     router: quote.router,
+                               *     payload: quote.payload,
+                               *   }],
+                               * });
+                               * ```
+                               */
+                           export declare function swapAndDeposit(signer: Signer | Wallet, options: ISwapAndDepositOptions): Promise<string>;
+
+                           /**
+                            * Numeric vault-type tag used by the on-chain `SwapRouter` to branch between
+                            * the ERC-4626 (`deposit(uint256, address)`) and multi-asset
+                            * (`deposit(address, uint256, address)`) deposit interfaces.
+                            *
+                            * Values match the contract's `VAULT_TYPE_ERC4626` / `VAULT_TYPE_TOKENIZED_VAULT_V2`
+                            * constants exactly. Set by an admin per-vault via `enableVault` and looked
+                            * up via `vaultInfo(vaultAddr).vaultType`. SDK callers normally do not pass
+                            * this — the router resolves it internally.
+                            */
+                           export declare enum SwapRouterVaultType {
+                               ERC4626 = 1,
+                               TokenizedVaultV2 = 2
+                           }
+
+                           /**
+                            * Table of Contents
+                            * - Formatters
+                            * - Datetime
+                            * - Arrays
+                            * - Caching
+                            */
+                           export declare function toNormalizedBn(value: string | bigint | number, decimals?: number | bigint): INormalizedNumber;
+
+                           /**
+                            * Formatters
+                            */
+                           export declare function toTitleCase(str: string, type?: 'camel'): string;
+
+                           /**
+                            * Track API response times and status.
+                            *
+                            * @param endpoint - The API endpoint called
+                            * @param method - HTTP method used
+                            * @param startTime - Start timestamp from performance.now()
+                            * @param status - HTTP response status code (0 for network errors)
+                            * @param server - Server identifier (production, staging, etc.)
+                            */
+                           export declare function trackApiCall(endpoint: string, method: string, startTime: number, status: number, server: string): void;
+
+                           /**
+                            * Track chain/network switches for usage distribution analysis.
+                            *
+                            * @param chainId - The chain ID being switched to
+                            */
+                           export declare function trackNetworkSwitch(chainId: number): void;
+
+                           export declare function truncate(s: string, amount?: number): string;
+
+                           /* Excluded from this release type: tryRecoverTxHash */
+
+                           /**
+                            * Vault addresses to exclude from `getTotalDeposited` TVL aggregation.
+                            * Addresses are lowercased so EVM, Solana, Sui and Stellar vaults can be
+                            * checked uniformly (don't wrap them with `getAddress` — non-EVM addresses
+                            * would throw). Add an address here to drop its `latest_reported_tvl` from
+                            * the headline number — e.g. closed pre-deposit vaults, test vaults, or
+                            * migrated v1 pools that are double-counted by a v2 successor.
+                            */
+                           export declare const TVL_EXCLUDED_VAULTS: ReadonlySet<string>;
+
+                           /**
+                            * Validity window for a submitted Soroban invocation (seconds).
+                            *
+                            * This becomes the transaction's `maxTime`. Validators reject a tx whose
+                            * `maxTime` has passed (`txTOO_LATE`), so the window must outlast the slowest
+                            * realistic sign-then-submit path: hardware wallets, careful manual review,
+                            * and institutional approval flows (e.g. Fordefi) that don't sign instantly.
+                            * 10 minutes comfortably covers those while staying well inside the Soroban
+                            * footprint/ledger-entry TTL, so the simulated footprint can't go stale first.
+                            *
+                            * The window is anchored to the *network* clock (see `getNetworkCloseTime` in
+                            * soroban.ts), not the signer's `Date.now()`, so a skewed device clock can't
+                            * make the deadline expire early.
+                            */
+                           declare const TX_TIMEOUT_SECONDS = 600;
+
+                           export declare type TypedContract<TAbi extends Abi> = Omit<BaseContract, 'getFunction' | 'getEvent'> & {
+                               [Method in ExtractAbiFunctionNames<TAbi>]: TypedContractFunction<TAbi, Method>;
+                           } & {
+                               /**
+                                * Return the function for a given name. This is useful when a contract
+                                * method name conflicts with a JavaScript name such as ``prototype`` or
+                                * when using a Contract programatically.
+                                */
+                               getFunction<T extends ExtractAbiFunctionNames<TAbi>>(key: T | TypedFragment<TAbi, T>): TypedContractFunction<TAbi, T>;
+                               /**
+                                * Return the event for a given name. This is useful when a contract
+                                * event name conflicts with a JavaScript name such as ``prototype`` or
+                                * when using a Contract programatically.
+                                */
+                               getEvent<T extends ExtractAbiEventNames<TAbi>>(key: T | EventFragment): TypedContractEvent<TAbi, T>;
+                               /**
+                                * All the Events available on this contract.
+                                */
+                               filters: {
+                                   [EventName in ExtractAbiEventNames<TAbi>]: TypedContractEvent<TAbi, EventName>;
+                               };
+                           };
+
+                           export declare interface TypedContractEvent<TAbi extends Abi, TEventName extends string, TEvent extends ExtractAbiEvents<TAbi> = ExtractAbiEvent<TAbi, TEventName>, TEventArgs extends readonly unknown[] = AsArray<Partial<AbiParametersToPrimitiveTypes<TEvent['inputs']>>>> {
+                               (...args: [...TEventArgs]): DeferredTopicFilter;
+                               /**
+                                * The name of the Contract event.
+                                */
+                               name: TEventName;
+                               /**
+                                * The fragment of the Contract event. This will throw on ambiguous
+                                * method names.
+                                */
+                               fragment: EventFragment;
+                               /**
+                                * Returns the fragment constrained by %%args%%. This can be used to
+                                * resolve ambiguous event names.
+                                */
+                               getFragment(...args: [...TEventArgs]): EventFragment;
+                           }
+
+                           export declare interface TypedContractFunction<TAbi extends Abi, TFunctionName extends string, TFunction extends ExtractAbiFunctions<TAbi> = ExtractAbiFunction<TAbi, TFunctionName>, TInputArgs extends readonly unknown[] = AsArray<AbiParametersToPrimitiveTypes<TFunction['inputs']>>, TResult = TypedContractFunctionResult<TAbi, TFunctionName>, TFragment = TypedFragment<TAbi, TFunctionName>> {
+                               (...args: [...TInputArgs, overrides?: Overrides]): Promise<TFunction['stateMutability'] extends 'view' | 'pure' ? TResult : ContractTransactionResponse>;
+                               /**
+                                * The name of the Contract method.
+                                */
+                               name: TFunctionName;
+                               /**
+                                * The fragment of the Contract method. This will throw on ambiguous
+                                * method names.
+                                */
+                               fragment: TFragment;
+                               /**
+                                * Returns the fragment constrained by %%args%%. This can be used to
+                                * resolve ambiguous method names.
+                                */
+                               getFragment(...args: [...TInputArgs]): TFragment;
+                               /**
+                                * Returns a populated transaction that can be used to perform the
+                                * contract method with %%args%%.
+                                */
+                               populateTransaction(...args: [...TInputArgs, overrides?: Overrides]): Promise<ContractTransaction>;
+                               /**
+                                * Call the contract method with %%args%% and return the value.
+                                *
+                                * If the return value is a single type, it will be dereferenced and
+                                * returned directly, otherwise the full Result will be returned.
+                                */
+                               staticCall(...args: [...TInputArgs, overrides?: Overrides]): Promise<TResult>;
+                               /**
+                                * Send a transaction for the contract method with %%args%%.
+                                */
+                               send(...args: [...TInputArgs, overrides?: Overrides]): Promise<ContractTransactionResponse>;
+                               /**
+                                * Estimate the gas to send the contract method with %%args%%.
+                                */
+                               estimateGas(...args: [...TInputArgs, overrides?: Overrides]): Promise<bigint>;
+                               /**
+                                * Call the contract method with %%args%% and return the Result
+                                * without any dereferencing.
+                                */
+                               staticCallResult(...args: [...TInputArgs, overrides?: Overrides]): Promise<Result>;
+                           }
+
+                           export declare type TypedContractFunctionResult<TAbi extends Abi, TFunctionName extends string, TOutputArgs = AbiParametersToPrimitiveTypes<ExtractAbiFunction<TAbi, TFunctionName>['outputs']>> = TOutputArgs extends readonly [] ? void : TOutputArgs extends readonly [infer Arg] ? Arg : TOutputArgs;
+
+                           export declare type TypedFragment<TAbi extends Abi, TFunctionName extends string, TFunction extends ExtractAbiFunctions<TAbi> = ExtractAbiFunction<TAbi, TFunctionName>> = Omit<FunctionFragment, 'inputs' | 'outputs' | 'stateMutability' | 'name' | 'type'> & {
+                               name: TFunction['name'];
+                               type: TFunction['type'];
+                               inputs: TFunction['inputs'];
+                               outputs: TFunction['outputs'];
+                               stateMutability: TFunction['stateMutability'];
+                           };
+
+                           export declare function unixToDate(epoch: number): Date;
+
+                           /**
+                            * Update the current user identity in Sentry.
+                            * Called when wallet address changes.
+                            *
+                            * @param walletAddress - New wallet address (or undefined to clear)
+                            * @param environment - Current environment
+                            */
+                           export declare function updateUser(walletAddress?: string, environment?: IEnv): void;
+
+                           /* Excluded from this release type: validateAmountPrecision */
+
+                           /**
+                            * Vault adapter configurations mapping vault addresses to their adapter settings
+                            */
+                           export declare const VAULT_ADAPTER_CONFIGS: Record<IAddress, IVaultAdapterConfig>;
+
+                           export declare const VAULT_ADDRESSES: Record<"musd" | "predlp" | "sentusd" | "pregrid" | "repouscc" | "earnxrp" | "tivkbtc" | "tivusdt0" | "supermon" | "earnmon" | "k3europ" | "wmon/ausd" | "wbtc/ausd" | "earnausd_monad" | "sausd" | "farmbold" | "sentuscc" | "sentbtc" | "svusdc" | "apusdc" | "testwethtsa" | "tacusr" | "upinjusdt" | "tac-teth" | "upausd" | "taccbbtc" | "xupusdc" | "uptbtc" | "gteth" | "ageth" | "upusdc" | "hgeth" | "upssylva" | "hbbtc" | "hbhype" | "upazt" | "susdt" | "upedge" | "coreusdc" | "upcusdo" | "shifteth" | "upsusde" | "uplbtc" | "upavax" | "tacrseth" | "earnausd" | "alpineusdcflagship" | "alpinecoinshiftusdc" | "upbtc" | "upstrbtc" | "maxiusr" | "upgammausdc" | "xhype" | "wildusd" | "alpinebtc" | "prenusd" | "upyzusd" | "upnusd" | "hlpe" | "nemo eth yield", `0x${string}`>;
+
+                           /**
+                            * Hardcoded subaccount addresses for specific vaults allocations
+                            */
+                           export declare const VAULT_ALLOCATION_SUBACCOUNTS: {
+                               AgoraAUSD: {
+                                   address: IAddress;
+                                   subaccount: IAddress;
+                                   useDebank: boolean;
+                               };
+                               earnAUSD: {
+                                   address: IAddress;
+                                   subaccount: IAddress;
+                                   useDebank: boolean;
+                               };
+                           };
+
+                           /**
+                            * The functions to call on the vault contract
+                            * @returns The functions to call
+                            */
+                           export declare const VAULT_FUNCTIONS_V1: IPoolFunctions[];
+
+                           export declare const VAULT_FUNCTIONS_V2: IPoolFunctions[];
+
+                           export declare const VAULT_FUNCTIONS_V2_RECEIPT: IPoolFunctions[];
+
+                           export declare const VAULT_FUNCTIONS_V2_WHITELISTED_ASSETS: IPoolFunctions[];
+
+                           /**
+                            * Vault Symbols Mapping
+                            * @deprecated use getVaultMetadata to fetch vault symbols from the backend
+                            */
+                           export declare const VAULT_SYMBOLS: Record<IAddress, string>;
+
+                           /**
+                            * Vault Symbols Reverse Mapping
+                            * @deprecated use getVaultMetadata to fetch vault symbols from the backend
+                            */
+                           export declare const VAULT_SYMBOLS_REVERSE: Record<VaultSymbols, IAddress>;
+
+                           /**
+                            * Address type for vault contracts across all supported chains.
+                            * EVM vaults use `0x`-prefixed hex addresses, Solana vaults use base58,
+                            * and Stellar vaults use 56-character base32 addresses (G/C prefix).
+                            *
+                            * Use this instead of `IAddress` when the address may belong to any chain.
+                            */
+                           export declare type VaultAddress = string;
+
+                           /**
+                            * allowance checks user's current allowance per pool
+                            * @param signer - signer / provider object
+                            * @param options - object including pool contract address, user wallet address
+                            * @returns normalized number object of the user's current allowance
+                            */
+                           export declare function vaultAllowance(signer: IContractRunner, options: IContractWriteOptions): Promise<INormalizedNumber>;
+
+                           /**
+                            * Approve a vault (or the appropriate adapter wrapper) to spend a token
+                            * ahead of a separate deposit call. Spender routing mirrors
+                            * {@link vaultDeposit} (multi-asset → vault, adapter → wrapper, standard →
+                            * vault). Returns `undefined` when the existing allowance already covers
+                            * `amount` **or** when the deposit asset is native.
+                            *
+                            * @returns Transaction hash when an approval was sent, `undefined` when
+                            *   the existing allowance already covers `amount` or the deposit asset is
+                            *   native (no ERC-20 allowance applies). Use {@link approve} for a
+                            *   discriminated `ApproveResult` if you need to tell those two cases apart.
+                            * @throws AugustValidationError on invalid wallet/target/amount.
+                            *
+                            * @example
+                            * ```ts
+                            * const hash = await augustSdk.evm.vaultApprove({
+                            *   target: '0x...',         // vault contract address
+                            *   wallet: walletAddress,
+                            *   amount: '100',           // 100 of the deposit token (UI units)
+                            *   wait: true,              // wait for the approval to confirm
+                            * });
+                            * if (hash) console.log('approve tx', hash);
+                            * // hash === undefined means the on-chain allowance already covers the
+                            * // amount, or the deposit asset is native (msg.value, no allowance).
+                            * ```
+                            */
+                           export declare function vaultApprove(signer: Signer | Wallet, options: IContractWriteOptions): Promise<string | undefined>;
+
+                           /**
+                            * Deposit underlying token into the specified vault. Auto-routes to the
+                            * correct contract path (single-asset ERC-4626, EVM-2 multi-asset,
+                            * Paraswap adapter, native-token wrapper, depositWithPermit) based on the
+                            * vault version and `depositAsset`.
+                            *
+                            * Amounts are encoded against the **deposit token's** decimals, not the
+                            * vault's share decimals. The SDK reads the appropriate decimals via the
+                            * vault metadata and the asset's ERC-20.
+                            *
+                            * Approval is handled automatically: if the existing allowance doesn't
+                            * cover `amount`, an `approve` is sent and **always waited for** (regardless
+                            * of the caller's `wait` flag) so the deposit tx can't be re-ordered ahead
+                            * of the approval on Monad-style RPCs.
+                            *
+                            * @param signer ethers Signer / Wallet (or viem WalletClient via {@link setSigner})
+                            * @param options Vault address, wallet, amount, optional `depositAsset` for
+                            *   adapter routes, optional `wait` to wait for the deposit receipt.
+                            * @returns Deposit transaction hash.
+                            * @throws AugustValidationError on invalid wallet/target/amount or missing
+                            *   adapter config when `depositAsset` differs from the vault underlying.
+                            * @throws AugustSDKError when the deposit submission or on-chain call fails.
+                            *
+                            * @example
+                            * ```ts
+                            * const hash = await augustSdk.evm.vaultDeposit({
+                            *   target: '0xE9B725010A9E419412ed67d0fA5f3A5f40159D32', // vault
+                            *   wallet: walletAddress,
+                            *   amount: '100',         // 100 USDC (UI units)
+                            *   wait: true,            // wait for the deposit receipt
+                            * });
+                            * ```
+                            *
+                            * @example Adapter deposit (different deposit asset than the vault's underlying)
+                            * ```ts
+                            * await augustSdk.evm.vaultDeposit({
+                            *   target: vaultAddress,
+                            *   wallet: walletAddress,
+                            *   amount: '0.5',
+                            *   depositAsset: WETH_ADDRESS,   // swap WETH -> vault underlying via the adapter
+                            *   chainId: 1,
+                            * });
+                            * ```
+                            */
+                           export declare function vaultDeposit(signer: Signer | Wallet, options: IContractWriteOptions): Promise<string>;
+
+                           /**
+                            * Check if vault has adapter support
+                            */
+                           export declare function vaultHasAdapter(vaultAddress: IAddress): boolean;
+
+                           declare const vaultIdl: {
+                               address: string;
+                               metadata: {
+                                   name: string;
+                                   version: string;
+                                   spec: string;
+                                   description: string;
+                               };
+                               instructions: ({
+                                   name: string;
+                                   docs: string[];
+                                   discriminator: number[];
+                                   accounts: ({
+                                       name: string;
+                                       writable: boolean;
+                                       pda: {
+                                           seeds: {
+                                               kind: string;
+                                               value: number[];
+                                           }[];
+                                       };
+                                       signer?: undefined;
+                                       address?: undefined;
+                                   } | {
+                                       name: string;
+                                       signer: boolean;
+                                       writable?: undefined;
+                                       pda?: undefined;
+                                       address?: undefined;
+                                   } | {
+                                       name: string;
+                                       writable: boolean;
+                                       pda?: undefined;
+                                       signer?: undefined;
+                                       address?: undefined;
+                                   } | {
+                                       name: string;
+                                       address: string;
+                                       writable?: undefined;
+                                       pda?: undefined;
+                                       signer?: undefined;
+                                   })[];
+                                   args: any[];
+                               } | {
+                                   name: string;
+                                   docs: string[];
+                                   discriminator: number[];
+                                   accounts: ({
+                                       name: string;
+                                       writable: boolean;
+                                       signer: boolean;
+                                       docs?: undefined;
+                                       pda?: undefined;
+                                       address?: undefined;
+                                   } | {
+                                       name: string;
+                                       docs: string[];
+                                       writable: boolean;
+                                       signer: boolean;
+                                       pda?: undefined;
+                                       address?: undefined;
+                                   } | {
+                                       name: string;
+                                       docs: string[];
+                                       writable: boolean;
+                                       pda: {
+                                           seeds: {
+                                               kind: string;
+                                               value: number[];
+                                           }[];
+                                           program?: undefined;
+                                       };
+                                       signer?: undefined;
+                                       address?: undefined;
+                                   } | {
+                                       name: string;
+                                       docs: string[];
+                                       writable: boolean;
+                                       signer?: undefined;
+                                       pda?: undefined;
+                                       address?: undefined;
+                                   } | {
+                                       name: string;
+                                       writable: boolean;
+                                       pda: {
+                                           seeds: ({
+                                               kind: string;
+                                               value: number[];
+                                               path?: undefined;
+                                           } | {
+                                               kind: string;
+                                               path: string;
+                                               value?: undefined;
+                                           })[];
+                                           program: {
+                                               kind: string;
+                                               value: number[];
+                                           };
+                                       };
+                                       signer?: undefined;
+                                       docs?: undefined;
+                                       address?: undefined;
+                                   } | {
+                                       name: string;
+                                       address: string;
+                                       writable?: undefined;
+                                       signer?: undefined;
+                                       docs?: undefined;
+                                       pda?: undefined;
+                                   })[];
+                                   args: {
+                                       name: string;
+                                       type: string;
+                                   }[];
+                               } | {
+                                   name: string;
+                                   docs: string[];
+                                   discriminator: number[];
+                                   accounts: ({
+                                       name: string;
+                                       writable: boolean;
+                                       pda: {
+                                           seeds: ({
+                                               kind: string;
+                                               value: number[];
+                                               path?: undefined;
+                                           } | {
+                                               kind: string;
+                                               path: string;
+                                               value?: undefined;
+                                           })[];
+                                       };
+                                       signer?: undefined;
+                                   } | {
+                                       name: string;
+                                       writable: boolean;
+                                       pda?: undefined;
+                                       signer?: undefined;
+                                   } | {
+                                       name: string;
+                                       writable: boolean;
+                                       signer: boolean;
+                                       pda?: undefined;
+                                   } | {
+                                       name: string;
+                                       writable?: undefined;
+                                       pda?: undefined;
+                                       signer?: undefined;
+                                   })[];
+                                   args: {
+                                       name: string;
+                                       type: string;
+                                   }[];
+                               } | {
+                                   name: string;
+                                   docs: string[];
+                                   discriminator: number[];
+                                   accounts: ({
+                                       name: string;
+                                       writable: boolean;
+                                       pda: {
+                                           seeds: ({
+                                               kind: string;
+                                               value: number[];
+                                               path?: undefined;
+                                           } | {
+                                               kind: string;
+                                               path: string;
+                                               value?: undefined;
+                                           })[];
+                                       };
+                                       signer?: undefined;
+                                       address?: undefined;
+                                   } | {
+                                       name: string;
+                                       writable?: undefined;
+                                       pda?: undefined;
+                                       signer?: undefined;
+                                       address?: undefined;
+                                   } | {
+                                       name: string;
+                                       writable: boolean;
+                                       signer: boolean;
+                                       pda?: undefined;
+                                       address?: undefined;
+                                   } | {
+                                       name: string;
+                                       address: string;
+                                       writable?: undefined;
+                                       pda?: undefined;
+                                       signer?: undefined;
+                                   })[];
+                                   args: {
+                                       name: string;
+                                       type: string;
+                                   }[];
+                               } | {
+                                   name: string;
+                                   docs: string[];
+                                   discriminator: number[];
+                                   accounts: ({
+                                       name: string;
+                                       writable: boolean;
+                                       pda: {
+                                           seeds: {
+                                               kind: string;
+                                               value: number[];
+                                           }[];
+                                       };
+                                       signer?: undefined;
+                                       address?: undefined;
+                                   } | {
+                                       name: string;
+                                       signer: boolean;
+                                       writable?: undefined;
+                                       pda?: undefined;
+                                       address?: undefined;
+                                   } | {
+                                       name: string;
+                                       writable: boolean;
+                                       signer: boolean;
+                                       pda?: undefined;
+                                       address?: undefined;
+                                   } | {
+                                       name: string;
+                                       address: string;
+                                       writable?: undefined;
+                                       pda?: undefined;
+                                       signer?: undefined;
+                                   })[];
+                                   args: {
+                                       name: string;
+                                       type: string;
+                                   }[];
+                               } | {
+                                   name: string;
+                                   docs: string[];
+                                   discriminator: number[];
+                                   accounts: ({
+                                       name: string;
+                                       writable: boolean;
+                                       pda: {
+                                           seeds: ({
+                                               kind: string;
+                                               value: number[];
+                                               path?: undefined;
+                                           } | {
+                                               kind: string;
+                                               path: string;
+                                               value?: undefined;
+                                           })[];
+                                           program?: undefined;
+                                       };
+                                       signer?: undefined;
+                                   } | {
+                                       name: string;
+                                       writable: boolean;
+                                       pda: {
+                                           seeds: ({
+                                               kind: string;
+                                               path: string;
+                                               value?: undefined;
+                                           } | {
+                                               kind: string;
+                                               value: number[];
+                                               path?: undefined;
+                                           })[];
+                                           program: {
+                                               kind: string;
+                                               value: number[];
+                                           };
+                                       };
+                                       signer?: undefined;
+                                   } | {
+                                       name: string;
+                                       writable: boolean;
+                                       pda?: undefined;
+                                       signer?: undefined;
+                                   } | {
+                                       name: string;
+                                       signer: boolean;
+                                       writable?: undefined;
+                                       pda?: undefined;
+                                   } | {
+                                       name: string;
+                                       writable?: undefined;
+                                       pda?: undefined;
+                                       signer?: undefined;
+                                   })[];
+                                   args: {
+                                       name: string;
+                                       type: string;
+                                   }[];
+                               })[];
+                               accounts: {
+                                   name: string;
+                                   discriminator: number[];
+                               }[];
+                               events: {
+                                   name: string;
+                                   discriminator: number[];
+                               }[];
+                               errors: {
+                                   code: number;
+                                   name: string;
+                                   msg: string;
+                               }[];
+                               types: ({
+                                   name: string;
+                                   serialization: string;
+                                   repr: {
+                                       kind: string;
+                                   };
+                                   type: {
+                                       kind: string;
+                                       fields: {
+                                           name: string;
+                                           type: string;
+                                       }[];
+                                   };
+                               } | {
+                                   name: string;
+                                   type: {
+                                       kind: string;
+                                       fields: ({
+                                           name: string;
+                                           type: string;
+                                       } | {
+                                           name: string;
+                                           type: {
+                                               array: (string | number)[];
+                                           };
+                                       })[];
+                                   };
+                                   serialization?: undefined;
+                                   repr?: undefined;
+                               })[];
+                           };
+
+                           /**
+                            * @TODO
+                            * @description withdraw funds from the specified pool including accrued rewards
+                            * @param signer signer / wallet object
+                            * @param options object including pool contract address, user wallet address, and more
+                            * @returns claim tx hash
+                            */
+                           export declare function vaultRedeem(signer: Signer | Wallet, options: IContractWriteOptions & {
+                               year: string;
+                               month: string;
+                               day: string;
+                               receiverIndex: string;
+                           }): Promise<string>;
+
+                           export declare enum VaultRedemptionStatus {
+                               AWAITING_COOLDOWN = "awaiting_cooldown",
+                               READY_TO_CLAIM = "ready_to_claim"
+                           }
+
+                           /**
+                            * Request to redeem vault shares. For EVM-1 vaults this queues a standard
+                            * redemption (claimable later via `vaultRedeem`); for EVM-2 vaults this
+                            * also handles the receipt-token allowance automatically. Pass
+                            * `isInstantRedeem: true` for vaults that support instant settlement.
+                            *
+                            * Approval of the receipt token (EVM-2) is always waited on before the
+                            * redeem call, regardless of the caller's `wait` flag.
+                            *
+                            * @param signer ethers Signer / Wallet (or viem WalletClient via {@link setSigner})
+                            * @param options Vault address, wallet, amount, optional `isInstantRedeem`,
+                            *   optional `wait` to wait for the redeem receipt.
+                            * @returns Redeem transaction hash.
+                            * @throws AugustValidationError on invalid wallet/target/amount.
+                            * @throws AugustSDKError when the redeem submission or on-chain call fails.
+                            *
+                            * @example
+                            * ```ts
+                            * const hash = await augustSdk.evm.vaultRequestRedeem({
+                            *   target: vaultAddress,
+                            *   wallet: walletAddress,
+                            *   amount: '10',           // 10 shares (UI units)
+                            *   wait: true,
+                            * });
+                            * ```
+                            *
+                            * @example Instant redemption
+                            * ```ts
+                            * await augustSdk.evm.vaultRequestRedeem({
+                            *   target: vaultAddress,
+                            *   wallet: walletAddress,
+                            *   amount: '10',
+                            *   isInstantRedeem: true,
+                            * });
+                            * ```
+                            */
+                           export declare function vaultRequestRedeem(signer: Signer | Wallet, options: IContractWriteOptions): Promise<string>;
+
+                           /**
+                            * Vault addresses registered on a `SwapRouter` via `enableVault`. The
+                            * presence of a vault here is the signal to route its deposits through the
+                            * SwapRouter rather than the legacy adapter path.
+                            *
+                            * Entries mirror the on-chain `vaultInfo[addr].referenceAsset != 0` state of
+                            * the `SwapRouter` deployment. Verify against the deployed contract before
+                            * adding a new entry — a vault that is not registered on-chain will revert
+                            * with `InvalidVault` at deposit time.
+                            *
+                            * Lowercase comparison is required when checking — use
+                            * {@link vaultUsesSwapRouter} rather than reading this set directly.
+                            */
+                           export declare const VAULTS_USING_SWAP_ROUTER: ReadonlySet<string>;
+
+                           /**
+                            * Vault Receipt Symbol Mapping
+                            * @deprecated use getVaultMetadata to fetch vault symbols from the backend
+                            */
+                           declare type VaultSymbols = 'predlp' | 'sentusd' | 'pregrid' | 'repouscc' | 'earnxrp' | 'tivkbtc' | 'tivusdt0' | 'supermon' | 'earnmon' | 'k3europ' | 'wmon/ausd' | 'wbtc/ausd' | 'earnausd_monad' | 'sausd' | 'farmbold' | 'sentuscc' | 'sentbtc' | 'svusdc' | 'apusdc' | 'testwethtsa' | 'tacusr' | 'upinjusdt' | 'tac-teth' | 'upausd' | 'taccbbtc' | 'xupusdc' | 'uptbtc' | 'gteth' | 'ageth' | 'upusdc' | 'hgeth' | 'upssylva' | 'hbbtc' | 'hbhype' | 'upazt' | 'susdt' | 'upedge' | 'coreusdc' | 'upcusdo' | 'shifteth' | 'upsusde' | 'uplbtc' | 'upavax' | 'tacrseth' | 'musd' | 'earnausd' | 'alpineusdcflagship' | 'alpinecoinshiftusdc' | 'upbtc' | 'upstrbtc' | 'maxiusr' | 'upgammausdc' | 'xhype' | 'wildusd' | 'alpinebtc' | 'prenusd' | 'upyzusd' | 'upnusd' | 'hlpe' | 'nemo eth yield';
+
+                           /**
+                            * Whether a vault has been registered on a `SwapRouter` and should route
+                            * its deposits through it. Address comparison is case-insensitive.
+                            *
+                            * @param vaultAddress - August vault address.
+                            * @returns `true` when the vault is in {@link VAULTS_USING_SWAP_ROUTER}.
+                            */
+                           export declare function vaultUsesSwapRouter(vaultAddress: IAddress): boolean;
+
+                           export declare function verifyAugustKey(key: string): Promise<boolean>;
+
+                           export declare function verifyInfuraKey(key: string): Promise<boolean>;
+
+                           /**
+                            * Convert a viem WalletClient to an ethers-compatible Signer
+                            * Uses the walletClient as a provider and wraps it for ethers compatibility
+                            * @param walletClient Viem WalletClient from wagmi or viem
+                            * @returns Ethers Signer that can be used with the SDK
+                            */
+                           export declare function viemToEthersSigner(walletClient: any): Promise<Signer | Wallet>;
+
+                           /**
+                            * @param walletClient a wagmi-derived client (from useWalletClient)
+                            * @returns An ethers JsonRpcSigner object used in sdk.evm.setSigner
+                            */
+                           export declare function walletClientToSigner(walletClient: WalletClient): Promise<ethers.JsonRpcSigner>;
+
+                           export declare const WEBSERVER_ENDPOINTS: {
+                               default: {
+                                   hello: string;
+                                   protected: string;
+                               };
+                               auth: {
+                                   verify: string;
+                                   sign: string;
+                                   login: string;
+                                   nonce: string;
+                                   refresh: string;
+                               };
+                               subaccount: {
+                                   rewards: (subaccount: IAddress) => string;
+                                   tokens: (subaccount: IAddress) => string;
+                                   twap: {
+                                       create: (subaccount: IAddress) => string;
+                                       stop: (subaccount: IAddress, id: string) => string;
+                                       fills: (subaccount: IAddress, id: string) => string;
+                                   };
+                                   debank: (subaccount: IAddress) => string;
+                                   health_factor: (subaccount: IAddress) => string;
+                                   summary: (subaccount: IAddress) => string;
+                                   batch: (subaccount: IAddress) => string;
+                                   loans: (subaccount: IAddress, side?: "BORROWER" | "LENDER" | "BOTH", active?: boolean) => string;
+                                   cefi: (subaccount: IAddress) => string;
+                                   otc_positions: (subaccount: IAddress) => string;
+                                   _: (subaccount: IAddress) => string;
+                               };
+                               users: {
+                                   get: string;
+                               };
+                               prices: (symbol: string) => string;
+                               metrics: {
+                                   pnl: (subaccount: IAddress, startTime?: string, endTime?: string) => string;
+                               };
+                               public: {
+                                   integrations: {
+                                       morpho: {
+                                           apy: (subaccount: IAddress, vaultAddress: IAddress) => string;
+                                       };
+                                   };
+                                   tokenizedVault: {
+                                       loans: (vaultAddress: VaultAddress, chainId: number, active: boolean) => string;
+                                       subaccountLoans: (vaultAddress: VaultAddress, chainId: number, active: boolean) => string;
+                                       list: string;
+                                       byVaultAddress: (vaultAddress: VaultAddress) => string;
+                                       historicalApy: (vaultAddress: IAddress) => string;
+                                       historicalTimeseries: (vaultAddress: IAddress, nDays?: number) => string;
+                                       annualizedApy: (vaultAddress: IAddress) => string;
+                                       summary: (vaultAddress: IAddress) => string;
+                                       withdrawals: (chain: string, vaultAddress: IAddress) => string;
+                                       debank: (vaultAddress: IAddress) => string;
+                                       userHistory: (vaultAddress: IAddress, wallet: IAddress) => string;
+                                       archivedVaults: string;
+                                   };
+                                   points: {
+                                       byUserAddress: (userAddress: IAddress) => string;
+                                       register: string;
+                                       leaderboard: string;
+                                   };
+                                   vaults: {
+                                       pendingRedemptions: (vaultAddress: IAddress) => string;
+                                   };
+                                   pnl: {
+                                       unrealizedHistory: (vaultAddress: VaultAddress, limit?: number) => string;
+                                       unrealizedLatest: string;
+                                   };
+                               };
+                               upshift: {
+                                   vaults: {
+                                       metadata: string;
+                                   };
+                               };
+                           };
+
+                           export declare const WEBSERVER_URL: {
+                               production: string;
+                               staging: string;
+                               development: string;
+                               localhost: string;
+                               qa: string;
+                               public: string;
+                               upshift: string;
+                           };
+
+                           /**
+                            * Withdrawal request with computed claimable date and current processing status.
+                            * The unique identifier is (receiver, claimableDate).
+                            *
+                            * @interface WithdrawalRequestStatus
+                            */
+                           export declare interface WithdrawalRequestStatus {
+                               /** Transaction hash of the withdrawal request */
+                               transactionHash: string;
+                               /** Block timestamp when the withdrawal was requested (seconds, UTC) */
+                               requestTimestamp: number;
+                               /** Shares amount being redeemed */
+                               shares: bigint;
+                               /** Receiver address for the withdrawal */
+                               receiver: string;
+                               /** Computed claimable date in UTC (year, month, day) */
+                               claimableDate: {
+                                   year: number;
+                                   month: number;
+                                   day: number;
+                               };
+                               /** Epoch timestamp when this withdrawal becomes claimable */
+                               claimableEpoch: number;
+                               /** Current status of the withdrawal */
+                               status: 'pending' | 'ready_to_claim' | 'processed';
+                               /** Transaction hash of the processing transaction (if processed) */
+                               processedTransactionHash?: string;
+                               /** Assets received (if processed) */
+                               assetsReceived?: bigint;
+                           }
+
+                           /**
+                            * Higher-order function to wrap SDK methods with performance tracking.
+                            * Tracks method calls, timing, chain usage, and errors.
+                            *
+                            * @param methodName - Name of the method being wrapped
+                            * @param method - The original async method
+                            * @param getChainId - Function to get current chain ID
+                            * @returns Wrapped method with tracking
+                            */
+                           export declare function withMethodTracking<T extends (...args: unknown[]) => Promise<unknown>>(methodName: string, method: T, getChainId?: () => number | undefined): T;
+
+                           /**
+                            * Wrap async operations with exponential backoff retry logic.
+                            * Retries on network errors with increasing delays between attempts.
+                            * @param fn - Async function to execute with retry logic
+                            * @param maxRetries - Maximum number of retry attempts
+                            * @param baseDelay - Initial delay in milliseconds (doubles each retry)
+                            * @param shouldRetry - Custom function to determine if error is retryable
+                            * @returns Result of successful function execution
+                            * @throws Last error if all retries exhausted
+                            */
+                           export declare function withRetry<T>(fn: () => Promise<T>, maxRetries?: number, baseDelay?: number, shouldRetry?: (error: Error) => boolean): Promise<T>;
+
+                           /**
+                            * Higher-order function to wrap synchronous SDK methods with tracking.
+                            * Uses breadcrumbs for tracking since spans require async context.
+                            *
+                            * @param methodName - Name of the method being wrapped
+                            * @param method - The original sync method
+                            * @param getChainId - Function to get current chain ID
+                            * @returns Wrapped method with tracking
+                            */
+                           export declare function withSyncMethodTracking<T extends (...args: unknown[]) => unknown>(methodName: string, method: T, getChainId?: () => number | undefined): T;
+
+                           export declare const WRAPPER_ADAPTOR: {
+                               43114: IAddress;
+                               1: IAddress;
+                           };
+
+                           export { }