@augustdigital/sdk 8.6.0 → 8.7.0

package/lib/sdk.d.ts

@@ -15485,6 +15485,32 @@ declare class AugustSDK extends AugustBase {
         timestamp: number;
         transactionHash: string;
     }[]>;
+    /**
+     * Get a vault's deposit/withdrawal activity across every participant.
+     *
+     * The vault-wide counterpart to {@link AugustSDK.getVaultUserHistory} — use
+     * it to answer flow questions ("how many deposits in the last 7 days", "net
+     * flow this week") that point-in-time TVL cannot. Reads from the Goldsky
+     * subgraph, paginated so busy vaults are not truncated; a `sinceTs` window
+     * keeps short lookbacks cheap.
+     * @param props - Vault address, optional chain id, optional `sinceTs`/`untilTs`
+     * Unix-second bounds, and an optional `types` filter.
+     * @returns Array of activity items (oldest-first) with normalized amounts,
+     * actor addresses, event type, and transaction hashes.
+     * @throws If `vault` is not a valid address or no chain id can be resolved.
+     * @example
+     * ```ts
+     * const weekAgo = Math.floor(Date.now() / 1000) - 7 * 86_400;
+     * const items = await sdk.getVaultActivity({ vault, chainId: 143, sinceTs: weekAgo });
+     * ```
+     */
+    getVaultActivity(props: {
+        vault: IAddress;
+        chainId?: IChainId;
+        sinceTs?: number;
+        untilTs?: number;
+        types?: ('withdraw-request' | 'deposit' | 'withdraw-processed' | 'redeem')[];
+    }): Promise<IVaultUserHistoryItem[]>;
     /**
      * Get lifetime PnL for a user in a specific vault.
      * Calculates realized and unrealized PnL based on deposit/withdrawal history and current position.
@@ -16110,6 +16136,52 @@ export declare class AugustVaults extends AugustBase {
         timestamp: number;
         transactionHash: string;
     }[]>;
+    /**
+     * Fetch a vault's deposit/withdrawal activity across every participant.
+     *
+     * This is the vault-wide counterpart to {@link getUserHistory}: instead of
+     * filtering the subgraph to one wallet, it returns every deposit,
+     * withdrawal-request, and processed-withdrawal event for the pool. Use it to
+     * answer flow questions ("how many deposits in the last 7 days", "net flow
+     * this week") that point-in-time TVL cannot.
+     *
+     * Rows are read from the Goldsky subgraph, paginated internally so busy
+     * vaults are not truncated at the 1000-row page cap. When `sinceTs` is
+     * supplied the reader stops paging once it passes the window boundary, so a
+     * short lookback stays cheap even on high-volume vaults.
+     *
+     * @param params - Query parameters.
+     * @param params.vault - Vault (pool) address to read activity for.
+     * @param params.chainId - Chain id of the vault; falls back to the active
+     * network when omitted. Required for the subgraph lookup.
+     * @param params.sinceTs - Lower bound (inclusive) as a Unix timestamp in
+     * seconds. Events at or after this time are returned.
+     * @param params.untilTs - Upper bound (inclusive) as a Unix timestamp in
+     * seconds. Events at or before this time are returned.
+     * @param params.types - Restrict to a subset of event types (e.g.
+     * `['deposit']`). Returns all types when omitted.
+     * @returns Activity items sorted oldest-first, each with a normalized
+     * `amount`, actor `address`, `type`, and `transactionHash`.
+     * @throws If `vault` is not a valid address, or no chain id can be resolved.
+     * @example
+     * ```ts
+     * const weekAgo = Math.floor(Date.now() / 1000) - 7 * 86_400;
+     * const deposits = await sdk.getVaultActivity({
+     *   vault: '0x36eDbF0C834591BFdfCaC0Ef9605528c75c406aA',
+     *   chainId: 143,
+     *   sinceTs: weekAgo,
+     *   types: ['deposit'],
+     * });
+     * console.log(`${deposits.length} deposits in the last 7 days`);
+     * ```
+     */
+    getVaultActivity({ vault, chainId, sinceTs, untilTs, types, }: {
+        vault: IAddress;
+        chainId?: IChainId;
+        sinceTs?: number;
+        untilTs?: number;
+        types?: IVaultUserHistoryItem['type'][];
+    }): Promise<IVaultUserHistoryItem[]>;
     /**
      * @function getStakingPositions gets all available reward staking positions
      * @param wallet optionally passed user wallet address
@@ -16692,6 +16764,25 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
       */
   export declare function depositViaSwapRouter(signer: Signer | Wallet, options: ISwapRouterDirectDepositOptions): Promise<string>;
 
+  /**
+   * Extract a human- and machine-readable reason from a thrown Solana/Anchor
+   * error.
+   *
+   * Anchor's {@link https://github.com/coral-xyz/anchor `ProgramError`} calls
+   * `super()` with no argument, so its `.message` is the empty string by
+   * construction — the real reason lives on `.msg`/`.code` (and `.toString()`).
+   * `AnchorError` puts it on `.error.errorMessage` / `.error.errorCode.number`.
+   * Reading `.message` directly (as this file used to) therefore rendered
+   * `"Solana deposit failed: "` for every recognized on-chain revert — dropping
+   * the numeric code the team needs to tell "Vault is paused" from
+   * "Insufficient amount" from an account-constraint violation.
+   *
+   * When no reason can be extracted, returns an actionable, user-facing fallback
+   * rather than an "unknown error" admission — the raw throwable is still
+   * preserved on the wrapped error's `cause` and in telemetry for diagnosis.
+   */
+  declare function describeSolanaError(e: unknown): string;
+
   /**
    * Get maximum block range for historical queries per chain.
    * Prevents RPC timeouts by limiting lookback window.
@@ -16914,6 +17005,29 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
        * @returns The transaction hash of the `depositNativeToken` call.
        */
       depositNativeViaSwapRouter(options: ISwapRouterNativeDepositOptions): Promise<string>;
