@augustdigital/sdk 8.15.0 → 8.16.1

package/lib/sdk.d.ts

@@ -18210,6 +18210,15 @@ declare function assertNotStellar(address: string, operation: string): void;
              */
             export declare const getDefaultSubgraphUrl: (_network: string, _symbol: string) => string | undefined;
 
+            /**
+             * Program ids for `network`, or `undefined` when the canonical program has no
+             * deployment there (currently `testnet`). Callers must handle `undefined` —
+             * silently substituting a default would hand back a dead address.
+             */
+            declare function getDeployedProgramIds(network: ISolanaNetwork): {
+                vault: string;
+            } | undefined;
+
             /**
              * Fetches the total amount deposited by an address on a whitelist contract
              * @param signer - signer / provider object
@@ -18977,6 +18986,15 @@ declare function assertNotStellar(address: string, operation: string): void;
               * 2. Fetch user's current assets (balanceOf * sharePrice via convertToAssets)
               * 3. Calculate PnL = assets withdrawn + current assets - assets deposited
               *
+              * `totalDeposited` is the face value of what the user actually paid in
+              * (each deposited asset's raw amount, rescaled to the vault's decimals — no
+              * live price conversion), so any entry/exit fee the vault charges is
+              * automatically counted as a cost against PnL rather than excluded from it.
+              * Pre-deposit multi-asset vaults are assumed to only accept dollar-pegged
+              * stablecoins into a dollar-denominated vault; a vault accepting a
+              * non-pegged deposit asset would need deposit-time price conversion, which
+              * this function does not perform.
+              *
               * @param vault - Vault contract address
               * @param wallet - User wallet address
               * @param options - RPC configuration and service options
@@ -20794,6 +20812,9 @@ declare function assertNotStellar(address: string, operation: string): void;
                  network?: ISolanaNetwork_2;
              }
 
+             /** Solana networks the canonical august_vault program is actually deployed on. */
+             declare type ISolanaDeployedNetwork = keyof typeof programIds;
+
              export declare type ISolanaNetwork = 'devnet' | 'mainnet-beta' | 'testnet' | 'localnet';
 
              declare type ISolanaNetwork_2 = 'devnet' | 'mainnet-beta' | 'testnet' | 'localnet';
@@ -21489,6 +21510,12 @@ declare function assertNotStellar(address: string, operation: string): void;
                  daily_pnl_per_share: Record<string, number>;
                  latest_reported_tvl: number | null;
                  cached_at?: string | null;
+                 /**
+                  * Per-vault provenance timestamps (APY recompute, newest share-price snapshot,
+                  * response assembly). Absent on older/cached responses predating the backend
+                  * change that added it.
+                  */
+                 freshness?: ITokenizedVaultFreshness | null;
                  instant_redeem_config: null | {
                      subaccount_address: string;
                      output_asset_symbol: string;
@@ -21512,6 +21539,48 @@ declare function assertNotStellar(address: string, operation: string): void;
                  name: string;
              }
 
+             /**
+              * Per-vault provenance timestamps returned by the backend on every tokenized-vault
+              * read (list and single-vault, on both the `api.augustdigital.io/tokenized_vault`
+              * and `api.upshift.finance/tokenized_vaults` surfaces).
+              *
+              * The three stamps describe *different* pipelines and are independently nullable —
+              * one of them cannot stand in for another. Consumers use the ordering between them
+              * to detect that the vault's share price has moved ahead of its APY: a
+              * `share_ratio_snapshot_at` later than `apy_computed_at` means a share-price
+              * snapshot has landed that the APY has not yet been recomputed from.
+              *
+              * All values are RFC 3339 UTC strings with a trailing `Z` (e.g.
+              * `'2026-07-25T00:01:46Z'`). The trailing `Z` matters: `new Date()` parses an
+              * offset-less date-time as *local* time, which would silently shift the stamp by
+              * the viewer's UTC offset.
+              *
+              * @see ITokenizedVault.freshness
+              */
+             export declare interface ITokenizedVaultFreshness {
+                 /**
+                  * When `historical_apy`, TVL and drawdown were last recomputed, or null if they
+                  * have never been computed for this vault.
+                  */
+                 apy_computed_at: string | null;
+                 /**
+                  * `snapshot_datetime` of the newest persisted share-price snapshot, or null when
+                  * the vault has no snapshot yet.
+                  *
+                  * The backend stamps this from a scalar `max(snapshot_datetime)`, so it is
+                  * populated independently of `load_snapshots` — including on the basic and
+                  * sub-accounts views (`load_snapshots=false`), which is what every app call site
+                  * sends. Never substitute another timestamp for it.
+                  */
+                 share_ratio_snapshot_at: string | null;
+                 /**
+                  * When the backend assembled the response body, before it entered the backend's
+                  * own response cache. Distinct from the top-level `cached_at` only in scope:
+                  * this one travels with the vault object.
+                  */
+                 cached_at: string | null;
+             }
+
              export declare interface ITokenizedVaultOperator {
                  address: `0x${string}`;
                  operator_type: IOperatorTypeEnum;
@@ -21749,6 +21818,13 @@ declare function assertNotStellar(address: string, operation: string): void;
                  defaultApyHorizon?: 7 | 30 | null;
                  latest_reported_tvl?: number | null;
                  cachedAt?: string | null;
+                 /**
+                  * Provenance timestamps for the vault's server-side data — when its APY was last
+                  * recomputed, when its newest share-price snapshot was taken, and when the
+                  * backend built the response. Null (or a null member) when the backend did not
+                  * report that stamp; see {@link IVaultFreshness}.
+                  */
+                 freshness?: IVaultFreshness | null;
                  showCapFilled?: boolean | null;
                  /** Controls how the vault's APY is displayed; null when the backend has not set an override. */
                  apyOverride?: IApyOverride | null;
@@ -21835,14 +21911,38 @@ declare function assertNotStellar(address: string, operation: string): void;
                  liquidAPY30Day?: number;
              }
 
+             /**
+              * A vault's APY breakdown.
+              *
+              * **Unit contract: every rate on this type is a PERCENTAGE, not a decimal
+              * fraction.** `7.95` means 7.95%. The backend reports these as decimal fractions
+              * (`0.0795`); the SDK multiplies by 100 exactly once, uniformly across every rate
+              * field, before returning them. Consumers must therefore divide by 100 at most once
+              * — and must apply the same treatment to `apy`, `liquidApy`, `pointsApy`,
+              * `campaignApy` and `underlyingApy`, because they all arrive in the same unit.
+              *
+              * This is stated explicitly because the convention going undocumented let a
+              * consumer scale a subset of these fields twice, making them contribute 1/100th of
+              * their value to a displayed total (AUGUST-6967). The unit is uniform here by
+              * design; treating some of these fields as decimals and others as percentages is
+              * always a bug on the consumer side.
+              */
              export declare interface IVaultApy {
+                 /** Base vault APY as a percentage (7.95 = 7.95%). */
                  apy: number;
+                 /** Human-readable note on how the APY is derived; empty or null when unset. */
                  explainer: string;
+                 /** Liquid-yield component as a percentage. */
                  liquidApy: number;
+                 /** Points-program APY as a percentage, or null when the vault has no points. */
                  pointsApy: number | null;
+                 /** Campaign-boost APY as a percentage, or null when no campaign is running. */
                  campaignApy: number | null;
+                 /** Claimable rewards, in the reward token's own units — not a percentage. */
                  rewardsClaimable: number;
+                 /** Compounded rewards, in the reward token's own units — not a percentage. */
                  rewardsCompounded: number;
+                 /** Underlying-asset APY as a percentage (e.g. staking yield on the deposit asset). */
                  underlyingApy: number;
              }
 
@@ -21938,6 +22038,64 @@ declare function assertNotStellar(address: string, operation: string): void;
                  symbol: string;
              };
 
