@mento-protocol/mento-sdk 3.2.6 → 3.2.7

package/dist/services/liquidity/rebalance.js

@@ -1,64 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildRebalanceParamsInternal = buildRebalanceParamsInternal;
-exports.buildRebalanceTransactionInternal = buildRebalanceTransactionInternal;
-const viem_1 = require("viem");
-const abis_1 = require("../../core/abis");
-const validation_1 = require("../../utils/validation");
-const liquidityHelpers_1 = require("./liquidityHelpers");
-function getRebalanceUnavailableError(poolAddress) {
-    return new Error(`Pool ${poolAddress} is not currently rebalanceable or does not have a supported liquidity strategy.`);
-}
-function assertRebalanceActionAmounts(poolAddress, amountRequired, amountTransferred) {
-    if (amountRequired <= 0n || amountTransferred <= 0n) {
-        throw new Error(`Rebalance action for pool ${poolAddress} has zero amounts and cannot be executed.`);
-    }
-}
-async function buildRebalanceParamsInternal(publicClient, chainId, poolService, poolAddress) {
-    (0, validation_1.validateAddress)(poolAddress, 'poolAddress');
-    const preview = await poolService.getPoolRebalancePreview(poolAddress);
-    if (!preview) {
-        throw getRebalanceUnavailableError(poolAddress);
-    }
-    assertRebalanceActionAmounts(poolAddress, preview.amountRequired.amount, preview.amountTransferred.amount);
-    const data = (0, viem_1.encodeFunctionData)({
-        abi: abis_1.LIQUIDITY_STRATEGY_ABI,
-        functionName: 'rebalance',
-        args: [poolAddress],
-    });
-    return {
-        params: {
-            to: preview.strategyAddress,
-            data,
-            value: '0',
-        },
-        poolAddress,
-        strategyAddress: preview.strategyAddress,
-        inputToken: preview.inputToken,
-        outputToken: preview.outputToken,
-        amountRequired: preview.amountRequired.amount,
-        expectedAmountTransferred: preview.amountTransferred.amount,
-        expectedProtocolIncentive: preview.protocolIncentive.amount,
-        expectedLiquiditySourceIncentive: preview.liquiditySourceIncentive.amount,
-        approvalToken: preview.approvalToken,
-        approvalSpender: preview.approvalSpender,
-        approvalAmount: preview.approvalAmount,
-        direction: preview.direction,
-    };
-}
-async function buildRebalanceTransactionInternal(publicClient, chainId, poolService, poolAddress, owner) {
-    (0, validation_1.validateAddress)(owner, 'owner');
-    const rebalance = await buildRebalanceParamsInternal(publicClient, chainId, poolService, poolAddress);
-    const approvalToken = rebalance.approvalToken;
-    const approvalSpender = rebalance.approvalSpender;
-    const currentAllowance = await (0, liquidityHelpers_1.getAllowance)(publicClient, approvalToken, owner, chainId, approvalSpender);
-    const approval = currentAllowance < rebalance.approvalAmount
-        ? {
-            token: rebalance.approvalToken,
-            amount: rebalance.approvalAmount,
-            params: (0, liquidityHelpers_1.buildApprovalParams)(chainId, approvalToken, rebalance.approvalAmount, approvalSpender),
-        }
-        : null;
-    return { approval, rebalance };
-}
-//# sourceMappingURL=rebalance.js.map

package/dist/services/liquidity/zapHelpers.d.ts

