@augustdigital/sdk 7.0.1 → 8.2.0

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/coingecko/fetcher.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchTokenPricesFromCoinGecko = fetchTokenPricesFromCoinGecko;
+const logger_1 = require("../../core/logger");
 const utils_1 = require("./utils");
 async function fetchTokenPricesFromCoinGecko(symbol, coinGeckoKey) {
     const coinId = utils_1.COINGECKO_COIN_ID_MAP[symbol.toLowerCase()];
@@ -19,17 +20,26 @@ async function fetchTokenPricesFromCoinGecko(symbol, coinGeckoKey) {
             },
         });
         if (!response.ok) {
-            console.error('\n\n❌ CoinGecko API Error:', response.statusText, coinId, '\n\n');
-            throw new Error(`❌ CoinGecko API Error: ${response.statusText}`);
+            const err = new Error(`CoinGecko API error: ${response.status} ${response.statusText}`);
+            logger_1.Logger.log.error('fetchTokenPricesFromCoinGecko', err, {
+                status: response.status,
+                statusText: response.statusText,
+                coinId,
+                symbol,
+            });
+            throw err;
         }
         const data = (await response.json());
-        if (data && data.length) {
-            return data.prices[data.length - 1][1];
+        if (data?.prices?.length) {
+            return data.prices[data.prices.length - 1][1];
         }
         return null;
     }
     catch (error) {
-        console.error('❌ Error fetching CoinGecko prices:', `${error} for ${coinId} ${symbol}`);
+        logger_1.Logger.log.error('fetchTokenPricesFromCoinGecko', error, {
+            coinId,
+            symbol,
+        });
         return null;
     }
 }

package/lib/services/debank/fetcher.js

@@ -10,18 +10,21 @@ async function fetchVaultDebankResponse(vaultAddress, headers) {
             const data = (await response.json());
             return data;
         }
-        console.error('#fetchVaultDebankResponse::', response.status, response.statusText);
+        core_1.Logger.log.error('fetchVaultDebankResponse', new Error(`HTTP ${response.status} ${response.statusText}`), { status: response.status, statusText: response.statusText });
         return false;
     }
     catch (e) {
-        console.error('#fetchVaultDebankResponse::', e);
+        core_1.Logger.log.error('fetchVaultDebankResponse', e);
         return false;
     }
 }
 async function fetchDebankResponse(address, headers) {
     const debankResponse = await (0, core_1.fetchAugustWithKey)(undefined, core_1.WEBSERVER_ENDPOINTS.subaccount.debank(address), { override: true, headers: headers });
     if (debankResponse.status !== 200) {
-        console.error('#getVaultAllocations::defi:', debankResponse.status, debankResponse.statusText);
+        core_1.Logger.log.error('fetchDebankResponse', new Error(`HTTP ${debankResponse.status} ${debankResponse.statusText}`), {
+            status: debankResponse.status,
+            statusText: debankResponse.statusText,
+        });
         return false;
     }
     else if (debankResponse.status === 200) {

package/lib/services/debank/utils.js

@@ -3,12 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseVaultLevelDebank = parseVaultLevelDebank;
 exports.getVaultExposure = getVaultExposure;
 exports.parseLoanLevelDebank = parseLoanLevelDebank;
-const core_1 = require("../../core/helpers/core");
+const core_1 = require("../../core");
+const core_2 = require("../../core/helpers/core");
 function addToTokenExposure(token, tokenExposure, exposureType, protocol, exposurePerCategory, netValue, borrower) {
     const usdAmount = Number(token?.price || 0) * Number(token?.amount);
     if (exposureType === 'wallet'
-        ? !(0, core_1.filterOutBySize)(usdAmount)
-        : !(0, core_1.filterOutBySize)(usdAmount))
+        ? !(0, core_2.filterOutBySize)(usdAmount)
+        : !(0, core_2.filterOutBySize)(usdAmount))
         return;
     if (exposureType === 'borrow') {
         netValue.value -= usdAmount;
@@ -73,7 +74,7 @@ function parseVaultLevelDebank(debankRes, protocolExposure, tokenExposure, borro
         });
         const foundExistingProtocolExposure = protocolExposure.find((exp) => exp.id === pos.id);
         if (!foundExistingProtocolExposure &&
-            (0, core_1.filterOutBySize)(protoReturnObj.netUsdValue)) {
+            (0, core_2.filterOutBySize)(protoReturnObj.netUsdValue)) {
             protocolExposure.push(protoReturnObj);
         }
         else if (foundExistingProtocolExposure) {
@@ -126,7 +127,7 @@ function parseVaultLevelDebank(debankRes, protocolExposure, tokenExposure, borro
         });
         const foundExistingProtocolExposure = protocolExposure.find((exp) => exp.id === pos.id);
         if (!foundExistingProtocolExposure &&
-            (0, core_1.filterOutBySize)(protoReturnObj.netUsdValue)) {
+            (0, core_2.filterOutBySize)(protoReturnObj.netUsdValue)) {
             protocolExposure.push(protoReturnObj);
         }
         else if (foundExistingProtocolExposure) {
@@ -272,7 +273,7 @@ function parseLoanLevelDebank(debankRes) {
         exposure = uniqueExposure;
     }
     catch (err) {
-        console.error('#getPoolLoansData::strategies:', err);
+        core_1.Logger.log.error('getPoolLoansData.strategies', err);
     }
     return { exposure, positions };
 }

package/lib/services/octavfi/fetcher.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchOctavfiPortfolios = fetchOctavfiPortfolios;
 const ethers_1 = require("ethers");
 const utils_1 = require("../../adapters/solana/utils");
+const core_1 = require("../../core");
 const BASE_URL = 'https://api.octav.fi';
 const OCTAVFI_API_KEY = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJodHRwczovL2hhc3VyYS5pby9qd3QvY2xhaW1zIjp7IngtaGFzdXJhLWRlZmF1bHQtcm9sZSI6InVzZXIiLCJ4LWhhc3VyYS1hbGxvd2VkLXJvbGVzIjpbInVzZXIiXSwieC1oYXN1cmEtdXNlci1pZCI6ImF1Z3VzdDEyMjM0In19.zaMUtrtdC82uaDh6XSZrsneEcKO3PFOE6FyX3G-MR6c';
 function filterEvmAndSolanaAddresses(addresses) {
@@ -15,7 +16,7 @@ function filterEvmAndSolanaAddresses(addresses) {
         if (utils_1.SolanaUtils.isSolanaAddress(address)) {
             return true;
         }
-        console.log(`Excluding address: ${address} (not EVM or Solana)`);
+        core_1.Logger.log.info('filterEvmAndSolanaAddresses.excluded', { address });
         return false;
     });
 }
@@ -30,16 +31,20 @@ async function fetchSinglePortfolio(address) {
         });
         if (!response.ok) {
             const errorText = await response.text();
-            console.error(`Failed to fetch portfolio for ${address}: ${response.status} ${response.statusText}. ${errorText}`);
+            core_1.Logger.log.error('fetchSinglePortfolio', new Error(`HTTP ${response.status} ${response.statusText}: ${errorText}`), {
+                address,
+                status: response.status,
+                statusText: response.statusText,
+            });
             return null;
         }
         const data = await response.json();
         if (!data || typeof data !== 'object') {
-            console.error(`Unexpected response type for ${address}:`, typeof data);
+            core_1.Logger.log.error('fetchSinglePortfolio.unexpected-type', new Error(`unexpected response type: ${typeof data}`), { address });
             return null;
         }
         if (data.error) {
-            console.error(`API error for ${address}:`, data.error);
+            core_1.Logger.log.error('fetchSinglePortfolio.api-error', new Error(String(data.error)), { address });
             return null;
         }
         let portfolio = data;
