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

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

@@ -1,162 +0,0 @@
-import { encodeFunctionData } from 'viem';
-import { ROUTER_ABI, ERC20_ABI } from '../../core/abis';
-import { getContractAddress } from '../../core/constants';
-import { validateAddress } from '../../utils/validation';
-import { buildApprovalParams, getAllowance, calculateMinAmount, getPoolInfo, validatePoolTokens } from './liquidityHelpers';
-function encodeAddLiquidityCall(tokenA, tokenB, amountADesired, amountBDesired, amountAMin, amountBMin, recipient, deadline) {
-    return encodeFunctionData({
-        abi: ROUTER_ABI,
-        functionName: 'addLiquidity',
-        args: [tokenA, tokenB, amountADesired, amountBDesired, amountAMin, amountBMin, recipient, deadline],
-    });
-}
-function encodeRemoveLiquidityCall(token0, token1, liquidity, amount0Min, amount1Min, recipient, deadline) {
-    return encodeFunctionData({
-        abi: ROUTER_ABI,
-        functionName: 'removeLiquidity',
-        args: [token0, token1, liquidity, amount0Min, amount1Min, recipient, deadline],
-    });
-}
-export async function buildAddLiquidityTransactionInternal(publicClient, chainId, poolService, poolAddress, tokenA, amountA, tokenB, amountB, recipient, owner, options) {
-    const addLiquidity = await buildAddLiquidityParamsInternal(publicClient, chainId, poolService, poolAddress, tokenA, amountA, tokenB, amountB, recipient, options);
-    validateAddress(owner, 'owner');
-    const ownerAddr = owner;
-    const tokenAAddr = addLiquidity.tokenA;
-    const tokenBAddr = addLiquidity.tokenB;
-    const [allowanceA, allowanceB] = await Promise.all([
-        getAllowance(publicClient, tokenAAddr, ownerAddr, chainId),
-        getAllowance(publicClient, tokenBAddr, ownerAddr, chainId),
-    ]);
-    const approvalA = allowanceA < amountA
-        ? { token: addLiquidity.tokenA, amount: amountA, params: buildApprovalParams(chainId, tokenAAddr, amountA) }
-        : null;
-    const approvalB = allowanceB < amountB
-        ? { token: addLiquidity.tokenB, amount: amountB, params: buildApprovalParams(chainId, tokenBAddr, amountB) }
-        : null;
-    return { approvalA, approvalB, addLiquidity };
-}
-export async function buildAddLiquidityParamsInternal(publicClient, chainId, poolService, poolAddress, tokenA, amountA, tokenB, amountB, recipient, options) {
-    validateAddress(poolAddress, 'poolAddress');
-    validateAddress(tokenA, 'tokenA');
-    validateAddress(tokenB, 'tokenB');
-    validateAddress(recipient, 'recipient');
-    const { token0, token1, factoryAddr } = await getPoolInfo(poolService, poolAddress);
-    validatePoolTokens(token0, token1, tokenA, tokenB);
-    const quote = await quoteAddLiquidityInternal(publicClient, chainId, poolService, poolAddress, tokenA, amountA, tokenB, amountB);
-    const amountAMin = calculateMinAmount(quote.amountA, options.slippageTolerance);
-    const amountBMin = calculateMinAmount(quote.amountB, options.slippageTolerance);
-    const routerAddress = getContractAddress(chainId, 'Router');
-    const data = encodeAddLiquidityCall(tokenA, tokenB, amountA, amountB, amountAMin, amountBMin, recipient, options.deadline);
-    return {
-        params: {
-            to: routerAddress,
-            data,
-            value: '0',
-        },
-        poolAddress,
-        token0,
-        token1,
-        tokenA,
-        tokenB,
-        amountADesired: amountA,
-        amountBDesired: amountB,
-        amountAMin,
-        amountBMin,
-        estimatedMinLiquidity: quote.liquidity,
-        deadline: options.deadline,
-    };
-}
-export async function quoteAddLiquidityInternal(publicClient, chainId, poolService, poolAddress, tokenA, amountA, tokenB, amountB) {
-    validateAddress(poolAddress, 'poolAddress');
-    validateAddress(tokenA, 'tokenA');
-    validateAddress(tokenB, 'tokenB');
-    const { token0, token1, factoryAddr } = await getPoolInfo(poolService, poolAddress);
-    validatePoolTokens(token0, token1, tokenA, tokenB);
-    const routerAddress = getContractAddress(chainId, 'Router');
-    const [resultAmountA, resultAmountB, liquidity] = (await publicClient.readContract({
-        address: routerAddress,
-        abi: ROUTER_ABI,
-        functionName: 'quoteAddLiquidity',
-        args: [tokenA, tokenB, factoryAddr, amountA, amountB],
-    }));
-    return { amountA: resultAmountA, amountB: resultAmountB, liquidity };
-}
-export async function buildRemoveLiquidityTransactionInternal(publicClient, chainId, poolService, poolAddress, liquidity, recipient, owner, options) {
-    validateAddress(owner, 'owner');
-    // Build remove liquidity params
-    const removeLiquidity = await buildRemoveLiquidityParamsInternal(publicClient, chainId, poolService, poolAddress, liquidity, recipient, options);
-    const poolAddr = poolAddress; // Pool address IS the LP token
-    const ownerAddr = owner;
-    const currentAllowance = await getAllowance(publicClient, poolAddr, ownerAddr, chainId);
-    const approval = currentAllowance < liquidity
-        ? { token: poolAddress, amount: liquidity, params: buildApprovalParams(chainId, poolAddr, liquidity) }
-        : null;
-    return { approval, removeLiquidity };
-}
-export async function buildRemoveLiquidityParamsInternal(publicClient, chainId, poolService, poolAddress, liquidity, recipient, options) {
-    validateAddress(poolAddress, 'poolAddress');
-    validateAddress(recipient, 'recipient');
-    const { token0, token1 } = await getPoolInfo(poolService, poolAddress);
-    const quote = await quoteRemoveLiquidityInternal(publicClient, chainId, poolService, poolAddress, liquidity);
-    const amount0Min = calculateMinAmount(quote.amount0, options.slippageTolerance);
-    const amount1Min = calculateMinAmount(quote.amount1, options.slippageTolerance);
-    const routerAddress = getContractAddress(chainId, 'Router');
-    const data = encodeRemoveLiquidityCall(token0, token1, liquidity, amount0Min, amount1Min, recipient, options.deadline);
-    return {
-        params: {
-            to: routerAddress,
-            data,
-            value: '0',
-        },
-        poolAddress,
-        token0,
-        token1,
-        liquidity,
-        amount0Min,
-        amount1Min,
-        expectedAmount0: quote.amount0,
-        expectedAmount1: quote.amount1,
-        deadline: options.deadline,
-    };
-}
-export async function quoteRemoveLiquidityInternal(publicClient, chainId, poolService, poolAddress, liquidity) {
-    validateAddress(poolAddress, 'poolAddress');
-    const { token0, token1, factoryAddr } = await getPoolInfo(poolService, poolAddress);
-    const routerAddress = getContractAddress(chainId, 'Router');
-    const [amount0, amount1] = (await publicClient.readContract({
-        address: routerAddress,
-        abi: ROUTER_ABI,
-        functionName: 'quoteRemoveLiquidity',
-        args: [token0, token1, factoryAddr, liquidity],
-    }));
-    return { amount0, amount1 };
-}
-export async function getLPTokenBalanceInternal(publicClient, poolService, poolAddress, owner) {
-    validateAddress(poolAddress, 'poolAddress');
-    validateAddress(owner, 'owner');
-    const { token0, token1 } = await getPoolInfo(poolService, poolAddress);
-    // Pool address IS the LP token address (FPMM pools are ERC20)
-    const [balance, totalSupply] = await Promise.all([
-        publicClient.readContract({
-            address: poolAddress,
-            abi: ERC20_ABI,
-            functionName: 'balanceOf',
-            args: [owner],
-        }),
-        publicClient.readContract({
-            address: poolAddress,
-            abi: ERC20_ABI,
-            functionName: 'totalSupply',
-            args: [],
-        }),
-    ]);
-    const sharePercent = totalSupply > 0n ? Number((balance * 10000n) / totalSupply) / 100 : 0;
-    return {
-        poolAddress,
-        balance,
-        token0,
-        token1,
-        totalSupply,
-        sharePercent,
-    };
-}

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