@@ -1,66 +0,0 @@
-import { Address } from 'viem';
-import { RouteService } from '../routes';
-import { ZapParams } from '../../core/types';
-import { RouterRoute } from '../../utils/pathEncoder';
-/**
- * Encodes the zapIn function call for the Router contract
- */
-export declare function encodeZapInCall(tokenIn: Address, amountInA: bigint, amountInB: bigint, zapParams: ZapParams, routesA: RouterRoute[], routesB: RouterRoute[], recipient: Address): string;
-/**
- * Encodes the zapOut function call for the Router contract
- */
-export declare function encodeZapOutCall(tokenOut: Address, liquidity: bigint, zapParams: ZapParams, routesA: RouterRoute[], routesB: RouterRoute[]): string;
-/**
- * Finds routes for zap in operations (from tokenIn to both pool tokens)
- *
- * @param routeService - Route service for finding swap paths
- * @param tokenIn - Input token address
- * @param token0 - Pool's token0 address
- * @param token1 - Pool's token1 address
- * @returns Routes from tokenIn to token0 and token1
- */
-export declare function findZapInRoutes(routeService: RouteService, tokenIn: string, token0: string, token1: string): Promise<{
-    routesA: RouterRoute[];
-    routesB: RouterRoute[];
-}>;
-/**
- * Finds routes for zap out operations (from both pool tokens to tokenOut)
- *
- * @param routeService - Route service for finding swap paths
- * @param token0 - Pool's token0 address
- * @param token1 - Pool's token1 address
- * @param tokenOut - Output token address
- * @returns Routes from token0 and token1 to tokenOut
- */
-export declare function findZapOutRoutes(routeService: RouteService, token0: string, token1: string, tokenOut: string): Promise<{
-    routesA: RouterRoute[];
-    routesB: RouterRoute[];
-}>;
-/**
- * Splits an amount into two parts based on a ratio
- *
- * @param amountIn - Total input amount
- * @param splitRatio - Ratio for splitting (0-1, e.g., 0.5 for 50/50)
- * @returns Split amounts for each part
- */
-export declare function splitAmount(amountIn: bigint, splitRatio: number): {
-    amountA: bigint;
-    amountB: bigint;
-};
-/**
- * Estimates minimum LP tokens from zap in amounts.
- *
- * This is a conservative lower-bound estimate. The inputs are slippage-adjusted
- * minimums, not expected amounts. Actual LP tokens minted on-chain may be higher
- * because the router uses balanceOf(address(this)) after swaps, which can exceed
- * the pre-calculated minimums.
- *
- * @param amountOutA - Minimum amount of token0 after swap (slippage-adjusted)
- * @param amountOutB - Minimum amount of token1 after swap (slippage-adjusted)
- * @param reserve0 - Current reserve of token0 in pool
- * @param reserve1 - Current reserve of token1 in pool
- * @param totalSupply - Total LP token supply
- * @returns Conservative estimate of minimum LP tokens to be minted
- */
-export declare function estimateLiquidityFromZapIn(amountOutA: bigint, amountOutB: bigint, reserve0: bigint, reserve1: bigint, totalSupply: bigint): bigint;
-//# sourceMappingURL=zapHelpers.d.ts.map

package/dist/services/liquidity/zapHelpers.js

