@mento-protocol/mento-sdk 3.1.0-beta.5 → 3.1.0-beta.6

package/dist/core/abis/index.d.ts

@@ -18,4 +18,5 @@ export * from './troveNFT';
 export * from './priceFeed';
 export * from './addressesRegistry';
 export * from './systemParams';
+export * from './liquidityStrategy';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/abis/index.js

@@ -34,4 +34,5 @@ __exportStar(require("./troveNFT"), exports);
 __exportStar(require("./priceFeed"), exports);
 __exportStar(require("./addressesRegistry"), exports);
 __exportStar(require("./systemParams"), exports);
+__exportStar(require("./liquidityStrategy"), exports);
 //# sourceMappingURL=index.js.map

package/dist/core/abis/liquidityStrategy.d.ts

@@ -0,0 +1,132 @@
+export declare const LIQUIDITY_STRATEGY_ABI: readonly [{
+    readonly name: "poolConfigs";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+        readonly name: "isToken0Debt";
+    }, {
+        readonly type: "uint32";
+        readonly name: "lastRebalance";
+    }, {
+        readonly type: "uint32";
+        readonly name: "rebalanceCooldown";
+    }, {
+        readonly type: "address";
+        readonly name: "protocolFeeRecipient";
+    }, {
+        readonly type: "uint64";
+        readonly name: "liquiditySourceIncentiveExpansion";
+    }, {
+        readonly type: "uint64";
+        readonly name: "protocolIncentiveExpansion";
+    }, {
+        readonly type: "uint64";
+        readonly name: "liquiditySourceIncentiveContraction";
+    }, {
+        readonly type: "uint64";
+        readonly name: "protocolIncentiveContraction";
+    }];
+}, {
+    readonly name: "determineAction";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "pool";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly type: "address";
+            readonly name: "pool";
+        }, {
+            readonly type: "tuple";
+            readonly components: readonly [{
+                readonly type: "uint256";
+                readonly name: "reserveNum";
+            }, {
+                readonly type: "uint256";
+                readonly name: "reserveDen";
+            }];
+            readonly name: "reserves";
+        }, {
+            readonly type: "tuple";
+            readonly components: readonly [{
+                readonly type: "uint256";
+                readonly name: "oracleNum";
+            }, {
+                readonly type: "uint256";
+                readonly name: "oracleDen";
+            }, {
+                readonly type: "bool";
+                readonly name: "poolPriceAbove";
+            }, {
+                readonly type: "uint16";
+                readonly name: "rebalanceThreshold";
+            }];
+            readonly name: "prices";
+        }, {
+            readonly type: "address";
+            readonly name: "token0";
+        }, {
+            readonly type: "address";
+            readonly name: "token1";
+        }, {
+            readonly type: "uint64";
+            readonly name: "token0Dec";
+        }, {
+            readonly type: "uint64";
+            readonly name: "token1Dec";
+        }, {
+            readonly type: "bool";
+            readonly name: "isToken0Debt";
+        }, {
+            readonly type: "tuple";
+            readonly components: readonly [{
+                readonly type: "uint64";
+                readonly name: "liquiditySourceIncentiveExpansion";
+            }, {
+                readonly type: "uint64";
+                readonly name: "protocolIncentiveExpansion";
+            }, {
+                readonly type: "uint64";
+                readonly name: "liquiditySourceIncentiveContraction";
+            }, {
+                readonly type: "uint64";
+                readonly name: "protocolIncentiveContraction";
+            }];
+            readonly name: "incentives";
+        }];
+        readonly name: "ctx";
+    }, {
+        readonly type: "tuple";
+        readonly components: readonly [{
+            readonly type: "uint8";
+            readonly name: "dir";
+        }, {
+            readonly type: "uint256";
+            readonly name: "amount0Out";
+        }, {
+            readonly type: "uint256";
+            readonly name: "amount1Out";
+        }, {
+            readonly type: "uint256";
+            readonly name: "amountOwedToPool";
+        }];
+        readonly name: "action";
+    }];
+}, {
+    readonly name: "rebalance";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "address";
+        readonly name: "pool";
+    }];
+    readonly outputs: readonly [];
+}];
+//# sourceMappingURL=liquidityStrategy.d.ts.map

package/dist/core/abis/liquidityStrategy.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LIQUIDITY_STRATEGY_ABI = void 0;
+const viem_1 = require("viem");
+exports.LIQUIDITY_STRATEGY_ABI = (0, viem_1.parseAbi)([
+    'function poolConfigs(address) view returns (bool isToken0Debt, uint32 lastRebalance, uint32 rebalanceCooldown, address protocolFeeRecipient, uint64 liquiditySourceIncentiveExpansion, uint64 protocolIncentiveExpansion, uint64 liquiditySourceIncentiveContraction, uint64 protocolIncentiveContraction)',
+    'function determineAction(address pool) view returns ((address pool, (uint256 reserveNum, uint256 reserveDen) reserves, (uint256 oracleNum, uint256 oracleDen, bool poolPriceAbove, uint16 rebalanceThreshold) prices, address token0, address token1, uint64 token0Dec, uint64 token1Dec, bool isToken0Debt, (uint64 liquiditySourceIncentiveExpansion, uint64 protocolIncentiveExpansion, uint64 liquiditySourceIncentiveContraction, uint64 protocolIncentiveContraction) incentives) ctx, (uint8 dir, uint256 amount0Out, uint256 amount1Out, uint256 amountOwedToPool) action)',
+    'function rebalance(address pool)',
+]);
+//# sourceMappingURL=liquidityStrategy.js.map

package/dist/core/constants/addresses.js

