@gearbox-protocol/sdk 16.0.0-next.8 → 16.0.0

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

@@ -6,8 +6,10 @@ const require_onchain_accounts_credit_account_compressor_CreditAccountCompressor
 const require_onchain_accounts_credit_account_compressor_CreditAccountCompressor = require("./credit-account-compressor/CreditAccountCompressor.js");
 require("./credit-account-compressor/index.js");
 const require_onchain_accounts_CreditAccountsServiceV310 = require("./CreditAccountsServiceV310.js");
-const require_onchain_accounts_intents_types = require("./intents/types.js");
+const require_onchain_accounts_intents_utils_pick_token = require("./intents/utils/pick-token.js");
+const require_onchain_accounts_intents_guards = require("./intents/guards.js");
 const require_onchain_accounts_intents_utils_credit_account_slice = require("./intents/utils/credit-account-slice.js");
+const require_onchain_accounts_quota_utils = require("./quota-utils.js");
 const require_onchain_accounts_intents_index = require("./intents/index.js");
 const require_onchain_accounts_liquidations_constants = require("./liquidations/constants.js");
 const require_onchain_accounts_liquidations_LiquidationsService = require("./liquidations/LiquidationsService.js");
@@ -17,7 +19,6 @@ require("./types.js");
 const require_onchain_accounts_withdrawal_compressor_intent_codec = require("./withdrawal-compressor/intent-codec.js");
 const require_onchain_accounts_withdrawal_compressor_AbstractWithdrawalCompressorContract = require("./withdrawal-compressor/AbstractWithdrawalCompressorContract.js");
 const require_onchain_accounts_withdrawal_compressor_addresses = require("./withdrawal-compressor/addresses.js");
-const require_onchain_accounts_withdrawal_compressor_errors = require("./withdrawal-compressor/errors.js");
 const require_onchain_accounts_withdrawal_compressor_RedemptionLoggerV310Contract = require("./withdrawal-compressor/RedemptionLoggerV310Contract.js");
 const require_onchain_accounts_withdrawal_compressor_createRedemptionLogger = require("./withdrawal-compressor/createRedemptionLogger.js");
 const require_onchain_accounts_withdrawal_compressor_WithdrawalCompressorV310Contract = require("./withdrawal-compressor/WithdrawalCompressorV310Contract.js");
@@ -34,8 +35,6 @@ exports.CreditAccountOperationsService = require_onchain_accounts_intents_index.
 exports.CreditAccountsServiceV310 = require_onchain_accounts_CreditAccountsServiceV310.CreditAccountsServiceV310;
 exports.DELAYED_INTENT_TYPES = require_onchain_accounts_withdrawal_compressor_intent_codec.DELAYED_INTENT_TYPES;
 exports.DELAYED_INTENT_VERSION = require_onchain_accounts_withdrawal_compressor_intent_codec.DELAYED_INTENT_VERSION;
-exports.IntentPreviewError = require_onchain_accounts_intents_types.IntentPreviewError;
-exports.InvalidDelayedIntentError = require_onchain_accounts_withdrawal_compressor_errors.InvalidDelayedIntentError;
 exports.LIQUIDATION_APPROVAL_BUFFER = require_onchain_accounts_liquidations_constants.LIQUIDATION_APPROVAL_BUFFER;
 exports.LIQUIDATION_COMPRESSOR_V313_ADDRESS = require_onchain_accounts_liquidations_constants.LIQUIDATION_COMPRESSOR_V313_ADDRESS;
 exports.LiquidationsService = require_onchain_accounts_liquidations_LiquidationsService.LiquidationsService;
@@ -45,6 +44,10 @@ exports.RedemptionLoggerV310Contract = require_onchain_accounts_withdrawal_compr
 exports.WithdrawalCompressorV310Contract = require_onchain_accounts_withdrawal_compressor_WithdrawalCompressorV310Contract.WithdrawalCompressorV310Contract;
 exports.WithdrawalCompressorV311Contract = require_onchain_accounts_withdrawal_compressor_WithdrawalCompressorV311Contract.WithdrawalCompressorV311Contract;
 exports.WithdrawalCompressorV313Contract = require_onchain_accounts_withdrawal_compressor_WithdrawalCompressorV313Contract.WithdrawalCompressorV313Contract;
