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

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

@@ -1,139 +0,0 @@
-import { PublicClient } from 'viem';
-import { PoolService } from '../pools';
-import { RouteService } from '../routes';
-import { AddLiquidityInput, RemoveLiquidityInput, RebalanceDetails, RebalanceInput, RebalanceTransaction, ZapInInput, ZapOutInput, PrepareZapInInput, PrepareZapOutInput, AddLiquidityQuote, RemoveLiquidityQuote, AddLiquidityDetails, RemoveLiquidityDetails, AddLiquidityTransaction, RemoveLiquidityTransaction, LPTokenBalance, LiquidityOptions, PreparedZapIn, PreparedZapOut, ZapInQuote, ZapOutQuote, ZapInDetails, ZapOutDetails, ZapInTransaction, ZapOutTransaction } from '../../core/types';
-export declare class LiquidityService {
-    private publicClient;
-    private chainId;
-    private poolService;
-    private routeService;
-    constructor(publicClient: PublicClient, chainId: number, poolService: PoolService, routeService: RouteService);
-    /**
-     * Builds add liquidity transaction with token approvals if needed.
-     * Provide two tokens in any order - the Router handles token ordering automatically.
-     * @param input - Add liquidity parameters including owner for allowance checks
-     * @returns Transaction with approvals (if needed) and add liquidity call
-     */
-    buildAddLiquidityTransaction(input: AddLiquidityInput & {
-        owner: string;
-    }): Promise<AddLiquidityTransaction>;
-    /**
-     * Builds add liquidity transaction parameters without checking token approvals.
-     * Use buildAddLiquidityTransaction if you need approval handling.
-     * @param input - Add liquidity parameters
-     * @returns Transaction details with encoded call data
-     */
-    buildAddLiquidityParams(input: AddLiquidityInput): Promise<AddLiquidityDetails>;
-    /**
-     * Builds remove liquidity transaction with LP token approval if needed.
-     * @param input - Remove liquidity parameters including owner for allowance check
-     * @returns Transaction with approval (if needed) and remove liquidity call
-     */
-    buildRemoveLiquidityTransaction(input: RemoveLiquidityInput & {
-        owner: string;
-    }): Promise<RemoveLiquidityTransaction>;
-    /**
-     * Builds remove liquidity transaction parameters without checking LP token approval.
-     * Use buildRemoveLiquidityTransaction if you need approval handling.
-     * @param input - Remove liquidity parameters
-     * @returns Transaction details with encoded call data
-     */
-    buildRemoveLiquidityParams(input: RemoveLiquidityInput): Promise<RemoveLiquidityDetails>;
-    /**
-     * Quotes an add liquidity operation (read-only call).
-     * Returns expected amounts and LP tokens based on current pool reserves.
-     * @param poolAddress - FPMM pool address
-     * @param tokenA - First token address
-     * @param amountA - Amount of first token
-     * @param tokenB - Second token address
-     * @param amountB - Amount of second token
-     * @returns Expected amounts and LP tokens to be minted
-     */
-    quoteAddLiquidity(poolAddress: string, tokenA: string, amountA: bigint, tokenB: string, amountB: bigint): Promise<AddLiquidityQuote>;
-    /**
-     * Quotes a remove liquidity operation (read-only call).
-     * Returns expected token amounts based on current pool reserves.
-     * @param poolAddress - FPMM pool address
-     * @param liquidity - Amount of LP tokens to burn
-     * @returns Expected amounts of token0 and token1
-     */
-    quoteRemoveLiquidity(poolAddress: string, liquidity: bigint): Promise<RemoveLiquidityQuote>;
-    /**
-     * Gets LP token balance and pool share percentage for an address.
-     * @param poolAddress - FPMM pool address (also the LP token address)
-     * @param owner - Address to check balance for
-     * @returns Balance, total supply, and share percentage
-     */
-    getLPTokenBalance(poolAddress: string, owner: string): Promise<LPTokenBalance>;
-    /**
-     * Builds zap in transaction with approval if needed.
-     * Adds liquidity using a single input token - the Router swaps it to both pool tokens automatically.
-     * @param input - Zap in parameters including owner for allowance check
-     * @returns Transaction with approval (if needed) and zap in call
-     */
-    buildZapInTransaction(input: ZapInInput & {
-        owner: string;
-    }): Promise<ZapInTransaction>;
-    /**
-     * Builds zap in transaction parameters without checking approval.
-     * Use buildZapInTransaction if you need approval handling.
-     * @param input - Zap in parameters
-     * @returns Transaction details with encoded call data and routing information
-     */
-    buildZapInParams(input: ZapInInput): Promise<ZapInDetails>;
-    prepareZapIn(input: PrepareZapInInput): Promise<PreparedZapIn>;
-    /**
-     * Builds zap out transaction with approval if needed.
-     * Removes liquidity and swaps both tokens to a single output token.
-     * @param input - Zap out parameters including owner for allowance check
-     * @returns Transaction with approval (if needed) and zap out call
-     */
-    buildZapOutTransaction(input: ZapOutInput & {
-        owner: string;
-    }): Promise<ZapOutTransaction>;
-    /**
-     * Builds zap out transaction parameters without checking approval.
-     * Use buildZapOutTransaction if you need approval handling.
-     * @param input - Zap out parameters
-     * @returns Transaction details with encoded call data and routing information
-     */
-    buildZapOutParams(input: ZapOutInput): Promise<ZapOutDetails>;
-    prepareZapOut(input: PrepareZapOutInput): Promise<PreparedZapOut>;
-    /**
-     * Quotes a zap in operation (read-only call).
-     * Estimates expected LP tokens and minimum amounts after swaps and slippage.
-     * @param poolAddress - FPMM pool address
-     * @param tokenIn - Input token address
-     * @param amountIn - Total input amount
-     * @param amountInSplit - Split ratio (0-1)
-     * @param options - Slippage tolerance and deadline
-     * @returns Expected LP tokens and minimum amounts for both pool tokens
-     */
-    quoteZapIn(poolAddress: string, tokenIn: string, amountIn: bigint, amountInSplit: number, options: LiquidityOptions): Promise<ZapInQuote>;
-    /**
-     * Quotes a zap out operation (read-only call).
-     * Estimates expected output tokens after removing liquidity and swapping.
-     * @param poolAddress - FPMM pool address
-     * @param tokenOut - Output token address
-     * @param liquidity - Amount of LP tokens to burn
-     * @param options - Slippage tolerance and deadline
-     * @returns Expected output amount and minimum amounts after slippage
-     */
-    quoteZapOut(poolAddress: string, tokenOut: string, liquidity: bigint, options: LiquidityOptions): Promise<ZapOutQuote>;
-    /**
-     * Builds rebalance transaction parameters without checking approval.
-     * Use buildRebalanceTransaction if you need approval handling.
-     * @param input - Rebalance parameters
-     * @returns Transaction details with encoded call data
-     */
-    buildRebalanceParams(input: RebalanceInput): Promise<RebalanceDetails>;
-    /**
-     * Builds a rebalance transaction with ERC20 approval if needed.
-     * @param input - Rebalance parameters including owner for allowance checks
-     * @returns Transaction with approval (if needed) and rebalance call
-     */
-    buildRebalanceTransaction(input: RebalanceInput & {
-        owner: string;
-    }): Promise<RebalanceTransaction>;
-}
-//# sourceMappingURL=LiquidityService.d.ts.map

