@morpho-org/consumer-sdk 0.4.0 → 0.5.0

package/lib/entities/marketV1/marketV1.js

@@ -0,0 +1,528 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MorphoMarketV1 = void 0;
+const blue_sdk_1 = require("@morpho-org/blue-sdk");
+const blue_sdk_viem_1 = require("@morpho-org/blue-sdk-viem");
+const simulation_sdk_1 = require("@morpho-org/simulation-sdk");
+const actions_1 = require("../../actions");
+const helpers_1 = require("../../helpers");
+const types_1 = require("../../types");
+class MorphoMarketV1 {
+    client;
+    marketParams;
+    chainId;
+    constructor(client, marketParams, chainId) {
+        this.client = client;
+        this.marketParams = marketParams;
+        this.chainId = chainId;
+    }
+    async getMarketData(parameters) {
+        (0, helpers_1.validateChainId)(this.client.viemClient.chain?.id, this.chainId);
+        return (0, blue_sdk_viem_1.fetchMarket)(this.marketParams.id, this.client.viemClient, {
+            ...parameters,
+            chainId: this.chainId,
+            deployless: this.client.options.supportDeployless,
+        });
+    }
+    async getPositionData(userAddress, parameters) {
+        (0, helpers_1.validateChainId)(this.client.viemClient.chain?.id, this.chainId);
+        return (0, blue_sdk_viem_1.fetchAccrualPosition)(userAddress, this.marketParams.id, this.client.viemClient, {
+            ...parameters,
+            deployless: this.client.options.supportDeployless,
+            chainId: this.chainId,
+        });
+    }
+    supplyCollateral({ amount = 0n, userAddress, nativeAmount, }) {
+        (0, helpers_1.validateChainId)(this.client.viemClient.chain?.id, this.chainId);
+        (0, helpers_1.validateUserAddress)(this.client.viemClient.account?.address, userAddress);
+        if (amount < 0n) {
+            throw new types_1.NonPositiveAssetAmountError(this.marketParams.collateralToken);
+        }
+        if (nativeAmount !== undefined && nativeAmount < 0n) {
+            throw new types_1.NegativeNativeAmountError(nativeAmount);
+        }
+        const totalCollateral = amount + (nativeAmount ?? 0n);
+        if (totalCollateral === 0n) {
+            throw new types_1.ZeroCollateralAmountError(this.marketParams.id);
+        }
+        if (nativeAmount !== undefined && nativeAmount > 0n) {
+            (0, helpers_1.validateNativeCollateral)(this.chainId, this.marketParams.collateralToken);
+        }
+        return {
+            getRequirements: (params) => (0, actions_1.getRequirements)(this.client.viemClient, {
+                address: this.marketParams.collateralToken,
+                chainId: this.chainId,
+                supportSignature: this.client.options.supportSignature,
+                supportDeployless: this.client.options.supportDeployless,
+                useSimplePermit: params?.useSimplePermit,
+                args: { amount, from: userAddress },
+            }),
+            buildTx: (requirementSignature) => (0, actions_1.marketV1SupplyCollateral)({
+                market: {
+                    chainId: this.chainId,
+                    marketParams: this.marketParams,
+                },
+                args: {
+                    amount,
+                    nativeAmount,
+                    onBehalf: userAddress,
+                    requirementSignature,
+                },
+                metadata: this.client.options.metadata,
+            }),
+        };
+    }
+    borrow({ amount, userAddress, positionData, slippageTolerance = blue_sdk_1.DEFAULT_SLIPPAGE_TOLERANCE, reallocations, }) {
+        (0, helpers_1.validateChainId)(this.client.viemClient.chain?.id, this.chainId);
+        (0, helpers_1.validateUserAddress)(this.client.viemClient.account?.address, userAddress);
+        if (amount <= 0n) {
+            throw new types_1.NonPositiveBorrowAmountError(this.marketParams.id);
+        }
+        (0, helpers_1.validateSlippageTolerance)(slippageTolerance);
+        if (!positionData) {
+            throw new types_1.MissingAccrualPositionError(this.marketParams.id);
+        }
+        (0, helpers_1.validateAccrualPosition)({
+            positionData,
+            expectedMarketId: this.marketParams.id,
+            expectedUser: userAddress,
+        });
+        (0, helpers_1.validatePositionHealth)({
+            positionData,
+            additionalCollateral: 0n,
+            borrowAmount: amount,
+            marketId: this.marketParams.id,
+            lltv: this.marketParams.lltv,
+        });
+        const minSharePrice = (0, helpers_1.computeMinBorrowSharePrice)({
+            borrowAmount: amount,
+            market: positionData.market,
+            slippageTolerance,
+        });
+        return {
+            getRequirements: async () => {
+                const authTx = await (0, actions_1.getMorphoAuthorizationRequirement)({
+                    viemClient: this.client.viemClient,
+                    chainId: this.chainId,
+                    userAddress,
+                });
+                return authTx ? [authTx] : [];
+            },
+            buildTx: () => (0, actions_1.marketV1Borrow)({
+                market: {
+                    chainId: this.chainId,
+                    marketParams: this.marketParams,
+                },
+                args: {
+                    amount,
+                    receiver: userAddress,
+                    minSharePrice,
+                    reallocations,
+                },
+                metadata: this.client.options.metadata,
+            }),
+        };
+    }
+    repay(params) {
+        (0, helpers_1.validateChainId)(this.client.viemClient.chain?.id, this.chainId);
+        (0, helpers_1.validateUserAddress)(this.client.viemClient.account?.address, params.userAddress);
+        const { userAddress, positionData, slippageTolerance = blue_sdk_1.DEFAULT_SLIPPAGE_TOLERANCE, } = params;
+        if ("assets" in params && "shares" in params) {
+            throw new types_1.MutuallyExclusiveRepayAmountsError(this.marketParams.id);
+        }
+        const isSharesMode = "shares" in params;
+        if (isSharesMode) {
+            if (params.shares <= 0n) {
+                throw new types_1.NonPositiveRepayAmountError(this.marketParams.id);
+            }
+        }
+        else {
+            if (params.assets <= 0n) {
+                throw new types_1.NonPositiveRepayAmountError(this.marketParams.id);
+            }
+        }
+        (0, helpers_1.validateSlippageTolerance)(slippageTolerance);
+        if (!positionData) {
+            throw new types_1.MissingAccrualPositionError(this.marketParams.id);
+        }
+        (0, helpers_1.validateAccrualPosition)({
+            positionData,
+            expectedMarketId: this.marketParams.id,
+            expectedUser: userAddress,
+        });
+        let assets;
+        let shares;
+        let transferAmount;
+        if (isSharesMode) {
+            (0, helpers_1.validateRepayShares)({
+                positionData,
+                repayShares: params.shares,
+                marketId: this.marketParams.id,
+            });
+            assets = 0n;
+            shares = params.shares;
+            // Add slippage buffer to cover interest accrued between tx construction and execution.
+            // Without this, the on-chain repay amount may exceed the pre-transferred ERC20 amount.
+            const baseTransferAmount = positionData.market.toBorrowAssets(shares, "Up");
+            transferAmount = blue_sdk_1.MathLib.wMulUp(baseTransferAmount, blue_sdk_1.MathLib.WAD + slippageTolerance);
+        }
+        else {
+            (0, helpers_1.validateRepayAmount)({
+                positionData,
+                repayAssets: params.assets,
+                marketId: this.marketParams.id,
+            });
+            assets = params.assets;
+            shares = 0n;
+            transferAmount = params.assets;
+        }
+        const maxSharePrice = (0, helpers_1.computeMaxRepaySharePrice)({
+            repayAssets: assets,
+            repayShares: shares,
+            market: positionData.market,
+            slippageTolerance,
+        });
+        return {
+            getRequirements: (reqParams) => (0, actions_1.getRequirements)(this.client.viemClient, {
+                address: this.marketParams.loanToken,
+                chainId: this.chainId,
+                supportSignature: this.client.options.supportSignature,
+                supportDeployless: this.client.options.supportDeployless,
+                useSimplePermit: reqParams?.useSimplePermit,
+                args: { amount: transferAmount, from: userAddress },
+            }),
+            buildTx: (requirementSignature) => (0, actions_1.marketV1Repay)({
+                market: {
+                    chainId: this.chainId,
+                    marketParams: this.marketParams,
+                },
+                args: {
+                    assets,
+                    shares,
+                    transferAmount,
+                    onBehalf: userAddress,
+                    receiver: userAddress,
+                    maxSharePrice,
+                    requirementSignature,
+                },
+                metadata: this.client.options.metadata,
+            }),
+        };
+    }
+    withdrawCollateral({ userAddress, amount, positionData, }) {
+        (0, helpers_1.validateChainId)(this.client.viemClient.chain?.id, this.chainId);
+        (0, helpers_1.validateUserAddress)(this.client.viemClient.account?.address, userAddress);
+        if (amount <= 0n) {
+            throw new types_1.NonPositiveWithdrawCollateralAmountError(this.marketParams.id);
+        }
+        if (!positionData) {
+            throw new types_1.MissingAccrualPositionError(this.marketParams.id);
+        }
+        (0, helpers_1.validateAccrualPosition)({
+            positionData,
+            expectedMarketId: this.marketParams.id,
+            expectedUser: userAddress,
+        });
+        if (amount > positionData.collateral) {
+            throw new types_1.WithdrawExceedsCollateralError({
+                withdrawAmount: amount,
+                available: positionData.collateral,
+                market: positionData.marketId,
+            });
+        }
+        (0, helpers_1.validatePositionHealthAfterWithdraw)({
+            positionData,
+            withdrawAmount: amount,
+            lltv: this.marketParams.lltv,
+            marketId: this.marketParams.id,
+        });
+        return {
+            buildTx: () => (0, actions_1.marketV1WithdrawCollateral)({
+                market: {
+                    chainId: this.chainId,
+                    marketParams: this.marketParams,
+                },
+                args: {
+                    amount,
+                    onBehalf: userAddress,
+                    receiver: userAddress,
+                },
+                metadata: this.client.options.metadata,
+            }),
+        };
+    }
+    repayWithdrawCollateral(params) {
+        (0, helpers_1.validateChainId)(this.client.viemClient.chain?.id, this.chainId);
+        (0, helpers_1.validateUserAddress)(this.client.viemClient.account?.address, params.userAddress);
+        const { userAddress, withdrawAmount, positionData, slippageTolerance = blue_sdk_1.DEFAULT_SLIPPAGE_TOLERANCE, } = params;
+        if ("assets" in params && "shares" in params) {
+            throw new types_1.MutuallyExclusiveRepayAmountsError(this.marketParams.id);
+        }
+        const isSharesMode = "shares" in params;
+        if (isSharesMode) {
+            if (params.shares <= 0n) {
+                throw new types_1.NonPositiveRepayAmountError(this.marketParams.id);
+            }
+        }
+        else {
+            if (params.assets <= 0n) {
+                throw new types_1.NonPositiveRepayAmountError(this.marketParams.id);
+            }
+        }
+        if (withdrawAmount <= 0n) {
+            throw new types_1.NonPositiveWithdrawCollateralAmountError(this.marketParams.id);
+        }
+        (0, helpers_1.validateSlippageTolerance)(slippageTolerance);
+        if (!positionData) {
+            throw new types_1.MissingAccrualPositionError(this.marketParams.id);
+        }
+        (0, helpers_1.validateAccrualPosition)({
+            positionData,
+            expectedMarketId: this.marketParams.id,
+            expectedUser: userAddress,
+        });
+        let assets;
+        let shares;
+        let transferAmount;
+        if (isSharesMode) {
+            (0, helpers_1.validateRepayShares)({
+                positionData,
+                repayShares: params.shares,
+                marketId: this.marketParams.id,
+            });
+            assets = 0n;
+            shares = params.shares;
+            const baseTransferAmount = positionData.market.toBorrowAssets(shares, "Up");
+            transferAmount = blue_sdk_1.MathLib.wMulUp(baseTransferAmount, blue_sdk_1.MathLib.WAD + slippageTolerance);
+        }
+        else {
+            (0, helpers_1.validateRepayAmount)({
+                positionData,
+                repayAssets: params.assets,
+                marketId: this.marketParams.id,
+            });
+            assets = params.assets;
+            shares = 0n;
+            transferAmount = params.assets;
+        }
+        if (withdrawAmount > positionData.collateral) {
+            throw new types_1.WithdrawExceedsCollateralError({
+                withdrawAmount,
+                available: positionData.collateral,
+                market: positionData.marketId,
+            });
+        }
+        // Simulate repay to get post-repay position, then validate withdraw health
+        const { position: positionAfterRepay } = positionData.repay(assets, shares);
+        (0, helpers_1.validatePositionHealthAfterWithdraw)({
+            positionData: positionAfterRepay,
+            withdrawAmount,
+            lltv: this.marketParams.lltv,
+            marketId: this.marketParams.id,
+        });
+        const maxSharePrice = (0, helpers_1.computeMaxRepaySharePrice)({
+            repayAssets: assets,
+            repayShares: shares,
+            market: positionData.market,
+            slippageTolerance,
+        });
+        return {
+            getRequirements: async (reqParams) => {
+                const [erc20Requirements, authTx] = await Promise.all([
+                    (0, actions_1.getRequirements)(this.client.viemClient, {
+                        address: this.marketParams.loanToken,
+                        chainId: this.chainId,
+                        supportSignature: this.client.options.supportSignature,
+                        supportDeployless: this.client.options.supportDeployless,
+                        useSimplePermit: reqParams?.useSimplePermit,
+                        args: { amount: transferAmount, from: userAddress },
+                    }),
+                    (0, actions_1.getMorphoAuthorizationRequirement)({
+                        viemClient: this.client.viemClient,
+                        chainId: this.chainId,
+                        userAddress,
+                    }),
+                ]);
+                return [...erc20Requirements, ...(authTx ? [authTx] : [])];
+            },
+            buildTx: (requirementSignature) => (0, actions_1.marketV1RepayWithdrawCollateral)({
+                market: {
+                    chainId: this.chainId,
+                    marketParams: this.marketParams,
+                },
+                args: {
+                    assets,
+                    shares,
+                    transferAmount,
+                    withdrawAmount,
+                    onBehalf: userAddress,
+                    receiver: userAddress,
+                    maxSharePrice,
+                    requirementSignature,
+                },
+                metadata: this.client.options.metadata,
+            }),
+        };
+    }
+    supplyCollateralBorrow({ amount = 0n, userAddress, positionData, borrowAmount, nativeAmount, slippageTolerance = blue_sdk_1.DEFAULT_SLIPPAGE_TOLERANCE, reallocations, }) {
+        (0, helpers_1.validateChainId)(this.client.viemClient.chain?.id, this.chainId);
+        (0, helpers_1.validateUserAddress)(this.client.viemClient.account?.address, userAddress);
+        if (amount < 0n) {
+            throw new types_1.NonPositiveAssetAmountError(this.marketParams.collateralToken);
+        }
+        if (nativeAmount !== undefined && nativeAmount < 0n) {
+            throw new types_1.NegativeNativeAmountError(nativeAmount);
+        }
+        if (borrowAmount <= 0n) {
+            throw new types_1.NonPositiveBorrowAmountError(this.marketParams.id);
+        }
+        if (!positionData) {
+            throw new types_1.MissingAccrualPositionError(this.marketParams.id);
+        }
+        (0, helpers_1.validateAccrualPosition)({
+            positionData,
+            expectedMarketId: this.marketParams.id,
+            expectedUser: userAddress,
+        });
+        const totalCollateral = amount + (nativeAmount ?? 0n);
+        if (totalCollateral === 0n) {
+            throw new types_1.ZeroCollateralAmountError(this.marketParams.id);
+        }
+        (0, helpers_1.validateSlippageTolerance)(slippageTolerance);
+        if (nativeAmount !== undefined && nativeAmount > 0n) {
+            (0, helpers_1.validateNativeCollateral)(this.chainId, this.marketParams.collateralToken);
+        }
+        (0, helpers_1.validatePositionHealth)({
+            positionData,
+            additionalCollateral: totalCollateral,
+            borrowAmount,
+            marketId: this.marketParams.id,
+            lltv: this.marketParams.lltv,
+        });
+        const minSharePrice = (0, helpers_1.computeMinBorrowSharePrice)({
+            borrowAmount,
+            market: positionData.market,
+            slippageTolerance,
+        });
+        return {
+            getRequirements: async (params) => {
+                const [erc20Requirements, authTx] = await Promise.all([
+                    (0, actions_1.getRequirements)(this.client.viemClient, {
+                        address: this.marketParams.collateralToken,
+                        chainId: this.chainId,
+                        supportSignature: this.client.options.supportSignature,
+                        supportDeployless: this.client.options.supportDeployless,
+                        useSimplePermit: params?.useSimplePermit,
+                        args: { amount, from: userAddress },
+                    }),
+                    (0, actions_1.getMorphoAuthorizationRequirement)({
+                        viemClient: this.client.viemClient,
+                        chainId: this.chainId,
+                        userAddress,
+                    }),
+                ]);
+                return [...erc20Requirements, ...(authTx ? [authTx] : [])];
+            },
+            buildTx: (requirementSignature) => (0, actions_1.marketV1SupplyCollateralBorrow)({
+                market: {
+                    chainId: this.chainId,
+                    marketParams: this.marketParams,
+                },
+                args: {
+                    amount,
+                    nativeAmount,
+                    borrowAmount,
+                    onBehalf: userAddress,
+                    receiver: userAddress,
+                    minSharePrice,
+                    requirementSignature,
+                    reallocations,
+                },
+                metadata: this.client.options.metadata,
+            }),
+        };
+    }
+    async getReallocationData({ vaultAddresses, market, block, }) {
+        (0, helpers_1.validateChainId)(this.client.viemClient.chain?.id, this.chainId);
+        if (market.id !== this.marketParams.id) {
+            throw new types_1.MarketIdMismatchError(market.id, this.marketParams.id);
+        }
+        const client = this.client.viemClient;
+        const fetchParams = {
+            blockNumber: block.number,
+            chainId: this.chainId,
+            deployless: this.client.options.supportDeployless,
+        };
+        // Phase 1: Fetch all vaults in parallel to get their withdrawQueues.
+        const vaults = await Promise.all(vaultAddresses.map((addr) => (0, blue_sdk_viem_1.fetchVault)(addr, client, fetchParams)));
+        // Collect unique market IDs from all vault withdrawQueues + target market.
+        const targetMarketId = this.marketParams.id;
+        const allMarketIds = new Set([targetMarketId]);
+        const vaultMarketPairs = [];
+        for (const vault of vaults) {
+            // Always include target market pair so its config/position is fetched
+            // even when the target market is only in the vault's supplyQueue.
+            vaultMarketPairs.push({ vault: vault.address, marketId: targetMarketId });
+            for (const mid of vault.withdrawQueue) {
+                allMarketIds.add(mid);
+                if (mid !== targetMarketId) {
+                    vaultMarketPairs.push({ vault: vault.address, marketId: mid });
+                }
+            }
+        }
+        // Phase 2: Fetch all source markets, vault configs, and positions in parallel.
+        const sourceMarketIds = [...allMarketIds].filter((mid) => mid !== targetMarketId);
+        const loanToken = market.params.loanToken;
+        const [markets, configs, positions, holdings] = await Promise.all([
+            Promise.all(sourceMarketIds.map((mid) => (0, blue_sdk_viem_1.fetchMarket)(mid, client, fetchParams))),
+            Promise.all(vaultMarketPairs.map(({ vault, marketId: mid }) => (0, blue_sdk_viem_1.fetchVaultMarketConfig)(vault, mid, client, fetchParams).then((config) => ({ vault, mid, config })))),
+            Promise.all(vaultMarketPairs.map(({ vault, marketId: mid }) => (0, blue_sdk_viem_1.fetchPosition)(vault, mid, client, fetchParams).then((position) => ({
+                vault,
+                mid,
+                position,
+            })))),
+            Promise.all(vaultAddresses.map((addr) => (0, blue_sdk_viem_1.fetchHolding)(addr, loanToken, client, fetchParams))),
+        ]);
+        // Assemble records for SimulationState.
+        const marketsRecord = {
+            [targetMarketId]: market,
+        };
+        for (const m of markets) {
+            marketsRecord[m.id] = m;
+        }
+        const vaultsRecord = {};
+        for (const v of vaults) {
+            vaultsRecord[v.address] = v;
+        }
+        const vaultMarketConfigsRecord = {};
+        for (const { vault, mid, config } of configs) {
+            (vaultMarketConfigsRecord[vault] ??= {})[mid] = config;
+        }
+        const positionsRecord = {};
+        for (const { vault, mid, position } of positions) {
+            (positionsRecord[vault] ??= {})[mid] = position;
+        }
+        const holdingsRecord = {};
+        for (const holding of holdings) {
+            (holdingsRecord[holding.user] ??= {})[holding.token] = holding;
+        }
+        return new simulation_sdk_1.SimulationState({
+            chainId: this.chainId,
+            block,
+            markets: marketsRecord,
+            vaults: vaultsRecord,
+            vaultMarketConfigs: vaultMarketConfigsRecord,
+            positions: positionsRecord,
+            holdings: holdingsRecord,
+        });
+    }
+    getReallocations({ reallocationData, borrowAmount, options, }) {
+        return (0, helpers_1.computeReallocations)({
+            reallocationData,
+            marketId: this.marketParams.id,
+            borrowAmount,
+            options: { enabled: true, ...options },
+        });
+    }
+}
+exports.MorphoMarketV1 = MorphoMarketV1;