+exports.borrowable = require_onchain_accounts_intents_guards.borrowable;
+exports.calcDefaultQuota = require_onchain_accounts_quota_utils.calcDefaultQuota;
+exports.calcQuotaUpdate = require_onchain_accounts_quota_utils.calcQuotaUpdate;
+exports.calcRecommendedQuota = require_onchain_accounts_quota_utils.calcRecommendedQuota;
 exports.createRedemptionLogger = require_onchain_accounts_withdrawal_compressor_createRedemptionLogger.createRedemptionLogger;
 exports.createWithdrawalCompressor = require_onchain_accounts_withdrawal_compressor_createWithdrawalCompressor.createWithdrawalCompressor;
 exports.decodeDelayedIntent = require_onchain_accounts_withdrawal_compressor_intent_codec.decodeDelayedIntent;
@@ -52,6 +55,8 @@ exports.encodeDelayedIntent = require_onchain_accounts_withdrawal_compressor_int
 exports.fetchCreditAccountSlice = require_onchain_accounts_intents_utils_credit_account_slice.fetchCreditAccountSlice;
 exports.getWithdrawalCompressorAddress = require_onchain_accounts_withdrawal_compressor_addresses.getWithdrawalCompressorAddress;
 exports.iCreditAccountAbi = require_onchain_accounts_withdrawal_compressor_AbstractWithdrawalCompressorContract.iCreditAccountAbi;
+exports.isPhantomToken = require_onchain_accounts_intents_utils_pick_token.isPhantomToken;
+exports.roundUpQuota = require_onchain_accounts_quota_utils.roundUpQuota;
 exports.toClaimableWithdrawal = require_onchain_accounts_withdrawal_compressor_AbstractWithdrawalCompressorContract.toClaimableWithdrawal;
 exports.toCreditAccountSlice = require_onchain_accounts_intents_utils_credit_account_slice.toCreditAccountSlice;
 exports.toPendingWithdrawal = require_onchain_accounts_withdrawal_compressor_AbstractWithdrawalCompressorContract.toPendingWithdrawal;

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

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("../../constants/math.js");
-require("../../constants/index.js");
-const require_onchain_accounts_intents_types = require("./types.js");
+const require_onchain_validation_checks = require("../../validation/checks.js");
+const require_onchain_validation_refusal = require("../../validation/refusal.js");
+const require_onchain_validation_token = require("../../validation/token.js");
 const require_onchain_accounts_intents_utils_common = require("./utils/common.js");
 const require_onchain_accounts_intents_utils_pick_token = require("./utils/pick-token.js");
 //#region src/onchain/accounts/intents/guards.ts
