@augustdigital/sdk 8.6.0 → 8.7.0

package/lib/core/helpers/chain-error.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUserRejectionError = isUserRejectionError;
+exports.isExpectedRevertError = isExpectedRevertError;
+exports.logChainError = logChainError;
+const logger_1 = require("../logger");
+/**
+ * Classification of caught chain/RPC/wallet errors so the SDK can decide
+ * whether a failure is worth a standalone Sentry issue or is routine, expected
+ * noise that should ride along as a breadcrumb instead.
+ *
+ * Why this exists: most of the SDK's read/write paths `catch` and re-throw, and
+ * historically logged every caught error at `error` level — which the SDK's
+ * Sentry sink turns into a billed issue (see the severity policy on
+ * `SDKSentrySink` in `core/logger`). Two large, low-signal categories dominate
+ * that volume:
+ *
+ * 1. **User-rejected transactions** — the user clicked "reject" in their wallet.
+ *    This is normal product behaviour, not an SDK fault, yet it fires on every
+ *    cancelled deposit/redeem/approve.
+ * 2. **Expected on-chain read reverts** — reading a function a vault doesn't
+ *    implement, or an address with no/incompatible bytecode, reverts. This is a
+ *    routine outcome of probing heterogeneous vaults, not a defect.
+ *
+ * These predicates let call sites demote exactly those cases to `warn` while
+ * leaving genuine failures at `error`. They are intentionally dependency-free
+ * (no `ethers`/Sentry imports) so they stay cheap and safe in both browser and
+ * Node, and classify purely by inspecting the error's `code`/`message` shape.
+ *
+ * @module
+ */
+/**
+ * Best-effort message extraction from an unknown thrown value. Reads
+ * `error.message` for `Error` and error-like objects, passes strings through,
+ * and falls back to `String(error)` for everything else. Never throws.
+ *
+ * @param error - The caught value, of unknown type.
+ * @returns The error's message text (never `undefined`).
+ */
+function errorText(error) {
+    if (typeof error === 'string')
+        return error;
+    if (error instanceof Error)
+        return error.message;
+    if (error && typeof error === 'object') {
+        const maybe = error.message;
+        if (typeof maybe === 'string')
+            return maybe;
+    }
+    return String(error);
+}
+/**
+ * Collect the `code` fields an error-like value may carry. Wallet/provider
+ * errors stash their machine-readable code in different places depending on the
+ * stack: ethers sets a top-level string `code` (e.g. `'ACTION_REJECTED'`),
+ * EIP-1193 providers use a numeric `code` (e.g. `4001`), and some wrap the
+ * original under `error`/`info.error`/`cause`. We scan the common locations so
+ * callers needn't know which library produced the error.
+ *
+ * @param error - The caught value, of unknown type.
+ * @returns Every string/number `code` found (possibly empty).
+ */
+function errorCodes(error) {
+    const codes = [];
+    if (error && typeof error === 'object') {
+        const e = error;
+        const candidates = [
+            e.code,
+            e.error?.code,
+            e.info?.error?.code,
+            e.cause?.code,
+        ];
+        for (const c of candidates) {
+            if (typeof c === 'string' || typeof c === 'number')
+                codes.push(c);
+        }
+    }
+    return codes;
+}
+/**
+ * Is this error a wallet/user rejection of a transaction or signature request?
+ *
+ * Detects ethers v6's `ACTION_REJECTED` code, the EIP-1193 `4001`
+ * ("User rejected the request") code (top-level or nested), and the common
+ * human-readable phrasings as a fallback for providers that omit a code.
+ *
+ * @param error - The caught value, of unknown type.
+ * @returns `true` when the failure was the user declining in their wallet.
+ *
+ * @example
+ * ```ts
+ * try { await vault.deposit(...); }
+ * catch (e) {
+ *   if (isUserRejectionError(e)) return; // user cancelled — not an error
+ *   throw e;
+ * }
+ * ```
+ */
+function isUserRejectionError(error) {
+    const codes = errorCodes(error);
+    if (codes.includes('ACTION_REJECTED') || codes.includes(4001))
+        return true;
+    const msg = errorText(error).toLowerCase();
+    return (msg.includes('user rejected') ||
+        msg.includes('user denied') ||
+        msg.includes('rejected the request') ||
+        msg.includes('request rejected'));
+}
+/**
+ * Is this error a routine on-chain read revert rather than a real failure?
+ *
+ * Reading a function a contract doesn't implement, or an address that holds no
+ * (or incompatible) bytecode, reverts — a normal outcome when the SDK probes
+ * heterogeneous vaults. Matches ethers' `CALL_EXCEPTION` code and the
+ * message variants emitted by ethers and viem (`missing revert data`,
+ * `execution reverted`, `call revert exception`, and the bare `reverted`
+ * phrasing such as `the contract function "totalAssets" reverted`).
+ *
+ * Scope note: callers apply this on **read** paths only. A reverted *write*
+ * (a tx that failed on-chain) is a genuine error and is intentionally not
+ * demoted by this predicate's use in `write.actions`.
+ *
+ * @param error - The caught value, of unknown type.
+ * @returns `true` when the failure is an expected/benign contract revert.
+ *
+ * @example
+ * ```ts
+ * try { return await vaultContract.maxDepositAmount(); }
+ * catch (e) {
+ *   logChainError('maxDeposit', e, isExpectedRevertError(e));
+ *   throw e;
+ * }
+ * ```
+ */
+function isExpectedRevertError(error) {
+    const codes = errorCodes(error);
+    if (codes.includes('CALL_EXCEPTION'))
+        return true;
+    const msg = errorText(error).toLowerCase();
+    return (msg.includes('call_exception') ||
+        msg.includes('missing revert data') ||
+        msg.includes('execution reverted') ||
+        msg.includes('call revert exception') ||
+        msg.includes('reverted'));
+}
+/**
+ * Log a caught chain error at the severity its category warrants, without
+ * swallowing it. When `isBenign` is `true` the failure is recorded as a `warn`
+ * (a Sentry breadcrumb that rides along with the next real issue, not a billed
+ * standalone issue); otherwise it is logged at `error` (a Sentry issue). The
+ * caller is still responsible for re-throwing — this only routes telemetry.
+ *
+ * Pass the benign decision explicitly (via {@link isUserRejectionError} or
+ * {@link isExpectedRevertError}) so the call site documents *why* the demotion
+ * is safe and each path opts into only the category that applies to it.
+ *
+ * @param tag - Low-cardinality call-site label (e.g. `'deposit'`), used as the
+ *   Sentry breadcrumb/issue grouping key.
+ * @param error - The caught value, of unknown type.
+ * @param isBenign - `true` to demote to `warn`; `false` to keep at `error`.
+ * @param context - Optional structured context attached to the log entry. It is
+ *   sanitized by the logger before transport.
+ */
+function logChainError(tag, error, isBenign, context) {
+    if (isBenign) {
+        // Demote to a breadcrumb: the SDK's Sentry sink forwards `warn` as a
+        // breadcrumb, so this no longer creates its own billed issue while still
+        // preserving the trail if a genuine error follows.
+        logger_1.Logger.log.warn(tag, { message: errorText(error), ...(context ?? {}) });
+        return;
+    }
+    logger_1.Logger.log.error(tag, error, context);
+}
+//# sourceMappingURL=chain-error.js.map

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