@@ -44,6 +44,7 @@ exports.addresses = {
         FPMMFactory: '0x353ED52bF8482027C0e0b9e3c0e5d96A9F680980',
         Router: '0xcf6cD45210b3ffE3cA28379C4683F1e60D0C2CCd',
         ReserveLiquidityStrategy: '0x734bb3251Ec3f1A83f8f2A8609bcEF649D54EbF8',
+        OpenLiquidityStrategy: '0xCCd2aD0603a08EBc14D223a983171ef18192e8c9',
     },
     [chainId_1.ChainId.MONAD]: {},
     [chainId_1.ChainId.CELO_SEPOLIA]: {

package/dist/core/types/contractAddresses.d.ts

@@ -30,6 +30,7 @@ export type ContractAddresses = {
     Router?: string;
     ReserveLiquidityStrategy?: string;
     CDPLiquidityStrategy?: string;
+    OpenLiquidityStrategy?: string;
 };
 /**
  * Map of chain IDs to their contract addresses.

package/dist/core/types/liquidity.d.ts

@@ -1,4 +1,5 @@
 import { CallParams } from './transaction';
+import { LiquidityStrategyDirection } from './pool';
 import { RouterRoute } from '../../utils/pathEncoder';
 export interface LiquidityOptions {
     slippageTolerance: number;
@@ -114,6 +115,25 @@ export interface ZapOutTransaction {
     approval: TokenApproval | null;
     zapOut: ZapOutDetails;
 }
+export interface RebalanceDetails {
+    params: CallParams;
+    poolAddress: string;
+    strategyAddress: string;
+    inputToken: string;
+    outputToken: string;
+    amountRequired: bigint;
+    expectedAmountTransferred: bigint;
+    expectedProtocolIncentive: bigint;
+    expectedLiquiditySourceIncentive: bigint;
+    approvalToken: string;
+    approvalSpender: string;
+    approvalAmount: bigint;
+    direction: LiquidityStrategyDirection;
+}
+export interface RebalanceTransaction {
+    approval: TokenApproval | null;
+    rebalance: RebalanceDetails;
+}
 export interface PreparedZapIn {
     routesA: RouterRoute[];
     routesB: RouterRoute[];
@@ -168,4 +188,7 @@ export interface ZapOutInput {
 export interface PrepareZapOutInput extends ZapOutInput {
     owner?: string;
 }
+export interface RebalanceInput {
+    poolAddress: string;
+}
 //# sourceMappingURL=liquidity.d.ts.map

package/dist/core/types/pool.d.ts

@@ -92,9 +92,72 @@ export interface FPMMRebalancing {
     rebalanceThresholdBelowPercent: number;
     /** Whether the current price is within rebalancing thresholds (null when pricing unavailable) */
     inBand: boolean | null;
-    /** The active liquidity strategy address for this pool, or null if none */
+    /** The registered Open Liquidity Strategy address for this pool, or null if none */
     liquidityStrategy: string | null;
 }
+export type LiquidityStrategyDirection = 'Expand' | 'Contract';
+export interface LiquidityStrategyRebalanceIncentives {
+    liquiditySourceIncentiveExpansion: bigint;
+    protocolIncentiveExpansion: bigint;
+    liquiditySourceIncentiveContraction: bigint;
+    protocolIncentiveContraction: bigint;
+}
+export interface LiquidityStrategyPoolConfig {
+    isToken0Debt: boolean;
+    lastRebalance: number;
+    rebalanceCooldown: number;
+    protocolFeeRecipient: string;
+    liquiditySourceIncentiveExpansion: bigint;
+    protocolIncentiveExpansion: bigint;
+    liquiditySourceIncentiveContraction: bigint;
+    protocolIncentiveContraction: bigint;
+}
+export interface LiquidityStrategyContext {
+    pool: string;
+    reserves: {
+        reserveNum: bigint;
+        reserveDen: bigint;
+    };
+    prices: {
+        oracleNum: bigint;
+        oracleDen: bigint;
+        poolPriceAbove: boolean;
+        rebalanceThreshold: number;
+    };
+    token0: string;
+    token1: string;
+    token0Dec: bigint;
+    token1Dec: bigint;
+    isToken0Debt: boolean;
+    incentives: LiquidityStrategyRebalanceIncentives;
+}
+export interface LiquidityStrategyAction {
+    dir: LiquidityStrategyDirection;
+    amount0Out: bigint;
+    amount1Out: bigint;
+    amountOwedToPool: bigint;
+}
+export interface PoolRebalanceTokenAmount {
+    token: string;
+    amount: bigint;
+}
+export interface PoolRebalancePreview {
+    poolAddress: string;
+    strategyAddress: string;
+    direction: LiquidityStrategyDirection;
+    config: LiquidityStrategyPoolConfig;
+    context: LiquidityStrategyContext;
+    action: LiquidityStrategyAction;
+    inputToken: string;
+    outputToken: string;
+    amountRequired: PoolRebalanceTokenAmount;
+    amountTransferred: PoolRebalanceTokenAmount;
+    protocolIncentive: PoolRebalanceTokenAmount;
+    liquiditySourceIncentive: PoolRebalanceTokenAmount;
+    approvalToken: string;
+    approvalSpender: string;
+    approvalAmount: bigint;
+}
 /**
  * Enriched details for an FPMM pool including pricing, fees, and rebalancing state
  */

package/dist/esm/core/abis/index.js

@@ -18,3 +18,4 @@ export * from './troveNFT';
 export * from './priceFeed';
 export * from './addressesRegistry';
 export * from './systemParams';
+export * from './liquidityStrategy';

package/dist/esm/core/abis/liquidityStrategy.js

@@ -0,0 +1,6 @@
+import { parseAbi } from 'viem';
+export const LIQUIDITY_STRATEGY_ABI = parseAbi([
+    'function poolConfigs(address) view returns (bool isToken0Debt, uint32 lastRebalance, uint32 rebalanceCooldown, address protocolFeeRecipient, uint64 liquiditySourceIncentiveExpansion, uint64 protocolIncentiveExpansion, uint64 liquiditySourceIncentiveContraction, uint64 protocolIncentiveContraction)',
+    'function determineAction(address pool) view returns ((address pool, (uint256 reserveNum, uint256 reserveDen) reserves, (uint256 oracleNum, uint256 oracleDen, bool poolPriceAbove, uint16 rebalanceThreshold) prices, address token0, address token1, uint64 token0Dec, uint64 token1Dec, bool isToken0Debt, (uint64 liquiditySourceIncentiveExpansion, uint64 protocolIncentiveExpansion, uint64 liquiditySourceIncentiveContraction, uint64 protocolIncentiveContraction) incentives) ctx, (uint8 dir, uint256 amount0Out, uint256 amount1Out, uint256 amountOwedToPool) action)',
+    'function rebalance(address pool)',
+]);

package/dist/esm/core/constants/addresses.js

@@ -39,6 +39,7 @@ export const addresses = {
         FPMMFactory: '0x353ED52bF8482027C0e0b9e3c0e5d96A9F680980',
         Router: '0xcf6cD45210b3ffE3cA28379C4683F1e60D0C2CCd',
         ReserveLiquidityStrategy: '0x734bb3251Ec3f1A83f8f2A8609bcEF649D54EbF8',
+        OpenLiquidityStrategy: '0xCCd2aD0603a08EBc14D223a983171ef18192e8c9',
     },
     [ChainId.MONAD]: {},
     [ChainId.CELO_SEPOLIA]: {

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

@@ -1,6 +1,7 @@
 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;
@@ -142,4 +143,21 @@ export class LiquidityService {
     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);
+    }
 }

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