package/lib/entities/vaultV1/vaultV1.js

@@ -17,6 +17,10 @@ class MorphoVaultV1 {
         this.chainId = chainId;
     }
     async getData(parameters) {
+        if (this.client.viemClient.chain?.id &&
+            this.client.viemClient.chain?.id !== this.chainId) {
+            throw new types_1.ChainIdMismatchError(this.client.viemClient.chain?.id, this.chainId);
+        }
         return (0, blue_sdk_viem_1.fetchAccrualVault)(this.vault, this.client.viemClient, {
             ...parameters,
             chainId: this.chainId,

package/lib/entities/vaultV2/vaultV2.js

@@ -17,6 +17,10 @@ class MorphoVaultV2 {
         this.chainId = chainId;
     }
     async getData(parameters) {
+        if (this.client.viemClient.chain?.id &&
+            this.client.viemClient.chain?.id !== this.chainId) {
+            throw new types_1.ChainIdMismatchError(this.client.viemClient.chain?.id, this.chainId);
+        }
         return (0, blue_sdk_viem_1.fetchAccrualVaultV2)(this.vault, this.client.viemClient, {
             ...parameters,
             chainId: this.chainId,

package/lib/helpers/computeReallocations.d.ts

@@ -0,0 +1,23 @@
+import { type MarketId } from "@morpho-org/blue-sdk";
+import type { SimulationState } from "@morpho-org/simulation-sdk";
+import { type ReallocationComputeOptions, type VaultReallocation } from "../types";
+/**
+ * Computes vault reallocations for a borrow operation on a target market.
+ *
+ * Replicates the shared liquidity algorithm from `populateSubBundle` in
+ * `@morpho-org/bundler-sdk-viem`. First attempts "friendly" reallocations
+ * respecting withdrawal utilization targets, then falls back to aggressive
+ * reallocations (100% withdrawal utilization) if liquidity is still insufficient.
+ *
+ * @param params.reallocationData - The simulation state containing market, vault, and position data.
+ * @param params.marketId - The target market to reallocate liquidity into.
+ * @param params.borrowAmount - The intended borrow amount (used to compute post-borrow utilization).
+ * @param params.options - Optional reallocation computation options.
+ * @returns Array of vault reallocations, sorted with withdrawals in ascending market id order.
+ */
+export declare const computeReallocations: ({ reallocationData: data, marketId, borrowAmount, options, }: {
+    readonly reallocationData: SimulationState;
+    readonly marketId: MarketId;
+    readonly borrowAmount: bigint;
+    readonly options?: ReallocationComputeOptions;
+}) => readonly VaultReallocation[];

package/lib/helpers/computeReallocations.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeReallocations = void 0;
+const blue_sdk_1 = require("@morpho-org/blue-sdk");
+const bundler_sdk_viem_1 = require("@morpho-org/bundler-sdk-viem");
+const types_1 = require("../types");
+/**
+ * Computes vault reallocations for a borrow operation on a target market.
+ *
+ * Replicates the shared liquidity algorithm from `populateSubBundle` in
+ * `@morpho-org/bundler-sdk-viem`. First attempts "friendly" reallocations
+ * respecting withdrawal utilization targets, then falls back to aggressive
+ * reallocations (100% withdrawal utilization) if liquidity is still insufficient.
+ *
+ * @param params.reallocationData - The simulation state containing market, vault, and position data.
+ * @param params.marketId - The target market to reallocate liquidity into.
+ * @param params.borrowAmount - The intended borrow amount (used to compute post-borrow utilization).
+ * @param params.options - Optional reallocation computation options.
+ * @returns Array of vault reallocations, sorted with withdrawals in ascending market id order.
+ */
+const computeReallocations = ({ reallocationData: data, marketId, borrowAmount, options, }) => {
+    if (options?.enabled === false)
+        return [];
+    const market = data.getMarket(marketId).accrueInterest(data.block.timestamp);
+    const newTotalBorrowAssets = market.totalBorrowAssets + borrowAmount;
+    const newTotalSupplyAssets = market.totalSupplyAssets;
+    const supplyTargetUtilization = options?.supplyTargetUtilization?.[market.params.id] ??
+        options?.defaultSupplyTargetUtilization ??
+        bundler_sdk_viem_1.DEFAULT_SUPPLY_TARGET_UTILIZATION;
+    if (blue_sdk_1.MarketUtils.getUtilization({
+        totalSupplyAssets: newTotalSupplyAssets,
+        totalBorrowAssets: newTotalBorrowAssets,
+    }) <= supplyTargetUtilization)
+        return [];
+    // Solve: newTotalBorrowAssets / (newTotalSupplyAssets + reallocatedAssets) = supplyTargetUtilization
+    let requiredAssets = supplyTargetUtilization === 0n
+        ? blue_sdk_1.MathLib.MAX_UINT_160
+        : blue_sdk_1.MathLib.wDivDown(newTotalBorrowAssets, supplyTargetUtilization) -
+            newTotalSupplyAssets;
+    // Phase 1: "friendly" reallocations respecting withdrawal utilization targets.
+    const { withdrawals: friendlyWithdrawals, data: friendlyReallocationData } = data.getMarketPublicReallocations(market.id, options);
+    const withdrawals = [...friendlyWithdrawals];
+    const friendlyReallocationMarket = friendlyReallocationData.getMarket(market.id);
+    if (friendlyReallocationMarket.totalBorrowAssets + borrowAmount >
+        friendlyReallocationMarket.totalSupplyAssets) {
+        // Phase 2: "aggressive" — fully withdraw from every market (100% utilization).
+        requiredAssets = newTotalBorrowAssets - newTotalSupplyAssets;
+        withdrawals.push(...friendlyReallocationData.getMarketPublicReallocations(market.id, {
+            ...options,
+            defaultMaxWithdrawalUtilization: blue_sdk_1.MathLib.WAD,
+            maxWithdrawalUtilization: {},
+        }).withdrawals);
+    }
+    if (requiredAssets <= 0n)
+        return [];
+    // Group withdrawals by vault, capping total at requiredAssets.
+    const reallocationsMap = {};
+    for (const { vault, ...withdrawal } of withdrawals) {
+        const vaultReallocations = (reallocationsMap[vault] ??= []);
+        const existing = vaultReallocations.find((item) => item.id === withdrawal.id);
+        const reallocatedAssets = blue_sdk_1.MathLib.min(withdrawal.assets, requiredAssets);
+        if (reallocatedAssets <= 0n)
+            continue;
+        if (existing != null) {
+            existing.assets += reallocatedAssets;
+        }
+        else {
+            vaultReallocations.push({
+                ...withdrawal,
+                assets: reallocatedAssets,
+            });
+        }
+        requiredAssets -= reallocatedAssets;
+        if (requiredAssets === 0n)
+            break;
+    }
+    // Transform into VaultReallocation[] format.
+    return Object.entries(reallocationsMap)
+        .filter(([, vaultWithdrawals]) => vaultWithdrawals.length > 0)
+        .map(([vault, vaultWithdrawals]) => ({
+        vault: vault,
+        fee: (() => {
+            const config = data.getVault(vault).publicAllocatorConfig;
+            if (config == null) {
+                throw new types_1.MissingPublicAllocatorConfigError(vault);
+            }
+            return config.fee;
+        })(),
+        withdrawals: vaultWithdrawals
+            // Reallocation withdrawals must be sorted by market id in ascending order.
+            .sort(({ id: idA }, { id: idB }) => idA > idB ? 1 : idA < idB ? -1 : 0)
+            .map(({ id, assets }) => ({
+            marketParams: data.getMarket(id).params,
+            amount: assets,
+        })),
+    }));
+};
+exports.computeReallocations = computeReallocations;

package/lib/helpers/constant.d.ts

@@ -1 +1,6 @@
+/** Maximum slippage tolerance: 10% */
 export declare const MAX_SLIPPAGE_TOLERANCE: bigint;
+/** Default LLTV buffer: 0.5% below LLTV. Prevents instant liquidation on new positions. */
+export declare const DEFAULT_LLTV_BUFFER: bigint;
+/** Maximum absolute share price cap (100 RAY). Prevents absurd maxSharePrice values in repay. */
+export declare const MAX_ABSOLUTE_SHARE_PRICE: bigint;