@mento-protocol/mento-sdk 3.2.3 → 3.2.5

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

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

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

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

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

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

package/dist/{cjs/types → services/liquidity}/index.js

@@ -14,5 +14,5 @@ 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("./contractAddresses"), exports);
-__exportStar(require("./contractAddressMap"), exports);
+__exportStar(require("./LiquidityService"), exports);
+//# sourceMappingURL=index.js.map

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

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

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

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