package/dist/services/liquidity/LiquidityService.js

@@ -1,168 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LiquidityService = void 0;
-const basicLiquidity_1 = require("./basicLiquidity");
-const zapIn_1 = require("./zapIn");
-const zapOut_1 = require("./zapOut");
-const rebalance_1 = require("./rebalance");
-class LiquidityService {
-    constructor(publicClient, chainId, poolService, routeService) {
-        this.publicClient = publicClient;
-        this.chainId = chainId;
-        this.poolService = poolService;
-        this.routeService = routeService;
-    }
-    /**
-     * Builds add liquidity transaction with token approvals if needed.
-     * Provide two tokens in any order - the Router handles token ordering automatically.
-     * @param input - Add liquidity parameters including owner for allowance checks
-     * @returns Transaction with approvals (if needed) and add liquidity call
-     */
-    async buildAddLiquidityTransaction(input) {
-        return (0, basicLiquidity_1.buildAddLiquidityTransactionInternal)(this.publicClient, this.chainId, this.poolService, input.poolAddress, input.tokenA, input.amountA, input.tokenB, input.amountB, input.recipient, input.owner, input.options);
-    }
-    /**
-     * Builds add liquidity transaction parameters without checking token approvals.
-     * Use buildAddLiquidityTransaction if you need approval handling.
-     * @param input - Add liquidity parameters
-     * @returns Transaction details with encoded call data
-     */
-    async buildAddLiquidityParams(input) {
-        return (0, basicLiquidity_1.buildAddLiquidityParamsInternal)(this.publicClient, this.chainId, this.poolService, input.poolAddress, input.tokenA, input.amountA, input.tokenB, input.amountB, input.recipient, input.options);
-    }
-    /**
-     * Builds remove liquidity transaction with LP token approval if needed.
-     * @param input - Remove liquidity parameters including owner for allowance check
-     * @returns Transaction with approval (if needed) and remove liquidity call
-     */
-    async buildRemoveLiquidityTransaction(input) {
-        return (0, basicLiquidity_1.buildRemoveLiquidityTransactionInternal)(this.publicClient, this.chainId, this.poolService, input.poolAddress, input.liquidity, input.recipient, input.owner, input.options);
-    }
-    /**
-     * Builds remove liquidity transaction parameters without checking LP token approval.
-     * Use buildRemoveLiquidityTransaction if you need approval handling.
-     * @param input - Remove liquidity parameters
-     * @returns Transaction details with encoded call data
-     */
-    async buildRemoveLiquidityParams(input) {
-        return (0, basicLiquidity_1.buildRemoveLiquidityParamsInternal)(this.publicClient, this.chainId, this.poolService, input.poolAddress, input.liquidity, input.recipient, input.options);
-    }
-    /**
-     * Quotes an add liquidity operation (read-only call).
-     * Returns expected amounts and LP tokens based on current pool reserves.
-     * @param poolAddress - FPMM pool address
-     * @param tokenA - First token address
-     * @param amountA - Amount of first token
-     * @param tokenB - Second token address
-     * @param amountB - Amount of second token
-     * @returns Expected amounts and LP tokens to be minted
-     */
-    async quoteAddLiquidity(poolAddress, tokenA, amountA, tokenB, amountB) {
-        return (0, basicLiquidity_1.quoteAddLiquidityInternal)(this.publicClient, this.chainId, this.poolService, poolAddress, tokenA, amountA, tokenB, amountB);
-    }
-    /**
-     * Quotes a remove liquidity operation (read-only call).
-     * Returns expected token amounts based on current pool reserves.
-     * @param poolAddress - FPMM pool address
-     * @param liquidity - Amount of LP tokens to burn
-     * @returns Expected amounts of token0 and token1
-     */
-    async quoteRemoveLiquidity(poolAddress, liquidity) {
-        return (0, basicLiquidity_1.quoteRemoveLiquidityInternal)(this.publicClient, this.chainId, this.poolService, poolAddress, liquidity);
-    }
-    /**
-     * Gets LP token balance and pool share percentage for an address.
-     * @param poolAddress - FPMM pool address (also the LP token address)
-     * @param owner - Address to check balance for
-     * @returns Balance, total supply, and share percentage
-     */
-    async getLPTokenBalance(poolAddress, owner) {
-        return (0, basicLiquidity_1.getLPTokenBalanceInternal)(this.publicClient, this.poolService, poolAddress, owner);
-    }
-    /**
-     * Builds zap in transaction with approval if needed.
-     * Adds liquidity using a single input token - the Router swaps it to both pool tokens automatically.
-     * @param input - Zap in parameters including owner for allowance check
-     * @returns Transaction with approval (if needed) and zap in call
-     */
-    async buildZapInTransaction(input) {
-        return (0, zapIn_1.buildZapInTransactionInternal)(this.publicClient, this.chainId, this.poolService, this.routeService, input.poolAddress, input.tokenIn, input.amountIn, input.amountInSplit, input.recipient, input.owner, input.options);
-    }
-    /**
-     * Builds zap in transaction parameters without checking approval.
-     * Use buildZapInTransaction if you need approval handling.
-     * @param input - Zap in parameters
-     * @returns Transaction details with encoded call data and routing information
-     */
-    async buildZapInParams(input) {
-        return (0, zapIn_1.buildZapInParamsInternal)(this.publicClient, this.chainId, this.poolService, this.routeService, input.poolAddress, input.tokenIn, input.amountIn, input.amountInSplit, input.recipient, input.options);
-    }
-    async prepareZapIn(input) {
-        return (0, zapIn_1.prepareZapInInternal)(this.publicClient, this.chainId, this.poolService, this.routeService, input.poolAddress, input.tokenIn, input.amountIn, input.amountInSplit, input.recipient, input.owner, input.options);
-    }
-    /**
-     * Builds zap out transaction with approval if needed.
-     * Removes liquidity and swaps both tokens to a single output token.
-     * @param input - Zap out parameters including owner for allowance check
-     * @returns Transaction with approval (if needed) and zap out call
-     */
-    async buildZapOutTransaction(input) {
-        return (0, zapOut_1.buildZapOutTransactionInternal)(this.publicClient, this.chainId, this.poolService, this.routeService, input.poolAddress, input.tokenOut, input.liquidity, input.recipient, input.owner, input.options);
-    }
-    /**
-     * Builds zap out transaction parameters without checking approval.
-     * Use buildZapOutTransaction if you need approval handling.
-     * @param input - Zap out parameters
-     * @returns Transaction details with encoded call data and routing information
-     */
-    async buildZapOutParams(input) {
-        return (0, zapOut_1.buildZapOutParamsInternal)(this.publicClient, this.chainId, this.poolService, this.routeService, input.poolAddress, input.tokenOut, input.liquidity, input.recipient, input.options);
-    }
-    async prepareZapOut(input) {
-        return (0, zapOut_1.prepareZapOutInternal)(this.publicClient, this.chainId, this.poolService, this.routeService, input.poolAddress, input.tokenOut, input.liquidity, input.recipient, input.owner, input.options);
-    }
-    /**
-     * Quotes a zap in operation (read-only call).
-     * Estimates expected LP tokens and minimum amounts after swaps and slippage.
-     * @param poolAddress - FPMM pool address
-     * @param tokenIn - Input token address
-     * @param amountIn - Total input amount
-     * @param amountInSplit - Split ratio (0-1)
-     * @param options - Slippage tolerance and deadline
-     * @returns Expected LP tokens and minimum amounts for both pool tokens
-     */
-    async quoteZapIn(poolAddress, tokenIn, amountIn, amountInSplit, options) {
-        return (0, zapIn_1.quoteZapInInternal)(this.publicClient, this.chainId, this.poolService, this.routeService, poolAddress, tokenIn, amountIn, amountInSplit, options);
-    }
-    /**
-     * Quotes a zap out operation (read-only call).
-     * Estimates expected output tokens after removing liquidity and swapping.
-     * @param poolAddress - FPMM pool address
-     * @param tokenOut - Output token address
-     * @param liquidity - Amount of LP tokens to burn
-     * @param options - Slippage tolerance and deadline
-     * @returns Expected output amount and minimum amounts after slippage
-     */
-    async quoteZapOut(poolAddress, tokenOut, liquidity, options) {
-        return (0, zapOut_1.quoteZapOutInternal)(this.publicClient, this.chainId, this.poolService, this.routeService, poolAddress, tokenOut, liquidity, options);
-    }
-    /**
-     * Builds rebalance transaction parameters without checking approval.
-     * Use buildRebalanceTransaction if you need approval handling.
-     * @param input - Rebalance parameters
-     * @returns Transaction details with encoded call data
-     */
-    async buildRebalanceParams(input) {
-        return (0, rebalance_1.buildRebalanceParamsInternal)(this.publicClient, this.chainId, this.poolService, input.poolAddress);
-    }
-    /**
-     * Builds a rebalance transaction with ERC20 approval if needed.
-     * @param input - Rebalance parameters including owner for allowance checks
-     * @returns Transaction with approval (if needed) and rebalance call
-     */
-    async buildRebalanceTransaction(input) {
-        return (0, rebalance_1.buildRebalanceTransactionInternal)(this.publicClient, this.chainId, this.poolService, input.poolAddress, input.owner);
-    }
-}
-exports.LiquidityService = LiquidityService;
-//# sourceMappingURL=LiquidityService.js.map

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

