@augustdigital/sdk 8.0.0 → 8.3.0

package/lib/modules/vaults/fetcher.js

@@ -31,7 +31,10 @@ async function fetchVaultWithFallback(vaultAddress, fetchFn, options = {}) {
         return { success: true, data, strategy: 'extended-retry' };
     }
     catch (error) {
-        console.warn(`Vault ${vaultAddress} failed with extended retry strategy:`, error);
+        core_1.Logger.log.warn('fetchVaultWithFallback:extended_retry_failed', {
+            vault: vaultAddress,
+            error,
+        });
     }
     return {
         success: false,

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

@@ -1,5 +1,5 @@
-import { IAddress, IHistoricalTimeseriesResponse, INormalizedNumber, ISubgraphWithdrawProccessed, IVault, IVaultAllocations, IVaultAnnualizedApy, IVaultAvailableRedemption, IVaultLoan, IVaultPosition, IVaultRedemptionHistoryItem, IVaultSummary, IVaultWithdrawals, IVaultPendingRedemptions, IActiveStakingPosition, IVaultHistoricalParams, IVaultUserLifetimePnl, IVaultBorrowerHealthFactor, IVaultPnl, VaultAddress } from '../../types';
-import { IVaultBaseOptions } from './types';
+import { type IAddress, type IHistoricalTimeseriesResponse, type INormalizedNumber, type ISubgraphWithdrawProccessed, type IVault, type IVaultAllocations, type IVaultAnnualizedApy, type IVaultAvailableRedemption, type IVaultLoan, type IVaultPosition, type IVaultRedemptionHistoryItem, type IVaultSummary, type IVaultWithdrawals, type IVaultPendingRedemptions, type IActiveStakingPosition, type IVaultHistoricalParams, type IVaultUserLifetimePnl, type IVaultBorrowerHealthFactor, type IVaultPnl, type VaultAddress } from '../../types';
+import type { IVaultBaseOptions } from './types';
 export declare function getVault({ vault, loans, allocations, options, loadSubaccounts, loadSnapshots, }: {
     vault: IAddress;
     loans?: boolean;

package/lib/modules/vaults/getters.js

@@ -909,9 +909,12 @@ async function getVaultPositions({ vault, wallet, solanaWallet, stellarWallet, o
                     if (stellarWallet && (0, utils_3.isStellarAddress)(stellarWallet)) {
                         const stellarNetwork = v.stellar_vault_metadata?.network_name ?? 'mainnet';
                         const position = await StellarGetters.getStellarUserPosition(v.address, stellarWallet, stellarNetwork);
-                        if (position) {
+                        if (position && !position.decimalsFromFallback) {
                             balance = (0, core_1.toNormalizedBn)(BigInt(position.shares), position.decimals);
                         }
+                        else if (position) {
+                            core_1.Logger.log.warn('getVaultPositions', 'Stellar decimals() unresolved — refusing to scale balance with fallback decimals (showing zero)', { vault: v.address, wallet: stellarWallet });
+                        }
                         else {
                             core_1.Logger.log.warn('getVaultPositions', 'Stellar position query failed — showing zero balance', { vault: v.address, wallet: stellarWallet });
                         }

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

@@ -1,4 +1,4 @@
-import { IAddress, IContractRunner, INormalizedNumber, IPoolFunctions, ITokenizedVault, IVault } from '../../types';
+import type { IAddress, IContractRunner, INormalizedNumber, IPoolFunctions, ITokenizedVault, IVault } from '../../types';
 import { ethers } from 'ethers';
 import type { WalletClient } from 'viem';
 export declare function walletClientToSigner(walletClient: WalletClient): Promise<ethers.JsonRpcSigner>;

package/lib/modules/vaults/utils.js

@@ -427,12 +427,13 @@ async function buildFormattedVault(provider, tokenizedVault, contractCalls) {
             }
             depositAssets = [...depositAssets, ...extraAssets];
             totalSupply = contractCalls.totalSupply;
-            ((maxSupply = (0, core_1.toNormalizedBn)(1000000000000)),
+            (maxSupply =
+                (0, core_1.toNormalizedBn)(1000000000000)),
                 (receipt = {
                     symbol: tokenizedVault.receipt_token_symbol,
                     address: contractCalls.lpTokenAddress,
                     decimals: contractCalls.decimals,
-                }));
+                });
             break;
         }
         default: {

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

@@ -1,5 +1,6 @@
-import { Signer, Wallet, TransactionResponse } from 'ethers';
-import { IAddress } from '../../types';
+import { type Signer, type Wallet, type TransactionResponse } from 'ethers';
+import type { 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,
@@ -408,7 +452,9 @@ async function vaultDeposit(signer, options) {
                     userAddress: wallet,
                 });
                 depositTx = await nativeDepositConfig.contract
-                    .connect(signer)[nativeDepositConfig.functionName](...nativeDepositConfig.args, nativeDepositConfig.value ? { value: nativeDepositConfig.value } : {});
+                    .connect(signer)[nativeDepositConfig.functionName](...nativeDepositConfig.args, nativeDepositConfig.value
+                    ? { value: nativeDepositConfig.value }
+                    : {});
             }
         }
         else {
@@ -666,4 +712,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}`;
+};

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

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PARASWAP_DEFAULTS = void 0;
+exports.fetchParaswapQuote = fetchParaswapQuote;
+const errors_1 = require("../../core/errors");
+const web3_1 = require("../../core/helpers/web3");
+const PARASWAP_PRICES_URL = 'https://api.paraswap.io/prices';
+const PARASWAP_TRANSACTIONS_BASE_URL = 'https://api.paraswap.io/transactions';
+const DEFAULT_PARTNER = 'august';
+const DEFAULT_PARTNER_ADDRESS = '0xb60ee0FA5B6bA917255A03e744967E0Bda531dD0';
+const PARASWAP_VERSION = '6.2';
+const BPS_DENOMINATOR = 10000n;
+async function fetchParaswapQuote(input) {
+    const priceRoute = await getPriceRoute(input);
+    const destAmountRaw = priceRoute.destAmount;
+    if (typeof destAmountRaw !== 'string' || !/^\d+$/.test(destAmountRaw)) {
+        throw new errors_1.AugustServerError(200, `fetchSwapQuote: Paraswap /prices returned non-numeric destAmount: ${String(destAmountRaw)}`, { context: { destAmount: destAmountRaw } });
+    }
+    const expectedAmountOut = BigInt(destAmountRaw);
+    const { router, payload } = await getTransactionData(input, priceRoute);
+    return { router, payload, expectedAmountOut, fetchedAt: Date.now() };
+}
+async function getPriceRoute(input) {
+    const params = new URLSearchParams({
+        network: String(input.chainId),
+        srcToken: input.srcToken,
+        srcDecimals: String(input.srcDecimals),
+        destToken: input.destToken,
+        destDecimals: String(input.destDecimals),
+        amount: input.amount.toString(),
+        partner: input.partner,
+        partnerAddress: input.partnerAddress,
+        version: PARASWAP_VERSION,
+    });
+    const url = `${PARASWAP_PRICES_URL}?${params.toString()}`;
+    let response;
+    try {
+        response = await input.fetchImpl(url, {
+            method: 'GET',
+            headers: { 'Content-Type': 'application/json' },
+            signal: input.signal,
+        });
+    }
+    catch (cause) {
+        throw new errors_1.AugustNetworkError('fetchSwapQuote: Paraswap /prices fetch failed', { cause, context: { url } });
+    }
+    if (!response.ok) {
+        throw new errors_1.AugustServerError(response.status, `fetchSwapQuote: Paraswap /prices returned HTTP ${response.status}`, { context: { url } });
+    }
+    const body = (await response.json());
+    if (body.error) {
+        throw new errors_1.AugustServerError(response.status, `fetchSwapQuote: Paraswap /prices error: ${body.error}`, { context: { providerError: body.error } });
+    }
+    if (!body.priceRoute) {
+        throw new errors_1.AugustServerError(response.status, 'fetchSwapQuote: Paraswap /prices returned no priceRoute', { context: { body } });
+    }
+    return body.priceRoute;
+}
+async function getTransactionData(input, priceRoute) {
+    const url = `${PARASWAP_TRANSACTIONS_BASE_URL}/${input.chainId}/?ignoreChecks=true&ignoreGasEstimate=true&onlyParams=false`;
+    const expectedDestAmount = BigInt(priceRoute.destAmount);
+    const minDestAmount = (expectedDestAmount * (BPS_DENOMINATOR - BigInt(input.slippageBps))) /
+        BPS_DENOMINATOR;
+    const requestBody = {
+        userAddress: input.receiver,
+        srcToken: input.srcToken,
+        destToken: input.destToken,
+        srcDecimals: input.srcDecimals,
+        destDecimals: input.destDecimals,
+        srcAmount: input.amount.toString(),
+        destAmount: minDestAmount.toString(),
+        priceRoute,
+        partner: input.partner,
+        partnerAddress: input.partnerAddress,
+    };
+    let response;
+    try {
+        response = await input.fetchImpl(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(requestBody),
+            signal: input.signal,
+        });
+    }
+    catch (cause) {
+        throw new errors_1.AugustNetworkError('fetchSwapQuote: Paraswap /transactions fetch failed', { cause, context: { url } });
+    }
+    if (!response.ok) {
+        throw new errors_1.AugustServerError(response.status, `fetchSwapQuote: Paraswap /transactions returned HTTP ${response.status}`, { context: { url } });
+    }
+    const body = (await response.json());
+    if (body.error) {
+        throw new errors_1.AugustServerError(response.status, `fetchSwapQuote: Paraswap /transactions error: ${body.error}`, { context: { providerError: body.error } });
+    }
+    if (!body.to || !body.data) {
+        throw new errors_1.AugustServerError(response.status, 'fetchSwapQuote: Paraswap /transactions returned no to/data', { context: { body } });
+    }
+    if (!(0, web3_1.checkAddress)(body.to, console, 'contract')) {
+        throw new errors_1.AugustServerError(response.status, `fetchSwapQuote: Paraswap /transactions returned an invalid router address: ${body.to}`, { context: { to: body.to } });
+    }
+    if (!/^0x[0-9a-fA-F]+$/.test(body.data) || body.data.length % 2 !== 0) {
+        throw new errors_1.AugustServerError(response.status, `fetchSwapQuote: Paraswap /transactions returned malformed calldata (${body.data.length} chars)`, { context: { dataPrefix: body.data.slice(0, 16) } });
+    }
+    if (body.data.length < 10) {
+        throw new errors_1.AugustValidationError('INVALID_INPUT', 'fetchSwapQuote: Paraswap /transactions returned calldata shorter than a 4-byte selector');
+    }
+    return {
+        router: body.to,
+        payload: body.data,
+    };
+}
+exports.PARASWAP_DEFAULTS = {
+    partner: DEFAULT_PARTNER,
+    partnerAddress: DEFAULT_PARTNER_ADDRESS,
+};
+//# sourceMappingURL=paraswap.js.map

package/lib/types/vaults.d.ts

@@ -332,3 +332,32 @@ export interface IVaultMetadataItem {
     address: string;
 }
 export type IVaultMetadata = Record<string, IVaultMetadataItem>;
+export declare enum SwapRouterVaultType {
+    ERC4626 = 1,
+    TokenizedVaultV2 = 2
+}
+export interface ISwapParams {
+    tokenIn: IAddress;
+    tokenOut: IAddress;
+    amountIn: bigint;
+    minAmountOut: bigint;
+    router: IAddress;
+    payload: `0x${string}`;
+}
+export interface ISwapRouterBaseOptions {
+    chainId: number;
+    vault: IAddress;
+    receiver: IAddress;
+    originCode?: `0x${string}`;
+    wait?: boolean;
+}
+export interface ISwapAndDepositOptions extends ISwapRouterBaseOptions {
+    swaps: ISwapParams[];
+}
+export interface ISwapRouterDirectDepositOptions extends ISwapRouterBaseOptions {
+    asset: IAddress;
+    amount: bigint;
+}
+export interface ISwapRouterNativeDepositOptions extends ISwapRouterBaseOptions {
+    amount: bigint;
+}