@gearbox-protocol/sdk 16.0.0-next.7 → 16.0.0-next.9

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

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_onchain_accounts_intents_types = require("./types.js");
+const require_onchain_accounts_intents_refusal = require("./refusal.js");
 const require_onchain_accounts_intents_utils_router_path = require("./utils/router-path.js");
 const require_onchain_accounts_intents_plan = require("./plan.js");
 const require_onchain_accounts_intents_operations = require("./operations.js");
@@ -18,7 +18,7 @@ function planTail(args) {
 	const { intent, claimable, view } = args;
 	const claimed = () => {
 		const output = require_onchain_accounts_intents_operations.instantOutput(claimable.outputs);
-		if (!output) throw new require_onchain_accounts_intents_types.IntentPreviewError("insufficientSourceBalance", "finishIntent: the claim credits nothing to spend");
+		if (!output) throw new require_onchain_accounts_intents_refusal.IntentPreviewError("insufficientSourceBalance", void 0, "finishIntent: the claim credits nothing to spend");
 		return output;
 	};
 	switch (intent.type) {

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

@@ -1,17 +1 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-//#region src/onchain/accounts/intents/types.ts
-/**
-* Validation failure that maps onto {@link PreviewErrorReason} rather than
-* crashing the caller: thrown by builders, converted to `{ ok: false }` by
-* `CreditAccountOperationsService.startIntent`.
-*/
-var IntentPreviewError = class extends Error {
-	reason;
-	constructor(reason, message) {
-		super(message ?? reason);
-		this.name = "IntentPreviewError";
-		this.reason = reason;
-	}
-};
-//#endregion
-exports.IntentPreviewError = IntentPreviewError;

package/dist/cjs/onchain/index.js

@@ -193,7 +193,7 @@ require("./market/index.js");
 const require_onchain_accounts_credit_account_compressor_CreditAccountCompressorV310Contract = require("./accounts/credit-account-compressor/CreditAccountCompressorV310Contract.js");
 const require_onchain_accounts_credit_account_compressor_CreditAccountCompressor = require("./accounts/credit-account-compressor/CreditAccountCompressor.js");
 const require_onchain_accounts_CreditAccountsServiceV310 = require("./accounts/CreditAccountsServiceV310.js");
-const require_onchain_accounts_intents_types = require("./accounts/intents/types.js");
+const require_onchain_accounts_intents_refusal = require("./accounts/intents/refusal.js");
 const require_onchain_accounts_intents_utils_credit_account_slice = require("./accounts/intents/utils/credit-account-slice.js");
 const require_onchain_accounts_intents_index = require("./accounts/intents/index.js");
 const require_onchain_accounts_liquidations_constants = require("./accounts/liquidations/constants.js");
@@ -337,7 +337,7 @@ exports.IERC20ZapperContract = require_onchain_market_zapper_IERC20ZapperContrac
 exports.IETHZapperContract = require_onchain_market_zapper_IETHZapperContract.IETHZapperContract;
 exports.InfinifiGatewayAdapterContract = require_onchain_market_adapters_contracts_InfinifiGatewayAdapterContract.InfinifiGatewayAdapterContract;
 exports.InfinifiUnwindingGatewayAdapterContract = require_onchain_market_adapters_contracts_InfinifiUnwindingGatewayAdapterContract.InfinifiUnwindingGatewayAdapterContract;
-exports.IntentPreviewError = require_onchain_accounts_intents_types.IntentPreviewError;
+exports.IntentPreviewError = require_onchain_accounts_intents_refusal.IntentPreviewError;
 exports.InvalidDelayedIntentError = require_onchain_accounts_withdrawal_compressor_errors.InvalidDelayedIntentError;
 exports.KelpLRTDepositPoolAdapterContract = require_onchain_market_adapters_contracts_KelpLRTDepositPoolAdapterContract.KelpLRTDepositPoolAdapterContract;
 exports.KelpLRTWithdrawalManagerAdapterContract = require_onchain_market_adapters_contracts_KelpLRTWithdrawalManagerAdapterContract.KelpLRTWithdrawalManagerAdapterContract;
@@ -645,6 +645,7 @@ exports.percentFmt = require_onchain_utils_formatter.percentFmt;
 exports.pickStrategyTargetCollateral = require_onchain_market_credit_collateralUtils.pickStrategyTargetCollateral;
 exports.rayToBps = require_onchain_market_math.rayToBps;
 exports.rayToNumber = require_onchain_utils_formatter.rayToNumber;
+exports.refuse = require_onchain_accounts_intents_refusal.refuse;
 exports.retry = require_onchain_utils_retry.retry;
 exports.rewardsFromTransfers = require_onchain_market_adapters_transferHelpers.rewardsFromTransfers;
 exports.sendRawTx = require_onchain_utils_viem_sendRawTx.sendRawTx;

package/dist/cjs/onchain/utils/bigint-math.js

@@ -42,6 +42,15 @@ var BigIntMath = class {
 	* @returns A non-positive bigint representation of `a`.
 	*/
 	static neg = (a) => a > 0 ? a * -1n : a;
+	/**
+	* Divides rounding toward positive infinity.
+	*
+	* @param a - Dividend; must not be negative.
+	* @param b - Divisor; must be positive — zero throws, negative returns
+	* nonsense rather than the ceiling.
+	* @returns The smallest integer that is at least `a / b`.
+	**/
+	static ceilDiv = (a, b) => (a + b - 1n) / b;
 };
 //#endregion
 exports.BigIntMath = BigIntMath;

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

@@ -1,6 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_onchain_utils_hex = require("../../onchain/utils/hex.js");
 const require_onchain_base_MultichainConstruct = require("../../onchain/base/MultichainConstruct.js");
+const require_onchain_accounts_intents_refusal = require("../../onchain/accounts/intents/refusal.js");
 const require_onchain_accounts_intents_utils_credit_account_slice = require("../../onchain/accounts/intents/utils/credit-account-slice.js");
 const require_onchain_accounts_intents_index = require("../../onchain/accounts/intents/index.js");
 require("../../onchain/index.js");
@@ -36,10 +37,7 @@ var PrepareApi = class extends require_onchain_base_MultichainConstruct.Multicha
 			network: position.chainId,
 			run: async (sdk) => {
 				const intent = resumable(params.intent ?? params.claimable.intent);
-				if (!intent) return {
-					ok: false,
-					reason: "noRecordedIntent"
-				};
+				if (!intent) return require_onchain_accounts_intents_refusal.refuse("noRecordedIntent", void 0);
 				return service(sdk).finishIntent({
 					intent,
 					claimable: params.claimable,
@@ -58,10 +56,7 @@ var PrepareApi = class extends require_onchain_base_MultichainConstruct.Multicha
 		const { marketRegister, pools } = this.sdk.chain(pool.chainId);
 		const tokenIn = params.tokenIn ?? marketRegister.findByPool(pool.pool).pool.underlying;
 		const tokenOut = lpRoute(params.tokenOut, () => pools.getDepositTokensOut(pool.pool, tokenIn));
-		if (!tokenOut) return {
-			ok: false,
-			reason: "unsupportedTokenPair"
-		};
+		if (!tokenOut) return unroutable(tokenIn, void 0);
 		const preview = pools.simulateDeposit({
 			pool: pool.pool,
 			amount: params.amount,
@@ -74,10 +69,7 @@ var PrepareApi = class extends require_onchain_base_MultichainConstruct.Multicha
 			wallet: params.wallet,
 			meta: pools.getDepositMetadata(pool.pool, tokenIn, tokenOut)
 		});
-		if (!call) return {
-			ok: false,
-			reason: "unsupportedTokenPair"
-		};
+		if (!call) return unroutable(tokenIn, tokenOut);
 		return {
 			ok: true,
 			operations: [],
@@ -92,10 +84,7 @@ var PrepareApi = class extends require_onchain_base_MultichainConstruct.Multicha
 		const { pools } = this.sdk.chain(pool.chainId);
 		const tokenIn = params.tokenIn ?? pool.pool;
 		const tokenOut = lpRoute(params.tokenOut, () => pools.getWithdrawalTokensOut(pool.pool, tokenIn));
-		if (!tokenOut) return {
-			ok: false,
-			reason: "unsupportedTokenPair"
-		};
+		if (!tokenOut) return unroutable(tokenIn, void 0);
 		const preview = pools.simulateWithdraw({
 			pool: pool.pool,
 			amount: params.amount,
@@ -124,10 +113,7 @@ var PrepareApi = class extends require_onchain_base_MultichainConstruct.Multicha
 		const { pools } = this.sdk.chain(pool.chainId);
 		const tokenIn = params.tokenIn ?? pool.pool;
 		const tokenOut = lpRoute(params.tokenOut, () => pools.getWithdrawalTokensOut(pool.pool, tokenIn));
-		if (!tokenOut) return {
-			ok: false,
-			reason: "unsupportedTokenPair"
-		};
+		if (!tokenOut) return unroutable(tokenIn, void 0);
 		const preview = pools.simulateRedeem({
 			pool: pool.pool,
 			amount: params.amount,
@@ -328,6 +314,19 @@ function resumable(intent) {
 	return intent ?? void 0;
 }
 /**
+* A pool route the market does not offer, as the refusal a caller reads.
+*
+* `to` is absent where {@link lpRoute} found no output to name at all, which
+* is the usual way of it; both are present where a pair exists but nothing of
+* ours implements it.
+**/
+function unroutable(from, to) {
+	return require_onchain_accounts_intents_refusal.refuse("unsupportedTokenPair", {
+		from,
+		to
+	});
+}
+/**
 * Picks the route the operation takes out of `tokenIn`, as a value rather than
 * an exception: an unroutable or ambiguous pair is a request the caller can
 * fix, so it belongs in the `ok: false` half alongside the strategy refusals.

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

@@ -5,7 +5,7 @@ import { CreditAccountCompressorV310Contract } from "./credit-account-compressor
 import { CreditAccountCompressor } from "./credit-account-compressor/CreditAccountCompressor.js";
 import "./credit-account-compressor/index.js";
 import { CreditAccountsServiceV310 } from "./CreditAccountsServiceV310.js";
-import { IntentPreviewError } from "./intents/types.js";
+import { IntentPreviewError, refuse } from "./intents/refusal.js";
 import { fetchCreditAccountSlice, toCreditAccountSlice } from "./intents/utils/credit-account-slice.js";
 import { CreditAccountOperationsService } from "./intents/index.js";
 import { LIQUIDATION_APPROVAL_BUFFER, LIQUIDATION_COMPRESSOR_V313_ADDRESS } from "./liquidations/constants.js";
@@ -25,4 +25,4 @@ import { toWithdrawalStatus } from "./withdrawal-compressor/types.js";
 import { WithdrawalCompressorV313Contract } from "./withdrawal-compressor/WithdrawalCompressorV313Contract.js";
 import { createWithdrawalCompressor } from "./withdrawal-compressor/createWithdrawalCompressor.js";
 import "./withdrawal-compressor/index.js";
-export { AbstractWithdrawalCompressorContract, AccountBotsService, CreditAccountCompressor, CreditAccountCompressorV310Contract, CreditAccountOperationsService, CreditAccountsServiceV310, DELAYED_INTENT_TYPES, DELAYED_INTENT_VERSION, IntentPreviewError, InvalidDelayedIntentError, LIQUIDATION_APPROVAL_BUFFER, LIQUIDATION_COMPRESSOR_V313_ADDRESS, LiquidationsService, MultichainLiquidationsService, PeripheryCompressorV310Contract, RedemptionLoggerV310Contract, WithdrawalCompressorV310Contract, WithdrawalCompressorV311Contract, WithdrawalCompressorV313Contract, createRedemptionLogger, createWithdrawalCompressor, decodeDelayedIntent, encodeDelayedIntent, fetchCreditAccountSlice, getWithdrawalCompressorAddress, iCreditAccountAbi, toClaimableWithdrawal, toCreditAccountSlice, toPendingWithdrawal, toRequestableWithdrawal, toWithdrawalStatus };
+export { AbstractWithdrawalCompressorContract, AccountBotsService, CreditAccountCompressor, CreditAccountCompressorV310Contract, CreditAccountOperationsService, CreditAccountsServiceV310, DELAYED_INTENT_TYPES, DELAYED_INTENT_VERSION, IntentPreviewError, InvalidDelayedIntentError, LIQUIDATION_APPROVAL_BUFFER, LIQUIDATION_COMPRESSOR_V313_ADDRESS, LiquidationsService, MultichainLiquidationsService, PeripheryCompressorV310Contract, RedemptionLoggerV310Contract, WithdrawalCompressorV310Contract, WithdrawalCompressorV311Contract, WithdrawalCompressorV313Contract, createRedemptionLogger, createWithdrawalCompressor, decodeDelayedIntent, encodeDelayedIntent, fetchCreditAccountSlice, getWithdrawalCompressorAddress, iCreditAccountAbi, refuse, toClaimableWithdrawal, toCreditAccountSlice, toPendingWithdrawal, toRequestableWithdrawal, toWithdrawalStatus };

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

@@ -1,6 +1,6 @@
-import "../../constants/math.js";
+import { PERCENTAGE_FACTOR } from "../../constants/math.js";
 import "../../constants/index.js";
-import { IntentPreviewError } from "./types.js";
+import { IntentPreviewError } from "./refusal.js";
 import { eq } from "./utils/common.js";
 import { isPhantomToken } from "./utils/pick-token.js";
 //#region src/onchain/accounts/intents/guards.ts
@@ -12,14 +12,23 @@ import { isPhantomToken } from "./utils/pick-token.js";
 * pool has run out of what it lends. On-chain those come back as a reverted
 * multicall with a selector no form can explain, so they are read from the
 * loaded market and reported as refusals instead.
+*
+* Every guard here refuses something the market decides rather than something
+* the arithmetic cannot do, which is why all six of their reasons are
+* `blocking`: the walk that hit one still reached an end state, and a caller
+* gets that state alongside the refusal.
 */
 /**
 * The facade takes no multicall while it is paused or past its expiration, so
 * every intent the engine previews would revert on arrival.
 */
 function assertMarketOperable(suite) {
-	if (suite.isPaused) throw new IntentPreviewError("marketPaused", `${suite.creditManager.address} is paused`);
-	if (suite.isExpired) throw new IntentPreviewError("marketExpired", `${suite.creditManager.address} expired at ${suite.creditFacade.expirationDate}`);
+	const creditManager = suite.creditManager.address;
+	if (suite.isPaused) throw new IntentPreviewError("marketPaused", { creditManager }, `${creditManager} is paused`);
+	if (suite.isExpired) throw new IntentPreviewError("marketExpired", {
+		creditManager,
+		expirationDate: suite.creditFacade.expirationDate
+	}, `${creditManager} expired at ${suite.creditFacade.expirationDate}`);
 }
 /**
 * What the pool will hand this manager in one transaction: the tightest of its
@@ -41,7 +50,19 @@ function borrowable(suite) {
 /** The pool has to be able to lend what the plan means to draw. */
 function assertCanBorrow(suite, amount) {
 	const limit = borrowable(suite);
-	if (amount > limit) throw new IntentPreviewError("insufficientPoolLiquidity", `borrow: ${amount} exceeds what the pool can lend now (${limit})`);
+	if (amount > limit) {
+		const token = suite.market.pool.underlying;
+		throw new IntentPreviewError("insufficientPoolLiquidity", {
+			requested: {
+				token,
+				balance: amount
+			},
+			available: {
+				token,
+				balance: limit
+			}
+		}, `borrow: ${amount} exceeds what the pool can lend now (${limit})`);
+	}
 }
 /**
 * What the account is allowed to end up holding more of than it started with.
@@ -61,9 +82,16 @@ function assertGrowthAllowed(args) {
 	const underlying = market.pool.underlying;
 	for (const { token, balance } of after) {
 		if (balance <= (before.find((a) => eq(a.token, token))?.balance ?? 0n)) continue;
-		if (forbidden.some((f) => eq(f, token))) throw new IntentPreviewError("forbiddenToken", `${token} is forbidden in this market and the plan buys more of it`);
+		if (forbidden.some((f) => eq(f, token))) throw new IntentPreviewError("forbiddenToken", { token }, `${token} is forbidden in this market and the plan buys more of it`);
 		if (eq(token, underlying) || isPhantomToken(sdk, token)) continue;
-		if (!market.pool.pqk.hasActiveQuota(token)) throw new IntentPreviewError("quotaLimitReached", `${token} takes no quota in this market, so it counts as no collateral`);
+		if (!market.pool.pqk.hasActiveQuota(token)) throw new IntentPreviewError("quotaLimitReached", {
+			token,
+			requested: void 0,
+			available: {
+				token: underlying,
+				balance: 0n
+			}
+		}, `${token} takes no quota in this market, so it counts as no collateral`);
 	}
 }
 /**
@@ -71,10 +99,23 @@ function assertGrowthAllowed(args) {
 * and reverts if the collateral does not cover it, so a plan that lands the
 * account below water is refused here.
 *
-* The bar is the health factor of the state the plan projects: collateral under
-* liquidation thresholds, capped by quota, against the debt. Note that a
-* position already underwater cannot be nursed back one step at a time — the
-* check is on where the transaction ends, not on whether it improved things.
+* The bar is the facade's own `1.0`, because this guard answers one question:
+* would the transaction revert. It is deliberately not `MIN_HF_LIMITED`, and
+* the three bars in this codebase are three different jobs:
+*
+* - here, `1.0` — what the facade enforces, so what a plan must clear to land;
+* - `maxWithdrawCollateral` sizes at `MIN_HF_LIMITED + 2` — a *sizing* helper
+*   leaving headroom, which is not the same as a validity check;
+* - `validateHF` refuses at or below `MIN_HF_LIMITED` — a form's own caution.
+*
+* Raising this one to `MIN_HF_LIMITED` was tried and reverted: it made
+* `maxWithdraw` hand back a ceiling this guard then refused, and it blocked
+* small top-ups of an account sitting in `[1.0, 1.01)` — the very operations
+* that rescue it. A form wanting the stricter bar has `validateHF`.
+*
+* Note that a position already underwater cannot be nursed back one step at a
+* time — the check is on where the transaction ends, not on whether it
+* improved things.
 *
 * @remarks
 * The caller decides the pricing the factor was computed at: main prices, or
@@ -82,20 +123,36 @@ function assertGrowthAllowed(args) {
 * whose reserve feed the SDK cannot read keeps its main price, so a plan can
 * still be refused on-chain after passing here.
 */
-function assertCollateralised(healthFactorBps) {
-	if (healthFactorBps < Number(10000n)) throw new IntentPreviewError("insufficientCollateral", `the account would end at a health factor of ${healthFactorBps}, below 1.0`);
+function assertCollateralised(healthFactorBps, safePrices) {
+	const required = Number(PERCENTAGE_FACTOR);
+	if (healthFactorBps < required) throw new IntentPreviewError("insufficientCollateral", {
+		healthFactor: healthFactorBps,
+		required,
+		safePrices
+	}, `the account would end at a health factor of ${healthFactorBps}, below ${required}`);
 }
 /**
 * A quota can only be raised as far as the market still has room for: past the
 * token's limit the keeper takes nothing more, whoever is asking.
 */
 function assertQuotaHeadroom(market, increases) {
+	const underlying = market.pool.underlying;
 	for (const { token, balance } of increases) {
 		if (balance <= 0n) continue;
 		const quota = market.pool.pqk.quotas.get(token);
 		if (!quota) continue;
 		const left = quota.limit - quota.totalQuoted;
-		if (balance > left) throw new IntentPreviewError("quotaLimitReached", `${token} has ${left} of quota left, the plan needs ${balance}`);
+		if (balance > left) throw new IntentPreviewError("quotaLimitReached", {
+			token,
+			requested: {
+				token: underlying,
+				balance
+			},
+			available: {
+				token: underlying,
+				balance: left
+			}
+		}, `${token} has ${left} of quota left, the plan needs ${balance}`);
 	}
 }
 //#endregion

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

@@ -1,6 +1,6 @@
 import { SDKConstruct } from "../../base/SDKConstruct.js";
 import { MIN_HF_LIMITED } from "../../../common-utils/utils/validation/validate-hf.js";
-import { IntentPreviewError } from "./types.js";
+import { IntentPreviewError, refuse } from "./refusal.js";
 import { assertMarketOperable } from "./guards.js";
 import { maxProportionalWithdrawal } from "./math.js";
 import { maxWithdrawCollateral } from "./maxWithdrawCollateral.js";
@@ -169,9 +169,11 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 		const [instant, delayed] = await Promise.allSettled([this.startIntent(props), this.startDelayedIntent(props)]);
 		const instantRoute = instant.status === "fulfilled" && instant.value.ok ? instant.value : void 0;
 		const delayedRoute = delayed.status === "fulfilled" && delayed.value.ok ? delayed.value : void 0;
+		const instantRefusal = instant.status === "fulfilled" && !instant.value.ok ? instant.value : void 0;
+		const delayedRefusal = delayed.status === "fulfilled" && !delayed.value.ok ? delayed.value : void 0;
 		const refused = {
-			instant: instant.status === "fulfilled" && !instant.value.ok ? instant.value.reason : void 0,
-			delayed: delayed.status === "fulfilled" && !delayed.value.ok ? delayed.value.reason : void 0
+			instant: instantRefusal?.reason,
+			delayed: delayedRefusal?.reason
 		};
 		if (instantRoute || delayedRoute) return {
 			ok: true,
@@ -181,11 +183,10 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 		};
 		const failed = [instant, delayed].find((s) => s.status === "rejected");
 		if (failed?.status === "rejected") throw failed.reason;
-		const reason = refused.instant ?? refused.delayed;
-		if (reason === void 0) throw new Error("intentRoutes: a route neither answered nor refused");
+		const chosen = instantRefusal ?? delayedRefusal;
+		if (chosen === void 0) throw new Error("intentRoutes: a route neither answered nor refused");
 		return {
-			ok: false,
-			reason,
+			...chosen,
 			refused
 		};
 	}
@@ -267,14 +268,8 @@ function plain(result) {
 }
 /** Unviable requests are values; anything else is a genuine failure. */
 function asFailure(e) {
-	if (e instanceof IntentPreviewError) return {
-		ok: false,
-		reason: e.reason
-	};
-	if (isUnroutable(e)) return {
-		ok: false,
-		reason: "unsupportedTokenPair"
-	};
+	if (e instanceof IntentPreviewError) return refuse(e.reason, e.detail);
+	if (isUnroutable(e)) return refuse("unsupportedTokenPair", void 0);
 	throw e;
 }
 /**
@@ -290,4 +285,4 @@ function isUnroutable(e) {
 	return false;
 }
 //#endregion
-export { CreditAccountOperationsService, IntentPreviewError, fetchCreditAccountSlice, toCreditAccountSlice };
+export { CreditAccountOperationsService, IntentPreviewError, fetchCreditAccountSlice, refuse, toCreditAccountSlice };

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

@@ -1,5 +1,6 @@
+import { BigIntMath } from "../../utils/bigint-math.js";
 import { LEVERAGE_DECIMALS } from "../../constants/math.js";
-import { IntentPreviewError } from "./types.js";
+import { IntentPreviewError } from "./refusal.js";
 //#region src/onchain/accounts/intents/math.ts
 /** Debt that realises `leverage` on `collateral`: `D = C · (L − 1)`. */
 function debtForLeverage(collateral, leverage) {
@@ -13,7 +14,7 @@ function debtForLeverage(collateral, leverage) {
 * it, so no rounding is introduced on the way.
 */
 function proportionalDebt(position, collateralDelta) {
-	if (position.collateral <= 0n) throw new IntentPreviewError("insufficientSourceBalance", "cannot preserve leverage on an account with no collateral");
+	if (position.collateral <= 0n) throw new IntentPreviewError("insufficientSourceBalance", void 0, "cannot preserve leverage on an account with no collateral");
 	return position.debt * collateralDelta / position.collateral;
 }
 /**
@@ -31,21 +32,37 @@ function maxProportionalWithdrawal(position, band) {
 	if (debt === 0n) return allButLast;
 	const repayable = debt - band.minDebt;
 	if (repayable < 0n) return 0n;
-	const bound = ceilDiv(collateral * (repayable + 1n), debt) - 1n;
+	const bound = BigIntMath.ceilDiv(collateral * (repayable + 1n), debt) - 1n;
 	return bound < allButLast ? bound : allButLast;
 }
-const ceilDiv = (a, b) => (a + b - 1n) / b;
 /** Total leverage cannot drop below 1x — that would be negative debt. */
 function assertLeverageAtLeastOne(leverage) {
-	if (leverage < 100n) throw new IntentPreviewError("leverageOutOfRange", `target leverage ${leverage} is below 1x`);
+	if (leverage < 100n) throw new IntentPreviewError("leverageOutOfRange", {
+		requested: leverage,
+		min: LEVERAGE_DECIMALS
+	}, `target leverage ${leverage} is below 1x`);
 }
 /**
 * Rejects a debt the facade would revert on: zero is always fine (no loan at
 * all), anything else has to sit inside `[minDebt, maxDebt]`.
 */
-function assertDebtInBand(debt, band) {
-	if (debt > band.maxDebt) throw new IntentPreviewError("debtOutOfRange", `debt ${debt} exceeds maxDebt ${band.maxDebt}`);
-	if (debt > 0n && debt < band.minDebt) throw new IntentPreviewError("debtOutOfRange", `debt ${debt} is below minDebt ${band.minDebt}`);
+function assertDebtInBand(debt, band, underlying) {
+	const detail = {
+		requested: {
+			token: underlying,
+			balance: debt
+		},
+		minDebt: {
+			token: underlying,
+			balance: band.minDebt
+		},
+		maxDebt: {
+			token: underlying,
+			balance: band.maxDebt
+		}
+	};
+	if (debt > band.maxDebt) throw new IntentPreviewError("debtOutOfRange", detail, `debt ${debt} exceeds maxDebt ${band.maxDebt}`);
+	if (debt > 0n && debt < band.minDebt) throw new IntentPreviewError("debtOutOfRange", detail, `debt ${debt} is below minDebt ${band.minDebt}`);
 }
 //#endregion
 export { assertDebtInBand, assertLeverageAtLeastOne, debtForLeverage, maxProportionalWithdrawal, proportionalDebt };

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

@@ -56,8 +56,8 @@ function maxWithdrawCollateral(props) {
 	const targetLt = BigInt(creditManager.liquidationThresholds.get(target.token) ?? 0);
 	const targetUsd = safeUsd(priceOracle, target.token, target.balance);
 	if (targetLt === 0n || !targetUsd) return 0n;
-	const keptUsd = ceilDiv(shortfall, targetLt);
-	const kept = ceilDiv(target.balance * keptUsd, targetUsd);
+	const keptUsd = BigIntMath.ceilDiv(shortfall, targetLt);
+	const kept = BigIntMath.ceilDiv(target.balance * keptUsd, targetUsd);
 	return kept >= target.balance ? 0n : target.balance - kept;
 }
 /** USD value at the main feed, or `undefined` when the token has no price. */
@@ -81,8 +81,5 @@ function safeUsd(oracle, token, amount) {
 		return main;
 	}
 }
-function ceilDiv(a, b) {
-	return (a + b - 1n) / b;
-}
 //#endregion
 export { maxWithdrawCollateral };

package/dist/esm/onchain/accounts/intents/open-strategy.js

@@ -1,8 +1,7 @@
-import "../../constants/math.js";
-import { IntentPreviewError } from "./types.js";
+import { IntentPreviewError } from "./refusal.js";
 import { convertAmount } from "./utils/convert-amount.js";
 import { assertCanBorrow, assertCollateralised, assertGrowthAllowed, assertMarketOperable, assertQuotaHeadroom } from "./guards.js";
-import { assertDebtInBand, debtForLeverage } from "./math.js";
+import { assertDebtInBand, assertLeverageAtLeastOne, debtForLeverage } from "./math.js";
 import { getQuotasForUpdate } from "./utils/quotas-for-update.js";
 import { createRouterPaths } from "./utils/router-path.js";
 import "./utils/index.js";
@@ -22,14 +21,14 @@ const NO_ACCOUNT = "0x0000000000000000000000000000000000000000";
 */
 async function previewOpenStrategy(props) {
 	const { sdk, creditManager, collateral, targetToken, leverage, slippage = 0, quotaReserve, leftoverBalances = [] } = props;
-	if (leverage < 100n) throw new IntentPreviewError("leverageOutOfRange", `openStrategy: leverage ${leverage} is below 1x`);
+	assertLeverageAtLeastOne(leverage);
 	const suite = sdk.marketRegister.findCreditManager(creditManager);
 	const market = sdk.marketRegister.findByCreditManager(creditManager);
 	assertMarketOperable(suite);
 	const underlying = market.pool.underlying.toLowerCase();
 	const convert = convertAmount(sdk, creditManager);
 	const margin = collateral.reduce((acc, a) => acc + convert(a.token, underlying, a.balance), 0n);
-	if (margin <= 0n) throw new IntentPreviewError("insufficientSourceBalance", "openStrategy: collateral is worth nothing in underlying");
+	if (margin <= 0n) throw new IntentPreviewError("insufficientSourceBalance", void 0, "openStrategy: collateral is worth nothing in underlying");
 	const debt = debtForLeverage(margin, leverage);
 	const account = {
 		creditAccount: NO_ACCOUNT,
@@ -41,7 +40,7 @@ async function previewOpenStrategy(props) {
 		accountDebt: 0n,
 		tokens: []
 	};
-	assertDebtInBand(debt, suite.creditFacade);
+	assertDebtInBand(debt, suite.creditFacade, underlying);
 	assertCanBorrow(suite, debt);
 	const leg = await createRouterPaths({
 		sdk,
@@ -90,7 +89,7 @@ async function previewOpenStrategy(props) {
 		timeToLiquidation: sdk.positions.timeToLiquidation(snapshot, projectedPool),
 		liquidationPrice: sdk.positions.liquidationPrice(snapshot)
 	};
-	assertCollateralised(metrics.healthFactor);
+	assertCollateralised(metrics.healthFactor, false);
 	return {
 		debt,
 		collateral: margin,