@@ -1,11 +0,0 @@
-import { PublicClient } from 'viem';
-import { PoolService } from '../pools';
-import { LiquidityOptions, AddLiquidityQuote, RemoveLiquidityQuote, AddLiquidityDetails, RemoveLiquidityDetails, AddLiquidityTransaction, RemoveLiquidityTransaction, LPTokenBalance } from '../../core/types';
-export declare function buildAddLiquidityTransactionInternal(publicClient: PublicClient, chainId: number, poolService: PoolService, poolAddress: string, tokenA: string, amountA: bigint, tokenB: string, amountB: bigint, recipient: string, owner: string, options: LiquidityOptions): Promise<AddLiquidityTransaction>;
-export declare function buildAddLiquidityParamsInternal(publicClient: PublicClient, chainId: number, poolService: PoolService, poolAddress: string, tokenA: string, amountA: bigint, tokenB: string, amountB: bigint, recipient: string, options: LiquidityOptions): Promise<AddLiquidityDetails>;
-export declare function quoteAddLiquidityInternal(publicClient: PublicClient, chainId: number, poolService: PoolService, poolAddress: string, tokenA: string, amountA: bigint, tokenB: string, amountB: bigint): Promise<AddLiquidityQuote>;
-export declare function buildRemoveLiquidityTransactionInternal(publicClient: PublicClient, chainId: number, poolService: PoolService, poolAddress: string, liquidity: bigint, recipient: string, owner: string, options: LiquidityOptions): Promise<RemoveLiquidityTransaction>;
-export declare function buildRemoveLiquidityParamsInternal(publicClient: PublicClient, chainId: number, poolService: PoolService, poolAddress: string, liquidity: bigint, recipient: string, options: LiquidityOptions): Promise<RemoveLiquidityDetails>;
-export declare function quoteRemoveLiquidityInternal(publicClient: PublicClient, chainId: number, poolService: PoolService, poolAddress: string, liquidity: bigint): Promise<RemoveLiquidityQuote>;
-export declare function getLPTokenBalanceInternal(publicClient: PublicClient, poolService: PoolService, poolAddress: string, owner: string): Promise<LPTokenBalance>;
-//# sourceMappingURL=basicLiquidity.d.ts.map