+             /**
+              * Provenance timestamps for a vault's server-side data, mapped from the backend
+              * `freshness` object.
+              *
+              * A vault's share price and its APY come from two different pipelines: the SDK
+              * reads share price live from chain (`totalAssets()/totalSupply()`), while APY is a
+              * backend column recomputed on a schedule. These stamps make the remaining gap
+              * visible so a UI can render "data as of X" instead of implying both numbers are
+              * equally current.
+              *
+              * The three fields are **independently nullable and independently meaningful** —
+              * none of them is a fallback for another. In particular, when
+              * `shareRatioSnapshotAt` is later than `apyComputedAt`, a share-price snapshot has
+              * landed that the APY has not yet been recomputed from: that ordering is the
+              * staleness signal.
+              *
+              * Every value is an RFC 3339 UTC string with a trailing `Z`, exactly as the backend
+              * sends it — the SDK does not reformat or reinterpret them. Keep the `Z` if you
+              * pass these anywhere: `new Date('2026-07-25T00:01:46')` (no `Z`) is parsed as
+              * *local* time and silently shifts by the viewer's UTC offset.
+              *
+              * @example
+              * ```ts
+              * const vault = await sdk.vaults.getVault(address);
+              * const { apyComputedAt, shareRatioSnapshotAt } = vault.freshness ?? {};
+              * // Only comparable when BOTH are present.
+              * const apyLagsSharePrice =
+              *   !!apyComputedAt &&
+              *   !!shareRatioSnapshotAt &&
+              *   new Date(shareRatioSnapshotAt) > new Date(apyComputedAt);
+              * ```
+              */
+             export declare interface IVaultFreshness {
+                 /**
+                  * When the backend last recomputed `historical_apy`, TVL and drawdown for this
+                  * vault. Null if never computed.
+                  */
+                 apyComputedAt: string | null;
+                 /**
+                  * Timestamp of the newest persisted share-price snapshot the backend holds. Null
+                  * only when the vault has no snapshot yet.
+                  *
+                  * Populated regardless of whether the read loaded snapshots — the backend stamps
+                  * it from a scalar `max(snapshot_datetime)`, so it is present even on
+                  * `load_snapshots=false` reads (the basic and sub-accounts views). When it is
+                  * null, treat it as absent: do not fall back to `apyComputedAt` or `cachedAt` in
+                  * its place.
+                  */
+                 shareRatioSnapshotAt: string | null;
+                 /**
+                  * When the backend assembled the response body this vault came from, before its
+                  * own response cache. Note this does **not** account for the SDK's client-side
+                  * LRU (10–15 min on `fetchTokenizedVault` / `fetchTokenizedVaults`), so a vault
+                  * served from that cache can be older than this stamp suggests is possible.
+                  */
+                 cachedAt: string | null;
+             }
+
              export declare type IVaultHistoricalParams = {
                  daysAgo?: number;
                  order?: IVaultOrderParam;
@@ -22860,6 +23018,25 @@ declare function assertNotStellar(address: string, operation: string): void;
                  website_url: string;
              }[];
 