@@ -1 +0,0 @@
-export * from './LiquidityService';

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

@@ -1,95 +0,0 @@
-import { encodeFunctionData } from 'viem';
-import { PoolType } from '../../core/types';
-import { ERC20_ABI, FPMM_ABI } from '../../core/abis';
-import { getContractAddress } from '../../core/constants';
-import { validateAddress } from '../../utils/validation';
-import { multicall } from '../../utils/multicall';
-function getApprovalSpender(chainId, spender) {
-    return spender ?? getContractAddress(chainId, 'Router');
-}
-export function buildApprovalParams(chainId, token, amount, spender) {
-    const approvalSpender = getApprovalSpender(chainId, spender);
-    const data = encodeFunctionData({
-        abi: ERC20_ABI,
-        functionName: 'approve',
-        args: [approvalSpender, amount],
-    });
-    return { to: token, data, value: '0' };
-}
-export async function getAllowance(publicClient, token, owner, chainId, spender) {
-    const approvalSpender = getApprovalSpender(chainId, spender);
-    return (await publicClient.readContract({
-        address: token,
-        abi: ERC20_ABI,
-        functionName: 'allowance',
-        args: [owner, approvalSpender],
-    }));
-}
-export function calculateMinAmount(amount, slippageTolerance) {
-    if (slippageTolerance < 0) {
-        throw new Error('Slippage tolerance cannot be negative');
-    }
-    if (slippageTolerance > 100) {
-        throw new Error('Slippage tolerance cannot exceed 100%');
-    }
-    const basisPoints = BigInt(Math.floor(slippageTolerance * 100));
-    const slippageMultiplier = 10000n - basisPoints;
-    return (amount * slippageMultiplier) / 10000n;
-}
-export async function getPoolInfo(poolService, poolAddress) {
-    validateAddress(poolAddress, 'poolAddress');
-    const pools = await poolService.getPools();
-    const pool = pools.find((p) => p.poolAddr.toLowerCase() === poolAddress.toLowerCase());
-    if (!pool) {
-        throw new Error(`Pool not found: ${poolAddress}. Ensure the address is a valid FPMM pool.`);
-    }
-    if (pool.poolType !== PoolType.FPMM) {
-        throw new Error(`Pool ${poolAddress} is type ${pool.poolType}. Only FPMM pools support liquidity provision.`);
-    }
-    return {
-        token0: pool.token0,
-        token1: pool.token1,
-        factoryAddr: pool.factoryAddr,
-    };
-}
-export function validatePoolTokens(poolToken0, poolToken1, tokenA, tokenB) {
-    const tokenALower = tokenA.toLowerCase();
-    const tokenBLower = tokenB.toLowerCase();
-    const token0Lower = poolToken0.toLowerCase();
-    const token1Lower = poolToken1.toLowerCase();
-    // Ensure both tokens belong to pool
-    const aInPool = tokenALower === token0Lower || tokenALower === token1Lower;
-    const bInPool = tokenBLower === token0Lower || tokenBLower === token1Lower;
-    if (!aInPool || !bInPool) {
-        throw new Error(`Tokens don't match pool. Pool has ${poolToken0} and ${poolToken1}, but received ${tokenA} and ${tokenB}`);
-    }
-    // Ensure tokens are different
-    if (tokenALower === tokenBLower) {
-        throw new Error('tokenA and tokenB must be different');
-    }
-}
-export async function getPoolSnapshot(publicClient, poolAddress) {
-    const results = await multicall(publicClient, [
-        {
-            address: poolAddress,
-            abi: FPMM_ABI,
-            functionName: 'getReserves',
-        },
-        {
-            address: poolAddress,
-            abi: ERC20_ABI,
-            functionName: 'totalSupply',
-            args: [],
-        },
-    ]);
-    if (results[0].status === 'failure' || results[1].status === 'failure') {
-        throw new Error(`Failed to fetch pool snapshot for ${poolAddress}`);
-    }
-    const [reserve0, reserve1, blockTimestampLast] = results[0].result;
-    return {
-        reserve0,
-        reserve1,
-        blockTimestampLast,
-        totalSupply: results[1].result,
-    };
-}

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