@@ -4,22 +4,25 @@ import { ERC20_ABI, FPMM_ABI } from '../../core/abis';
 import { getContractAddress } from '../../core/constants';
 import { validateAddress } from '../../utils/validation';
 import { multicall } from '../../utils/multicall';
-export function buildApprovalParams(chainId, token, amount) {
-    const routerAddress = getContractAddress(chainId, 'Router');
+function getApprovalSpender(chainId, spender) {
+    return spender ?? getContractAddress(chainId, 'Router');
+}
+export function buildApprovalParams(chainId, token, amount, spender) {
+    const approvalSpender = getApprovalSpender(chainId, spender);
     const data = encodeFunctionData({
         abi: ERC20_ABI,
         functionName: 'approve',
-        args: [routerAddress, amount],
+        args: [approvalSpender, amount],
     });
     return { to: token, data, value: '0' };
 }
-export async function getAllowance(publicClient, token, owner, chainId) {
-    const routerAddress = getContractAddress(chainId, 'Router');
+export async function getAllowance(publicClient, token, owner, chainId, spender) {
+    const approvalSpender = getApprovalSpender(chainId, spender);
     return (await publicClient.readContract({
         address: token,
         abi: ERC20_ABI,
         functionName: 'allowance',
-        args: [owner, routerAddress],
+        args: [owner, approvalSpender],
     }));
 }
 export function calculateMinAmount(amount, slippageTolerance) {

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

@@ -0,0 +1,59 @@
+import { encodeFunctionData } from 'viem';
+import { LIQUIDITY_STRATEGY_ABI } from '../../core/abis';
+import { validateAddress } from '../../utils/validation';
+import { buildApprovalParams, getAllowance } from './liquidityHelpers';
+function getRebalanceUnavailableError(poolAddress) {
+    return new Error(`Pool ${poolAddress} is not currently rebalanceable or does not have a supported liquidity strategy.`);
+}
+function assertRebalanceActionAmounts(poolAddress, amountRequired, amountTransferred) {
+    if (amountRequired <= 0n || amountTransferred <= 0n) {
+        throw new Error(`Rebalance action for pool ${poolAddress} has zero amounts and cannot be executed.`);
+    }
+}
+export async function buildRebalanceParamsInternal(publicClient, chainId, poolService, poolAddress) {
+    validateAddress(poolAddress, 'poolAddress');
+    const preview = await poolService.getPoolRebalancePreview(poolAddress);
+    if (!preview) {
+        throw getRebalanceUnavailableError(poolAddress);
+    }
+    assertRebalanceActionAmounts(poolAddress, preview.amountRequired.amount, preview.amountTransferred.amount);
+    const data = encodeFunctionData({
+        abi: LIQUIDITY_STRATEGY_ABI,
+        functionName: 'rebalance',
+        args: [poolAddress],
+    });
+    return {
+        params: {
+            to: preview.strategyAddress,
+            data,
+            value: '0',
+        },
+        poolAddress,
+        strategyAddress: preview.strategyAddress,
+        inputToken: preview.inputToken,
+        outputToken: preview.outputToken,
+        amountRequired: preview.amountRequired.amount,
+        expectedAmountTransferred: preview.amountTransferred.amount,
+        expectedProtocolIncentive: preview.protocolIncentive.amount,
+        expectedLiquiditySourceIncentive: preview.liquiditySourceIncentive.amount,
+        approvalToken: preview.approvalToken,
+        approvalSpender: preview.approvalSpender,
+        approvalAmount: preview.approvalAmount,
+        direction: preview.direction,
+    };
+}
+export async function buildRebalanceTransactionInternal(publicClient, chainId, poolService, poolAddress, owner) {
+    validateAddress(owner, 'owner');
+    const rebalance = await buildRebalanceParamsInternal(publicClient, chainId, poolService, poolAddress);
+    const approvalToken = rebalance.approvalToken;
+    const approvalSpender = rebalance.approvalSpender;
+    const currentAllowance = await getAllowance(publicClient, approvalToken, owner, chainId, approvalSpender);
+    const approval = currentAllowance < rebalance.approvalAmount
+        ? {
+            token: rebalance.approvalToken,
+            amount: rebalance.approvalAmount,
+            params: buildApprovalParams(chainId, approvalToken, rebalance.approvalAmount, approvalSpender),
+        }
+        : null;
+    return { approval, rebalance };
+}

package/dist/esm/services/pools/PoolService.js

@@ -1,6 +1,7 @@
 import { PoolType } from '../../core/types';
 import { fetchFPMMPools, fetchVirtualPools } from './poolDiscovery';
 import { fetchFPMMPoolDetailsBatch, fetchVirtualPoolDetailsBatch, } from './poolDetails';
+import { fetchPoolRebalancePreview, fetchPoolRebalancePreviewBatch, } from './rebalancePreview';
 /**
  * Service for discovering liquidity pools in the Mento protocol.
  * Aggregates pools from multiple factory contracts (FPMM and VirtualPool).
@@ -104,6 +105,14 @@ export class PoolService {
         const [details] = await this.getPoolDetailsBatch([poolAddr]);
         return details;
     }
+    async getPoolRebalancePreview(poolAddr) {
+        const details = await this.getPoolDetails(poolAddr);
+        return fetchPoolRebalancePreview(this.publicClient, details);
+    }
+    async getPoolRebalancePreviewBatch(poolAddresses) {
+        const details = await this.getPoolDetailsBatch(poolAddresses);
+        return fetchPoolRebalancePreviewBatch(this.publicClient, details);
+    }
     async getPoolDetailsBatch(poolAddresses) {
         const pools = await this.getPools();
         const targets = poolAddresses

package/dist/esm/services/pools/poolDetails.js

@@ -1,4 +1,4 @@
-import { addresses } from '../../core/constants';
+import { tryGetContractAddress } from '../../core/constants';
 import { FPMM_ABI, VIRTUAL_POOL_ABI } from '../../core/abis';
 import { getAddress } from 'viem';
 import { multicall } from '../../utils/multicall';
@@ -15,17 +15,18 @@ export async function fetchFPMMPoolDetailsBatch(publicClient, chainId, pools) {
     if (pools.length === 0) {
         return [];
     }
-    const knownStrategies = getKnownLiquidityStrategies(chainId);
-    const contracts = pools.flatMap((pool) => buildFPMMContracts(pool, knownStrategies));
+    const openLiquidityStrategy = getOpenLiquidityStrategy(chainId);
+    const contracts = pools.flatMap((pool) => buildFPMMContracts(pool, openLiquidityStrategy));
     const results = await multicall(publicClient, contracts);
-    const perPoolResultCount = FPMM_FIXED_RESULT_COUNT + knownStrategies.length + 1;
+    const strategyCheckCount = openLiquidityStrategy ? 1 : 0;
+    const perPoolResultCount = FPMM_FIXED_RESULT_COUNT + strategyCheckCount + 1;
     return pools.map((pool, index) => {
         const offset = index * perPoolResultCount;
         const poolResults = results.slice(offset, offset + perPoolResultCount);
-        return parseFPMMPoolDetails(pool, knownStrategies, poolResults);
+        return parseFPMMPoolDetails(pool, openLiquidityStrategy, poolResults);
     });
 }
-function buildFPMMContracts(pool, knownStrategies) {
+function buildFPMMContracts(pool, openLiquidityStrategy) {
     const address = pool.poolAddr;
     return [
         { address, abi: FPMM_ABI, functionName: 'getReserves' },
@@ -36,16 +37,18 @@ function buildFPMMContracts(pool, knownStrategies) {
         { address, abi: FPMM_ABI, functionName: 'rebalanceIncentive' },
         { address, abi: FPMM_ABI, functionName: 'rebalanceThresholdAbove' },
         { address, abi: FPMM_ABI, functionName: 'rebalanceThresholdBelow' },
-        ...knownStrategies.map((strategyAddr) => ({
-            address,
-            abi: FPMM_ABI,
-            functionName: 'liquidityStrategy',
-            args: [strategyAddr],
-        })),
+        ...(openLiquidityStrategy
+            ? [{
+                    address,
+                    abi: FPMM_ABI,
+                    functionName: 'liquidityStrategy',
+                    args: [openLiquidityStrategy],
+                }]
+            : []),
         { address, abi: FPMM_ABI, functionName: 'getRebalancingState' },
     ];
 }
-function parseFPMMPoolDetails(pool, knownStrategies, results) {
+function parseFPMMPoolDetails(pool, openLiquidityStrategy, results) {
     try {
         const reservesRes = results[0];
         const decimals0Res = results[1];
@@ -79,10 +82,14 @@ function parseFPMMPoolDetails(pool, knownStrategies, results) {
         const rebalanceIncentiveBps = rebalanceIncentiveRes.result;
         const thresholdAboveBps = thresholdAboveRes.result;
         const thresholdBelowBps = thresholdBelowRes.result;
-        const strategyResults = results.slice(FPMM_FIXED_RESULT_COUNT, FPMM_FIXED_RESULT_COUNT + knownStrategies.length);
-        const activeIndex = strategyResults.findIndex((result) => result.status === 'success' && result.result === true);
-        const liquidityStrategy = activeIndex >= 0 ? knownStrategies[activeIndex] : null;
-        const rebalancingRes = results[FPMM_FIXED_RESULT_COUNT + knownStrategies.length];
+        const strategyCheckCount = openLiquidityStrategy ? 1 : 0;
+        const openStrategyResult = strategyCheckCount > 0 ? results[FPMM_FIXED_RESULT_COUNT] : null;
+        const liquidityStrategy = openLiquidityStrategy &&
+            openStrategyResult?.status === 'success' &&
+            openStrategyResult.result === true
+            ? openLiquidityStrategy
+            : null;
+        const rebalancingRes = results[FPMM_FIXED_RESULT_COUNT + strategyCheckCount];
         let pricing = null;
         let inBand = null;
         if (rebalancingRes?.status === 'success') {
@@ -187,23 +194,16 @@ function parseVirtualPoolDetails(pool, results) {
     }
 }
 /**
- * Returns the known liquidity strategy addresses for the given chain.
+ * Returns the configured Open Liquidity Strategy for the given chain.
  */
-function getKnownLiquidityStrategies(chainId) {
-    const chainAddresses = addresses[chainId];
-    if (!chainAddresses)
-        return [];
-    const strategyCandidates = [
-        chainAddresses.ReserveLiquidityStrategy,
-        chainAddresses.CDPLiquidityStrategy,
-    ].filter((address) => Boolean(address));
-    // Normalize to checksummed addresses and ignore malformed config values.
-    return strategyCandidates.flatMap((address) => {
-        try {
-            return [getAddress(address)];
-        }
-        catch {
-            return [];
-        }
-    });
+function getOpenLiquidityStrategy(chainId) {
+    const strategyAddress = tryGetContractAddress(chainId, 'OpenLiquidityStrategy');
+    if (!strategyAddress)
+        return null;
+    try {
+        return getAddress(strategyAddress);
+    }
+    catch {
+        return null;
+    }
 }

package/dist/esm/services/pools/rebalancePreview.js

@@ -0,0 +1,181 @@
+import { getAddress } from 'viem';
+import { LIQUIDITY_STRATEGY_ABI } from '../../core/abis';
+import { multicall } from '../../utils/multicall';
+// Liquidity strategy incentive rates are stored as 18-decimal percentages.
+const FEE_DENOMINATOR = 10n ** 18n;
+function toBigIntValue(value) {
+    return typeof value === 'bigint' ? value : BigInt(value);
+}
+function toNumberValue(value) {
+    return typeof value === 'number' ? value : Number(value);
+}
+function parseDirection(value) {
+    const normalized = toNumberValue(value);
+    if (normalized === 0)
+        return 'Expand';
+    if (normalized === 1)
+        return 'Contract';
+    throw new Error(`Unsupported liquidity strategy direction: ${normalized}`);
+}
+function parsePoolConfig(raw) {
+    return {
+        isToken0Debt: raw[0],
+        lastRebalance: toNumberValue(raw[1]),
+        rebalanceCooldown: toNumberValue(raw[2]),
+        protocolFeeRecipient: raw[3],
+        liquiditySourceIncentiveExpansion: toBigIntValue(raw[4]),
+        protocolIncentiveExpansion: toBigIntValue(raw[5]),
+        liquiditySourceIncentiveContraction: toBigIntValue(raw[6]),
+        protocolIncentiveContraction: toBigIntValue(raw[7]),
+    };
+}
+function parseContext(raw) {
+    return {
+        pool: raw[0],
+        reserves: {
+            reserveNum: toBigIntValue(raw[1][0]),
+            reserveDen: toBigIntValue(raw[1][1]),
+        },
+        prices: {
+            oracleNum: toBigIntValue(raw[2][0]),
+            oracleDen: toBigIntValue(raw[2][1]),
+            poolPriceAbove: raw[2][2],
+            rebalanceThreshold: toNumberValue(raw[2][3]),
+        },
+        token0: raw[3],
+        token1: raw[4],
+        token0Dec: toBigIntValue(raw[5]),
+        token1Dec: toBigIntValue(raw[6]),
+        isToken0Debt: raw[7],
+        incentives: {
+            liquiditySourceIncentiveExpansion: toBigIntValue(raw[8][0]),
+            protocolIncentiveExpansion: toBigIntValue(raw[8][1]),
+            liquiditySourceIncentiveContraction: toBigIntValue(raw[8][2]),
+            protocolIncentiveContraction: toBigIntValue(raw[8][3]),
+        },
+    };
+}
+function parseAction(raw) {
+    return {
+        dir: parseDirection(raw[0]),
+        amount0Out: toBigIntValue(raw[1]),
+        amount1Out: toBigIntValue(raw[2]),
+        amountOwedToPool: toBigIntValue(raw[3]),
+    };
+}
+function isPreviewEligible(detail) {
+    return (detail.poolType === 'FPMM' &&
+        detail.pricing !== null &&
+        detail.rebalancing.inBand === false &&
+        !!detail.rebalancing.liquidityStrategy);
+}
+function buildPreview(detail, strategyAddress, config, context, action) {
+    const debtToken = context.isToken0Debt ? context.token0 : context.token1;
+    const collateralToken = context.isToken0Debt ? context.token1 : context.token0;
+    const inputToken = action.dir === 'Expand' ? debtToken : collateralToken;
+    const outputToken = action.dir === 'Expand' ? collateralToken : debtToken;
+    const amountTransferredValue = action.amount0Out > 0n ? action.amount0Out : action.amount1Out;
+    const protocolRate = action.dir === 'Expand'
+        ? config.protocolIncentiveExpansion
+        : config.protocolIncentiveContraction;
+    const liquiditySourceRate = action.dir === 'Expand'
+        ? config.liquiditySourceIncentiveExpansion
+        : config.liquiditySourceIncentiveContraction;
+    const protocolIncentiveAmount = (amountTransferredValue * protocolRate) / FEE_DENOMINATOR;
+    const liquiditySourceBase = amountTransferredValue > protocolIncentiveAmount
+        ? amountTransferredValue - protocolIncentiveAmount
+        : 0n;
+    const liquiditySourceIncentiveAmount = (liquiditySourceBase * liquiditySourceRate) / FEE_DENOMINATOR;
+    return {
+        poolAddress: detail.poolAddr,
+        strategyAddress,
+        direction: action.dir,
+        config,
+        context,
+        action,
+        inputToken,
+        outputToken,
+        amountRequired: {
+            token: inputToken,
+            amount: action.amountOwedToPool,
+        },
+        amountTransferred: {
+            token: outputToken,
+            amount: amountTransferredValue,
+        },
+        protocolIncentive: {
+            token: outputToken,
+            amount: protocolIncentiveAmount,
+        },
+        liquiditySourceIncentive: {
+            token: outputToken,
+            amount: liquiditySourceIncentiveAmount,
+        },
+        approvalToken: inputToken,
+        approvalSpender: strategyAddress,
+        approvalAmount: action.amountOwedToPool,
+    };
+}
+export async function fetchPoolRebalancePreview(publicClient, detail) {
+    const [preview] = await fetchPoolRebalancePreviewBatch(publicClient, [detail]);
+    return preview;
+}
+export async function fetchPoolRebalancePreviewBatch(publicClient, details) {
+    const previews = details.map(() => null);
+    const eligibleTargets = details.flatMap((detail, index) => {
+        if (!isPreviewEligible(detail))
+            return [];
+        const strategyAddress = detail.rebalancing.liquidityStrategy;
+        if (!strategyAddress)
+            return [];
+        try {
+            return [
+                {
+                    index,
+                    detail,
+                    strategyAddress: getAddress(strategyAddress),
+                },
+            ];
+        }
+        catch {
+            return [];
+        }
+    });
+    if (eligibleTargets.length === 0) {
+        return previews;
+    }
+    const contracts = eligibleTargets.flatMap(({ detail, strategyAddress }) => [
+        {
+            address: strategyAddress,
+            abi: LIQUIDITY_STRATEGY_ABI,
+            functionName: 'poolConfigs',
+            args: [detail.poolAddr],
+        },
+        {
+            address: strategyAddress,
+            abi: LIQUIDITY_STRATEGY_ABI,
+            functionName: 'determineAction',
+            args: [detail.poolAddr],
+        },
+    ]);
+    const results = await multicall(publicClient, contracts);
+    eligibleTargets.forEach((target, targetIndex) => {
+        const configResult = results[targetIndex * 2];
+        const determineActionResult = results[targetIndex * 2 + 1];
+        if (!configResult || !determineActionResult)
+            return;
+        if (configResult.status === 'failure' || determineActionResult.status === 'failure')
+            return;
+        try {
+            const config = parsePoolConfig(configResult.result);
+            const [rawContext, rawAction] = determineActionResult.result;
+            const context = parseContext(rawContext);
+            const action = parseAction(rawAction);
+            previews[target.index] = buildPreview(target.detail, target.strategyAddress, config, context, action);
+        }
+        catch {
+            previews[target.index] = null;
+        }
+    });
+    return previews;
+}

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

@@ -1,7 +1,7 @@
 import { PublicClient } from 'viem';
 import { PoolService } from '../pools';
 import { RouteService } from '../routes';
-import { AddLiquidityInput, RemoveLiquidityInput, ZapInInput, ZapOutInput, PrepareZapInInput, PrepareZapOutInput, AddLiquidityQuote, RemoveLiquidityQuote, AddLiquidityDetails, RemoveLiquidityDetails, AddLiquidityTransaction, RemoveLiquidityTransaction, LPTokenBalance, LiquidityOptions, PreparedZapIn, PreparedZapOut, ZapInQuote, ZapOutQuote, ZapInDetails, ZapOutDetails, ZapInTransaction, ZapOutTransaction } from '../../core/types';
+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;
@@ -120,5 +120,20 @@ export declare class LiquidityService {
      * @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

@@ -4,6 +4,7 @@ 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;
@@ -145,6 +146,23 @@ class LiquidityService {
     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/liquidityHelpers.d.ts

@@ -1,8 +1,8 @@
 import { Address, PublicClient } from 'viem';
 import { PoolService } from '../pools';
 import { CallParams } from '../../core/types';
-export declare function buildApprovalParams(chainId: number, token: Address, amount: bigint): CallParams;
-export declare function getAllowance(publicClient: PublicClient, token: Address, owner: Address, chainId: number): Promise<bigint>;
+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;

package/dist/services/liquidity/liquidityHelpers.js

@@ -12,22 +12,25 @@ 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 buildApprovalParams(chainId, token, amount) {
-    const routerAddress = (0, constants_1.getContractAddress)(chainId, 'Router');
+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: [routerAddress, amount],
+        args: [approvalSpender, amount],
     });
     return { to: token, data, value: '0' };
 }
-async function getAllowance(publicClient, token, owner, chainId) {
-    const routerAddress = (0, constants_1.getContractAddress)(chainId, 'Router');
+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, routerAddress],
+        args: [owner, approvalSpender],
     }));
 }
 function calculateMinAmount(amount, slippageTolerance) {

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

package/dist/services/liquidity/rebalance.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRebalanceParamsInternal = buildRebalanceParamsInternal;
+exports.buildRebalanceTransactionInternal = buildRebalanceTransactionInternal;
+const viem_1 = require("viem");
+const abis_1 = require("../../core/abis");
+const validation_1 = require("../../utils/validation");
+const liquidityHelpers_1 = require("./liquidityHelpers");
+function getRebalanceUnavailableError(poolAddress) {
+    return new Error(`Pool ${poolAddress} is not currently rebalanceable or does not have a supported liquidity strategy.`);
+}
+function assertRebalanceActionAmounts(poolAddress, amountRequired, amountTransferred) {
+    if (amountRequired <= 0n || amountTransferred <= 0n) {
+        throw new Error(`Rebalance action for pool ${poolAddress} has zero amounts and cannot be executed.`);
+    }
+}
+async function buildRebalanceParamsInternal(publicClient, chainId, poolService, poolAddress) {
+    (0, validation_1.validateAddress)(poolAddress, 'poolAddress');
+    const preview = await poolService.getPoolRebalancePreview(poolAddress);
+    if (!preview) {
+        throw getRebalanceUnavailableError(poolAddress);
+    }
+    assertRebalanceActionAmounts(poolAddress, preview.amountRequired.amount, preview.amountTransferred.amount);
+    const data = (0, viem_1.encodeFunctionData)({
+        abi: abis_1.LIQUIDITY_STRATEGY_ABI,
+        functionName: 'rebalance',
+        args: [poolAddress],
+    });
+    return {
+        params: {
+            to: preview.strategyAddress,
+            data,
+            value: '0',
+        },
+        poolAddress,
+        strategyAddress: preview.strategyAddress,
+        inputToken: preview.inputToken,
+        outputToken: preview.outputToken,
+        amountRequired: preview.amountRequired.amount,
+        expectedAmountTransferred: preview.amountTransferred.amount,
+        expectedProtocolIncentive: preview.protocolIncentive.amount,
+        expectedLiquiditySourceIncentive: preview.liquiditySourceIncentive.amount,
+        approvalToken: preview.approvalToken,
+        approvalSpender: preview.approvalSpender,
+        approvalAmount: preview.approvalAmount,
+        direction: preview.direction,
+    };
+}
+async function buildRebalanceTransactionInternal(publicClient, chainId, poolService, poolAddress, owner) {
+    (0, validation_1.validateAddress)(owner, 'owner');
+    const rebalance = await buildRebalanceParamsInternal(publicClient, chainId, poolService, poolAddress);
+    const approvalToken = rebalance.approvalToken;
+    const approvalSpender = rebalance.approvalSpender;
+    const currentAllowance = await (0, liquidityHelpers_1.getAllowance)(publicClient, approvalToken, owner, chainId, approvalSpender);
+    const approval = currentAllowance < rebalance.approvalAmount
+        ? {
+            token: rebalance.approvalToken,
+            amount: rebalance.approvalAmount,
+            params: (0, liquidityHelpers_1.buildApprovalParams)(chainId, approvalToken, rebalance.approvalAmount, approvalSpender),
+        }
+        : null;
+    return { approval, rebalance };
+}
+//# sourceMappingURL=rebalance.js.map

package/dist/services/pools/PoolService.d.ts

@@ -1,4 +1,4 @@
-import { Pool, PoolDetails } from '../../core/types';
+import { Pool, PoolDetails, PoolRebalancePreview } from '../../core/types';
 import { PublicClient } from 'viem';
 /**
  * Result of pool discovery including any warnings from failed factories
@@ -62,6 +62,8 @@ export declare class PoolService {
      * ```
      */
     getPoolDetails(poolAddr: string): Promise<PoolDetails>;
+    getPoolRebalancePreview(poolAddr: string): Promise<PoolRebalancePreview | null>;
+    getPoolRebalancePreviewBatch(poolAddresses?: string[]): Promise<Array<PoolRebalancePreview | null>>;
     getPoolDetailsBatch(poolAddresses?: string[]): Promise<PoolDetails[]>;
 }
 //# sourceMappingURL=PoolService.d.ts.map