+             /**
+              * Map the backend `freshness` object onto the camelCased {@link IVaultFreshness}
+              * shape carried on `IVault`. Shared across all chain adapters (EVM, Solana,
+              * Stellar) so every surface reports provenance identically.
+              *
+              * Each of the three stamps is passed through independently: a missing member
+              * becomes `null` and is never defaulted from one of the others. That is the point
+              * of the object — `apy_computed_at` and `share_ratio_snapshot_at` describe two
+              * different pipelines, and collapsing them would erase the very staleness signal
+              * (snapshot newer than APY) the field exists to expose.
+              *
+              * @param tokenizedVault - Backend tokenized-vault payload. `freshness` is absent on
+              *   responses predating the backend change, and may be explicitly null.
+              * @returns The mapped freshness object, or `null` when the backend reported none.
+              *   Values are the backend's RFC 3339 UTC strings verbatim — no reformatting, so
+              *   the trailing `Z` is preserved.
+              */
+             export declare function mapVaultFreshness(tokenizedVault: ITokenizedVault | undefined | null): IVaultFreshness | null;
+
              /**
               * Max fee ceiling in stroops (1_000_000 stroops = 0.1 XLM).
               * assembleTransaction adjusts to the actual fee from simulation.
@@ -23107,9 +23284,6 @@ declare function assertNotStellar(address: string, operation: string): void;
                  "mainnet-beta": {
                      vault: string;
                  };
-                 testnet: {
-                     vault: string;
-                 };
                  localnet: {
                      vault: string;
                  };
@@ -24315,7 +24489,7 @@ declare function assertNotStellar(address: string, operation: string): void;
                       isSolanaAddress: isSolanaAddress;
                       isSolana: (signature: string) => boolean;
                       getProgram: ({ provider, idl, programId, network, }: {
-                          idl: any;
+                          idl?: any;
                           programId?: string;
                       } & ISolanaConnectionOptions) => Program<any>;
                       getProvider: ({ connection, publicKey, signTransaction, }: {
@@ -24379,9 +24553,6 @@ declare function assertNotStellar(address: string, operation: string): void;
                           "mainnet-beta": {
                               vault: string;
                           };
-                          testnet: {
-                              vault: string;
-                          };
                           localnet: {
                               vault: string;
                           };
@@ -24433,1516 +24604,1516 @@ declare function assertNotStellar(address: string, operation: string): void;
                   get connection(): web3.Connection;
                   get provider(): AnchorProvider;
                   setWalletProvider(_publicKey: PublicKey | string, signTransaction: (<T extends Transaction | web3.VersionedTransaction>(transaction: T) => Promise<T>) | undefined): void;
-                  getProgram(programIdl: any): Program<any>;
-                  getVaultState(vaultProgramId: PublicKey | string, idl: any, vaultAddress?: PublicKey | string): Promise<{
-                      vaultState: unknown | null;
-                      depositMintDecimals: number | null;
-                  }>;
-                  getVaultStateReadOnly(vaultProgramId: PublicKey | string, idl: any, vaultAddress?: PublicKey | string): Promise<{
-                      vaultState: ISolanaVaultState | null;
-                      depositMintDecimals: number | null;
-                  }>;
-                  getToken(mintAddress: string | PublicKey): Promise<{
-                      address: string;
-                      symbol: string;
-                      decimals: number;
-                      name: string;
-                      image: string;
-                  }>;
-                  getTokenSymbol(mintAddress: string | PublicKey): Promise<string>;
-                  fetchUserTokenBalance(publicKey: PublicKey | string, depositMint: PublicKey | string): Promise<any>;
-                  fetchUserShareBalance(publicKey: PublicKey | string, shareMint: PublicKey | string): Promise<any>;
-                  /**
-                   * BigInt-safe variant of {@link fetchUserShareBalance}. Returns the raw u64
-                   * `amount` (as a base-units string) plus the mint's `decimals` (or `null`
-                   * when the scale can't be determined — see Returns), so the caller can
-                   * produce a correct `INormalizedNumber` without losing precision.
-                   *
-                   * Prefer this anywhere the result feeds BigInt math — positions, max-
-                   * actions, redemption sizing, allowance checks. `fetchUserShareBalance`
-                   * returns a JS-number `uiAmount` which silently encodes against 18 decimals
-                   * when passed through `toNormalizedBn(value)` without an explicit decimals
-                   * argument; that's exactly how the jitoSOL "missing position" regression
-                   * manifested.
-                   *
-                   * RPC cost: 1 `getParsedTokenAccountsByOwner` call. Worst case ~150ms on a
-                   * healthy mainnet endpoint.
-                   *
-                   * @param publicKey   Wallet owner (PublicKey or base58 string).
-                   * @param shareMint   The vault's share-token mint (PublicKey or base58).
-                   * @returns
-                   *   `{ amount, decimals }`. Three observable shapes:
-                   *   - `{ amount: '<u64>', decimals: <number> }` — token account exists.
-                   *   - `{ amount: '0', decimals: null }` — no token account for this mint
-                   *     under this wallet, OR `tokenAmount` was missing from the response,
-                   *     OR `publicKey`/`shareMint` was not supplied. Distinguishable from a
-                   *     genuine zero-balance account (`decimals` would be set there).
-                   *   - `{ amount: '0', decimals: null }` — RPC threw (error is logged).
-                   *
-                   *   `decimals === null` means "we could not determine the scale" — callers
-                   *   that need an `INormalizedNumber` must fall back to a known decimals
-                   *   value (typically the deposit mint's decimals from backend metadata)
-                   *   before normalizing. Never throws.
-                   */
-                  fetchUserShareBalanceRaw(publicKey: PublicKey | string, shareMint: PublicKey | string): Promise<{
-                      amount: string;
-                      decimals: number | null;
-                  }>;
                   /**
-                   * Deposit funds into a Solana August vault.
-                   * @param depositAmount  `bigint` (raw on-chain units) or `number` (UI amount).
-                   */
-                  vaultDeposit(vaultProgramId: PublicKey | string, idl: any, publicKey: PublicKey | string, depositAmount: number | bigint, sendTransaction: (transaction: Transaction | web3.VersionedTransaction, connection: Connection, options?: SendTransactionOptions) => Promise<web3.TransactionSignature>, vaultAddress?: PublicKey | string): Promise<any>;
-                  /**
-                   * Redeem vault shares from a Solana August vault.
-                   * @param redeemShares  `bigint` (raw share units) or `number` (UI amount).
-                   */
-                  vaultRedeem(vaultProgramId: PublicKey | string, idl: any, publicKey: PublicKey | string, redeemShares: number | bigint, sendTransaction: (transaction: Transaction | web3.VersionedTransaction, connection: Connection, options?: SendTransactionOptions) => Promise<web3.TransactionSignature>, vaultAddress?: PublicKey | string): Promise<any>;
-                  getProgramId(type: 'vault'): string;
-              }
-
-              declare namespace SolanaConstants {
-                  export {
-                      fallbackDecimals,
-                      fallbackNetwork,
-                      fallbackRpcEndpoints,
-                      programIds,
-                      vaultIdl
-                  }
-              }
-
-              declare namespace SolanaGetters {
-                  export {
-                      getSolanaVault
-                  }
-              }
-
-              declare const SOROBAN_RPC_URLS: Record<IStellarNetwork, string>;
-
-              export declare const SPECIAL_CHAINS: {
-                  solana: {
-                      name: string;
-                      chainId: number;
-                      explorer: string;
-                  };
-                  stellar: {
-                      name: string;
-                      chainId: number;
-                      explorer: string;
-                  };
-              };
-
-              export declare const Stellar: {
-                  utils: {
-                      isStellarAddress: isStellarAddress;
-                      getExplorerLink: getExplorerLink;
-                      assertNotStellar: assertNotStellar;
-                  };
-                  constants: typeof StellarConstants;
-                  actions: typeof StellarActions;
-                  submit: typeof StellarSubmit;
-                  getters: typeof StellarGetters;
-              };
-
-              declare const STELLAR_CHAIN: {
-                  name: string;
-                  chainId: number;
-                  explorer: string;
-              };
-
-              declare const STELLAR_CHAIN_ID: number;
-
-              declare const STELLAR_FALLBACK_DECIMALS = 7;
-
-              declare namespace StellarActions {
-                  export {
-                      handleStellarDeposit,
-                      handleStellarRedeem
-                  }
-              }
-
-              /**
-               * Stellar Adapter for August SDK
-               *
-               * @example
-               * ```
-               * const adapter = new StellarAdapter('testnet');
-               * const xdr = await adapter.vaultDeposit({
-               *   contractId: 'CBGWW5...',
-               *   amount: '1000000',
-               *   senderAddress: 'GDLZ...',
-               * });
-               * // Sign xdr with wallet (e.g. Freighter), then submit via adapter.submitTransaction()
-               * ```
-               */
-              export declare class StellarAdapter {
-                  private _network;
-                  /**
-                   * Optional consumer-supplied Soroban RPC endpoint (e.g. a keyed Alchemy URL).
-                   * When set it is the primary, with the SDK's public endpoints as failover.
-                   */
-                  private _sorobanRpcUrl?;
-                  /**
-                   * @param network - Stellar network to operate on; defaults to `'mainnet'`.
-                   * @param options - Optional adapter configuration. Its `sorobanRpcUrl` field
-                   *   overrides the Soroban RPC endpoint (e.g. a keyed Alchemy URL): it becomes
-                   *   the primary with the SDK's built-in public endpoints kept behind it as
-                   *   failover, and a per-call `sorobanRpcUrl` (on the deposit/redeem params)
-                   *   takes precedence over this adapter-level one.
-                   */
-                  constructor(network?: IStellarNetwork, options?: {
-                      sorobanRpcUrl?: string;
-                  });
-                  get network(): IStellarNetwork;
-                  isStellarAddress(address: string): boolean;
-                  getExplorerLink(id: string, type?: 'contract' | 'account' | 'tx'): string;
-                  /**
-                   * Build an unsigned deposit transaction for a Stellar vault.
-                   * @returns Base64-encoded XDR of the unsigned transaction.
-                   */
-                  vaultDeposit(params: Omit<IStellarDepositParams, 'network'>): Promise<string>;
-                  /**
-                   * Build an unsigned redeem transaction for a Stellar vault.
-                   * @returns Base64-encoded XDR of the unsigned transaction.
-                   */
-                  vaultRedeem(params: Omit<IStellarRedeemParams, 'network'>): Promise<string>;
-                  /**
-                   * Submit a signed Soroban transaction and poll until the network confirms it.
+                   * Build an Anchor `Program` bound to this adapter's provider and network.
                    *
-                   * Submits on the network this adapter was constructed with, so `signedXdr`
-                   * must be signed for that same network.
+                   * The program id is resolved as: explicit `programId` → the `address` carried
+                   * by a custom `programIdl` → the canonical deployment for this adapter's
+                   * network. A copy of the SDK's bundled `vaultIdl` defers to the network
+                   * default (its embedded `address` is a build stamp, not network-aware), so
+                   * forwarding it on devnet never silently targets the mainnet program.
                    *
-                   * @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>;
-                       /**
-                        * Get user's vault share balance.
-                        *
-                        * @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.
+                   * @param programIdl - Anchor IDL to bind. Defaults to the SDK's bundled
+                   *   `august_vault` IDL. A custom IDL's `address` is honoured when it differs
+                   *   from the bundled build stamp.
+                   * @param programId - Base58 program id that overrides both the IDL's address
+                   *   and the network default. Use this to target a non-canonical deployment.
+                   * @returns An Anchor `Program` for the resolved program id. No RPC is made —
+                   *   construction is offline.
+                   * @throws {@link AugustValidationError} if no program id can be resolved
+                       *   because this adapter's network has no canonical deployment (e.g.
+                       *   `testnet`) and neither `programId` nor a custom IDL address was supplied.
+                       *
+                       * @example
+                       * ```ts
+                       * // canonical program on the adapter's network
+                       * const program = sdk.solana.getProgram();
+                       *
+                       * // a different deployment, same interface
+                       * const legacy = sdk.solana.getProgram(vaultIdl, '7B8n9vL51b6ibqRAd1adZsi3x3kxtq5NZaondh22Vkyq');
+                       * ```
+                       */
+                   getProgram(programIdl?: any, programId?: string): Program<any>;
+                   getVaultState(vaultProgramId: PublicKey | string, idl: any, vaultAddress?: PublicKey | string): Promise<{
+                       vaultState: unknown | null;
+                       depositMintDecimals: number | null;
+                   }>;
+                   getVaultStateReadOnly(vaultProgramId: PublicKey | string, idl: any, vaultAddress?: PublicKey | string): Promise<{
+                       vaultState: ISolanaVaultState | null;
+                       depositMintDecimals: number | null;
+                   }>;
+                   getToken(mintAddress: string | PublicKey): Promise<{
+                       address: string;
+                       symbol: string;
+                       decimals: number;
+                       name: string;
+                       image: string;
+                   }>;
+                   getTokenSymbol(mintAddress: string | PublicKey): Promise<string>;
+                   fetchUserTokenBalance(publicKey: PublicKey | string, depositMint: PublicKey | string): Promise<any>;
+                   fetchUserShareBalance(publicKey: PublicKey | string, shareMint: PublicKey | string): Promise<any>;
+                   /**
+                    * BigInt-safe variant of {@link fetchUserShareBalance}. Returns the raw u64
+                    * `amount` (as a base-units string) plus the mint's `decimals` (or `null`
+                    * when the scale can't be determined — see Returns), so the caller can
+                    * produce a correct `INormalizedNumber` without losing precision.
+                    *
+                    * Prefer this anywhere the result feeds BigInt math — positions, max-
+                    * actions, redemption sizing, allowance checks. `fetchUserShareBalance`
+                    * returns a JS-number `uiAmount` which silently encodes against 18 decimals
+                    * when passed through `toNormalizedBn(value)` without an explicit decimals
+                    * argument; that's exactly how the jitoSOL "missing position" regression
+                    * manifested.
+                    *
+                    * RPC cost: 1 `getParsedTokenAccountsByOwner` call. Worst case ~150ms on a
+                    * healthy mainnet endpoint.
+                    *
+                    * @param publicKey   Wallet owner (PublicKey or base58 string).
+                    * @param shareMint   The vault's share-token mint (PublicKey or base58).
+                    * @returns
+                    *   `{ amount, decimals }`. Three observable shapes:
+                    *   - `{ amount: '<u64>', decimals: <number> }` — token account exists.
+                    *   - `{ amount: '0', decimals: null }` — no token account for this mint
+                    *     under this wallet, OR `tokenAmount` was missing from the response,
+                    *     OR `publicKey`/`shareMint` was not supplied. Distinguishable from a
+                    *     genuine zero-balance account (`decimals` would be set there).
+                    *   - `{ amount: '0', decimals: null }` — RPC threw (error is logged).
+                    *
+                    *   `decimals === null` means "we could not determine the scale" — callers
+                    *   that need an `INormalizedNumber` must fall back to a known decimals
+                    *   value (typically the deposit mint's decimals from backend metadata)
+                    *   before normalizing. Never throws.
+                    */
+                   fetchUserShareBalanceRaw(publicKey: PublicKey | string, shareMint: PublicKey | string): Promise<{
+                       amount: string;
+                       decimals: number | null;
+                   }>;
+                   /**
+                    * Deposit funds into a Solana August vault.
+                    * @param depositAmount  `bigint` (raw on-chain units) or `number` (UI amount).
+                    */
+                   vaultDeposit(vaultProgramId: PublicKey | string, idl: any, publicKey: PublicKey | string, depositAmount: number | bigint, sendTransaction: (transaction: Transaction | web3.VersionedTransaction, connection: Connection, options?: SendTransactionOptions) => Promise<web3.TransactionSignature>, vaultAddress?: PublicKey | string): Promise<any>;
+                   /**
+                    * Redeem vault shares from a Solana August vault.
+                    * @param redeemShares  `bigint` (raw share units) or `number` (UI amount).
+                    */
+                   vaultRedeem(vaultProgramId: PublicKey | string, idl: any, publicKey: PublicKey | string, redeemShares: number | bigint, sendTransaction: (transaction: Transaction | web3.VersionedTransaction, connection: Connection, options?: SendTransactionOptions) => Promise<web3.TransactionSignature>, vaultAddress?: PublicKey | string): Promise<any>;
+                   /**
+                    * Canonical program id for a program type on this adapter's network.
+                    *
+                    * @param type - Program to look up. Only `'vault'` (august_vault) exists today.
+                    * @returns The base58 program id.
+                    * @throws {@link AugustValidationError} if the canonical program is not
+                        *   deployed on this adapter's network (e.g. `testnet`). Previously an
+                        *   unmapped network threw a bare `TypeError`.
                         */
-                       convertToShares(vaultAddress: string, rawAmount: string): Promise<string | null>;
+                    getProgramId(type: 'vault'): string;
                    }
 
