@gearbox-protocol/sdk 16.0.0-next.16 → 16.0.0-next.18

package/dist/cjs/onchain/accounts/intents/index.js

@@ -50,6 +50,10 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 	* withdraw form should offer. Taking everything out is the same intent with
 	* `MAX_UINT256` for an amount, and needs none of this arithmetic.
 	*
+	* Takes no target health factor, unlike {@link maxWithdrawCollateral}: a
+	* proportional withdrawal leaves the factor where it found it, and the
+	* facade's `minDebt` is what bounds it.
+	*
 	* @param props - Account slice and the SDK holding its market
 	* @returns Amount in underlying units; `0n` when nothing can leave
 	*/
@@ -85,8 +89,9 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 	* yet, and adjusting measures against the net value the caller already
 	* holds. Nothing is fetched, so a form can ask on every keystroke.
 	*
-	* @param props - The manager, the SDK holding its market, and what stands
-	* behind the position
+	* @param props - The manager, the SDK holding its market, what stands
+	* behind the position, and optionally the health factor the ceiling should
+	* leave
 	* @returns The band, or nothing when the market has none to offer
 	*/
 	leverageBand(props) {
@@ -94,19 +99,23 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 	}
 	/**
 	* Largest `WITHDRAW_ASSET` amount of one token the account can take out
-	* while its health factor stays at {@link MIN_HF_LIMITED} plus a basis
-	* point — the ceiling a withdraw-collateral form should offer. Thresholds,
-	* prices and quota activity come from the account's market, valued the way
-	* the facade values a call that pays out; zero debt frees the whole balance.
+	* while its health factor stays at `targetHF` — the ceiling a
+	* withdraw-collateral form should offer. Thresholds, prices and quota
+	* activity come from the account's market, valued the way the facade values
+	* a call that pays out; zero debt frees the whole balance.
+	*
+	* The default is {@link MIN_HF_LIMITED}, the bar `validateHF` holds an
+	* account to.
 	*
-	* @param props - Account slice, the SDK holding its market, and the
-	* collateral to withdraw
+	* @param props - Account slice, the SDK holding its market, the collateral
+	* to withdraw, and optionally the health factor to leave behind
 	* @returns Amount in the token's units; `0n` when nothing can leave
 	*/
 	maxWithdrawCollateral(props) {
+		const { targetHF = require_common_utils_utils_validation_validate_hf.MIN_HF_LIMITED, ...rest } = props;
 		return require_onchain_accounts_intents_maxWithdrawCollateral.maxWithdrawCollateral({
-			...props,
-			targetHF: require_common_utils_utils_validation_validate_hf.MIN_HF_LIMITED + 2n
+			...rest,
+			targetHF: targetHF + 2n
 		});
 	}
 	/**

package/dist/cjs/onchain/accounts/intents/leverage-band.js

@@ -31,13 +31,13 @@ require("./utils/index.js");
 * calcLeverageBand({ sdk, creditManager, collateral }) // { min: 1.1, max: 9 }
 * ```
 **/