@@ -1,59 +0,0 @@
-import { encodeFunctionData } from 'viem';
-import { LIQUIDITY_STRATEGY_ABI } from '../../core/abis';
-import { validateAddress } from '../../utils/validation';
-import { buildApprovalParams, getAllowance } from './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.`);
-    }
-}
-export async function buildRebalanceParamsInternal(publicClient, chainId, poolService, poolAddress) {
-    validateAddress(poolAddress, 'poolAddress');
-    const preview = await poolService.getPoolRebalancePreview(poolAddress);
-    if (!preview) {
-        throw getRebalanceUnavailableError(poolAddress);
-    }
-    assertRebalanceActionAmounts(poolAddress, preview.amountRequired.amount, preview.amountTransferred.amount);
-    const data = encodeFunctionData({
-        abi: 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,
-    };
-}
-export async function buildRebalanceTransactionInternal(publicClient, chainId, poolService, poolAddress, owner) {
-    validateAddress(owner, 'owner');
-    const rebalance = await buildRebalanceParamsInternal(publicClient, chainId, poolService, poolAddress);
-    const approvalToken = rebalance.approvalToken;
-    const approvalSpender = rebalance.approvalSpender;
-    const currentAllowance = await getAllowance(publicClient, approvalToken, owner, chainId, approvalSpender);
-    const approval = currentAllowance < rebalance.approvalAmount
-        ? {
-            token: rebalance.approvalToken,
-            amount: rebalance.approvalAmount,
-            params: buildApprovalParams(chainId, approvalToken, rebalance.approvalAmount, approvalSpender),
-        }
-        : null;
-    return { approval, rebalance };
-}

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

@@ -1,181 +0,0 @@
-import { encodeFunctionData } from 'viem';
-import { ROUTER_ABI } from '../../core/abis';
-import { encodeRoutePath } from '../../utils/pathEncoder';
-// ========== ENCODING FUNCTIONS ==========
-/**
- * Encodes the zapIn function call for the Router contract
- */
-export function encodeZapInCall(tokenIn, amountInA, amountInB, zapParams, routesA, routesB, recipient) {
-    return encodeFunctionData({
-        abi: ROUTER_ABI,
-        functionName: 'zapIn',
-        args: [tokenIn, amountInA, amountInB, zapParams, routesA, routesB, recipient],
-    });
-}
-/**
- * Encodes the zapOut function call for the Router contract
- */
-export function encodeZapOutCall(tokenOut, liquidity, zapParams, routesA, routesB) {
-    return encodeFunctionData({
-        abi: 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
- */
-export 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 ? encodeRoutePath(routeA.path, tokenIn, token0) : [];
-    const routesB = routeB ? 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
- */
-export 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 ? encodeRoutePath(routeA.path, token0, tokenOut) : [];
-    const routesB = routeB ? 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
- */
-export 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
- */
-export 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`.
- */
-export 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
- */
-export 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;
-}

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

@@ -1,131 +0,0 @@
-import { ROUTER_ABI } from '../../core/abis';
-import { getContractAddress } from '../../core/constants';
-import { validateAddress } from '../../utils/validation';
-import { buildApprovalParams, getAllowance, calculateMinAmount, getPoolInfo, getPoolSnapshot } from './liquidityHelpers';
-import { encodeZapInCall, findZapInRoutes, splitAmount, estimateLiquidityFromZapIn, quoteAddLiquidityFromReserves, computeTargetPoolImpact, } from './zapHelpers';
-// ========== ZAP IN OPERATIONS ==========
-/**
- * Builds a complete zap in transaction including approval if needed
- */
-export 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
- */
-export 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)
- */
-export 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;
-}
-export async function prepareZapInInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenIn, amountIn, amountInSplit, recipient, owner, options) {
-    if (owner) {
-        validateAddress(owner, 'owner');
-    }
-    const [context, currentAllowance] = await Promise.all([
-        prepareZapInContextInternal(publicClient, chainId, poolService, routeService, poolAddress, tokenIn, amountIn, amountInSplit, recipient, options),
-        owner ? getAllowance(publicClient, tokenIn, owner, chainId) : Promise.resolve(null),
-    ]);
-    const approval = owner && currentAllowance !== null && currentAllowance < amountIn
-        ? { token: tokenIn, amount: amountIn, params: 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) {
-    validateAddress(poolAddress, 'poolAddress');
-    validateAddress(tokenIn, 'tokenIn');
-    validateAddress(recipient, 'recipient');
-    const { token0, token1, factoryAddr } = await getPoolInfo(poolService, poolAddress);
-    const { amountA: amountInA, amountB: amountInB } = splitAmount(amountIn, amountInSplit);
-    const [{ routesA, routesB }, poolSnapshot] = await Promise.all([
-        findZapInRoutes(routeService, tokenIn, token0, token1),
-        getPoolSnapshot(publicClient, poolAddress),
-    ]);
-    const routerAddress = getContractAddress(chainId, 'Router');
-    const [amountOutMinA, amountOutMinB, amountAMin, amountBMin] = (await publicClient.readContract({
-        address: routerAddress,
-        abi: 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 = computeTargetPoolImpact(routesA, amountInA, amountOutMinA, token0, token1, factoryAddr);
-    const impactB = 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 = quoteAddLiquidityFromReserves(amountOutMinA, amountOutMinB, useReserveA, useReserveB);
-    const baselineAmountAMin = projected.amountA > 0n ? projected.amountA : amountAMin;
-    const baselineAmountBMin = projected.amountB > 0n ? projected.amountB : amountBMin;
-    const finalAmountAMin = calculateMinAmount(baselineAmountAMin, options.slippageTolerance);
-    const finalAmountBMin = calculateMinAmount(baselineAmountBMin, options.slippageTolerance);
-    const finalAmountOutMinA = calculateMinAmount(amountOutMinA, options.slippageTolerance);
-    const finalAmountOutMinB = calculateMinAmount(amountOutMinB, options.slippageTolerance);
-    const expectedLiquidity = 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 = 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,
-        },
-    };
-}