@augustdigital/sdk 8.0.0 → 8.2.0

package/lib/abis/index.d.ts

@@ -26,3 +26,4 @@ export * from './MultiAssetNativeDepositWrapper';
 export * from './TokenizedVaultV2SenderAllocationWhitelist';
 export * from './RwaRedeemSubaccount';
 export * from './OFT';
+export * from './SwapRouter';

package/lib/abis/index.js

@@ -42,4 +42,5 @@ __exportStar(require("./MultiAssetNativeDepositWrapper"), exports);
 __exportStar(require("./TokenizedVaultV2SenderAllocationWhitelist"), exports);
 __exportStar(require("./RwaRedeemSubaccount"), exports);
 __exportStar(require("./OFT"), exports);
+__exportStar(require("./SwapRouter"), exports);
 //# sourceMappingURL=index.js.map

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

@@ -1,4 +1,5 @@
 import { IContractWriteOptions, INativeDepositOptions, ApproveResult } from '../../modules/vaults/write.actions';
+import type { ISwapAndDepositOptions, ISwapRouterDirectDepositOptions, ISwapRouterNativeDepositOptions } from '../../types';
 import { IPreviewDepositOptions, IPreviewRedeemOptions, IAllowanceOptions, IBalanceOfOptions, IMaxDepositOptions } from '../../modules/vaults/read.actions';
 import { CompatibleSigner } from '../../core/helpers/signer';
 import { IAddress } from '../../types';