-function calcLeverageBand({ sdk, creditManager, collateral }) {
+function calcLeverageBand({ sdk, creditManager, collateral, targetHF }) {
 	const found = resolve(sdk, creditManager);
 	if (!found) return;
 	const { suite, market } = found;
 	const target = suite.strategyTargetCollateral;
 	if (!target) return;
-	const ceiling = suite.creditManager.maxLeverage(target);
+	const ceiling = suite.creditManager.maxLeverage(target, targetHF);
 	const underlying = market.pool.underlying;
 	const convert = require_onchain_accounts_intents_utils_convert_amount.convertAmount(sdk, creditManager);
 	const netValue = collateral.reduce((acc, a) => acc + convert(a.token, underlying, a.balance), 0n);

package/dist/cjs/onchain/accounts/intents/testing/sdk-mock.js

@@ -182,7 +182,7 @@ function buildMockSdk(args) {
 			liquidationThresholds,
 			collateralTokens,
 			feeInterest: args.feeInterest ?? 0,
-			maxLeverage: (collateral) => require_onchain_market_math.calcMaxLeverage(liquidationThresholds.get(collateral) ?? 0)
+			maxLeverage: (collateral, targetHF) => require_onchain_market_math.calcMaxLeverage(liquidationThresholds.get(collateral) ?? 0, targetHF)
 		},
 		creditFacade: {
 			address: args.creditFacade,

package/dist/cjs/onchain/market/credit/CreditManagerV310Contract.js

@@ -66,8 +66,8 @@ var CreditManagerV310Contract = class extends require_onchain_base_BaseContract.
 	/**
 	* {@inheritDoc ICreditManagerContract.maxLeverage}
 	*/
-	maxLeverage(collateral) {
-		return require_onchain_market_math.calcMaxLeverage(this.liquidationThresholds.mustGet(collateral));
+	maxLeverage(collateral, targetHF) {
+		return require_onchain_market_math.calcMaxLeverage(this.liquidationThresholds.mustGet(collateral), targetHF);
 	}
 	/**
 	* {@inheritDoc ICreditManagerContract.liquidationPremium}

package/dist/cjs/onchain/market/math.js

@@ -163,24 +163,36 @@ function calcNetStrategyApy(opportunity, totalCollateralApy, leverage, mode = "s
 **/
 const MAX_LEVERAGE_BUFFER_BPS = 500;
 /**
-* Highest total-value leverage a liquidation threshold allows, floored:
-* `floor((100% − buffer) / (100% − liquidationThreshold))`. At HF = 1, debt is
-* `liquidationThreshold × totalValue`, leaving `1 − liquidationThreshold` of
-* equity per unit of exposure; the {@link MAX_LEVERAGE_BUFFER_BPS} buffer
-* keeps the maxed position slightly away from that boundary.
+* Highest total-value leverage a liquidation threshold allows, floored.
+*
+* At HF = 1, debt is `liquidationThreshold × totalValue`, leaving
+* `1 − liquidationThreshold` of equity per unit of exposure; a maxed position
+* has to stay some way off that boundary. Given a `targetHF`, that distance is
+* solved for — `HF = liquidationThreshold × L / (L − 1)` inverts to
+* `L = targetHF / (targetHF − liquidationThreshold)`.
+*
+* Without one it falls back on a flat {@link MAX_LEVERAGE_BUFFER_BPS}, which
+* under-buffers as the threshold rises — at 95% it allows 19x, or HF ≈ 1.0028.
+* That branch is scaffolding, kept so this parameter moves no number before
+* the callers name a target, and goes away with the constant.
+*
+* @param targetHF - Health factor the maxed position should leave, in basis
+* points. Omitted keeps the legacy buffer.
 *
 * @example
 * ```ts
 * // liquidationThreshold: 9000 bps = 90%
-* calcMaxLeverage(9000) // floor((1 − 0.05) / (1 − 0.9)) = 9x total exposure
+* calcMaxLeverage(9000)        // floor((1 − 0.05) / (1 − 0.9)) = 9x
+* calcMaxLeverage(9000, 10100) // floor(1.01 / (1.01 − 0.9))    = 9x
 * ```
-* @throws If `liquidationThreshold` is 100% or more, which would make
-* leverage unbounded.
+* @throws If `liquidationThreshold` is 100% or more, or reaches a named
+* `targetHF` — either way no leverage clears the bar.
 **/
-function calcMaxLeverage(liquidationThreshold) {
+function calcMaxLeverage(liquidationThreshold, targetHF) {
 	if (liquidationThreshold >= FULL) throw new Error("cannot compute max leverage: liquidation threshold is 100% or more");
-	const leverage = Math.floor((FULL - 500) / (FULL - liquidationThreshold));
-	return Math.max(leverage, 1);
+	if (targetHF === void 0) return Math.max(Math.floor((FULL - 500) / (FULL - liquidationThreshold)), 1);
+	if (liquidationThreshold >= targetHF) throw new Error("cannot compute max leverage: liquidation threshold reaches the target health factor");
+	return Math.max(Math.floor(targetHF / (targetHF - liquidationThreshold)), 1);
 }
 /**
 * Converts a credit account's health factor from the 18-decimal fixed point the

package/dist/cjs/rewards/index.js

@@ -4,5 +4,5 @@ const require_rewards_rewards_api = require("./rewards/api.js");
 const require_rewards_rewards_extra_apy = require("./rewards/extra-apy.js");
 require("./rewards/index.js");
 exports.PoolPointsAPI = require_rewards_rewards_extra_apy.PoolPointsAPI;
-exports.RewardAmountAPI = require_rewards_rewards_api.RewardAmountAPI;
 exports.getKeyForPoolPointsInfo = require_rewards_rewards_extra_apy.getKeyForPoolPointsInfo;
+exports.getMerklRewards = require_rewards_rewards_api.getMerklRewards;

package/dist/cjs/rewards/rewards/api.js

@@ -1,70 +1,80 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_utils_AddressMap = require("../../onchain/utils/AddressMap.js");
 const require_onchain_utils_bigint_math = require("../../onchain/utils/bigint-math.js");
-const require_onchain_chain_chains = require("../../onchain/chain/chains.js");
 const require_onchain_utils_formatter = require("../../onchain/utils/formatter.js");
 require("../../onchain/index.js");
 require("../../common-utils/index.js");
 const require_rewards_rewards_merkl_api = require("./merkl-api.js");
 let viem = require("viem");
 //#region src/rewards/rewards/api.ts
-var RewardAmountAPI = class RewardAmountAPI {
-	constructor() {}
-	static async getLmRewardsMerkle({ pools, account, network, reportError, apiKey }) {
-		const [merkleXYZLMResponse] = await Promise.allSettled([require_rewards_rewards_merkl_api.MerkleXYZApi.fetchWithFallback(require_rewards_rewards_merkl_api.MerkleXYZApi.getUserRewardsUrl({ params: {
-			chainId: require_onchain_chain_chains.chains[network].id,
-			user: (0, viem.getAddress)(account)
-		} }), apiKey)]);
-		const merkleXYZLm = RewardAmountAPI.extractFulfilled(merkleXYZLMResponse, reportError, "merkleXYZLm")?.data;
-		const poolByItsToken = Object.values(pools).reduce((acc, p) => {
-			p.stakedDieselToken.forEach((t) => {
-				if (t) acc[t] = p.address;
-			});
-			p.stakedDieselToken_old.forEach((t) => {
-				if (t) acc[t] = p.address;
-			});
-			acc[p.dieselToken] = p.address;
-			return acc;
-		}, {});
-		const extraRewards = (merkleXYZLm || []).reduce((acc, chainRewards) => {
-			chainRewards.rewards.forEach((reward) => {
-				const rewardToken = reward.token.address.toLowerCase();
-				reward.breakdowns.forEach((reason) => {
-					const poolToken = ((reason.reason || "").split("_").find((part) => part.startsWith("0x")) || "").toLowerCase();
-					const pool = poolByItsToken[poolToken];
-					const total = require_onchain_utils_formatter.toBigInt(reason.amount || 0);
-					const claimed = require_onchain_utils_formatter.toBigInt(reason.claimed || 0);
-					const claimable = require_onchain_utils_bigint_math.BigIntMath.max(total - claimed, 0n);
-					const key = [
-						pool,
-						poolToken,
-						rewardToken
-					].join("_");
-					if (pool && claimable > 0n) {
-						const prevAmount = acc[key]?.amount || 0n;
-						acc[key] = {
-							pool,
-							poolToken,
-							rewardToken,
-							rewardTokenSymbol: reward.token.symbol,
-							rewardTokenDecimals: reward.token.decimals || 18,
-							amount: prevAmount + claimable,
-							type: "extraMerkle"
-						};
-					}
+/**
+* The wallet's claimable Merkl rewards on one chain.
+*
+* Never rejects on a transport failure: the fetch is settled rather than
+* awaited, and a failure goes to `reportError` and yields an empty list. A
+* caller that must tell "this chain is down" from "this chain has no rewards"
+* has to watch that callback.
+*/
+async function getMerklRewards({ sdk, account, reportError, apiKey }) {
+	const [merkleXYZLMResponse] = await Promise.allSettled([require_rewards_rewards_merkl_api.MerkleXYZApi.fetchWithFallback(require_rewards_rewards_merkl_api.MerkleXYZApi.getUserRewardsUrl({ params: {
+		chainId: sdk.chainId,
+		user: (0, viem.getAddress)(account)
+	} }), apiKey)]);
+	const merkleXYZLm = extractFulfilled(merkleXYZLMResponse, reportError, "merkleXYZLm")?.data;
+	const poolByItsToken = require_onchain_utils_AddressMap.AddressMap.fromMappedArray(sdk.marketRegister.pools.map(({ pool }) => pool.address), (address) => address);
+	const claimable = /* @__PURE__ */ new Map();
+	for (const chainRewards of merkleXYZLm || []) for (const reward of chainRewards.rewards) {
+		if (!(0, viem.isAddress)(reward.token.address, { strict: false })) continue;
+		const rewardTokenAddress = (0, viem.getAddress)(reward.token.address);
+		for (const reason of reward.breakdowns) {
+			const poolTokenAddress = (reason.reason || "").split("_").find((part) => part.startsWith("0x")) ?? "";
+			if (!(0, viem.isAddress)(poolTokenAddress, { strict: false })) continue;
+			const pool = poolByItsToken.get(poolTokenAddress);
+			if (!pool) continue;
+			const total = require_onchain_utils_formatter.toBigInt(reason.amount || 0);
+			const claimed = require_onchain_utils_formatter.toBigInt(reason.claimed || 0);
+			const amount = require_onchain_utils_bigint_math.BigIntMath.max(total - claimed, 0n);
+			if (amount === 0n) continue;
+			const key = `${pool}_${rewardTokenAddress}`;
+			const seen = claimable.get(key);
+			if (seen) {
+				claimable.set(key, {
+					...seen,
+					amount: seen.amount + amount
 				});
+				continue;
+			}
+			const poolToken = sdk.tokensMeta.getToken(pool);
+			if (!poolToken) continue;
+			claimable.set(key, {
+				chainId: sdk.chainId,
+				pool,
+				poolToken,
+				rewardToken: toRewardToken(sdk, rewardTokenAddress, reward.token),
+				amount
 			});
-			return acc;
-		}, {});
-		return Object.values(extraRewards);
-	}
-	static extractFulfilled(r, reportError, description) {
-		if (r.status === "fulfilled") return r.value;
-		else {
-			if (reportError) reportError(r.reason, description);
-			else console.error(r.reason);
-			return;
 		}
 	}
-};
+	return [...claimable.values()];
+}
+/**
+* A campaign's incentive token is not protocol collateral, so the registry
+* usually has no entry for it — and Merkl always names it. The one place the
+* two sources are reconciled.
+*/
+function toRewardToken(sdk, address, merkl) {
+	return sdk.tokensMeta.getToken(address) ?? {
+		chainId: sdk.chainId,
+		address,
+		symbol: merkl.symbol,
+		name: merkl.symbol,
+		decimals: merkl.decimals || 18
+	};
+}
+function extractFulfilled(r, reportError, description) {
+	if (r.status === "fulfilled") return r.value;
+	if (reportError) reportError(r.reason, description);
+	else console.error(r.reason);
+}
 //#endregion
-exports.RewardAmountAPI = RewardAmountAPI;
+exports.getMerklRewards = getMerklRewards;

package/dist/cjs/rewards/rewards/index.js

@@ -2,5 +2,5 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_rewards_rewards_api = require("./api.js");
 const require_rewards_rewards_extra_apy = require("./extra-apy.js");
 exports.PoolPointsAPI = require_rewards_rewards_extra_apy.PoolPointsAPI;
-exports.RewardAmountAPI = require_rewards_rewards_api.RewardAmountAPI;
 exports.getKeyForPoolPointsInfo = require_rewards_rewards_extra_apy.getKeyForPoolPointsInfo;
+exports.getMerklRewards = require_rewards_rewards_api.getMerklRewards;

package/dist/cjs/sdk/prepare/PrepareApi.js

@@ -252,24 +252,26 @@ var PrepareApi = class extends require_onchain_base_MultichainConstruct.Multicha
 	/**
 	* {@inheritDoc OpportunitiesPrepare.leverageBand}
 	**/
-	leverageBand(strategy, collateral) {
+	leverageBand(strategy, collateral, targetHF) {
 		const sdk = this.sdk.chain(strategy.chainId);
 		return service(sdk).leverageBand({
 			sdk,
 			creditManager: strategy.creditManager,
-			collateral
+			collateral,
+			targetHF
 		});
 	}
 	/**
 	* {@inheritDoc OpportunitiesPrepare.maxWithdrawCollateral}
 	**/
-	async maxWithdrawCollateral(position, token) {
+	async maxWithdrawCollateral(position, token, targetHF) {
 		return this.queryChain({
 			network: position.chainId,
 			run: async (sdk) => service(sdk).maxWithdrawCollateral({
 				creditAccount: await slice(sdk, position.creditAccount),
 				sdk,
-				token
+				token,
+				targetHF
 			})
 		});
 	}

package/dist/esm/onchain/accounts/intents/index.js

@@ -49,6 +49,10 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	* withdraw form should offer. Taking everything out is the same intent with
 	* `MAX_UINT256` for an amount, and needs none of this arithmetic.
 	*
+	* Takes no target health factor, unlike {@link maxWithdrawCollateral}: a
+	* proportional withdrawal leaves the factor where it found it, and the
+	* facade's `minDebt` is what bounds it.
+	*
 	* @param props - Account slice and the SDK holding its market
 	* @returns Amount in underlying units; `0n` when nothing can leave
 	*/
@@ -84,8 +88,9 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	* yet, and adjusting measures against the net value the caller already
 	* holds. Nothing is fetched, so a form can ask on every keystroke.
 	*
-	* @param props - The manager, the SDK holding its market, and what stands
-	* behind the position
+	* @param props - The manager, the SDK holding its market, what stands
+	* behind the position, and optionally the health factor the ceiling should
+	* leave
 	* @returns The band, or nothing when the market has none to offer
 	*/
 	leverageBand(props) {
@@ -93,19 +98,23 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	}
 	/**
 	* Largest `WITHDRAW_ASSET` amount of one token the account can take out
-	* while its health factor stays at {@link MIN_HF_LIMITED} plus a basis
-	* point — the ceiling a withdraw-collateral form should offer. Thresholds,
-	* prices and quota activity come from the account's market, valued the way
-	* the facade values a call that pays out; zero debt frees the whole balance.
+	* while its health factor stays at `targetHF` — the ceiling a
+	* withdraw-collateral form should offer. Thresholds, prices and quota
+	* activity come from the account's market, valued the way the facade values
+	* a call that pays out; zero debt frees the whole balance.
+	*
+	* The default is {@link MIN_HF_LIMITED}, the bar `validateHF` holds an
+	* account to.
 	*
-	* @param props - Account slice, the SDK holding its market, and the
-	* collateral to withdraw
+	* @param props - Account slice, the SDK holding its market, the collateral
+	* to withdraw, and optionally the health factor to leave behind
 	* @returns Amount in the token's units; `0n` when nothing can leave
 	*/
 	maxWithdrawCollateral(props) {
+		const { targetHF = MIN_HF_LIMITED, ...rest } = props;
 		return maxWithdrawCollateral({
-			...props,
-			targetHF: MIN_HF_LIMITED + 2n
+			...rest,
+			targetHF: targetHF + 2n
 		});
 	}
 	/**

package/dist/esm/onchain/accounts/intents/leverage-band.js

@@ -30,13 +30,13 @@ import "./utils/index.js";
 * calcLeverageBand({ sdk, creditManager, collateral }) // { min: 1.1, max: 9 }
 * ```
 **/
-function calcLeverageBand({ sdk, creditManager, collateral }) {
+function calcLeverageBand({ sdk, creditManager, collateral, targetHF }) {
 	const found = resolve(sdk, creditManager);
 	if (!found) return;
 	const { suite, market } = found;
 	const target = suite.strategyTargetCollateral;
 	if (!target) return;
-	const ceiling = suite.creditManager.maxLeverage(target);
+	const ceiling = suite.creditManager.maxLeverage(target, targetHF);
 	const underlying = market.pool.underlying;
 	const convert = convertAmount(sdk, creditManager);
 	const netValue = collateral.reduce((acc, a) => acc + convert(a.token, underlying, a.balance), 0n);

package/dist/esm/onchain/accounts/intents/testing/sdk-mock.js

@@ -182,7 +182,7 @@ function buildMockSdk(args) {
 			liquidationThresholds,
 			collateralTokens,
 			feeInterest: args.feeInterest ?? 0,
-			maxLeverage: (collateral) => calcMaxLeverage(liquidationThresholds.get(collateral) ?? 0)
+			maxLeverage: (collateral, targetHF) => calcMaxLeverage(liquidationThresholds.get(collateral) ?? 0, targetHF)
 		},
 		creditFacade: {
 			address: args.creditFacade,

package/dist/esm/onchain/market/credit/CreditManagerV310Contract.js

@@ -65,8 +65,8 @@ var CreditManagerV310Contract = class extends BaseContract {
 	/**
 	* {@inheritDoc ICreditManagerContract.maxLeverage}
 	*/
-	maxLeverage(collateral) {
-		return calcMaxLeverage(this.liquidationThresholds.mustGet(collateral));
+	maxLeverage(collateral, targetHF) {
+		return calcMaxLeverage(this.liquidationThresholds.mustGet(collateral), targetHF);
 	}
 	/**
 	* {@inheritDoc ICreditManagerContract.liquidationPremium}

package/dist/esm/onchain/market/math.js

@@ -162,24 +162,36 @@ function calcNetStrategyApy(opportunity, totalCollateralApy, leverage, mode = "s
 **/
 const MAX_LEVERAGE_BUFFER_BPS = 500;
 /**
-* Highest total-value leverage a liquidation threshold allows, floored:
-* `floor((100% − buffer) / (100% − liquidationThreshold))`. At HF = 1, debt is
-* `liquidationThreshold × totalValue`, leaving `1 − liquidationThreshold` of
-* equity per unit of exposure; the {@link MAX_LEVERAGE_BUFFER_BPS} buffer
-* keeps the maxed position slightly away from that boundary.
+* Highest total-value leverage a liquidation threshold allows, floored.
+*
+* At HF = 1, debt is `liquidationThreshold × totalValue`, leaving
+* `1 − liquidationThreshold` of equity per unit of exposure; a maxed position
+* has to stay some way off that boundary. Given a `targetHF`, that distance is
+* solved for — `HF = liquidationThreshold × L / (L − 1)` inverts to
+* `L = targetHF / (targetHF − liquidationThreshold)`.
+*
+* Without one it falls back on a flat {@link MAX_LEVERAGE_BUFFER_BPS}, which
+* under-buffers as the threshold rises — at 95% it allows 19x, or HF ≈ 1.0028.
+* That branch is scaffolding, kept so this parameter moves no number before
+* the callers name a target, and goes away with the constant.
+*
+* @param targetHF - Health factor the maxed position should leave, in basis
+* points. Omitted keeps the legacy buffer.
 *
 * @example
 * ```ts
 * // liquidationThreshold: 9000 bps = 90%
-* calcMaxLeverage(9000) // floor((1 − 0.05) / (1 − 0.9)) = 9x total exposure
+* calcMaxLeverage(9000)        // floor((1 − 0.05) / (1 − 0.9)) = 9x
+* calcMaxLeverage(9000, 10100) // floor(1.01 / (1.01 − 0.9))    = 9x
 * ```
-* @throws If `liquidationThreshold` is 100% or more, which would make
-* leverage unbounded.
+* @throws If `liquidationThreshold` is 100% or more, or reaches a named
+* `targetHF` — either way no leverage clears the bar.
 **/
-function calcMaxLeverage(liquidationThreshold) {
+function calcMaxLeverage(liquidationThreshold, targetHF) {
 	if (liquidationThreshold >= FULL) throw new Error("cannot compute max leverage: liquidation threshold is 100% or more");
-	const leverage = Math.floor((FULL - 500) / (FULL - liquidationThreshold));
-	return Math.max(leverage, 1);
+	if (targetHF === void 0) return Math.max(Math.floor((FULL - 500) / (FULL - liquidationThreshold)), 1);
+	if (liquidationThreshold >= targetHF) throw new Error("cannot compute max leverage: liquidation threshold reaches the target health factor");
+	return Math.max(Math.floor(targetHF / (targetHF - liquidationThreshold)), 1);
 }
 /**
 * Converts a credit account's health factor from the 18-decimal fixed point the

package/dist/esm/rewards/index.js

@@ -1,5 +1,5 @@
 import "./apy/index.js";
-import { RewardAmountAPI } from "./rewards/api.js";
+import { getMerklRewards } from "./rewards/api.js";
 import { PoolPointsAPI, getKeyForPoolPointsInfo } from "./rewards/extra-apy.js";
 import "./rewards/index.js";
-export { PoolPointsAPI, RewardAmountAPI, getKeyForPoolPointsInfo };
+export { PoolPointsAPI, getKeyForPoolPointsInfo, getMerklRewards };

package/dist/esm/rewards/rewards/api.js

@@ -1,69 +1,79 @@
+import { AddressMap } from "../../onchain/utils/AddressMap.js";
 import { BigIntMath } from "../../onchain/utils/bigint-math.js";
-import { chains } from "../../onchain/chain/chains.js";
 import { toBigInt } from "../../onchain/utils/formatter.js";
 import "../../onchain/index.js";
 import "../../common-utils/index.js";
 import { MerkleXYZApi } from "./merkl-api.js";
-import { getAddress } from "viem";
+import { getAddress, isAddress } from "viem";
 //#region src/rewards/rewards/api.ts
-var RewardAmountAPI = class RewardAmountAPI {
-	constructor() {}
-	static async getLmRewardsMerkle({ pools, account, network, reportError, apiKey }) {
-		const [merkleXYZLMResponse] = await Promise.allSettled([MerkleXYZApi.fetchWithFallback(MerkleXYZApi.getUserRewardsUrl({ params: {
-			chainId: chains[network].id,
-			user: getAddress(account)
-		} }), apiKey)]);
-		const merkleXYZLm = RewardAmountAPI.extractFulfilled(merkleXYZLMResponse, reportError, "merkleXYZLm")?.data;
-		const poolByItsToken = Object.values(pools).reduce((acc, p) => {
-			p.stakedDieselToken.forEach((t) => {
-				if (t) acc[t] = p.address;
-			});
-			p.stakedDieselToken_old.forEach((t) => {
-				if (t) acc[t] = p.address;
-			});
-			acc[p.dieselToken] = p.address;
-			return acc;
-		}, {});
-		const extraRewards = (merkleXYZLm || []).reduce((acc, chainRewards) => {
-			chainRewards.rewards.forEach((reward) => {
-				const rewardToken = reward.token.address.toLowerCase();
-				reward.breakdowns.forEach((reason) => {
-					const poolToken = ((reason.reason || "").split("_").find((part) => part.startsWith("0x")) || "").toLowerCase();
-					const pool = poolByItsToken[poolToken];
-					const total = toBigInt(reason.amount || 0);
-					const claimed = toBigInt(reason.claimed || 0);
-					const claimable = BigIntMath.max(total - claimed, 0n);
-					const key = [
-						pool,
-						poolToken,
-						rewardToken
-					].join("_");
-					if (pool && claimable > 0n) {
-						const prevAmount = acc[key]?.amount || 0n;
-						acc[key] = {
-							pool,
-							poolToken,
-							rewardToken,
-							rewardTokenSymbol: reward.token.symbol,
-							rewardTokenDecimals: reward.token.decimals || 18,
-							amount: prevAmount + claimable,
-							type: "extraMerkle"
-						};
-					}
+/**
+* The wallet's claimable Merkl rewards on one chain.
+*
+* Never rejects on a transport failure: the fetch is settled rather than
+* awaited, and a failure goes to `reportError` and yields an empty list. A
+* caller that must tell "this chain is down" from "this chain has no rewards"
+* has to watch that callback.
+*/
+async function getMerklRewards({ sdk, account, reportError, apiKey }) {
+	const [merkleXYZLMResponse] = await Promise.allSettled([MerkleXYZApi.fetchWithFallback(MerkleXYZApi.getUserRewardsUrl({ params: {
+		chainId: sdk.chainId,
+		user: getAddress(account)
+	} }), apiKey)]);
+	const merkleXYZLm = extractFulfilled(merkleXYZLMResponse, reportError, "merkleXYZLm")?.data;
+	const poolByItsToken = AddressMap.fromMappedArray(sdk.marketRegister.pools.map(({ pool }) => pool.address), (address) => address);
+	const claimable = /* @__PURE__ */ new Map();
+	for (const chainRewards of merkleXYZLm || []) for (const reward of chainRewards.rewards) {
+		if (!isAddress(reward.token.address, { strict: false })) continue;
+		const rewardTokenAddress = getAddress(reward.token.address);
+		for (const reason of reward.breakdowns) {
+			const poolTokenAddress = (reason.reason || "").split("_").find((part) => part.startsWith("0x")) ?? "";
+			if (!isAddress(poolTokenAddress, { strict: false })) continue;
+			const pool = poolByItsToken.get(poolTokenAddress);
+			if (!pool) continue;
+			const total = toBigInt(reason.amount || 0);
+			const claimed = toBigInt(reason.claimed || 0);
+			const amount = BigIntMath.max(total - claimed, 0n);
+			if (amount === 0n) continue;
+			const key = `${pool}_${rewardTokenAddress}`;
+			const seen = claimable.get(key);
+			if (seen) {
+				claimable.set(key, {
+					...seen,
+					amount: seen.amount + amount
 				});
+				continue;
+			}
+			const poolToken = sdk.tokensMeta.getToken(pool);
+			if (!poolToken) continue;
+			claimable.set(key, {
+				chainId: sdk.chainId,
+				pool,
+				poolToken,
+				rewardToken: toRewardToken(sdk, rewardTokenAddress, reward.token),
+				amount
 			});
-			return acc;
-		}, {});
-		return Object.values(extraRewards);
-	}
-	static extractFulfilled(r, reportError, description) {
-		if (r.status === "fulfilled") return r.value;
-		else {
-			if (reportError) reportError(r.reason, description);
-			else console.error(r.reason);
-			return;
 		}
 	}
-};
+	return [...claimable.values()];
+}
+/**
+* A campaign's incentive token is not protocol collateral, so the registry
+* usually has no entry for it — and Merkl always names it. The one place the
+* two sources are reconciled.
+*/
+function toRewardToken(sdk, address, merkl) {
+	return sdk.tokensMeta.getToken(address) ?? {
+		chainId: sdk.chainId,
+		address,
+		symbol: merkl.symbol,
+		name: merkl.symbol,
+		decimals: merkl.decimals || 18
+	};
+}
+function extractFulfilled(r, reportError, description) {
+	if (r.status === "fulfilled") return r.value;
+	if (reportError) reportError(r.reason, description);
+	else console.error(r.reason);
+}
 //#endregion
-export { RewardAmountAPI };
+export { getMerklRewards };

package/dist/esm/rewards/rewards/index.js

@@ -1,3 +1,3 @@
-import { RewardAmountAPI } from "./api.js";
+import { getMerklRewards } from "./api.js";
 import { PoolPointsAPI, getKeyForPoolPointsInfo } from "./extra-apy.js";
-export { PoolPointsAPI, RewardAmountAPI, getKeyForPoolPointsInfo };
+export { PoolPointsAPI, getKeyForPoolPointsInfo, getMerklRewards };

package/dist/esm/sdk/prepare/PrepareApi.js

@@ -251,24 +251,26 @@ var PrepareApi = class extends MultichainConstruct {
 	/**
 	* {@inheritDoc OpportunitiesPrepare.leverageBand}
 	**/
-	leverageBand(strategy, collateral) {
+	leverageBand(strategy, collateral, targetHF) {
 		const sdk = this.sdk.chain(strategy.chainId);
 		return service(sdk).leverageBand({
 			sdk,
 			creditManager: strategy.creditManager,
-			collateral
+			collateral,
+			targetHF
 		});
 	}
 	/**
 	* {@inheritDoc OpportunitiesPrepare.maxWithdrawCollateral}
 	**/
-	async maxWithdrawCollateral(position, token) {
+	async maxWithdrawCollateral(position, token, targetHF) {
 		return this.queryChain({
 			network: position.chainId,
 			run: async (sdk) => service(sdk).maxWithdrawCollateral({
 				creditAccount: await slice(sdk, position.creditAccount),
 				sdk,
-				token
+				token,
+				targetHF
 			})
 		});
 	}

package/dist/types/onchain/accounts/intents/index.d.ts

@@ -46,6 +46,10 @@ declare class CreditAccountOperationsService extends SDKConstruct {
    * withdraw form should offer. Taking everything out is the same intent with
    * `MAX_UINT256` for an amount, and needs none of this arithmetic.
    *
+   * Takes no target health factor, unlike {@link maxWithdrawCollateral}: a
+   * proportional withdrawal leaves the factor where it found it, and the
+   * facade's `minDebt` is what bounds it.
+   *
    * @param props - Account slice and the SDK holding its market
    * @returns Amount in underlying units; `0n` when nothing can leave
    */
@@ -76,24 +80,29 @@ declare class CreditAccountOperationsService extends SDKConstruct {
    * yet, and adjusting measures against the net value the caller already
    * holds. Nothing is fetched, so a form can ask on every keystroke.
    *
-   * @param props - The manager, the SDK holding its market, and what stands
-   * behind the position
+   * @param props - The manager, the SDK holding its market, what stands
+   * behind the position, and optionally the health factor the ceiling should
+   * leave
    * @returns The band, or nothing when the market has none to offer
    */
   leverageBand(props: LeverageBandProps): LeverageBand | undefined;
   /**
    * Largest `WITHDRAW_ASSET` amount of one token the account can take out
-   * while its health factor stays at {@link MIN_HF_LIMITED} plus a basis
-   * point — the ceiling a withdraw-collateral form should offer. Thresholds,
-   * prices and quota activity come from the account's market, valued the way
-   * the facade values a call that pays out; zero debt frees the whole balance.
+   * while its health factor stays at `targetHF` — the ceiling a
+   * withdraw-collateral form should offer. Thresholds, prices and quota
+   * activity come from the account's market, valued the way the facade values
+   * a call that pays out; zero debt frees the whole balance.
+   *
+   * The default is {@link MIN_HF_LIMITED}, the bar `validateHF` holds an
+   * account to.
    *
-   * @param props - Account slice, the SDK holding its market, and the
-   * collateral to withdraw
+   * @param props - Account slice, the SDK holding its market, the collateral
+   * to withdraw, and optionally the health factor to leave behind
    * @returns Amount in the token's units; `0n` when nothing can leave
    */
   maxWithdrawCollateral(props: Pick<StartIntentProps, "creditAccount" | "sdk"> & {
     token: Address;
+    targetHF?: bigint;
   }): bigint;
   /**
    * Previews the same operation when its source only redeems through its

package/dist/types/onchain/accounts/intents/leverage-band.d.ts

@@ -1,4 +1,4 @@
-import { Leverage } from "../../../model/primitives.js";
+import { Bps, Leverage } from "../../../model/primitives.js";
 import "../../../model/index.js";
 import { Asset } from "../../base/types.js";
 import { OnchainSDK } from "../../OnchainSDK.js";
@@ -20,6 +20,11 @@ interface LeverageBandProps {
    * underlying here, so a caller hands over amounts and no exchange rates.
    **/
   readonly collateral: readonly Asset[];
+  /**
+   * Health factor the maxed leverage should leave the position at, in basis
+   * points. Omitted keeps `calcMaxLeverage` on its flat buffer.
+   **/
+  readonly targetHF?: Bps;
 }
 /**
  * The leverages this market will actually fund for a position of this size.
@@ -48,6 +53,6 @@ interface LeverageBandProps {
  * calcLeverageBand({ sdk, creditManager, collateral }) // { min: 1.1, max: 9 }
  * ```
  **/
-declare function calcLeverageBand({ sdk, creditManager, collateral }: LeverageBandProps): LeverageBand | undefined;
+declare function calcLeverageBand({ sdk, creditManager, collateral, targetHF }: LeverageBandProps): LeverageBand | undefined;
 //#endregion
 export { LeverageBand, LeverageBandProps, calcLeverageBand };

package/dist/types/onchain/market/credit/CreditManagerV310Contract.d.ts

@@ -1004,7 +1004,7 @@ declare class CreditManagerV310Contract extends BaseContract<abi> implements ICr
   /**
    * {@inheritDoc ICreditManagerContract.maxLeverage}
    */
-  maxLeverage(collateral: Address): Leverage;
+  maxLeverage(collateral: Address, targetHF?: Bps): Leverage;
   /**
    * {@inheritDoc ICreditManagerContract.liquidationPremium}
    */

package/dist/types/onchain/market/credit/types.d.ts

@@ -133,13 +133,14 @@ interface ICreditManagerContract extends IBaseContract {
    */
   readonly liquidationPremium: Bps;
   /**
-   * Highest total-value leverage a collateral's liquidation threshold allows:
-   * `(1 − 0.05) / (1 − lt)`.
+   * Highest total-value leverage a collateral's liquidation threshold allows.
    *
    * @param collateral - Collateral token address.
+   * @param targetHF - Health factor the maxed position should leave, in basis
+   * points. Omitted keeps the flat buffer.
    * @throws If the credit manager does not value the token.
    */
-  maxLeverage: (collateral: Address) => Leverage;
+  maxLeverage: (collateral: Address, targetHF?: Bps) => Leverage;
   stateHuman: (raw?: boolean) => CreditManagerStateHuman;
 }
 /**

package/dist/types/onchain/market/math.d.ts

@@ -132,21 +132,32 @@ declare function calcNetStrategyApy(opportunity: StrategyRateInputs, totalCollat
  **/
 declare const MAX_LEVERAGE_BUFFER_BPS = 500;
 /**
- * Highest total-value leverage a liquidation threshold allows, floored:
- * `floor((100% − buffer) / (100% − liquidationThreshold))`. At HF = 1, debt is
- * `liquidationThreshold × totalValue`, leaving `1 − liquidationThreshold` of
- * equity per unit of exposure; the {@link MAX_LEVERAGE_BUFFER_BPS} buffer
- * keeps the maxed position slightly away from that boundary.
+ * Highest total-value leverage a liquidation threshold allows, floored.
+ *
+ * At HF = 1, debt is `liquidationThreshold × totalValue`, leaving
+ * `1 − liquidationThreshold` of equity per unit of exposure; a maxed position
+ * has to stay some way off that boundary. Given a `targetHF`, that distance is
+ * solved for — `HF = liquidationThreshold × L / (L − 1)` inverts to
+ * `L = targetHF / (targetHF − liquidationThreshold)`.
+ *
+ * Without one it falls back on a flat {@link MAX_LEVERAGE_BUFFER_BPS}, which
+ * under-buffers as the threshold rises — at 95% it allows 19x, or HF ≈ 1.0028.
+ * That branch is scaffolding, kept so this parameter moves no number before
+ * the callers name a target, and goes away with the constant.
+ *
+ * @param targetHF - Health factor the maxed position should leave, in basis
+ * points. Omitted keeps the legacy buffer.
  *
  * @example
  * ```ts
  * // liquidationThreshold: 9000 bps = 90%
- * calcMaxLeverage(9000) // floor((1 − 0.05) / (1 − 0.9)) = 9x total exposure
+ * calcMaxLeverage(9000)        // floor((1 − 0.05) / (1 − 0.9)) = 9x
+ * calcMaxLeverage(9000, 10100) // floor(1.01 / (1.01 − 0.9))    = 9x
  * ```
- * @throws If `liquidationThreshold` is 100% or more, which would make
- * leverage unbounded.
+ * @throws If `liquidationThreshold` is 100% or more, or reaches a named
+ * `targetHF` — either way no leverage clears the bar.
  **/
-declare function calcMaxLeverage(liquidationThreshold: Bps): Leverage;
+declare function calcMaxLeverage(liquidationThreshold: Bps, targetHF?: Bps): Leverage;
 /**
  * Converts a credit account's health factor from the 18-decimal fixed point the
  * contracts store to basis points.

package/dist/types/rewards/index.d.ts

@@ -1,7 +1,7 @@
 import { Apy, ApyDetails, DebtReward, ExternalApy, ExtraCollateralAPY, ExtraCollateralPointsInfo, FarmInfo, GearAPY, GearAPYDetails, PointsInfo, PointsReward, PoolExtraApy, PoolOutputDetails, PoolPointsInfo, TokenOutputDetails } from "./apy/output-details.js";
 import { DataResult, Output } from "./apy/output.js";
 import "./apy/index.js";
-import { GearboxExtraMerkleLmReward, GearboxLmReward, GetLmRewardsMerkleProps, PoolData, RewardAmountAPI } from "./rewards/api.js";
+import { GetMerklRewardsProps, MerklReward, MerklRewardsSdk, getMerklRewards } from "./rewards/api.js";
 import { GetPointsByPoolProps, GetTotalTokensOnProtocolProps, PoolPointsAPI, PoolPointsBase, getKeyForPoolPointsInfo } from "./rewards/extra-apy.js";
 import "./rewards/index.js";
-export { Apy, ApyDetails, DataResult, DebtReward, ExternalApy, ExtraCollateralAPY, ExtraCollateralPointsInfo, FarmInfo, GearAPY, GearAPYDetails, GearboxExtraMerkleLmReward, GearboxLmReward, GetLmRewardsMerkleProps, GetPointsByPoolProps, GetTotalTokensOnProtocolProps, Output, PointsInfo, PointsReward, PoolData, PoolExtraApy, PoolOutputDetails, PoolPointsAPI, PoolPointsBase, PoolPointsInfo, RewardAmountAPI, TokenOutputDetails, getKeyForPoolPointsInfo };
+export { Apy, ApyDetails, DataResult, DebtReward, ExternalApy, ExtraCollateralAPY, ExtraCollateralPointsInfo, FarmInfo, GearAPY, GearAPYDetails, GetMerklRewardsProps, GetPointsByPoolProps, GetTotalTokensOnProtocolProps, MerklReward, MerklRewardsSdk, Output, PointsInfo, PointsReward, PoolExtraApy, PoolOutputDetails, PoolPointsAPI, PoolPointsBase, PoolPointsInfo, TokenOutputDetails, getKeyForPoolPointsInfo, getMerklRewards };

package/dist/types/rewards/rewards/api.d.ts

@@ -1,39 +1,54 @@
-import { NetworkType } from "../../onchain/chain/chains.js";
+import { ChainId, Token } from "../../model/primitives.js";
+import "../../model/index.js";
+import { OnchainSDK } from "../../onchain/OnchainSDK.js";
 import "../../onchain/index.js";
 import { Address } from "viem";
 //#region src/rewards/rewards/api.d.ts
-interface PoolData {
-  address: Address;
-  version: number;
-  underlyingToken: Address;
-  dieselRateRay: bigint;
-  dieselToken: Address;
-  stakedDieselToken: Address[];
-  stakedDieselToken_old: Address[];
-  expectedLiquidity: bigint;
+/**
+ * One claimable Merkl liquidity-mining reward, denominated.
+ *
+ * Both tokens arrive resolved, so a consumer neither looks one up nor
+ * reassembles one out of the loose fields Merkl sends.
+ */
+interface MerklReward {
+  readonly chainId: ChainId;
+  /** Market pool whose depositors the campaign rewards. */
+  readonly pool: Address;
+  /** That pool's share token — what the campaign is keyed on. */
+  readonly poolToken: Token;
+  /** The incentive token being handed out. */
+  readonly rewardToken: Token;
+  /** Claimable amount, i.e. distributed minus already claimed. Always > 0. */
+  readonly amount: bigint;
 }
-interface GearboxExtraMerkleLmReward {
-  pool: Address;
-  poolToken: Address;
-  rewardTokenSymbol: string;
-  rewardTokenDecimals: number;
-  rewardToken: Address;
-  amount: bigint;
-  type: "extraMerkle";
-}
-type GearboxLmReward = GearboxExtraMerkleLmReward;
 type ReportHandler = (e: unknown, description?: string) => void;
-interface GetLmRewardsMerkleProps {
-  pools: Record<Address, PoolData>;
+/**
+ * What this read needs off a chain's SDK: which chain to ask Merkl about, the
+ * pools a campaign can be keyed on, and the registry that names their tokens.
+ *
+ * Sliced rather than taking the whole {@link OnchainSDK} so a caller can hand
+ * over a narrowed object — a test fixture included — without casting.
+ */
+type MerklRewardsSdk = Pick<OnchainSDK, "chainId" | "marketRegister" | "tokensMeta">;
+interface GetMerklRewardsProps {
+  /**
+   * The chain's SDK, attached. Reading `marketRegister` before attach throws,
+   * which the slice above cannot express.
+   */
+  sdk: MerklRewardsSdk;
   account: Address;
-  network: NetworkType;
   reportError?: ReportHandler;
+  /** Raises Merkl's rate limit; the keyless path answers too. */
   apiKey?: string;
 }
-declare class RewardAmountAPI {
-  private constructor();
-  static getLmRewardsMerkle({ pools, account, network, reportError, apiKey }: GetLmRewardsMerkleProps): Promise<GearboxExtraMerkleLmReward[]>;
-  private static extractFulfilled;
-}
+/**
+ * The wallet's claimable Merkl rewards on one chain.
+ *
+ * Never rejects on a transport failure: the fetch is settled rather than
+ * awaited, and a failure goes to `reportError` and yields an empty list. A
+ * caller that must tell "this chain is down" from "this chain has no rewards"
+ * has to watch that callback.
+ */
+declare function getMerklRewards({ sdk, account, reportError, apiKey }: GetMerklRewardsProps): Promise<MerklReward[]>;
 //#endregion
-export { GearboxExtraMerkleLmReward, GearboxLmReward, GetLmRewardsMerkleProps, PoolData, RewardAmountAPI };
+export { GetMerklRewardsProps, MerklReward, MerklRewardsSdk, getMerklRewards };

package/dist/types/rewards/rewards/index.d.ts

@@ -1,3 +1,3 @@
-import { GearboxExtraMerkleLmReward, GearboxLmReward, GetLmRewardsMerkleProps, PoolData, RewardAmountAPI } from "./api.js";
+import { GetMerklRewardsProps, MerklReward, MerklRewardsSdk, getMerklRewards } from "./api.js";
 import { GetPointsByPoolProps, GetTotalTokensOnProtocolProps, PoolPointsAPI, PoolPointsBase, getKeyForPoolPointsInfo } from "./extra-apy.js";
-export { GearboxExtraMerkleLmReward, GearboxLmReward, GetLmRewardsMerkleProps, GetPointsByPoolProps, GetTotalTokensOnProtocolProps, PoolData, PoolPointsAPI, PoolPointsBase, RewardAmountAPI, getKeyForPoolPointsInfo };
+export { GetMerklRewardsProps, GetPointsByPoolProps, GetTotalTokensOnProtocolProps, MerklReward, MerklRewardsSdk, PoolPointsAPI, PoolPointsBase, getKeyForPoolPointsInfo, getMerklRewards };

package/dist/types/sdk/prepare/PrepareApi.d.ts

@@ -1,4 +1,4 @@
-import { ChainId } from "../../model/primitives.js";
+import { Bps, ChainId } from "../../model/primitives.js";
 import { DataResponse } from "../../model/response.js";
 import "../../model/index.js";
 import { Asset } from "../../onchain/base/types.js";
@@ -91,11 +91,11 @@ declare class PrepareApi extends MultichainConstruct implements OpportunitiesPre
   /**
    * {@inheritDoc OpportunitiesPrepare.leverageBand}
    **/
-  leverageBand(strategy: StrategyInput, collateral: readonly Asset[]): LeverageBand | undefined;
+  leverageBand(strategy: StrategyInput, collateral: readonly Asset[], targetHF?: Bps): LeverageBand | undefined;
   /**
    * {@inheritDoc OpportunitiesPrepare.maxWithdrawCollateral}
    **/
-  maxWithdrawCollateral(position: PositionInput, token: Address): Promise<DataResponse<bigint>>;
+  maxWithdrawCollateral(position: PositionInput, token: Address, targetHF?: bigint): Promise<DataResponse<bigint>>;
 }
 //#endregion
 export { ChainOf, PrepareApi };

package/dist/types/sdk/prepare/types.d.ts

@@ -1,3 +1,4 @@
+import { Bps } from "../../model/primitives.js";
 import { PoolOpportunityKey, StrategyOpportunityKey } from "../../model/opportunities.js";
 import { StrategyPositionKey } from "../../model/positions.js";
 import { DataResponse } from "../../model/response.js";
@@ -483,7 +484,7 @@ interface OpportunitiesPrepare {
    * no borrowing room left. Not the same answer as "every leverage works", and
    * a caller must not mark a range for it.
    **/
-  leverageBand(strategy: StrategyInput, collateral: readonly Asset[]): LeverageBand | undefined;
+  leverageBand(strategy: StrategyInput, collateral: readonly Asset[], targetHF?: Bps): LeverageBand | undefined;
   /**
    * Largest amount of one collateral {@link withdrawCollateral} can move out
    * while the account stays safely collateralised, in the token's units: the
@@ -491,8 +492,11 @@ interface OpportunitiesPrepare {
    * capped by their quotas) and the target keeps covering what the debt still
    * requires. Zero debt frees the whole balance — the ceiling a
    * withdraw-collateral form should offer.
+   *
+   * `targetHF` names the health factor to leave the account at, in basis
+   * points; omitted, the SDK holds it to the bar a form would.
    **/
-  maxWithdrawCollateral(position: PositionInput, token: Address): Promise<DataResponse<bigint>>;
+  maxWithdrawCollateral(position: PositionInput, token: Address, targetHF?: bigint): Promise<DataResponse<bigint>>;
   /**
    * The tail of a delayed route: claim the matured withdrawal, then whatever the
    * operation that requested it still owes — repaying debt and paying the wallet

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gearbox-protocol/sdk",
-  "version": "16.0.0-next.16",
+  "version": "16.0.0-next.18",
   "description": "Gearbox SDK",
   "license": "MIT",
   "repository": {