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

package/dist/esm/services/borrow/internal/borrowTransactionService.js

@@ -0,0 +1,271 @@
+import { encodeFunctionData } from 'viem';
+import { BORROWER_OPERATIONS_ABI, TROVE_MANAGER_ABI } from '../../../core/abis';
+import { getTroveOperationHints } from './borrowHints';
+import { optionalAddressOrZero, parseTroveId, requireAddress, requireNonNegativeBigInt, requireNonNegativeInteger, requirePositiveBigInt, requireUint128, } from './borrowValidation';
+const ZERO_VALUE_HEX = '0x0';
+export class BorrowTransactionService {
+    constructor(publicClient) {
+        this.publicClient = publicClient;
+    }
+    async buildOpenTroveTransaction(ctx, params) {
+        const owner = requireAddress(params.owner, 'owner');
+        const ownerIndex = requireNonNegativeInteger(params.ownerIndex, 'ownerIndex');
+        const collAmount = requirePositiveBigInt(params.collAmount, 'collAmount');
+        const boldAmount = requirePositiveBigInt(params.boldAmount, 'boldAmount');
+        const annualInterestRate = requireNonNegativeBigInt(params.annualInterestRate, 'annualInterestRate');
+        const maxUpfrontFee = requireNonNegativeBigInt(params.maxUpfrontFee, 'maxUpfrontFee');
+        const addManager = optionalAddressOrZero(params.addManager, 'addManager');
+        const removeManager = optionalAddressOrZero(params.removeManager, 'removeManager');
+        const receiver = optionalAddressOrZero(params.receiver, 'receiver');
+        const hints = await getTroveOperationHints(this.publicClient, ctx, annualInterestRate);
+        const data = params.interestBatchManager
+            ? encodeFunctionData({
+                abi: BORROWER_OPERATIONS_ABI,
+                functionName: 'openTroveAndJoinInterestBatchManager',
+                args: [
+                    {
+                        owner,
+                        ownerIndex: BigInt(ownerIndex),
+                        collAmount,
+                        boldAmount,
+                        upperHint: hints.upper,
+                        lowerHint: hints.lower,
+                        interestBatchManager: requireAddress(params.interestBatchManager, 'interestBatchManager'),
+                        maxUpfrontFee,
+                        addManager,
+                        removeManager,
+                        receiver,
+                    },
+                ],
+            })
+            : encodeFunctionData({
+                abi: BORROWER_OPERATIONS_ABI,
+                functionName: 'openTrove',
+                args: [
+                    owner,
+                    BigInt(ownerIndex),
+                    collAmount,
+                    boldAmount,
+                    hints.upper,
+                    hints.lower,
+                    annualInterestRate,
+                    maxUpfrontFee,
+                    addManager,
+                    removeManager,
+                    receiver,
+                ],
+            });
+        return {
+            to: ctx.addresses.borrowerOperations,
+            data,
+            value: ZERO_VALUE_HEX,
+        };
+    }
+    buildAdjustTroveTransaction(ctx, params) {
+        const troveId = parseTroveId(params.troveId);
+        const collChange = requireNonNegativeBigInt(params.collChange, 'collChange');
+        const debtChange = requireNonNegativeBigInt(params.debtChange, 'debtChange');
+        const maxUpfrontFee = requireNonNegativeBigInt(params.maxUpfrontFee, 'maxUpfrontFee');
+        const data = encodeFunctionData({
+            abi: BORROWER_OPERATIONS_ABI,
+            functionName: 'adjustTrove',
+            args: [troveId, collChange, params.isCollIncrease, debtChange, params.isDebtIncrease, maxUpfrontFee],
+        });
+        return { to: ctx.addresses.borrowerOperations, data, value: ZERO_VALUE_HEX };
+    }
+    async buildAdjustZombieTroveTransaction(ctx, params) {
+        const troveId = parseTroveId(params.troveId);
+        const collChange = requireNonNegativeBigInt(params.collChange, 'collChange');
+        const debtChange = requireNonNegativeBigInt(params.debtChange, 'debtChange');
+        const maxUpfrontFee = requireNonNegativeBigInt(params.maxUpfrontFee, 'maxUpfrontFee');
+        const currentRate = (await this.publicClient.readContract({
+            address: ctx.addresses.troveManager,
+            abi: TROVE_MANAGER_ABI,
+            functionName: 'getTroveAnnualInterestRate',
+            args: [troveId],
+        }));
+        const hints = await getTroveOperationHints(this.publicClient, ctx, currentRate);
+        const data = encodeFunctionData({
+            abi: BORROWER_OPERATIONS_ABI,
+            functionName: 'adjustZombieTrove',
+            args: [
+                troveId,
+                collChange,
+                params.isCollIncrease,
+                debtChange,
+                params.isDebtIncrease,
+                hints.upper,
+                hints.lower,
+                maxUpfrontFee,
+            ],
+        });
+        return { to: ctx.addresses.borrowerOperations, data, value: ZERO_VALUE_HEX };
+    }
+    buildCloseTroveTransaction(ctx, troveId) {
+        const parsedTroveId = parseTroveId(troveId);
+        const data = encodeFunctionData({
+            abi: BORROWER_OPERATIONS_ABI,
+            functionName: 'closeTrove',
+            args: [parsedTroveId],
+        });
+        return { to: ctx.addresses.borrowerOperations, data, value: ZERO_VALUE_HEX };
+    }
+    buildAddCollTransaction(ctx, troveId, amount) {
+        const parsedTroveId = parseTroveId(troveId);
+        const collAmount = requirePositiveBigInt(amount, 'amount');
+        const data = encodeFunctionData({
+            abi: BORROWER_OPERATIONS_ABI,
+            functionName: 'addColl',
+            args: [parsedTroveId, collAmount],
+        });
+        return { to: ctx.addresses.borrowerOperations, data, value: ZERO_VALUE_HEX };
+    }
+    buildWithdrawCollTransaction(ctx, troveId, amount) {
+        const parsedTroveId = parseTroveId(troveId);
+        const collAmount = requirePositiveBigInt(amount, 'amount');
+        const data = encodeFunctionData({
+            abi: BORROWER_OPERATIONS_ABI,
+            functionName: 'withdrawColl',
+            args: [parsedTroveId, collAmount],
+        });
+        return { to: ctx.addresses.borrowerOperations, data, value: ZERO_VALUE_HEX };
+    }
+    buildBorrowMoreTransaction(ctx, troveId, amount, maxFee) {
+        const parsedTroveId = parseTroveId(troveId);
+        const borrowAmount = requirePositiveBigInt(amount, 'amount');
+        const maxUpfrontFee = requireNonNegativeBigInt(maxFee, 'maxFee');
+        const data = encodeFunctionData({
+            abi: BORROWER_OPERATIONS_ABI,
+            functionName: 'withdrawBold',
+            args: [parsedTroveId, borrowAmount, maxUpfrontFee],
+        });
+        return { to: ctx.addresses.borrowerOperations, data, value: ZERO_VALUE_HEX };
+    }
+    buildRepayDebtTransaction(ctx, troveId, amount) {
+        const parsedTroveId = parseTroveId(troveId);
+        const repayAmount = requirePositiveBigInt(amount, 'amount');
+        const data = encodeFunctionData({
+            abi: BORROWER_OPERATIONS_ABI,
+            functionName: 'repayBold',
+            args: [parsedTroveId, repayAmount],
+        });
+        return { to: ctx.addresses.borrowerOperations, data, value: ZERO_VALUE_HEX };
+    }
+    async buildAdjustInterestRateTransaction(ctx, troveId, newRate, maxFee) {
+        const parsedTroveId = parseTroveId(troveId);
+        const newAnnualInterestRate = requireNonNegativeBigInt(newRate, 'newRate');
+        const maxUpfrontFee = requireNonNegativeBigInt(maxFee, 'maxFee');
+        const hints = await getTroveOperationHints(this.publicClient, ctx, newAnnualInterestRate);
+        const data = encodeFunctionData({
+            abi: BORROWER_OPERATIONS_ABI,
+            functionName: 'adjustTroveInterestRate',
+            args: [parsedTroveId, newAnnualInterestRate, hints.upper, hints.lower, maxUpfrontFee],
+        });
+        return { to: ctx.addresses.borrowerOperations, data, value: ZERO_VALUE_HEX };
+    }
+    buildClaimCollateralTransaction(ctx) {
+        const data = encodeFunctionData({
+            abi: BORROWER_OPERATIONS_ABI,
+            functionName: 'claimCollateral',
+            args: [],
+        });
+        return { to: ctx.addresses.borrowerOperations, data, value: ZERO_VALUE_HEX };
+    }
+    async buildSetBatchManagerTransaction(ctx, troveId, manager, maxFee) {
+        const parsedTroveId = parseTroveId(troveId);
+        const newBatchManager = requireAddress(manager, 'manager');
+        const maxUpfrontFee = requireNonNegativeBigInt(maxFee, 'maxFee');
+        const currentRate = (await this.publicClient.readContract({
+            address: ctx.addresses.troveManager,
+            abi: TROVE_MANAGER_ABI,
+            functionName: 'getTroveAnnualInterestRate',
+            args: [parsedTroveId],
+        }));
+        const hints = await getTroveOperationHints(this.publicClient, ctx, currentRate);
+        const data = encodeFunctionData({
+            abi: BORROWER_OPERATIONS_ABI,
+            functionName: 'setInterestBatchManager',
+            args: [parsedTroveId, newBatchManager, hints.upper, hints.lower, maxUpfrontFee],
+        });
+        return { to: ctx.addresses.borrowerOperations, data, value: ZERO_VALUE_HEX };
+    }
+    async buildRemoveFromBatchTransaction(ctx, troveId, newRate, maxFee) {
+        const parsedTroveId = parseTroveId(troveId);
+        const newAnnualInterestRate = requireNonNegativeBigInt(newRate, 'newRate');
+        const maxUpfrontFee = requireNonNegativeBigInt(maxFee, 'maxFee');
+        const hints = await getTroveOperationHints(this.publicClient, ctx, newAnnualInterestRate);
+        const data = encodeFunctionData({
+            abi: BORROWER_OPERATIONS_ABI,
+            functionName: 'removeFromBatch',
+            args: [parsedTroveId, newAnnualInterestRate, hints.upper, hints.lower, maxUpfrontFee],
+        });
+        return { to: ctx.addresses.borrowerOperations, data, value: ZERO_VALUE_HEX };
+    }
+    async buildSwitchBatchManagerTransaction(ctx, troveId, newManager, maxFee) {
+        const parsedTroveId = parseTroveId(troveId);
+        const managerAddress = requireAddress(newManager, 'newManager');
+        const maxUpfrontFee = requireNonNegativeBigInt(maxFee, 'maxFee');
+        const currentRate = (await this.publicClient.readContract({
+            address: ctx.addresses.troveManager,
+            abi: TROVE_MANAGER_ABI,
+            functionName: 'getTroveAnnualInterestRate',
+            args: [parsedTroveId],
+        }));
+        const [removeHints, addHints] = await Promise.all([
+            getTroveOperationHints(this.publicClient, ctx, currentRate),
+            getTroveOperationHints(this.publicClient, ctx, currentRate),
+        ]);
+        const data = encodeFunctionData({
+            abi: BORROWER_OPERATIONS_ABI,
+            functionName: 'switchBatchManager',
+            args: [
+                parsedTroveId,
+                removeHints.upper,
+                removeHints.lower,
+                managerAddress,
+                addHints.upper,
+                addHints.lower,
+                maxUpfrontFee,
+            ],
+        });
+        return { to: ctx.addresses.borrowerOperations, data, value: ZERO_VALUE_HEX };
+    }
+    async buildSetInterestDelegateTransaction(ctx, troveId, delegate, minRate, maxRate, newRate, maxFee, minChangePeriod) {
+        const parsedTroveId = parseTroveId(troveId);
+        const delegateAddress = requireAddress(delegate, 'delegate');
+        const minInterestRate = requireUint128(minRate, 'minRate');
+        const maxInterestRate = requireUint128(maxRate, 'maxRate');
+        const newAnnualInterestRate = requireNonNegativeBigInt(newRate, 'newRate');
+        const maxUpfrontFee = requireNonNegativeBigInt(maxFee, 'maxFee');
+        const minRateChangePeriod = requireNonNegativeBigInt(minChangePeriod, 'minChangePeriod');
+        if (minInterestRate > maxInterestRate) {
+            throw new Error('minRate cannot be greater than maxRate');
+        }
+        const hints = await getTroveOperationHints(this.publicClient, ctx, newAnnualInterestRate);
+        const data = encodeFunctionData({
+            abi: BORROWER_OPERATIONS_ABI,
+            functionName: 'setInterestIndividualDelegate',
+            args: [
+                parsedTroveId,
+                delegateAddress,
+                minInterestRate,
+                maxInterestRate,
+                newAnnualInterestRate,
+                hints.upper,
+                hints.lower,
+                maxUpfrontFee,
+                minRateChangePeriod,
+            ],
+        });
+        return { to: ctx.addresses.borrowerOperations, data, value: ZERO_VALUE_HEX };
+    }
+    buildRemoveInterestDelegateTransaction(ctx, troveId) {
+        const parsedTroveId = parseTroveId(troveId);
+        const data = encodeFunctionData({
+            abi: BORROWER_OPERATIONS_ABI,
+            functionName: 'removeInterestIndividualDelegate',
+            args: [parsedTroveId],
+        });
+        return { to: ctx.addresses.borrowerOperations, data, value: ZERO_VALUE_HEX };
+    }
+}