@@ -15,6 +16,9 @@ declare class EVMAdapter {
     vaultDeposit(options: IContractWriteOptions): Promise<string>;
     vaultRequestRedeem(options: IContractWriteOptions): Promise<string>;
     depositNative(options: INativeDepositOptions): Promise<string>;
+    swapAndDeposit(options: ISwapAndDepositOptions): Promise<string>;
+    depositViaSwapRouter(options: ISwapRouterDirectDepositOptions): Promise<string>;
+    depositNativeViaSwapRouter(options: ISwapRouterNativeDepositOptions): Promise<string>;
     vaultRedeem(options: IContractWriteOptions & {
         year: string;
         month: string;

package/lib/adapters/evm/index.js

@@ -60,6 +60,18 @@ class EVMAdapter {
         const signer = await this.getSigner();
         return (0, write_actions_1.depositNative)(signer, options);
     }
+    async swapAndDeposit(options) {
+        const signer = await this.getSigner();
+        return (0, write_actions_1.swapAndDeposit)(signer, options);
+    }
+    async depositViaSwapRouter(options) {
+        const signer = await this.getSigner();
+        return (0, write_actions_1.depositViaSwapRouter)(signer, options);
+    }
+    async depositNativeViaSwapRouter(options) {
+        const signer = await this.getSigner();
+        return (0, write_actions_1.depositNativeViaSwapRouter)(signer, options);
+    }
     async vaultRedeem(options) {
         const signer = await this.getSigner();
         return (0, write_actions_1.vaultRedeem)(signer, options);

package/lib/core/analytics/method-taxonomy.js

@@ -65,6 +65,9 @@ exports.METHOD_CATEGORIES = {
     maxDeposit: 'read.vault',
     vaultDeposit: 'write.deposit',
     depositNative: 'write.deposit',
+    swapAndDeposit: 'write.deposit',
+    depositViaSwapRouter: 'write.deposit',
+    depositNativeViaSwapRouter: 'write.deposit',
     vaultRedeem: 'write.redeem',
     vaultRequestRedeem: 'write.redeem',
     rwaRedeemAsset: 'write.redeem',

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

@@ -1 +1 @@
-export declare const SDK_VERSION = "8.0.0";
+export declare const SDK_VERSION = "8.2.0";

package/lib/core/analytics/version.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SDK_VERSION = void 0;
-exports.SDK_VERSION = '8.0.0';
+exports.SDK_VERSION = '8.2.0';
 //# sourceMappingURL=version.js.map

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

@@ -0,0 +1,8 @@
+import { IAddress } from '../../types';
+export declare const SWAP_ROUTER_ADDRESSES: Readonly<Record<number, IAddress>>;
+export declare const VAULTS_USING_SWAP_ROUTER: ReadonlySet<string>;
+export declare const ORIGIN_CODES: {
+    readonly default: `0x${string}`;
+};
+export declare const SWAP_ROUTER_MAX_SWAPS = 9;
+export declare const SWAP_ROUTER_WRAPPED_NATIVE: Readonly<Record<number, IAddress>>;

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SWAP_ROUTER_WRAPPED_NATIVE = exports.SWAP_ROUTER_MAX_SWAPS = exports.ORIGIN_CODES = exports.VAULTS_USING_SWAP_ROUTER = exports.SWAP_ROUTER_ADDRESSES = void 0;
+exports.SWAP_ROUTER_ADDRESSES = {
+    1: '0xAC771209FF2b71EECfF6E85a9AD01db8Ff2618B0',
+};
+exports.VAULTS_USING_SWAP_ROUTER = new Set([
+    '0xe9b725010a9e419412ed67d0fa5f3a5f40159d32',
+    '0x74ad2f789ed583dbd141bbdafc673fe1f033718b',
+]);
+exports.ORIGIN_CODES = {
+    default: '0x0000000000000000000000000000000000000000000000000000000000000000',
+};
+exports.SWAP_ROUTER_MAX_SWAPS = 9;
+exports.SWAP_ROUTER_WRAPPED_NATIVE = {
+    1: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+};
+//# sourceMappingURL=swap-router.js.map

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

@@ -0,0 +1,4 @@
+import { IAddress } from '../../types';
+export declare function getSwapRouterAddress(chainId: number): IAddress | undefined;
+export declare function vaultUsesSwapRouter(vaultAddress: IAddress): boolean;
+export declare function resolveOriginCode(provided?: `0x${string}`): `0x${string}`;

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSwapRouterAddress = getSwapRouterAddress;
+exports.vaultUsesSwapRouter = vaultUsesSwapRouter;
+exports.resolveOriginCode = resolveOriginCode;
+const swap_router_1 = require("../constants/swap-router");
+const errors_1 = require("../errors");
+function getSwapRouterAddress(chainId) {
+    return swap_router_1.SWAP_ROUTER_ADDRESSES[chainId];
+}
+function vaultUsesSwapRouter(vaultAddress) {
+    return swap_router_1.VAULTS_USING_SWAP_ROUTER.has(vaultAddress.toLowerCase());
+}
+function resolveOriginCode(provided) {
+    if (provided === undefined)
+        return swap_router_1.ORIGIN_CODES.default;
+    if (!/^0x[0-9a-fA-F]{64}$/.test(provided)) {
+        throw new errors_1.AugustValidationError('INVALID_INPUT', `resolveOriginCode: originCode must be a 32-byte hex string (66 chars incl. 0x), got "${provided}" (${provided.length} chars)`, { context: { provided, expectedLength: 66 } });
+    }
+    return provided;
+}
+//# sourceMappingURL=swap-router.js.map

package/lib/core/index.d.ts

@@ -9,8 +9,10 @@ export * from './constants/adapters';
 export * from './constants/core';
 export * from './constants/web3';
 export * from './constants/vaults';
+export * from './constants/swap-router';
 export * from './helpers/web3';
 export * from './helpers/vaults';
 export * from './helpers/core';
 export * from './helpers/adapters';
 export * from './helpers/signer';
+export * from './helpers/swap-router';

package/lib/core/index.js

@@ -25,9 +25,11 @@ __exportStar(require("./constants/adapters"), exports);
 __exportStar(require("./constants/core"), exports);
 __exportStar(require("./constants/web3"), exports);
 __exportStar(require("./constants/vaults"), exports);
+__exportStar(require("./constants/swap-router"), exports);
 __exportStar(require("./helpers/web3"), exports);
 __exportStar(require("./helpers/vaults"), exports);
 __exportStar(require("./helpers/core"), exports);
 __exportStar(require("./helpers/adapters"), exports);
 __exportStar(require("./helpers/signer"), exports);
+__exportStar(require("./helpers/swap-router"), exports);
 //# sourceMappingURL=index.js.map

package/lib/index.d.ts

@@ -3,6 +3,7 @@ export * from './types';
 export * from './core';
 export * from './abis';
 export * from './services/debank';
+export * from './services/swap-quotes';
 export * from './modules/vaults';
 export * from './modules/sub-accounts';
 export * from './evm';

package/lib/index.js

@@ -20,6 +20,7 @@ __exportStar(require("./types"), exports);
 __exportStar(require("./core"), exports);
 __exportStar(require("./abis"), exports);
 __exportStar(require("./services/debank"), exports);
+__exportStar(require("./services/swap-quotes"), exports);
 __exportStar(require("./modules/vaults"), exports);
 __exportStar(require("./modules/sub-accounts"), exports);
 __exportStar(require("./evm"), exports);

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

@@ -1,5 +1,6 @@
 import { Signer, Wallet, TransactionResponse } from 'ethers';
 import { IAddress } from '../../types';
+import type { ISwapAndDepositOptions, ISwapRouterDirectDepositOptions, ISwapRouterNativeDepositOptions } from '../../types';
 export type IContractWriteOptions = {
     target: IAddress;
     wallet: IAddress;
@@ -10,6 +11,8 @@ export type IContractWriteOptions = {
     poolName?: string;
     isInstantRedeem?: boolean;
     isDepositWithPermit?: boolean;
+    receiver?: IAddress;
+    slippageBps?: number;
 };
 export type INativeDepositOptions = {
     wrapperAddress: IAddress;
@@ -31,6 +34,7 @@ export declare function resolveSpender(args: {
     isMultiAssetVault: boolean;
     isAdapterDeposit: boolean;
     adapterWrapperAddress?: IAddress;
+    swapRouterAddress?: IAddress;
 }): IAddress;
 export declare function validateAmountPrecision(amount: string | bigint | number): void;
 export declare function isNonceParsing(error: unknown): boolean;
@@ -71,3 +75,6 @@ export type IRwaRedeemOptions = {
     wait?: boolean;
 };
 export declare function rwaRedeemAsset(signer: Signer | Wallet, options: IRwaRedeemOptions): Promise<string>;
+export declare function swapAndDeposit(signer: Signer | Wallet, options: ISwapAndDepositOptions): Promise<string>;
+export declare function depositViaSwapRouter(signer: Signer | Wallet, options: ISwapRouterDirectDepositOptions): Promise<string>;
+export declare function depositNativeViaSwapRouter(signer: Signer | Wallet, options: ISwapRouterNativeDepositOptions): Promise<string>;

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

@@ -15,9 +15,13 @@ exports.vaultRequestRedeem = vaultRequestRedeem;
 exports.vaultRedeem = vaultRedeem;
 exports.depositNative = depositNative;
 exports.rwaRedeemAsset = rwaRedeemAsset;
+exports.swapAndDeposit = swapAndDeposit;
+exports.depositViaSwapRouter = depositViaSwapRouter;
+exports.depositNativeViaSwapRouter = depositNativeViaSwapRouter;
 const ethers_1 = require("ethers");
 const abis_1 = require("../../abis");
 const core_1 = require("../../core");
+const swap_quotes_1 = require("../../services/swap-quotes");
 const adapter_helpers_1 = require("./adapter.helpers");
 const utils_1 = require("./utils");
 function safeBigInt(value, context = 'safeBigInt') {
@@ -50,6 +54,8 @@ async function resolveDepositTokenDecimals(args) {
     return readErc20Decimals(actualDepositAsset);
 }
 function resolveSpender(args) {
+    if (args.swapRouterAddress)
+        return args.swapRouterAddress;
     if (args.isMultiAssetVault)
         return args.target;
     if (args.isAdapterDeposit && args.adapterWrapperAddress)
@@ -202,11 +208,16 @@ 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,
@@ -318,7 +329,23 @@ async function vaultDeposit(signer, options) {
             actualDepositAsset === '0x0000000000000000000000000000000000000000';
         const isAdapterDeposit = actualDepositAsset.toLowerCase() !== underlyingAsset.toLowerCase();
         const isMultiAssetVault = vaultVersion === 'evm-2';
-        if (isAdapterDeposit && !isMultiAssetVault && !adapterConfig) {
+        const resolvedChainId = chainId ?? tokenizedVault?.chain;
+        const wantsSwapRouter = (0, core_1.vaultUsesSwapRouter)(target);
+        const swapRouterAddress = wantsSwapRouter && resolvedChainId !== undefined
+            ? (0, core_1.getSwapRouterAddress)(resolvedChainId)
+            : undefined;
+        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 } });
+        }
+        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}`);
         }
         const depositTokenDecimals = await resolveDepositTokenDecimals({
@@ -337,6 +364,23 @@ 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,
@@ -666,4 +710,219 @@ async function rwaRedeemAsset(signer, options) {
         throw new core_1.AugustSDKError('UNKNOWN', `RWA redeem failed: ${e instanceof Error ? e.message : 'Unknown error'}`, { cause: e, context: { target, asset, amount, minOut } });
     }
 }
+async function dispatchViaSwapRouter(args) {
+    const amountRaw = BigInt(args.normalizedAmt.raw);
+    const sharesReceiver = args.receiver ?? args.wallet;
+    if (args.isNativeToken) {
+        const wrappedNative = core_1.SWAP_ROUTER_WRAPPED_NATIVE[args.chainId];
+        if (!wrappedNative ||
+            args.underlyingAsset.toLowerCase() !== wrappedNative.toLowerCase()) {
+            throw new core_1.AugustValidationError('INVALID_INPUT', `vaultDeposit (SwapRouter): native deposit is only supported when the vault's reference asset is the chain's wrapped-native token. Vault ${args.target} underlying ${args.underlyingAsset} is not. Wrap to ${wrappedNative ?? 'WETH'} first and call again with depositAsset = the wrapped token.`, {
+                context: {
+                    vault: args.target,
+                    underlying: args.underlyingAsset,
+                    chainId: args.chainId,
+                    wrappedNative,
+                },
+            });
+        }
+        return depositNativeViaSwapRouter(args.signer, {
+            chainId: args.chainId,
+            vault: args.target,
+            receiver: sharesReceiver,
+            amount: amountRaw,
+            wait: args.wait,
+        });
+    }
+    const isUnderlying = args.actualDepositAsset.toLowerCase() ===
+        args.underlyingAsset.toLowerCase();
+    if (isUnderlying) {
+        return depositViaSwapRouter(args.signer, {
+            chainId: args.chainId,
+            vault: args.target,
+            receiver: sharesReceiver,
+            asset: args.actualDepositAsset,
+            amount: amountRaw,
+            wait: args.wait,
+        });
+    }
+    const underlyingErc20 = (0, core_1.createContract)({
+        address: args.underlyingAsset,
+        provider: args.signer,
+        abi: abis_1.ABI_ERC20,
+    });
+    const underlyingDecimals = Number(await underlyingErc20.decimals());
+    const quote = await (0, swap_quotes_1.fetchSwapQuote)({
+        chainId: args.chainId,
+        srcToken: args.actualDepositAsset,
+        srcDecimals: args.depositTokenDecimals,
+        destToken: args.underlyingAsset,
+        destDecimals: underlyingDecimals,
+        amount: amountRaw,
+        receiver: args.routerAddress,
+        slippageBps: args.slippageBps,
+    });
+    return swapAndDeposit(args.signer, {
+        chainId: args.chainId,
+        vault: args.target,
+        receiver: sharesReceiver,
+        swaps: [
+            {
+                tokenIn: args.actualDepositAsset,
+                tokenOut: args.underlyingAsset,
+                amountIn: amountRaw,
+                minAmountOut: quote.minAmountOut,
+                router: quote.router,
+                payload: quote.payload,
+            },
+        ],
+        wait: args.wait,
+    });
+}
+function resolveSwapRouterOrThrow(chainId) {
+    const router = (0, core_1.getSwapRouterAddress)(chainId);
+    if (!router) {
+        throw new core_1.AugustValidationError('INVALID_CHAIN', `SwapRouter: no deployment registered for chainId ${chainId}`, { context: { chainId } });
+    }
+    return router;
+}
+async function ensureAllowance(signer, token, owner, spender, amount) {
+    const tokenContract = (0, core_1.createContract)({
+        address: token,
+        provider: signer,
+        abi: abis_1.ABI_ERC20,
+    });
+    const current = safeBigInt(await tokenContract.allowance(owner, spender), 'swapRouter:allowance');
+    if (current >= amount)
+        return;
+    const { hash } = await safeSendTx(() => tokenContract.connect(signer).approve(spender, amount), signer, true);
+    core_1.Logger.log.info('swapRouter:approve:tx_hash', hash);
+}
+function ensureSwapsValid(swaps) {
+    if (swaps.length === 0) {
+        throw new core_1.AugustValidationError('INVALID_INPUT', 'swapAndDeposit: at least one swap leg is required');
+    }
+    if (swaps.length > core_1.SWAP_ROUTER_MAX_SWAPS) {
+        throw new core_1.AugustValidationError('INVALID_INPUT', `swapAndDeposit: too many swaps (${swaps.length} > ${core_1.SWAP_ROUTER_MAX_SWAPS})`, { context: { count: swaps.length, max: core_1.SWAP_ROUTER_MAX_SWAPS } });
+    }
+    for (let i = 0; i < swaps.length; i += 1) {
+        validateSwapParams(swaps[i], i);
+    }
+}
+function validateSwapParams(swap, index) {
+    const where = `swapAndDeposit: swaps[${index}]`;
+    if (!(0, core_1.checkAddress)(swap.tokenIn, console, 'contract')) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `${where}.tokenIn is not a valid address`);
+    }
+    if (!(0, core_1.checkAddress)(swap.tokenOut, console, 'contract')) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `${where}.tokenOut is not a valid address`);
+    }
+    if (!(0, core_1.checkAddress)(swap.router, console, 'contract')) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `${where}.router is not a valid address`);
+    }
+    if (swap.tokenIn.toLowerCase() === swap.tokenOut.toLowerCase()) {
+        throw new core_1.AugustValidationError('INVALID_INPUT', `${where}: tokenIn and tokenOut are identical — no swap needed`);
+    }
+    if (swap.amountIn <= 0n) {
+        throw new core_1.AugustValidationError('INVALID_INPUT', `${where}.amountIn must be greater than zero`);
+    }
+    if (swap.minAmountOut <= 0n) {
+        throw new core_1.AugustValidationError('INVALID_INPUT', `${where}.minAmountOut must be greater than zero — slippage protection cannot be disabled`);
+    }
+    if (!/^0x[0-9a-fA-F]+$/.test(swap.payload) || swap.payload.length < 10) {
+        throw new core_1.AugustValidationError('INVALID_INPUT', `${where}.payload must be ABI-encoded calldata (got "${swap.payload.slice(0, 12)}…")`);
+    }
+}
+function totalInputPerToken(swaps) {
+    const totals = new Map();
+    for (const swap of swaps) {
+        const key = swap.tokenIn.toLowerCase();
+        totals.set(key, (totals.get(key) ?? 0n) + swap.amountIn);
+    }
+    return totals;
+}
+async function resolveSignerEOA(signer, callerContext) {
+    const getAddress = signer.getAddress;
+    if (typeof getAddress !== 'function') {
+        throw new core_1.AugustValidationError('INVALID_INPUT', `${callerContext}: signer must implement getAddress(); got ${typeof getAddress}`);
+    }
+    const eoa = await getAddress.call(signer);
+    if (!eoa || !(0, core_1.checkAddress)(eoa, console, 'wallet')) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `${callerContext}: signer.getAddress() returned an invalid address: ${String(eoa)}`);
+    }
+    return eoa;
+}
+async function swapAndDeposit(signer, options) {
+    const { chainId, vault, receiver, swaps, originCode, wait } = options;
+    const goodVault = (0, core_1.checkAddress)(vault, console, 'contract');
+    const goodReceiver = (0, core_1.checkAddress)(receiver, console, 'wallet');
+    if (!goodVault || !goodReceiver) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', `swapAndDeposit: invalid ${!goodVault ? 'vault' : 'receiver'} address`);
+    }
+    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);
+    }
+    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;
+}
+async function depositViaSwapRouter(signer, options) {
+    const { chainId, vault, receiver, asset, amount, originCode, wait } = options;
+    const goodVault = (0, core_1.checkAddress)(vault, console, 'contract');
+    const goodReceiver = (0, core_1.checkAddress)(receiver, console, 'wallet');
+    const goodAsset = (0, core_1.checkAddress)(asset, console, 'contract');
+    if (!goodVault || !goodReceiver || !goodAsset) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', 'depositViaSwapRouter: invalid address');
+    }
+    if (amount === 0n) {
+        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;
+}
+async function depositNativeViaSwapRouter(signer, options) {
+    const { chainId, vault, receiver, amount, originCode, wait } = options;
+    const goodVault = (0, core_1.checkAddress)(vault, console, 'contract');
+    const goodReceiver = (0, core_1.checkAddress)(receiver, console, 'wallet');
+    if (!goodVault || !goodReceiver) {
+        throw new core_1.AugustValidationError('INVALID_ADDRESS', 'depositNativeViaSwapRouter: invalid address');
+    }
+    if (amount === 0n) {
+        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;
+}
 //# sourceMappingURL=write.actions.js.map

package/lib/services/swap-quotes/index.d.ts

@@ -0,0 +1,25 @@
+import type { IAddress } from '../../types';
+export type ISwapQuoteProvider = 'paraswap';
+export interface ISwapQuoteRequest {
+    chainId: number;
+    srcToken: IAddress;
+    srcDecimals: number;
+    destToken: IAddress;
+    destDecimals: number;
+    amount: bigint;
+    receiver: IAddress;
+    slippageBps?: number;
+    partner?: string;
+    partnerAddress?: IAddress;
+    fetchImpl?: typeof fetch;
+    signal?: AbortSignal;
+}
+export type ISwapQuoteResult = {
+    provider: 'paraswap';
+    router: IAddress;
+    payload: `0x${string}`;
+    expectedAmountOut: bigint;
+    minAmountOut: bigint;
+    fetchedAt: number;
+};
+export declare function fetchSwapQuote(request: ISwapQuoteRequest): Promise<ISwapQuoteResult>;

package/lib/services/swap-quotes/index.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchSwapQuote = fetchSwapQuote;
+const errors_1 = require("../../core/errors");
+const paraswap_1 = require("./paraswap");
+const DEFAULT_SLIPPAGE_BPS = 100;
+const BPS_DENOMINATOR = 10000n;
+async function fetchSwapQuote(request) {
+    validateRequest(request);
+    const slippageBps = request.slippageBps ?? DEFAULT_SLIPPAGE_BPS;
+    const fetchImpl = request.fetchImpl ?? globalThis.fetch;
+    const { router, payload, expectedAmountOut, fetchedAt } = await (0, paraswap_1.fetchParaswapQuote)({
+        chainId: request.chainId,
+        srcToken: request.srcToken,
+        srcDecimals: request.srcDecimals,
+        destToken: request.destToken,
+        destDecimals: request.destDecimals,
+        amount: request.amount,
+        receiver: request.receiver,
+        slippageBps,
+        partner: request.partner ?? paraswap_1.PARASWAP_DEFAULTS.partner,
+        partnerAddress: request.partnerAddress ?? paraswap_1.PARASWAP_DEFAULTS.partnerAddress,
+        fetchImpl,
+        signal: request.signal,
+    });
+    const minAmountOut = applySlippage(expectedAmountOut, slippageBps);
+    return {
+        provider: 'paraswap',
+        router,
+        payload,
+        expectedAmountOut,
+        minAmountOut,
+        fetchedAt,
+    };
+}
+function validateRequest(req) {
+    if (req.slippageBps !== undefined &&
+        (req.slippageBps < 0 || req.slippageBps >= 10000)) {
+        throw new errors_1.AugustValidationError('INVALID_INPUT', `fetchSwapQuote: slippageBps must be in [0, 10000), got ${req.slippageBps}. 10000 bps = 100% slippage and disables protection entirely; use a tighter bound.`);
+    }
+    if (req.amount === 0n) {
+        throw new errors_1.AugustValidationError('INVALID_INPUT', 'fetchSwapQuote: amount must be greater than zero');
+    }
+    if (req.srcToken.toLowerCase() === req.destToken.toLowerCase()) {
+        throw new errors_1.AugustValidationError('INVALID_INPUT', 'fetchSwapQuote: srcToken and destToken are identical — no swap needed');
+    }
+}
+function applySlippage(amount, slippageBps) {
+    return (amount * (BPS_DENOMINATOR - BigInt(slippageBps))) / BPS_DENOMINATOR;
+}
+//# sourceMappingURL=index.js.map

package/lib/services/swap-quotes/paraswap.d.ts

@@ -0,0 +1,26 @@
+import type { IAddress } from '../../types';
+export interface IParaswapQuoteInput {
+    chainId: number;
+    srcToken: IAddress;
+    srcDecimals: number;
+    destToken: IAddress;
+    destDecimals: number;
+    amount: bigint;
+    receiver: IAddress;
+    slippageBps: number;
+    partner: string;
+    partnerAddress: IAddress;
+    fetchImpl: typeof fetch;
+    signal?: AbortSignal;
+}
+export interface IParaswapQuoteOutput {
+    router: IAddress;
+    payload: `0x${string}`;
+    expectedAmountOut: bigint;
+    fetchedAt: number;
+}
+export declare function fetchParaswapQuote(input: IParaswapQuoteInput): Promise<IParaswapQuoteOutput>;
+export declare const PARASWAP_DEFAULTS: {
+    readonly partner: "august";
+    readonly partnerAddress: `0x${string}`;
+};