@augustdigital/sdk 8.6.1 → 8.7.0

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

@@ -18,6 +18,7 @@ exports.rwaRedeemAsset = rwaRedeemAsset;
 exports.swapAndDeposit = swapAndDeposit;
 exports.depositViaSwapRouter = depositViaSwapRouter;
 exports.depositNativeViaSwapRouter = depositNativeViaSwapRouter;
+exports.swapRouterDeposit = swapRouterDeposit;
 const ethers_1 = require("ethers");
 const abis_1 = require("../../abis");
 const core_1 = require("../../core");
@@ -64,8 +65,6 @@ async function resolveDepositTokenDecimals(args) {
 }
 /** @internal */
 function resolveSpender(args) {
-    if (args.swapRouterAddress)
-        return args.swapRouterAddress;
     if (args.isMultiAssetVault)
         return args.target;
     if (args.isAdapterDeposit && args.adapterWrapperAddress)
@@ -245,16 +244,11 @@ async function approveCore(signer, options) {
         if (isNativeToken)
             return { kind: 'native' };
         const isAdapterDeposit = actualDepositAsset.toLowerCase() !== underlyingAsset.toLowerCase();
-        const resolvedChainId = options.chainId ?? tokenizedVault?.chain;
-        const swapRouterAddress = resolvedChainId !== undefined && (0, core_1.vaultUsesSwapRouter)(target)
-            ? (0, core_1.getSwapRouterAddress)(resolvedChainId)
-            : undefined;
         const spenderAddress = resolveSpender({
             target,
             isMultiAssetVault,
             isAdapterDeposit,
             adapterWrapperAddress: adapterConfig?.wrapperAddress,
-            swapRouterAddress,
         });
         const depositTokenDecimals = await resolveDepositTokenDecimals({
             actualDepositAsset,
@@ -470,26 +464,12 @@ async function vaultDeposit(signer, options) {
             actualDepositAsset === '0x0000000000000000000000000000000000000000';
         const isAdapterDeposit = actualDepositAsset.toLowerCase() !== underlyingAsset.toLowerCase();
         const isMultiAssetVault = vaultVersion === 'evm-2';
-        const resolvedChainId = chainId ?? tokenizedVault?.chain;
-        const wantsSwapRouter = (0, core_1.vaultUsesSwapRouter)(target);
-        const swapRouterAddress = wantsSwapRouter && resolvedChainId !== undefined
-            ? (0, core_1.getSwapRouterAddress)(resolvedChainId)
-            : undefined;
-        // Legacy adapter uses minAmountOut: 0 (MEV-vulnerable); fall-through is unsafe.
-        if (wantsSwapRouter && !swapRouterAddress) {
-            throw new core_1.AugustValidationError('INVALID_CHAIN', resolvedChainId === undefined
-                ? `vaultDeposit: vault ${target} requires SwapRouter routing but chainId could not be resolved — pass options.chainId or ensure tokenized-vault metadata is loaded`
-                : `vaultDeposit: vault ${target} is registered on SwapRouter but no SwapRouter is deployed for chainId ${resolvedChainId}`, { context: { vault: target, chainId: resolvedChainId } });
-        }
-        // SwapRouter has no permit variant; throw rather than silently drop the signature.
-        if (wantsSwapRouter && options?.isDepositWithPermit) {
-            throw new core_1.AugustValidationError('INVALID_INPUT', `vaultDeposit: isDepositWithPermit is not supported on SwapRouter-routed vaults (${target}). Call vaultDeposit without isDepositWithPermit, or use the legacy vault.deposit path directly.`, { context: { vault: target } });
-        }
-        if (isAdapterDeposit &&
-            !isMultiAssetVault &&
-            !adapterConfig &&
-            !swapRouterAddress) {
-            throw new core_1.AugustValidationError('INVALID_INPUT', `vaultDeposit: depositAsset ${actualDepositAsset} differs from vault underlying ${underlyingAsset} but no adapter is configured for vault ${target}`);
+        // 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.
+        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 depositTokenDecimals = await resolveDepositTokenDecimals({
             actualDepositAsset,
@@ -507,23 +487,6 @@ async function vaultDeposit(signer, options) {
             },
         });
         const normalizedAmt = (0, core_1.toNormalizedBn)(amount, depositTokenDecimals);
-        if (swapRouterAddress && resolvedChainId !== undefined) {
-            return dispatchViaSwapRouter({
-                signer,
-                routerAddress: swapRouterAddress,
-                chainId: resolvedChainId,
-                target,
-                wallet,
-                receiver: options.receiver,
-                actualDepositAsset,
-                underlyingAsset,
-                isNativeToken,
-                depositTokenDecimals,
-                normalizedAmt,
-                slippageBps: options.slippageBps,
-                wait,
-            });
-        }
         if (!isNativeToken) {
             const spenderAddress = resolveSpender({
                 target,
@@ -1355,4 +1318,146 @@ async function depositNativeViaSwapRouter(signer, options) {
     core_1.Logger.log.info('depositNativeViaSwapRouter:tx_hash', hash);
     return hash;
 }
+/**
+ * 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,
+ * });
+ * ```
+ */
+async function swapRouterDeposit(signer, options) {
+    const { chainId, vault, depositAsset, amount, receiver, slippageBps, wait } = options;
+    if (!(0, core_1.checkAddress)(vault, console, 'contract')) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `swapRouterDeposit: invalid vault address "${vault}"`);
+    }
+    if (!(0, core_1.checkAddress)(depositAsset, console, 'contract')) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `swapRouterDeposit: invalid depositAsset address "${depositAsset}"`);
+    }
+    if (amount === undefined || amount === null) {
+        throw new core_1.AugustValidationError('INVALID_INPUT', 'swapRouterDeposit: amount is required');
+    }
+    validateAmountPrecision(amount);
+    // Explicit opt-in: resolve the router straight from chainId rather than
+    // consulting VAULTS_USING_SWAP_ROUTER, so this path never depends on the
+    // implicit allowlist that could route a native-deposit vault through a swap.
+    const routerAddress = resolveSwapRouterOrThrow(chainId);
+    const eoa = await resolveSignerEOA(signer, 'swapRouterDeposit');
+    // Reference asset + decimals from the vault on-chain. Mirrors vaultDeposit's
+    // metadata resolution so the deposit-token decimals (and therefore the raw
+    // amount) match exactly; kept separate to leave the vaultDeposit money path
+    // untouched.
+    const tokenizedVault = (await (0, core_1.fetchTokenizedVault)(vault))?.[0];
+    const isMultiAssetVault = (0, core_1.getVaultVersionV2)(tokenizedVault) === 'evm-2';
+    let underlyingAsset;
+    let vaultDecimals;
+    if (isMultiAssetVault) {
+        const poolContract = (0, core_1.createContract)({
+            address: vault,
+            provider: signer,
+            abi: abis_1.ABI_TOKENIZED_VAULT_V2,
+        });
+        const [asset, receiptTokenAddr] = await Promise.all([
+            poolContract.asset(),
+            poolContract.lpTokenAddress(),
+        ]);
+        underlyingAsset = asset;
+        const receiptContract = (0, core_1.createContract)({
+            address: receiptTokenAddr,
+            provider: signer,
+            abi: abis_1.ABI_ERC20,
+        });
+        vaultDecimals = Number(await receiptContract.decimals());
+    }
+    else {
+        const poolContract = (0, core_1.createContract)({
+            address: vault,
+            provider: signer,
+            abi: abis_1.ABI_LENDING_POOLS,
+        });
+        const [asset, rawDecimals] = await Promise.all([
+            poolContract.asset(),
+            poolContract.decimals(),
+        ]);
+        underlyingAsset = asset;
+        vaultDecimals = Number(rawDecimals);
+    }
+    const isNativeToken = depositAsset === ethers_1.ZeroAddress ||
+        depositAsset === '0x0000000000000000000000000000000000000000';
+    const depositTokenDecimals = await resolveDepositTokenDecimals({
+        actualDepositAsset: depositAsset,
+        underlyingAsset,
+        isNativeToken,
+        isMultiAssetVault,
+        vaultDecimals,
+        readErc20Decimals: async (addr) => {
+            const erc20 = (0, core_1.createContract)({
+                address: addr,
+                provider: signer,
+                abi: abis_1.ABI_ERC20,
+            });
+            return Number(await erc20.decimals());
+        },
+    });
+    const normalizedAmt = (0, core_1.toNormalizedBn)(amount, depositTokenDecimals);
+    if (BigInt(normalizedAmt.raw) === 0n) {
+        throw new core_1.AugustValidationError('INVALID_INPUT', 'swapRouterDeposit: amount must be greater than zero');
+    }
+    return dispatchViaSwapRouter({
+        signer,
+        routerAddress,
+        chainId,
+        target: vault,
+        wallet: eoa,
+        receiver,
+        actualDepositAsset: depositAsset,
+        underlyingAsset,
+        isNativeToken,
+        depositTokenDecimals,
+        normalizedAmt,
+        slippageBps,
+        wait,
+    });
+}
 //# sourceMappingURL=write.actions.js.map