-                   declare namespace StellarConstants {
+                   declare namespace SolanaConstants {
                        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
+                           fallbackDecimals,
+                           fallbackNetwork,
+                           fallbackRpcEndpoints,
+                           getDeployedProgramIds,
+                           programIds,
+                           vaultIdl,
+                           ISolanaDeployedNetwork
                        }
                    }
 
-                   declare namespace StellarGetters {
+                   declare namespace SolanaGetters {
                        export {
-                           getStellarVault,
-                           getStellarUserPosition,
-                           convertToShares
+                           getSolanaVault
                        }
                    }
 
-                   declare namespace StellarSubmit {
+                   declare const SOROBAN_RPC_URLS: Record<IStellarNetwork, string>;
+
+                   export declare const SPECIAL_CHAINS: {
+                       solana: {
+                           name: string;
+                           chainId: number;
+                           explorer: string;
+                       };
+                       stellar: {
+                           name: string;
+                           chainId: number;
+                           explorer: string;
+                       };
+                   };
+
+                   export declare const Stellar: {
+                       utils: {
+                           isStellarAddress: isStellarAddress;
+                           getExplorerLink: getExplorerLink;
+                           assertNotStellar: assertNotStellar;
+                       };
+                       constants: typeof StellarConstants;
+                       actions: typeof StellarActions;
+                       submit: typeof StellarSubmit;
+                       getters: typeof StellarGetters;
+                   };
+
+                   declare const STELLAR_CHAIN: {
+                       name: string;
+                       chainId: number;
+                       explorer: string;
+                   };
+
+                   declare const STELLAR_CHAIN_ID: number;
+
+                   declare const STELLAR_FALLBACK_DECIMALS = 7;
+
+                   declare namespace StellarActions {
                        export {
-                           submitStellarTransaction
+                           handleStellarDeposit,
+                           handleStellarRedeem
                        }
                    }
 
                    /**
-                    * @deprecated
-                    * Replaced by SUBGRAPH_VAULT_URLS which are subgraphs deployed on Goldsky.
+                    * Stellar Adapter for August SDK
+                    *
+                    * @example
+                    * ```
+                    * const adapter = new StellarAdapter('testnet');
+                    * const xdr = await adapter.vaultDeposit({
+                    *   contractId: 'CBGWW5...',
+                    *   amount: '1000000',
+                    *   senderAddress: 'GDLZ...',
+                    * });
+                    * // Sign xdr with wallet (e.g. Freighter), then submit via adapter.submitTransaction()
+                    * ```
                     */
-                   export declare const SUBGRAPH_POOL_URLS: (apiKey: string, chainId?: number, pool?: IAddress) => {
-                       1: string;
-                       8453: string;
-                       43114: string;
-                       42161: string;
-                       56: string;
-                   } | {
-                       999: string;
-                   };
+                   export declare class StellarAdapter {
+                       private _network;
+                       /**
+                        * Optional consumer-supplied Soroban RPC endpoint (e.g. a keyed Alchemy URL).
+                        * When set it is the primary, with the SDK's public endpoints as failover.
+                        */
+                       private _sorobanRpcUrl?;
+                       /**
+                        * @param network - Stellar network to operate on; defaults to `'mainnet'`.
+                        * @param options - Optional adapter configuration. Its `sorobanRpcUrl` field
+                        *   overrides the Soroban RPC endpoint (e.g. a keyed Alchemy URL): it becomes
+                        *   the primary with the SDK's built-in public endpoints kept behind it as
+                        *   failover, and a per-call `sorobanRpcUrl` (on the deposit/redeem params)
+                        *   takes precedence over this adapter-level one.
+                        */
+                       constructor(network?: IStellarNetwork, options?: {
+                           sorobanRpcUrl?: string;
+                       });
+                       get network(): IStellarNetwork;
+                       isStellarAddress(address: string): boolean;
+                       getExplorerLink(id: string, type?: 'contract' | 'account' | 'tx'): string;
+                       /**
+                        * Build an unsigned deposit transaction for a Stellar vault.
+                        * @returns Base64-encoded XDR of the unsigned transaction.
+                        */
+                       vaultDeposit(params: Omit<IStellarDepositParams, 'network'>): Promise<string>;
+                       /**
+                        * Build an unsigned redeem transaction for a Stellar vault.
+                        * @returns Base64-encoded XDR of the unsigned transaction.
+                        */
+                       vaultRedeem(params: Omit<IStellarRedeemParams, 'network'>): Promise<string>;
+                       /**
+                        * Submit a signed Soroban transaction and poll until the network confirms it.
+                        *
+                        * 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>;
+                            /**
+                             * Get user's vault share balance.
+                             *
+                             * @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>;
+                        }
 
-                   /**
-                    * Subgraph URLs
-                    * @deprecated use getVaultMetadata to fetch subgraph URLs from the backend
-                    */
-                   export declare const SUBGRAPH_VAULT_URLS: Record<VaultSymbols, string>;
+                        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
+                            }
+                        }
 
-                   /**
-                    * Submit a signed Soroban transaction and poll until confirmed.
-                    *
-                    * @param signedXdr - Base64-encoded XDR of the signed transaction
-                    * @param network - Stellar network name
-                    * @param sorobanRpcUrl - Optional override Soroban RPC endpoint (e.g. a keyed
-                    *   Alchemy URL); becomes the primary with the SDK's public endpoints kept as
-                    *   failover. Omit to use the public endpoints.
-                    * @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, sorobanRpcUrl?: string): Promise<string>;
+                        declare namespace StellarGetters {
+                            export {
+                                getStellarVault,
+                                getStellarUserPosition,
+                                convertToShares
+                            }
+                        }
 
-                        /**
-                         * 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[];
+                        declare namespace StellarSubmit {
+                            export {
+                                submitStellarTransaction
+                            }
                         }
 
                         /**
-                         * 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.
+                         * @deprecated
+                         * Replaced by SUBGRAPH_VAULT_URLS which are subgraphs deployed on Goldsky.
                          */
-                        export declare const SWAP_ROUTER_ADDRESSES: Readonly<Record<number, IAddress>>;
+                        export declare const SUBGRAPH_POOL_URLS: (apiKey: string, chainId?: number, pool?: IAddress) => {
+                            1: string;
+                            8453: string;
+                            43114: string;
+                            42161: string;
+                            56: string;
+                        } | {
+                            999: string;
+                        };
 
                         /**
-                         * Block at which each chain's `SwapRouter` was deployed/configured — the safe
-                         * lower bound for scanning its `TokenEnabled` / `VaultEnabled` log history.
-                         *
-                         * The router stores its allowlist as `mapping(address => bool) whitelistedTokens`
-                         * with no on-chain enumeration, so {@link getSwapRouterWhitelistedTokens} must
-                         * reconstruct the candidate set from `TokenEnabled` events before verifying each
-                         * against the current mapping. Starting the `eth_getLogs` scan here (rather than
-                         * from genesis) bounds it to the router's own lifetime — a few chunks — instead
-                         * of the whole chain.
-                         *
-                         * Mainnet value is the router's deployment block (its first emitted event, the
-                         * constructor `OwnershipTransferred`). A too-low value only costs extra empty
-                         * log ranges; a value ABOVE the first `TokenEnabled` would silently miss tokens,
-                         * so err on the side of earlier.
+                         * Subgraph URLs
+                         * @deprecated use getVaultMetadata to fetch subgraph URLs from the backend
                          */
-                        export declare const SWAP_ROUTER_DEPLOY_BLOCKS: Readonly<Record<number, number>>;
+                        export declare const SUBGRAPH_VAULT_URLS: Record<VaultSymbols, string>;
 
                         /**
-                         * 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.
+                         * Submit a signed Soroban transaction and poll until confirmed.
                          *
-                         * `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}`;
-                            /** Human-readable aggregator name — for display; never derive routing logic from it. */
-                            name: string;
-                        }>>;
+                         * @param signedXdr - Base64-encoded XDR of the signed transaction
+                         * @param network - Stellar network name
+                         * @param sorobanRpcUrl - Optional override Soroban RPC endpoint (e.g. a keyed
+                         *   Alchemy URL); becomes the primary with the SDK's public endpoints kept as
+                         *   failover. Omit to use the public endpoints.
+                         * @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, sorobanRpcUrl?: string): Promise<string>;
 