package/dist/services/liquidity/basicLiquidity.js

@@ -1,172 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildAddLiquidityTransactionInternal = buildAddLiquidityTransactionInternal;
-exports.buildAddLiquidityParamsInternal = buildAddLiquidityParamsInternal;
-exports.quoteAddLiquidityInternal = quoteAddLiquidityInternal;
-exports.buildRemoveLiquidityTransactionInternal = buildRemoveLiquidityTransactionInternal;
-exports.buildRemoveLiquidityParamsInternal = buildRemoveLiquidityParamsInternal;
-exports.quoteRemoveLiquidityInternal = quoteRemoveLiquidityInternal;
-exports.getLPTokenBalanceInternal = getLPTokenBalanceInternal;
-const viem_1 = require("viem");
-const abis_1 = require("../../core/abis");
-const constants_1 = require("../../core/constants");
-const validation_1 = require("../../utils/validation");
-const liquidityHelpers_1 = require("./liquidityHelpers");
-function encodeAddLiquidityCall(tokenA, tokenB, amountADesired, amountBDesired, amountAMin, amountBMin, recipient, deadline) {
-    return (0, viem_1.encodeFunctionData)({
-        abi: abis_1.ROUTER_ABI,
-        functionName: 'addLiquidity',
-        args: [tokenA, tokenB, amountADesired, amountBDesired, amountAMin, amountBMin, recipient, deadline],
-    });
-}
-function encodeRemoveLiquidityCall(token0, token1, liquidity, amount0Min, amount1Min, recipient, deadline) {
-    return (0, viem_1.encodeFunctionData)({
-        abi: abis_1.ROUTER_ABI,
-        functionName: 'removeLiquidity',
-        args: [token0, token1, liquidity, amount0Min, amount1Min, recipient, deadline],
-    });
-}
-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);
-    (0, validation_1.validateAddress)(owner, 'owner');
-    const ownerAddr = owner;
-    const tokenAAddr = addLiquidity.tokenA;
-    const tokenBAddr = addLiquidity.tokenB;
-    const [allowanceA, allowanceB] = await Promise.all([
-        (0, liquidityHelpers_1.getAllowance)(publicClient, tokenAAddr, ownerAddr, chainId),
-        (0, liquidityHelpers_1.getAllowance)(publicClient, tokenBAddr, ownerAddr, chainId),
-    ]);
-    const approvalA = allowanceA < amountA
-        ? { token: addLiquidity.tokenA, amount: amountA, params: (0, liquidityHelpers_1.buildApprovalParams)(chainId, tokenAAddr, amountA) }
-        : null;
-    const approvalB = allowanceB < amountB
-        ? { token: addLiquidity.tokenB, amount: amountB, params: (0, liquidityHelpers_1.buildApprovalParams)(chainId, tokenBAddr, amountB) }
-        : null;
-    return { approvalA, approvalB, addLiquidity };
-}
-async function buildAddLiquidityParamsInternal(publicClient, chainId, poolService, poolAddress, tokenA, amountA, tokenB, amountB, recipient, options) {
-    (0, validation_1.validateAddress)(poolAddress, 'poolAddress');
-    (0, validation_1.validateAddress)(tokenA, 'tokenA');
-    (0, validation_1.validateAddress)(tokenB, 'tokenB');
-    (0, validation_1.validateAddress)(recipient, 'recipient');
-    const { token0, token1, factoryAddr } = await (0, liquidityHelpers_1.getPoolInfo)(poolService, poolAddress);
-    (0, liquidityHelpers_1.validatePoolTokens)(token0, token1, tokenA, tokenB);
-    const quote = await quoteAddLiquidityInternal(publicClient, chainId, poolService, poolAddress, tokenA, amountA, tokenB, amountB);
-    const amountAMin = (0, liquidityHelpers_1.calculateMinAmount)(quote.amountA, options.slippageTolerance);
-    const amountBMin = (0, liquidityHelpers_1.calculateMinAmount)(quote.amountB, options.slippageTolerance);
-    const routerAddress = (0, constants_1.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,
-    };
-}
-async function quoteAddLiquidityInternal(publicClient, chainId, poolService, poolAddress, tokenA, amountA, tokenB, amountB) {
-    (0, validation_1.validateAddress)(poolAddress, 'poolAddress');
-    (0, validation_1.validateAddress)(tokenA, 'tokenA');
-    (0, validation_1.validateAddress)(tokenB, 'tokenB');
-    const { token0, token1, factoryAddr } = await (0, liquidityHelpers_1.getPoolInfo)(poolService, poolAddress);
-    (0, liquidityHelpers_1.validatePoolTokens)(token0, token1, tokenA, tokenB);
-    const routerAddress = (0, constants_1.getContractAddress)(chainId, 'Router');
-    const [resultAmountA, resultAmountB, liquidity] = (await publicClient.readContract({
-        address: routerAddress,
-        abi: abis_1.ROUTER_ABI,
-        functionName: 'quoteAddLiquidity',
-        args: [tokenA, tokenB, factoryAddr, amountA, amountB],
-    }));
-    return { amountA: resultAmountA, amountB: resultAmountB, liquidity };
-}
-async function buildRemoveLiquidityTransactionInternal(publicClient, chainId, poolService, poolAddress, liquidity, recipient, owner, options) {
-    (0, validation_1.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 (0, liquidityHelpers_1.getAllowance)(publicClient, poolAddr, ownerAddr, chainId);
-    const approval = currentAllowance < liquidity
-        ? { token: poolAddress, amount: liquidity, params: (0, liquidityHelpers_1.buildApprovalParams)(chainId, poolAddr, liquidity) }
-        : null;
-    return { approval, removeLiquidity };
-}
-async function buildRemoveLiquidityParamsInternal(publicClient, chainId, poolService, poolAddress, liquidity, recipient, options) {
-    (0, validation_1.validateAddress)(poolAddress, 'poolAddress');
-    (0, validation_1.validateAddress)(recipient, 'recipient');
-    const { token0, token1 } = await (0, liquidityHelpers_1.getPoolInfo)(poolService, poolAddress);
-    const quote = await quoteRemoveLiquidityInternal(publicClient, chainId, poolService, poolAddress, liquidity);
-    const amount0Min = (0, liquidityHelpers_1.calculateMinAmount)(quote.amount0, options.slippageTolerance);
-    const amount1Min = (0, liquidityHelpers_1.calculateMinAmount)(quote.amount1, options.slippageTolerance);
-    const routerAddress = (0, constants_1.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,
-    };
-}
-async function quoteRemoveLiquidityInternal(publicClient, chainId, poolService, poolAddress, liquidity) {
-    (0, validation_1.validateAddress)(poolAddress, 'poolAddress');
-    const { token0, token1, factoryAddr } = await (0, liquidityHelpers_1.getPoolInfo)(poolService, poolAddress);
-    const routerAddress = (0, constants_1.getContractAddress)(chainId, 'Router');
-    const [amount0, amount1] = (await publicClient.readContract({
-        address: routerAddress,
-        abi: abis_1.ROUTER_ABI,
-        functionName: 'quoteRemoveLiquidity',
-        args: [token0, token1, factoryAddr, liquidity],
-    }));
-    return { amount0, amount1 };
-}
-async function getLPTokenBalanceInternal(publicClient, poolService, poolAddress, owner) {
-    (0, validation_1.validateAddress)(poolAddress, 'poolAddress');
-    (0, validation_1.validateAddress)(owner, 'owner');
-    const { token0, token1 } = await (0, liquidityHelpers_1.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: abis_1.ERC20_ABI,
-            functionName: 'balanceOf',
-            args: [owner],
-        }),
-        publicClient.readContract({
-            address: poolAddress,
-            abi: abis_1.ERC20_ABI,
-            functionName: 'totalSupply',
-            args: [],
-        }),
-    ]);
-    const sharePercent = totalSupply > 0n ? Number((balance * 10000n) / totalSupply) / 100 : 0;
-    return {
-        poolAddress,
-        balance,
-        token0,
-        token1,
-        totalSupply,
-        sharePercent,
-    };
-}
-//# sourceMappingURL=basicLiquidity.js.map

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

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