@@ -12,13 +12,25 @@ import type { IAddress } from '../../types';
  */
 export declare function getSwapRouterAddress(chainId: number): IAddress | undefined;
 /**
- * Whether a vault has been registered on a `SwapRouter` and should route
- * its deposits through it. Address comparison is case-insensitive.
+ * Whether a vault is eligible for the any-token `SwapRouter` deposit surface
+ * (the SwapRouter is `enableVault`-ed for it on-chain). Address comparison is
+ * case-insensitive.
+ *
+ * This gates the (flag-controlled) swap-router deposit UI and can fail-fast a
+ * {@link swapRouterDeposit} call. It does **not** affect {@link vaultDeposit},
+ * which is always the native/multiasset/adapter path.
  *
  * @param vaultAddress - August vault address.
- * @returns `true` when the vault is in {@link VAULTS_USING_SWAP_ROUTER}.
+ * @returns `true` when the vault is in {@link SWAP_ROUTER_ELIGIBLE_VAULTS}.
+ */
+export declare function isSwapRouterEligible(vaultAddress: IAddress): boolean;
+/**
+ * @deprecated Renamed to {@link isSwapRouterEligible}. The meaning also changed:
+ * it no longer implies `vaultDeposit` routes the vault through the SwapRouter
+ * (that behavior was removed) — it only reports swap-router *eligibility* for
+ * the opt-in deposit surface. Kept as an alias for one release.
  */