package/dist/services/pools/PoolService.js

@@ -4,6 +4,7 @@ exports.PoolService = void 0;
 const types_1 = require("../../core/types");
 const poolDiscovery_1 = require("./poolDiscovery");
 const poolDetails_1 = require("./poolDetails");
+const rebalancePreview_1 = require("./rebalancePreview");
 /**
  * Service for discovering liquidity pools in the Mento protocol.
  * Aggregates pools from multiple factory contracts (FPMM and VirtualPool).
@@ -107,6 +108,14 @@ class PoolService {
         const [details] = await this.getPoolDetailsBatch([poolAddr]);
         return details;
     }
+    async getPoolRebalancePreview(poolAddr) {
+        const details = await this.getPoolDetails(poolAddr);
+        return (0, rebalancePreview_1.fetchPoolRebalancePreview)(this.publicClient, details);
+    }
+    async getPoolRebalancePreviewBatch(poolAddresses) {
+        const details = await this.getPoolDetailsBatch(poolAddresses);
+        return (0, rebalancePreview_1.fetchPoolRebalancePreviewBatch)(this.publicClient, details);
+    }
     async getPoolDetailsBatch(poolAddresses) {
         const pools = await this.getPools();
         const targets = poolAddresses

package/dist/services/pools/poolDetails.js

@@ -21,17 +21,18 @@ async function fetchFPMMPoolDetailsBatch(publicClient, chainId, pools) {
     if (pools.length === 0) {
         return [];
     }
-    const knownStrategies = getKnownLiquidityStrategies(chainId);
-    const contracts = pools.flatMap((pool) => buildFPMMContracts(pool, knownStrategies));
+    const openLiquidityStrategy = getOpenLiquidityStrategy(chainId);
+    const contracts = pools.flatMap((pool) => buildFPMMContracts(pool, openLiquidityStrategy));
     const results = await (0, multicall_1.multicall)(publicClient, contracts);
-    const perPoolResultCount = FPMM_FIXED_RESULT_COUNT + knownStrategies.length + 1;
+    const strategyCheckCount = openLiquidityStrategy ? 1 : 0;
+    const perPoolResultCount = FPMM_FIXED_RESULT_COUNT + strategyCheckCount + 1;
     return pools.map((pool, index) => {
         const offset = index * perPoolResultCount;
         const poolResults = results.slice(offset, offset + perPoolResultCount);
-        return parseFPMMPoolDetails(pool, knownStrategies, poolResults);
+        return parseFPMMPoolDetails(pool, openLiquidityStrategy, poolResults);
     });
 }
-function buildFPMMContracts(pool, knownStrategies) {
+function buildFPMMContracts(pool, openLiquidityStrategy) {
     const address = pool.poolAddr;
     return [
         { address, abi: abis_1.FPMM_ABI, functionName: 'getReserves' },
@@ -42,16 +43,18 @@ function buildFPMMContracts(pool, knownStrategies) {
         { address, abi: abis_1.FPMM_ABI, functionName: 'rebalanceIncentive' },
         { address, abi: abis_1.FPMM_ABI, functionName: 'rebalanceThresholdAbove' },
         { address, abi: abis_1.FPMM_ABI, functionName: 'rebalanceThresholdBelow' },
-        ...knownStrategies.map((strategyAddr) => ({
-            address,
-            abi: abis_1.FPMM_ABI,
-            functionName: 'liquidityStrategy',
-            args: [strategyAddr],
-        })),
+        ...(openLiquidityStrategy
+            ? [{
+                    address,
+                    abi: abis_1.FPMM_ABI,
+                    functionName: 'liquidityStrategy',
+                    args: [openLiquidityStrategy],
+                }]
+            : []),
         { address, abi: abis_1.FPMM_ABI, functionName: 'getRebalancingState' },
     ];
 }
-function parseFPMMPoolDetails(pool, knownStrategies, results) {
+function parseFPMMPoolDetails(pool, openLiquidityStrategy, results) {
     try {
         const reservesRes = results[0];
         const decimals0Res = results[1];
@@ -85,10 +88,14 @@ function parseFPMMPoolDetails(pool, knownStrategies, results) {
         const rebalanceIncentiveBps = rebalanceIncentiveRes.result;
         const thresholdAboveBps = thresholdAboveRes.result;
         const thresholdBelowBps = thresholdBelowRes.result;
-        const strategyResults = results.slice(FPMM_FIXED_RESULT_COUNT, FPMM_FIXED_RESULT_COUNT + knownStrategies.length);
-        const activeIndex = strategyResults.findIndex((result) => result.status === 'success' && result.result === true);
-        const liquidityStrategy = activeIndex >= 0 ? knownStrategies[activeIndex] : null;
-        const rebalancingRes = results[FPMM_FIXED_RESULT_COUNT + knownStrategies.length];
+        const strategyCheckCount = openLiquidityStrategy ? 1 : 0;
+        const openStrategyResult = strategyCheckCount > 0 ? results[FPMM_FIXED_RESULT_COUNT] : null;
+        const liquidityStrategy = openLiquidityStrategy &&
+            openStrategyResult?.status === 'success' &&
+            openStrategyResult.result === true
+            ? openLiquidityStrategy
+            : null;
+        const rebalancingRes = results[FPMM_FIXED_RESULT_COUNT + strategyCheckCount];
         let pricing = null;
         let inBand = null;
         if (rebalancingRes?.status === 'success') {
@@ -193,24 +200,17 @@ function parseVirtualPoolDetails(pool, results) {
     }
 }
 /**
- * Returns the known liquidity strategy addresses for the given chain.
+ * Returns the configured Open Liquidity Strategy for the given chain.
  */
