@mento-protocol/mento-sdk 3.2.2 → 3.2.3

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

@@ -1,248 +0,0 @@
-import { ROUTER_ABI } from '../../core/abis';
-import { getContractAddress } from '../../core/constants';
-import { RouteNotFoundError, ZapOutRouteNotViableError } from '../../core/errors';
-import { validateAddress } from '../../utils/validation';
-import { encodeRoutePath } from '../../utils/pathEncoder';
-import { buildApprovalParams, getAllowance, calculateMinAmount, getPoolInfo } from './liquidityHelpers';
-import { encodeZapOutCall, findZapOutRoutes } from './zapHelpers';
-const INSUFFICIENT_LIQUIDITY_SELECTOR = '0xbb55fd27';
-const MAX_ROUTE_CANDIDATES_PER_LEG = 8;
-const MAX_ROUTE_COMBINATIONS = 48;
-const ROUTE_SIMULATION_BATCH_SIZE = 6;
-export async function buildZapOutTransactionInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenOut, liquidity, recipient, owner, options) {
-    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, details.params.data);
-        }
-        catch (error) {
-            if (!isInsufficientLiquidityError(error)) {
-                throw error;
-            }
-            details = await findViableZapOutDetails(publicClient, chainId, poolService, routeService, poolAddress, tokenOut, liquidity, ownerAddr, options);
-        }
-    }
-    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,
-    };
-}
-async function prepareZapOutContextInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenOut, liquidity, recipient, options) {
-    validateAddress(poolAddress, 'poolAddress');
-    validateAddress(tokenOut, 'tokenOut');
-    validateAddress(recipient, 'recipient');
-    const { token0, token1, factoryAddr } = await getPoolInfo(poolService, poolAddress);
-    const { routesA, routesB } = await findZapOutRoutes(routeService, token0, token1, tokenOut);
-    const details = await buildZapOutDetailsForRoutes(publicClient, chainId, poolAddress, tokenOut, liquidity, token0, token1, factoryAddr, routesA, routesB, options);
-    return {
-        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) {
-    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 finalAmountAMin = calculateMinAmount(amountAMin, options.slippageTolerance);
-    const finalAmountBMin = calculateMinAmount(amountBMin, options.slippageTolerance);
-    const finalAmountOutMinA = calculateMinAmount(amountOutMinA, options.slippageTolerance);
-    const finalAmountOutMinB = calculateMinAmount(amountOutMinB, options.slippageTolerance);
-    const zapParams = {
-        tokenA: token0,
-        tokenB: token1,
-        factory: factoryAddr,
-        amountAMin: finalAmountAMin,
-        amountBMin: finalAmountBMin,
-        amountOutMinA: finalAmountOutMinA,
-        amountOutMinB: finalAmountOutMinB,
-    };
-    const data = encodeZapOutCall(tokenOut, liquidity, zapParams, routesA, routesB);
-    return {
-        params: {
-            to: routerAddress,
-            data,
-            value: '0',
-        },
-        poolAddress,
-        tokenOut,
-        liquidity,
-        routesA,
-        routesB,
-        zapParams,
-        estimatedMinTokenOut: finalAmountOutMinA + finalAmountOutMinB,
-    };
-}
-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 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) {
-            routeCombinations.push({ routesA, routesB });
-            if (routeCombinations.length >= MAX_ROUTE_COMBINATIONS) {
-                break outer;
-            }
-        }
-    }
-    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);
-                return candidate;
-            }
-            catch {
-                return null;
-            }
-        }));
-        for (const candidate of candidates) {
-            if (candidate && (!best || candidate.estimatedMinTokenOut > best.estimatedMinTokenOut)) {
-                best = candidate;
-            }
-        }
-    }
-    if (!best) {
-        throw new ZapOutRouteNotViableError(poolAddress, tokenOut);
-    }
-    return best;
-}
-async function getEncodedRouteCandidates(routeService, tokenIn, tokenOut, sourcePoolAddress, allRoutes) {
-    if (tokenIn.toLowerCase() === tokenOut.toLowerCase()) {
-        return [[]];
-    }
-    const rawCandidates = [];
-    try {
-        rawCandidates.push(await routeService.findRoute(tokenIn, tokenOut));
-    }
-    catch {
-        // Continue; we'll try the broader route set next.
-    }
-    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();
-        const t1 = tokenOut.toLowerCase();
-        return (a0 === t0 && a1 === t1) || (a0 === t1 && a1 === t0);
-    });
-    rawCandidates.push(...pairCandidates);
-    if (rawCandidates.length === 0) {
-        throw new RouteNotFoundError(tokenIn, tokenOut);
-    }
-    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 = [];
-    const seen = new Set();
-    for (const route of rawCandidates) {
-        try {
-            const encoded = encodeRoutePath(route.path, tokenIn, tokenOut);
-            const key = JSON.stringify(encoded);
-            if (seen.has(key))
-                continue;
-            seen.add(key);
-            encodedRoutes.push(encoded);
-            if (encodedRoutes.length >= MAX_ROUTE_CANDIDATES_PER_LEG) {
-                break;
-            }
-        }
-        catch {
-            // Invalid path encoding for this direction; skip.
-        }
-    }
-    if (encodedRoutes.length === 0) {
-        throw new RouteNotFoundError(tokenIn, tokenOut);
-    }
-    return encodedRoutes;
-}
-function routeUsesPool(route, poolAddress) {
-    const normalizedPool = poolAddress.toLowerCase();
-    return route.path.some((hop) => hop.poolAddr.toLowerCase() === normalizedPool);
-}
-async function simulateZapOut(publicClient, owner, routerAddress, data) {
-    await publicClient.call({
-        account: owner,
-        to: routerAddress,
-        data,
-    });
-}
-function isInsufficientLiquidityError(error) {
-    const message = extractErrorMessage(error).toLowerCase();
-    return (message.includes(INSUFFICIENT_LIQUIDITY_SELECTOR) ||
-        message.includes('insufficientliquidity'));
-}
-function extractErrorMessage(error) {
-    if (!(error instanceof Error)) {
-        return String(error);
-    }
-    const typed = error;
-    const parts = [
-        typed.message,
-        typed.shortMessage,
-        typed.details,
-        typed.cause instanceof Error ? typed.cause.message : undefined,
-    ].filter((part) => Boolean(part));
-    return parts.join(' | ');
-}

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