-export declare function vaultUsesSwapRouter(vaultAddress: IAddress): boolean;
+export declare const vaultUsesSwapRouter: typeof isSwapRouterEligible;
 /**
  * Normalize an optional origin code to the value to send on-chain.
  *

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

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.vaultUsesSwapRouter = void 0;
 exports.getSwapRouterAddress = getSwapRouterAddress;
-exports.vaultUsesSwapRouter = vaultUsesSwapRouter;
+exports.isSwapRouterEligible = isSwapRouterEligible;
 exports.resolveOriginCode = resolveOriginCode;
 const swap_router_1 = require("../constants/swap-router");
 const errors_1 = require("../errors");
@@ -20,15 +21,27 @@ function getSwapRouterAddress(chainId) {
     return swap_router_1.SWAP_ROUTER_ADDRESSES[chainId];
 }
 /**
- * Whether a vault has been registered on a `SwapRouter` and should route
- * its deposits through it. Address comparison is case-insensitive.
+ * Whether a vault is eligible for the any-token `SwapRouter` deposit surface
+ * (the SwapRouter is `enableVault`-ed for it on-chain). Address comparison is
+ * case-insensitive.
+ *
+ * This gates the (flag-controlled) swap-router deposit UI and can fail-fast a
+ * {@link swapRouterDeposit} call. It does **not** affect {@link vaultDeposit},
+ * which is always the native/multiasset/adapter path.
  *
  * @param vaultAddress - August vault address.
- * @returns `true` when the vault is in {@link VAULTS_USING_SWAP_ROUTER}.
+ * @returns `true` when the vault is in {@link SWAP_ROUTER_ELIGIBLE_VAULTS}.
  */