@@ -13,14 +13,27 @@ const require_onchain_accounts_intents_utils_pick_token = require("./utils/pick-
 * 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 require_onchain_accounts_intents_types.IntentPreviewError("marketPaused", `${suite.creditManager.address} is paused`);
-	if (suite.isExpired) throw new require_onchain_accounts_intents_types.IntentPreviewError("marketExpired", `${suite.creditManager.address} expired at ${suite.creditFacade.expirationDate}`);
+	const creditManager = suite.creditManager.address;
+	require_onchain_validation_refusal.raise(require_onchain_validation_checks.checkCreditManagerPaused({
+		isPaused: suite.isPaused,
+		creditManager
+	}), `${creditManager} is paused`);
+	require_onchain_validation_refusal.raise(require_onchain_validation_checks.checkMarketExpired({
+		isExpired: suite.isExpired,
+		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
@@ -31,18 +44,35 @@ function assertMarketOperable(suite) {
 function borrowable(suite) {
 	const { pool } = suite.market.pool;
 	const { maxDebtPerBlockMultiplier, maxDebt } = suite.creditFacade;
-	if (maxDebtPerBlockMultiplier === 0) return 0n;
+	if (maxDebtPerBlockMultiplier === 0) return {
+		limit: 0n,
+		binding: "facadePerBlockCap"
+	};
 	const available = pool.creditManagerDebtParams.get(suite.creditManager.address)?.available;
 	return [
-		pool.availableLiquidity,
-		maxDebt * BigInt(maxDebtPerBlockMultiplier),
-		...available === void 0 ? [] : [available]
-	].reduce((a, b) => a < b ? a : b);
+		{
+			limit: pool.availableLiquidity,
+			binding: "poolAvailableLiquidity"
+		},
+		{
+			limit: maxDebt * BigInt(maxDebtPerBlockMultiplier),
+			binding: "facadePerBlockCap"
+		},
+		...available === void 0 ? [] : [{
+			limit: available,
+			binding: "managerDebtAvailable"
+		}]
+	].reduce((a, b) => b.limit < a.limit ? b : a);
 }
 /** 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 require_onchain_accounts_intents_types.IntentPreviewError("insufficientPoolLiquidity", `borrow: ${amount} exceeds what the pool can lend now (${limit})`);
+function assertCanBorrow(sdk, suite, amount) {
+	const { limit, binding } = borrowable(suite);
+	require_onchain_validation_refusal.raise(require_onchain_validation_checks.checkBorrowLimit({
+		requested: amount,
+		available: limit,
+		binding,
+		underlying: require_onchain_validation_token.toToken(sdk, suite.market.pool.underlying)
+	}), `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.
@@ -62,9 +92,17 @@ function assertGrowthAllowed(args) {
 	const underlying = market.pool.underlying;
 	for (const { token, balance } of after) {
 		if (balance <= (before.find((a) => require_onchain_accounts_intents_utils_common.eq(a.token, token))?.balance ?? 0n)) continue;
-		if (forbidden.some((f) => require_onchain_accounts_intents_utils_common.eq(f, token))) throw new require_onchain_accounts_intents_types.IntentPreviewError("forbiddenToken", `${token} is forbidden in this market and the plan buys more of it`);
+		require_onchain_validation_refusal.raise(require_onchain_validation_checks.checkForbiddenToken({
+			token: require_onchain_validation_token.toToken(sdk, token),
+			isForbidden: forbidden.some((f) => require_onchain_accounts_intents_utils_common.eq(f, token))
+		}), `${token} is forbidden in this market and the plan buys more of it`);
 		if (require_onchain_accounts_intents_utils_common.eq(token, underlying) || require_onchain_accounts_intents_utils_pick_token.isPhantomToken(sdk, token)) continue;
-		if (!market.pool.pqk.hasActiveQuota(token)) throw new require_onchain_accounts_intents_types.IntentPreviewError("quotaLimitReached", `${token} takes no quota in this market, so it counts as no collateral`);
+		if (!market.pool.pqk.hasActiveQuota(token)) require_onchain_validation_refusal.raise(require_onchain_validation_checks.checkQuotaLimit({
+			token: require_onchain_validation_token.toToken(sdk, token),
+			requested: void 0,
+			available: 0n,
+			underlying: require_onchain_validation_token.toToken(sdk, underlying)
+		}), `${token} takes no quota in this market, so it counts as no collateral`);
 	}
 }
 /**
@@ -72,10 +110,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;
+* - a form refuses at or below `MIN_HF_LIMITED` (`MIN_HEALTH_FACTOR_FORM`).
+*
+* 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
@@ -83,20 +134,31 @@ 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 require_onchain_accounts_intents_types.IntentPreviewError("insufficientCollateral", `the account would end at a health factor of ${healthFactorBps}, below 1.0`);
+function assertCollateralised(healthFactorBps, safePrices) {
+	const required = require_onchain_validation_checks.MIN_HEALTH_FACTOR_FACADE;
+	require_onchain_validation_refusal.raise(require_onchain_validation_checks.checkCollateralised({
+		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) {
+function assertQuotaHeadroom(sdk, 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 require_onchain_accounts_intents_types.IntentPreviewError("quotaLimitReached", `${token} has ${left} of quota left, the plan needs ${balance}`);
+		require_onchain_validation_refusal.raise(require_onchain_validation_checks.checkQuotaLimit({
+			token: require_onchain_validation_token.toToken(sdk, token),
+			requested: balance,
+			available: left,
+			underlying: require_onchain_validation_token.toToken(sdk, underlying)
+		}), `${token} has ${left} of quota left, the plan needs ${balance}`);
 	}
 }
 //#endregion

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

@@ -1,8 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_onchain_base_SDKConstruct = require("../../base/SDKConstruct.js");
-const require_common_utils_utils_validation_validate_hf = require("../../../common-utils/utils/validation/validate-hf.js");
-const require_onchain_accounts_intents_types = require("./types.js");
+const require_onchain_validation_checks = require("../../validation/checks.js");
+const require_onchain_validation_refusal = require("../../validation/refusal.js");
+const require_onchain_accounts_intents_utils_pick_token = require("./utils/pick-token.js");
 const require_onchain_accounts_intents_guards = require("./guards.js");
+const require_onchain_accounts_intents_leverage_band = require("./leverage-band.js");
 const require_onchain_accounts_intents_math = require("./math.js");
 const require_onchain_accounts_intents_maxWithdrawCollateral = require("./maxWithdrawCollateral.js");
 const require_onchain_accounts_intents_utils_credit_account_slice = require("./utils/credit-account-slice.js");
@@ -44,17 +46,27 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 		}));
 	}
 	/**
-	* Largest `WITHDRAW` amount (in underlying) the account can take out while
-	* keeping leverage and staying inside the facade's debt band — the ceiling a
-	* withdraw form should offer. Taking everything out is the same intent with
-	* `MAX_UINT256` for an amount, and needs none of this arithmetic.
+	* Both ends of what a `WITHDRAW` can take out, in underlying: the largest
+	* partial withdrawal that keeps leverage and stays inside the facade's debt
+	* band, and the net value an exit hands over. They are reported together
+	* because a withdraw form needs both — the range it may offer, and the one
+	* amount past it that is allowed — and because the distance between them is
+	* the account's own, not a constant a caller could assume.
+	*
+	* 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
+	* @returns The two ceilings, see {@link WithdrawCeilings} for the gap between
+	* them
 	*/
 	maxWithdraw(props) {
 		const view = require_onchain_accounts_intents_view.accountView(props.creditAccount, props.sdk);
-		return require_onchain_accounts_intents_math.maxProportionalWithdrawal(view, view.band);
+		return {
+			partial: require_onchain_accounts_intents_math.maxProportionalWithdrawal(view, view.band),
+			exit: view.collateral > 0n ? view.collateral : 0n
+		};
 	}
 	/**
 	* Debt a `REPAY` would have to cover to settle the account, in underlying
@@ -73,20 +85,44 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 		return require_onchain_accounts_intents_view.accountView(props.creditAccount, props.sdk).debt;
 	}
 	/**
+	* The leverages a position of a given size can be opened at, or moved to.
+	*
+	* A credit manager's `maxLeverage` follows from the liquidation threshold
+	* alone, so it is the same for a hundred dollars and for a million. What a
+	* given deposit reaches is decided by the debt it implies and by the band
+	* the market puts that debt in — the range a leverage slider should offer.
+	*
+	* Unlike the other ceilings here this one reads no account: opening has none
+	* 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, 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) {
+		return require_onchain_accounts_intents_leverage_band.calcLeverageBand(props);
+	}
+	/**
 	* 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 a form 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_onchain_validation_checks.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
 		});
 	}
 	/**
@@ -140,7 +176,7 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 			});
 			return {
 				...result,
-				preview: tail.state,
+				state: tail.state,
 				delayed
 			};
 		} catch (e) {
@@ -170,9 +206,11 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 		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,
@@ -182,11 +220,10 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 		};
 		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
 		};
 	}
@@ -199,17 +236,36 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 	* whole tail: the tokens land on the account and only their quota has to
 	* catch up.
 	*
+	* A claim that brought only part of what the request queued — a legacy Mellow
+	* multivault, which pays out what it holds liquid and re-queues the rest — is
+	* served in proportion, and what it did not settle comes back as `remainder`:
+	* the withdrawal still in flight and the intent to finish it with.
+	*
 	* @param props - The recorded intent, the account slice as it stands now, and
 	* the matured claimable
-	* @returns Shaped exactly like {@link startIntent}'s result, so both halves of
-	* an operation are consumed the same way
+	* @returns Shaped exactly like {@link startIntent}'s result with the remainder
+	* beside it, so both halves of an operation are consumed the same way
 	*/
 	async finishIntent(props) {
-		return plain(await this.#preview(props, () => require_onchain_accounts_intents_tail.planTail({
-			intent: props.intent,
-			claimable: props.claimable,
-			view: require_onchain_accounts_intents_view.accountView(props.creditAccount, props.sdk)
-		})));
+		let remainder;
+		const result = await this.#preview(props, () => {
+			const tail = require_onchain_accounts_intents_tail.planTail({
+				intent: props.intent,
+				claimable: props.claimable,
+				view: require_onchain_accounts_intents_view.accountView(props.creditAccount, props.sdk)
+			});
+			remainder = tail.remainder;
+			return tail.steps;
+		});
+		if (!result.ok) return result;
+		const { operations, state, calls } = result;
+		return {
+			ok: true,
+			operations,
+			state,
+			calls,
+			remainder
+		};
 	}
 	/**
 	* Previews opening a brand-new leveraged position.
@@ -227,7 +283,7 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 		try {
 			return {
 				ok: true,
-				preview: await require_onchain_accounts_intents_open_strategy.previewOpenStrategy(props)
+				state: await require_onchain_accounts_intents_open_strategy.buildOpenStrategyState(props)
 			};
 		} catch (e) {
 			return asFailure(e);
@@ -246,7 +302,7 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 			return {
 				ok: true,
 				operations,
-				preview: state,
+				state,
 				calls,
 				delayed
 			};
@@ -258,24 +314,18 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 /** Drops the delayed half for the flows that cannot produce one. */
 function plain(result) {
 	if (!result.ok) return result;
-	const { operations, preview, calls } = result;
+	const { operations, state, calls } = result;
 	return {
 		ok: true,
 		operations,
-		preview,
+		state,
 		calls
 	};
 }
 /** Unviable requests are values; anything else is a genuine failure. */
 function asFailure(e) {
-	if (e instanceof require_onchain_accounts_intents_types.IntentPreviewError) return {
-		ok: false,
-		reason: e.reason
-	};
-	if (isUnroutable(e)) return {
-		ok: false,
-		reason: "unsupportedTokenPair"
-	};
+	if (e instanceof require_onchain_validation_refusal.IntentPreviewError) return require_onchain_validation_refusal.refuse(e.reason, e.detail);
+	if (isUnroutable(e)) return require_onchain_validation_refusal.refuse("unsupportedTokenPair", void 0);
 	throw e;
 }
 /**
@@ -292,6 +342,7 @@ function isUnroutable(e) {
 }
 //#endregion
 exports.CreditAccountOperationsService = CreditAccountOperationsService;
-exports.IntentPreviewError = require_onchain_accounts_intents_types.IntentPreviewError;
+exports.borrowable = require_onchain_accounts_intents_guards.borrowable;
 exports.fetchCreditAccountSlice = require_onchain_accounts_intents_utils_credit_account_slice.fetchCreditAccountSlice;
+exports.isPhantomToken = require_onchain_accounts_intents_utils_pick_token.isPhantomToken;
 exports.toCreditAccountSlice = require_onchain_accounts_intents_utils_credit_account_slice.toCreditAccountSlice;

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

@@ -0,0 +1,70 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_utils_bigint_math = require("../../utils/bigint-math.js");
+const require_onchain_constants_math = require("../../constants/math.js");
+//#region src/onchain/accounts/intents/leverage-band.ts
+/**
+* The leverages this market will actually fund for a position of this size.
+*
+* A credit manager's `maxLeverage` follows from the liquidation threshold
+* alone, so it is the same for a hundred dollars and for a million. What a
+* given deposit reaches is decided by the debt it implies —
+* `debt = netValue × (leverage − 1)` — and by the band the market puts that
+* debt in. This inverts that relation.
+*
+* Rounding is asymmetric because the forward direction truncates: the floor
+* rounds **up** so the leverage it names really does clear `minDebt`, and the
+* ceiling rounds **down** so it really does stay under the borrow limit.
+*
+* Nothing here is fetched or simulated — every input is loaded market state,
+* so a form can call this on each keystroke.
+*
+* @param props - {@link LeverageBandProps}
+* @returns The band, or `undefined` when there is nothing to offer: an
+* unknown manager, a market with no strategy, or a deposit too small to reach
+* `minDebt` at any leverage the threshold allows.
+*
+* @example
+* ```ts
+* // minDebt 1k, borrow limit 100k, threshold ceiling 9x, deposit worth 10k
+* calcLeverageBand({ sdk, creditManager, collateral }) // { min: 1.1, max: 9 }
+* ```
+**/
+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, targetHF);
+	const underlying = market.pool.underlying;
+	const convert = (from, to, amount) => market.priceOracle.safeConvert(from, to, amount).value;
+	const netValue = collateral.reduce((acc, a) => acc + convert(a.token, underlying, a.balance), 0n);
+	if (netValue <= 0n) return {
+		min: 1,
+		max: ceiling
+	};
+	const { minDebt, maxDebt } = suite.creditFacade;
+	const available = market.pool.pool.creditManagerDebtParams.get(suite.creditManager.address)?.available;
+	const borrowLimit = available === void 0 ? maxDebt : require_onchain_utils_bigint_math.BigIntMath.min(maxDebt, available);
+	const floor = require_onchain_utils_bigint_math.BigIntMath.ceilDiv(require_onchain_constants_math.LEVERAGE_DECIMALS * minDebt, netValue);
+	const roof = require_onchain_constants_math.LEVERAGE_DECIMALS * borrowLimit / netValue;
+	const min = 1 + Number(floor) / Number(require_onchain_constants_math.LEVERAGE_DECIMALS);
+	const max = Math.min(ceiling, 1 + Number(roof) / Number(require_onchain_constants_math.LEVERAGE_DECIMALS));
+	return min > max ? void 0 : {
+		min,
+		max
+	};
+}
+/** The manager's suite and market, or nothing while they cannot be resolved. */
+function resolve(sdk, creditManager) {
+	try {
+		return {
+			suite: sdk.marketRegister.findCreditManager(creditManager),
+			market: sdk.marketRegister.findByCreditManager(creditManager)
+		};
+	} catch {
+		return;
+	}
+}
+//#endregion
+exports.calcLeverageBand = calcLeverageBand;

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