-                        /**
-                         * Vaults whose UI **may offer the any-token SwapRouter deposit surface** —
-                         * i.e. the SwapRouter is `enableVault`-ed for them on-chain.
-                         *
-                         * This is *eligibility metadata only*. It is consumed by:
-                         *  - the app UI, to decide whether to render the (flag-gated) swap-router
-                         *    deposit surface for a vault; and
-                         *  - {@link swapRouterDeposit}, optionally, as a fail-fast eligibility check.
-                         *
-                         * It is deliberately **NOT** read by {@link vaultDeposit}: `vaultDeposit` is the
-                         * native/multiasset/adapter path and never routes through the SwapRouter. That
-                         * separation is what stops a natively-accepted asset from being silently
-                         * swapped — the regression that implicit auto-routing caused. Any-token swap
-                         * deposits are the explicit, opt-in job of {@link swapRouterDeposit}.
-                         *
-                         * Membership requires the vault to be registered on-chain
-                         * (`vaultInfo[addr].referenceAsset != 0`) — an unregistered vault reverts with
-                         * `InvalidVault` at deposit time. A listed vault's natively-accepted assets
-                         * (for a multi-asset vault, its whole deposit-asset set) still deposit via
-                         * `vaultDeposit`; only tokens OUTSIDE that set go through `swapRouterDeposit`.
-                         *
-                         * Lowercase comparison is required when checking — use
-                         * {@link isSwapRouterEligible} rather than reading this set directly.
-                         *
-                         * @deprecated Superseded by {@link getSwapRouterEligibleVaults}, which derives
-                         * the eligible set from the router's on-chain `VaultEnabled` history and
-                         * verifies each vault's current registration (`vaultInfo.referenceAsset != 0`)
-                         * — so new enablements surface without an SDK release. This static set stays
-                         * functional as the zero-RPC fallback seed (e.g. TanStack Query `initialData`)
-                         * and for SDK-internal sync consumers.
-                         */
-                        export declare const SWAP_ROUTER_ELIGIBLE_VAULTS: ReadonlySet<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[];
+                             }
 
-                        /**
-                         * 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;
+                             /**
+                              * Sum a wallet's per-asset deposits into the vault's own decimals, at face
+                              * value — 1 unit of any deposited asset is treated as 1 unit of the vault's
+                              * reporting currency, with no live price conversion.
+                              *
+                              * Used by {@link getVaultUserLifetimePnl} for `totalDeposited`. Pre-deposit
+                              * multi-asset vaults only accept dollar-pegged stablecoins (USDC, USDT, DAI,
+                              * USDS, RLUSD, etc.) into a dollar-denominated vault, so face value is a
+                              * reasonable stand-in for USD value. This intentionally does NOT re-quote
+                              * through a live price oracle: doing so priced a historical deposit at
+                              * today's market rate, so `totalDeposited` (and lifetimePnl) drifted between
+                              * calls purely from stablecoin peg noise, and approximately re-inflated
+                              * deposits back toward face value — which silently excluded the vault's
+                              * entry fee from PnL. The fee is money the user actually paid, so PnL must
+                              * be computed net of it.
+                              *
+                              * @param depositsByAsset - Raw deposited amount per asset, keyed by
+                              *   lowercased asset address (or `'default'` / `'lz-default'` for
+                              *   single-asset / cross-chain rows).
+                              * @param assetDecimals - Decimals for each key in `depositsByAsset`.
+                              * @param vaultDecimals - The vault's own decimals — the target scale every
+                              *   asset is rescaled to.
+                              * @returns Total deposited, in raw base units at `vaultDecimals`.
+                              */
+                             export declare function sumDepositsAtFaceValue(depositsByAsset: Map<string, bigint>, assetDecimals: Map<string, number>, vaultDecimals: number): bigint;
 