@@ -57,7 +62,7 @@ async function fetchSinglePortfolio(address) {
         return portfolio;
     }
     catch (error) {
-        console.error(`Error fetching portfolio for ${address}:`, error);
+        core_1.Logger.log.error('fetchSinglePortfolio', error, { address });
         return null;
     }
 }

package/lib/services/subgraph/vaults.js

@@ -297,7 +297,7 @@ async function getSubgraphWithdrawProccessed(pool, provider, slackWebookUrl = sl
         const requests = [];
         if (!goldskyUrl) {
             const chainId = await (0, core_1.getChainId)(provider);
-            console.error('#getSubgraphWithdrawProccessed: goldsky url is undefined:', chainId, vaultSymbol, pool);
+            core_1.Logger.log.error('getSubgraphWithdrawProccessed.missing-subgraph-url', new Error('goldsky url is undefined'), { chainId, vaultSymbol, pool });
             slack_1.SLACK.error({
                 title: 'Missing Subgraph',
                 error: '#getSubgraphWithdrawProccessed: goldsky url is undefined',
@@ -326,7 +326,7 @@ async function getSubgraphWithdrawProccessed(pool, provider, slackWebookUrl = sl
         }
       }`, GOLDSKY_API_KEY);
         if (result.status !== 200) {
-            console.error('#getSubgraphWithdrawProccessed:', result.status, result.statusText, pool);
+            core_1.Logger.log.error('getSubgraphWithdrawProccessed', new Error(`HTTP ${result.status} ${result.statusText}`), { status: result.status, statusText: result.statusText, pool });
             return [];
         }
         const json = (await result.json());
@@ -334,7 +334,7 @@ async function getSubgraphWithdrawProccessed(pool, provider, slackWebookUrl = sl
         return requests;
     }
     catch (e) {
-        console.error('#getSubgraphWithdrawProccessed::', pool, e);
+        core_1.Logger.log.error('getSubgraphWithdrawProccessed', e, { pool });
         return [];
     }
 }
@@ -638,7 +638,7 @@ async function getSubgraphVaultHistory(provider, pool, slackWebookUrl = slack_1.
       }
     }`, GOLDSKY_API_KEY);
         if (result.status !== 200) {
-            console.error('#getSubgraphVaultHistory:', result.status, result.statusText);
+            core_1.Logger.log.error('getSubgraphVaultHistory', new Error(`HTTP ${result.status} ${result.statusText}`), { status: result.status, statusText: result.statusText });
             return requests;
         }
         const json = (await result.json());
@@ -648,7 +648,7 @@ async function getSubgraphVaultHistory(provider, pool, slackWebookUrl = slack_1.
         return formattedRequests;
     }
     catch (e) {
-        console.error('#getSubgraphVaultHistory::', pool, e);
+        core_1.Logger.log.error('getSubgraphVaultHistory', e, { pool });
         return [];
     }
 }
@@ -740,7 +740,7 @@ async function getSubgraphUserTransfers(user, provider, pool, slackWebookUrl = s
         return userTransfers;
     }
     catch (e) {
-        console.error('#getSubgraphUserTransfers::', pool, ':', e);
+        core_1.Logger.log.error('getSubgraphUserTransfers', e, { pool });
         return [];
     }
 }

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}`;
+};