@mento-protocol/mento-sdk 3.2.2 → 3.2.3

package/dist/services/pools/PoolService.d.ts

@@ -1,69 +0,0 @@
-import { Pool, PoolDetails, PoolRebalancePreview } from '../../core/types';
-import { PublicClient } from 'viem';
-/**
- * Result of pool discovery including any warnings from failed factories
- */
-export interface PoolDiscoveryResult {
-    pools: Pool[];
-    warnings: string[];
-}
-/**
- * Service for discovering liquidity pools in the Mento protocol.
- * Aggregates pools from multiple factory contracts (FPMM and VirtualPool).
- */
-export declare class PoolService {
-    private publicClient;
-    private chainId;
-    private poolsCache;
-    private discoveryWarnings;
-    private poolsPromise;
-    private poolDetailsCache;
-    private poolDetailPromises;
-    constructor(publicClient: PublicClient, chainId: number);
-    /**
-     * Returns any warnings from the last pool discovery operation.
-     * Useful for debugging when some factories fail but others succeed.
-     */
-    getDiscoveryWarnings(): string[];
-    /**
-     * 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`)
-     * ```
-     */
-    getPools(): Promise<Pool[]>;
-    private loadPools;
-    /**
-     * 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)
-     * }
-     * ```
-     */
-    getPoolDetails(poolAddr: string): Promise<PoolDetails>;
-    getPoolRebalancePreview(poolAddr: string): Promise<PoolRebalancePreview | null>;
-    getPoolRebalancePreviewBatch(poolAddresses?: string[]): Promise<Array<PoolRebalancePreview | null>>;
-    getPoolDetailsBatch(poolAddresses?: string[]): Promise<PoolDetails[]>;
-}
-//# sourceMappingURL=PoolService.d.ts.map

package/dist/services/pools/PoolService.js