-                        /**
-                         * Human-readable display name of the `SwapRouter` periphery contract on each
-                         * supported chain.
-                         *
-                         * The contract exposes no on-chain name (no `@title` accessor), so UIs that
-                         * want to show *which contract* performed the swap-and-deposit — rather than a
-                         * bare address — read it from here. Display metadata only: never derive
-                         * routing or eligibility logic from it.
-                         *
-                         * Missing keys mean no SwapRouter is deployed on that chain.
-                         *
-                         * @see {@link getSwapRouterName} for the typed lookup helper.
-                         */
-                        export declare const SWAP_ROUTER_NAMES: Readonly<Record<number, string>>;
+                             /**
+                              * 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>>;
 
-                        /**
-                         * 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>>;
+                             /**
+                              * Block at which each chain's `SwapRouter` was deployed/configured — the safe
+                              * lower bound for scanning its `TokenEnabled` / `VaultEnabled` log history.
+                              *
+                              * The router stores its allowlist as `mapping(address => bool) whitelistedTokens`
+                              * with no on-chain enumeration, so {@link getSwapRouterWhitelistedTokens} must
+                              * reconstruct the candidate set from `TokenEnabled` events before verifying each
+                              * against the current mapping. Starting the `eth_getLogs` scan here (rather than
+                              * from genesis) bounds it to the router's own lifetime — a few chunks — instead
+                              * of the whole chain.
+                              *
+                              * Mainnet value is the router's deployment block (its first emitted event, the
+                              * constructor `OwnershipTransferred`). A too-low value only costs extra empty
+                              * log ranges; a value ABOVE the first `TokenEnabled` would silently miss tokens,
+                              * so err on the side of earlier.
+                              */
+                             export declare const SWAP_ROUTER_DEPLOY_BLOCKS: Readonly<Record<number, number>>;
 
