@augustdigital/sdk 8.12.0 → 8.14.0

package/lib/sdk.d.ts

@@ -15771,6 +15771,52 @@ declare class AugustSDK extends AugustBase {
         untilTs?: number;
         types?: ('withdraw-request' | 'deposit' | 'withdraw-processed' | 'redeem')[];
     }): Promise<IVaultUserHistoryItem[]>;
+    /**
+     * Resolve the ERC-20 tokens currently whitelisted for the `SwapRouter` on a
+     * chain — the any-token set a deposit UI can offer as swap-and-deposit inputs.
+     *
+     * Delegates to {@link AugustVaults.getSwapRouterWhitelistedTokens}, which
+     * reconstructs the set from the router's `TokenEnabled` events and verifies
+     * each against the on-chain `whitelistedTokens` mapping (not enumerable).
+     * Returns `[]` when no router is deployed on `chainId` or no provider is
+     * configured for it.
+     *
+     * @param chainId - EVM chain ID to resolve the allowlist for.
+     * @param options - Optional `fromBlock` to override the deploy-block scan floor.
+     * @returns Checksummed whitelisted token addresses; `[]` when unavailable.
+     * @throws AugustSDKError when an `eth_getLogs` scan chunk fails.
+     * @example
+     * ```ts
+     * const tokens = await augustSdk.getSwapRouterWhitelistedTokens(1);
+     * ```
+     */
+    getSwapRouterWhitelistedTokens(chainId: number, options?: {
+        fromBlock?: number;
+    }): Promise<IAddress[]>;
+    /**
+     * Resolve the vaults currently eligible for the any-token `SwapRouter`
+     * deposit surface on a chain — every vault the router has `enableVault`-ed
+     * whose on-chain registration is still live.
+     *
+     * Delegates to {@link AugustVaults.getSwapRouterEligibleVaults}, which
+     * reconstructs the set from the router's `VaultEnabled` events and verifies
+     * each vault's current `vaultInfo` registration (not enumerable). Returns
+     * `[]` when no router is deployed on `chainId` or no provider is configured
+     * for it. On-chain eligibility only — app-level policy (e.g. OVault
+     * exclusions) remains the caller's responsibility.
+     *
+     * @param chainId - EVM chain ID to resolve eligible vaults for.
+     * @param options - Optional `fromBlock` to override the deploy-block scan floor.
+     * @returns Checksummed eligible vault addresses; `[]` when unavailable.
+     * @throws AugustSDKError when an `eth_getLogs` scan chunk fails.
+     * @example
+     * ```ts
+     * const vaults = await augustSdk.getSwapRouterEligibleVaults(1);
+     * ```
+     */
+    getSwapRouterEligibleVaults(chainId: number, options?: {
+        fromBlock?: number;
+    }): Promise<IAddress[]>;
     /**
      * Get lifetime PnL for a user in a specific vault.
      * Calculates realized and unrealized PnL based on deposit/withdrawal history and current position.
@@ -16562,6 +16608,59 @@ export declare class AugustVaults extends AugustBase {
         untilTs?: number;
         types?: IVaultUserHistoryItem['type'][];
     }): Promise<IVaultUserHistoryItem[]>;
+    /**
+     * Resolve the ERC-20 tokens currently whitelisted for the `SwapRouter` on a
+     * chain — the any-token set a deposit UI can offer as swap-and-deposit inputs,
+     * each verified `true` against the router's on-chain allowlist.
+     *
+     * Reconstructs the set from the router's `TokenEnabled` event history and
+     * re-checks `whitelistedTokens(token)` for each (the mapping is not
+     * enumerable). See {@link getSwapRouterWhitelistedTokens} for the full
+     * two-stage behavior and RPC cost. Uses this instance's configured provider
+     * for `chainId`; returns `[]` (no RPC) when no router is deployed there or no
+     * provider is configured.
+     *
+     * @param chainId - EVM chain ID to resolve the allowlist for.
+     * @param options - Optional `fromBlock` to override the deploy-block scan floor.
+     * @returns Checksummed whitelisted token addresses; `[]` when unavailable.
+     *   Callers still exclude a target vault's natively-accepted assets (those
+     *   deposit without a swap).
+     * @throws AugustSDKError when an `eth_getLogs` scan chunk fails.
+     * @example
+     * ```ts
+     * const tokens = await augustSdk.getSwapRouterWhitelistedTokens(1);
+     * ```
+     */
+    getSwapRouterWhitelistedTokens(chainId: number, options?: {
+        fromBlock?: number;
+    }): Promise<IAddress[]>;
+    /**
+     * Resolve the vaults currently eligible for the any-token `SwapRouter`
+     * deposit surface on a chain — every vault the router has `enableVault`-ed
+     * whose on-chain registration is still live.
+     *
+     * Reconstructs the set from the router's `VaultEnabled` event history and
+     * re-checks `vaultInfo(vault).referenceAsset != 0` for each (the mapping is
+     * not enumerable). See {@link getSwapRouterEligibleVaults} for the full
+     * two-stage behavior and RPC cost. Uses this instance's configured provider
+     * for `chainId`; returns `[]` (no RPC) when no router is deployed there or no
+     * provider is configured.
+     *
+     * On-chain eligibility only — app-level policy (e.g. excluding vaults with
+     * their own OVault deposit flow) remains the caller's responsibility.
+     *
+     * @param chainId - EVM chain ID to resolve eligible vaults for.
+     * @param options - Optional `fromBlock` to override the deploy-block scan floor.
+     * @returns Checksummed eligible vault addresses; `[]` when unavailable.
+     * @throws AugustSDKError when an `eth_getLogs` scan chunk fails.
+     * @example
+     * ```ts
+     * const vaults = await augustSdk.getSwapRouterEligibleVaults(1);
+     * ```
+     */
+    getSwapRouterEligibleVaults(chainId: number, options?: {
+        fromBlock?: number;
+    }): Promise<IAddress[]>;
     /**
      * @function getStakingPositions gets all available reward staking positions
      * @param wallet optionally passed user wallet address
@@ -17073,6 +17172,53 @@ export declare function dateToUnix(date: Date): number;
 
 export declare function daysAgo(days: number): Date;
 
+/**
+ * Decode a raw EVM revert blob into a named error with arguments.
+ *
+ * Pure and offline — no RPC calls, no network. Handles the three revert
+ * shapes the EVM produces:
+ *
+ * 1. `Error(string)` (`0x08c379a0`) — a `require`/`revert` with a message.
+ * 2. `Panic(uint256)` (`0x4e487b71`) — compiler-inserted checks, with the
+ *    numeric code translated to its documented meaning (overflow, division by
+ *    zero, …).
+ * 3. Custom errors — matched against a built-in corpus of OpenZeppelin
+ *    ERC-6093 / SafeERC20 / ERC4626 / Ownable / Pausable errors, LayerZero V2
+ *    OApp/OFT errors, and every `error` fragment in the vault ABIs the SDK
+ *    ships (tokenized vaults, SwapRouter, lending pools, …). Callers can
+ *    extend the corpus per call via `opts.extraAbis`, which take precedence.
+ *
+ * Truncated input degrades gracefully: when the 4-byte selector matches a
+ * known error but the argument bytes are incomplete (e.g. an alert pipeline
+ * clipped the hex), the result still carries `kind: 'custom'`, `name`, and
+ * `signature`, with `args` omitted and `reason` explaining the truncation.
+ *
+ * @param data - The revert blob as a `0x`-prefixed hex string (the `data`
+ *   field of an ethers v6 `CALL_EXCEPTION`). Anything shorter than a 4-byte
+ *   selector, or not hex at all, yields `kind: 'unknown'`.
+ * @param opts - Optional settings.
+ * @param opts.extraAbis - Additional ABIs whose `error` fragments are checked
+ *   before the built-in corpus.
+ * @returns The decoded revert. Never throws; unrecognized selectors return
+ *   `kind: 'unknown'` with the selector preserved so callers can look it up
+ *   via {@link lookupSelector}.
+ *
+ * @example
+ * ```ts
+ * const decoded = decodeRevertData('0xe450d38c…');
+ * // {
+ * //   kind: 'custom',
+ * //   selector: '0xe450d38c',
+ * //   name: 'ERC20InsufficientBalance',
+ * //   signature: 'ERC20InsufficientBalance(address,uint256,uint256)',
+ * //   args: ['0x9281…', 487711967n, 1261711967n],
+ * // }
+ * ```
+ */
+export declare function decodeRevertData(data: string, opts?: {
+    extraAbis?: InterfaceAbi[];
+}): IDecodedRevert;
+
 export declare const DEFAULT_FETCH_OPTIONS: {
     readonly method: "GET";
     readonly headers: {
@@ -17582,6 +17728,34 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
    */
   export declare const explorerLink: (hex: IAddress, chain: IChainId, type: IExplorerType) => string;
 
+  /**
+   * Parse an ethers v6 error *string* and recover the machine-readable fields
+   * embedded in it.
+   *
+   * ethers v6 serializes rich error objects into a single message of the shape
+   * `… (action="estimateGas", data="0x…", reason=…, transaction={ "data":
+   * "0x…", "from": "0x…", "to": "0x…" }, …, code=CALL_EXCEPTION, version=…)` —
+   * exactly what error-alert pipelines end up carrying once the original error
+   * object is stringified. This helper regex-extracts the revert `data`, the
+   * `action`, the `code`, and the embedded transaction fields.
+   *
+   * Pure and offline. Tolerant of truncation: alert transports often cap
+   * message length mid-hex, so every field is matched without requiring its
+   * closing quote and the result simply omits whatever did not survive.
+   *
+   * @param text - The error text to parse (an ethers v6 `error.message`, or a
+   *   log/alert line that embeds one).
+   * @returns The recovered fields; an empty object when nothing matched. Never
+   *   throws.
+   *
+   * @example
+   * ```ts
+   * const ctx = extractRevertFromErrorText(alertErrorLine);
+   * if (ctx.revertData) console.log(decodeRevertData(ctx.revertData));
+   * ```
+   */
+  export declare function extractRevertFromErrorText(text: string): IExtractedRevertContext;
+
   export declare const FALLBACK_CHAINID = 42161;
 
   /**
@@ -18285,6 +18459,130 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                 */
             export declare function getSwapRouterDepositResult(signer: Signer | Wallet, { txHash, vault }: ISwapRouterDepositResultOptions): Promise<ISwapRouterDepositResult | null>;
 
+            /**
+             * Resolve the vaults currently eligible for the any-token `SwapRouter` deposit
+             * surface on a chain — i.e. every vault the router has `enableVault`-ed that is
+             * still registered on-chain.
+             *
+             * The router stores registrations as `mapping(address => VaultInfo) vaultInfo`
+             * with **no on-chain enumeration**, so (exactly like
+             * {@link getSwapRouterWhitelistedTokens}) this runs in two stages:
+             *  1. Scan the router's `VaultEnabled(address)` event history (from the chain's
+             *     {@link SWAP_ROUTER_DEPLOY_BLOCKS} floor, in `eth_getLogs` chunks sized by
+             *     {@link determineBlockSkipInternal}) to reconstruct the candidate set of
+             *     every vault ever enabled.
+             *  2. Re-read `vaultInfo(vault)` for each candidate — batched via Multicall3
+             *     where verified, else per-call — and keep only those whose
+             *     `referenceAsset != address(0)` (an unregistered vault reverts with
+             *     `InvalidVault` at deposit time). This makes later disables correct
+             *     without replaying `VaultDisabled`, and is the fail-closed source of
+             *     truth: a vault surfaces only on a definite on-chain registration.
+             *
+             * This is the dynamic successor to the static
+             * {@link SWAP_ROUTER_ELIGIBLE_VAULTS} snapshot / {@link isSwapRouterEligible}.
+             * It reports **on-chain eligibility only** — app-level policy (e.g. excluding
+             * OVault-enabled vaults that have their own deposit flow) remains the caller's
+             * responsibility, as does the flag gating of the UI surface.
+             *
+             * The resolved list is cached per chain for 5 minutes — registrations change
+             * only via an admin `enableVault`/`disableVault` transaction, so a short TTL
+             * keeps the (multi-RPC) scan off the hot path without going stale for long.
+             *
+             * @param chainId - EVM chain ID. Chains without a {@link SWAP_ROUTER_ADDRESSES}
+             *   entry resolve to `[]` with no RPC.
+             * @param options - `rpcUrl` (required) must point at `chainId`'s network;
+             *   `fromBlock` overrides the default deploy-block scan floor.
+             * @returns Checksummed addresses of the currently-registered eligible vaults,
+             *   deduped. Empty when no router is deployed or none are registered.
+             * @throws AugustValidationError when `rpcUrl` is missing/empty.
+             * @throws AugustSDKError when an `eth_getLogs` chunk fails — surfaced (not
+             *   swallowed) so a partial scan never masquerades as the complete set.
+             * @worstCaseRpcCalls On mainnet, 1 `eth_blockNumber` + ~4 `eth_getLogs` chunks
+             *   (router-lifetime ÷ 50k-block window) + 1 Multicall3 `eth_call` ≈ 6; scales
+             *   with the router's on-chain age, not with candidate count.
+             * @example
+             * ```ts
+             * const vaults = await getSwapRouterEligibleVaults(1, {
+             *   rpcUrl: 'https://eth-mainnet.example/v2/KEY',
+             * });
+             * // ['0x74aD…718b', '0xE9B7…9D32']  (Sentora USD, Upshift Core USDC)
+             * ```
+             */
+            export declare function getSwapRouterEligibleVaults(chainId: number, options: {
+                rpcUrl: string;
+                fromBlock?: number;
+            }): Promise<IAddress[]>;
+
+            /**
+             * Resolve the human-readable display name of the `SwapRouter` periphery
+             * contract for a chain.
+             *
+             * The contract exposes no name on-chain, so this reads the SDK-maintained
+             * {@link SWAP_ROUTER_NAMES} registry. Intended for UI surfaces that label the
+             * contract a swap-and-deposit routes through (e.g. a "Router" row in a
+             * transaction overview) — display metadata only, never routing logic.
+             *
+             * @param chainId - EVM chain ID.
+             * @returns The display name (e.g. `'Upshift Swap Router'`), or `undefined`
+             *   when no SwapRouter is deployed on the chain — callers should omit the
+             *   label rather than show an address.
+             * @example
+             * ```ts
+             * const name = getSwapRouterName(1);
+             * // 'Upshift Swap Router'
+             * ```
+             */
+            export declare function getSwapRouterName(chainId: number): string | undefined;
+
+            /**
+             * Resolve the ERC-20 tokens currently whitelisted for the `SwapRouter` on a
+             * chain — the any-token set a UI can offer as swap-and-deposit inputs.
+             *
+             * The router exposes its allowlist only as `mapping(address => bool)
+             * whitelistedTokens` with **no on-chain enumeration**, so this cannot be a
+             * single view call. It runs in two stages:
+             *  1. Scan the router's `TokenEnabled(address)` event history (from the chain's
+             *     {@link SWAP_ROUTER_DEPLOY_BLOCKS} floor, in `eth_getLogs` chunks sized by
+             *     {@link determineBlockSkipInternal}) to reconstruct the candidate set of
+             *     every token ever enabled.
+             *  2. Re-read `whitelistedTokens(token)` for each candidate — batched via
+             *     Multicall3 where verified, else per-call — and keep only those the
+             *     mapping currently returns `true` for. This step makes later disables (and
+             *     disable-then-re-enable) correct without replaying `TokenDisabled`, and is
+             *     the fail-closed source of truth: a token surfaces only on a definite
+             *     on-chain `true`.
+             *
+             * The resolved list is cached per chain for 5 minutes — the allowlist changes
+             * only via an admin `enableToken`/`disableToken` transaction, so a short TTL
+             * keeps the (multi-RPC) scan off the hot path without going stale for long.
+             *
+             * @param chainId - EVM chain ID. Chains without a {@link SWAP_ROUTER_ADDRESSES}
+             *   entry resolve to `[]` with no RPC.
+             * @param options - `rpcUrl` (required) must point at `chainId`'s network;
+             *   `fromBlock` overrides the default deploy-block scan floor (e.g. to widen a
+             *   scan on a chain missing from {@link SWAP_ROUTER_DEPLOY_BLOCKS}).
+             * @returns Checksummed addresses of the currently-whitelisted tokens, deduped.
+             *   Empty when no router is deployed or none are enabled. Callers still filter
+             *   out a given vault's natively-accepted assets (those deposit without a swap).
+             * @throws AugustValidationError when `rpcUrl` is missing/empty.
+             * @throws AugustSDKError when an `eth_getLogs` chunk fails — surfaced (not
+             *   swallowed) so a partial scan never masquerades as a complete allowlist.
+             * @worstCaseRpcCalls On mainnet, 1 `eth_blockNumber` + ~4 `eth_getLogs` chunks
+             *   (router-lifetime ÷ 50k-block window) + 1 Multicall3 `eth_call` ≈ 6; scales
+             *   with the router's on-chain age, not with candidate count.
+             * @example
+             * ```ts
+             * const tokens = await getSwapRouterWhitelistedTokens(1, {
+             *   rpcUrl: 'https://eth-mainnet.example/v2/KEY',
+             * });
+             * // ['0xA0b8…', '0xdAC1…', '0xC02a…', '0x2260…']  (USDC, USDT, WETH, WBTC)
+             * ```
+             */
+            export declare function getSwapRouterWhitelistedTokens(chainId: number, options: {
+                rpcUrl: string;
+                fromBlock?: number;
+            }): Promise<IAddress[]>;
+
             /**
              * Fetch token symbol from contract.
              * Results are cached to minimize RPC calls.
@@ -18601,6 +18899,21 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                 coingeckoKey?: string;
             }): Promise<IVaultUserLifetimePnl>;
 
+            /**
+             * Classify a vault's protocol version from its address alone.
+             *
+             * @deprecated Use {@link getVaultVersionV2} instead. This V1 classifier can only
+             * recognise a multi-asset vault (`evm-2`) if its address is hard-coded in the
+             * static `MULTI_ASSET_VAULTS` list. Any multi-asset vault missing from that list
+             * is silently misclassified as `evm-1`, which broke deposit preview/simulation in
+             * the 2026-07-06 Sentora incident. `getVaultVersionV2` reads the backend
+             * `internal_type` (falling back to the static list only as a safety net), so new
+             * vaults classify correctly without a code change. Retained as a non-breaking
+             * shim; scheduled for removal in the next major.
+             *
+             * @param vault - The vault contract address (EVM `0x…`, Solana, or Stellar).
+             * @returns The vault version slug, or `undefined` for empty/invalid input.
+             */
             export declare function getVaultVersion(vault: string): IVaultVersion | undefined;
 
             export declare function getVaultVersionV2(vault: (Pick<ITokenizedVault, 'address'> & {
@@ -19472,6 +19785,33 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                 portfolio_item_list: IDebankPortfolioItemObject[];
             }
 
+            /** Result of decoding a raw revert blob with {@link decodeRevertData}. */
+            export declare interface IDecodedRevert {
+                /**
+                 * `'error-string'` for `Error(string)` (a `require` message), `'panic'` for
+                 * compiler-inserted `Panic(uint256)`, `'custom'` when the selector matched a
+                 * corpus (or caller-supplied) custom error, `'unknown'` when nothing matched.
+                 */
+                kind: IRevertKind;
+                /** The 4-byte selector (`0x` + 8 hex chars), always present — even for `'unknown'` so callers can 4byte-lookup it. */
+                selector: string;
+                /** Error name (e.g. `'ERC20InsufficientBalance'`, `'Error'`, `'Panic'`). Absent for `'unknown'`. */
+                name?: string;
+                /** Full error signature (e.g. `'ERC20InsufficientBalance(address,uint256,uint256)'`). Absent for `'unknown'`. */
+                signature?: string;
+                /**
+                 * Decoded arguments in declaration order (`bigint` for integers, checksummed
+                 * strings for addresses). Absent when the selector matched but the argument
+                 * bytes were truncated or malformed — see {@link IDecodedRevert.reason}.
+                 */
+                args?: unknown[];
+                /**
+                 * Human-readable summary when one exists: the `Error(string)` message, the
+                 * named `Panic` code, or a note that the argument data was truncated.
+                 */
+                reason?: string;
+            }
+
             /**
              * A token's discount-factor ladder from `GET /risk/discount_factors`
              * (backend `DiscountFactorRead` schema). `steps` are ascending notional
@@ -19564,6 +19904,22 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                 loanBalance: number;
             };
 
+            /** Fields recovered from an ethers v6 error string by {@link extractRevertFromErrorText}. */
+            export declare interface IExtractedRevertContext {
+                /** The revert blob from the top-level `data="0x…"` field, when present. */
+                revertData?: string;
+                /** The failed operation from `action="…"` (e.g. `'estimateGas'`, `'call'`). */
+                action?: string;
+                /** The ethers error code from `code=…` (e.g. `'CALL_EXCEPTION'`). */
+                code?: string;
+                /** The embedded `transaction={ … }` fields that survived, when any did. */
+                tx?: {
+                    from?: string;
+                    to?: string;
+                    data?: string;
+                };
+            }
+
             /**
              * API Fetching and Data Utilities
              *
@@ -20160,6 +20516,9 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                 refundChainId?: number;
             }
 
+            /** The revert shapes {@link decodeRevertData} distinguishes. */
+            export declare type IRevertKind = 'error-string' | 'panic' | 'custom' | 'unknown';
+
             /**
              * Result of the public `GET /revert_reason` endpoint (backend `RevertResponse`
              * schema) — the decoded failure reasons for a reverted transaction, collected
@@ -20286,6 +20645,23 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
              */
             export declare function isHubOnlyReceipt(vault: IAddress): boolean;
 
+            /** Result of an {@link simulateCall} `eth_call` replay. */
+            export declare type ISimulateCallResult = {
+                /** The call succeeded. */
+                ok: true;
+                /** The raw return data of the call, `0x`-prefixed. */
+                returnData: string;
+            } | {
+                /** The call reverted or the node rejected it. */
+                ok: false;
+                /** Fresh, untruncated revert blob when the node returned one. */
+                revertData?: string;
+                /** {@link decodeRevertData} applied to `revertData`, when present. */
+                decoded?: IDecodedRevert;
+                /** The underlying error message, for failures without revert data. */
+                errorMessage: string;
+            };
+
             export declare function isInsufficientFundsError(error: unknown): boolean;
 
             /* Excluded from this release type: isMulticall3Supported */
@@ -20413,6 +20789,11 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
              *
              * @param vaultAddress - August vault address.
              * @returns `true` when the vault is in {@link SWAP_ROUTER_ELIGIBLE_VAULTS}.
+             * @deprecated Superseded by {@link getSwapRouterEligibleVaults}, which resolves
+             * eligibility from the router's on-chain `VaultEnabled` history + current
+             * `vaultInfo` registration instead of this static snapshot. Kept functional as
+             * the zero-RPC sync fallback (seed data, fail-fast checks); migrate UI gates
+             * to the async resolver.
              */
             export declare function isSwapRouterEligible(vaultAddress: IAddress): boolean;
 
@@ -21081,6 +21462,26 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                 strategist: ITokenizedVaultStrategist;
             }
 
+            /** Snapshot of a holder's token state returned by {@link readTokenState}. */
+            export declare interface ITokenState {
+                /** Token symbol, when the contract implements `symbol()`. */
+                symbol?: string;
+                /** Token decimals, when the contract implements `decimals()`. */
+                decimals?: number;
+                /** The holder's raw balance in base units, when `balanceOf` resolved. */
+                balance?: bigint;
+                /** Raw allowance from holder to `spender`, only probed when `spender` was given. */
+                allowance?: bigint;
+                /**
+                 * Whether the holder is frozen/blacklisted by the token issuer, from the
+                 * first compliance getter the token implements (`isAccountFrozen` — Agora
+                 * AUSD, `isBlacklisted` — USDC-style, `isFrozen`). `undefined` when the
+                 * token exposes none of them — which is NOT evidence the holder is clear,
+                 * only that the token has no recognized compliance getter.
+                 */
+                frozen?: boolean;
+            }
+
             /**
              * One unrealized-PnL snapshot for a vault, computed by the August backend
              * from periodic vault state. `timestamp` is an ISO-8601 datetime; monetary
@@ -22306,6 +22707,28 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                 };
             };
 
+            /**
+             * Look up candidate signatures for an unknown 4-byte selector against public
+             * signature databases.
+             *
+             * Network helper — queries [openchain.xyz](https://openchain.xyz) first and
+             * falls back to [4byte.directory](https://www.4byte.directory). Kept separate
+             * from {@link decodeRevertData} so the core decode path stays offline.
+             * Worst case 2 HTTPS requests.
+             *
+             * @param selector - The selector to look up. Longer hex (a full revert blob)
+             *   is accepted; only the first 4 bytes are used.
+             * @returns Candidate signatures (e.g. `['ERC20InsufficientBalance(address,uint256,uint256)']`),
+             *   most-likely first. Empty when the input is not hex, no database knows the
+             *   selector, or both databases were unreachable. Never throws.
+             *
+             * @example
+             * ```ts
+             * const candidates = await lookupSelector('0xe450d38c');
+             * ```
+             */
+            export declare function lookupSelector(selector: string): Promise<string[]>;
+
             /**
              * Map composability integrations from backend format to vault format.
              * Shared across all chain adapters.
@@ -22600,6 +23023,38 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
              */
             export declare function readEnv(name: string): string | undefined;
 
+            /**
+             * Read a bounded, fixed set of token-state probes for a holder — the exact
+             * facts needed to explain a failed deposit/transfer: what the token is, what
+             * the holder has, what the spender may pull, and whether the issuer froze the
+             * holder.
+             *
+             * The probe set is deliberately fixed (no arbitrary calldata): `symbol()`,
+             * `decimals()`, `balanceOf(holder)`, `allowance(holder, spender)` when a
+             * spender is given, and the compliance getters tried in order —
+             * `isAccountFrozen(address)` (Agora AUSD, selector `0xe816d97f`),
+             * `isBlacklisted(address)` (USDC-style), `isFrozen(address)`. Probes the
+             * token does not implement resolve to `undefined`; this function never
+             * throws.
+             *
+             * Worst case 7 RPC calls (4 base probes + 3 compliance getters), batched by
+             * the provider where supported.
+             *
+             * @param provider - A connected `JsonRpcProvider` for the token's chain.
+             * @param token - The ERC-20 token contract address.
+             * @param holder - The account whose balance/compliance state to read.
+             * @param spender - Optional spender for the `allowance(holder, spender)`
+             *   probe (e.g. the vault a deposit approves).
+             * @returns The token state with every unresolvable probe as `undefined`.
+             *
+             * @example
+             * ```ts
+             * const state = await readTokenState(provider, ausd, eoa, vault);
+             * // { symbol: 'AUSD', decimals: 6, balance: 487711967n, allowance: 0n, frozen: false }
+             * ```
+             */
+            export declare function readTokenState(provider: JsonRpcProvider, token: string, holder: string, spender?: string): Promise<ITokenState>;
+
             /**
              * Register a user for the points program, authenticated by a wallet signature.
              *
@@ -22686,6 +23141,48 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
 
             /* Excluded from this release type: resolveDepositTokenDecimals */
 
+            /**
+             * Resolve whether a single fee (management or performance) is currently waived.
+             *
+             * Backend-driven, per AUGUST-5584. This centralizes logic that previously lived —
+             * and diverged — across two upshift-app components. The resolution is deliberately
+             * split between the backend and the SDK:
+             *
+             * - The backend `isFeeWaivedToggle` (`platform_fee_override.is_fee_waived`) is both
+             *   the master enable AND the TVL latch. Retool config takes precedence over live
+             *   TVL, and the backend flips this flag `false` once live TVL crosses the
+             *   configured threshold. That flip is one-way: if TVL later falls back below the
+             *   threshold the waiver does NOT re-apply. The SDK therefore does no TVL math and
+             *   never reads `latest_reported_tvl` here — trusting the flag preserves the latch.
+             * - The **date** window is time-dependent, so it cannot be a static DB flag; the SDK
+             *   evaluates it live against the clock.
+             *
+             * Resolution:
+             * - Toggle off  → never waived (also the only "hide" path once TVL trips the latch).
+             * - Toggle on, both date and TVL blank → indefinite manual waiver → waived.
+             * - Toggle on with a date window → waived while `now < waivedUntilDate`.
+             * - Toggle on with a TVL threshold configured → waived (the backend keeps the toggle
+             *   on only while live TVL is under the threshold).
+             *
+             * @param isFeeWaivedToggle - Backend master/TVL-latch flag. `false` ⇒ never waived.
+             * @param waivedUntilDate - ISO datetime string the waiver runs until, or `null` for
+             *   no date window. An unparseable string yields `NaN`, which is never `> now`, so
+             *   it correctly contributes no date-based waiver.
+             * @param waivedUntilTvl - Configured TVL threshold in whole USD, or `null`. Used only
+             *   to detect that a TVL-based waiver was set (values `<= 0` are treated as unset);
+             *   the threshold comparison itself is owned by the backend.
+             * @param now - Clock, injected for deterministic testing. Defaults to `new Date()`.
+             * @returns `true` if the UI should present this fee as "Fee Waived" right now.
+             * @example
+             * ```ts
+             * // Toggle on, 30-day window still open → waived.
+             * resolveFeeWaived(true, '2099-01-01T00:00:00Z', null); // true
+             * // Toggle off overrides everything → not waived.
+             * resolveFeeWaived(false, '2099-01-01T00:00:00Z', 10_000_000); // false
+             * ```
+             */
+            export declare function resolveFeeWaived(isFeeWaivedToggle: boolean, waivedUntilDate: string | null, waivedUntilTvl: number | null, now?: Date): boolean;
+
             /**
              * Normalize an optional origin code to the value to send on-chain.
              *
@@ -23607,6 +24104,51 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
              /** Plug in an `ILogger`. Independent of `setLogger`; pass `null` to clear. */
              declare function setStructuredLogger(custom: ILogger | null): void;
 
+             /**
+              * Replay a call via `eth_call` and decode the revert when it fails.
+              *
+              * The primary use is re-executing a transaction that failed at `estimateGas`
+              * (so no transaction hash ever existed): the node returns the *full* revert
+              * blob, which both confirms the failure still reproduces and recovers
+              * untruncated revert data even when the original error text was clipped in
+              * transit. Passing a historical `blockTag` replays against archival state
+              * (requires an archive-capable RPC).
+              *
+              * Exactly 1 RPC call (`eth_call`).
+              *
+              * @param provider - A connected `JsonRpcProvider` for the target chain, e.g.
+              *   from `createProvider(rpcUrl, chainId)`. Note that some listed public RPCs
+              *   reject keyless `eth_call` — supply a working endpoint via the SDK's RPC
+              *   precedence (constructor `providers` map / `AUGUST_RPC_<chainId>` env).
+              * @param tx - The call to replay: `to` and `data` are required, `from`
+              *   matters whenever the target checks `msg.sender`.
+              * @param blockTag - Optional block to execute against (`'latest'` by
+              *   default; a number or hex tag replays historical state).
+              * @param opts - Optional settings forwarded to {@link decodeRevertData}.
+              * @param opts.extraAbis - Additional ABIs checked before the built-in corpus
+              *   when decoding a revert.
+              * @returns `{ ok: true, returnData }` on success; on failure `{ ok: false }`
+              *   with the fresh `revertData` and its decode when the node supplied one.
+              *   Never throws on revert — only on programmer error (e.g. no provider).
+              *
+              * @example
+              * ```ts
+              * const result = await simulateCall(provider, {
+              *   from: eoa,
+              *   to: vault,
+              *   data: calldata,
+              * });
+              * if (!result.ok && result.decoded) console.log(result.decoded.signature);
+              * ```
+              */
+             export declare function simulateCall(provider: JsonRpcProvider, tx: {
+                 from?: string;
+                 to: string;
+                 data: string;
+             }, blockTag?: string | number, opts?: {
+                 extraAbis?: InterfaceAbi[];
+             }): Promise<ISimulateCallResult>;
+
              /**
               * Simulate contract transaction without executing on-chain.
               * Useful for testing transaction viability before sending.
@@ -24095,6 +24637,24 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                         */
                        export declare const SWAP_ROUTER_ADDRESSES: Readonly<Record<number, IAddress>>;
 
+                       /**
+                        * Block at which each chain's `SwapRouter` was deployed/configured — the safe
+                        * lower bound for scanning its `TokenEnabled` / `VaultEnabled` log history.
+                        *
+                        * The router stores its allowlist as `mapping(address => bool) whitelistedTokens`
+                        * with no on-chain enumeration, so {@link getSwapRouterWhitelistedTokens} must
+                        * reconstruct the candidate set from `TokenEnabled` events before verifying each
+                        * against the current mapping. Starting the `eth_getLogs` scan here (rather than
+                        * from genesis) bounds it to the router's own lifetime — a few chunks — instead
+                        * of the whole chain.
+                        *
+                        * Mainnet value is the router's deployment block (its first emitted event, the
+                        * constructor `OwnershipTransferred`). A too-low value only costs extra empty
+                        * log ranges; a value ABOVE the first `TokenEnabled` would silently miss tokens,
+                        * so err on the side of earlier.
+                        */
+                       export declare const SWAP_ROUTER_DEPLOY_BLOCKS: Readonly<Record<number, number>>;
+
                        /**
                         * The DEX aggregator whitelisted on each chain's `SwapRouter` via
                         * `enableRouter`, plus the single aggregator contract method every swap leg is
@@ -24157,6 +24717,13 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                         *
                         * Lowercase comparison is required when checking — use
                         * {@link isSwapRouterEligible} rather than reading this set directly.
+                        *
+                        * @deprecated Superseded by {@link getSwapRouterEligibleVaults}, which derives
+                        * the eligible set from the router's on-chain `VaultEnabled` history and
+                        * verifies each vault's current registration (`vaultInfo.referenceAsset != 0`)
+                        * — so new enablements surface without an SDK release. This static set stays
+                        * functional as the zero-RPC fallback seed (e.g. TanStack Query `initialData`)
+                        * and for SDK-internal sync consumers.
                         */
                        export declare const SWAP_ROUTER_ELIGIBLE_VAULTS: ReadonlySet<string>;
 
@@ -24170,6 +24737,21 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                         */
                        export declare const SWAP_ROUTER_MAX_SWAPS = 9;
 
+                       /**
+                        * Human-readable display name of the `SwapRouter` periphery contract on each
+                        * supported chain.
+                        *
+                        * The contract exposes no on-chain name (no `@title` accessor), so UIs that
+                        * want to show *which contract* performed the swap-and-deposit — rather than a
+                        * bare address — read it from here. Display metadata only: never derive
+                        * routing or eligibility logic from it.
+                        *
+                        * Missing keys mean no SwapRouter is deployed on that chain.
+                        *
+                        * @see {@link getSwapRouterName} for the typed lookup helper.
+                        */
+                       export declare const SWAP_ROUTER_NAMES: Readonly<Record<number, string>>;
+
                        /**
                         * Wrapped-native ERC-20 per chain that has a SwapRouter deployment. Mirrors
                         * the on-chain `wrappedNativeTokenAddress()` view to avoid an extra RPC on
@@ -25002,10 +25584,12 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                              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.
+                              * @deprecated Renamed to {@link SWAP_ROUTER_ELIGIBLE_VAULTS} (itself now
+                              * superseded by {@link getSwapRouterEligibleVaults}, the on-chain-derived
+                              * resolver), and the semantics changed: this set no longer drives
+                              * `vaultDeposit` auto-routing (that branch was removed) — it only marks vaults
+                              * whose UI may offer the swap-router deposit surface. Kept as an alias for one
+                              * release; migrate to the async resolver.
                               */
                              export declare const VAULTS_USING_SWAP_ROUTER: ReadonlySet<string>;
 
@@ -25016,10 +25600,12 @@ export declare function depositNative(signer: Signer | Wallet, options: INativeD
                              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.
+                              * @deprecated Renamed to {@link isSwapRouterEligible} (itself now superseded by
+                              * {@link getSwapRouterEligibleVaults}, the on-chain-derived resolver). The
+                              * meaning also changed: it no longer implies `vaultDeposit` routes the vault
+                              * through the SwapRouter (that behavior was removed) — it only reports
+                              * swap-router *eligibility* for the opt-in deposit surface. Kept as an alias
+                              * for one release; migrate to the async resolver.
                               */
                              export declare const vaultUsesSwapRouter: typeof isSwapRouterEligible;