@@ -1,209 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PoolService = void 0;
-const types_1 = require("../../core/types");
-const poolDiscovery_1 = require("./poolDiscovery");
-const poolDetails_1 = require("./poolDetails");
-const rebalancePreview_1 = require("./rebalancePreview");
-/**
- * Service for discovering liquidity pools in the Mento protocol.
- * Aggregates pools from multiple factory contracts (FPMM and VirtualPool).
- */
-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([
-            (0, poolDiscovery_1.fetchFPMMPools)(this.publicClient, this.chainId),
-            (0, poolDiscovery_1.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 (0, rebalancePreview_1.fetchPoolRebalancePreview)(this.publicClient, details);
-    }
-    async getPoolRebalancePreviewBatch(poolAddresses) {
-        const details = await this.getPoolDetailsBatch(poolAddresses);
-        return (0, rebalancePreview_1.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 === types_1.PoolType.FPMM),
-                virtual: missingTargets.filter(({ pool }) => pool.poolType !== types_1.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([
-                    (0, poolDetails_1.fetchFPMMPoolDetailsBatch)(this.publicClient, this.chainId, grouped.fpmm.map(({ pool }) => pool)),
-                    (0, poolDetails_1.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;
-    }
-}
-exports.PoolService = PoolService;
-function createDeferred() {
-    let resolve;
-    let reject;
-    const promise = new Promise((resolvePromise, rejectPromise) => {
-        resolve = resolvePromise;
-        reject = rejectPromise;
-    });
-    return { promise, resolve, reject };
-}
-//# sourceMappingURL=PoolService.js.map

package/dist/services/pools/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./PoolService";
-//# sourceMappingURL=index.d.ts.map

package/dist/services/pools/poolDetails.d.ts

@@ -1,13 +0,0 @@
-import { Pool, FPMMPoolDetails, VirtualPoolDetails } from '../../core/types';
-import { PublicClient } from 'viem';
-/**
- * Fetches enriched details for an FPMM pool
- */
-export declare function fetchFPMMPoolDetails(publicClient: PublicClient, chainId: number, pool: Pool): Promise<FPMMPoolDetails>;
-export declare function fetchFPMMPoolDetailsBatch(publicClient: PublicClient, chainId: number, pools: Pool[]): Promise<FPMMPoolDetails[]>;
-/**
- * Fetches enriched details for a Virtual pool
- */
-export declare function fetchVirtualPoolDetails(publicClient: PublicClient, pool: Pool): Promise<VirtualPoolDetails>;
-export declare function fetchVirtualPoolDetailsBatch(publicClient: PublicClient, pools: Pool[]): Promise<VirtualPoolDetails[]>;
-//# sourceMappingURL=poolDetails.d.ts.map

package/dist/services/pools/poolDetails.js

@@ -1,216 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchFPMMPoolDetails = fetchFPMMPoolDetails;
-exports.fetchFPMMPoolDetailsBatch = fetchFPMMPoolDetailsBatch;
-exports.fetchVirtualPoolDetails = fetchVirtualPoolDetails;
-exports.fetchVirtualPoolDetailsBatch = fetchVirtualPoolDetailsBatch;
-const constants_1 = require("../../core/constants");
-const abis_1 = require("../../core/abis");
-const viem_1 = require("viem");
-const multicall_1 = require("../../utils/multicall");
-const FPMM_FIXED_RESULT_COUNT = 8;
-const VIRTUAL_RESULT_COUNT = 3;
-/**
- * Fetches enriched details for an FPMM pool
- */
-async function fetchFPMMPoolDetails(publicClient, chainId, pool) {
-    const [details] = await fetchFPMMPoolDetailsBatch(publicClient, chainId, [pool]);
-    return details;
-}
-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 (0, multicall_1.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: abis_1.FPMM_ABI, functionName: 'getReserves' },
-        { address, abi: abis_1.FPMM_ABI, functionName: 'decimals0' },
-        { address, abi: abis_1.FPMM_ABI, functionName: 'decimals1' },
-        { address, abi: abis_1.FPMM_ABI, functionName: 'lpFee' },
-        { address, abi: abis_1.FPMM_ABI, functionName: 'protocolFee' },
-        { address, abi: abis_1.FPMM_ABI, functionName: 'rebalanceIncentive' },
-        { address, abi: abis_1.FPMM_ABI, functionName: 'rebalanceThresholdAbove' },
-        { address, abi: abis_1.FPMM_ABI, functionName: 'rebalanceThresholdBelow' },
-        ...(openLiquidityStrategy
-            ? [{
-                    address,
-                    abi: abis_1.FPMM_ABI,
-                    functionName: 'liquidityStrategy',
-                    args: [openLiquidityStrategy],
-                }]
-            : []),
-        { address, abi: abis_1.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
- */
-async function fetchVirtualPoolDetails(publicClient, pool) {
-    const [details] = await fetchVirtualPoolDetailsBatch(publicClient, [pool]);
-    return details;
-}
-async function fetchVirtualPoolDetailsBatch(publicClient, pools) {
-    if (pools.length === 0) {
-        return [];
-    }
-    const contracts = pools.flatMap((pool) => buildVirtualContracts(pool));
-    const results = await (0, multicall_1.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: abis_1.VIRTUAL_POOL_ABI, functionName: 'getReserves' },
-        { address, abi: abis_1.VIRTUAL_POOL_ABI, functionName: 'protocolFee' },
-        { address, abi: abis_1.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 = (0, constants_1.tryGetContractAddress)(chainId, 'OpenLiquidityStrategy');
-    if (!strategyAddress)
-        return null;
-    try {
-        return (0, viem_1.getAddress)(strategyAddress);
-    }
-    catch {
-        return null;
-    }
-}
-//# sourceMappingURL=poolDetails.js.map

package/dist/services/pools/poolDiscovery.d.ts

@@ -1,12 +0,0 @@
-import { Pool } from '../../core/types';
-import { PublicClient } from 'viem';
-/**
- * Fetches all FPMM pools from the FPMM Factory
- */
-export declare function fetchFPMMPools(publicClient: PublicClient, chainId: number): Promise<Pool[]>;
-/**
- * Fetches all active Virtual pools from the VirtualPoolFactory,
- * then resolves token pairs and exchange IDs from each pool and BiPoolManager.
- */
-export declare function fetchVirtualPools(publicClient: PublicClient, chainId: number): Promise<Pool[]>;
-//# sourceMappingURL=poolDiscovery.d.ts.map

package/dist/services/pools/poolDiscovery.js

@@ -1,117 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fetchFPMMPools = fetchFPMMPools;
-exports.fetchVirtualPools = fetchVirtualPools;
-const constants_1 = require("../../core/constants");
-const types_1 = require("../../core/types");
-const abis_1 = require("../../core/abis");
-const sortUtils_1 = require("../../utils/sortUtils");
-const multicall_1 = require("../../utils/multicall");
-/**
- * Fetches all FPMM pools from the FPMM Factory
- */
-async function fetchFPMMPools(publicClient, chainId) {
-    const fpmmFactoryAddress = (0, constants_1.tryGetContractAddress)(chainId, 'FPMMFactory');
-    if (!fpmmFactoryAddress) {
-        return [];
-    }
-    try {
-        // Get all deployed FPMM pool addresses
-        const poolAddresses = (await publicClient.readContract({
-            address: fpmmFactoryAddress,
-            abi: abis_1.FPMM_FACTORY_ABI,
-            functionName: 'deployedFPMMAddresses',
-        }));
-        if (poolAddresses.length === 0) {
-            return [];
-        }
-        // Batch all token0/token1 reads into a single multicall
-        const contracts = poolAddresses.flatMap((poolAddress) => [
-            { address: poolAddress, abi: abis_1.FPMM_ABI, functionName: 'token0' },
-            { address: poolAddress, abi: abis_1.FPMM_ABI, functionName: 'token1' },
-        ]);
-        const results = await (0, multicall_1.multicall)(publicClient, contracts);
-        return poolAddresses.map((poolAddress, i) => {
-            const token0Result = results[i * 2];
-            const token1Result = results[i * 2 + 1];
-            if (token0Result.status === 'failure' || token1Result.status === 'failure') {
-                throw new Error(`Failed to read token addresses for pool ${poolAddress}`);
-            }
-            return {
-                factoryAddr: fpmmFactoryAddress,
-                poolAddr: poolAddress,
-                token0: token0Result.result,
-                token1: token1Result.result,
-                poolType: types_1.PoolType.FPMM,
-            };
-        });
-    }
-    catch (error) {
-        throw new Error(`Failed to fetch FPMM pools: ${error.message}`);
-    }
-}
-/**
- * Fetches all active Virtual pools from the VirtualPoolFactory,
- * then resolves token pairs and exchange IDs from each pool and BiPoolManager.
- */
-async function fetchVirtualPools(publicClient, chainId) {
-    const virtualPoolFactoryAddress = (0, constants_1.tryGetContractAddress)(chainId, 'VirtualPoolFactory');
-    const biPoolManagerAddress = (0, constants_1.tryGetContractAddress)(chainId, 'BiPoolManager');
-    if (!virtualPoolFactoryAddress || !biPoolManagerAddress) {
-        return [];
-    }
-    try {
-        // Fetch active pool addresses and all exchanges in parallel
-        const [poolAddresses, exchangesData] = await Promise.all([
-            publicClient.readContract({
-                address: virtualPoolFactoryAddress,
-                abi: abis_1.VIRTUAL_POOL_FACTORY_ABI,
-                functionName: 'getAllPools',
-            }),
-            publicClient.readContract({
-                address: biPoolManagerAddress,
-                abi: abis_1.BIPOOL_MANAGER_ABI,
-                functionName: 'getExchanges',
-            }),
-        ]);
-        if (poolAddresses.length === 0) {
-            return [];
-        }
-        // Build a lookup from sorted token pair to exchangeId
-        const tokenPairToExchangeId = new Map();
-        for (const exchange of exchangesData) {
-            if (exchange.assets.length === 2) {
-                const [t0, t1] = (0, sortUtils_1.sortTokenAddresses)(exchange.assets[0], exchange.assets[1]);
-                tokenPairToExchangeId.set(`${t0}:${t1}`, exchange.exchangeId);
-            }
-        }
-        // Batch all tokens() reads into a single multicall
-        const contracts = poolAddresses.map((poolAddress) => ({
-            address: poolAddress,
-            abi: abis_1.VIRTUAL_POOL_ABI,
-            functionName: 'tokens',
-        }));
-        const results = await (0, multicall_1.multicall)(publicClient, contracts);
-        return poolAddresses.map((poolAddress, i) => {
-            const result = results[i];
-            if (result.status === 'failure') {
-                throw new Error(`Failed to read token addresses for virtual pool ${poolAddress}`);
-            }
-            const [token0, token1] = result.result;
-            const [sorted0, sorted1] = (0, sortUtils_1.sortTokenAddresses)(token0, token1);
-            const exchangeId = tokenPairToExchangeId.get(`${sorted0}:${sorted1}`);
-            return {
-                factoryAddr: virtualPoolFactoryAddress,
-                poolAddr: poolAddress,
-                token0: sorted0,
-                token1: sorted1,
-                poolType: types_1.PoolType.Virtual,
-                exchangeId,
-            };
-        });
-    }
-    catch (error) {
-        throw new Error(`Failed to fetch Virtual pools: ${error.message}`);
-    }
-}
-//# sourceMappingURL=poolDiscovery.js.map

package/dist/services/pools/rebalancePreview.d.ts

@@ -1,5 +0,0 @@
-import { type PublicClient } from 'viem';
-import type { PoolDetails, PoolRebalancePreview } from '../../core/types';
-export declare function fetchPoolRebalancePreview(publicClient: PublicClient, detail: PoolDetails): Promise<PoolRebalancePreview | null>;
-export declare function fetchPoolRebalancePreviewBatch(publicClient: PublicClient, details: PoolDetails[]): Promise<Array<PoolRebalancePreview | null>>;
-//# sourceMappingURL=rebalancePreview.d.ts.map