-function vaultUsesSwapRouter(vaultAddress) {
-    return swap_router_1.VAULTS_USING_SWAP_ROUTER.has(vaultAddress.toLowerCase());
+function isSwapRouterEligible(vaultAddress) {
+    return swap_router_1.SWAP_ROUTER_ELIGIBLE_VAULTS.has(vaultAddress.toLowerCase());
 }
+/**
+ * @deprecated Renamed to {@link isSwapRouterEligible}. The meaning also changed:
+ * it no longer implies `vaultDeposit` routes the vault through the SwapRouter
+ * (that behavior was removed) — it only reports swap-router *eligibility* for
+ * the opt-in deposit surface. Kept as an alias for one release.
+ */
+exports.vaultUsesSwapRouter = isSwapRouterEligible;
 /**
  * Normalize an optional origin code to the value to send on-chain.
  *

package/lib/core/index.d.ts

@@ -12,6 +12,7 @@ export * from './constants/vaults';
 export * from './constants/swap-router';
 export * from './helpers/web3';
 export * from './helpers/vaults';
+export * from './helpers/chain-error';
 export * from './helpers/core';
 export * from './helpers/adapters';
 export * from './helpers/signer';

package/lib/core/index.js

@@ -28,6 +28,7 @@ __exportStar(require("./constants/vaults"), exports);
 __exportStar(require("./constants/swap-router"), exports);
 __exportStar(require("./helpers/web3"), exports);
 __exportStar(require("./helpers/vaults"), exports);
+__exportStar(require("./helpers/chain-error"), exports);
 __exportStar(require("./helpers/core"), exports);
 __exportStar(require("./helpers/adapters"), exports);
 __exportStar(require("./helpers/signer"), exports);

package/lib/main.d.ts

@@ -253,6 +253,32 @@ export declare class AugustSDK extends AugustBase {
         timestamp: number;
         transactionHash: string;
     }[]>;
+    /**
+     * Get a vault's deposit/withdrawal activity across every participant.
+     *
+     * The vault-wide counterpart to {@link AugustSDK.getVaultUserHistory} — use
+     * it to answer flow questions ("how many deposits in the last 7 days", "net
+     * flow this week") that point-in-time TVL cannot. Reads from the Goldsky
+     * subgraph, paginated so busy vaults are not truncated; a `sinceTs` window
+     * keeps short lookbacks cheap.
+     * @param props - Vault address, optional chain id, optional `sinceTs`/`untilTs`
+     * Unix-second bounds, and an optional `types` filter.
+     * @returns Array of activity items (oldest-first) with normalized amounts,
+     * actor addresses, event type, and transaction hashes.
+     * @throws If `vault` is not a valid address or no chain id can be resolved.
+     * @example
+     * ```ts
+     * const weekAgo = Math.floor(Date.now() / 1000) - 7 * 86_400;
+     * const items = await sdk.getVaultActivity({ vault, chainId: 143, sinceTs: weekAgo });
+     * ```
+     */
+    getVaultActivity(props: {
+        vault: IAddress;
+        chainId?: IChainId;
+        sinceTs?: number;
+        untilTs?: number;
+        types?: ('withdraw-request' | 'deposit' | 'withdraw-processed' | 'redeem')[];
+    }): Promise<import("./types").IVaultUserHistoryItem[]>;
     /**
      * Get lifetime PnL for a user in a specific vault.
      * Calculates realized and unrealized PnL based on deposit/withdrawal history and current position.

package/lib/main.js

@@ -316,6 +316,28 @@ class AugustSDK extends core_1.AugustBase {
     async getVaultUserTransfers(props) {
         return await this.vaults.getUserTransfers(props);
     }
+    /**
+     * Get a vault's deposit/withdrawal activity across every participant.
+     *
+     * The vault-wide counterpart to {@link AugustSDK.getVaultUserHistory} — use
+     * it to answer flow questions ("how many deposits in the last 7 days", "net
+     * flow this week") that point-in-time TVL cannot. Reads from the Goldsky
+     * subgraph, paginated so busy vaults are not truncated; a `sinceTs` window
+     * keeps short lookbacks cheap.
+     * @param props - Vault address, optional chain id, optional `sinceTs`/`untilTs`
+     * Unix-second bounds, and an optional `types` filter.
+     * @returns Array of activity items (oldest-first) with normalized amounts,
+     * actor addresses, event type, and transaction hashes.
+     * @throws If `vault` is not a valid address or no chain id can be resolved.
+     * @example
+     * ```ts
+     * const weekAgo = Math.floor(Date.now() / 1000) - 7 * 86_400;
+     * const items = await sdk.getVaultActivity({ vault, chainId: 143, sinceTs: weekAgo });
+     * ```
+     */
+    async getVaultActivity(props) {
+        return await this.vaults.getVaultActivity(props);
+    }
     /**
      * Get lifetime PnL for a user in a specific vault.
      * Calculates realized and unrealized PnL based on deposit/withdrawal history and current position.

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

@@ -254,6 +254,52 @@ export declare class AugustVaults extends AugustBase {
         timestamp: number;
         transactionHash: string;
     }[]>;
+    /**
+     * Fetch a vault's deposit/withdrawal activity across every participant.
+     *
+     * This is the vault-wide counterpart to {@link getUserHistory}: instead of
+     * filtering the subgraph to one wallet, it returns every deposit,
+     * withdrawal-request, and processed-withdrawal event for the pool. Use it to
+     * answer flow questions ("how many deposits in the last 7 days", "net flow
+     * this week") that point-in-time TVL cannot.
+     *
+     * Rows are read from the Goldsky subgraph, paginated internally so busy
+     * vaults are not truncated at the 1000-row page cap. When `sinceTs` is
+     * supplied the reader stops paging once it passes the window boundary, so a
+     * short lookback stays cheap even on high-volume vaults.
+     *
+     * @param params - Query parameters.
+     * @param params.vault - Vault (pool) address to read activity for.
+     * @param params.chainId - Chain id of the vault; falls back to the active
+     * network when omitted. Required for the subgraph lookup.
+     * @param params.sinceTs - Lower bound (inclusive) as a Unix timestamp in
+     * seconds. Events at or after this time are returned.
+     * @param params.untilTs - Upper bound (inclusive) as a Unix timestamp in
+     * seconds. Events at or before this time are returned.
+     * @param params.types - Restrict to a subset of event types (e.g.
+     * `['deposit']`). Returns all types when omitted.
+     * @returns Activity items sorted oldest-first, each with a normalized
+     * `amount`, actor `address`, `type`, and `transactionHash`.
+     * @throws If `vault` is not a valid address, or no chain id can be resolved.
+     * @example
+     * ```ts
+     * const weekAgo = Math.floor(Date.now() / 1000) - 7 * 86_400;
+     * const deposits = await sdk.getVaultActivity({
+     *   vault: '0x36eDbF0C834591BFdfCaC0Ef9605528c75c406aA',
+     *   chainId: 143,
+     *   sinceTs: weekAgo,
+     *   types: ['deposit'],
+     * });
+     * console.log(`${deposits.length} deposits in the last 7 days`);
+     * ```
+     */
+    getVaultActivity({ vault, chainId, sinceTs, untilTs, types, }: {
+        vault: IAddress;
+        chainId?: IChainId;
+        sinceTs?: number;
+        untilTs?: number;
+        types?: IVaultUserHistoryItem['type'][];
+    }): Promise<IVaultUserHistoryItem[]>;
     /**
      * @function getStakingPositions gets all available reward staking positions
      * @param wallet optionally passed user wallet address

package/lib/modules/vaults/main.js

@@ -905,6 +905,77 @@ class AugustVaults extends core_1.AugustBase {
         core_1.Logger.log.info('getUserTransfers', `${wallet}::${finalArray.length}`);
         return finalArray;
     }
+    /**
+     * Fetch a vault's deposit/withdrawal activity across every participant.
+     *
+     * This is the vault-wide counterpart to {@link getUserHistory}: instead of
+     * filtering the subgraph to one wallet, it returns every deposit,
+     * withdrawal-request, and processed-withdrawal event for the pool. Use it to
+     * answer flow questions ("how many deposits in the last 7 days", "net flow
+     * this week") that point-in-time TVL cannot.
+     *
+     * Rows are read from the Goldsky subgraph, paginated internally so busy
+     * vaults are not truncated at the 1000-row page cap. When `sinceTs` is
+     * supplied the reader stops paging once it passes the window boundary, so a
+     * short lookback stays cheap even on high-volume vaults.
+     *
+     * @param params - Query parameters.
+     * @param params.vault - Vault (pool) address to read activity for.
+     * @param params.chainId - Chain id of the vault; falls back to the active
+     * network when omitted. Required for the subgraph lookup.
+     * @param params.sinceTs - Lower bound (inclusive) as a Unix timestamp in
+     * seconds. Events at or after this time are returned.
+     * @param params.untilTs - Upper bound (inclusive) as a Unix timestamp in
+     * seconds. Events at or before this time are returned.
+     * @param params.types - Restrict to a subset of event types (e.g.
+     * `['deposit']`). Returns all types when omitted.
+     * @returns Activity items sorted oldest-first, each with a normalized
+     * `amount`, actor `address`, `type`, and `transactionHash`.
+     * @throws If `vault` is not a valid address, or no chain id can be resolved.
+     * @example
+     * ```ts
+     * const weekAgo = Math.floor(Date.now() / 1000) - 7 * 86_400;
+     * const deposits = await sdk.getVaultActivity({
+     *   vault: '0x36eDbF0C834591BFdfCaC0Ef9605528c75c406aA',
+     *   chainId: 143,
+     *   sinceTs: weekAgo,
+     *   types: ['deposit'],
+     * });
+     * console.log(`${deposits.length} deposits in the last 7 days`);
+     * ```
+     */
+    async getVaultActivity({ vault, chainId, sinceTs, untilTs, types, }) {
+        if (!(0, ethers_1.isAddress)(vault))
+            throw new Error(`Vault parameter is not an address: ${String(vault)}`);
+        const _chainId = chainId || this.activeNetwork?.chainId;
+        if (!_chainId) {
+            throw new Error('Chain ID is required for getVaultActivity. Pass chainId explicitly or configure an active network.');
+        }
+        const provider = (0, core_1.createProvider)(this.providers?.[_chainId]);
+        const raw = await (0, vaults_1.getSubgraphVaultHistory)(provider, vault, undefined, {
+            sinceTs,
+        });
+        const typeFilter = types?.length ? new Set(types) : undefined;
+        return raw
+            .map((h) => ({
+            timestamp: Number(h.timestamp_),
+            address: h.address,
+            amount: (0, core_1.toNormalizedBn)(BigInt(h.amount), h.decimals),
+            pool: h.contractId_,
+            chainId: _chainId,
+            type: h.type,
+            transactionHash: h.transactionHash_,
+        }))
+            .filter((h) => {
+            if (sinceTs !== undefined && h.timestamp < sinceTs)
+                return false;
+            if (untilTs !== undefined && h.timestamp > untilTs)
+                return false;
+            if (typeFilter && !typeFilter.has(h.type))
+                return false;
+            return true;
+        });
+    }
     /**
      * @function getStakingPositions gets all available reward staking positions
      * @param wallet optionally passed user wallet address

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

@@ -40,7 +40,7 @@ async function fetchInstantRedemptionFee(signer, options) {
         }
     }
     catch (e) {
-        core_1.Logger.log.error('failed to fetch instant redeem fee', e);
+        (0, core_1.logChainError)('failed to fetch instant redeem fee', e, (0, core_1.isExpectedRevertError)(e));
         throw new Error(`Failed to fetch instant redeem fee for ${target}: ${e instanceof Error ? e.message : 'Unknown error'}`);
     }
 }
@@ -83,7 +83,7 @@ async function vaultAllowance(signer, options) {
         return normalized;
     }
     catch (e) {
-        core_1.Logger.log.error('allowance', e);
+        (0, core_1.logChainError)('allowance', e, (0, core_1.isExpectedRevertError)(e));
         throw new Error(`Failed to fetch allowance: ${e instanceof Error ? e.message : 'Unknown error'}`);
     }
 }
@@ -109,7 +109,7 @@ async function sendersWhitelistAddress(signer, options) {
         return whitelistAddress;
     }
     catch (e) {
-        core_1.Logger.log.error('sendersWhitelistAddress', e);
+        (0, core_1.logChainError)('sendersWhitelistAddress', e, (0, core_1.isExpectedRevertError)(e));
         throw new Error(`Failed to fetch senders whitelist address: ${e instanceof Error ? e.message : 'Unknown error'}`);
     }
 }
@@ -138,7 +138,7 @@ async function isWhitelisted(signer, options) {
         return result;
     }
     catch (e) {
-        core_1.Logger.log.error('isWhitelisted', e);
+        (0, core_1.logChainError)('isWhitelisted', e, (0, core_1.isExpectedRevertError)(e));
         throw new Error(`Failed to check whitelist status: ${e instanceof Error ? e.message : 'Unknown error'}`);
     }
 }
@@ -183,7 +183,7 @@ async function getDeposited(signer, options) {
         return normalized;
     }
     catch (e) {
-        core_1.Logger.log.error('getDeposited', e);
+        (0, core_1.logChainError)('getDeposited', e, (0, core_1.isExpectedRevertError)(e));
         throw new Error(`Failed to fetch deposited amount: ${e instanceof Error ? e.message : 'Unknown error'}`);
     }
 }
@@ -232,7 +232,7 @@ async function getRemainingAllocations(signer, options) {
         return normalized;
     }
     catch (e) {
-        core_1.Logger.log.error('getRemainingAllocations', e);
+        (0, core_1.logChainError)('getRemainingAllocations', e, (0, core_1.isExpectedRevertError)(e));
         throw new Error(`Failed to fetch remaining allocations: ${e instanceof Error ? e.message : 'Unknown error'}`);
     }
 }
@@ -263,7 +263,11 @@ async function previewRwaRedemption(signer, options) {
         return normalized;
     }
     catch (e) {
-        core_1.Logger.log.error('previewRwaRedemption', e, { target, asset, amount });
+        (0, core_1.logChainError)('previewRwaRedemption', e, (0, core_1.isExpectedRevertError)(e), {
+            target,
+            asset,
+            amount,
+        });
         throw new Error(`Preview RWA redemption failed: ${e instanceof Error ? e.message : 'Unknown error'}`);
     }
 }
@@ -354,7 +358,10 @@ async function previewDeposit(signer, options) {
         if (e instanceof core_1.AugustValidationError || e instanceof core_1.AugustSDKError) {
             throw e;
         }
-        core_1.Logger.log.error('previewDeposit', e, { vault, amount: amount.toString() });
+        (0, core_1.logChainError)('previewDeposit', e, (0, core_1.isExpectedRevertError)(e), {
+            vault,
+            amount: amount.toString(),
+        });
         throw new core_1.AugustSDKError('UNKNOWN', `previewDeposit failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { vault, amount: amount.toString() } });
     }
 }
@@ -410,7 +417,7 @@ async function previewRedeem(signer, options) {
         if (e instanceof core_1.AugustValidationError || e instanceof core_1.AugustSDKError) {
             throw e;
         }
-        core_1.Logger.log.error('previewRedeem', e, {
+        (0, core_1.logChainError)('previewRedeem', e, (0, core_1.isExpectedRevertError)(e), {
             vault,
             shares: shares.toString(),
         });
@@ -480,7 +487,11 @@ async function allowance(signer, options) {
         if (e instanceof core_1.AugustValidationError || e instanceof core_1.AugustSDKError) {
             throw e;
         }
-        core_1.Logger.log.error('allowance', e, { vault, owner, asset });
+        (0, core_1.logChainError)('allowance', e, (0, core_1.isExpectedRevertError)(e), {
+            vault,
+            owner,
+            asset,
+        });
         throw new core_1.AugustSDKError('UNKNOWN', `allowance failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { vault, owner, asset } });
     }
 }
@@ -521,7 +532,7 @@ async function balanceOf(signer, options) {
         if (e instanceof core_1.AugustValidationError || e instanceof core_1.AugustSDKError) {
             throw e;
         }
-        core_1.Logger.log.error('balanceOf', e, { asset, owner });
+        (0, core_1.logChainError)('balanceOf', e, (0, core_1.isExpectedRevertError)(e), { asset, owner });
         throw new core_1.AugustSDKError('UNKNOWN', `balanceOf failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { asset, owner } });
     }
 }
@@ -575,7 +586,10 @@ async function maxDeposit(signer, options) {
         if (e instanceof core_1.AugustValidationError || e instanceof core_1.AugustSDKError) {
             throw e;
         }
-        core_1.Logger.log.error('maxDeposit', e, { vault, receiver });
+        (0, core_1.logChainError)('maxDeposit', e, (0, core_1.isExpectedRevertError)(e), {
+            vault,
+            receiver,
+        });
         throw new core_1.AugustSDKError('UNKNOWN', `maxDeposit failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { vault, receiver } });
     }
 }

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

@@ -1,6 +1,6 @@
 import { type Signer, type Wallet, type TransactionResponse } from 'ethers';
 import type { IAddress } from '../../types';
-import type { ISwapAndDepositOptions, ISwapRouterDirectDepositOptions, ISwapRouterNativeDepositOptions } from '../../types';
+import type { ISwapAndDepositOptions, ISwapRouterDirectDepositOptions, ISwapRouterNativeDepositOptions, ISwapRouterDepositOptions } from '../../types';
 export type IContractWriteOptions = {
     target: IAddress;
     wallet: IAddress;
@@ -76,7 +76,6 @@ export declare function resolveSpender(args: {
     isMultiAssetVault: boolean;
     isAdapterDeposit: boolean;
     adapterWrapperAddress?: IAddress;
-    swapRouterAddress?: IAddress;
 }): IAddress;
 /** @internal */
 export declare function validateAmountPrecision(amount: string | bigint | number): void;
@@ -438,3 +437,53 @@ export declare function depositViaSwapRouter(signer: Signer | Wallet, options: I
  * addresses, or zero amount.
  */
 export declare function depositNativeViaSwapRouter(signer: Signer | Wallet, options: ISwapRouterNativeDepositOptions): Promise<string>;
+/**
+ * Deposit into an August vault through the on-chain `SwapRouter`, selecting the
+ * correct router path from the deposit asset. This is the high-level, explicit
+ * counterpart to the SwapRouter branch inside {@link vaultDeposit}.
+ *
+ * Where `vaultDeposit` decides whether to use the SwapRouter from the
+ * `VAULTS_USING_SWAP_ROUTER` allowlist, this function always routes through the
+ * SwapRouter because the caller asked it to. Making the intent explicit is the
+ * point: a native-deposit vault (e.g. a multi-asset Tokenized Vault V2 whose
+ * non-reference assets are accepted directly) is never accidentally swapped —
+ * the regression that implicit, allowlist-driven routing caused. Use
+ * `vaultDeposit` for native / adapter deposits and this for SwapRouter deposits.
+ *
+ * The vault's reference asset and its decimals are read on-chain (never trusted
+ * from the caller — a wrong reference asset would mis-route the swap). The path
+ * is then chosen from `depositAsset`:
+ *  - equals the reference asset → direct router deposit, no swap
+ *    ({@link depositViaSwapRouter});
+ *  - the zero address → native-token deposit ({@link depositNativeViaSwapRouter}),
+ *    valid only when the reference asset is the chain's wrapped-native token;
+ *  - any other ERC-20 → a swap to the reference asset (Paraswap quote pinned to
+ *    the chain's whitelisted aggregator, fail-closed on router/selector drift)
+ *    bundled into {@link swapAndDeposit}.
+ *
+ * Side effects: reads tokenized-vault metadata, the vault's reference asset and
+ * decimals, and (on the swap path) one Paraswap quote; sends one ERC-20
+ * `approve` to the SwapRouter when allowance is short, then the deposit tx.
+ *
+ * @param signer - ethers `Signer` or `Wallet` that signs the approval + deposit.
+ * @param options - {@link ISwapRouterDepositOptions}.
+ * @returns The transaction hash of the router deposit call.
+ * @throws {@link AugustValidationError} for an unsupported chain (no SwapRouter
+ *   deployment), an invalid vault or deposit-asset address, a missing or zero
+ *   amount, a native deposit into a non-wrapped-native vault, or drift between
+ *   the aggregator quote and the on-chain router whitelist.
+ * @worstCaseRpcCalls 5 on the swap path — tokenized-vault metadata, reference
+ *   asset + decimals, deposit-token decimals, the quote, and the allowance read.
+ * @example
+ * ```ts
+ * // USDT deposited into a USDC-reference vault → swapped to USDC en route.
+ * const hash = await augustSdk.evm.swapRouterDeposit({
+ *   chainId: 1,
+ *   vault: '0xe9b725010a9e419412ed67d0fa5f3a5f40159d32',
+ *   depositAsset: '0xdAC17F958D2ee523a2206206994597C13D831ec7',
+ *   amount: '100',
+ *   slippageBps: 50,
+ * });
+ * ```
+ */
+export declare function swapRouterDeposit(signer: Signer | Wallet, options: ISwapRouterDepositOptions): Promise<string>;