@mento-protocol/mento-sdk 3.2.7 → 3.2.8

package/dist/services/liquidity/rebalance.js

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

@@ -0,0 +1,100 @@
+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;
+};
+/**
+ * Off-chain mirror of Router.sol's quoteAddLiquidity / _quoteZapLiquidity logic.
+ *
+ * Given desired amounts and pool reserves, returns the (amountA, amountB) the
+ * router will actually deposit when adding liquidity. Used to predict the exact
+ * `amountAMin` / `amountBMin` the contract will check against post-swap reserves.
+ *
+ * @param amountADesired - Desired amount of tokenA
+ * @param amountBDesired - Desired amount of tokenB
+ * @param reserveA - Reserve of tokenA at the moment liquidity is added
+ * @param reserveB - Reserve of tokenB at the moment liquidity is added
+ */
+export declare function quoteAddLiquidityFromReserves(amountADesired: bigint, amountBDesired: bigint, reserveA: bigint, reserveB: bigint): {
+    amountA: bigint;
+    amountB: bigint;
+};
+/**
+ * Computes the net delta a single-hop zap swap applies to a target pool's
+ * reserves. Returns `{delta0, delta1}` to add to the pool's pre-swap reserves
+ * to obtain the reserves the router will see when it runs `_quoteZapLiquidity`.
+ *
+ * Only single-hop routes whose factory matches the target pool's factory and
+ * whose `(from, to)` are `(token0, token1)` (in either direction) are
+ * considered. Multi-hop routes and routes through other pools have no effect
+ * on the target pool's reserves and return `{0, 0}`.
+ *
+ * Note: Multi-hop routes that traverse the target pool as an intermediate hop
+ * are intentionally not handled here — they are uncommon for single-sided zaps
+ * and would require per-hop amounts from `getAmountsOut`.
+ */
+export declare function computeTargetPoolImpact(routes: RouterRoute[], amountIn: bigint, amountOut: bigint, token0: Address, token1: Address, factoryAddr: Address): {
+    delta0: bigint;
+    delta1: 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

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeZapInCall = encodeZapInCall;
+exports.encodeZapOutCall = encodeZapOutCall;
+exports.findZapInRoutes = findZapInRoutes;
+exports.findZapOutRoutes = findZapOutRoutes;
+exports.splitAmount = splitAmount;
+exports.quoteAddLiquidityFromReserves = quoteAddLiquidityFromReserves;
+exports.computeTargetPoolImpact = computeTargetPoolImpact;
+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 };
+}
+/**
+ * Off-chain mirror of Router.sol's quoteAddLiquidity / _quoteZapLiquidity logic.
+ *
+ * Given desired amounts and pool reserves, returns the (amountA, amountB) the
+ * router will actually deposit when adding liquidity. Used to predict the exact
+ * `amountAMin` / `amountBMin` the contract will check against post-swap reserves.
+ *
+ * @param amountADesired - Desired amount of tokenA
+ * @param amountBDesired - Desired amount of tokenB
+ * @param reserveA - Reserve of tokenA at the moment liquidity is added
+ * @param reserveB - Reserve of tokenB at the moment liquidity is added
+ */
+function quoteAddLiquidityFromReserves(amountADesired, amountBDesired, reserveA, reserveB) {
+    if (reserveA === 0n && reserveB === 0n) {
+        return { amountA: amountADesired, amountB: amountBDesired };
+    }
+    if (reserveA === 0n || reserveB === 0n) {
+        // Mirrors Router.sol's InsufficientLiquidity revert. Caller can fall back.
+        return { amountA: 0n, amountB: 0n };
+    }
+    const amountBOptimal = (amountADesired * reserveB) / reserveA;
+    if (amountBOptimal <= amountBDesired) {
+        return { amountA: amountADesired, amountB: amountBOptimal };
+    }
+    const amountAOptimal = (amountBDesired * reserveA) / reserveB;
+    return { amountA: amountAOptimal, amountB: amountBDesired };
+}
+/**
+ * Computes the net delta a single-hop zap swap applies to a target pool's
+ * reserves. Returns `{delta0, delta1}` to add to the pool's pre-swap reserves
+ * to obtain the reserves the router will see when it runs `_quoteZapLiquidity`.
+ *
+ * Only single-hop routes whose factory matches the target pool's factory and
+ * whose `(from, to)` are `(token0, token1)` (in either direction) are
+ * considered. Multi-hop routes and routes through other pools have no effect
+ * on the target pool's reserves and return `{0, 0}`.
+ *
+ * Note: Multi-hop routes that traverse the target pool as an intermediate hop
+ * are intentionally not handled here — they are uncommon for single-sided zaps
+ * and would require per-hop amounts from `getAmountsOut`.
+ */
+function computeTargetPoolImpact(routes, amountIn, amountOut, token0, token1, factoryAddr) {
+    if (routes.length !== 1) {
+        return { delta0: 0n, delta1: 0n };
+    }
+    const route = routes[0];
+    if (route.factory.toLowerCase() !== factoryAddr.toLowerCase()) {
+        return { delta0: 0n, delta1: 0n };
+    }
+    const fromLower = route.from.toLowerCase();
+    const toLower = route.to.toLowerCase();
+    const t0 = token0.toLowerCase();
+    const t1 = token1.toLowerCase();
+    if (fromLower === t0 && toLower === t1) {
+        return { delta0: amountIn, delta1: -amountOut };
+    }
+    if (fromLower === t1 && toLower === t0) {
+        return { delta0: -amountOut, delta1: amountIn };
+    }
+    return { delta0: 0n, delta1: 0n };
+}
+/**
+ * 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

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

@@ -0,0 +1,138 @@
+"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],
+    }));
+    // Re-quote amountAMin / amountBMin against POST-swap reserves.
+    //
+    // `generateZapInParams` calls `quoteAddLiquidity` with the pool's *current*
+    // reserves, but on-chain `_quoteZapLiquidity` runs *after* the zap's internal
+    // swap, which moves the same pool when tokenIn is one of the pool tokens.
+    // Applying user slippage on top of a pre-swap minimum makes the contract
+    // reject any non-trivial amount because the deterministic price impact of
+    // the swap alone exceeds the slippage budget. Predict the post-swap reserves
+    // and re-derive the minimums so that user slippage only covers real drift
+    // between quote-time and execution.
+    const impactA = (0, zapHelpers_1.computeTargetPoolImpact)(routesA, amountInA, amountOutMinA, token0, token1, factoryAddr);
+    const impactB = (0, zapHelpers_1.computeTargetPoolImpact)(routesB, amountInB, amountOutMinB, token0, token1, factoryAddr);
+    const projectedReserveA = poolSnapshot.reserve0 + impactA.delta0 + impactB.delta0;
+    const projectedReserveB = poolSnapshot.reserve1 + impactA.delta1 + impactB.delta1;
+    const useReserveA = projectedReserveA > 0n ? projectedReserveA : poolSnapshot.reserve0;
+    const useReserveB = projectedReserveB > 0n ? projectedReserveB : poolSnapshot.reserve1;
+    const projected = (0, zapHelpers_1.quoteAddLiquidityFromReserves)(amountOutMinA, amountOutMinB, useReserveA, useReserveB);
+    const baselineAmountAMin = projected.amountA > 0n ? projected.amountA : amountAMin;
+    const baselineAmountBMin = projected.amountB > 0n ? projected.amountB : amountBMin;
+    const finalAmountAMin = (0, liquidityHelpers_1.calculateMinAmount)(baselineAmountAMin, options.slippageTolerance);
+    const finalAmountBMin = (0, liquidityHelpers_1.calculateMinAmount)(baselineAmountBMin, 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

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