@mento-protocol/mento-sdk 3.1.0-beta.4 → 3.1.0-beta.5

package/dist/esm/services/liquidity/zapOut.js

@@ -5,79 +5,84 @@ import { validateAddress } from '../../utils/validation';
 import { encodeRoutePath } from '../../utils/pathEncoder';
 import { buildApprovalParams, getAllowance, calculateMinAmount, getPoolInfo } from './liquidityHelpers';
 import { encodeZapOutCall, findZapOutRoutes } from './zapHelpers';
-// ========== ZAP OUT OPERATIONS ==========
 const INSUFFICIENT_LIQUIDITY_SELECTOR = '0xbb55fd27';
 const MAX_ROUTE_CANDIDATES_PER_LEG = 8;
 const MAX_ROUTE_COMBINATIONS = 48;
-/**
- * Builds a complete zap out transaction including approval if needed
- */
+const ROUTE_SIMULATION_BATCH_SIZE = 6;
 export async function buildZapOutTransactionInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenOut, liquidity, recipient, owner, options) {
-    validateAddress(owner, 'owner');
-    // Build zap out params
-    let zapOut = await buildZapOutParamsInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenOut, liquidity, recipient, options);
-    // Check LP token allowance
-    const poolAddr = poolAddress;
-    const ownerAddr = owner;
-    const currentAllowance = await getAllowance(publicClient, poolAddr, ownerAddr, chainId);
-    // Build approval if needed
-    const approval = currentAllowance < liquidity
-        ? { token: poolAddress, amount: liquidity, params: buildApprovalParams(chainId, poolAddr, liquidity) }
-        : null;
-    // We can only preflight/simulate a real zap call when approval is already sufficient.
-    // Before approval, transferFrom in zapOut() would fail and make simulation meaningless.
-    if (currentAllowance >= liquidity) {
+    const prepared = await prepareZapOutInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenOut, liquidity, recipient, owner, options);
+    return {
+        approval: prepared.approval ?? null,
+        zapOut: prepared.details,
+    };
+}
+export async function buildZapOutParamsInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenOut, liquidity, recipient, options) {
+    const prepared = await prepareZapOutInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenOut, liquidity, recipient, undefined, options);
+    return prepared.details;
+}
+export async function quoteZapOutInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenOut, liquidity, options) {
+    const prepared = await prepareZapOutInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenOut, liquidity, tokenOut, undefined, options);
+    return prepared.quote;
+}
+export async function prepareZapOutInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenOut, liquidity, recipient, owner, options) {
+    if (owner) {
+        validateAddress(owner, 'owner');
+    }
+    const [context, currentAllowance] = await Promise.all([
+        prepareZapOutContextInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenOut, liquidity, recipient, options),
+        owner ? getAllowance(publicClient, poolAddress, owner, chainId) : Promise.resolve(null),
+    ]);
+    let details = context.details;
+    const approval = owner && currentAllowance !== null && currentAllowance < liquidity
+        ? { token: poolAddress, amount: liquidity, params: buildApprovalParams(chainId, poolAddress, liquidity) }
+        : owner
+            ? null
+            : undefined;
+    if (owner && currentAllowance !== null && currentAllowance >= liquidity) {
+        const ownerAddr = owner;
         const routerAddress = getContractAddress(chainId, 'Router');
         try {
-            await simulateZapOut(publicClient, ownerAddr, routerAddress, zapOut.params.data);
+            await simulateZapOut(publicClient, ownerAddr, routerAddress, details.params.data);
         }
         catch (error) {
-            // Only attempt route fallback for the known liquidity failure.
             if (!isInsufficientLiquidityError(error)) {
                 throw error;
             }
-            zapOut = await findViableZapOutDetails(publicClient, chainId, poolService, routeService, poolAddress, tokenOut, liquidity, ownerAddr, options);
+            details = await findViableZapOutDetails(publicClient, chainId, poolService, routeService, poolAddress, tokenOut, liquidity, ownerAddr, options);
         }
     }