@@ -1,129 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encodeZapInCall = encodeZapInCall;
-exports.encodeZapOutCall = encodeZapOutCall;
-exports.findZapInRoutes = findZapInRoutes;
-exports.findZapOutRoutes = findZapOutRoutes;
-exports.splitAmount = splitAmount;
-exports.estimateLiquidityFromZapIn = estimateLiquidityFromZapIn;
-const viem_1 = require("viem");
-const abis_1 = require("../../core/abis");
-const pathEncoder_1 = require("../../utils/pathEncoder");
-// ========== ENCODING FUNCTIONS ==========
-/**
- * Encodes the zapIn function call for the Router contract
- */
-function encodeZapInCall(tokenIn, amountInA, amountInB, zapParams, routesA, routesB, recipient) {
-    return (0, viem_1.encodeFunctionData)({
-        abi: abis_1.ROUTER_ABI,
-        functionName: 'zapIn',
-        args: [tokenIn, amountInA, amountInB, zapParams, routesA, routesB, recipient],
-    });
-}
-/**
- * Encodes the zapOut function call for the Router contract
- */
-function encodeZapOutCall(tokenOut, liquidity, zapParams, routesA, routesB) {
-    return (0, viem_1.encodeFunctionData)({
-        abi: abis_1.ROUTER_ABI,
-        functionName: 'zapOut',
-        args: [tokenOut, liquidity, zapParams, routesA, routesB],
-    });
-}
-// ========== ROUTING FUNCTIONS ==========
-/**
- * Finds routes for zap in operations (from tokenIn to both pool tokens)
- *
- * @param routeService - Route service for finding swap paths
- * @param tokenIn - Input token address
- * @param token0 - Pool's token0 address
- * @param token1 - Pool's token1 address
- * @returns Routes from tokenIn to token0 and token1
- */
-async function findZapInRoutes(routeService, tokenIn, token0, token1) {
-    const [routeA, routeB] = await Promise.all([
-        tokenIn.toLowerCase() !== token0.toLowerCase()
-            ? routeService.findRoute(tokenIn, token0)
-            : Promise.resolve(null),
-        tokenIn.toLowerCase() !== token1.toLowerCase()
-            ? routeService.findRoute(tokenIn, token1)
-            : Promise.resolve(null),
-    ]);
-    const routesA = routeA ? (0, pathEncoder_1.encodeRoutePath)(routeA.path, tokenIn, token0) : [];
-    const routesB = routeB ? (0, pathEncoder_1.encodeRoutePath)(routeB.path, tokenIn, token1) : [];
-    return { routesA, routesB };
-}
-/**
- * Finds routes for zap out operations (from both pool tokens to tokenOut)
- *
- * @param routeService - Route service for finding swap paths
- * @param token0 - Pool's token0 address
- * @param token1 - Pool's token1 address
- * @param tokenOut - Output token address
- * @returns Routes from token0 and token1 to tokenOut
- */
-async function findZapOutRoutes(routeService, token0, token1, tokenOut) {
-    const [routeA, routeB] = await Promise.all([
-        token0.toLowerCase() !== tokenOut.toLowerCase()
-            ? routeService.findRoute(token0, tokenOut)
-            : Promise.resolve(null),
-        token1.toLowerCase() !== tokenOut.toLowerCase()
-            ? routeService.findRoute(token1, tokenOut)
-            : Promise.resolve(null),
-    ]);
-    const routesA = routeA ? (0, pathEncoder_1.encodeRoutePath)(routeA.path, token0, tokenOut) : [];
-    const routesB = routeB ? (0, pathEncoder_1.encodeRoutePath)(routeB.path, token1, tokenOut) : [];
-    return { routesA, routesB };
-}
-// ========== CALCULATION FUNCTIONS ==========
-/**
- * Splits an amount into two parts based on a ratio
- *
- * @param amountIn - Total input amount
- * @param splitRatio - Ratio for splitting (0-1, e.g., 0.5 for 50/50)
- * @returns Split amounts for each part
- */
-function splitAmount(amountIn, splitRatio) {
-    if (splitRatio < 0 || splitRatio > 1) {
-        throw new Error('Split ratio must be between 0 and 1');
-    }
-    const amountA = (amountIn * BigInt(Math.floor(splitRatio * 10000))) / 10000n;
-    const amountB = amountIn - amountA;
-    return { amountA, amountB };
-}
-/**
- * Estimates minimum LP tokens from zap in amounts.
- *
- * This is a conservative lower-bound estimate. The inputs are slippage-adjusted
- * minimums, not expected amounts. Actual LP tokens minted on-chain may be higher
- * because the router uses balanceOf(address(this)) after swaps, which can exceed
- * the pre-calculated minimums.
- *
- * @param amountOutA - Minimum amount of token0 after swap (slippage-adjusted)
- * @param amountOutB - Minimum amount of token1 after swap (slippage-adjusted)
- * @param reserve0 - Current reserve of token0 in pool
- * @param reserve1 - Current reserve of token1 in pool
- * @param totalSupply - Total LP token supply
- * @returns Conservative estimate of minimum LP tokens to be minted
- */
-function estimateLiquidityFromZapIn(amountOutA, amountOutB, reserve0, reserve1, totalSupply) {
-    if (totalSupply === 0n) {
-        // First liquidity provision - use geometric mean with BigInt sqrt
-        // to avoid precision loss from Number() conversion on 18-decimal values
-        const product = amountOutA * amountOutB;
-        if (product === 0n)
-            return 0n;
-        let x = product;
-        let y = (x + 1n) / 2n;
-        while (y < x) {
-            x = y;
-            y = (x + product / x) / 2n;
-        }
-        return x;
-    }
-    // Existing pool - calculate based on smaller ratio
-    const liquidityA = (amountOutA * totalSupply) / reserve0;
-    const liquidityB = (amountOutB * totalSupply) / reserve1;
-    return liquidityA < liquidityB ? liquidityA : liquidityB;
-}
-//# sourceMappingURL=zapHelpers.js.map

package/dist/services/liquidity/zapIn.d.ts

