@augustdigital/sdk 9.10.1 → 9.12.0

package/lib/core/helpers/swap-router.js

@@ -10,6 +10,7 @@ exports.getOriginInfo = getOriginInfo;
 exports.readOriginInfo = readOriginInfo;
 exports.readSwapRouterVaultInfo = readSwapRouterVaultInfo;
 exports.readSwapRouterTokenWhitelisted = readSwapRouterTokenWhitelisted;
+exports.readSwapRouterPaused = readSwapRouterPaused;
 exports.getSwapRouterWhitelistedTokens = getSwapRouterWhitelistedTokens;
 exports.getSwapRouterEligibleVaults = getSwapRouterEligibleVaults;
 const ethers_1 = require("ethers");
@@ -332,6 +333,49 @@ async function readSwapRouterTokenWhitelisted(runner, chainId, token) {
     cache_1.CACHE.set(cacheKey, whitelisted, { ttl: SWAP_ROUTER_ORIGIN_INFO_TTL_MS });
     return whitelisted;
 }
+/**
+ * Cache TTL for a SwapRouter's pause state (15 seconds). Far shorter than the
+ * 5-minute TTL of the other router reads: the owner pauses the router to stop
+ * deposits during an incident, so a pause must reach the deposit-route
+ * resolver within seconds. Long enough that the resolver and the router write
+ * it hands off to share one `isPaused()` read.
+ */
+const SWAP_ROUTER_PAUSED_TTL_MS = 15 * 1000;
+/**
+ * Read whether a chain's `SwapRouter` is paused (`isPaused()`), cached for 15
+ * seconds. Every router entry point (`deposit`, `swapAndDeposit`,
+ * `depositNativeToken`) reverts with `ContractIsPaused` while the router is
+ * paused, so callers check this before routing a deposit or sending an
+ * approval to the router.
+ *
+ * @param runner - Contract runner (provider or signer) used for the read.
+ * @param chainId - EVM chain ID.
+ * @returns `true` while the router is paused; `false` when it is not, or on a
+ *   chain with no SwapRouter (no RPC).
+ * @throws When the `isPaused()` read fails. Callers wrap it in
+ *   {@link AugustSDKError}.
+ * @worstCaseRpcCalls 1 — one `isPaused()` call; none on a cache hit.
+ * @internal
+ */
+async function readSwapRouterPaused(runner, chainId) {
+    const router = getSwapRouterAddress(chainId);
+    if (!router)
+        return false;
+    const cacheKey = `swap-router-paused-${chainId}-${router.toLowerCase()}`;
+    const cached = await (0, cache_1.getSafeCache)(cacheKey);
+    if (cached !== null)
+        return cached;
+    const contract = (0, web3_1.createContract)({
+        address: router,
+        provider: runner,
+        abi: abis_1.ABI_SWAP_ROUTER,
+    });
+    if (!contract)
+        return false;
+    const paused = (await contract.isPaused()) === true;
+    cache_1.CACHE.set(cacheKey, paused, { ttl: SWAP_ROUTER_PAUSED_TTL_MS });
+    return paused;
+}
 /** Cache TTL for a chain's resolved SwapRouter token allowlist (5 minutes). */
 const SWAP_ROUTER_WHITELIST_TTL_MS = 5 * 60 * 1000;
 /**

package/lib/main.d.ts

@@ -206,8 +206,24 @@ export declare class AugustSDK extends AugustBase {
     }): Promise<number>;
     /**
      * Get redemption requests that are ready to be claimed.
+     *
+     * For a Solana vault, `wallet` is the holder's base58 address and the result
+     * lists their withdrawal-queue requests: waiting (`AWAITING_COOLDOWN`) and
+     * past-window (`EXPIRED`, cancel-only) ones in `availableRedemptions`, and
+     * claimable ones (`READY_TO_CLAIM`) in `pendingRedemptions`, each with
+     * `estimatedAssets`, the net payout at the current share price. Without a
+     * Solana wallet, or for a vault with no queue, both lists are empty. Solana
+     * RPC: the vault state, one `getAccountInfo` for the queue, and, when it
+     * exists, one `getProgramAccounts` and one `getMultipleAccountsInfo` (the
+     * vault state, share mint and payout accounts, read together).
+     *
      * @param props - Vault address, chain ID, and optional wallet filter
      * @returns Array of available redemption requests with amounts and timestamps
+     * @example
+     * ```ts
+     * const { availableRedemptions, pendingRedemptions } =
+     *   await sdk.getVaultAvailableRedemptions({ vault: solanaVault, wallet: holder });
+     * ```
      */
     getVaultAvailableRedemptions(props: {
         vault: IAddress;

package/lib/main.js

@@ -317,8 +317,24 @@ class AugustSDK extends core_1.AugustBase {
     }
     /**
      * Get redemption requests that are ready to be claimed.
+     *
+     * For a Solana vault, `wallet` is the holder's base58 address and the result
+     * lists their withdrawal-queue requests: waiting (`AWAITING_COOLDOWN`) and
+     * past-window (`EXPIRED`, cancel-only) ones in `availableRedemptions`, and
+     * claimable ones (`READY_TO_CLAIM`) in `pendingRedemptions`, each with
+     * `estimatedAssets`, the net payout at the current share price. Without a
+     * Solana wallet, or for a vault with no queue, both lists are empty. Solana
+     * RPC: the vault state, one `getAccountInfo` for the queue, and, when it
+     * exists, one `getProgramAccounts` and one `getMultipleAccountsInfo` (the
+     * vault state, share mint and payout accounts, read together).
+     *
      * @param props - Vault address, chain ID, and optional wallet filter
      * @returns Array of available redemption requests with amounts and timestamps
+     * @example
+     * ```ts
+     * const { availableRedemptions, pendingRedemptions } =
+     *   await sdk.getVaultAvailableRedemptions({ vault: solanaVault, wallet: holder });
+     * ```
      */
     async getVaultAvailableRedemptions(props) {
         return await this.vaults.getVaultAvailableRedemptions(props);

package/lib/modules/vaults/getters.d.ts

@@ -1,4 +1,4 @@
-import { type IAddress, type IHistoricalTimeseriesPoint, type IHistoricalTimeseriesResponse, type INormalizedNumber, type ISubgraphReserveDeposit, type ISubgraphTransfer, type ISubgraphUserHistoryItem, type ITokenizedVault, type ISubgraphWithdrawProccessed, type IVault, type IVaultAllocations, type IVaultAnnualizedApy, type IVaultAvailableRedemption, type IVaultLoan, type IVaultPosition, type IVaultRedemptionHistoryItem, type IVaultSummary, type IVaultWithdrawals, type IVaultPendingRedemptions, type IActiveStakingPosition, type IVaultHistoricalParams, type IVaultUserLifetimePnl, type IVaultBorrowerHealthFactor, type IVaultPnl, type VaultAddress } from '../../types';
+import { type IAddress, type IHistoricalTimeseriesPoint, type IHistoricalTimeseriesResponse, type INormalizedNumber, type ISubgraphReserveDeposit, type ISubgraphTransfer, type ISubgraphUserHistoryItem, type ITokenizedVault, type ISubgraphWithdrawProccessed, type ISubgraphWithdrawRequest, type IVault, type IVaultAllocations, type IVaultAnnualizedApy, type IVaultAvailableRedemption, type IVaultLoan, type IVaultPosition, type IVaultRedemptionHistoryItem, type IVaultSummary, type IVaultWithdrawals, type IVaultPendingRedemptions, type IActiveStakingPosition, type IVaultHistoricalParams, type IVaultUserLifetimePnl, type IVaultBorrowerHealthFactor, type IVaultPnl, type VaultAddress } from '../../types';
 import type { IVaultBaseOptions } from './types';
 /**
  * Vault Data Getters
@@ -98,7 +98,7 @@ export declare function getVaultAvailableRedemptions({ vault, wallet, options, p
     };
 }): Promise<{
     processedWithdrawals: ISubgraphWithdrawProccessed[];
-    requestedWithdrawals: import("../../types").ISubgraphWithdrawRequest[];
+    requestedWithdrawals: ISubgraphWithdrawRequest[];
     availableRedemptions: IVaultAvailableRedemption[];
     pendingRedemptions: IVaultAvailableRedemption[];
 }>;

package/lib/modules/vaults/getters.js

@@ -85,6 +85,8 @@ const debank_1 = require("../../services/debank");
 const utils_2 = require("../../adapters/solana/utils");
 const SolanaGetters = __importStar(require("../../adapters/solana/getters"));
 const SolanaConstants = __importStar(require("../../adapters/solana/constants"));
+const withdrawal_queue_1 = require("../../adapters/solana/withdrawal-queue");
+const web3_js_1 = require("@solana/web3.js");
 const StellarGetters = __importStar(require("../../adapters/stellar/getters"));
 const utils_3 = require("../../adapters/stellar/utils");
 const constants_1 = require("../../adapters/stellar/constants");
@@ -935,6 +937,51 @@ async function readLagDuration(vaultContract, vault, scope) {
  * an empty response to any *other* view still surfaces as an error.
  */
 const LAG_DURATION_SELECTOR = '0x24e86d67';
+/**
+ * A Solana wallet's withdrawal-queue requests on one vault, for
+ * `getVaultPositions` and `getVaultAvailableRedemptions`. Empty when the vault
+ * has no queue, the wallet has no request, or the service cannot name the queue
+ * program (including where the queue is not deployed); a failed read is logged
+ * and reads as empty, like the balance reads beside it.
+ *
+ * RPC: see `getSolanaWithdrawalRedemptions` (one `getAccountInfo` for a vault
+ * with no queue; up to one more `getProgramAccounts` and one
+ * `getMultipleAccountsInfo`).
+ */
+async function readSolanaRedemptions(input) {
+    const empty = {
+        availableRedemptions: [],
+        pendingRedemptions: [],
+    };
+    const { tokenizedVault, solanaService, vaultState } = input;
+    if (!vaultState.shareMint)
+        return empty;
+    try {
+        const queueProgramId = (0, withdrawal_queue_1.resolveQueueProgramId)(solanaService);
+        if (!queueProgramId)
+            return empty;
+        const metadata = tokenizedVault.solana_vault_metadata;
+        const programId = utils_2.SolanaUtils.resolveProgramId(String(tokenizedVault.address), metadata);
+        return await (0, withdrawal_queue_1.getSolanaWithdrawalRedemptions)({
+            connection: solanaService.connection,
+            queueProgramId,
+            vaultStateAddress: metadata?.vault_state_pda
+                ? new web3_js_1.PublicKey(metadata.vault_state_pda)
+                : utils_2.SolanaUtils.deriveVaultStatePda(programId),
+            shareMint: new web3_js_1.PublicKey(vaultState.shareMint),
+            owner: new web3_js_1.PublicKey(input.wallet),
+            vault: tokenizedVault.address,
+            depositDecimals: input.depositDecimals,
+        });
+    }
+    catch (error) {
+        core_1.Logger.log.warn('readSolanaRedemptions', 'Withdrawal requests read failed', {
+            vault: tokenizedVault.address,
+            error,
+        });
+        return empty;
+    }
+}
 async function getVaultAvailableRedemptions({ vault, wallet, options, prefetchedReads, }) {
     try {
         // Stellar vaults don't support on-chain redemptions yet
@@ -949,6 +996,41 @@ async function getVaultAvailableRedemptions({ vault, wallet, options, prefetched
                 }),
             };
         }
+        // Solana: the wallet's withdrawal-queue requests. There is no processed
+        // history to report, so the verbose lists are always empty.
+        if (utils_2.SolanaUtils.isSolanaAddress(vault)) {
+            const empty = {
+                availableRedemptions: [],
+                pendingRedemptions: [],
+                ...(options.verbose && {
+                    processedWithdrawals: [],
+                    requestedWithdrawals: [],
+                }),
+            };
+            const solanaService = options.solanaService;
+            if (!wallet || !utils_2.SolanaUtils.isSolanaAddress(wallet) || !solanaService) {
+                return empty;
+            }
+            const solanaVault = (await (0, core_1.fetchTokenizedVault)(vault, options?.headers, false, false))?.[0];
+            if (!solanaVault)
+                return empty;
+            const vaultStateRes = await solanaService.getVaultState(utils_2.SolanaUtils.resolveProgramId(String(solanaVault.address), solanaVault.solana_vault_metadata), SolanaConstants.vaultIdl, solanaVault.solana_vault_metadata?.vault_state_pda ?? undefined);
+            const vaultState = vaultStateRes?.vaultState;
+            if (!vaultState)
+                return empty;
+            return {
+                ...empty,
+                ...(await readSolanaRedemptions({
+                    tokenizedVault: solanaVault,
+                    wallet,
+                    solanaService,
+                    vaultState,
+                    depositDecimals: vaultStateRes?.depositMintDecimals ??
+                        solanaVault.solana_vault_metadata?.deposit_token_decimals ??
+                        SolanaConstants.fallbackDecimals,
+                })),
+            };
+        }
         // setup
         const provider = (0, core_1.createProvider)(options.rpcUrl);
         const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(vault, options?.headers, false, false))?.[0];
@@ -1435,6 +1517,10 @@ async function getVaultPositions({ vault, wallet, solanaWallet, stellarWallet, o
                     const fallbackShareDecimals = v.solana_vault_metadata?.deposit_token_decimals ??
                         SolanaConstants.fallbackDecimals;
                     let balance = (0, core_1.toNormalizedBn)(0, fallbackShareDecimals);
+                    let redemptions = {
+                        availableRedemptions: [],
+                        pendingRedemptions: [],
+                    };
                     // Defensive: without a Solana adapter we can't fetch on-chain
                     // state. The outer filter in modules/vaults/main.ts already gates
                     // on `this.solanaService`, so this is a belt-and-suspenders guard
@@ -1456,6 +1542,15 @@ async function getVaultPositions({ vault, wallet, solanaWallet, stellarWallet, o
                             const decimals = raw.decimals ?? fallbackShareDecimals;
                             balance = (0, core_1.toNormalizedBn)(BigInt(raw.amount), decimals);
                         }
+                        if (vaultState) {
+                            redemptions = await readSolanaRedemptions({
+                                tokenizedVault: v,
+                                wallet: solanaWallet,
+                                solanaService: options.solanaService,
+                                vaultState,
+                                depositDecimals: vaultStateRes?.depositMintDecimals ?? fallbackShareDecimals,
+                            });
+                        }
                     }
                     return {
                         // Mirror the Stellar branch — return the backend's `v.address`,
@@ -1464,9 +1559,14 @@ async function getVaultPositions({ vault, wallet, solanaWallet, stellarWallet, o
                         // not 0x-hex; the IAddress typing across non-EVM positions is a
                         // known wart documented in IVaultPosition.
                         vault: v.address,
-                        status: renderStatus([], balance),
-                        availableRedemptions: [],
-                        pendingRedemptions: [],
+                        // Any queued request, waiting or claimable, marks the position
+                        // REDEEM; the shares it escrows are no longer in the wallet.
+                        status: renderStatus([
+                            ...redemptions.availableRedemptions,
+                            ...redemptions.pendingRedemptions,
+                        ], balance),
+                        availableRedemptions: redemptions.availableRedemptions,
+                        pendingRedemptions: redemptions.pendingRedemptions,
                         redeemable: balance,
                         walletBalance: balance,
                     };

package/lib/modules/vaults/main.d.ts

@@ -68,6 +68,8 @@ export declare class AugustVaults extends AugustBase {
     /**
      * Calculate total deposited across all tokenized vaults by summing latest_reported_tvl.
      * Uses the /tokenized_vault endpoint which returns latest_reported_tvl in USD.
+     * Wrapper vaults (non-null `underlying_vault_address`) are skipped: their
+     * deposits sit in the underlying vault as LP and are already counted there.
      * @param options Optional configuration for loading vaults
      * @returns Total deposited amount in USD (sum of all latest_reported_tvl values)
      */
@@ -160,7 +162,17 @@ export declare class AugustVaults extends AugustBase {
         nDays?: number;
     }): Promise<import("../../types").IHistoricalTimeseriesResponse>;
     /**
+     * A wallet's redemption requests on one vault, split into
+     * `availableRedemptions` and `pendingRedemptions`. EVM, Stellar and Solana
+     * vault addresses are accepted; see `AugustSDK.getVaultAvailableRedemptions`
+     * for what each list holds on Solana.
      *
+     * @param props - `vault`, the vault address; `chainId`, the EVM chain whose
+     *   RPC to use (the active network when omitted); `wallet`, the holder,
+     *   required for Solana, where it is base58; `verbose`, to also return the
+     *   processed and requested withdrawal lists (always empty for Solana).
+     * @returns `{ availableRedemptions, pendingRedemptions }`, plus the verbose lists.
+     * @throws Error when unauthorized, or when `vault` is missing or not an address.
      */
     getVaultAvailableRedemptions({ vault, chainId, wallet, verbose, }: {
         vault: IAddress;

package/lib/modules/vaults/main.js

@@ -339,6 +339,8 @@ class AugustVaults extends core_1.AugustBase {
     /**
      * Calculate total deposited across all tokenized vaults by summing latest_reported_tvl.
      * Uses the /tokenized_vault endpoint which returns latest_reported_tvl in USD.
+     * Wrapper vaults (non-null `underlying_vault_address`) are skipped: their
+     * deposits sit in the underlying vault as LP and are already counted there.
      * @param options Optional configuration for loading vaults
      * @returns Total deposited amount in USD (sum of all latest_reported_tvl values)
      */
@@ -348,6 +350,8 @@ class AugustVaults extends core_1.AugustBase {
         allVaults.forEach((vault) => {
             if (vaults_2.TVL_EXCLUDED_VAULTS.has(vault.address?.toLowerCase()))
                 return;
+            if (vault.underlying_vault_address)
+                return;
             if (vault.latest_reported_tvl !== null &&
                 vault.latest_reported_tvl !== undefined) {
                 total += vault.latest_reported_tvl;
@@ -591,14 +595,26 @@ class AugustVaults extends core_1.AugustBase {
         });
     }
     /**
+     * A wallet's redemption requests on one vault, split into
+     * `availableRedemptions` and `pendingRedemptions`. EVM, Stellar and Solana
+     * vault addresses are accepted; see `AugustSDK.getVaultAvailableRedemptions`
+     * for what each list holds on Solana.
      *
+     * @param props - `vault`, the vault address; `chainId`, the EVM chain whose
+     *   RPC to use (the active network when omitted); `wallet`, the holder,
+     *   required for Solana, where it is base58; `verbose`, to also return the
+     *   processed and requested withdrawal lists (always empty for Solana).
+     * @returns `{ availableRedemptions, pendingRedemptions }`, plus the verbose lists.
+     * @throws Error when unauthorized, or when `vault` is missing or not an address.
      */
     async getVaultAvailableRedemptions({ vault, chainId, wallet, verbose, }) {
         if (!this.authorized)
             throw new Error('Not authorized.');
         if (!vault)
             throw new Error('Vault input parameter is undefined.');
-        if (!(0, ethers_1.isAddress)(vault) && !(0, utils_2.isStellarAddress)(vault))
+        if (!(0, ethers_1.isAddress)(vault) &&
+            !(0, utils_2.isStellarAddress)(vault) &&
+            !utils_1.SolanaUtils.isSolanaAddress(vault))
             throw new Error(`Vault input parameter is not an address: ${String(vault)}`);
         return await (0, getters_1.getVaultAvailableRedemptions)({
             vault,

package/lib/modules/vaults/types.d.ts

@@ -1,5 +1,5 @@
 import type { Connection } from '@solana/web3.js';
-import type { IAddress, IEnv, IStellarNetwork, IWSMonitorHeaders } from '../../types';
+import type { IAddress, IEnv, ISolanaNetwork, IStellarNetwork, IWSMonitorHeaders } from '../../types';
 /**
  * Structural interface for the Solana adapter surface used by vault operations.
  * Avoids importing the concrete SolanaAdapter class to prevent circular dependencies.
@@ -29,6 +29,19 @@ export interface ISolanaService {
         amount: string;
         decimals: number | null;
     }>;
+    /**
+     * Canonical program id for this service's network, as
+     * `SolanaAdapter.getProgramId`. Optional so a hand-built service keeps
+     * working: without it the withdrawal-queue reads are skipped, and vaults and
+     * positions come back without queue data.
+     */
+    getProgramId?: (type: 'vault' | 'withdrawalQueue') => string;
+    /**
+     * This service's network, as `SolanaAdapter.network`. When present, the
+     * withdrawal-queue reads look the queue program up in `programIds` directly
+     * instead of calling `getProgramId`.
+     */
+    network?: ISolanaNetwork;
 }
 /**
  * Base configuration for vault operations.

package/lib/modules/vaults/write.actions.d.ts

@@ -172,8 +172,11 @@ export type ApproveResult =
 /**
  * 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 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 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';
 /** A deposit's route — the SwapRouter or the vault's native path — and the address to approve. */
 export type IDepositRoute = {
     /**
@@ -199,23 +202,25 @@ export type IGetDepositRouteOptions = Pick<IContractWriteOptions, 'target' | 'de
  * 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 });
@@ -555,7 +560,8 @@ export declare function rwaRedeemAsset(signer: Signer | Wallet, options: IRwaRed
  * 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
@@ -598,7 +604,8 @@ export declare function swapAndDeposit(signer: Signer | Wallet, options: ISwapAn
  * 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>;
 /**
@@ -626,7 +633,8 @@ export declare function depositViaSwapRouter(signer: Signer | Wallet, options: I
  * 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>;
 /**
@@ -724,14 +732,16 @@ export declare function isNativeSwapRouterDepositSupported(chainId: number, vaul
  *   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/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.