-    return { approval, zapOut };
+    return {
+        routesA: details.routesA,
+        routesB: details.routesB,
+        quote: {
+            amountOutFromA: details.zapParams.amountOutMinA,
+            amountOutFromB: details.zapParams.amountOutMinB,
+            amountAMin: details.zapParams.amountAMin,
+            amountBMin: details.zapParams.amountBMin,
+            estimatedMinTokenOut: details.estimatedMinTokenOut,
+        },
+        approval,
+        details,
+    };
 }
-/**
- * Builds zap out transaction parameters without checking approval
- */
-export async function buildZapOutParamsInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenOut, liquidity, recipient, options) {
+async function prepareZapOutContextInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenOut, liquidity, recipient, options) {
     validateAddress(poolAddress, 'poolAddress');
     validateAddress(tokenOut, 'tokenOut');
     validateAddress(recipient, 'recipient');
-    // Get pool info
-    const { token0, token1, factoryAddr } = await getPoolInfo(poolService, poolAddress);
-    // Find routes for swapping (from pool tokens to tokenOut)
-    const { routesA, routesB } = await findZapOutRoutes(routeService, token0, token1, tokenOut);
-    return buildZapOutDetailsForRoutes(publicClient, chainId, poolAddress, tokenOut, liquidity, token0, token1, factoryAddr, routesA, routesB, options);
-}
-/**
- * Quotes a zap out operation (read-only)
- */
-export async function quoteZapOutInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenOut, liquidity, options) {
-    validateAddress(poolAddress, 'poolAddress');
-    validateAddress(tokenOut, 'tokenOut');
     const { token0, token1, factoryAddr } = await getPoolInfo(poolService, poolAddress);
-    // Find routes for swapping (from pool tokens to tokenOut)
     const { routesA, routesB } = await findZapOutRoutes(routeService, token0, token1, tokenOut);
-    const routerAddress = getContractAddress(chainId, 'Router');
-    const [amountOutMinA, amountOutMinB, amountAMin, amountBMin] = (await publicClient.readContract({
-        address: routerAddress,
-        abi: ROUTER_ABI,
-        functionName: 'generateZapOutParams',
-        args: [token0, token1, factoryAddr, liquidity, routesA, routesB],
-    }));
-    const finalAmountOutFromA = calculateMinAmount(amountOutMinA, options.slippageTolerance);
-    const finalAmountOutFromB = calculateMinAmount(amountOutMinB, options.slippageTolerance);
+    const details = await buildZapOutDetailsForRoutes(publicClient, chainId, poolAddress, tokenOut, liquidity, token0, token1, factoryAddr, routesA, routesB, options);
     return {
-        amountOutFromA: finalAmountOutFromA,
-        amountOutFromB: finalAmountOutFromB,
-        amountAMin: calculateMinAmount(amountAMin, options.slippageTolerance),
-        amountBMin: calculateMinAmount(amountBMin, options.slippageTolerance),
-        estimatedMinTokenOut: finalAmountOutFromA + finalAmountOutFromB,
+        routesA,
+        routesB,
+        quote: {
+            amountOutFromA: details.zapParams.amountOutMinA,
+            amountOutFromB: details.zapParams.amountOutMinB,
+            amountAMin: details.zapParams.amountAMin,
+            amountBMin: details.zapParams.amountBMin,
+            estimatedMinTokenOut: details.estimatedMinTokenOut,
+        },
+        details,
     };
 }
 async function buildZapOutDetailsForRoutes(publicClient, chainId, poolAddress, tokenOut, liquidity, token0, token1, factoryAddr, routesA, routesB, options) {
@@ -120,25 +125,36 @@ async function buildZapOutDetailsForRoutes(publicClient, chainId, poolAddress, t
 async function findViableZapOutDetails(publicClient, chainId, poolService, routeService, poolAddress, tokenOut, liquidity, owner, options) {
     const { token0, token1, factoryAddr } = await getPoolInfo(poolService, poolAddress);
     const routerAddress = getContractAddress(chainId, 'Router');
-    const routesAOptions = await getEncodedRouteCandidates(routeService, token0, tokenOut, poolAddress);
-    const routesBOptions = await getEncodedRouteCandidates(routeService, token1, tokenOut, poolAddress);
-    let best = null;
-    let combinationsTried = 0;
+    const allRoutes = await routeService.getRoutes({ cached: false, returnAllRoutes: true });
+    const [routesAOptions, routesBOptions] = await Promise.all([
+        getEncodedRouteCandidates(routeService, token0, tokenOut, poolAddress, allRoutes),
+        getEncodedRouteCandidates(routeService, token1, tokenOut, poolAddress, allRoutes),
+    ]);
+    const routeCombinations = [];
     outer: for (const routesA of routesAOptions) {
         for (const routesB of routesBOptions) {
-            if (combinationsTried >= MAX_ROUTE_COMBINATIONS) {
+            routeCombinations.push({ routesA, routesB });
+            if (routeCombinations.length >= MAX_ROUTE_COMBINATIONS) {
                 break outer;
             }
-            combinationsTried += 1;
+        }
+    }
+    let best = null;
+    for (let index = 0; index < routeCombinations.length; index += ROUTE_SIMULATION_BATCH_SIZE) {
+        const batch = routeCombinations.slice(index, index + ROUTE_SIMULATION_BATCH_SIZE);
+        const candidates = await Promise.all(batch.map(async ({ routesA, routesB }) => {
             try {
                 const candidate = await buildZapOutDetailsForRoutes(publicClient, chainId, poolAddress, tokenOut, liquidity, token0, token1, factoryAddr, routesA, routesB, options);
                 await simulateZapOut(publicClient, owner, routerAddress, candidate.params.data);
-                if (!best || candidate.estimatedMinTokenOut > best.estimatedMinTokenOut) {
-                    best = candidate;
-                }
+                return candidate;
             }
             catch {
-                // Ignore non-viable route combination and continue searching.
+                return null;
+            }
+        }));
+        for (const candidate of candidates) {
+            if (candidate && (!best || candidate.estimatedMinTokenOut > best.estimatedMinTokenOut)) {
+                best = candidate;
             }
         }
     }
@@ -147,21 +163,18 @@ async function findViableZapOutDetails(publicClient, chainId, poolService, route
     }
     return best;
 }
-async function getEncodedRouteCandidates(routeService, tokenIn, tokenOut, sourcePoolAddress) {
+async function getEncodedRouteCandidates(routeService, tokenIn, tokenOut, sourcePoolAddress, allRoutes) {
     if (tokenIn.toLowerCase() === tokenOut.toLowerCase()) {
         return [[]];
     }
     const rawCandidates = [];
-    // Include the SDK default first for consistency.
     try {
         rawCandidates.push(await routeService.findRoute(tokenIn, tokenOut));
     }
     catch {
-        // Continue; we'll try full route enumeration next.
+        // Continue; we'll try the broader route set next.
     }
-    // Build a broader candidate set for fallback route selection.
-    const allRoutes = await routeService.getRoutes({ cached: false, returnAllRoutes: true });
-    const pairCandidates = allRoutes.filter((route) => {
+    const pairCandidates = (allRoutes ?? await routeService.getRoutes({ cached: false, returnAllRoutes: true })).filter((route) => {
         const a0 = route.tokens[0].address.toLowerCase();
         const a1 = route.tokens[1].address.toLowerCase();
         const t0 = tokenIn.toLowerCase();
@@ -172,14 +185,13 @@ async function getEncodedRouteCandidates(routeService, tokenIn, tokenOut, source
     if (rawCandidates.length === 0) {
         throw new RouteNotFoundError(tokenIn, tokenOut);
     }
-    // Prioritize routes that avoid swapping through the same pool being zapped out.
-    rawCandidates.sort((a, b) => {
-        const aUsesSourcePool = routeUsesPool(a, sourcePoolAddress) ? 1 : 0;
-        const bUsesSourcePool = routeUsesPool(b, sourcePoolAddress) ? 1 : 0;
-        if (aUsesSourcePool !== bUsesSourcePool)
-            return aUsesSourcePool - bUsesSourcePool;
-        if (a.path.length !== b.path.length)
-            return a.path.length - b.path.length;
+    rawCandidates.sort((routeA, routeB) => {
+        const routeAUsesSourcePool = routeUsesPool(routeA, sourcePoolAddress) ? 1 : 0;
+        const routeBUsesSourcePool = routeUsesPool(routeB, sourcePoolAddress) ? 1 : 0;
+        if (routeAUsesSourcePool !== routeBUsesSourcePool)
+            return routeAUsesSourcePool - routeBUsesSourcePool;
+        if (routeA.path.length !== routeB.path.length)
+            return routeA.path.length - routeB.path.length;
         return 0;
     });
     const encodedRoutes = [];

package/dist/esm/services/pools/PoolService.js

@@ -1,6 +1,6 @@
 import { PoolType } from '../../core/types';
 import { fetchFPMMPools, fetchVirtualPools } from './poolDiscovery';
-import { fetchFPMMPoolDetails, fetchVirtualPoolDetails } from './poolDetails';
+import { fetchFPMMPoolDetailsBatch, fetchVirtualPoolDetailsBatch, } from './poolDetails';
 /**
  * Service for discovering liquidity pools in the Mento protocol.
  * Aggregates pools from multiple factory contracts (FPMM and VirtualPool).
@@ -11,6 +11,9 @@ export class PoolService {
         this.chainId = chainId;
         this.poolsCache = null;
         this.discoveryWarnings = [];
+        this.poolsPromise = null;
+        this.poolDetailsCache = new Map();
+        this.poolDetailPromises = new Map();
     }
     /**
      * Returns any warnings from the last pool discovery operation.
@@ -36,23 +39,36 @@ export class PoolService {
         if (this.poolsCache) {
             return this.poolsCache;
         }
-        const pools = [];
-        const warnings = [];
+        if (this.poolsPromise) {
+            return this.poolsPromise;
+        }
+        this.poolsPromise = this.loadPools();
         try {
-            const fpmmPools = await fetchFPMMPools(this.publicClient, this.chainId);
-            pools.push(...fpmmPools);
+            return await this.poolsPromise;
         }
-        catch (error) {
-            const message = `Failed to fetch FPMM pools: ${error instanceof Error ? error.message : String(error)}`;
-            warnings.push(message);
+        finally {
+            this.poolsPromise = null;
         }
-        try {
-            const virtualPools = await fetchVirtualPools(this.publicClient, this.chainId);
-            pools.push(...virtualPools);
+    }
+    async loadPools() {
+        const warnings = [];
+        const settled = await Promise.allSettled([
+            fetchFPMMPools(this.publicClient, this.chainId),
+            fetchVirtualPools(this.publicClient, this.chainId),
+        ]);
+        const pools = [];
+        const [fpmmResult, virtualResult] = settled;
+        if (fpmmResult.status === 'fulfilled') {
+            pools.push(...fpmmResult.value);
         }
-        catch (error) {
-            const message = `Failed to fetch Virtual pools: ${error instanceof Error ? error.message : String(error)}`;
-            warnings.push(message);
+        else {
+            warnings.push(`Failed to fetch FPMM pools: ${fpmmResult.reason instanceof Error ? fpmmResult.reason.message : String(fpmmResult.reason)}`);
+        }
+        if (virtualResult.status === 'fulfilled') {
+            pools.push(...virtualResult.value);
+        }
+        else {
+            warnings.push(`Failed to fetch Virtual pools: ${virtualResult.reason instanceof Error ? virtualResult.reason.message : String(virtualResult.reason)}`);
         }
         this.discoveryWarnings = warnings;
         // Only throw if NO pools were discovered from any factory
@@ -85,16 +101,95 @@ export class PoolService {
      * ```
      */
     async getPoolDetails(poolAddr) {
+        const [details] = await this.getPoolDetailsBatch([poolAddr]);
+        return details;
+    }
+    async getPoolDetailsBatch(poolAddresses) {
         const pools = await this.getPools();
-        const pool = pools.find((p) => p.poolAddr.toLowerCase() === poolAddr.toLowerCase());
-        if (!pool) {
-            throw new Error(`Pool not found: ${poolAddr}. ` + 'Ensure the address is a valid pool discovered by getPools().');
+        const targets = poolAddresses
+            ? poolAddresses.map((poolAddress) => {
+                const pool = pools.find((candidate) => candidate.poolAddr.toLowerCase() === poolAddress.toLowerCase());
+                if (!pool) {
+                    throw new Error(`Pool not found: ${poolAddress}. Ensure the address is a valid pool discovered by getPools().`);
+                }
+                return pool;
+            })
+            : pools;
+        const results = new Array(targets.length);
+        const pendingResults = [];
+        const missingTargets = [];
+        for (const [index, pool] of targets.entries()) {
+            const key = pool.poolAddr.toLowerCase();
+            const cached = this.poolDetailsCache.get(key);
+            if (cached) {
+                results[index] = cached;
+                continue;
+            }
+            const inFlight = this.poolDetailPromises.get(key);
+            if (inFlight) {
+                pendingResults.push(inFlight.then((detail) => {
+                    results[index] = detail;
+                }));
+                continue;
+            }
+            missingTargets.push({ pool, index, key });
         }
-        if (pool.poolType === PoolType.FPMM) {
-            return fetchFPMMPoolDetails(this.publicClient, this.chainId, pool);
-        }
-        else {
-            return fetchVirtualPoolDetails(this.publicClient, pool);
+        if (missingTargets.length > 0) {
+            const grouped = {
+                fpmm: missingTargets.filter(({ pool }) => pool.poolType === PoolType.FPMM),
+                virtual: missingTargets.filter(({ pool }) => pool.poolType !== PoolType.FPMM),
+            };
+            const createdPromises = new Map();
+            const createdPendingResults = [];
+            for (const target of missingTargets) {
+                const deferred = createDeferred();
+                this.poolDetailPromises.set(target.key, deferred.promise);
+                createdPromises.set(target.key, deferred);
+                const pendingResult = deferred.promise.then((detail) => {
+                    results[target.index] = detail;
+                });
+                pendingResults.push(pendingResult);
+                createdPendingResults.push(pendingResult);
+            }
+            try {
+                const [fpmmDetails, virtualDetails] = await Promise.all([
+                    fetchFPMMPoolDetailsBatch(this.publicClient, this.chainId, grouped.fpmm.map(({ pool }) => pool)),
+                    fetchVirtualPoolDetailsBatch(this.publicClient, grouped.virtual.map(({ pool }) => pool)),
+                ]);
+                for (const [groupIndex, detail] of fpmmDetails.entries()) {
+                    const target = grouped.fpmm[groupIndex];
+                    this.poolDetailsCache.set(target.key, detail);
+                    createdPromises.get(target.key)?.resolve(detail);
+                }
+                for (const [groupIndex, detail] of virtualDetails.entries()) {
+                    const target = grouped.virtual[groupIndex];
+                    this.poolDetailsCache.set(target.key, detail);
+                    createdPromises.get(target.key)?.resolve(detail);
+                }
+            }
+            catch (error) {
+                for (const target of missingTargets) {
+                    createdPromises.get(target.key)?.reject(error);
+                }
+                await Promise.allSettled(createdPendingResults);
+                throw error;
+            }
+            finally {
+                for (const target of missingTargets) {
+                    this.poolDetailPromises.delete(target.key);
+                }
+            }
         }
+        await Promise.all(pendingResults);
+        return results;
     }
 }
+function createDeferred() {
+    let resolve;
+    let reject;
+    const promise = new Promise((resolvePromise, rejectPromise) => {
+        resolve = resolvePromise;
+        reject = rejectPromise;
+    });
+    return { promise, resolve, reject };
+}

package/dist/esm/services/pools/poolDetails.js

@@ -2,35 +2,51 @@ import { addresses } from '../../core/constants';
 import { FPMM_ABI, VIRTUAL_POOL_ABI } from '../../core/abis';
 import { getAddress } from 'viem';
 import { multicall } from '../../utils/multicall';
+const FPMM_FIXED_RESULT_COUNT = 8;
+const VIRTUAL_RESULT_COUNT = 3;
 /**
  * Fetches enriched details for an FPMM pool
  */
 export async function fetchFPMMPoolDetails(publicClient, chainId, pool) {
+    const [details] = await fetchFPMMPoolDetailsBatch(publicClient, chainId, [pool]);
+    return details;
+}
+export async function fetchFPMMPoolDetailsBatch(publicClient, chainId, pools) {
+    if (pools.length === 0) {
+        return [];
+    }
+    const knownStrategies = getKnownLiquidityStrategies(chainId);
+    const contracts = pools.flatMap((pool) => buildFPMMContracts(pool, knownStrategies));
+    const results = await multicall(publicClient, contracts);
+    const perPoolResultCount = FPMM_FIXED_RESULT_COUNT + knownStrategies.length + 1;
+    return pools.map((pool, index) => {
+        const offset = index * perPoolResultCount;
+        const poolResults = results.slice(offset, offset + perPoolResultCount);
+        return parseFPMMPoolDetails(pool, knownStrategies, poolResults);
+    });
+}
+function buildFPMMContracts(pool, knownStrategies) {
     const address = pool.poolAddr;
+    return [
+        { address, abi: FPMM_ABI, functionName: 'getReserves' },
+        { address, abi: FPMM_ABI, functionName: 'decimals0' },
+        { address, abi: FPMM_ABI, functionName: 'decimals1' },
+        { address, abi: FPMM_ABI, functionName: 'lpFee' },
+        { address, abi: FPMM_ABI, functionName: 'protocolFee' },
+        { address, abi: FPMM_ABI, functionName: 'rebalanceIncentive' },
+        { address, abi: FPMM_ABI, functionName: 'rebalanceThresholdAbove' },
+        { address, abi: FPMM_ABI, functionName: 'rebalanceThresholdBelow' },
+        ...knownStrategies.map((strategyAddr) => ({
+            address,
+            abi: FPMM_ABI,
+            functionName: 'liquidityStrategy',
+            args: [strategyAddr],
+        })),
+        { address, abi: FPMM_ABI, functionName: 'getRebalancingState' },
+    ];
+}
+function parseFPMMPoolDetails(pool, knownStrategies, results) {
     try {
-        // Known liquidity strategy addresses for this chain
-        const knownStrategies = getKnownLiquidityStrategies(chainId);
-        // Build all contract reads for a single multicall
-        const coreContracts = [
-            { address, abi: FPMM_ABI, functionName: 'getReserves' },
-            { address, abi: FPMM_ABI, functionName: 'decimals0' },
-            { address, abi: FPMM_ABI, functionName: 'decimals1' },
-            { address, abi: FPMM_ABI, functionName: 'lpFee' },
-            { address, abi: FPMM_ABI, functionName: 'protocolFee' },
-            { address, abi: FPMM_ABI, functionName: 'rebalanceIncentive' },
-            { address, abi: FPMM_ABI, functionName: 'rebalanceThresholdAbove' },
-            { address, abi: FPMM_ABI, functionName: 'rebalanceThresholdBelow' },
-            ...knownStrategies.map((strategyAddr) => ({
-                address,
-                abi: FPMM_ABI,
-                functionName: 'liquidityStrategy',
-                args: [strategyAddr],
-            })),
-            // Include getRebalancingState in the same multicall (allowFailure handles FXMarketClosed)
-            { address, abi: FPMM_ABI, functionName: 'getRebalancingState' },
-        ];
-        const results = await multicall(publicClient, coreContracts);
-        // Parse core results (first 8 are fixed)
         const reservesRes = results[0];
         const decimals0Res = results[1];
         const decimals1Res = results[2];
@@ -39,8 +55,15 @@ export async function fetchFPMMPoolDetails(publicClient, chainId, pool) {
         const rebalanceIncentiveRes = results[5];
         const thresholdAboveRes = results[6];
         const thresholdBelowRes = results[7];
-        // Check core results
-        if (reservesRes.status === 'failure' ||
+        if (!reservesRes ||
+            !decimals0Res ||
+            !decimals1Res ||
+            !lpFeeRes ||
+            !protocolFeeRes ||
+            !rebalanceIncentiveRes ||
+            !thresholdAboveRes ||
+            !thresholdBelowRes ||
+            reservesRes.status === 'failure' ||
             decimals0Res.status === 'failure' ||
             decimals1Res.status === 'failure' ||
             lpFeeRes.status === 'failure' ||
@@ -56,15 +79,13 @@ export async function fetchFPMMPoolDetails(publicClient, chainId, pool) {
         const rebalanceIncentiveBps = rebalanceIncentiveRes.result;
         const thresholdAboveBps = thresholdAboveRes.result;
         const thresholdBelowBps = thresholdBelowRes.result;
-        // Parse strategy results (indices 8 .. 8+N-1)
-        const strategyResults = results.slice(8, 8 + knownStrategies.length);
-        const activeIndex = strategyResults.findIndex((r) => r.status === 'success' && r.result === true);
+        const strategyResults = results.slice(FPMM_FIXED_RESULT_COUNT, FPMM_FIXED_RESULT_COUNT + knownStrategies.length);
+        const activeIndex = strategyResults.findIndex((result) => result.status === 'success' && result.result === true);
         const liquidityStrategy = activeIndex >= 0 ? knownStrategies[activeIndex] : null;
-        // Parse getRebalancingState (last result) — graceful degradation when FX market is closed
-        const rebalancingRes = results[8 + knownStrategies.length];
+        const rebalancingRes = results[FPMM_FIXED_RESULT_COUNT + knownStrategies.length];
         let pricing = null;
         let inBand = null;
-        if (rebalancingRes.status === 'success') {
+        if (rebalancingRes?.status === 'success') {
             const [oraclePriceNum, oraclePriceDen, reservePriceNum, reservePriceDen, reservePriceAboveOraclePrice, rebalanceThreshold, priceDifference,] = rebalancingRes.result;
             pricing = {
                 oraclePriceNum,
@@ -79,7 +100,6 @@ export async function fetchFPMMPoolDetails(publicClient, chainId, pool) {
             };
             inBand = priceDifference < BigInt(rebalanceThreshold);
         }
-        // If rebalancingRes.status === 'failure' (likely FXMarketClosed) — pricing stays null
         return {
             ...pool,
             poolType: 'FPMM',
@@ -116,14 +136,35 @@ export async function fetchFPMMPoolDetails(publicClient, chainId, pool) {
  * Fetches enriched details for a Virtual pool
  */
 export async function fetchVirtualPoolDetails(publicClient, pool) {
+    const [details] = await fetchVirtualPoolDetailsBatch(publicClient, [pool]);
+    return details;
+}
+export async function fetchVirtualPoolDetailsBatch(publicClient, pools) {
+    if (pools.length === 0) {
+        return [];
+    }
+    const contracts = pools.flatMap((pool) => buildVirtualContracts(pool));
+    const results = await multicall(publicClient, contracts);
+    return pools.map((pool, index) => {
+        const offset = index * VIRTUAL_RESULT_COUNT;
+        const poolResults = results.slice(offset, offset + VIRTUAL_RESULT_COUNT);
+        return parseVirtualPoolDetails(pool, poolResults);
+    });
+}
+function buildVirtualContracts(pool) {
     const address = pool.poolAddr;
+    return [
+        { address, abi: VIRTUAL_POOL_ABI, functionName: 'getReserves' },
+        { address, abi: VIRTUAL_POOL_ABI, functionName: 'protocolFee' },
+        { address, abi: VIRTUAL_POOL_ABI, functionName: 'metadata' },
+    ];
+}
+function parseVirtualPoolDetails(pool, results) {
     try {
-        const results = await multicall(publicClient, [
-            { address, abi: VIRTUAL_POOL_ABI, functionName: 'getReserves' },
-            { address, abi: VIRTUAL_POOL_ABI, functionName: 'protocolFee' },
-            { address, abi: VIRTUAL_POOL_ABI, functionName: 'metadata' },
-        ]);
-        if (results[0].status === 'failure' || results[1].status === 'failure' || results[2].status === 'failure') {
+        if (results.length !== VIRTUAL_RESULT_COUNT ||
+            results[0].status === 'failure' ||
+            results[1].status === 'failure' ||
+            results[2].status === 'failure') {
             throw new Error('One or more virtual pool reads failed');
         }
         const [reserve0, reserve1, blockTimestampLast] = results[0].result;

package/dist/esm/services/quotes/QuoteService.js

@@ -57,27 +57,29 @@ export class QuoteService {
         if (!route) {
             route = await this.routeService.findRoute(tokenIn, tokenOut);
         }
-        // Convert route.path to Router contract's Route[] format
-        const routerRoutes = encodeRoutePath(route.path, tokenIn, tokenOut);
-        const routerAddress = getContractAddress(this.chainId, 'Router');
-        try {
-            const amounts = (await this.publicClient.readContract({
-                address: routerAddress,
-                abi: ROUTER_ABI,
-                functionName: 'getAmountsOut',
-                args: [amountIn, routerRoutes],
-            }));
-            return amounts[amounts.length - 1];
-        }
-        catch (error) {
-            if (error instanceof BaseError) {
-                const revertError = error.walk((e) => e instanceof ContractFunctionRevertedError);
-                if (revertError instanceof ContractFunctionRevertedError &&
-                    revertError.data?.errorName === 'FXMarketClosed') {
-                    throw new FXMarketClosedError();
-                }
+        return getAmountOutForRoute(this.publicClient, this.chainId, tokenIn, tokenOut, amountIn, route);
+    }
+}
+export async function getAmountOutForRoute(publicClient, chainId, tokenIn, tokenOut, amountIn, route) {
+    const routerRoutes = encodeRoutePath(route.path, tokenIn, tokenOut);
+    const routerAddress = getContractAddress(chainId, 'Router');
+    try {
+        const amounts = (await publicClient.readContract({
+            address: routerAddress,
+            abi: ROUTER_ABI,
+            functionName: 'getAmountsOut',
+            args: [amountIn, routerRoutes],
+        }));
+        return amounts[amounts.length - 1];
+    }
+    catch (error) {
+        if (error instanceof BaseError) {
+            const revertError = error.walk((candidate) => candidate instanceof ContractFunctionRevertedError);
+            if (revertError instanceof ContractFunctionRevertedError &&
+                revertError.data?.errorName === 'FXMarketClosed') {
+                throw new FXMarketClosedError();
             }
-            throw error;
         }
+        throw error;
     }
 }