package/dist/services/liquidity/index.js

@@ -1,18 +0,0 @@
-"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("./LiquidityService"), exports);
-//# sourceMappingURL=index.js.map

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

@@ -1,19 +0,0 @@
-import { Address, PublicClient } from 'viem';
-import { PoolService } from '../pools';
-import { CallParams } from '../../core/types';
-export declare function buildApprovalParams(chainId: number, token: Address, amount: bigint, spender?: Address): CallParams;
-export declare function getAllowance(publicClient: PublicClient, token: Address, owner: Address, chainId: number, spender?: Address): Promise<bigint>;
-export declare function calculateMinAmount(amount: bigint, slippageTolerance: number): bigint;
-export declare function getPoolInfo(poolService: PoolService, poolAddress: string): Promise<{
-    token0: Address;
-    token1: Address;
-    factoryAddr: Address;
-}>;
-export declare function validatePoolTokens(poolToken0: Address, poolToken1: Address, tokenA: string, tokenB: string): void;
-export declare function getPoolSnapshot(publicClient: PublicClient, poolAddress: Address): Promise<{
-    reserve0: bigint;
-    reserve1: bigint;
-    blockTimestampLast: bigint;
-    totalSupply: bigint;
-}>;
-//# sourceMappingURL=liquidityHelpers.d.ts.map

