@augustdigital/sdk 9.10.1 → 9.11.0

package/README.md

@@ -109,19 +109,21 @@ const { registered, originFeeBps, collector } = await sdk.getOriginInfo({
 - **Where it applies.** `vaultDeposit` sends a deposit through `SwapRouter.deposit` with the code when
   `sdk.evm.getDepositRoute()` returns `via: 'router'`: the vault is registered on the router, the vault accepts
   the asset as-is (its reference asset, or a Tokenized Vault V2 whitelisted asset — never swapped), the router
-  whitelists the asset, the deposit is not a permit, native-token or adapter deposit, and the code is
-  registered. `swapRouterDeposit`, `swapAndDeposit`, `depositViaSwapRouter` and `depositNativeViaSwapRouter`
+  whitelists the asset, the router is not paused, the deposit is not a permit, native-token or adapter deposit,
+  and the code is registered. `swapRouterDeposit`, `swapAndDeposit`, `depositViaSwapRouter` and `depositNativeViaSwapRouter`
   send it too.
 - **Precedence.** An `originCode` passed to a router method wins, then the instance code, then the all-zero
   sentinel (no origin fee). Pass the zero sentinel to opt one call out.
 - **Fallback.** When the code cannot be applied — it is not registered, the chain is not mainnet, the router
-  does not whitelist the asset, the vault does not accept it or is not registered on the router, or it is a
-  permit, native-token or adapter deposit — `vaultDeposit` takes the vault's native path and logs
+  is paused (`router-paused`, checked with a 15-second cache) or does not whitelist the asset, the vault does
+  not accept it or is not registered on the router, or it is a permit, native-token or adapter deposit —
+  `vaultDeposit` takes the vault's native path and logs
   `vaultDeposit:attribution-skipped` with the reason (Sentry tag `sdk.attribution.origin=skipped`). The router
   methods send the zero sentinel for an unregistered instance code and log `<method>:attribution-skipped`.
   With `strictOrigin: true` an unregistered instance code throws `AugustValidationError` before any approval
-  instead. An `originCode` passed to a router method that is not registered always throws
-  `AugustValidationError` before any approval.
+  instead; a paused router falls back to native even then. An `originCode` passed to a router method that is
+  not registered always throws `AugustValidationError` before any approval. While the router is paused, the
+  router methods throw `AugustSDKError` (`context.reason: 'router-paused'`) before any approval.
 - **Approve `route.spender`, not the vault.** A routed deposit is pulled by the SwapRouter. `vaultDeposit` and
   `approve` handle this; if you send approvals yourself, read the spender first:
 

package/lib/adapters/evm/index.d.ts

@@ -106,9 +106,10 @@ declare class EVMAdapter {
      * (`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
@@ -174,7 +175,8 @@ declare class EVMAdapter {
      * @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
@@ -198,6 +200,8 @@ declare class EVMAdapter {
      *
      * @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>;
     /**
@@ -207,6 +211,8 @@ declare class EVMAdapter {
      *
      * @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>;
     /**
@@ -224,6 +230,8 @@ declare class EVMAdapter {
      * @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({

package/lib/adapters/evm/index.js

@@ -154,9 +154,10 @@ class EVMAdapter {
      * (`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
@@ -231,7 +232,8 @@ class EVMAdapter {
      * @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
@@ -258,6 +260,8 @@ class EVMAdapter {
      *
      * @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.
      */
     async depositViaSwapRouter(options) {
         const signer = await this._getSigner();
@@ -270,6 +274,8 @@ class EVMAdapter {
      *
      * @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.
      */
     async depositNativeViaSwapRouter(options) {
         const signer = await this._getSigner();
@@ -290,6 +296,8 @@ class EVMAdapter {
      * @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({

package/lib/core/analytics/version.d.ts

@@ -3,4 +3,4 @@
  * Generated during publish from package.json version
  * This file is gitignored and created at publish time
  */
-export declare const SDK_VERSION = "9.10.1";
+export declare const SDK_VERSION = "9.11.0";

package/lib/core/analytics/version.js

@@ -6,5 +6,5 @@ exports.SDK_VERSION = void 0;
  * Generated during publish from package.json version
  * This file is gitignored and created at publish time
  */
-exports.SDK_VERSION = '9.10.1';
+exports.SDK_VERSION = '9.11.0';
 //# sourceMappingURL=version.js.map

package/lib/core/helpers/swap-router.d.ts

@@ -169,6 +169,23 @@ export declare function readSwapRouterVaultInfo(runner: IContractRunner, chainId
  * @internal
  */
 export declare function readSwapRouterTokenWhitelisted(runner: IContractRunner, chainId: number, token: IAddress): Promise<boolean>;
+/**
+ * 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
+ */
+export declare function readSwapRouterPaused(runner: IContractRunner, chainId: number): Promise<boolean>;
 /**
  * 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.

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/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.

package/lib/sdk.d.ts

@@ -18062,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
@@ -18086,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>;
 
@@ -18292,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
@@ -18360,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
@@ -18384,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>;
                                                /**
@@ -18393,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>;
                                                /**
@@ -18410,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({
@@ -19226,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 });
@@ -25832,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 */
@@ -28006,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
@@ -28086,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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@augustdigital/sdk",
-  "version": "9.10.1",
+  "version": "9.11.0",
   "main": "lib/index.js",
   "types": "lib/sdk.d.ts",
   "keywords": [