package/dist/esm/services/borrow/internal/borrowTypes.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/services/borrow/internal/borrowValidation.js

@@ -0,0 +1,89 @@
+import { encodeAbiParameters, getAddress, keccak256, parseAbiParameters, zeroAddress } from 'viem';
+import { validateAddress } from '../../../utils/validation';
+const UINT128_MAX = (1n << 128n) - 1n;
+export const MAX_SAFE_INTEGER_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
+const TROVE_ID_PARAMETERS = parseAbiParameters('address opener, address owner, uint256 ownerIndex');
+export function requireDebtTokenSymbol(symbol) {
+    if (typeof symbol !== 'string' || symbol.trim().length === 0) {
+        throw new Error('debtTokenSymbol must be a non-empty string');
+    }
+    return symbol.trim();
+}
+export function requireAddress(address, fieldName) {
+    validateAddress(address, fieldName);
+    return address;
+}
+export function optionalAddressOrZero(value, fieldName) {
+    if (!value)
+        return zeroAddress;
+    return requireAddress(value, fieldName);
+}
+export function parseTroveId(troveId) {
+    if (typeof troveId !== 'string' || troveId.trim().length === 0) {
+        throw new Error('troveId must be a non-empty string');
+    }
+    let parsed;
+    try {
+        parsed = BigInt(troveId);
+    }
+    catch {
+        throw new Error(`Invalid troveId: ${troveId}`);
+    }
+    if (parsed < 0n) {
+        throw new Error('troveId cannot be negative');
+    }
+    return parsed;
+}
+export function formatTroveId(troveId) {
+    return `0x${troveId.toString(16)}`;
+}
+export function deriveTroveId(opener, owner, ownerIndex) {
+    const openerAddress = getAddress(requireAddress(opener, 'opener'));
+    const ownerAddress = getAddress(requireAddress(owner, 'owner'));
+    const validatedOwnerIndex = requireNonNegativeInteger(ownerIndex, 'ownerIndex');
+    return BigInt(keccak256(encodeAbiParameters(TROVE_ID_PARAMETERS, [openerAddress, ownerAddress, BigInt(validatedOwnerIndex)])));
+}
+export function requireNonNegativeInteger(value, fieldName) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new Error(`${fieldName} must be a non-negative safe integer`);
+    }
+    return value;
+}
+export function requireNonNegativeBigInt(value, fieldName) {
+    if (typeof value !== 'bigint' || value < 0n) {
+        throw new Error(`${fieldName} must be a non-negative bigint`);
+    }
+    return value;
+}
+export function requirePositiveBigInt(value, fieldName) {
+    if (typeof value !== 'bigint' || value <= 0n) {
+        throw new Error(`${fieldName} must be a positive bigint`);
+    }
+    return value;
+}
+export function requireUint128(value, fieldName) {
+    const parsed = requireNonNegativeBigInt(value, fieldName);
+    if (parsed > UINT128_MAX) {
+        throw new Error(`${fieldName} exceeds uint128 max value`);
+    }
+    return parsed;
+}
+function integerSqrt(value) {
+    if (value < 0n) {
+        throw new Error('Cannot compute square root of a negative bigint');
+    }
+    if (value < 2n) {
+        return value;
+    }
+    let x0 = value;
+    let x1 = (x0 + 1n) >> 1n;
+    while (x1 < x0) {
+        x0 = x1;
+        x1 = (x1 + value / x1) >> 1n;
+    }
+    return x0;
+}
+export function ceilSqrt(value) {
+    const floor = integerSqrt(value);
+    return floor * floor === value ? floor : floor + 1n;
+}