package/dist/services/liquidity/liquidityHelpers.js

@@ -1,104 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildApprovalParams = buildApprovalParams;
-exports.getAllowance = getAllowance;
-exports.calculateMinAmount = calculateMinAmount;
-exports.getPoolInfo = getPoolInfo;
-exports.validatePoolTokens = validatePoolTokens;
-exports.getPoolSnapshot = getPoolSnapshot;
-const viem_1 = require("viem");
-const types_1 = require("../../core/types");
-const abis_1 = require("../../core/abis");
-const constants_1 = require("../../core/constants");
-const validation_1 = require("../../utils/validation");
-const multicall_1 = require("../../utils/multicall");
-function getApprovalSpender(chainId, spender) {
-    return spender ?? (0, constants_1.getContractAddress)(chainId, 'Router');
-}
-function buildApprovalParams(chainId, token, amount, spender) {
-    const approvalSpender = getApprovalSpender(chainId, spender);
-    const data = (0, viem_1.encodeFunctionData)({
-        abi: abis_1.ERC20_ABI,
-        functionName: 'approve',
-        args: [approvalSpender, amount],
-    });
-    return { to: token, data, value: '0' };
-}
-async function getAllowance(publicClient, token, owner, chainId, spender) {
-    const approvalSpender = getApprovalSpender(chainId, spender);
-    return (await publicClient.readContract({
-        address: token,
-        abi: abis_1.ERC20_ABI,
-        functionName: 'allowance',
-        args: [owner, approvalSpender],
-    }));
-}
-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;
-}
-async function getPoolInfo(poolService, poolAddress) {
-    (0, validation_1.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 !== types_1.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,
-    };
-}
-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');
-    }
-}
-async function getPoolSnapshot(publicClient, poolAddress) {
-    const results = await (0, multicall_1.multicall)(publicClient, [
-        {
-            address: poolAddress,
-            abi: abis_1.FPMM_ABI,
-            functionName: 'getReserves',
-        },
-        {
-            address: poolAddress,
-            abi: abis_1.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,
-    };
-}
-//# sourceMappingURL=liquidityHelpers.js.map

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

@@ -1,6 +0,0 @@
-import { PublicClient } from 'viem';
-import { RebalanceDetails, RebalanceTransaction } from '../../core/types';
-import { PoolService } from '../pools';
-export declare function buildRebalanceParamsInternal(publicClient: PublicClient, chainId: number, poolService: PoolService, poolAddress: string): Promise<RebalanceDetails>;
-export declare function buildRebalanceTransactionInternal(publicClient: PublicClient, chainId: number, poolService: PoolService, poolAddress: string, owner: string): Promise<RebalanceTransaction>;
-//# sourceMappingURL=rebalance.d.ts.map