@@ -1,7 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_onchain_utils_bigint_math = require("../../utils/bigint-math.js");
 const require_onchain_constants_math = require("../../constants/math.js");
-const require_onchain_accounts_intents_types = require("./types.js");
+const require_onchain_validation_checks = require("../../validation/checks.js");
+const require_onchain_validation_refusal = require("../../validation/refusal.js");
+const require_onchain_validation_token = require("../../validation/token.js");
 //#region src/onchain/accounts/intents/math.ts
 /** Debt that realises `leverage` on `collateral`: `D = C · (L − 1)`. */
 function debtForLeverage(collateral, leverage) {
@@ -15,7 +17,7 @@ function debtForLeverage(collateral, leverage) {
 * it, so no rounding is introduced on the way.
 */
 function proportionalDebt(position, collateralDelta) {
-	if (position.collateral <= 0n) throw new require_onchain_accounts_intents_types.IntentPreviewError("insufficientSourceBalance", "cannot preserve leverage on an account with no collateral");
+	if (position.collateral <= 0n) throw new require_onchain_validation_refusal.IntentPreviewError("insufficientSourceBalance", void 0, "cannot preserve leverage on an account with no collateral");
 	return position.debt * collateralDelta / position.collateral;
 }
 /**
@@ -38,15 +40,23 @@ function maxProportionalWithdrawal(position, band) {
 }
 /** Total leverage cannot drop below 1x — that would be negative debt. */
 function assertLeverageAtLeastOne(leverage) {
-	if (leverage < 100n) throw new require_onchain_accounts_intents_types.IntentPreviewError("leverageOutOfRange", `target leverage ${leverage} is below 1x`);
+	require_onchain_validation_refusal.raise(require_onchain_validation_checks.checkLeverageAtLeastOne({
+		leverage,
+		min: require_onchain_constants_math.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 require_onchain_accounts_intents_types.IntentPreviewError("debtOutOfRange", `debt ${debt} exceeds maxDebt ${band.maxDebt}`);
-	if (debt > 0n && debt < band.minDebt) throw new require_onchain_accounts_intents_types.IntentPreviewError("debtOutOfRange", `debt ${debt} is below minDebt ${band.minDebt}`);
+function assertDebtInBand(sdk, debt, band, underlying) {
+	require_onchain_validation_refusal.raise(require_onchain_validation_checks.checkDebtInBand({
+		debt,
+		minDebt: band.minDebt,
+		maxDebt: band.maxDebt,
+		underlying: require_onchain_validation_token.toToken(sdk, underlying),
+		allowZero: true
+	}), debt > band.maxDebt ? `debt ${debt} exceeds maxDebt ${band.maxDebt}` : `debt ${debt} is below minDebt ${band.minDebt}`);
 }
 //#endregion
 exports.assertDebtInBand = assertDebtInBand;

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

@@ -12,9 +12,11 @@ const require_onchain_accounts_intents_utils_common = require("./utils/common.js
 * check counts: a holding backed by a quota contributes the lesser of the
 * quota and its threshold-weighted value, an unquoted one — the underlying —
 * its weighted value alone, and dust or a disabled balance nothing at all.
-* Collateral is valued at the lower of its two feeds, the way the facade
-* values a call that hands funds over; the debt is valued at the main feed,
-* as the check does. Zero debt frees the whole balance.
+* Collateral is valued at the protocol safe price (`min` of the two feeds,
+* 0 when there is no reserve), the way the facade values a call that hands
+* funds over; the underlying is exempt and is valued at the main feed, as
+* `CreditManagerV3._safeConvertToUSD` does. The debt is valued at the main
+* feed, as the check does. Zero debt frees the whole balance.
 *
 * Rounding always favours the account, so the answer clears the check rather
 * than landing a wei short of it.
@@ -31,13 +33,13 @@ function maxWithdrawCollateral(props) {
 	const underlying = market.pool.underlying;
 	const target = creditAccount.tokens.find((t) => require_onchain_accounts_intents_utils_common.eq(t.token, token));
 	if (!target || target.balance <= 10n) return 0n;
-	if (creditAccount.accountDebt === 0n) return target.balance;
+	if (creditAccount.totalDebt === 0n) return target.balance;
 	const masked = creditAccount.enabledTokensMask !== 0n;
 	const counts = (t) => t.balance > 10n && (!masked || (t.mask & creditAccount.enabledTokensMask) !== 0n);
 	/** What a holding backs, in the check's units: USD × PERCENTAGE_FACTOR. */
 	const weigh = (t) => {
 		const lt = BigInt(creditManager.liquidationThresholds.get(t.token) ?? 0);
-		const weighted = (safeUsd(priceOracle, t.token, t.balance) ?? 0n) * lt;
+		const weighted = (require_onchain_accounts_intents_utils_common.eq(t.token, underlying) ? usd(priceOracle, t.token, t.balance) ?? 0n : priceOracle.safeConvertMinUSD(t.token, t.balance).value) * lt;
 		if (t.quota === 0n) return weighted;
 		return require_onchain_utils_bigint_math.BigIntMath.min(quotaUsd(t) * require_onchain_constants_math.PERCENTAGE_FACTOR, weighted);
 	};
@@ -48,15 +50,15 @@ function maxWithdrawCollateral(props) {
 		if (require_onchain_accounts_intents_utils_common.eq(t.token, token) || !counts(t)) continue;
 		otherMoney += weigh(t);
 	}
-	const borrowed = usd(priceOracle, underlying, creditAccount.accountDebt);
+	const borrowed = usd(priceOracle, underlying, creditAccount.totalDebt);
 	if (borrowed === void 0 || borrowed <= 0n) return 0n;
 	const required = borrowed * targetHF;
 	if (required <= otherMoney) return target.balance;
 	const shortfall = required - otherMoney;
 	if (target.quota > 0n && quotaUsd(target) * 10000n < shortfall) return 0n;
 	const targetLt = BigInt(creditManager.liquidationThresholds.get(target.token) ?? 0);
-	const targetUsd = safeUsd(priceOracle, target.token, target.balance);
-	if (targetLt === 0n || !targetUsd) return 0n;
+	const targetUsd = require_onchain_accounts_intents_utils_common.eq(target.token, underlying) ? usd(priceOracle, target.token, target.balance) ?? 0n : priceOracle.safeConvertMinUSD(target.token, target.balance).value;
+	if (targetLt === 0n || targetUsd === 0n) return 0n;
 	const keptUsd = require_onchain_utils_bigint_math.BigIntMath.ceilDiv(shortfall, targetLt);
 	const kept = require_onchain_utils_bigint_math.BigIntMath.ceilDiv(target.balance * keptUsd, targetUsd);
 	return kept >= target.balance ? 0n : target.balance - kept;
@@ -69,18 +71,5 @@ function usd(oracle, token, amount) {
 		return;
 	}
 }
-/**
-* USD value at the lower of the token's two feeds — what a call handing funds
-* over is judged at. Falls back to the main feed where there is no second one.
-**/
-function safeUsd(oracle, token, amount) {
-	const main = usd(oracle, token, amount);
-	if (main === void 0) return;
-	try {
-		return require_onchain_utils_bigint_math.BigIntMath.min(main, oracle.convertToUSD(token, amount, true));
-	} catch {
-		return main;
-	}
-}
 //#endregion
 exports.maxWithdrawCollateral = maxWithdrawCollateral;