@@ -1,18 +0,0 @@
-import { PublicClient } from 'viem';
-import { PoolService } from '../pools';
-import { RouteService } from '../routes';
-import { LiquidityOptions, PreparedZapIn, ZapInQuote, ZapInDetails, ZapInTransaction } from '../../core/types';
-/**
- * Builds a complete zap in transaction including approval if needed
- */
-export declare function buildZapInTransactionInternal(publicClient: PublicClient, chainId: number, poolService: PoolService, routeService: RouteService, poolAddress: string, tokenIn: string, amountIn: bigint, amountInSplit: number, recipient: string, owner: string, options: LiquidityOptions): Promise<ZapInTransaction>;
-/**
- * Builds zap in transaction parameters without checking approval
- */
-export declare function buildZapInParamsInternal(publicClient: PublicClient, chainId: number, poolService: PoolService, routeService: RouteService, poolAddress: string, tokenIn: string, amountIn: bigint, amountInSplit: number, recipient: string, options: LiquidityOptions): Promise<ZapInDetails>;
-/**
- * Quotes a zap in operation (read-only)
- */
-export declare function quoteZapInInternal(publicClient: PublicClient, chainId: number, poolService: PoolService, routeService: RouteService, poolAddress: string, tokenIn: string, amountIn: bigint, amountInSplit: number, options: LiquidityOptions): Promise<ZapInQuote>;
-export declare function prepareZapInInternal(publicClient: PublicClient, chainId: number, poolService: PoolService, routeService: RouteService, poolAddress: string, tokenIn: string, amountIn: bigint, amountInSplit: number, recipient: string, owner: string | undefined, options: LiquidityOptions): Promise<PreparedZapIn>;
-//# sourceMappingURL=zapIn.d.ts.map

package/dist/services/liquidity/zapIn.js

