@augustdigital/sdk 9.7.1 → 9.9.0

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

@@ -8,6 +8,7 @@ exports.isNonceParsing = isNonceParsing;
 exports.safeWaitForTx = safeWaitForTx;
 exports.safeSendTx = safeSendTx;
 exports.tryRecoverTxHash = tryRecoverTxHash;
+exports.getDepositRoute = getDepositRoute;
 exports.vaultApprove = vaultApprove;
 exports.approve = approve;
 exports.vaultDeposit = vaultDeposit;
@@ -24,6 +25,7 @@ exports.swapRouterDeposit = swapRouterDeposit;
 const ethers_1 = require("ethers");
 const abis_1 = require("../../abis");
 const core_1 = require("../../core");
+const types_1 = require("../../types");
 const swap_quotes_1 = require("../../services/swap-quotes");
 const adapter_helpers_1 = require("./adapter.helpers");
 const utils_1 = require("./utils");
@@ -428,6 +430,191 @@ function throwIfInsufficientFunds(isInsufficient, operation, error, context) {
         return;
     throw new core_1.AugustValidationError('ACCOUNT_NOT_FUNDED', `${operation} failed: insufficient native balance to cover gas/network fees`, { cause: error, context });
 }
+/**
+ * Shared catch path for the SwapRouter write methods, with the same recovery
+ * and classification as `vaultDeposit`: recover a nonce-parse hash, pass typed
+ * SDK errors through, log (demoting user rejections and unfunded accounts),
+ * map insufficient funds to `ACCOUNT_NOT_FUNDED`, and wrap the rest.
+ * @internal
+ */
+async function handleSwapRouterWriteError(e, tx, signer, wait, operation, label, context) {
+    const recovered = await tryRecoverTxHash(e, signer, wait);
+    if (recovered) {
+        core_1.Logger.log.warn(`${operation}:nonce-fallback`, { hash: recovered });
+        return recovered;
+    }
+    if (e instanceof core_1.AugustSDKError)
+        throw e;
+    const ctx = { ...context, ...localTxBroadcastContext(tx, e) };
+    const insufficientFunds = (0, core_1.isInsufficientFundsError)(e);
+    (0, core_1.logChainError)(operation, e, (0, core_1.isUserRejectionError)(e) || insufficientFunds, ctx);
+    throwIfInsufficientFunds(insufficientFunds, label, e, ctx);
+    throw new core_1.AugustSDKError('UNKNOWN', `${label} failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: ctx });
+}
+/**
+ * Whether a router-registered vault takes `asset` as-is: its reference asset,
+ * or, for a Tokenized Vault V2 (backend `evm-2` and router `vaultType`), an
+ * asset on the vault's assets whitelist. Shared by the deposit-route resolver
+ * and the `swapRouterDeposit` dispatch so neither swaps an asset the vault
+ * accepts.
+ * @internal
+ */
+async function isAcceptedDirectly(signer, target, asset, isMultiAssetVault, vaultInfo) {
+    const lower = asset.toLowerCase();
+    return (lower === vaultInfo.referenceAsset.toLowerCase() ||
+        (isMultiAssetVault &&
+            vaultInfo.vaultType === types_1.SwapRouterVaultType.TokenizedVaultV2 &&
+            (await (0, core_1.getWhitelistedAssets)(signer, await (0, core_1.createContract)({
+                address: target,
+                provider: signer,
+                abi: abis_1.ABI_TOKENIZED_VAULT_V2,
+            }).assetsWhitelistAddress())).some((a) => a.toLowerCase() === lower)));
+}
+/** @internal */
+async function resolveDepositRoute(signer, args) {
+    const { target, chainId, actualDepositAsset, isMultiAssetVault } = args;
+    const asset = actualDepositAsset.toLowerCase();
+    const isNativeToken = actualDepositAsset === ethers_1.ZeroAddress;
+    const isAdapterDeposit = asset !== args.underlyingAsset.toLowerCase();
+    const wrapper = (0, core_1.getVaultAdapterConfig)(target)?.wrapperAddress;
+    const native = (reason) => ({
+        via: 'native',
+        spender: isNativeToken
+            ? null
+            : resolveSpender({
+                target,
+                isMultiAssetVault,
+                isAdapterDeposit,
+                adapterWrapperAddress: wrapper,
+            }),
+        reason,
+    });
+    const originCode = (0, core_1.getOriginCode)();
+    if (!originCode)
+        return native('no-origin-code');
+    const router = chainId ? (0, core_1.getSwapRouterAddress)(chainId) : undefined;
+    if (!chainId || !router)
+        return native('no-router');
+    if (!core_1.ORIGIN_ATTRIBUTION_CHAINS.includes(chainId)) {
+        return native('chain-not-supported');
+    }
+    if (args.isDepositWithPermit)
+        return native('permit');
+    if (isNativeToken)
+        return native('native-token');
+    if (isAdapterDeposit && !isMultiAssetVault && wrapper) {
+        return native('adapter');
+    }
+    const vaultInfo = await (0, core_1.readSwapRouterVaultInfo)(signer, chainId, target);
+    if (!vaultInfo || vaultInfo.referenceAsset === ethers_1.ZeroAddress) {
+        return native('vault-not-registered');
+    }
+    if (!(await isAcceptedDirectly(signer, target, actualDepositAsset, isMultiAssetVault, vaultInfo))) {
+        return native('asset-not-accepted');
+    }
+    if (!(await (0, core_1.readSwapRouterTokenWhitelisted)(signer, chainId, actualDepositAsset))) {
+        return native('router-token-not-whitelisted');
+    }
+    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 } });
+        }
+        return native('origin-not-registered');
+    }
+    return { via: 'router', spender: router };
+}
+/**
+ * Resolve whether a deposit can go through the SwapRouter carrying the
+ * instance origin code (`router`) or takes the vault's native path
+ * (`native`), and which address to approve. Read-only. `vaultDeposit` and
+ * `approve` follow this route, so integrators that manage approvals
+ * themselves must approve `route.spender`, not the vault.
+ *
+ * The route is `router` only when an origin code is configured, the chain is
+ * 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`.
+ *
+ * @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`.
+ * @throws AugustSDKError when a backend, vault or router read fails.
+ * @worstCaseRpcCalls 7 — 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.
+ * @example
+ * ```ts
+ * const route = await augustSdk.evm.getDepositRoute({ target: vault, depositAsset: usdt });
+ * if (route.spender) await approveToken(usdt, route.spender, amount);
+ * ```
+ */
+async function getDepositRoute(signer, options) {
+    const { target, depositAsset } = options;
+    if (!(0, core_1.checkAddress)(target, console)) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', 'getDepositRoute: invalid target address');
+    }
+    try {
+        const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(target))?.[0];
+        const isMultiAssetVault = (0, core_1.getVaultVersionV2)(tokenizedVault) === 'evm-2';
+        const underlyingAsset = (await (0, core_1.createContract)({
+            address: target,
+            provider: signer,
+            abi: isMultiAssetVault ? abis_1.ABI_TOKENIZED_VAULT_V2 : abis_1.ABI_LENDING_POOLS,
+        }).asset());
+        return await resolveDepositRoute(signer, {
+            target,
+            chainId: tokenizedVault?.chain ?? options.chainId,
+            actualDepositAsset: depositAsset || underlyingAsset,
+            underlyingAsset,
+            isMultiAssetVault,
+            isDepositWithPermit: options.isDepositWithPermit,
+        });
+    }
+    catch (e) {
+        if (e instanceof core_1.AugustSDKError)
+            throw e;
+        throw new core_1.AugustSDKError('UNKNOWN', `getDepositRoute failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { target, chainId: options.chainId } });
+    }
+}
+/**
+ * Report whether a deposit carried the instance origin code: the bounded
+ * `sdk.attribution.origin` tag (`applied` | `skipped` | `none`), the code only
+ * as a span attribute, and — when a configured code was not applied — a
+ * warning with the resolver's reason, which the logger also forwards to
+ * Sentry as a breadcrumb.
+ * @internal
+ */
+function trackOriginAttribution(route, context, operation = 'vaultDeposit') {
+    const status = route.via === 'router'
+        ? 'applied'
+        : route.reason === 'no-origin-code'
+            ? 'none'
+            : 'skipped';
+    if (status === 'skipped') {
+        core_1.Logger.log.warn(`${operation}:attribution-skipped`, {
+            reason: route.reason,
+            ...context,
+        });
+    }
+    if (!(0, core_1.isAnalyticsEnabled)())
+        return;
+    const sentry = (0, core_1.getSentrySDK)();
+    sentry?.setTag('sdk.attribution.origin', status);
+    if (status === 'applied') {
+        sentry
+            ?.getActiveSpan()
+            ?.setAttribute('sdk.attribution.origin_code', (0, core_1.resolveOriginCode)(undefined, context.chainId));
+    }
+}
 async function approveCore(signer, options) {
     const { wallet, target, wait, amount, depositAsset } = options;
     const [goodWallet, goodPool] = [
@@ -444,7 +631,6 @@ async function approveCore(signer, options) {
     try {
         const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(target))?.[0];
         const vaultVersion = (0, core_1.getVaultVersionV2)(tokenizedVault);
-        const adapterConfig = (0, core_1.getVaultAdapterConfig)(target);
         const isMultiAssetVault = vaultVersion === 'evm-2';
         const poolContract = isMultiAssetVault
             ? (0, core_1.createContract)({
@@ -483,13 +669,14 @@ async function approveCore(signer, options) {
         // Native tokens travel as msg.value — no ERC-20 allowance to grant.
         if (isNativeToken)
             return { kind: 'native' };
-        const isAdapterDeposit = actualDepositAsset.toLowerCase() !== underlyingAsset.toLowerCase();
-        const spenderAddress = resolveSpender({
+        const spenderAddress = (await resolveDepositRoute(signer, {
             target,
+            chainId: tokenizedVault?.chain ?? options.chainId,
+            actualDepositAsset,
+            underlyingAsset,
             isMultiAssetVault,
-            isAdapterDeposit,
-            adapterWrapperAddress: adapterConfig?.wrapperAddress,
-        });
+            isDepositWithPermit: options.isDepositWithPermit,
+        })).spender;
         const depositTokenDecimals = await resolveDepositTokenDecimals({
             actualDepositAsset,
             underlyingAsset,
@@ -547,14 +734,18 @@ async function approveCore(signer, options) {
  * Approve a vault (or the appropriate adapter wrapper) to spend a token
  * ahead of a separate deposit call. Spender routing mirrors
  * {@link vaultDeposit} (multi-asset → vault, adapter → wrapper, standard →
- * vault). Returns `undefined` when the existing allowance already covers
- * `amount` **or** when the deposit asset is native.
+ * vault, SwapRouter when {@link getDepositRoute} routes there). Returns
+ * `undefined` when the existing allowance already covers `amount` **or**
+ * when the deposit asset is native.
  *
  * @returns Transaction hash when an approval was sent, `undefined` when
  *   the existing allowance already covers `amount` or the deposit asset is
  *   native (no ERC-20 allowance applies). Use {@link approve} for a
  *   discriminated `ApproveResult` if you need to tell those two cases apart.
  * @throws AugustValidationError on invalid wallet/target/amount.
+ * @throws AugustValidationError when `attribution.strictOrigin` is set and the
+ *   configured origin code is not registered on the SwapRouter (the spender
+ *   follows {@link getDepositRoute}).
  *
  * @example
  * ```ts
@@ -600,6 +791,9 @@ async function vaultApprove(signer, options) {
  * ```
  *
  * @throws AugustValidationError on invalid wallet/target/amount.
+ * @throws AugustValidationError when `attribution.strictOrigin` is set and the
+ *   configured origin code is not registered on the SwapRouter (the spender
+ *   follows {@link getDepositRoute}).
  * @throws AugustSDKError when the approval submission fails.
  */
 async function approve(signer, options) {
@@ -611,6 +805,11 @@ async function approve(signer, options) {
  * Paraswap adapter, native-token wrapper, depositWithPermit) based on the
  * vault version and `depositAsset`.
  *
+ * With `attribution.originCode` configured, a deposit the SwapRouter can take
+ * directly goes through `SwapRouter.deposit` carrying that code, and the
+ * router is approved instead of the vault — see {@link getDepositRoute} for
+ * the rules and the fallback reasons. Without a code nothing changes.
+ *
  * Amounts are encoded against the **deposit token's** decimals, not the
  * vault's share decimals. The SDK reads the appropriate decimals via the
  * vault metadata and the asset's ERC-20.
@@ -626,6 +825,8 @@ async function approve(signer, options) {
  * @returns Deposit transaction hash.
  * @throws AugustValidationError on invalid wallet/target/amount or missing
  *   adapter config when `depositAsset` differs from the vault underlying.
+ * @throws AugustValidationError when `attribution.strictOrigin` is set and the
+ *   configured origin code is not registered on the SwapRouter.
  * @throws AugustSDKError when the deposit submission or on-chain call fails.
  *
  * @example
@@ -708,13 +909,23 @@ async function vaultDeposit(signer, options) {
             actualDepositAsset === '0x0000000000000000000000000000000000000000';
         const isAdapterDeposit = actualDepositAsset.toLowerCase() !== underlyingAsset.toLowerCase();
         const isMultiAssetVault = vaultVersion === 'evm-2';
-        // vaultDeposit is the NATIVE path only — it never routes through the
-        // SwapRouter. Any-token swap deposits are the explicit, opt-in job of
-        // {@link swapRouterDeposit}; keeping them out of here is what stops a
-        // natively-accepted asset from being silently swapped.
+        // vaultDeposit never swaps. Any-token swap deposits are the explicit,
+        // opt-in job of {@link swapRouterDeposit}; keeping them out of here is what
+        // stops a natively-accepted asset from being silently swapped. The only
+        // SwapRouter use is a direct deposit carrying a configured origin code.
         if (isAdapterDeposit && !isMultiAssetVault && !adapterConfig) {
             throw new core_1.AugustValidationError('INVALID_INPUT', `vaultDeposit: depositAsset ${actualDepositAsset} differs from vault underlying ${underlyingAsset} but no adapter is configured for vault ${target}. For an any-token deposit into a SwapRouter-eligible vault, use swapRouterDeposit instead.`);
         }
+        const routeChainId = tokenizedVault?.chain ?? chainId;
+        const route = await resolveDepositRoute(signer, {
+            target,
+            chainId: routeChainId,
+            actualDepositAsset,
+            underlyingAsset,
+            isMultiAssetVault,
+            isDepositWithPermit: options?.isDepositWithPermit,
+        });
+        trackOriginAttribution(route, { chainId: routeChainId, target });
         const depositTokenDecimals = await resolveDepositTokenDecimals({
             actualDepositAsset,
             underlyingAsset,
@@ -725,12 +936,7 @@ async function vaultDeposit(signer, options) {
         });
         const normalizedAmt = (0, core_1.toNormalizedBn)(amount, depositTokenDecimals);
         if (!isNativeToken) {
-            const spenderAddress = resolveSpender({
-                target,
-                isMultiAssetVault,
-                isAdapterDeposit,
-                adapterWrapperAddress: adapterConfig?.wrapperAddress,
-            });
+            const spenderAddress = route.spender;
             const depositTokenContract = (0, core_1.createContract)({
                 address: actualDepositAsset,
                 provider: signer,
@@ -746,7 +952,16 @@ async function vaultDeposit(signer, options) {
             }
         }
         // Route to appropriate deposit method
-        if (isMultiAssetVault) {
+        if (route.via === 'router') {
+            depositTx = await (0, core_1.createContract)({
+                address: route.spender,
+                provider: signer,
+                abi: abis_1.ABI_SWAP_ROUTER,
+            })
+                .connect(signer)
+                .deposit((0, core_1.resolveOriginCode)(undefined, routeChainId), normalizedAmt.raw, target, actualDepositAsset, wallet);
+        }
+        else if (isMultiAssetVault) {
             if (options?.isDepositWithPermit) {
                 // depositWithPermit flow
                 // build structure hash of permit off chain
@@ -1428,7 +1643,13 @@ async function dispatchViaSwapRouter(args) {
     }
     const isUnderlying = args.actualDepositAsset.toLowerCase() ===
         args.underlyingAsset.toLowerCase();
-    if (isUnderlying) {
+    const vaultInfo = !isUnderlying && args.isMultiAssetVault
+        ? await (0, core_1.readSwapRouterVaultInfo)(args.signer, args.chainId, args.target)
+        : undefined;
+    if (isUnderlying ||
+        (vaultInfo &&
+            (await isAcceptedDirectly(args.signer, args.target, args.actualDepositAsset, true, vaultInfo)) &&
+            (await (0, core_1.readSwapRouterTokenWhitelisted)(args.signer, args.chainId, args.actualDepositAsset)))) {
         return depositViaSwapRouter(args.signer, {
             chainId: args.chainId,
             vault: args.target,
@@ -1506,6 +1727,31 @@ async function dispatchViaSwapRouter(args) {
         wait: args.wait,
     });
 }
+/**
+ * Resolve the origin code a SwapRouter write method sends and check its
+ * registration before any approval or transaction, so an unregistered code
+ * never costs the user a reverted deposit. A code passed to the call must be
+ * registered or the call throws. An unregistered instance code falls back to
+ * the zero sentinel with the same `attribution-skipped` signal as
+ * `vaultDeposit`, or throws under `attribution.strictOrigin`. The zero
+ * sentinel is sent without a read.
+ * @internal
+ */
+async function resolveRouterOriginCode(signer, operation, chainId, vault, provided) {
+    const code = (0, core_1.resolveOriginCode)(provided, chainId);
+    if (code === core_1.ORIGIN_CODES.default ||
+        (await (0, core_1.readOriginInfo)(chainId, code, () => signer)).registered) {
+        return code;
+    }
+    if (provided !== undefined) {
+        throw new core_1.AugustValidationError('INVALID_INPUT', `${operation}: originCode is not registered on the SwapRouter for chain ${chainId}. Register it with addOrigin (check it with getOriginInfo), or pass a registered code.`, { context: { chainId, vault } });
+    }
+    if ((0, core_1.isStrictOrigin)()) {
+        throw new core_1.AugustValidationError('INVALID_INPUT', `${operation}: attribution.originCode is not registered on the SwapRouter for chain ${chainId} and attribution.strictOrigin is set. Register it with addOrigin, or unset strictOrigin to deposit without an origin code.`, { context: { chainId, vault } });
+    }
+    trackOriginAttribution({ via: 'native', spender: null, reason: 'origin-not-registered' }, { chainId, target: vault }, operation);
+    return core_1.ORIGIN_CODES.default;
+}
 /** @internal */
 function resolveSwapRouterOrThrow(chainId) {
     const router = (0, core_1.getSwapRouterAddress)(chainId);
@@ -1599,7 +1845,9 @@ async function resolveSignerEOA(signer, callerContext) {
  * @returns The transaction hash of the `swapAndDeposit` call.
  *
  * @throws {@link AugustValidationError} for unsupported chains, invalid
- * addresses, empty/oversized swap arrays.
+ * 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.
  *
  * @example
@@ -1637,20 +1885,29 @@ async function swapAndDeposit(signer, options) {
     }
     ensureSwapsValid(swaps);
     const routerAddress = resolveSwapRouterOrThrow(chainId);
-    const eoa = await resolveSignerEOA(signer, 'swapAndDeposit');
-    for (const [tokenIn, totalIn] of totalInputPerToken(swaps)) {
-        await ensureAllowance(signer, tokenIn, eoa, routerAddress, totalIn);
+    let tx;
+    try {
+        const origin = await resolveRouterOriginCode(signer, 'swapAndDeposit', chainId, vault, originCode);
+        const eoa = await resolveSignerEOA(signer, 'swapAndDeposit');
+        for (const [tokenIn, totalIn] of totalInputPerToken(swaps)) {
+            await ensureAllowance(signer, tokenIn, eoa, routerAddress, totalIn);
+        }
+        const routerContract = (0, core_1.createContract)({
+            address: routerAddress,
+            provider: signer,
+            abi: abis_1.ABI_SWAP_ROUTER,
+        });
+        tx = (await routerContract
+            .connect(signer)
+            .swapAndDeposit(origin, vault, receiver, swaps));
+        if (wait)
+            await safeWaitForTx(tx);
+        core_1.Logger.log.info('swapAndDeposit:tx_hash', tx.hash);
+        return tx.hash;
+    }
+    catch (e) {
+        return handleSwapRouterWriteError(e, tx, signer, wait, 'swapAndDeposit', 'Swap and deposit', { chainId, vault });
     }
-    const routerContract = (0, core_1.createContract)({
-        address: routerAddress,
-        provider: signer,
-        abi: abis_1.ABI_SWAP_ROUTER,
-    });
-    const { hash } = await safeSendTx(() => routerContract
-        .connect(signer)
-        .swapAndDeposit((0, core_1.resolveOriginCode)(originCode), vault, receiver, swaps), signer, wait);
-    core_1.Logger.log.info('swapAndDeposit:tx_hash', hash);
-    return hash;
 }
 /**
  * Deposit a vault's reference asset directly through the SwapRouter — no
@@ -1662,7 +1919,11 @@ async function swapAndDeposit(signer, options) {
  * @returns The transaction hash of the `deposit` call.
  *
  * @throws {@link AugustValidationError} for unsupported chains, invalid
- * addresses, or zero amount.
+ * addresses, zero amount, or an origin code 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.
  */
 async function depositViaSwapRouter(signer, options) {
     const { chainId, vault, receiver, asset, amount, originCode, wait } = options;
@@ -1676,18 +1937,27 @@ async function depositViaSwapRouter(signer, options) {
         throw new core_1.AugustValidationError('INVALID_INPUT', 'depositViaSwapRouter: amount must be greater than zero');
     }
     const routerAddress = resolveSwapRouterOrThrow(chainId);
-    const eoa = await resolveSignerEOA(signer, 'depositViaSwapRouter');
-    await ensureAllowance(signer, asset, eoa, routerAddress, amount);
-    const routerContract = (0, core_1.createContract)({
-        address: routerAddress,
-        provider: signer,
-        abi: abis_1.ABI_SWAP_ROUTER,
-    });
-    const { hash } = await safeSendTx(() => routerContract
-        .connect(signer)
-        .deposit((0, core_1.resolveOriginCode)(originCode), amount, vault, asset, receiver), signer, wait);
-    core_1.Logger.log.info('depositViaSwapRouter:tx_hash', hash);
-    return hash;
+    let tx;
+    try {
+        const origin = await resolveRouterOriginCode(signer, 'depositViaSwapRouter', chainId, vault, originCode);
+        const eoa = await resolveSignerEOA(signer, 'depositViaSwapRouter');
+        await ensureAllowance(signer, asset, eoa, routerAddress, amount);
+        const routerContract = (0, core_1.createContract)({
+            address: routerAddress,
+            provider: signer,
+            abi: abis_1.ABI_SWAP_ROUTER,
+        });
+        tx = (await routerContract
+            .connect(signer)
+            .deposit(origin, amount, vault, asset, receiver));
+        if (wait)
+            await safeWaitForTx(tx);
+        core_1.Logger.log.info('depositViaSwapRouter:tx_hash', tx.hash);
+        return tx.hash;
+    }
+    catch (e) {
+        return handleSwapRouterWriteError(e, tx, signer, wait, 'depositViaSwapRouter', 'SwapRouter deposit', { chainId, vault });
+    }
 }
 /**
  * Deposit native ETH (or chain-native equivalent) into a vault via the
@@ -1710,7 +1980,11 @@ async function depositViaSwapRouter(signer, options) {
  * @returns The transaction hash of the `depositNativeToken` call.
  *
  * @throws {@link AugustValidationError} for unsupported chains, invalid
- * addresses, or zero amount.
+ * addresses, zero amount, or an origin code 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.
  */
 async function depositNativeViaSwapRouter(signer, options) {
     const { chainId, vault, receiver, amount, originCode, wait } = options;
@@ -1723,18 +1997,27 @@ async function depositNativeViaSwapRouter(signer, options) {
         throw new core_1.AugustValidationError('INVALID_INPUT', 'depositNativeViaSwapRouter: amount must be greater than zero');
     }
     const routerAddress = resolveSwapRouterOrThrow(chainId);
-    const routerContract = (0, core_1.createContract)({
-        address: routerAddress,
-        provider: signer,
-        abi: abis_1.ABI_SWAP_ROUTER,
-    });
-    const { hash } = await safeSendTx(() => routerContract
-        .connect(signer)
-        .depositNativeToken((0, core_1.resolveOriginCode)(originCode), vault, receiver, {
-        value: amount,
-    }), signer, wait);
-    core_1.Logger.log.info('depositNativeViaSwapRouter:tx_hash', hash);
-    return hash;
+    let tx;
+    try {
+        const origin = await resolveRouterOriginCode(signer, 'depositNativeViaSwapRouter', chainId, vault, originCode);
+        const routerContract = (0, core_1.createContract)({
+            address: routerAddress,
+            provider: signer,
+            abi: abis_1.ABI_SWAP_ROUTER,
+        });
+        tx = (await routerContract
+            .connect(signer)
+            .depositNativeToken(origin, vault, receiver, {
+            value: amount,
+        }));
+        if (wait)
+            await safeWaitForTx(tx);
+        core_1.Logger.log.info('depositNativeViaSwapRouter:tx_hash', tx.hash);
+        return tx.hash;
+    }
+    catch (e) {
+        return handleSwapRouterWriteError(e, tx, signer, wait, 'depositNativeViaSwapRouter', 'SwapRouter native deposit', { chainId, vault });
+    }
 }
 /**
  * Whether a vault can take a native-ETH (chain-native token) SwapRouter
@@ -1810,21 +2093,22 @@ async function isNativeSwapRouterDepositSupported(chainId, vault, options) {
 }
 /**
  * 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}.
+ * correct router path from the deposit asset.
  *
- * 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
+ * {@link vaultDeposit} never swaps; this function always routes through the
+ * SwapRouter, because the caller asked it to. Keeping swaps opt-in 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 regression that implicit, allowlist-driven routing inside `vaultDeposit`
+ * caused before it was removed. 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
+ *  - equals the reference asset, or is an asset a Tokenized Vault V2 accepts
+ *    as-is that the router also whitelists (e.g. USDT into Sentora USD) →
+ *    direct router deposit, no swap and no swap fee
  *    ({@link depositViaSwapRouter});
  *  - the zero address → native-token deposit ({@link depositNativeViaSwapRouter}),
  *    valid only when the reference asset is the chain's wrapped-native token —
@@ -1835,23 +2119,36 @@ async function isNativeSwapRouterDepositSupported(chainId, vault, options) {
  *    the chain's whitelisted aggregator, fail-closed on router/selector drift)
  *    bundled into {@link swapAndDeposit}.
  *
- * An `originCode` is forwarded verbatim to whichever of those three entry points
- * runs, so a partner's origin fee accrues on every path. Omitting it sends the
- * all-zero sentinel, which the router reads as "no origin fee".
+ * The origin code — the per-call `originCode`, else the SDK instance's
+ * `attribution.originCode` on Ethereum mainnet, else the all-zero sentinel
+ * ("no origin fee") — is forwarded to whichever of those three entry points
+ * runs, so a partner's origin fee accrues on every path.
  *
  * 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.
+ * decimals, for a Tokenized Vault V2 non-reference asset the router's
+ * `vaultInfo` and `whitelistedTokens` and the vault's assets whitelist, the
+ * origin code's registration, 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.
+ *   amount, a native deposit into a non-wrapped-native vault, drift between
+ *   the aggregator quote and the on-chain router whitelist, or an origin code
+ *   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 —
+ *   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.
  * @example
  * ```ts
  * // USDT deposited into a USDC-reference vault → swapped to USDC en route.
@@ -1865,6 +2162,15 @@ async function isNativeSwapRouterDepositSupported(chainId, vault, options) {
  * ```
  */
 async function swapRouterDeposit(signer, options) {
+    try {
+        return await swapRouterDepositCore(signer, options);
+    }
+    catch (e) {
+        return handleSwapRouterWriteError(e, undefined, signer, options.wait, 'swapRouterDeposit', 'Swap router deposit', { chainId: options.chainId, vault: options.vault });
+    }
+}
+/** @internal */
+async function swapRouterDepositCore(signer, options) {
     const { chainId, vault, depositAsset, amount, receiver, slippageBps, originCode, wait, } = options;
     if (!(0, core_1.checkAddress)(vault, console, 'contract')) {
         throw new core_1.AugustValidationError('INVALID_ADDRESS', `swapRouterDeposit: invalid vault address "${vault}"`);
@@ -1941,6 +2247,7 @@ async function swapRouterDeposit(signer, options) {
         actualDepositAsset: depositAsset,
         underlyingAsset,
         isNativeToken,
+        isMultiAssetVault,
         depositTokenDecimals,
         normalizedAmt,
         slippageBps,