-function getKnownLiquidityStrategies(chainId) {
-    const chainAddresses = constants_1.addresses[chainId];
-    if (!chainAddresses)
-        return [];
-    const strategyCandidates = [
-        chainAddresses.ReserveLiquidityStrategy,
-        chainAddresses.CDPLiquidityStrategy,
-    ].filter((address) => Boolean(address));
-    // Normalize to checksummed addresses and ignore malformed config values.
-    return strategyCandidates.flatMap((address) => {
-        try {
-            return [(0, viem_1.getAddress)(address)];
-        }
-        catch {
-            return [];
-        }
-    });
+function getOpenLiquidityStrategy(chainId) {
+    const strategyAddress = (0, constants_1.tryGetContractAddress)(chainId, 'OpenLiquidityStrategy');
+    if (!strategyAddress)
+        return null;
+    try {
+        return (0, viem_1.getAddress)(strategyAddress);
+    }
+    catch {
+        return null;
+    }
 }
 //# sourceMappingURL=poolDetails.js.map

package/dist/services/pools/rebalancePreview.d.ts

@@ -0,0 +1,5 @@
+import { type PublicClient } from 'viem';
+import type { PoolDetails, PoolRebalancePreview } from '../../core/types';
+export declare function fetchPoolRebalancePreview(publicClient: PublicClient, detail: PoolDetails): Promise<PoolRebalancePreview | null>;
+export declare function fetchPoolRebalancePreviewBatch(publicClient: PublicClient, details: PoolDetails[]): Promise<Array<PoolRebalancePreview | null>>;
+//# sourceMappingURL=rebalancePreview.d.ts.map

package/dist/services/pools/rebalancePreview.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchPoolRebalancePreview = fetchPoolRebalancePreview;
+exports.fetchPoolRebalancePreviewBatch = fetchPoolRebalancePreviewBatch;
+const viem_1 = require("viem");
+const abis_1 = require("../../core/abis");
+const multicall_1 = require("../../utils/multicall");
+// Liquidity strategy incentive rates are stored as 18-decimal percentages.
+const FEE_DENOMINATOR = 10n ** 18n;
+function toBigIntValue(value) {
+    return typeof value === 'bigint' ? value : BigInt(value);
+}
+function toNumberValue(value) {
+    return typeof value === 'number' ? value : Number(value);
+}
+function parseDirection(value) {
+    const normalized = toNumberValue(value);
+    if (normalized === 0)
+        return 'Expand';
+    if (normalized === 1)
+        return 'Contract';
+    throw new Error(`Unsupported liquidity strategy direction: ${normalized}`);
+}
+function parsePoolConfig(raw) {
+    return {
+        isToken0Debt: raw[0],
+        lastRebalance: toNumberValue(raw[1]),
+        rebalanceCooldown: toNumberValue(raw[2]),
+        protocolFeeRecipient: raw[3],
+        liquiditySourceIncentiveExpansion: toBigIntValue(raw[4]),
+        protocolIncentiveExpansion: toBigIntValue(raw[5]),
+        liquiditySourceIncentiveContraction: toBigIntValue(raw[6]),
+        protocolIncentiveContraction: toBigIntValue(raw[7]),
+    };
+}
+function parseContext(raw) {
+    return {
+        pool: raw[0],
+        reserves: {
+            reserveNum: toBigIntValue(raw[1][0]),
+            reserveDen: toBigIntValue(raw[1][1]),
+        },
+        prices: {
+            oracleNum: toBigIntValue(raw[2][0]),
+            oracleDen: toBigIntValue(raw[2][1]),
+            poolPriceAbove: raw[2][2],
+            rebalanceThreshold: toNumberValue(raw[2][3]),
+        },
+        token0: raw[3],
+        token1: raw[4],
+        token0Dec: toBigIntValue(raw[5]),
+        token1Dec: toBigIntValue(raw[6]),
+        isToken0Debt: raw[7],
+        incentives: {
+            liquiditySourceIncentiveExpansion: toBigIntValue(raw[8][0]),
+            protocolIncentiveExpansion: toBigIntValue(raw[8][1]),
+            liquiditySourceIncentiveContraction: toBigIntValue(raw[8][2]),
+            protocolIncentiveContraction: toBigIntValue(raw[8][3]),
+        },
+    };
+}
+function parseAction(raw) {
+    return {
+        dir: parseDirection(raw[0]),
+        amount0Out: toBigIntValue(raw[1]),
+        amount1Out: toBigIntValue(raw[2]),
+        amountOwedToPool: toBigIntValue(raw[3]),
+    };
+}
+function isPreviewEligible(detail) {
+    return (detail.poolType === 'FPMM' &&
+        detail.pricing !== null &&
+        detail.rebalancing.inBand === false &&
+        !!detail.rebalancing.liquidityStrategy);
+}
+function buildPreview(detail, strategyAddress, config, context, action) {
+    const debtToken = context.isToken0Debt ? context.token0 : context.token1;
+    const collateralToken = context.isToken0Debt ? context.token1 : context.token0;
+    const inputToken = action.dir === 'Expand' ? debtToken : collateralToken;
+    const outputToken = action.dir === 'Expand' ? collateralToken : debtToken;
+    const amountTransferredValue = action.amount0Out > 0n ? action.amount0Out : action.amount1Out;
+    const protocolRate = action.dir === 'Expand'
+        ? config.protocolIncentiveExpansion
+        : config.protocolIncentiveContraction;
+    const liquiditySourceRate = action.dir === 'Expand'
+        ? config.liquiditySourceIncentiveExpansion
+        : config.liquiditySourceIncentiveContraction;
+    const protocolIncentiveAmount = (amountTransferredValue * protocolRate) / FEE_DENOMINATOR;
+    const liquiditySourceBase = amountTransferredValue > protocolIncentiveAmount
+        ? amountTransferredValue - protocolIncentiveAmount
+        : 0n;
+    const liquiditySourceIncentiveAmount = (liquiditySourceBase * liquiditySourceRate) / FEE_DENOMINATOR;
+    return {
+        poolAddress: detail.poolAddr,
+        strategyAddress,
+        direction: action.dir,
+        config,
+        context,
+        action,
+        inputToken,
+        outputToken,
+        amountRequired: {
+            token: inputToken,
+            amount: action.amountOwedToPool,
+        },
+        amountTransferred: {
+            token: outputToken,
+            amount: amountTransferredValue,
+        },
+        protocolIncentive: {
+            token: outputToken,
+            amount: protocolIncentiveAmount,
+        },
+        liquiditySourceIncentive: {
+            token: outputToken,
+            amount: liquiditySourceIncentiveAmount,
+        },
+        approvalToken: inputToken,
+        approvalSpender: strategyAddress,
+        approvalAmount: action.amountOwedToPool,
+    };
+}
+async function fetchPoolRebalancePreview(publicClient, detail) {
+    const [preview] = await fetchPoolRebalancePreviewBatch(publicClient, [detail]);
+    return preview;
+}
+async function fetchPoolRebalancePreviewBatch(publicClient, details) {
+    const previews = details.map(() => null);
+    const eligibleTargets = details.flatMap((detail, index) => {
+        if (!isPreviewEligible(detail))
+            return [];
+        const strategyAddress = detail.rebalancing.liquidityStrategy;
+        if (!strategyAddress)
+            return [];
+        try {
+            return [
+                {
+                    index,
+                    detail,
+                    strategyAddress: (0, viem_1.getAddress)(strategyAddress),
+                },
+            ];
+        }
+        catch {
+            return [];
+        }
+    });
+    if (eligibleTargets.length === 0) {
+        return previews;
+    }
+    const contracts = eligibleTargets.flatMap(({ detail, strategyAddress }) => [
+        {
+            address: strategyAddress,
+            abi: abis_1.LIQUIDITY_STRATEGY_ABI,
+            functionName: 'poolConfigs',
+            args: [detail.poolAddr],
+        },
+        {
+            address: strategyAddress,
+            abi: abis_1.LIQUIDITY_STRATEGY_ABI,
+            functionName: 'determineAction',
+            args: [detail.poolAddr],
+        },
+    ]);
+    const results = await (0, multicall_1.multicall)(publicClient, contracts);
+    eligibleTargets.forEach((target, targetIndex) => {
+        const configResult = results[targetIndex * 2];
+        const determineActionResult = results[targetIndex * 2 + 1];
+        if (!configResult || !determineActionResult)
+            return;
+        if (configResult.status === 'failure' || determineActionResult.status === 'failure')
+            return;
+        try {
+            const config = parsePoolConfig(configResult.result);
+            const [rawContext, rawAction] = determineActionResult.result;
+            const context = parseContext(rawContext);
+            const action = parseAction(rawAction);
+            previews[target.index] = buildPreview(target.detail, target.strategyAddress, config, context, action);
+        }
+        catch {
+            previews[target.index] = null;
+        }
+    });
+    return previews;
+}
+//# sourceMappingURL=rebalancePreview.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mento-protocol/mento-sdk",
   "description": "Official SDK for interacting with the Mento Protocol",
-  "version": "3.1.0-beta.5",
+  "version": "3.1.0-beta.6",
   "license": "MIT",
   "author": "Mento Labs",
   "keywords": [