-                        /**
-                         * 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>;
+                             /**
+                              * 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}`;
+                                 /** Human-readable aggregator name — for display; never derive routing logic from it. */
+                                 name: string;
+                             }>>;
 
                              /**
-                              * Deposit into an August vault through the on-chain `SwapRouter`, selecting the
-                              * correct router path from the deposit asset. This is the high-level, explicit
-                              * counterpart to the SwapRouter branch inside {@link vaultDeposit}.
+                              * Vaults whose UI **may offer the any-token SwapRouter deposit surface** —
+                              * i.e. the SwapRouter is `enableVault`-ed for them on-chain.
                               *
-                              * Where `vaultDeposit` decides whether to use the SwapRouter from the
-                              * `VAULTS_USING_SWAP_ROUTER` allowlist, this function always routes through the
-                              * SwapRouter because the caller asked it to. Making the intent explicit is the
-                              * point: a native-deposit vault (e.g. a multi-asset Tokenized Vault V2 whose
-                              * non-reference assets are accepted directly) is never accidentally swapped —
-                              * the regression that implicit, allowlist-driven routing caused. Use
-                              * `vaultDeposit` for native / adapter deposits and this for SwapRouter deposits.
+                              * This is *eligibility metadata only*. It is consumed by:
+                              *  - the app UI, to decide whether to render the (flag-gated) swap-router
+                              *    deposit surface for a vault; and
+                              *  - {@link swapRouterDeposit}, optionally, as a fail-fast eligibility check.
                               *
-                              * The vault's reference asset and its decimals are read on-chain (never trusted
-                              * from the caller — a wrong reference asset would mis-route the swap). The path
-                              * is then chosen from `depositAsset`:
-                              *  - equals the reference asset → direct router deposit, no swap
-                              *    ({@link depositViaSwapRouter});
-                              *  - the zero address → native-token deposit ({@link depositNativeViaSwapRouter}),
-                              *    valid only when the reference asset is the chain's wrapped-native token;
-                              *  - any other ERC-20 → a swap to the reference asset (Paraswap quote pinned to
-                              *    the chain's whitelisted aggregator, fail-closed on router/selector drift)
-                              *    bundled into {@link swapAndDeposit}.
+                              * It is deliberately **NOT** read by {@link vaultDeposit}: `vaultDeposit` is the
+                              * native/multiasset/adapter path and never routes through the SwapRouter. That
+                              * separation is what stops a natively-accepted asset from being silently
+                              * swapped — the regression that implicit auto-routing caused. Any-token swap
+                              * deposits are the explicit, opt-in job of {@link swapRouterDeposit}.
                               *
-                              * Side effects: reads tokenized-vault metadata, the vault's reference asset and
-                              * decimals, and (on the swap path) one Paraswap quote; sends one ERC-20
-                              * `approve` to the SwapRouter when allowance is short, then the deposit tx.
+                              * Membership requires the vault to be registered on-chain
+                              * (`vaultInfo[addr].referenceAsset != 0`) — an unregistered vault reverts with
+                              * `InvalidVault` at deposit time. A listed vault's natively-accepted assets
+                              * (for a multi-asset vault, its whole deposit-asset set) still deposit via
+                              * `vaultDeposit`; only tokens OUTSIDE that set go through `swapRouterDeposit`.
                               *
-                              * @param signer - ethers `Signer` or `Wallet` that signs the approval + deposit.
-                              * @param options - {@link ISwapRouterDepositOptions}.
-                              * @returns The transaction hash of the router deposit call.
-                              * @throws {@link AugustValidationError} for an unsupported chain (no SwapRouter
-                                  *   deployment), an invalid vault or deposit-asset address, a missing or zero
-                                  *   amount, a native deposit into a non-wrapped-native vault, or drift between
-                                  *   the aggregator quote and the on-chain router whitelist.
-                                  * @worstCaseRpcCalls 5 on the swap path — tokenized-vault metadata, reference
-                                  *   asset + decimals, deposit-token decimals, the quote, and the allowance read.
-                                  * @example
-                                  * ```ts
-                                  * // USDT deposited into a USDC-reference vault → swapped to USDC en route.
-                                  * const hash = await augustSdk.evm.swapRouterDeposit({
-                                  *   chainId: 1,
-                                  *   vault: '0xe9b725010a9e419412ed67d0fa5f3a5f40159d32',
-                                  *   depositAsset: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
-                                  *   amount: '100',
-                                  *   slippageBps: 50,
-                                  * });
-                                  * ```
-                                  */
-                              export declare function swapRouterDeposit(signer: Signer | Wallet, options: ISwapRouterDepositOptions): 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>;
+                              * Lowercase comparison is required when checking — use
+                              * {@link isSwapRouterEligible} rather than reading this set directly.
+                              *
+                              * @deprecated Superseded by {@link getSwapRouterEligibleVaults}, which derives
+                              * the eligible set from the router's on-chain `VaultEnabled` history and
+                              * verifies each vault's current registration (`vaultInfo.referenceAsset != 0`)
+                              * — so new enablements surface without an SDK release. This static set stays
+                              * functional as the zero-RPC fallback seed (e.g. TanStack Query `initialData`)
+                              * and for SDK-internal sync consumers.
+                              */
+                             export declare const SWAP_ROUTER_ELIGIBLE_VAULTS: ReadonlySet<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;
+
+                             /**
+                              * Human-readable display name of the `SwapRouter` periphery contract on each
+                              * supported chain.
+                              *
+                              * The contract exposes no on-chain name (no `@title` accessor), so UIs that
+                              * want to show *which contract* performed the swap-and-deposit — rather than a
+                              * bare address — read it from here. Display metadata only: never derive
+                              * routing or eligibility logic from it.
+                              *
+                              * Missing keys mean no SwapRouter is deployed on that chain.
+                              *
+                              * @see {@link getSwapRouterName} for the typed lookup helper.
+                              */
+                             export declare const SWAP_ROUTER_NAMES: Readonly<Record<number, string>>;
+
+                             /**
+                              * 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>;
+
                                   /**
-                                   * Call the contract method with %%args%% and return the value.
+                                   * Deposit into an August vault through the on-chain `SwapRouter`, selecting the
+                                   * correct router path from the deposit asset. This is the high-level, explicit
+                                   * counterpart to the SwapRouter branch inside {@link vaultDeposit}.
                                    *
-                                   * 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;
-                                  };
-                                  MonarqXRP: {
-                                      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>;
-
-                              /**
-                               * @deprecated Renamed to {@link SWAP_ROUTER_ELIGIBLE_VAULTS} (itself now
-                               * superseded by {@link getSwapRouterEligibleVaults}, the on-chain-derived
-                               * resolver), and the semantics changed: this set no longer drives
-                               * `vaultDeposit` auto-routing (that branch was removed) — it only marks vaults
-                               * whose UI may offer the swap-router deposit surface. Kept as an alias for one
-                               * release; migrate to the async resolver.
-                               */
-                              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';
-
-                              /**
-                               * @deprecated Renamed to {@link isSwapRouterEligible} (itself now superseded by
-                               * {@link getSwapRouterEligibleVaults}, the on-chain-derived resolver). The
-                               * meaning also changed: it no longer implies `vaultDeposit` routes the vault
-                               * through the SwapRouter (that behavior was removed) — it only reports
-                               * swap-router *eligibility* for the opt-in deposit surface. Kept as an alias
-                               * for one release; migrate to the async resolver.
-                               */
-                              export declare const vaultUsesSwapRouter: typeof isSwapRouterEligible;
-
-                              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: {
-                                      list: (offset?: number, limit?: number) => string;
-                                      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;
-                                      loanByAddress: (loanAddress: string, chainId: number) => string;
-                                      _: (subaccount: IAddress) => string;
-                                  };
-                                  transactions: {
-                                      v2: (subaccount: string, startTime?: string, endTime?: string) => string;
-                                  };
-                                  otc: {
-                                      positions: string;
-                                      marginRequirements: (otcCounterpartyId?: string, payer?: string) => string;
-                                  };
-                                  curator: {
-                                      vaultSubaccounts: (vaultAddress: string) => string;
-                                      vaultWhitelist: (vaultAddress: string) => string;
-                                  };
-                                  timelockRequests: (vaultAddress: string, chainId: number, status?: string) => string;
-                                  users: {
-                                      get: string;
-                                  };
-                                  dashboard: {
-                                      loans: string;
-                                  };
-                                  risk: {
-                                      discountFactors: string;
-                                      collateralExcessOrDeficit: (subaccount: string, tokenAddress: string, tokenChain: number, targetHealthFactor?: number) => string;
-                                      collateralSimulation: string;
-                                  };
-                                  prices: (symbol: string) => string;
-                                  metrics: {
-                                      pnl: (subaccount: IAddress, startTime?: string, endTime?: string) => string;
-                                      vaultPerformanceFees: (params: {
-                                          vaultAddress: string;
-                                          annualizedFeesPct: number;
-                                          nativeDenominated: boolean;
-                                          calculationPeriod: string;
-                                          startDate?: string;
-                                          endDate?: 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;
-                                      };
-                                      revertReason: (txHash: string, chain: number) => string;
-                                      oracleClassification: (vaultAddress: string, chainId: number) => 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 { }
+                                   * Where `vaultDeposit` decides whether to use the SwapRouter from the
+                                   * `VAULTS_USING_SWAP_ROUTER` allowlist, this function always routes through the
+                                   * SwapRouter because the caller asked it to. Making the intent explicit is the
+                                   * point: a native-deposit vault (e.g. a multi-asset Tokenized Vault V2 whose
+                                   * non-reference assets are accepted directly) is never accidentally swapped —
+                                   * the regression that implicit, allowlist-driven routing caused. Use
+                                   * `vaultDeposit` for native / adapter deposits and this for SwapRouter deposits.
+                                   *
+                                   * The vault's reference asset and its decimals are read on-chain (never trusted
+                                   * from the caller — a wrong reference asset would mis-route the swap). The path
+                                   * is then chosen from `depositAsset`:
+                                   *  - equals the reference asset → direct router deposit, no swap
+                                   *    ({@link depositViaSwapRouter});
+                                   *  - the zero address → native-token deposit ({@link depositNativeViaSwapRouter}),
+                                   *    valid only when the reference asset is the chain's wrapped-native token;
+                                   *  - any other ERC-20 → a swap to the reference asset (Paraswap quote pinned to
+                                   *    the chain's whitelisted aggregator, fail-closed on router/selector drift)
+                                   *    bundled into {@link swapAndDeposit}.
+                                   *
+                                   * Side effects: reads tokenized-vault metadata, the vault's reference asset and
+                                   * decimals, and (on the swap path) one Paraswap quote; sends one ERC-20
+                                   * `approve` to the SwapRouter when allowance is short, then the deposit tx.
+                                   *
+                                   * @param signer - ethers `Signer` or `Wallet` that signs the approval + deposit.
+                                   * @param options - {@link ISwapRouterDepositOptions}.
+                                   * @returns The transaction hash of the router deposit call.
+                                   * @throws {@link AugustValidationError} for an unsupported chain (no SwapRouter
+                                       *   deployment), an invalid vault or deposit-asset address, a missing or zero
+                                       *   amount, a native deposit into a non-wrapped-native vault, or drift between
+                                       *   the aggregator quote and the on-chain router whitelist.
+                                       * @worstCaseRpcCalls 5 on the swap path — tokenized-vault metadata, reference
+                                       *   asset + decimals, deposit-token decimals, the quote, and the allowance read.
+                                       * @example
+                                       * ```ts
+                                       * // USDT deposited into a USDC-reference vault → swapped to USDC en route.
+                                       * const hash = await augustSdk.evm.swapRouterDeposit({
+                                       *   chainId: 1,
+                                       *   vault: '0xe9b725010a9e419412ed67d0fa5f3a5f40159d32',
+                                       *   depositAsset: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
+                                       *   amount: '100',
+                                       *   slippageBps: 50,
+                                       * });
+                                       * ```
+                                       */
+                                   export declare function swapRouterDeposit(signer: Signer | Wallet, options: ISwapRouterDepositOptions): 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;
+                                       };
+                                       MonarqXRP: {
+                                           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;
+
+                                   /**
+                                    * august_vault program IDL (Anchor).
+                                    *
+                                    * GENERATED — do not edit by hand. The versioned multi-vault interface the SDK
+                                    * targets, generated from the devnet on-chain IDL of `C8B1…` — the only
+                                    * deployment that publishes one matching this file. Refresh with
+                                    * `anchor idl fetch C8B1… -u devnet`.
+                                    *
+                                    * At runtime the SDK targets the canonical `up12…` instead, whose own published
+                                    * IDL is STALE (an Anchor IDL upload is not refreshed by a program upgrade), so
+                                    * it can't be used as the generation source. The solana-idl-drift check (CI)
+                                    * therefore validates `up12…` by pinning its deployed binary and by decoding
+                                    * live VaultState accounts against this file — see
+                                    * tests/vaults/solana-idl-drift.test.ts.
+                                    *
+                                    * `address` is a build stamp (the mainnet id), NOT network-aware. Never rely on
+                                    * it: SolanaAdapter/getProgram resolve the real program id per network from
+                                    * programIds, or from an explicit `programId` override.
+                                    */
+                                   declare const vaultIdl: {
+                                       accounts: {
+                                           discriminator: number[];
+                                           name: string;
+                                       }[];
+                                       address: string;
+                                       errors: {
+                                           code: number;
+                                           msg: string;
+                                           name: string;
+                                       }[];
+                                       events: {
+                                           discriminator: number[];
+                                           name: string;
+                                       }[];
+                                       instructions: ({
+                                           accounts: ({
+                                               name: string;
+                                               signer: boolean;
+                                               writable: boolean;
+                                               docs?: undefined;
+                                               pda?: undefined;
+                                               address?: undefined;
+                                           } | {
+                                               docs: string[];
+                                               name: string;
+                                               signer: boolean;
+                                               writable: boolean;
+                                               pda?: undefined;
+                                               address?: undefined;
+                                           } | {
+                                               docs: string[];
+                                               name: string;
+                                               writable: boolean;
+                                               signer?: undefined;
+                                               pda?: undefined;
+                                               address?: undefined;
+                                           } | {
+                                               docs: string[];
+                                               name: string;
+                                               signer?: undefined;
+                                               writable?: undefined;
+                                               pda?: undefined;
+                                               address?: undefined;
+                                           } | {
+                                               name: string;
+                                               pda: {
+                                                   program: {
+                                                       kind: string;
+                                                       value: number[];
+                                                   };
+                                                   seeds: ({
+                                                       kind: string;
+                                                       value: number[];
+                                                       path?: undefined;
+                                                   } | {
+                                                       kind: string;
+                                                       path: string;
+                                                       value?: undefined;
+                                                   })[];
+                                               };
+                                               writable: boolean;
+                                               signer?: undefined;
+                                               docs?: undefined;
+                                               address?: undefined;
+                                           } | {
+                                               address: string;
+                                               name: string;
+                                               signer?: undefined;
+                                               writable?: undefined;
+                                               docs?: undefined;
+                                               pda?: undefined;
+                                           })[];
+                                           args: {
+                                               name: string;
+                                               type: string;
+                                           }[];
+                                           discriminator: number[];
+                                           docs: string[];
+                                           name: string;
+                                       } | {
+                                           accounts: ({
+                                               name: string;
+                                               writable: boolean;
+                                               signer?: undefined;
+                                               address?: undefined;
+                                           } | {
+                                               name: string;
+                                               writable?: undefined;
+                                               signer?: undefined;
+                                               address?: undefined;
+                                           } | {
+                                               name: string;
+                                               signer: boolean;
+                                               writable?: undefined;
+                                               address?: undefined;
+                                           } | {
+                                               name: string;
+                                               signer: boolean;
+                                               writable: boolean;
+                                               address?: undefined;
+                                           } | {
+                                               address: string;
+                                               name: string;
+                                               writable?: undefined;
+                                               signer?: undefined;
+                                           })[];
+                                           args: {
+                                               name: string;
+                                               type: string;
+                                           }[];
+                                           discriminator: number[];
+                                           docs: string[];
+                                           name: string;
+                                       } | {
+                                           accounts: ({
+                                               name: string;
+                                               writable: boolean;
+                                               pda?: undefined;
+                                               signer?: undefined;
+                                           } | {
+                                               name: string;
+                                               pda: {
+                                                   program: {
+                                                       kind: string;
+                                                       value: number[];
+                                                   };
+                                                   seeds: ({
+                                                       kind: string;
+                                                       path: string;
+                                                       value?: undefined;
+                                                   } | {
+                                                       kind: string;
+                                                       value: number[];
+                                                       path?: undefined;
+                                                   })[];
+                                               };
+                                               writable: boolean;
+                                               signer?: undefined;
+                                           } | {
+                                               name: string;
+                                               signer: boolean;
+                                               writable?: undefined;
+                                               pda?: undefined;
+                                           } | {
+                                               name: string;
+                                               writable?: undefined;
+                                               pda?: undefined;
+                                               signer?: undefined;
+                                           })[];
+                                           args: {
+                                               name: string;
+                                               type: string;
+                                           }[];
+                                           discriminator: number[];
+                                           docs: string[];
+                                           name: string;
+                                       } | {
+                                           accounts: ({
+                                               docs: string[];
+                                               name: string;
+                                               signer: boolean;
+                                               writable?: undefined;
+                                               pda?: undefined;
+                                               address?: undefined;
+                                           } | {
+                                               docs: string[];
+                                               name: string;
+                                               writable: boolean;
+                                               signer?: undefined;
+                                               pda?: undefined;
+                                               address?: undefined;
+                                           } | {
+                                               docs: string[];
+                                               name: string;
+                                               signer?: undefined;
+                                               writable?: undefined;
+                                               pda?: undefined;
+                                               address?: undefined;
+                                           } | {
+                                               name: string;
+                                               pda: {
+                                                   program: {
+                                                       kind: string;
+                                                       value: number[];
+                                                   };
+                                                   seeds: ({
+                                                       kind: string;
+                                                       value: number[];
+                                                       path?: undefined;
+                                                   } | {
+                                                       kind: string;
+                                                       path: string;
+                                                       value?: undefined;
+                                                   })[];
+                                               };
+                                               writable: boolean;
+                                               docs?: undefined;
+                                               signer?: undefined;
+                                               address?: undefined;
+                                           } | {
+                                               address: string;
+                                               name: string;
+                                               docs?: undefined;
+                                               signer?: undefined;
+                                               writable?: undefined;
+                                               pda?: undefined;
+                                           })[];
+                                           args: {
+                                               name: string;
+                                               type: string;
+                                           }[];
+                                           discriminator: number[];
+                                           docs: string[];
+                                           name: string;
+                                       })[];
+                                       metadata: {
+                                           description: string;
+                                           name: string;
+                                           spec: string;
+                                           version: string;
+                                       };
+                                       types: ({
+                                           name: string;
+                                           repr: {
+                                               kind: string;
+                                           };
+                                           serialization: string;
+                                           type: {
+                                               fields: {
+                                                   name: string;
+                                                   type: string;
+                                               }[];
+                                               kind: string;
+                                           };
+                                       } | {
+                                           name: string;
+                                           type: {
+                                               fields: ({
+                                                   name: string;
+                                                   type: string;
+                                               } | {
+                                                   name: string;
+                                                   type: {
+                                                       array: (string | number)[];
+                                                   };
+                                               })[];
+                                               kind: string;
+                                           };
+                                           repr?: undefined;
+                                           serialization?: 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>;
+
+                                   /**
+                                    * @deprecated Renamed to {@link SWAP_ROUTER_ELIGIBLE_VAULTS} (itself now
+                                    * superseded by {@link getSwapRouterEligibleVaults}, the on-chain-derived
+                                    * resolver), and the semantics changed: this set no longer drives
+                                    * `vaultDeposit` auto-routing (that branch was removed) — it only marks vaults
+                                    * whose UI may offer the swap-router deposit surface. Kept as an alias for one
+                                    * release; migrate to the async resolver.
+                                    */
+                                   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';
+
+                                   /**
+                                    * @deprecated Renamed to {@link isSwapRouterEligible} (itself now superseded by
+                                    * {@link getSwapRouterEligibleVaults}, the on-chain-derived resolver). The
+                                    * meaning also changed: it no longer implies `vaultDeposit` routes the vault
+                                    * through the SwapRouter (that behavior was removed) — it only reports
+                                    * swap-router *eligibility* for the opt-in deposit surface. Kept as an alias
+                                    * for one release; migrate to the async resolver.
+                                    */
+                                   export declare const vaultUsesSwapRouter: typeof isSwapRouterEligible;
+
+                                   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: {
+                                           list: (offset?: number, limit?: number) => string;
+                                           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;
+                                           loanByAddress: (loanAddress: string, chainId: number) => string;
+                                           _: (subaccount: IAddress) => string;
+                                       };
+                                       transactions: {
+                                           v2: (subaccount: string, startTime?: string, endTime?: string) => string;
+                                       };
+                                       otc: {
+                                           positions: string;
+                                           marginRequirements: (otcCounterpartyId?: string, payer?: string) => string;
+                                       };
+                                       curator: {
+                                           vaultSubaccounts: (vaultAddress: string) => string;
+                                           vaultWhitelist: (vaultAddress: string) => string;
+                                       };
+                                       timelockRequests: (vaultAddress: string, chainId: number, status?: string) => string;
+                                       users: {
+                                           get: string;
+                                       };
+                                       dashboard: {
+                                           loans: string;
+                                       };
+                                       risk: {
+                                           discountFactors: string;
+                                           collateralExcessOrDeficit: (subaccount: string, tokenAddress: string, tokenChain: number, targetHealthFactor?: number) => string;
+                                           collateralSimulation: string;
+                                       };
+                                       prices: (symbol: string) => string;
+                                       metrics: {
+                                           pnl: (subaccount: IAddress, startTime?: string, endTime?: string) => string;
+                                           vaultPerformanceFees: (params: {
+                                               vaultAddress: string;
+                                               annualizedFeesPct: number;
+                                               nativeDenominated: boolean;
+                                               calculationPeriod: string;
+                                               startDate?: string;
+                                               endDate?: 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;
+                                           };
+                                           revertReason: (txHash: string, chain: number) => string;
+                                           oracleClassification: (vaultAddress: string, chainId: number) => 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 { }