package/dist/esm/services/index.js

@@ -0,0 +1,8 @@
+export * from './pools';
+export * from './routes';
+export * from './quotes';
+export * from './swap';
+export * from './trading';
+export * from './borrow';
+export * from './tokens';
+export * from './liquidity';

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

@@ -0,0 +1,163 @@
+import { buildAddLiquidityTransactionInternal, buildAddLiquidityParamsInternal, buildRemoveLiquidityTransactionInternal, buildRemoveLiquidityParamsInternal, quoteAddLiquidityInternal, quoteRemoveLiquidityInternal, getLPTokenBalanceInternal, } from './basicLiquidity';
+import { buildZapInTransactionInternal, buildZapInParamsInternal, prepareZapInInternal, quoteZapInInternal, } from './zapIn';
+import { buildZapOutTransactionInternal, buildZapOutParamsInternal, prepareZapOutInternal, quoteZapOutInternal, } from './zapOut';
+import { buildRebalanceParamsInternal, buildRebalanceTransactionInternal, } from './rebalance';
+export 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 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 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 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 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 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 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 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 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 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 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 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 buildZapOutParamsInternal(this.publicClient, this.chainId, this.poolService, this.routeService, input.poolAddress, input.tokenOut, input.liquidity, input.recipient, input.options);
+    }
+    async prepareZapOut(input) {
+        return 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 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 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 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 buildRebalanceTransactionInternal(this.publicClient, this.chainId, this.poolService, input.poolAddress, input.owner);
+    }
+}