@augustdigital/sdk 9.9.1 → 9.11.0

package/lib/modules/vaults/write.actions.js

@@ -515,6 +515,12 @@ async function resolveDepositRoute(signer, args) {
     if (!(await (0, core_1.readSwapRouterTokenWhitelisted)(signer, chainId, actualDepositAsset))) {
         return native('router-token-not-whitelisted');
     }
+    // After the cached registration gates, so only a deposit that would
+    // otherwise route pays the short-TTL read; before the origin check, so a
+    // paused router falls back to native instead of throwing under strictOrigin.
+    if (await (0, core_1.readSwapRouterPaused)(signer, chainId)) {
+        return native('router-paused');
+    }
     if (!(await (0, core_1.readOriginInfo)(chainId, originCode, () => signer)).registered) {
         if ((0, core_1.isStrictOrigin)()) {
             throw new core_1.AugustValidationError('INVALID_INPUT', `attribution.originCode is not registered on the SwapRouter for chain ${chainId} and attribution.strictOrigin is set. Register it with addOrigin, or unset strictOrigin to fall back to a native deposit.`, { context: { chainId, target } });
@@ -534,23 +540,25 @@ async function resolveDepositRoute(signer, args) {
  * Ethereum mainnet ({@link ORIGIN_ATTRIBUTION_CHAINS}) and has a SwapRouter,
  * the vault is registered on it, the vault accepts the asset directly (its
  * reference asset, or a Tokenized Vault V2 whitelisted asset — deposited
- * as-is, never swapped), the router whitelists the asset, the deposit is not a
- * permit, native-token or adapter deposit, and the code is registered.
- * Otherwise it is `native` with a `reason`.
+ * as-is, never swapped), the router whitelists the asset, the router is not
+ * paused, the deposit is not a permit, native-token or adapter deposit, and
+ * the code is registered. Otherwise it is `native` with a `reason`. A paused
+ * router gives `router-paused` even under `attribution.strictOrigin`.
  *
  * @param signer - ethers `Signer` / `Wallet` used for the reads.
  * @param options - {@link IGetDepositRouteOptions}; `depositAsset` defaults
  *   to the vault's underlying.
  * @returns {@link IDepositRoute}.
  * @throws AugustValidationError on an invalid `target`, or an unregistered
- *   code under `attribution.strictOrigin`.
+ *   code under `attribution.strictOrigin` while the router is not paused.
  * @throws AugustSDKError when a backend, vault or router read fails.
- * @worstCaseRpcCalls 7 — the backend vault row, `asset()`, the router's
+ * @worstCaseRpcCalls 8 — the backend vault row, `asset()`, the router's
  *   `vaultInfo`, the vault's `assetsWhitelistAddress()` and
  *   `getWhitelistedAssets()` (Tokenized Vault V2 non-reference asset only),
- *   the router's `whitelistedTokens(asset)`, and the router's `origins`. The
- *   router reads and `getWhitelistedAssets()` are cached for 5 minutes. No
- *   router read without a code or off Ethereum mainnet.
+ *   the router's `whitelistedTokens(asset)`, `isPaused()` and `origins`. The
+ *   router reads and `getWhitelistedAssets()` are cached for 5 minutes, except
+ *   `isPaused()` (15 seconds). No router read without a code or off Ethereum
+ *   mainnet.
  * @example
  * ```ts
  * const route = await augustSdk.evm.getDepositRoute({ target: vault, depositAsset: usdt });
@@ -1752,6 +1760,19 @@ async function resolveRouterOriginCode(signer, operation, chainId, vault, provid
     trackOriginAttribution({ via: 'native', spender: null, reason: 'origin-not-registered' }, { chainId, target: vault }, operation);
     return core_1.ORIGIN_CODES.default;
 }
+/**
+ * Throw before any approval when the chain's SwapRouter is paused. Every
+ * router entry point reverts with `ContractIsPaused` while it is paused, so an
+ * approval sent first would only cost the user gas. Unlike `vaultDeposit`,
+ * these methods have no native path to fall back to: the caller asked for the
+ * router.
+ * @internal
+ */
+async function assertSwapRouterNotPaused(signer, operation, chainId, vault) {
+    if (!(await (0, core_1.readSwapRouterPaused)(signer, chainId)))
+        return;
+    throw new core_1.AugustSDKError('UNKNOWN', `${operation}: the SwapRouter on chain ${chainId} is paused and rejects every deposit. Deposit into the vault directly with vaultDeposit, or retry once the router is unpaused.`, { context: { chainId, vault, reason: 'router-paused' } });
+}
 /** @internal */
 function resolveSwapRouterOrThrow(chainId) {
     const router = (0, core_1.getSwapRouterAddress)(chainId);
@@ -1848,7 +1869,8 @@ async function resolveSignerEOA(signer, callerContext) {
  * addresses, empty/oversized swap arrays, or an origin code not registered on
  * the router (a per-call code, or the instance code under
  * `attribution.strictOrigin`), before any approval.
- * @throws {@link AugustSDKError} on unrecoverable contract or RPC failure.
+ * @throws {@link AugustSDKError} while the SwapRouter is paused (checked before
+ * any approval), or on unrecoverable contract or RPC failure.
  *
  * @example
  * ```ts
@@ -1887,6 +1909,7 @@ async function swapAndDeposit(signer, options) {
     const routerAddress = resolveSwapRouterOrThrow(chainId);
     let tx;
     try {
+        await assertSwapRouterNotPaused(signer, 'swapAndDeposit', chainId, vault);
         const origin = await resolveRouterOriginCode(signer, 'swapAndDeposit', chainId, vault, originCode);
         const eoa = await resolveSignerEOA(signer, 'swapAndDeposit');
         for (const [tokenIn, totalIn] of totalInputPerToken(swaps)) {
@@ -1923,7 +1946,8 @@ async function swapAndDeposit(signer, options) {
  * per-call code, or the instance code under `attribution.strictOrigin`),
  * before any approval; with code `ACCOUNT_NOT_FUNDED` when the account cannot
  * cover gas.
- * @throws {@link AugustSDKError} on unrecoverable contract or RPC failure.
+ * @throws {@link AugustSDKError} while the SwapRouter is paused (checked before
+ * any approval), or on unrecoverable contract or RPC failure.
  */
 async function depositViaSwapRouter(signer, options) {
     const { chainId, vault, receiver, asset, amount, originCode, wait } = options;
@@ -1939,6 +1963,7 @@ async function depositViaSwapRouter(signer, options) {
     const routerAddress = resolveSwapRouterOrThrow(chainId);
     let tx;
     try {
+        await assertSwapRouterNotPaused(signer, 'depositViaSwapRouter', chainId, vault);
         const origin = await resolveRouterOriginCode(signer, 'depositViaSwapRouter', chainId, vault, originCode);
         const eoa = await resolveSignerEOA(signer, 'depositViaSwapRouter');
         await ensureAllowance(signer, asset, eoa, routerAddress, amount);
@@ -1984,7 +2009,8 @@ async function depositViaSwapRouter(signer, options) {
  * per-call code, or the instance code under `attribution.strictOrigin`),
  * before any approval; with code `ACCOUNT_NOT_FUNDED` when the account cannot
  * cover gas.
- * @throws {@link AugustSDKError} on unrecoverable contract or RPC failure.
+ * @throws {@link AugustSDKError} while the SwapRouter is paused (checked before
+ * any approval), or on unrecoverable contract or RPC failure.
  */
 async function depositNativeViaSwapRouter(signer, options) {
     const { chainId, vault, receiver, amount, originCode, wait } = options;
@@ -1999,6 +2025,7 @@ async function depositNativeViaSwapRouter(signer, options) {
     const routerAddress = resolveSwapRouterOrThrow(chainId);
     let tx;
     try {
+        await assertSwapRouterNotPaused(signer, 'depositNativeViaSwapRouter', chainId, vault);
         const origin = await resolveRouterOriginCode(signer, 'depositNativeViaSwapRouter', chainId, vault, originCode);
         const routerContract = (0, core_1.createContract)({
             address: routerAddress,
@@ -2141,14 +2168,16 @@ async function isNativeSwapRouterDepositSupported(chainId, vault, options) {
  *   not registered on the router (a per-call code, or the instance code under
  *   `attribution.strictOrigin`), before any approval; with code
  *   `ACCOUNT_NOT_FUNDED` when the account cannot cover gas.
- * @throws {@link AugustSDKError} on unrecoverable contract or RPC failure.
- * @worstCaseRpcCalls 10 on the swap path into a Tokenized Vault V2 —
+ * @throws {@link AugustSDKError} while the SwapRouter is paused (checked before
+ * any approval), or on unrecoverable contract or RPC failure.
+ * @worstCaseRpcCalls 11 on the swap path into a Tokenized Vault V2 —
  *   tokenized-vault metadata, reference asset + decimals, deposit-token
  *   decimals, the router's `vaultInfo` and `whitelistedTokens`, the vault's
  *   `assetsWhitelistAddress()` and `getWhitelistedAssets()`, the quote, the
- *   origin code's `origins` (none for the zero sentinel), and the allowance
- *   read. The router reads and `getWhitelistedAssets()` are cached for 5
- *   minutes.
+ *   router's `isPaused()`, the origin code's `origins` (none for the zero
+ *   sentinel), and the allowance read. The router reads and
+ *   `getWhitelistedAssets()` are cached for 5 minutes, except `isPaused()`
+ *   (15 seconds).
  * @example
  * ```ts
  * // USDT deposited into a USDC-reference vault → swapped to USDC en route.

package/lib/sdk.d.ts

@@ -1,8 +1,9 @@
 import type { Abi } from 'abitype';
 import type { AbiParametersToPrimitiveTypes } from 'abitype';
-import type { AnchorProvider } from '@coral-xyz/anchor';
+import { AnchorProvider } from '@coral-xyz/anchor';
 import type { BaseContract } from 'ethers';
 import { Commitment } from '@solana/web3.js';
+import { ConfirmOptions } from '@solana/web3.js';
 import { Connection } from '@solana/web3.js';
 import type { ContractTransaction } from 'ethers';
 import type { ContractTransactionResponse } from 'ethers';
@@ -28,9 +29,12 @@ import type { Result } from 'ethers';
 import type { SendTransactionOptions } from '@solana/wallet-adapter-base';
 import type * as Sentry from '@sentry/browser';
 import { Signer } from 'ethers';
+import { Signer as Signer_2 } from '@solana/web3.js';
 import { Transaction } from '@solana/web3.js';
 import { TransactionReceipt } from 'ethers';
 import { TransactionResponse } from 'ethers';
+import { TransactionSignature } from '@solana/web3.js';
+import { VersionedTransaction } from '@solana/web3.js';
 import { Wallet } from 'ethers';
 import type { WalletClient } from 'viem';
 import { web3 } from '@coral-xyz/anchor';
@@ -15201,9 +15205,14 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
    * position as pure profit — a plausible-looking but wrong number.
    *
    * This guard rejects exactly that state: a non-zero position with no recorded
-   * deposits *and* no recorded withdrawals. Any of the following is treated as
-   * consistent and passes:
+   * deposits, no shares received by transfer *and* no recorded withdrawals. It
+   * also rejects a non-zero position with no recorded deposits when a share mint
+   * to the wallet has no matching deposit (`mintsMatchHistory: false`): the mint
+   * proves a deposit the history failed to return, so neither a peer transfer
+   * nor a withdrawal makes the cost basis complete. Otherwise, any of the
+   * following is treated as consistent and passes:
    * - deposits are present (the normal, computable case);
+   * - shares were received by transfer and priced (see {@link transferCostBasis});
    * - withdrawals are present (a fully-exited-then-re-entered position is still
    *   computable — the withdrawal records prove history loaded);
    * - the current position is zero (the wallet never interacted or fully exited,
@@ -15213,15 +15222,17 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
    * path with no added latency.
    *
    * Shares received by a direct token transfer (never deposited, never withdrew)
-   * reach this guard as deposits: {@link getVaultUserLifetimePnl} prices them
-   * with {@link transferCostBasis} first. The guard still throws for such a
-   * wallet when its transfers cannot be read or priced.
+   * reach this guard as `receivedByTransferRaw`: {@link getVaultUserLifetimePnl}
+   * prices them with {@link transferCostBasis} first. The guard still throws for
+   * such a wallet when its transfers cannot be read or priced, or when a share
+   * mint to it has no indexed deposit.
    *
    * @param params - See {@link PnlHistoryConsistencyParams}.
    * @returns `void` when the history is consistent.
    * @throws {@link AugustHistoryUnavailableError} with code `HISTORY_UNAVAILABLE`
-       *   and `context: { vault, wallet }` when a non-zero position has neither
-       *   deposits nor withdrawals recorded. The message carries the
+       *   and `context: { vault, wallet }` when a non-zero position has no deposits
+       *   recorded and either a share mint without a matching deposit or neither
+       *   received shares nor withdrawals. The message carries the
        *   `#getVaultUserLifetimePnl::<vault>::<wallet>` prefix so it groups with the
        *   other errors leaving the getter.
        * @example
@@ -15230,12 +15241,14 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
        *   vault,
        *   wallet,
        *   hasDeposits: depositsByAsset.size > 0,
+       *   mintsMatchHistory,
+       *   receivedByTransferRaw: costBasis.receivedByTransferRaw,
        *   totalWithdrawnRaw,
        *   currentPositionRaw: currentPositionValue.raw,
        * });
        * ```
        */
-   export declare function assertPnlHistoryConsistent({ vault, wallet, hasDeposits, totalWithdrawnRaw, currentPositionRaw, }: PnlHistoryConsistencyParams): void;
+   export declare function assertPnlHistoryConsistent({ vault, wallet, hasDeposits, mintsMatchHistory, receivedByTransferRaw, totalWithdrawnRaw, currentPositionRaw, }: PnlHistoryConsistencyParams): void;
 
    /**
     * Guard against converting lifetime PnL to USD with a fabricated price.
@@ -15922,7 +15935,7 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                 * ```
                 */
                /** Stable error codes attached to SDK errors. */
-               export declare type AugustErrorCode = 'AUTH_MISSING_KEY' | 'AUTH_INVALID_KEY' | 'AUTH_FORBIDDEN' | 'AUTH_UNAUTHORIZED' | 'INVALID_URL' | 'INVALID_INPUT' | 'INVALID_CHAIN' | 'INVALID_ADDRESS' | 'ACCOUNT_NOT_FUNDED' | 'NETWORK_ERROR' | 'TIMEOUT' | 'RATE_LIMITED' | 'SERVER_ERROR' | 'HISTORY_UNAVAILABLE' | 'PRICE_UNAVAILABLE' | 'UNKNOWN';
+               export declare type AugustErrorCode = 'AUTH_MISSING_KEY' | 'AUTH_INVALID_KEY' | 'AUTH_FORBIDDEN' | 'AUTH_UNAUTHORIZED' | 'INVALID_URL' | 'INVALID_INPUT' | 'INVALID_CHAIN' | 'INVALID_ADDRESS' | 'ACCOUNT_NOT_FUNDED' | 'NETWORK_ERROR' | 'TIMEOUT' | 'RATE_LIMITED' | 'SERVER_ERROR' | 'TRANSACTION_UNCONFIRMED' | 'HISTORY_UNAVAILABLE' | 'PRICE_UNAVAILABLE' | 'UNKNOWN';
 
                /** Options accepted by every SDK error constructor. */
                export declare interface AugustErrorOptions {
@@ -16863,6 +16876,35 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                         toJSON(): Record<string, unknown>;
                     }
 
+                    /**
+                     * A transaction was sent but its outcome could not be established
+                     * (`TRANSACTION_UNCONFIRMED`). It may have landed: check {@link signature}
+                     * before resubmitting, or a deposit or redeem can execute twice.
+                     * `context.reason` says what was seen (e.g. `expired_not_found`: the blockhash
+                     * expired and no lookup found it, so it very likely never landed).
+                     *
+                     * @example
+                     * ```ts
+                     * try {
+                     *   await sdk.solana.vaultDeposit(programId, idl, wallet, amount, undefined, vault);
+                     * } catch (err) {
+                     *   if (err instanceof AugustTransactionError) showPending(err.signature);
+                     *   else throw err;
+                     * }
+                     * ```
+                     */
+                    export declare class AugustTransactionError extends AugustSDKError {
+                        /** Signature of the transaction that was sent. */
+                        readonly signature: string;
+                        /**
+                         * @param message - Human-readable description, naming the signature.
+                         * @param signature - Signature of the transaction that was sent.
+                         * @param options - Standard SDK error options.
+                         */
+                        constructor(message: string, signature: string, options?: AugustErrorOptions);
+                        toJSON(): Record<string, unknown>;
+                    }
+
                     /** Caller-side input failed validation. */
                     export declare class AugustValidationError extends AugustSDKError {
                         constructor(code: Extract<AugustErrorCode, 'INVALID_URL' | 'INVALID_INPUT' | 'INVALID_CHAIN' | 'INVALID_ADDRESS' | 'ACCOUNT_NOT_FUNDED'>, message: string, options?: AugustErrorOptions);
@@ -17478,6 +17520,29 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                   */
                                  export declare function balanceOf(signer: IContractRunner, options: IBalanceOfOptions): Promise<bigint>;
 
+                                 /**
+                                  * `AnchorProvider` whose `sendAndConfirm` — what `program.methods…rpc()` calls —
+                                  * confirms with {@link confirmByBlockhash} instead of Anchor's signature-only
+                                  * WebSocket wait. Signing and Anchor's error translation are unchanged.
+                                  */
+                                 declare class BlockhashConfirmingProvider extends AnchorProvider {
+                                     /**
+                                      * Sign, send and confirm a transaction.
+                                      *
+                                      * @param tx - Transaction to send. Its blockhash (and fee payer, if unset)
+                                      *   are set here. A `VersionedTransaction` already carries a blockhash this
+                                      *   cannot learn the expiry of, so it takes Anchor's default path.
+                                      * @param signers - Extra signers besides the wallet.
+                                      * @param opts - Defaults to the provider's options.
+                                      * @returns The transaction signature.
+                                      * @throws See {@link confirmByBlockhash}; also whatever the wallet or
+                                      *   `sendRawTransaction` throws (user rejection, preflight failure).
+                                      * @remarks **RPC cost.** `getLatestBlockhash` + `sendRawTransaction`, then
+                                      *   the confirmation polls described on {@link confirmByBlockhash}.
+                                      */
+                                     sendAndConfirm(tx: Transaction | VersionedTransaction, signers?: Signer_2[], opts?: ConfirmOptions): Promise<TransactionSignature>;
+                                 }
+
                                  /**
                                   * Build an ERC-8021 schema-0 attribution suffix from builder codes.
                                   *
@@ -17997,15 +18062,19 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                       * per-call code, or the instance code under `attribution.strictOrigin`),
                                       * before any approval; with code `ACCOUNT_NOT_FUNDED` when the account cannot
                                       * cover gas.
-                                      * @throws {@link AugustSDKError} on unrecoverable contract or RPC failure.
+                                      * @throws {@link AugustSDKError} while the SwapRouter is paused (checked before
+                                          * any approval), or on unrecoverable contract or RPC failure.
                                           */
                                       export declare function depositNativeViaSwapRouter(signer: Signer | Wallet, options: ISwapRouterNativeDepositOptions): Promise<string>;
 
                                       /**
                                        * Why {@link getDepositRoute} kept a deposit on the vault's native path.
                                        * `no-origin-code` is what every SDK without `attribution.originCode` gets.
+                                       * `router-paused` means the SwapRouter's owner paused it: the deposit goes
+                                       * straight to the vault, even under `attribution.strictOrigin`, until the
+                                       * router is unpaused.
                                        */
-                                      export declare type DepositRouteReason = 'no-origin-code' | 'no-router' | 'chain-not-supported' | 'permit' | 'native-token' | 'adapter' | 'vault-not-registered' | 'asset-not-accepted' | 'router-token-not-whitelisted' | 'origin-not-registered';
+                                      export declare type DepositRouteReason = 'no-origin-code' | 'no-router' | 'chain-not-supported' | 'permit' | 'native-token' | 'adapter' | 'vault-not-registered' | 'asset-not-accepted' | 'router-token-not-whitelisted' | 'router-paused' | 'origin-not-registered';
 
                                       /**
                                        * Deposit a vault's reference asset directly through the SwapRouter — no
@@ -18021,7 +18090,8 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                            * per-call code, or the instance code under `attribution.strictOrigin`),
                                            * before any approval; with code `ACCOUNT_NOT_FUNDED` when the account cannot
                                            * cover gas.
-                                           * @throws {@link AugustSDKError} on unrecoverable contract or RPC failure.
+                                           * @throws {@link AugustSDKError} while the SwapRouter is paused (checked before
+                                               * any approval), or on unrecoverable contract or RPC failure.
                                                */
                                            export declare function depositViaSwapRouter(signer: Signer | Wallet, options: ISwapRouterDirectDepositOptions): Promise<string>;
 
@@ -18227,9 +18297,10 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                 * (`route.spender`, not necessarily the vault). See {@link getDepositRoute}.
                                                 *
                                                 * @param options - {@link IGetDepositRouteOptions}.
-                                                * @returns `{ via, spender, reason? }` — `reason` explains a native route.
+                                                * @returns `{ via, spender, reason? }` — `reason` explains a native route
+                                                *   (`router-paused` while the SwapRouter is paused).
                                                 * @throws AugustValidationError on an invalid target, or an unregistered
-                                                *   code under `attribution.strictOrigin`.
+                                                *   code under `attribution.strictOrigin` while the router is not paused.
                                                 * @throws AugustSDKError when a backend, vault or router read fails.
                                                 * @example
                                                 * ```ts
@@ -18295,7 +18366,8 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                 * @param options - {@link ISwapAndDepositOptions}.
                                                 * @returns The transaction hash of the `swapAndDeposit` call.
                                                 * @throws AugustValidationError on invalid inputs (bad chain, empty swaps).
-                                                * @throws AugustSDKError on RPC / contract revert.
+                                                * @throws AugustSDKError while the SwapRouter is paused (checked before any
+                                                *   approval), or on RPC / contract revert.
                                                 *
                                                 * @example
                                                 * ```ts
@@ -18319,6 +18391,8 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                 *
                                                 * @param options - {@link ISwapRouterDirectDepositOptions}.
                                                 * @returns The transaction hash of the `deposit` call.
+                                                * @throws AugustSDKError while the SwapRouter is paused (checked before any
+                                                *   approval), or on RPC / contract revert.
                                                 */
                                                depositViaSwapRouter(options: ISwapRouterDirectDepositOptions): Promise<string>;
                                                /**
@@ -18328,6 +18402,8 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                 *
                                                 * @param options - {@link ISwapRouterNativeDepositOptions}.
                                                 * @returns The transaction hash of the `depositNativeToken` call.
+                                                * @throws AugustSDKError while the SwapRouter is paused (checked before any
+                                                *   approval), or on RPC / contract revert.
                                                 */
                                                depositNativeViaSwapRouter(options: ISwapRouterNativeDepositOptions): Promise<string>;
                                                /**
@@ -18345,6 +18421,8 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                 * @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.
+                                                * @throws AugustSDKError while the SwapRouter is paused (checked before any
+                                                *   approval), or on RPC / contract revert.
                                                 * @example
                                                 * ```ts
                                                 * const hash = await augustSdk.evm.swapRouterDeposit({
@@ -19161,23 +19239,25 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                           * Ethereum mainnet ({@link ORIGIN_ATTRIBUTION_CHAINS}) and has a SwapRouter,
                                                           * the vault is registered on it, the vault accepts the asset directly (its
                                                           * reference asset, or a Tokenized Vault V2 whitelisted asset — deposited
-                                                          * as-is, never swapped), the router whitelists the asset, the deposit is not a
-                                                          * permit, native-token or adapter deposit, and the code is registered.
-                                                          * Otherwise it is `native` with a `reason`.
+                                                          * as-is, never swapped), the router whitelists the asset, the router is not
+                                                          * paused, the deposit is not a permit, native-token or adapter deposit, and
+                                                          * the code is registered. Otherwise it is `native` with a `reason`. A paused
+                                                          * router gives `router-paused` even under `attribution.strictOrigin`.
                                                           *
                                                           * @param signer - ethers `Signer` / `Wallet` used for the reads.
                                                           * @param options - {@link IGetDepositRouteOptions}; `depositAsset` defaults
                                                           *   to the vault's underlying.
                                                           * @returns {@link IDepositRoute}.
                                                               * @throws AugustValidationError on an invalid `target`, or an unregistered
-                                                              *   code under `attribution.strictOrigin`.
+                                                              *   code under `attribution.strictOrigin` while the router is not paused.
                                                               * @throws AugustSDKError when a backend, vault or router read fails.
-                                                              * @worstCaseRpcCalls 7 — the backend vault row, `asset()`, the router's
+                                                              * @worstCaseRpcCalls 8 — the backend vault row, `asset()`, the router's
                                                               *   `vaultInfo`, the vault's `assetsWhitelistAddress()` and
                                                               *   `getWhitelistedAssets()` (Tokenized Vault V2 non-reference asset only),
-                                                              *   the router's `whitelistedTokens(asset)`, and the router's `origins`. The
-                                                              *   router reads and `getWhitelistedAssets()` are cached for 5 minutes. No
-                                                              *   router read without a code or off Ethereum mainnet.
+                                                              *   the router's `whitelistedTokens(asset)`, `isPaused()` and `origins`. The
+                                                              *   router reads and `getWhitelistedAssets()` are cached for 5 minutes, except
+                                                              *   `isPaused()` (15 seconds). No router read without a code or off Ethereum
+                                                              *   mainnet.
                                                               * @example
                                                               * ```ts
                                                               * const route = await augustSdk.evm.getDepositRoute({ target: vault, depositAsset: usdt });
@@ -20179,16 +20259,18 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                                      * shares add to `totalDeposited` (and are reported again as
                                                                      * `receivedByTransfer`), sent shares add to `totalWithdrawn`. This holds
                                                                      * alongside indexed deposits, so a wallet that received shares and also
-                                                                     * deposited is not credited with the received shares as profit. LayerZero
-                                                                     * OVaults count transfers only when history holds no deposit, because their
-                                                                     * composer delivers cross-chain deposits by transfer.
+                                                                     * deposited is not credited with the received shares as profit. On LayerZero
+                                                                     * OVaults, transfers from or to the hub composer and share OFT do not count,
+                                                                     * because the composer delivers cross-chain deposits by transfer and those
+                                                                     * are already counted as LayerZero deposits.
                                                                      *
                                                                      * Gaps in the indexed history: a share mint with no `Deposit` event counts as
                                                                      * a deposit of the assets in its `ReserveDeposit` event
                                                                      * ({@link selectReserveDeposits}; High Growth ETH emits it for Kelp gain-adapter
                                                                      * deposits), and a withdrawal request the vault logged twice counts once
                                                                      * ({@link countWithdrawalRequestsOnce}). Transfers fold in for a depositor only
-                                                                     * once every mint is explained.
+                                                                     * once every mint is explained. A wallet with no indexed deposit and a mint
+                                                                     * that no deposit explains throws `HISTORY_UNAVAILABLE`.
                                                                      *
                                                                      * Tokenized Vault V2 redemptions carry only shares, so a settled one counts at
                                                                      * the assets the vault paid, or at the share ratio on its claim date when the
@@ -20203,9 +20285,8 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                                      * for a Tokenized Vault V2 wallet with redemption requests, a `lagDuration()`
                                                                      * read plus one backend timeseries request. A timeseries window with no usable
                                                                      * ratio (a closed vault whose history stopped earlier) is read again in full,
-                                                                     * so the latest earlier day still prices it. For
-                                                                     * non-LayerZero vaults the transfer query runs in parallel with the history
-                                                                     * read; for LayerZero vaults it runs only when history holds no deposit.
+                                                                     * so the latest earlier day still prices it. The transfer query runs for
+                                                                     * every vault, in parallel with the history read.
                                                                      *
                                                                      * @param vault - Vault contract address
                                                                      * @param wallet - User wallet address
@@ -20213,7 +20294,8 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                                      * @returns Lifetime PnL data in both native token and USD
                                                                      * @throws {@link AugustHistoryUnavailableError} (`HISTORY_UNAVAILABLE`) when a
                                                                          *   live position has no indexed deposits, withdrawals or priceable share
-                                                                         *   transfers.
+                                                                         *   transfers, or has no indexed deposit while a share mint to the wallet has
+                                                                         *   no matching deposit.
                                                                          * @throws {@link AugustPriceUnavailableError} (`PRICE_UNAVAILABLE`) when the
                                                                              *   underlying asset has no USD price, or `asset()` cannot be read.
                                                                              */
@@ -20389,6 +20471,9 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                                           *   or when the wallet's deposit-mint balance is below `depositAmount`.
                                                                           * @throws AugustSDKError when a candidate token account's balance cannot be
                                                                           *   read, or wrapping any downstream failure (`cause` preserved).
+                                                                          * @throws AugustTransactionError (`TRANSACTION_UNCONFIRMED`) when the
+                                                                          *   transaction was sent but its outcome could not be established; check
+                                                                          *   `signature` before resubmitting.
                                                                           * @remarks **Side effects.** Submits exactly one transaction, signed by the
                                                                           *   provider's wallet. When the wallet has no share account, that transaction
                                                                           *   also creates one, and `publicKey` pays its rent — roughly 0.00204 SOL,
@@ -20437,6 +20522,9 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                                           *   or when the wallet holds fewer shares than `redeemShares`.
                                                                           * @throws AugustSDKError when a candidate token account's balance cannot be
                                                                           *   read, or wrapping any downstream failure (`cause` preserved).
+                                                                          * @throws AugustTransactionError (`TRANSACTION_UNCONFIRMED`) when the
+                                                                          *   transaction was sent but its outcome could not be established; check
+                                                                          *   `signature` before resubmitting.
                                                                           * @remarks **Side effects.** Submits exactly one transaction, signed by the
                                                                           *   provider's wallet. That transaction also creates the payout account when
                                                                           *   the wallet has none, and the vault's fee-recipient account when *it* has
@@ -24884,9 +24972,10 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                                          }
 
                                                                          /**
-                                                                          * One subaccount record from the admin-only `GET /subaccount` directory
-                                                                          * endpoint (backend `ISubaccountRead` schema). Nullable fields are optional
-                                                                          * metadata the operations team may not have filled in.
+                                                                          * One subaccount record (backend `ISubaccountRead` schema), as returned by the
+                                                                          * admin-only `GET /subaccount` directory, `GET /users/{address}/subaccounts`
+                                                                          * and `GET /org/subaccounts`. Nullable fields are optional metadata the
+                                                                          * operations team may not have filled in.
                                                                           */
                                                                          export declare interface IWSSubaccountListItem {
                                                                              id: string;
@@ -24908,6 +24997,15 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                                              variant: string | null;
                                                                              default_fee_rate_in_bips: number | null;
                                                                              wallet_role: string | null;
+                                                                             /**
+                                                                              * Cached USD account value, refreshed out of band by an hourly backend job.
+                                                                              * A sort key and placeholder, not an authoritative NAV — read the live value
+                                                                              * from the subaccount summary. `null` before the job's first run; absent on
+                                                                              * backends that predate the field.
+                                                                              */
+                                                                             latest_account_value?: number | null;
+                                                                             /** Naive-UTC ISO timestamp of `latest_account_value`. */
+                                                                             account_value_updated_at?: string | null;
                                                                              chains: IWSSubaccountListChain[];
                                                                          }
 
@@ -25524,7 +25622,9 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                                           *
                                                                           * A depositor whose history misses a mint ({@link historyCoversMints}) is the
                                                                           * exception: its transfers do not count, so the result matches what the getter
-                                                                          * returned before transfers counted for depositors. On a LayerZero OVault the
+                                                                          * returned before transfers counted for depositors. A wallet with no deposit
+                                                                          * still gets a basis here when its history misses a mint, but
+                                                                          * {@link assertPnlHistoryConsistent} rejects it. On a LayerZero OVault the
                                                                           * caller leaves the hub composer and share OFT out of the transfers (see
                                                                           * {@link selectPeerTransfers}): the composer's deliveries are already counted
                                                                           * as LayerZero deposits, and shares bridged to a spoke chain still count in the
@@ -25587,6 +25687,16 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                                               * (subgraph deposits or LayerZero cross-chain deposits).
                                                                               */
                                                                              hasDeposits: boolean;
+                                                                             /**
+                                                                              * Whether the indexed deposits explain every share mint to the wallet (see
+                                                                              * {@link historyCoversMints}). Defaults to `true`.
+                                                                              */
+                                                                             mintsMatchHistory?: boolean;
+                                                                             /**
+                                                                              * Shares received by peer transfer, priced in raw base units (asset
+                                                                              * decimals) by {@link transferCostBasis}. Defaults to zero.
+                                                                              */
+                                                                             receivedByTransferRaw?: bigint;
                                                                              /** Total withdrawn, in raw base units (asset decimals). */
                                                                              totalWithdrawnRaw: bigint;
                                                                              /** Current on-chain position value, in raw base units (asset decimals). */
@@ -25737,6 +25847,8 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
 
                                                                          /* Excluded from this release type: readOriginInfo */
 
+                                                                         /* Excluded from this release type: readSwapRouterPaused */
+
                                                                          /* Excluded from this release type: readSwapRouterTokenWhitelisted */
 
                                                                          /* Excluded from this release type: readSwapRouterVaultInfo */
@@ -27174,7 +27286,7 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                                                    getProvider: ({ connection, publicKey, signTransaction, }: {
                                                                                        publicKey: PublicKey;
                                                                                        signTransaction: (<T extends Transaction | web3.VersionedTransaction>(transaction: T) => Promise<T>) | undefined;
-                                                                                   } & ISolanaConnectionOptions) => AnchorProvider;
+                                                                                   } & ISolanaConnectionOptions) => BlockhashConfirmingProvider;
                                                                                    getReadOnlyProvider: ({ connection }: ISolanaConnectionOptions) => AnchorProvider;
                                                                                    deriveShareMintPda: (vaultProgramId: PublicKey | string) => web3.PublicKey;
                                                                                    deriveVaultStatePda: (vaultProgramId: PublicKey | string) => web3.PublicKey;
@@ -27911,7 +28023,8 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                                                                * addresses, empty/oversized swap arrays, or an origin code not registered on
                                                                                                * the router (a per-call code, or the instance code under
                                                                                                * `attribution.strictOrigin`), before any approval.
-                                                                                               * @throws {@link AugustSDKError} on unrecoverable contract or RPC failure.
+                                                                                               * @throws {@link AugustSDKError} while the SwapRouter is paused (checked before
+                                                                                                   * any approval), or on unrecoverable contract or RPC failure.
                                                                                                    *
                                                                                                    * @example
                                                                                                    * ```ts
@@ -27991,14 +28104,16 @@ declare type AsArray<T> = T extends readonly unknown[] ? T : never;
                                                                                                     *   not registered on the router (a per-call code, or the instance code under
                                                                                                     *   `attribution.strictOrigin`), before any approval; with code
                                                                                                     *   `ACCOUNT_NOT_FUNDED` when the account cannot cover gas.
-                                                                                                    * @throws {@link AugustSDKError} on unrecoverable contract or RPC failure.
-                                                                                                        * @worstCaseRpcCalls 10 on the swap path into a Tokenized Vault V2 —
+                                                                                                    * @throws {@link AugustSDKError} while the SwapRouter is paused (checked before
+                                                                                                        * any approval), or on unrecoverable contract or RPC failure.
+                                                                                                        * @worstCaseRpcCalls 11 on the swap path into a Tokenized Vault V2 —
                                                                                                         *   tokenized-vault metadata, reference asset + decimals, deposit-token
                                                                                                         *   decimals, the router's `vaultInfo` and `whitelistedTokens`, the vault's
                                                                                                         *   `assetsWhitelistAddress()` and `getWhitelistedAssets()`, the quote, the
-                                                                                                        *   origin code's `origins` (none for the zero sentinel), and the allowance
-                                                                                                        *   read. The router reads and `getWhitelistedAssets()` are cached for 5
-                                                                                                        *   minutes.
+                                                                                                        *   router's `isPaused()`, the origin code's `origins` (none for the zero
+                                                                                                        *   sentinel), and the allowance read. The router reads and
+                                                                                                        *   `getWhitelistedAssets()` are cached for 5 minutes, except `isPaused()`
+                                                                                                        *   (15 seconds).
                                                                                                         * @example
                                                                                                         * ```ts
                                                                                                         * // USDT deposited into a USDC-reference vault → swapped to USDC en route.