+      /**
+       * Deposit into a vault through the on-chain `SwapRouter`, choosing the router
+       * path from `depositAsset` (direct deposit, native wrap, or a swap to the
+       * reference asset). The high-level, explicit counterpart to the SwapRouter
+       * branch inside {@link vaultDeposit} — the caller opts into the router
+       * deliberately, so a native-deposit vault is never accidentally swapped.
+       *
+       * Reads the vault's reference asset + decimals on-chain, resolves the swap
+       * quote and fail-closes on aggregator/whitelist drift, and sends the ERC-20
+       * approval to the SwapRouter when allowance is short.
+       *
+       * @param options - {@link ISwapRouterDepositOptions}.
+       * @returns The transaction hash of the router deposit call.
+       * @throws AugustValidationError on unsupported chain, invalid address, zero
+       *   amount, a native deposit into a non-wrapped-native vault, or quote drift.
+       * @example
+       * ```ts
+       * const hash = await augustSdk.evm.swapRouterDeposit({
+       *   chainId: 1, vault, depositAsset: USDT, amount: '100', slippageBps: 50,
+       * });
+       * ```
+       */
+      swapRouterDeposit(options: ISwapRouterDepositOptions): Promise<string>;
       /**
        * Claim assets from a matured redemption request on a dated-redemption
        * (RWA-style) vault. The `year`, `month`, `day`, and `receiverIndex` tuple
@@ -19011,7 +19125,7 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
             * only refresh user identity and the cached API-key hash.
             *
             * @param config - Analytics configuration. Pass `tracesSampleRate` to
-            *   override the Phase 1/2 default of `1.0`.
+            *   override the default of `0.1`.
             * @param environment - Current environment (DEV or PROD).
             * @param walletAddress - Optional wallet address for user identification.
             * @param apiKey - Optional API key (hashed for identification).
@@ -19405,6 +19519,34 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
 
            export declare function isEarlierThanNow(startTime: Date): boolean;
 
+           /**
+            * Is this error a routine on-chain read revert rather than a real failure?
+            *
+            * Reading a function a contract doesn't implement, or an address that holds no
+            * (or incompatible) bytecode, reverts — a normal outcome when the SDK probes
+            * heterogeneous vaults. Matches ethers' `CALL_EXCEPTION` code and the
+            * message variants emitted by ethers and viem (`missing revert data`,
+            * `execution reverted`, `call revert exception`, and the bare `reverted`
+            * phrasing such as `the contract function "totalAssets" reverted`).
+            *
+            * Scope note: callers apply this on **read** paths only. A reverted *write*
+            * (a tx that failed on-chain) is a genuine error and is intentionally not
+            * demoted by this predicate's use in `write.actions`.
+            *
+            * @param error - The caught value, of unknown type.
+            * @returns `true` when the failure is an expected/benign contract revert.
+            *
+            * @example
+            * ```ts
+            * try { return await vaultContract.maxDepositAmount(); }
+            * catch (e) {
+            *   logChainError('maxDeposit', e, isExpectedRevertError(e));
+            *   throw e;
+            * }
+            * ```
+            */
+           export declare function isExpectedRevertError(error: unknown): boolean;
+
            /**
             * Whether a vault's receipt token is hub-only (no cross-chain withdraw).
             * The deposit UI must not offer a spoke share destination for these vaults.
@@ -19527,6 +19669,20 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
             */
            declare function isStellarAddress(address: string): boolean;
 
+           /**
+            * Whether a vault is eligible for the any-token `SwapRouter` deposit surface
+            * (the SwapRouter is `enableVault`-ed for it on-chain). Address comparison is
+            * case-insensitive.
+            *
+            * This gates the (flag-controlled) swap-router deposit UI and can fail-fast a
+            * {@link swapRouterDeposit} call. It does **not** affect {@link vaultDeposit},
+            * which is always the native/multiasset/adapter path.
+            *
+            * @param vaultAddress - August vault address.
+            * @returns `true` when the vault is in {@link SWAP_ROUTER_ELIGIBLE_VAULTS}.
+            */
+           export declare function isSwapRouterEligible(vaultAddress: IAddress): boolean;
+
            /** Parameters for building an unsigned Stellar vault deposit transaction. */
            declare interface IStellarDepositParams {
                contractId: string;
@@ -19676,6 +19832,27 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                ownerAddr: IAddress;
            }
 