@@ -1,119 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildZapInTransactionInternal = buildZapInTransactionInternal;
-exports.buildZapInParamsInternal = buildZapInParamsInternal;
-exports.quoteZapInInternal = quoteZapInInternal;
-exports.prepareZapInInternal = prepareZapInInternal;
-const abis_1 = require("../../core/abis");
-const constants_1 = require("../../core/constants");
-const validation_1 = require("../../utils/validation");
-const liquidityHelpers_1 = require("./liquidityHelpers");
-const zapHelpers_1 = require("./zapHelpers");
-// ========== ZAP IN OPERATIONS ==========
-/**
- * Builds a complete zap in transaction including approval if needed
- */
-async function buildZapInTransactionInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenIn, amountIn, amountInSplit, recipient, owner, options) {
-    const prepared = await prepareZapInInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenIn, amountIn, amountInSplit, recipient, owner, options);
-    return {
-        approval: prepared.approval ?? null,
-        zapIn: prepared.details,
-    };
-}
-/**
- * Builds zap in transaction parameters without checking approval
- */
-async function buildZapInParamsInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenIn, amountIn, amountInSplit, recipient, options) {
-    const prepared = await prepareZapInInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenIn, amountIn, amountInSplit, recipient, undefined, options);
-    return prepared.details;
-}
-/**
- * Quotes a zap in operation (read-only)
- */
-async function quoteZapInInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenIn, amountIn, amountInSplit, options) {
-    const prepared = await prepareZapInInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenIn, amountIn, amountInSplit, tokenIn, undefined, options);
-    return prepared.quote;
-}
-async function prepareZapInInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenIn, amountIn, amountInSplit, recipient, owner, options) {
-    if (owner) {
-        (0, validation_1.validateAddress)(owner, 'owner');
-    }
-    const [context, currentAllowance] = await Promise.all([
-        prepareZapInContextInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenIn, amountIn, amountInSplit, recipient, options),
-        owner ? (0, liquidityHelpers_1.getAllowance)(publicClient, tokenIn, owner, chainId) : Promise.resolve(null),
-    ]);
-    const approval = owner && currentAllowance !== null && currentAllowance < amountIn
-        ? { token: tokenIn, amount: amountIn, params: (0, liquidityHelpers_1.buildApprovalParams)(chainId, tokenIn, amountIn) }
-        : owner
-            ? null
-            : undefined;
-    return {
-        routesA: context.routesA,
-        routesB: context.routesB,
-        quote: context.quote,
-        approval,
-        details: context.details,
-    };
-}
-async function prepareZapInContextInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenIn, amountIn, amountInSplit, recipient, options) {
-    (0, validation_1.validateAddress)(poolAddress, 'poolAddress');
-    (0, validation_1.validateAddress)(tokenIn, 'tokenIn');
-    (0, validation_1.validateAddress)(recipient, 'recipient');
-    const { token0, token1, factoryAddr } = await (0, liquidityHelpers_1.getPoolInfo)(poolService, poolAddress);
-    const { amountA: amountInA, amountB: amountInB } = (0, zapHelpers_1.splitAmount)(amountIn, amountInSplit);
-    const [{ routesA, routesB }, poolSnapshot] = await Promise.all([
-        (0, zapHelpers_1.findZapInRoutes)(routeService, tokenIn, token0, token1),
-        (0, liquidityHelpers_1.getPoolSnapshot)(publicClient, poolAddress),
-    ]);
-    const routerAddress = (0, constants_1.getContractAddress)(chainId, 'Router');
-    const [amountOutMinA, amountOutMinB, amountAMin, amountBMin] = (await publicClient.readContract({
-        address: routerAddress,
-        abi: abis_1.ROUTER_ABI,
-        functionName: 'generateZapInParams',
-        args: [token0, token1, factoryAddr, amountInA, amountInB, 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 expectedLiquidity = (0, zapHelpers_1.estimateLiquidityFromZapIn)(finalAmountOutMinA, finalAmountOutMinB, poolSnapshot.reserve0, poolSnapshot.reserve1, poolSnapshot.totalSupply);
-    const quote = {
-        amountOutFromA: finalAmountOutMinA,
-        amountOutFromB: finalAmountOutMinB,
-        amountAMin: finalAmountAMin,
-        amountBMin: finalAmountBMin,
-        estimatedMinLiquidity: expectedLiquidity,
-    };
-    const zapParams = {
-        tokenA: token0,
-        tokenB: token1,
-        factory: factoryAddr,
-        amountAMin: finalAmountAMin,
-        amountBMin: finalAmountBMin,
-        amountOutMinA: finalAmountOutMinA,
-        amountOutMinB: finalAmountOutMinB,
-    };
-    const data = (0, zapHelpers_1.encodeZapInCall)(tokenIn, amountInA, amountInB, zapParams, routesA, routesB, recipient);
-    return {
-        routesA,
-        routesB,
-        quote,
-        details: {
-            params: {
-                to: routerAddress,
-                data,
-                value: '0',
-            },
-            poolAddress,
-            tokenIn,
-            amountIn,
-            amountInA,
-            amountInB,
-            routesA,
-            routesB,
-            zapParams,
-            estimatedMinLiquidity: expectedLiquidity,
-        },
-    };
-}
-//# sourceMappingURL=zapIn.js.map

package/dist/services/liquidity/zapOut.d.ts

@@ -1,9 +0,0 @@
-import { PublicClient } from 'viem';
-import { PoolService } from '../pools';
-import { RouteService } from '../routes';
-import { LiquidityOptions, PreparedZapOut, ZapOutQuote, ZapOutDetails, ZapOutTransaction } from '../../core/types';
-export declare function buildZapOutTransactionInternal(publicClient: PublicClient, chainId: number, poolService: PoolService, routeService: RouteService, poolAddress: string, tokenOut: string, liquidity: bigint, recipient: string, owner: string, options: LiquidityOptions): Promise<ZapOutTransaction>;
-export declare function buildZapOutParamsInternal(publicClient: PublicClient, chainId: number, poolService: PoolService, routeService: RouteService, poolAddress: string, tokenOut: string, liquidity: bigint, recipient: string, options: LiquidityOptions): Promise<ZapOutDetails>;
-export declare function quoteZapOutInternal(publicClient: PublicClient, chainId: number, poolService: PoolService, routeService: RouteService, poolAddress: string, tokenOut: string, liquidity: bigint, options: LiquidityOptions): Promise<ZapOutQuote>;
-export declare function prepareZapOutInternal(publicClient: PublicClient, chainId: number, poolService: PoolService, routeService: RouteService, poolAddress: string, tokenOut: string, liquidity: bigint, recipient: string, owner: string | undefined, options: LiquidityOptions): Promise<PreparedZapOut>;
-//# sourceMappingURL=zapOut.d.ts.map

package/dist/services/liquidity/zapOut.js

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