@@ -1,204 +0,0 @@
-import { PoolType } from '../../core/types';
-import { fetchFPMMPools, fetchVirtualPools } from './poolDiscovery';
-import { fetchFPMMPoolDetailsBatch, fetchVirtualPoolDetailsBatch, } from './poolDetails';
-import { fetchPoolRebalancePreview, fetchPoolRebalancePreviewBatch, } from './rebalancePreview';
-/**
- * Service for discovering liquidity pools in the Mento protocol.
- * Aggregates pools from multiple factory contracts (FPMM and VirtualPool).
- */
-export class PoolService {
-    constructor(publicClient, chainId) {
-        this.publicClient = publicClient;
-        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.
-     * Useful for debugging when some factories fail but others succeed.
-     */
-    getDiscoveryWarnings() {
-        return [...this.discoveryWarnings];
-    }
-    /**
-     * Fetches all pools available in the protocol from both FPMM and Virtual pool factories
-     * Results are cached in memory for the service instance lifetime
-     *
-     * @returns Array of all pools available in the protocol
-     * @throws {Error} If no pools can be discovered from any factory
-     *
-     * @example
-     * ```typescript
-     * const pools = await poolService.getPools()
-     * console.log(`Found ${pools.length} pools`)
-     * ```
-     */
-    async getPools() {
-        if (this.poolsCache) {
-            return this.poolsCache;
-        }
-        if (this.poolsPromise) {
-            return this.poolsPromise;
-        }
-        this.poolsPromise = this.loadPools();
-        try {
-            return await this.poolsPromise;
-        }
-        finally {
-            this.poolsPromise = null;
-        }
-    }
-    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);
-        }
-        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
-        if (pools.length === 0) {
-            throw new Error('Failed to discover any pools from any factory. ' +
-                'All pool factory queries failed. Check network connectivity and RPC endpoint.');
-        }
-        this.poolsCache = pools;
-        return pools;
-    }
-    /**
-     * Fetches enriched on-chain details for a specific pool by address.
-     * Resolves the pool type from the discovery cache, then fetches
-     * pool-type-specific data (pricing, fees, rebalancing for FPMM; reserves and spread for Virtual).
-     *
-     * @param poolAddr - The deployed pool contract address
-     * @returns Enriched pool details (FPMMPoolDetails or VirtualPoolDetails)
-     * @throws {Error} If the pool address is not found in any known factory
-     * @throws {Error} If on-chain calls fail
-     *
-     * @example
-     * ```typescript
-     * const details = await poolService.getPoolDetails('0x...')
-     * if (details.poolType === 'FPMM') {
-     *   console.log(details.pricing.oraclePrice)
-     *   console.log(details.rebalancing.inBand)
-     * } else {
-     *   console.log(details.spreadPercent)
-     * }
-     * ```
-     */
-    async getPoolDetails(poolAddr) {
-        const [details] = await this.getPoolDetailsBatch([poolAddr]);
-        return details;
-    }
-    async getPoolRebalancePreview(poolAddr) {
-        const details = await this.getPoolDetails(poolAddr);
-        return fetchPoolRebalancePreview(this.publicClient, details);
-    }
-    async getPoolRebalancePreviewBatch(poolAddresses) {
-        const details = await this.getPoolDetailsBatch(poolAddresses);
-        return fetchPoolRebalancePreviewBatch(this.publicClient, details);
-    }
-    async getPoolDetailsBatch(poolAddresses) {
-        const pools = await this.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 (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/index.js

@@ -1 +0,0 @@
-export * from "./PoolService";

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

@@ -1,209 +0,0 @@
-import { tryGetContractAddress } 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 openLiquidityStrategy = getOpenLiquidityStrategy(chainId);
-    const contracts = pools.flatMap((pool) => buildFPMMContracts(pool, openLiquidityStrategy));
-    const results = await multicall(publicClient, contracts);
-    const strategyCheckCount = openLiquidityStrategy ? 1 : 0;
-    const perPoolResultCount = FPMM_FIXED_RESULT_COUNT + strategyCheckCount + 1;
-    return pools.map((pool, index) => {
-        const offset = index * perPoolResultCount;
-        const poolResults = results.slice(offset, offset + perPoolResultCount);
-        return parseFPMMPoolDetails(pool, openLiquidityStrategy, poolResults);
-    });
-}
-function buildFPMMContracts(pool, openLiquidityStrategy) {
-    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' },
-        ...(openLiquidityStrategy
-            ? [{
-                    address,
-                    abi: FPMM_ABI,
-                    functionName: 'liquidityStrategy',
-                    args: [openLiquidityStrategy],
-                }]
-            : []),
-        { address, abi: FPMM_ABI, functionName: 'getRebalancingState' },
-    ];
-}
-function parseFPMMPoolDetails(pool, openLiquidityStrategy, results) {
-    try {
-        const reservesRes = results[0];
-        const decimals0Res = results[1];
-        const decimals1Res = results[2];
-        const lpFeeRes = results[3];
-        const protocolFeeRes = results[4];
-        const rebalanceIncentiveRes = results[5];
-        const thresholdAboveRes = results[6];
-        const thresholdBelowRes = results[7];
-        if (!reservesRes ||
-            !decimals0Res ||
-            !decimals1Res ||
-            !lpFeeRes ||
-            !protocolFeeRes ||
-            !rebalanceIncentiveRes ||
-            !thresholdAboveRes ||
-            !thresholdBelowRes ||
-            reservesRes.status === 'failure' ||
-            decimals0Res.status === 'failure' ||
-            decimals1Res.status === 'failure' ||
-            lpFeeRes.status === 'failure' ||
-            protocolFeeRes.status === 'failure' ||
-            rebalanceIncentiveRes.status === 'failure' ||
-            thresholdAboveRes.status === 'failure' ||
-            thresholdBelowRes.status === 'failure') {
-            throw new Error('One or more core pool reads failed');
-        }
-        const [reserve0, reserve1, blockTimestampLast] = reservesRes.result;
-        const lpFeeBps = lpFeeRes.result;
-        const protocolFeeBps = protocolFeeRes.result;
-        const rebalanceIncentiveBps = rebalanceIncentiveRes.result;
-        const thresholdAboveBps = thresholdAboveRes.result;
-        const thresholdBelowBps = thresholdBelowRes.result;
-        const strategyCheckCount = openLiquidityStrategy ? 1 : 0;
-        const openStrategyResult = strategyCheckCount > 0 ? results[FPMM_FIXED_RESULT_COUNT] : null;
-        const liquidityStrategy = openLiquidityStrategy &&
-            openStrategyResult?.status === 'success' &&
-            openStrategyResult.result === true
-            ? openLiquidityStrategy
-            : null;
-        const rebalancingRes = results[FPMM_FIXED_RESULT_COUNT + strategyCheckCount];
-        let pricing = null;
-        let inBand = null;
-        if (rebalancingRes?.status === 'success') {
-            const [oraclePriceNum, oraclePriceDen, reservePriceNum, reservePriceDen, reservePriceAboveOraclePrice, rebalanceThreshold, priceDifference,] = rebalancingRes.result;
-            pricing = {
-                oraclePriceNum,
-                oraclePriceDen,
-                oraclePrice: Number(oraclePriceNum) / Number(oraclePriceDen),
-                reservePriceNum,
-                reservePriceDen,
-                reservePrice: Number(reservePriceNum) / Number(reservePriceDen),
-                priceDifferenceBps: priceDifference,
-                priceDifferencePercent: Number(priceDifference) / 100,
-                reservePriceAboveOraclePrice,
-            };
-            inBand = priceDifference < BigInt(rebalanceThreshold);
-        }
-        return {
-            ...pool,
-            poolType: 'FPMM',
-            scalingFactor0: decimals0Res.result,
-            scalingFactor1: decimals1Res.result,
-            reserve0,
-            reserve1,
-            blockTimestampLast,
-            pricing,
-            fees: {
-                lpFeeBps,
-                lpFeePercent: Number(lpFeeBps) / 100,
-                protocolFeeBps,
-                protocolFeePercent: Number(protocolFeeBps) / 100,
-                totalFeePercent: (Number(lpFeeBps) + Number(protocolFeeBps)) / 100,
-            },
-            rebalancing: {
-                rebalanceIncentiveBps,
-                rebalanceIncentivePercent: Number(rebalanceIncentiveBps) / 100,
-                rebalanceThresholdAboveBps: thresholdAboveBps,
-                rebalanceThresholdAbovePercent: Number(thresholdAboveBps) / 100,
-                rebalanceThresholdBelowBps: thresholdBelowBps,
-                rebalanceThresholdBelowPercent: Number(thresholdBelowBps) / 100,
-                inBand,
-                liquidityStrategy,
-            },
-        };
-    }
-    catch (error) {
-        throw new Error(`Failed to fetch FPMM pool details for ${pool.poolAddr}: ${error.message}`);
-    }
-}
-/**
- * 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 {
-        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;
-        const [dec0, dec1] = results[2].result;
-        const spreadBps = results[1].result;
-        return {
-            ...pool,
-            poolType: 'Virtual',
-            scalingFactor0: dec0,
-            scalingFactor1: dec1,
-            reserve0,
-            reserve1,
-            blockTimestampLast,
-            spreadBps,
-            spreadPercent: Number(spreadBps) / 100,
-        };
-    }
-    catch (error) {
-        throw new Error(`Failed to fetch Virtual pool details for ${pool.poolAddr}: ${error.message}`);
-    }
-}
-/**
- * Returns the configured Open Liquidity Strategy for the given chain.
- */
-function getOpenLiquidityStrategy(chainId) {
-    const strategyAddress = tryGetContractAddress(chainId, 'OpenLiquidityStrategy');
-    if (!strategyAddress)
-        return null;
-    try {
-        return getAddress(strategyAddress);
-    }
-    catch {
-        return null;
-    }
-}