+           /**
+            * Is this error a wallet/user rejection of a transaction or signature request?
+            *
+            * Detects ethers v6's `ACTION_REJECTED` code, the EIP-1193 `4001`
+            * ("User rejected the request") code (top-level or nested), and the common
+            * human-readable phrasings as a fallback for providers that omit a code.
+            *
+            * @param error - The caught value, of unknown type.
+            * @returns `true` when the failure was the user declining in their wallet.
+            *
+            * @example
+            * ```ts
+            * try { await vault.deposit(...); }
+            * catch (e) {
+            *   if (isUserRejectionError(e)) return; // user cancelled — not an error
+            *   throw e;
+            * }
+            * ```
+            */
+           export declare function isUserRejectionError(error: unknown): boolean;
+
            /**
             * Signer Compatibility Helpers
             *
@@ -19823,6 +20000,44 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                wait?: boolean;
            }
 
+           /**
+            * Options for {@link swapRouterDeposit} — the high-level, explicit SwapRouter
+            * deposit entry point. It reads the vault's reference asset and decimals
+            * on-chain, then picks the correct router path from `depositAsset`, so callers
+            * do not hand-build swap legs or pre-resolve decimals themselves.
+            *
+            * Prefer this over relying on the implicit routing inside `vaultDeposit`: here
+            * the caller opts into the SwapRouter deliberately, so a vault is never
+            * silently routed through a swap it does not need — the failure mode that broke
+            * native multi-asset deposits when a multi-asset vault was added to
+            * `VAULTS_USING_SWAP_ROUTER`.
+            *
+            * Unlike {@link ISwapRouterBaseOptions}, `receiver` is optional here and
+            * defaults to the signer's resolved EOA.
+            */
+           export declare interface ISwapRouterDepositOptions extends Omit<ISwapRouterBaseOptions, 'receiver'> {
+               /**
+                * Token being deposited, held by the signer. Its relationship to the vault's
+                * reference asset selects the router path:
+                *  - equals the reference asset → direct router deposit (no swap);
+                *  - the zero address → native-token deposit (only when the reference asset
+                *    is the chain's wrapped-native token);
+                *  - any other ERC-20 → a swap to the reference asset via the chain's
+                *    whitelisted DEX aggregator, bundled into the deposit.
+                */
+               depositAsset: IAddress;
+               /** Amount in `depositAsset`'s smallest unit (decimal string or bigint). */
+               amount: string | bigint;
+               /** Address that receives the minted shares. Defaults to the signer's EOA. */
+               receiver?: IAddress;
+               /**
+                * Max slippage in basis points for the swap leg. Only used when `depositAsset`
+                * differs from the reference asset; passed through to the swap quote, whose
+                * own default applies when omitted.
+                */
+               slippageBps?: number;
+           }
+
            /**
             * Options for `depositViaSwapRouter` — direct deposit (no swap) of an
             * already-held asset, routed through the SwapRouter so origin/swap-fee
@@ -21072,6 +21287,26 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
 
            export declare function loanStateToReadable(loanState: number | bigint): "PREAPPROVED" | "FUNDING_REQUIRED" | "FUNDED" | "ACTIVE" | "CANCELLED" | "MATURED" | "CLOSED";
 
+           /**
+            * Log a caught chain error at the severity its category warrants, without
+            * swallowing it. When `isBenign` is `true` the failure is recorded as a `warn`
+            * (a Sentry breadcrumb that rides along with the next real issue, not a billed
+            * standalone issue); otherwise it is logged at `error` (a Sentry issue). The
+            * caller is still responsible for re-throwing — this only routes telemetry.
+            *
+            * Pass the benign decision explicitly (via {@link isUserRejectionError} or
+            * {@link isExpectedRevertError}) so the call site documents *why* the demotion
+            * is safe and each path opts into only the category that applies to it.
+            *
+            * @param tag - Low-cardinality call-site label (e.g. `'deposit'`), used as the
+            *   Sentry breadcrumb/issue grouping key.
+            * @param error - The caught value, of unknown type.
+            * @param isBenign - `true` to demote to `warn`; `false` to keep at `error`.
+            * @param context - Optional structured context attached to the log entry. It is
+            *   sanitized by the logger before transport.
+            */
+           export declare function logChainError(tag: string, error: unknown, isBenign: boolean, context?: Record<string, unknown>): void;
+
            export declare const Logger: {
                setLogger: typeof setLogger;
                setStructuredLogger: typeof setStructuredLogger;
@@ -22476,6 +22711,7 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
 
             declare namespace SolanaActions {
                 export {
+                    describeSolanaError,
                     handleSolanaDeposit,
                     handleSolanaRedeem
                 }
@@ -22855,6 +23091,32 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                           selector: `0x${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.
+                       */
+                      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
@@ -22918,930 +23180,973 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                            export declare function swapAndDeposit(signer: Signer | Wallet, options: ISwapAndDepositOptions): Promise<string>;
 
                            /**
-                            * Numeric vault-type tag used by the on-chain `SwapRouter` to branch between
-                            * the ERC-4626 (`deposit(uint256, address)`) and multi-asset
-                            * (`deposit(address, uint256, address)`) deposit interfaces.
+                            * 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}.
                             *
-                            * 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.
+                            * 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.
                             *
-                            * @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.
+                            * 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}.
                             *
-                            * @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.
+                            * 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.
                             *
-                            * 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%%.
+                            * @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,
+                                * });
+                                * ```
                                 */
-                               send(...args: [...TInputArgs, overrides?: Overrides]): Promise<ContractTransactionResponse>;
-                               /**
-                                * Estimate the gas to send the contract method with %%args%%.
-                                */
-                               estimateGas(...args: [...TInputArgs, overrides?: Overrides]): Promise<bigint>;
-                               /**
-                                * Call the contract method with %%args%% and return the Result
-                                * without any dereferencing.
-                                */
-                               staticCallResult(...args: [...TInputArgs, overrides?: Overrides]): Promise<Result>;
-                           }
-
-                           export declare type TypedContractFunctionResult<TAbi extends Abi, TFunctionName extends string, TOutputArgs = AbiParametersToPrimitiveTypes<ExtractAbiFunction<TAbi, TFunctionName>['outputs']>> = TOutputArgs extends readonly [] ? void : TOutputArgs extends readonly [infer Arg] ? Arg : TOutputArgs;
-
-                           export declare type TypedFragment<TAbi extends Abi, TFunctionName extends string, TFunction extends ExtractAbiFunctions<TAbi> = ExtractAbiFunction<TAbi, TFunctionName>> = Omit<FunctionFragment, 'inputs' | 'outputs' | 'stateMutability' | 'name' | 'type'> & {
-                               name: TFunction['name'];
-                               type: TFunction['type'];
-                               inputs: TFunction['inputs'];
-                               outputs: TFunction['outputs'];
-                               stateMutability: TFunction['stateMutability'];
-                           };
-
-                           export declare function unixToDate(epoch: number): Date;
-
-                           /**
-                            * Update the current user identity in Sentry.
-                            * Called when wallet address changes.
-                            *
-                            * @param walletAddress - New wallet address (or undefined to clear)
-                            * @param environment - Current environment
-                            */
-                           export declare function updateUser(walletAddress?: string, environment?: IEnv): void;
-
-                           /* Excluded from this release type: validateAmountPrecision */
-
-                           /**
-                            * Vault adapter configurations mapping vault addresses to their adapter settings
-                            */
-                           export declare const VAULT_ADAPTER_CONFIGS: Record<IAddress, IVaultAdapterConfig>;
-
-                           export declare const VAULT_ADDRESSES: Record<"musd" | "predlp" | "sentusd" | "pregrid" | "repouscc" | "earnxrp" | "tivkbtc" | "tivusdt0" | "supermon" | "earnmon" | "k3europ" | "wmon/ausd" | "wbtc/ausd" | "earnausd_monad" | "sausd" | "farmbold" | "sentuscc" | "sentbtc" | "svusdc" | "apusdc" | "testwethtsa" | "tacusr" | "upinjusdt" | "tac-teth" | "upausd" | "taccbbtc" | "xupusdc" | "uptbtc" | "gteth" | "ageth" | "upusdc" | "hgeth" | "upssylva" | "hbbtc" | "hbhype" | "upazt" | "susdt" | "upedge" | "coreusdc" | "upcusdo" | "shifteth" | "upsusde" | "uplbtc" | "upavax" | "tacrseth" | "earnausd" | "alpineusdcflagship" | "alpinecoinshiftusdc" | "upbtc" | "upstrbtc" | "maxiusr" | "upgammausdc" | "xhype" | "wildusd" | "alpinebtc" | "prenusd" | "upyzusd" | "upnusd" | "hlpe" | "nemo eth yield", `0x${string}`>;
-
-                           /**
-                            * Hardcoded subaccount addresses for specific vaults allocations
-                            */
-                           export declare const VAULT_ALLOCATION_SUBACCOUNTS: {
-                               AgoraAUSD: {
-                                   address: IAddress;
-                                   subaccount: IAddress;
-                                   useDebank: boolean;
-                               };
-                               earnAUSD: {
-                                   address: IAddress;
-                                   subaccount: IAddress;
-                                   useDebank: boolean;
-                               };
-                           };
-
-                           /**
-                            * The functions to call on the vault contract
-                            * @returns The functions to call
-                            */
-                           export declare const VAULT_FUNCTIONS_V1: IPoolFunctions[];
-
-                           export declare const VAULT_FUNCTIONS_V2: IPoolFunctions[];
-
-                           export declare const VAULT_FUNCTIONS_V2_RECEIPT: IPoolFunctions[];
-
-                           export declare const VAULT_FUNCTIONS_V2_WHITELISTED_ASSETS: IPoolFunctions[];
-
-                           /**
-                            * Vault Symbols Mapping
-                            * @deprecated use getVaultMetadata to fetch vault symbols from the backend
-                            */
-                           export declare const VAULT_SYMBOLS: Record<IAddress, string>;
-
-                           /**
-                            * Vault Symbols Reverse Mapping
-                            * @deprecated use getVaultMetadata to fetch vault symbols from the backend
-                            */
-                           export declare const VAULT_SYMBOLS_REVERSE: Record<VaultSymbols, IAddress>;
-
-                           /**
-                            * Address type for vault contracts across all supported chains.
-                            * EVM vaults use `0x`-prefixed hex addresses, Solana vaults use base58,
-                            * and Stellar vaults use 56-character base32 addresses (G/C prefix).
-                            *
-                            * Use this instead of `IAddress` when the address may belong to any chain.
-                            */
-                           export declare type VaultAddress = string;
-
-                           /**
-                            * allowance checks user's current allowance per pool
-                            * @param signer - signer / provider object
-                            * @param options - object including pool contract address, user wallet address
-                            * @returns normalized number object of the user's current allowance
-                            */
-                           export declare function vaultAllowance(signer: IContractRunner, options: IContractWriteOptions): Promise<INormalizedNumber>;
-
-                           /**
-                            * Approve a vault (or the appropriate adapter wrapper) to spend a token
-                            * ahead of a separate deposit call. Spender routing mirrors
-                            * {@link vaultDeposit} (multi-asset → vault, adapter → wrapper, standard →
-                            * vault). Returns `undefined` when the existing allowance already covers
-                            * `amount` **or** when the deposit asset is native.
-                            *
-                            * @returns Transaction hash when an approval was sent, `undefined` when
-                            *   the existing allowance already covers `amount` or the deposit asset is
-                            *   native (no ERC-20 allowance applies). Use {@link approve} for a
-                            *   discriminated `ApproveResult` if you need to tell those two cases apart.
-                            * @throws AugustValidationError on invalid wallet/target/amount.
-                            *
-                            * @example
-                            * ```ts
-                            * const hash = await augustSdk.evm.vaultApprove({
-                            *   target: '0x...',         // vault contract address
-                            *   wallet: walletAddress,
-                            *   amount: '100',           // 100 of the deposit token (UI units)
-                            *   wait: true,              // wait for the approval to confirm
-                            * });
-                            * if (hash) console.log('approve tx', hash);
-                            * // hash === undefined means the on-chain allowance already covers the
-                            * // amount, or the deposit asset is native (msg.value, no allowance).
-                            * ```
-                            */
-                           export declare function vaultApprove(signer: Signer | Wallet, options: IContractWriteOptions): Promise<string | undefined>;
-
-                           /**
-                            * Deposit underlying token into the specified vault. Auto-routes to the
-                            * correct contract path (single-asset ERC-4626, EVM-2 multi-asset,
-                            * Paraswap adapter, native-token wrapper, depositWithPermit) based on the
-                            * vault version and `depositAsset`.
-                            *
-                            * Amounts are encoded against the **deposit token's** decimals, not the
-                            * vault's share decimals. The SDK reads the appropriate decimals via the
-                            * vault metadata and the asset's ERC-20.
-                            *
-                            * Approval is handled automatically: if the existing allowance doesn't
-                            * cover `amount`, an `approve` is sent and **always waited for** (regardless
-                            * of the caller's `wait` flag) so the deposit tx can't be re-ordered ahead
-                            * of the approval on Monad-style RPCs.
-                            *
-                            * @param signer ethers Signer / Wallet (or viem WalletClient via {@link setSigner})
-                            * @param options Vault address, wallet, amount, optional `depositAsset` for
-                            *   adapter routes, optional `wait` to wait for the deposit receipt.
-                            * @returns Deposit transaction hash.
-                            * @throws AugustValidationError on invalid wallet/target/amount or missing
-                            *   adapter config when `depositAsset` differs from the vault underlying.
-                            * @throws AugustSDKError when the deposit submission or on-chain call fails.
-                            *
-                            * @example
-                            * ```ts
-                            * const hash = await augustSdk.evm.vaultDeposit({
-                            *   target: '0xE9B725010A9E419412ed67d0fA5f3A5f40159D32', // vault
-                            *   wallet: walletAddress,
-                            *   amount: '100',         // 100 USDC (UI units)
-                            *   wait: true,            // wait for the deposit receipt
-                            * });
-                            * ```
-                            *
-                            * @example Adapter deposit (different deposit asset than the vault's underlying)
-                            * ```ts
-                            * await augustSdk.evm.vaultDeposit({
-                            *   target: vaultAddress,
-                            *   wallet: walletAddress,
-                            *   amount: '0.5',
-                            *   depositAsset: WETH_ADDRESS,   // swap WETH -> vault underlying via the adapter
-                            *   chainId: 1,
-                            * });
-                            * ```
-                            */
-                           export declare function vaultDeposit(signer: Signer | Wallet, options: IContractWriteOptions): Promise<string>;
-
-                           /**
-                            * Check if vault has adapter support
-                            */
-                           export declare function vaultHasAdapter(vaultAddress: IAddress): boolean;
-
-                           declare const vaultIdl: {
-                               address: string;
-                               metadata: {
-                                   name: string;
-                                   version: string;
-                                   spec: string;
-                                   description: string;
-                               };
-                               instructions: ({
-                                   name: string;
-                                   docs: string[];
-                                   discriminator: number[];
-                                   accounts: ({
-                                       name: string;
-                                       writable: boolean;
-                                       pda: {
-                                           seeds: {
-                                               kind: string;
-                                               value: number[];
-                                           }[];
-                                       };
-                                       signer?: undefined;
-                                       address?: undefined;
-                                   } | {
-                                       name: string;
-                                       signer: boolean;
-                                       writable?: undefined;
-                                       pda?: undefined;
-                                       address?: undefined;
-                                   } | {
-                                       name: string;
-                                       writable: boolean;
-                                       pda?: undefined;
-                                       signer?: undefined;
-                                       address?: undefined;
-                                   } | {
-                                       name: string;
-                                       address: string;
-                                       writable?: undefined;
-                                       pda?: undefined;
-                                       signer?: undefined;
-                                   })[];
-                                   args: any[];
-                               } | {
-                                   name: string;
-                                   docs: string[];
-                                   discriminator: number[];
-                                   accounts: ({
-                                       name: string;
-                                       writable: boolean;
-                                       signer: boolean;
-                                       docs?: undefined;
-                                       pda?: undefined;
-                                       address?: undefined;
-                                   } | {
-                                       name: string;
-                                       docs: string[];
-                                       writable: boolean;
-                                       signer: boolean;
-                                       pda?: undefined;
-                                       address?: undefined;
-                                   } | {
-                                       name: string;
-                                       docs: string[];
-                                       writable: boolean;
-                                       pda: {
-                                           seeds: {
-                                               kind: string;
-                                               value: number[];
-                                           }[];
-                                           program?: undefined;
-                                       };
-                                       signer?: undefined;
-                                       address?: undefined;
-                                   } | {
-                                       name: string;
-                                       docs: string[];
-                                       writable: boolean;
-                                       signer?: undefined;
-                                       pda?: undefined;
-                                       address?: undefined;
-                                   } | {
-                                       name: string;
-                                       writable: boolean;
-                                       pda: {
-                                           seeds: ({
-                                               kind: string;
-                                               value: number[];
-                                               path?: undefined;
-                                           } | {
-                                               kind: string;
-                                               path: string;
-                                               value?: undefined;
-                                           })[];
-                                           program: {
-                                               kind: string;
-                                               value: number[];
-                                           };
-                                       };
-                                       signer?: undefined;
-                                       docs?: undefined;
-                                       address?: undefined;
-                                   } | {
-                                       name: string;
-                                       address: string;
-                                       writable?: undefined;
-                                       signer?: undefined;
-                                       docs?: undefined;
-                                       pda?: undefined;
-                                   })[];
-                                   args: {
-                                       name: string;
-                                       type: string;
-                                   }[];
-                               } | {
-                                   name: string;
-                                   docs: string[];
-                                   discriminator: number[];
-                                   accounts: ({
-                                       name: string;
-                                       writable: boolean;
-                                       pda: {
-                                           seeds: ({
-                                               kind: string;
-                                               value: number[];
-                                               path?: undefined;
-                                           } | {
-                                               kind: string;
-                                               path: string;
-                                               value?: undefined;
-                                           })[];
-                                       };
-                                       signer?: undefined;
-                                   } | {
-                                       name: string;
-                                       writable: boolean;
-                                       pda?: undefined;
-                                       signer?: undefined;
-                                   } | {
-                                       name: string;
-                                       writable: boolean;
-                                       signer: boolean;
-                                       pda?: undefined;
-                                   } | {
-                                       name: string;
-                                       writable?: undefined;
-                                       pda?: undefined;
-                                       signer?: undefined;
-                                   })[];
-                                   args: {
-                                       name: string;
-                                       type: string;
-                                   }[];
-                               } | {
-                                   name: string;
-                                   docs: string[];
-                                   discriminator: number[];
-                                   accounts: ({
-                                       name: string;
-                                       writable: boolean;
-                                       pda: {
-                                           seeds: ({
-                                               kind: string;
-                                               value: number[];
-                                               path?: undefined;
-                                           } | {
-                                               kind: string;
-                                               path: string;
-                                               value?: undefined;
-                                           })[];
-                                       };
-                                       signer?: undefined;
-                                       address?: undefined;
-                                   } | {
-                                       name: string;
-                                       writable?: undefined;
-                                       pda?: undefined;
-                                       signer?: undefined;
-                                       address?: undefined;
-                                   } | {
-                                       name: string;
-                                       writable: boolean;
-                                       signer: boolean;
-                                       pda?: undefined;
-                                       address?: undefined;
-                                   } | {
-                                       name: string;
-                                       address: string;
-                                       writable?: undefined;
-                                       pda?: undefined;
-                                       signer?: undefined;
-                                   })[];
-                                   args: {
-                                       name: string;
-                                       type: string;
-                                   }[];
-                               } | {
-                                   name: string;
-                                   docs: string[];
-                                   discriminator: number[];
-                                   accounts: ({
-                                       name: string;
-                                       writable: boolean;
-                                       pda: {
-                                           seeds: {
-                                               kind: string;
-                                               value: number[];
-                                           }[];
-                                       };
-                                       signer?: undefined;
-                                       address?: undefined;
-                                   } | {
-                                       name: string;
-                                       signer: boolean;
-                                       writable?: undefined;
-                                       pda?: undefined;
-                                       address?: undefined;
-                                   } | {
-                                       name: string;
-                                       writable: boolean;
-                                       signer: boolean;
-                                       pda?: undefined;
-                                       address?: undefined;
-                                   } | {
-                                       name: string;
-                                       address: string;
-                                       writable?: undefined;
-                                       pda?: undefined;
-                                       signer?: undefined;
-                                   })[];
-                                   args: {
-                                       name: string;
-                                       type: string;
-                                   }[];
-                               } | {
-                                   name: string;
-                                   docs: string[];
-                                   discriminator: number[];
-                                   accounts: ({
-                                       name: string;
-                                       writable: boolean;
-                                       pda: {
-                                           seeds: ({
-                                               kind: string;
-                                               value: number[];
-                                               path?: undefined;
-                                           } | {
-                                               kind: string;
-                                               path: string;
-                                               value?: undefined;
-                                           })[];
-                                           program?: undefined;
-                                       };
-                                       signer?: undefined;
-                                   } | {
-                                       name: string;
-                                       writable: boolean;
-                                       pda: {
-                                           seeds: ({
-                                               kind: string;
-                                               path: string;
-                                               value?: undefined;
-                                           } | {
-                                               kind: string;
-                                               value: number[];
-                                               path?: undefined;
-                                           })[];
-                                           program: {
-                                               kind: string;
-                                               value: number[];
-                                           };
-                                       };
-                                       signer?: undefined;
-                                   } | {
-                                       name: string;
-                                       writable: boolean;
-                                       pda?: undefined;
-                                       signer?: undefined;
-                                   } | {
-                                       name: string;
-                                       signer: boolean;
-                                       writable?: undefined;
-                                       pda?: undefined;
-                                   } | {
-                                       name: string;
-                                       writable?: undefined;
-                                       pda?: undefined;
-                                       signer?: undefined;
-                                   })[];
-                                   args: {
-                                       name: string;
-                                       type: string;
-                                   }[];
-                               })[];
-                               accounts: {
-                                   name: string;
-                                   discriminator: number[];
-                               }[];
-                               events: {
-                                   name: string;
-                                   discriminator: number[];
-                               }[];
-                               errors: {
-                                   code: number;
-                                   name: string;
-                                   msg: string;
-                               }[];
-                               types: ({
-                                   name: string;
-                                   serialization: string;
-                                   repr: {
-                                       kind: string;
-                                   };
-                                   type: {
-                                       kind: string;
-                                       fields: {
-                                           name: string;
-                                           type: string;
-                                       }[];
-                                   };
-                               } | {
-                                   name: string;
-                                   type: {
-                                       kind: string;
-                                       fields: ({
-                                           name: string;
-                                           type: string;
-                                       } | {
-                                           name: string;
-                                           type: {
-                                               array: (string | number)[];
-                                           };
-                                       })[];
-                                   };
-                                   serialization?: undefined;
-                                   repr?: undefined;
-                               })[];
-                           };
-
-                           /**
-                            * @TODO
-                            * @description withdraw funds from the specified pool including accrued rewards
-                            * @param signer signer / wallet object
-                            * @param options object including pool contract address, user wallet address, and more
-                            * @returns claim tx hash
-                            */
-                           export declare function vaultRedeem(signer: Signer | Wallet, options: IContractWriteOptions & {
-                               year: string;
-                               month: string;
-                               day: string;
-                               receiverIndex: string;
-                           }): Promise<string>;
-
-                           export declare enum VaultRedemptionStatus {
-                               AWAITING_COOLDOWN = "awaiting_cooldown",
-                               READY_TO_CLAIM = "ready_to_claim"
-                           }
-
-                           /**
-                            * Request to redeem vault shares. For EVM-1 vaults this queues a standard
-                            * redemption (claimable later via `vaultRedeem`); for EVM-2 vaults this
-                            * also handles the receipt-token allowance automatically. Pass
-                            * `isInstantRedeem: true` for vaults that support instant settlement.
-                            *
-                            * Approval of the receipt token (EVM-2) is always waited on before the
-                            * redeem call, regardless of the caller's `wait` flag.
-                            *
-                            * @param signer ethers Signer / Wallet (or viem WalletClient via {@link setSigner})
-                            * @param options Vault address, wallet, amount, optional `isInstantRedeem`,
-                            *   optional `wait` to wait for the redeem receipt.
-                            * @returns Redeem transaction hash.
-                            * @throws AugustValidationError on invalid wallet/target/amount.
-                            * @throws AugustSDKError when the redeem submission or on-chain call fails.
-                            *
-                            * @example
-                            * ```ts
-                            * const hash = await augustSdk.evm.vaultRequestRedeem({
-                            *   target: vaultAddress,
-                            *   wallet: walletAddress,
-                            *   amount: '10',           // 10 shares (UI units)
-                            *   wait: true,
-                            * });
-                            * ```
-                            *
-                            * @example Instant redemption
-                            * ```ts
-                            * await augustSdk.evm.vaultRequestRedeem({
-                            *   target: vaultAddress,
-                            *   wallet: walletAddress,
-                            *   amount: '10',
-                            *   isInstantRedeem: true,
-                            * });
-                            * ```
-                            */
-                           export declare function vaultRequestRedeem(signer: Signer | Wallet, options: IContractWriteOptions): Promise<string>;
-
-                           /**
-                            * Vault addresses registered on a `SwapRouter` via `enableVault`. The
-                            * presence of a vault here is the signal to route its deposits through the
-                            * SwapRouter rather than the legacy adapter path.
-                            *
-                            * Entries mirror the on-chain `vaultInfo[addr].referenceAsset != 0` state of
-                            * the `SwapRouter` deployment. Verify against the deployed contract before
-                            * adding a new entry — a vault that is not registered on-chain will revert
-                            * with `InvalidVault` at deposit time.
-                            *
-                            * Lowercase comparison is required when checking — use
-                            * {@link vaultUsesSwapRouter} rather than reading this set directly.
-                            */
-                           export declare const VAULTS_USING_SWAP_ROUTER: ReadonlySet<string>;
-
-                           /**
-                            * Vault Receipt Symbol Mapping
-                            * @deprecated use getVaultMetadata to fetch vault symbols from the backend
-                            */
-                           declare type VaultSymbols = 'predlp' | 'sentusd' | 'pregrid' | 'repouscc' | 'earnxrp' | 'tivkbtc' | 'tivusdt0' | 'supermon' | 'earnmon' | 'k3europ' | 'wmon/ausd' | 'wbtc/ausd' | 'earnausd_monad' | 'sausd' | 'farmbold' | 'sentuscc' | 'sentbtc' | 'svusdc' | 'apusdc' | 'testwethtsa' | 'tacusr' | 'upinjusdt' | 'tac-teth' | 'upausd' | 'taccbbtc' | 'xupusdc' | 'uptbtc' | 'gteth' | 'ageth' | 'upusdc' | 'hgeth' | 'upssylva' | 'hbbtc' | 'hbhype' | 'upazt' | 'susdt' | 'upedge' | 'coreusdc' | 'upcusdo' | 'shifteth' | 'upsusde' | 'uplbtc' | 'upavax' | 'tacrseth' | 'musd' | 'earnausd' | 'alpineusdcflagship' | 'alpinecoinshiftusdc' | 'upbtc' | 'upstrbtc' | 'maxiusr' | 'upgammausdc' | 'xhype' | 'wildusd' | 'alpinebtc' | 'prenusd' | 'upyzusd' | 'upnusd' | 'hlpe' | 'nemo eth yield';
-
-                           /**
-                            * Whether a vault has been registered on a `SwapRouter` and should route
-                            * its deposits through it. Address comparison is case-insensitive.
-                            *
-                            * @param vaultAddress - August vault address.
-                            * @returns `true` when the vault is in {@link VAULTS_USING_SWAP_ROUTER}.
-                            */
-                           export declare function vaultUsesSwapRouter(vaultAddress: IAddress): boolean;
-
-                           export declare function verifyAugustKey(key: string): Promise<boolean>;
-
-                           export declare function verifyInfuraKey(key: string): Promise<boolean>;
-
-                           /**
-                            * Convert a viem WalletClient to an ethers-compatible Signer
-                            * Uses the walletClient as a provider and wraps it for ethers compatibility
-                            * @param walletClient Viem WalletClient from wagmi or viem
-                            * @returns Ethers Signer that can be used with the SDK
-                            */
-                           export declare function viemToEthersSigner(walletClient: any): Promise<Signer | Wallet>;
-
-                           /**
-                            * @param walletClient a wagmi-derived client (from useWalletClient)
-                            * @returns An ethers JsonRpcSigner object used in sdk.evm.setSigner
-                            */
-                           export declare function walletClientToSigner(walletClient: WalletClient): Promise<ethers.JsonRpcSigner>;
-
-                           export declare const WEBSERVER_ENDPOINTS: {
-                               default: {
-                                   hello: string;
-                                   protected: string;
-                               };
-                               auth: {
-                                   verify: string;
-                                   sign: string;
-                                   login: string;
-                                   nonce: string;
-                                   refresh: string;
-                               };
-                               subaccount: {
-                                   rewards: (subaccount: IAddress) => string;
-                                   tokens: (subaccount: IAddress) => string;
-                                   twap: {
-                                       create: (subaccount: IAddress) => string;
-                                       stop: (subaccount: IAddress, id: string) => string;
-                                       fills: (subaccount: IAddress, id: string) => string;
-                                   };
-                                   debank: (subaccount: IAddress) => string;
-                                   health_factor: (subaccount: IAddress) => string;
-                                   summary: (subaccount: IAddress) => string;
-                                   batch: (subaccount: IAddress) => string;
-                                   loans: (subaccount: IAddress, side?: "BORROWER" | "LENDER" | "BOTH", active?: boolean) => string;
-                                   cefi: (subaccount: IAddress) => string;
-                                   otc_positions: (subaccount: IAddress) => string;
-                                   _: (subaccount: IAddress) => string;
-                               };
-                               users: {
-                                   get: string;
-                               };
-                               prices: (symbol: string) => string;
-                               metrics: {
-                                   pnl: (subaccount: IAddress, startTime?: string, endTime?: string) => string;
-                               };
-                               public: {
-                                   integrations: {
-                                       morpho: {
-                                           apy: (subaccount: IAddress, vaultAddress: IAddress) => string;
-                                       };
-                                   };
-                                   tokenizedVault: {
-                                       loans: (vaultAddress: VaultAddress, chainId: number, active: boolean) => string;
-                                       subaccountLoans: (vaultAddress: VaultAddress, chainId: number, active: boolean) => string;
-                                       list: string;
-                                       byVaultAddress: (vaultAddress: VaultAddress) => string;
-                                       historicalApy: (vaultAddress: IAddress) => string;
-                                       historicalTimeseries: (vaultAddress: IAddress, nDays?: number) => string;
-                                       annualizedApy: (vaultAddress: IAddress) => string;
-                                       summary: (vaultAddress: IAddress) => string;
-                                       withdrawals: (chain: string, vaultAddress: IAddress) => string;
-                                       debank: (vaultAddress: IAddress) => string;
-                                       userHistory: (vaultAddress: IAddress, wallet: IAddress) => string;
-                                       archivedVaults: string;
-                                   };
-                                   points: {
-                                       byUserAddress: (userAddress: IAddress) => string;
-                                       register: string;
-                                       leaderboard: string;
-                                   };
-                                   vaults: {
-                                       pendingRedemptions: (vaultAddress: IAddress) => string;
-                                   };
-                                   pnl: {
-                                       unrealizedHistory: (vaultAddress: VaultAddress, limit?: number) => string;
-                                       unrealizedLatest: string;
-                                   };
-                               };
-                               upshift: {
-                                   vaults: {
-                                       metadata: string;
-                                   };
-                               };
-                           };
-
-                           export declare const WEBSERVER_URL: {
-                               production: string;
-                               staging: string;
-                               development: string;
-                               localhost: string;
-                               qa: string;
-                               public: string;
-                               upshift: string;
-                           };
-
-                           /**
-                            * Withdrawal request with computed claimable date and current processing status.
-                            * The unique identifier is (receiver, claimableDate).
-                            *
-                            * @interface WithdrawalRequestStatus
-                            */
-                           export declare interface WithdrawalRequestStatus {
-                               /** Transaction hash of the withdrawal request */
-                               transactionHash: string;
-                               /** Block timestamp when the withdrawal was requested (seconds, UTC) */
-                               requestTimestamp: number;
-                               /** Shares amount being redeemed */
-                               shares: bigint;
-                               /** Receiver address for the withdrawal */
-                               receiver: string;
-                               /** Computed claimable date in UTC (year, month, day) */
-                               claimableDate: {
-                                   year: number;
-                                   month: number;
-                                   day: number;
-                               };
-                               /** Epoch timestamp when this withdrawal becomes claimable */
-                               claimableEpoch: number;
-                               /** Current status of the withdrawal */
-                               status: 'pending' | 'ready_to_claim' | 'processed';
-                               /** Transaction hash of the processing transaction (if processed) */
-                               processedTransactionHash?: string;
-                               /** Assets received (if processed) */
-                               assetsReceived?: bigint;
-                           }
-
-                           /**
-                            * Higher-order function to wrap SDK methods with performance tracking.
-                            * Tracks method calls, timing, chain usage, and errors.
-                            *
-                            * @param methodName - Name of the method being wrapped
-                            * @param method - The original async method
-                            * @param getChainId - Function to get current chain ID
-                            * @returns Wrapped method with tracking
-                            */
-                           export declare function withMethodTracking<T extends (...args: unknown[]) => Promise<unknown>>(methodName: string, method: T, getChainId?: () => number | undefined): T;
-
-                           /**
-                            * Wrap async operations with exponential backoff retry logic.
-                            * Retries on network errors with increasing delays between attempts.
-                            * @param fn - Async function to execute with retry logic
-                            * @param maxRetries - Maximum number of retry attempts
-                            * @param baseDelay - Initial delay in milliseconds (doubles each retry)
-                            * @param shouldRetry - Custom function to determine if error is retryable
-                            * @returns Result of successful function execution
-                            * @throws Last error if all retries exhausted
-                            */
-                           export declare function withRetry<T>(fn: () => Promise<T>, maxRetries?: number, baseDelay?: number, shouldRetry?: (error: Error) => boolean): Promise<T>;
-
-                           /**
-                            * Higher-order function to wrap synchronous SDK methods with tracking.
-                            * Uses breadcrumbs for tracking since spans require async context.
-                            *
-                            * @param methodName - Name of the method being wrapped
-                            * @param method - The original sync method
-                            * @param getChainId - Function to get current chain ID
-                            * @returns Wrapped method with tracking
-                            */
-                           export declare function withSyncMethodTracking<T extends (...args: unknown[]) => unknown>(methodName: string, method: T, getChainId?: () => number | undefined): T;
-
-                           export declare const WRAPPER_ADAPTOR: {
-                               43114: IAddress;
-                               1: IAddress;
-                           };
-
-                           export { }
+                            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;
+                                };
+                            };
+
+                            /**
+                             * 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}, and the semantics
+                             * changed: this set no longer drives `vaultDeposit` auto-routing (that branch
+                             * was removed) — it now only marks vaults whose UI may offer the swap-router
+                             * deposit surface. Kept as an alias for one release; migrate to the new name.
+                             */
+                            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}. 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.
+                             */
+                            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: {
+                                    rewards: (subaccount: IAddress) => string;
+                                    tokens: (subaccount: IAddress) => string;
+                                    twap: {
+                                        create: (subaccount: IAddress) => string;
+                                        stop: (subaccount: IAddress, id: string) => string;
+                                        fills: (subaccount: IAddress, id: string) => string;
+                                    };
+                                    debank: (subaccount: IAddress) => string;
+                                    health_factor: (subaccount: IAddress) => string;
+                                    summary: (subaccount: IAddress) => string;
+                                    batch: (subaccount: IAddress) => string;
+                                    loans: (subaccount: IAddress, side?: "BORROWER" | "LENDER" | "BOTH", active?: boolean) => string;
+                                    cefi: (subaccount: IAddress) => string;
+                                    otc_positions: (subaccount: IAddress) => string;
+                                    _: (subaccount: IAddress) => string;
+                                };
+                                users: {
+                                    get: string;
+                                };
+                                prices: (symbol: string) => string;
+                                metrics: {
+                                    pnl: (subaccount: IAddress, startTime?: string, endTime?: string) => string;
+                                };
+                                public: {
+                                    integrations: {
+                                        morpho: {
+                                            apy: (subaccount: IAddress, vaultAddress: IAddress) => string;
+                                        };
+                                    };
+                                    tokenizedVault: {
+                                        loans: (vaultAddress: VaultAddress, chainId: number, active: boolean) => string;
+                                        subaccountLoans: (vaultAddress: VaultAddress, chainId: number, active: boolean) => string;
+                                        list: string;
+                                        byVaultAddress: (vaultAddress: VaultAddress) => string;
+                                        historicalApy: (vaultAddress: IAddress) => string;
+                                        historicalTimeseries: (vaultAddress: IAddress, nDays?: number) => string;
+                                        annualizedApy: (vaultAddress: IAddress) => string;
+                                        summary: (vaultAddress: IAddress) => string;
+                                        withdrawals: (chain: string, vaultAddress: IAddress) => string;
+                                        debank: (vaultAddress: IAddress) => string;
+                                        userHistory: (vaultAddress: IAddress, wallet: IAddress) => string;
+                                        archivedVaults: string;
+                                    };
+                                    points: {
+                                        byUserAddress: (userAddress: IAddress) => string;
+                                        register: string;
+                                        leaderboard: string;
+                                    };
+                                    vaults: {
+                                        pendingRedemptions: (vaultAddress: IAddress) => string;
+                                    };
+                                    pnl: {
+                                        unrealizedHistory: (vaultAddress: VaultAddress, limit?: number) => string;
+                                        unrealizedLatest: string;
+                                    };
+                                };
+                                upshift: {
+                                    vaults: {
+                                        metadata: string;
+                                    };
+                                };
+                            };
+
+                            export declare const WEBSERVER_URL: {
+                                production: string;
+                                staging: string;
+                                development: string;
+                                localhost: string;
+                                qa: string;
+                                public: string;
+                                upshift: string;
+                            };
+
+                            /**
+                             * Withdrawal request with computed claimable date and current processing status.
+                             * The unique identifier is (receiver, claimableDate).
+                             *
+                             * @interface WithdrawalRequestStatus
+                             */
+                            export declare interface WithdrawalRequestStatus {
+                                /** Transaction hash of the withdrawal request */
+                                transactionHash: string;
+                                /** Block timestamp when the withdrawal was requested (seconds, UTC) */
+                                requestTimestamp: number;
+                                /** Shares amount being redeemed */
+                                shares: bigint;
+                                /** Receiver address for the withdrawal */
+                                receiver: string;
+                                /** Computed claimable date in UTC (year, month, day) */
+                                claimableDate: {
+                                    year: number;
+                                    month: number;
+                                    day: number;
+                                };
+                                /** Epoch timestamp when this withdrawal becomes claimable */
+                                claimableEpoch: number;
+                                /** Current status of the withdrawal */
+                                status: 'pending' | 'ready_to_claim' | 'processed';
+                                /** Transaction hash of the processing transaction (if processed) */
+                                processedTransactionHash?: string;
+                                /** Assets received (if processed) */
+                                assetsReceived?: bigint;
+                            }
+
+                            /**
+                             * Higher-order function to wrap SDK methods with performance tracking.
+                             * Tracks method calls, timing, chain usage, and errors.
+                             *
+                             * @param methodName - Name of the method being wrapped
+                             * @param method - The original async method
+                             * @param getChainId - Function to get current chain ID
+                             * @returns Wrapped method with tracking
+                             */
+                            export declare function withMethodTracking<T extends (...args: unknown[]) => Promise<unknown>>(methodName: string, method: T, getChainId?: () => number | undefined): T;
+
+                            /**
+                             * Wrap async operations with exponential backoff retry logic.
+                             * Retries on network errors with increasing delays between attempts.
+                             * @param fn - Async function to execute with retry logic
+                             * @param maxRetries - Maximum number of retry attempts
+                             * @param baseDelay - Initial delay in milliseconds (doubles each retry)
+                             * @param shouldRetry - Custom function to determine if error is retryable
+                             * @returns Result of successful function execution
+                             * @throws Last error if all retries exhausted
+                             */
+                            export declare function withRetry<T>(fn: () => Promise<T>, maxRetries?: number, baseDelay?: number, shouldRetry?: (error: Error) => boolean): Promise<T>;
+
+                            /**
+                             * Higher-order function to wrap synchronous SDK methods with tracking.
+                             * Uses breadcrumbs for tracking since spans require async context.
+                             *
+                             * @param methodName - Name of the method being wrapped
+                             * @param method - The original sync method
+                             * @param getChainId - Function to get current chain ID
+                             * @returns Wrapped method with tracking
+                             */
+                            export declare function withSyncMethodTracking<T extends (...args: unknown[]) => unknown>(methodName: string, method: T, getChainId?: () => number | undefined): T;
+
+                            export declare const WRAPPER_ADAPTOR: {
+                                43114: IAddress;
+                                1: IAddress;
+                            };
+
+                            export { }