@mento-protocol/mento-sdk 3.2.7 → 3.3.0-beta.0

package/dist/services/liquidity/zapOut.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildZapOutTransactionInternal = buildZapOutTransactionInternal;
+exports.buildZapOutParamsInternal = buildZapOutParamsInternal;
+exports.quoteZapOutInternal = quoteZapOutInternal;
+exports.prepareZapOutInternal = prepareZapOutInternal;
+const abis_1 = require("../../core/abis");
+const constants_1 = require("../../core/constants");
+const errors_1 = require("../../core/errors");
+const validation_1 = require("../../utils/validation");
+const pathEncoder_1 = require("../../utils/pathEncoder");
+const liquidityHelpers_1 = require("./liquidityHelpers");
+const zapHelpers_1 = require("./zapHelpers");
+const INSUFFICIENT_LIQUIDITY_SELECTOR = '0xbb55fd27';
+const MAX_ROUTE_CANDIDATES_PER_LEG = 8;
+const MAX_ROUTE_COMBINATIONS = 48;
+const ROUTE_SIMULATION_BATCH_SIZE = 6;
+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,
+    };
+}
+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;
+}
+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;
+}
+async function prepareZapOutInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenOut, liquidity, recipient, owner, options) {
+    if (owner) {
+        (0, validation_1.validateAddress)(owner, 'owner');
+    }
+    const [context, currentAllowance] = await Promise.all([
+        prepareZapOutContextInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenOut, liquidity, recipient, options),
+        owner ? (0, liquidityHelpers_1.getAllowance)(publicClient, poolAddress, owner, chainId) : Promise.resolve(null),
+    ]);
+    let details = context.details;
+    const approval = owner && currentAllowance !== null && currentAllowance < liquidity
+        ? { token: poolAddress, amount: liquidity, params: (0, liquidityHelpers_1.buildApprovalParams)(chainId, poolAddress, liquidity) }
+        : owner
+            ? null
+            : undefined;
+    if (owner && currentAllowance !== null && currentAllowance >= liquidity) {
+        const ownerAddr = owner;
+        const routerAddress = (0, constants_1.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) {
+    (0, validation_1.validateAddress)(poolAddress, 'poolAddress');
+    (0, validation_1.validateAddress)(tokenOut, 'tokenOut');
+    (0, validation_1.validateAddress)(recipient, 'recipient');
+    const { token0, token1, factoryAddr } = await (0, liquidityHelpers_1.getPoolInfo)(poolService, poolAddress);
+    const { routesA, routesB } = await (0, zapHelpers_1.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 = (0, constants_1.getContractAddress)(chainId, 'Router');
+    const [amountOutMinA, amountOutMinB, amountAMin, amountBMin] = (await publicClient.readContract({
+        address: routerAddress,
+        abi: abis_1.ROUTER_ABI,
+        functionName: 'generateZapOutParams',
+        args: [token0, token1, factoryAddr, liquidity, routesA, routesB],
+    }));
+    const finalAmountAMin = (0, liquidityHelpers_1.calculateMinAmount)(amountAMin, options.slippageTolerance);
+    const finalAmountBMin = (0, liquidityHelpers_1.calculateMinAmount)(amountBMin, options.slippageTolerance);
+    const finalAmountOutMinA = (0, liquidityHelpers_1.calculateMinAmount)(amountOutMinA, options.slippageTolerance);
+    const finalAmountOutMinB = (0, liquidityHelpers_1.calculateMinAmount)(amountOutMinB, options.slippageTolerance);
+    const zapParams = {
+        tokenA: token0,
+        tokenB: token1,
+        factory: factoryAddr,
+        amountAMin: finalAmountAMin,
+        amountBMin: finalAmountBMin,
+        amountOutMinA: finalAmountOutMinA,
+        amountOutMinB: finalAmountOutMinB,
+    };
+    const data = (0, zapHelpers_1.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 (0, liquidityHelpers_1.getPoolInfo)(poolService, poolAddress);
+    const routerAddress = (0, constants_1.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 errors_1.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 errors_1.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 = (0, pathEncoder_1.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 errors_1.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(' | ');
+}
+//# sourceMappingURL=zapOut.js.map

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

@@ -0,0 +1,69 @@
+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

@@ -0,0 +1,209 @@
+"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

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

package/dist/services/pools/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./PoolService"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,13 @@
+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