@gearbox-protocol/sdk 16.2.0 → 16.3.0-next.2

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

@@ -1,7 +1,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_onchain_base_SDKConstruct = require("../../base/SDKConstruct.js");
-const require_onchain_validation_checks = require("../../validation/checks.js");
-const require_onchain_validation_refusal = require("../../validation/refusal.js");
+const require_model_errors_prepare_errors = require("../../../model/errors/prepare-errors.js");
+const require_model_result = require("../../../model/result.js");
+require("../../../model/index.js");
+const require_onchain_validation_helpers_health_factor_limits = require("../../validation/helpers/health-factor-limits.js");
+const require_onchain_validation_raise = require("../../validation/raise.js");
+require("../../validation/index.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");
@@ -26,7 +30,7 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 	* Previews an operation on an existing account.
 	*
 	* @param props - Intent plus account slice, quota reserve and slippage
-	* @returns Operations, projected state and calldata, or `{ ok: false, reason }`
+	* @returns Operations, projected state and calldata, or `{ ok: false, error }`
 	* when the intent cannot be satisfied (e.g. the account lacks the source
 	* balance)
 	*/
@@ -47,8 +51,8 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 	}
 	/**
 	* 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
+	* partial withdrawal that keeps leverage and stays inside the facade's
+	* `debtLimits`, 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.
@@ -64,7 +68,7 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 	maxWithdraw(props) {
 		const view = require_onchain_accounts_intents_view.accountView(props.creditAccount, props.sdk);
 		return {
-			partial: require_onchain_accounts_intents_math.maxProportionalWithdrawal(view, view.band),
+			partial: require_onchain_accounts_intents_math.maxProportionalWithdrawal(view, view.debtLimits),
 			exit: view.collateral > 0n ? view.collateral : 0n
 		};
 	}
@@ -89,8 +93,8 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 	*
 	* 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.
+	* given deposit reaches is decided by the debt it implies and by the
+	* `debtLimits` 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
@@ -109,9 +113,9 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 	* 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.
+	* a call that withdraws collateral; zero debt frees the whole balance.
 	*
-	* The default is {@link MIN_HF_LIMITED}, the bar a form holds an
+	* The default is {@link MIN_HF_LIMITED}, the threshold a form holds an
 	* account to.
 	*
 	* @param props - Account slice, the SDK holding its market, the collateral
@@ -119,7 +123,7 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 	* @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;
+		const { targetHF = require_onchain_validation_helpers_health_factor_limits.MIN_HF_LIMITED, ...rest } = props;
 		return require_onchain_accounts_intents_maxWithdrawCollateral.maxWithdrawCollateral({
 			...rest,
 			targetHF: targetHF + 2n
@@ -131,8 +135,8 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 	*
 	* Sits apart from {@link startIntent} because it is a different trade route,
 	* not a different intent: the request goes to the issuer instead of the
-	* router, and the proceeds — hence the repayment and the payout — arrive days
-	* later. Both routes of one intent are quoted together by
+	* router, and what it sells for — hence the repayment and the withdrawal —
+	* arrives days later. Both routes of one intent are quoted together by
 	* {@link intentRoutes}; this is the one to call when the delayed route is the
 	* only one of interest.
 	*
@@ -144,7 +148,7 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 	*
 	* @param props - Intent plus account slice, quota reserve and slippage
 	* @returns The request transaction, the state it ends in and what it recorded
-	* for the tail, or `{ ok: false, reason }` — `noDelayedRoute` when this route
+	* for the tail, or `{ ok: false, error }` — `noDelayedRoute` when this route
 	* does not exist for the account at all
 	*/
 	async startDelayedIntent(props) {
@@ -180,7 +184,7 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 				delayed
 			};
 		} catch (e) {
-			return asFailure(e);
+			return asSDKError(e);
 		}
 	}
 	/**
@@ -190,7 +194,7 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 	* Which routes an account has depends on the intent and the token it sells,
 	* and a form has to know before it can offer a choice — so both are quoted
 	* from the same request and each is reported on its own. A route the account
-	* cannot take comes back `undefined` with its refusal in `refused`; only when
+	* cannot take comes back `undefined` with its error in `errors`; only when
 	* neither answers is the whole result `{ ok: false }`.
 	*
 	* A route that could not be quoted at all — a pathfinder with no path out of
@@ -200,31 +204,31 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 	*
 	* @param props - A withdraw or adjust-leverage intent plus account slice,
 	* quota reserve and slippage
-	* @returns Whichever routes are viable, or `{ ok: false, reason }` when none is
+	* @returns Whichever routes are viable, or `{ ok: false, error }` when none is
 	*/
 	async intentRoutes(props) {
 		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: instantRefusal?.reason,
-			delayed: delayedRefusal?.reason
+		const instantError = instant.status === "fulfilled" && !instant.value.ok ? instant.value.error : void 0;
+		const delayedError = delayed.status === "fulfilled" && !delayed.value.ok ? delayed.value.error : void 0;
+		const errors = {
+			...instantError === void 0 ? {} : { instant: instantError },
+			...delayedError === void 0 ? {} : { delayed: delayedError }
 		};
 		if (instantRoute || delayedRoute) return {
 			ok: true,
 			instant: instantRoute,
 			delayed: delayedRoute,
-			refused
+			errors
 		};
 		const failed = [instant, delayed].find((s) => s.status === "rejected");
 		if (failed?.status === "rejected") throw failed.reason;
-		const chosen = instantRefusal ?? delayedRefusal;
+		const chosen = instantError ?? delayedError;
 		if (chosen === void 0) throw new Error("intentRoutes: a route neither answered nor refused");
 		return {
-			...chosen,
-			refused
+			...require_model_result.sdkErr(chosen),
+			errors
 		};
 	}
 	/**
@@ -237,7 +241,7 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 	* 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
+	* multivault, which hands over 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.
 	*
@@ -276,7 +280,7 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 	*
 	* @param props - Credit manager, wallet collateral, target token and leverage
 	* @returns Debt, position size, projected balances and quotas for both the
-	* expected and the floor branch, or `{ ok: false, reason }` when the requested
+	* expected and the floor branch, or `{ ok: false, error }` when the requested
 	* leverage or the resulting debt is not viable
 	*/
 	async openStrategyIntent(props) {
@@ -286,7 +290,7 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 				state: await require_onchain_accounts_intents_open_strategy.buildOpenStrategyState(props)
 			};
 		} catch (e) {
-			return asFailure(e);
+			return asSDKError(e);
 		}
 	}
 	/** Plan → realise → wrap. Unviable requests become `{ ok: false }`. */
@@ -307,7 +311,7 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 				delayed
 			};
 		} catch (e) {
-			return asFailure(e);
+			return asSDKError(e);
 		}
 	}
 };
@@ -323,16 +327,16 @@ function plain(result) {
 	};
 }
 /** Unviable requests are values; anything else is a genuine failure. */
-function asFailure(e) {
-	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);
+function asSDKError(e) {
+	if (e instanceof require_onchain_validation_raise.IntentPreviewError) return require_model_result.sdkErr(e.error);
+	if (isUnroutable(e)) return require_model_result.sdkErr(require_model_errors_prepare_errors.unsupportedTokenPair());
 	throw e;
 }
 /**
 * How the pathfinder says there is no route: it reverts instead of answering
 * with an empty path, so viem raises a contract error where the rest of the
 * engine raises an {@link IntentPreviewError}. Nothing is wrong — the trade
-* asked for cannot be made, which is a refusal the caller can act on, and one
+* asked for cannot be made, which is an error the caller can act on, and one
 * `intentRoutes` in particular must keep as a value so the other route can
 * still be offered.
 */
@@ -342,7 +346,6 @@ function isUnroutable(e) {
 }
 //#endregion
 exports.CreditAccountOperationsService = CreditAccountOperationsService;
-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

@@ -8,7 +8,7 @@ const require_onchain_constants_math = require("../../constants/math.js");
 * 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 = netValue × (leverage − 1)` — and by the `debtLimits` the market puts that
 * debt in. This inverts that relation.
 *
 * Rounding is asymmetric because the forward direction truncates: the floor

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

@@ -1,9 +1,13 @@
 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_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_model_errors_operation_errors = require("../../../model/errors/operation-errors.js");
+require("../../../model/index.js");
+const require_onchain_validation_helpers_token = require("../../validation/helpers/token.js");
+const require_onchain_validation_checks_checkDebtLimits = require("../../validation/checks/checkDebtLimits.js");
+const require_onchain_validation_checks_checkLeverage = require("../../validation/checks/checkLeverage.js");
+const require_onchain_validation_raise = require("../../validation/raise.js");
+require("../../validation/index.js");
 //#region src/onchain/accounts/intents/math.ts
 /** Debt that realises `leverage` on `collateral`: `D = C · (L − 1)`. */
 function debtForLeverage(collateral, leverage) {
@@ -17,30 +21,30 @@ 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_validation_refusal.IntentPreviewError("insufficientSourceBalance", void 0, "cannot preserve leverage on an account with no collateral");
+	if (position.collateral <= 0n) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_operation_errors.insufficientBalance(), "cannot preserve leverage on an account with no collateral");
 	return position.debt * collateralDelta / position.collateral;
 }
 /**
 * Largest withdrawal (in underlying) that {@link proportionalDebt} can still
 * pay for: the repayment it implies leaves debt at or above `minDebt`, and
 * strictly less than the collateral goes — the last unit closes the account
-* rather than shrinks it. `0n` when the debt already sits below the band.
+* rather than shrinks it. `0n` when the debt already sits below `minDebt`.
 *
 * Solves `floor(D0 · W / C0) ≤ D0 − minDebt` for `W`.
 */
-function maxProportionalWithdrawal(position, band) {
+function maxProportionalWithdrawal(position, debtLimits) {
 	const { debt, collateral } = position;
 	if (collateral <= 0n) return 0n;
 	const allButLast = collateral - 1n;
 	if (debt === 0n) return allButLast;
-	const repayable = debt - band.minDebt;
+	const repayable = debt - debtLimits.minDebt;
 	if (repayable < 0n) return 0n;
 	const bound = require_onchain_utils_bigint_math.BigIntMath.ceilDiv(collateral * (repayable + 1n), debt) - 1n;
 	return bound < allButLast ? bound : allButLast;
 }
 /** Total leverage cannot drop below 1x — that would be negative debt. */
 function assertLeverageAtLeastOne(leverage) {
-	require_onchain_validation_refusal.raise(require_onchain_validation_checks.checkLeverageAtLeastOne({
+	require_onchain_validation_raise.raise(require_onchain_validation_checks_checkLeverage.checkLeverage({
 		leverage,
 		min: require_onchain_constants_math.LEVERAGE_DECIMALS
 	}), `target leverage ${leverage} is below 1x`);
@@ -49,17 +53,17 @@ function assertLeverageAtLeastOne(leverage) {
 * 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(sdk, debt, band, underlying) {
-	require_onchain_validation_refusal.raise(require_onchain_validation_checks.checkDebtInBand({
+function assertDebtLimits(sdk, debt, debtLimits, underlying) {
+	require_onchain_validation_raise.raise(require_onchain_validation_checks_checkDebtLimits.checkDebtLimits({
 		debt,
-		minDebt: band.minDebt,
-		maxDebt: band.maxDebt,
-		underlying: require_onchain_validation_token.toToken(sdk, underlying),
+		minDebt: debtLimits.minDebt,
+		maxDebt: debtLimits.maxDebt,
+		underlying: require_onchain_validation_helpers_token.toToken(sdk, underlying),
 		allowZero: true
-	}), debt > band.maxDebt ? `debt ${debt} exceeds maxDebt ${band.maxDebt}` : `debt ${debt} is below minDebt ${band.minDebt}`);
+	}), debt > debtLimits.maxDebt ? `debt ${debt} exceeds maxDebt ${debtLimits.maxDebt}` : `debt ${debt} is below minDebt ${debtLimits.minDebt}`);
 }
 //#endregion
-exports.assertDebtInBand = assertDebtInBand;
+exports.assertDebtLimits = assertDebtLimits;
 exports.assertLeverageAtLeastOne = assertLeverageAtLeastOne;
 exports.debtForLeverage = debtForLeverage;
 exports.maxProportionalWithdrawal = maxProportionalWithdrawal;

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

@@ -1,5 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_onchain_validation_refusal = require("../../validation/refusal.js");
+const require_model_errors_operation_errors = require("../../../model/errors/operation-errors.js");
+require("../../../model/index.js");
+const require_onchain_validation_raise = require("../../validation/raise.js");
 const require_onchain_accounts_intents_guards = require("./guards.js");
 const require_onchain_accounts_intents_math = require("./math.js");
 const require_onchain_accounts_intents_utils_price_impact = require("./utils/price-impact.js");
@@ -34,7 +36,7 @@ async function buildOpenStrategyState(props) {
 	const underlying = market.pool.underlying.toLowerCase();
 	const convert = (from, to, amount) => market.priceOracle.safeConvert(from, to, amount).value;
 	const margin = collateral.reduce((acc, a) => acc + convert(a.token, underlying, a.balance), 0n);
-	if (margin <= 0n) throw new require_onchain_validation_refusal.IntentPreviewError("insufficientSourceBalance", void 0, "openStrategy: collateral is worth nothing in underlying");
+	if (margin <= 0n) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_operation_errors.insufficientBalance(), "openStrategy: collateral is worth nothing in underlying");
 	const debt = require_onchain_accounts_intents_math.debtForLeverage(margin, leverage);
 	const account = existing ?? {
 		creditAccount: NO_ACCOUNT,
@@ -46,7 +48,7 @@ async function buildOpenStrategyState(props) {
 		totalDebt: 0n,
 		tokens: []
 	};
-	require_onchain_accounts_intents_math.assertDebtInBand(sdk, debt, suite.creditFacade, underlying);
+	require_onchain_accounts_intents_math.assertDebtLimits(sdk, debt, suite.creditFacade, underlying);
 	require_onchain_accounts_intents_guards.assertCanBorrow(sdk, suite, debt);
 	const paths = require_onchain_accounts_intents_utils_router_path.createRouterPaths({
 		sdk,
@@ -82,7 +84,7 @@ async function buildOpenStrategyState(props) {
 		before: [],
 		after: averageAssets
 	});
-	require_onchain_accounts_intents_guards.assertQuotaHeadroom(sdk, market, averageQuota);
+	require_onchain_accounts_intents_guards.assertQuotaAvailable(sdk, market, averageQuota);
 	const snapshot = {
 		creditManager,
 		assets: averageAssets,

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

@@ -1,8 +1,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_onchain_constants_math = require("../../constants/math.js");
 require("../../constants/index.js");
-const require_onchain_validation_refusal = require("../../validation/refusal.js");
-const require_onchain_validation_token = require("../../validation/token.js");
+const require_model_errors_operation_errors = require("../../../model/errors/operation-errors.js");
+const require_model_errors_prepare_errors = require("../../../model/errors/prepare-errors.js");
+require("../../../model/index.js");
+const require_onchain_validation_helpers_token = require("../../validation/helpers/token.js");
+const require_onchain_validation_raise = require("../../validation/raise.js");
 const require_onchain_accounts_intents_utils_common = require("./utils/common.js");
 const require_onchain_accounts_intents_math = require("./math.js");
 //#region src/onchain/accounts/intents/plan.ts
@@ -16,7 +19,7 @@ function planAddCollateral(intent) {
 /** Intent 4: one asset out at fixed debt. */
 function planWithdrawAsset(intent, view) {
 	assertPositive(intent.amount, "withdrawAsset");
-	return payout(view, intent.token, intent.amount, intent.to);
+	return withdraw(view, intent.token, intent.amount, intent.to);
 }
 /** Intent 6: collateral fixed, debt retargeted to `C0 · (L1 − 1)`. */
 function planAdjustLeverage(intent, view) {
@@ -25,21 +28,22 @@ function planAdjustLeverage(intent, view) {
 	const T = intent.token ?? positionToken(view, "adjustLeverage");
 	if (delta > 0n) return [borrow(delta), convert(U, T, delta)];
 	const shortfall = -delta - view.balanceOf(U);
-	if (shortfall > 0n && require_onchain_accounts_intents_utils_common.eq(T, U)) throw new require_onchain_validation_refusal.IntentPreviewError("insufficientSourceBalance", {
-		required: require_onchain_validation_token.toTokenAmount(view.sdk, U, -delta),
-		held: require_onchain_validation_token.toTokenAmount(view.sdk, U, view.balanceOf(U))
-	}, `adjustLeverage: needs ${-delta} underlying, account holds ${view.balanceOf(U)}`);
+	if (shortfall > 0n && require_onchain_accounts_intents_utils_common.eq(T, U)) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_operation_errors.insufficientBalance({
+		required: require_onchain_validation_helpers_token.toTokenAmount(view.sdk, U, -delta),
+		held: require_onchain_validation_helpers_token.toTokenAmount(view.sdk, U, view.balanceOf(U)),
+		holderKind: "creditAccount"
+	}), `adjustLeverage: needs ${-delta} underlying, account holds ${view.balanceOf(U)}`);
 	return [...shortfall > 0n ? [convert(T, U, view.price(U, T, shortfall))] : [], repay(-delta)];
 }
 /** Intents 1.1 / 1.2: collateral grows by `a`, debt grows to match. */
 function planDeposit(intent, view) {
 	assertPositive(intent.amount, "deposit");
 	const U = view.underlying;
-	if (!require_onchain_accounts_intents_utils_common.eq(intent.token, U) && !(view.rwaAsset && require_onchain_accounts_intents_utils_common.eq(intent.token, view.rwaAsset))) throw new require_onchain_validation_refusal.IntentPreviewError("unsupportedCollateralToken", { token: require_onchain_validation_token.toToken(view.sdk, intent.token) }, `deposit: only ${U}${view.rwaAsset ? ` or ${view.rwaAsset}` : ""} can be deposited, got ${intent.token}`);
+	if (!require_onchain_accounts_intents_utils_common.eq(intent.token, U) && !(view.rwaAsset && require_onchain_accounts_intents_utils_common.eq(intent.token, view.rwaAsset))) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_prepare_errors.unsupportedCollateralToken(require_onchain_validation_helpers_token.toToken(view.sdk, intent.token)), `deposit: only ${U}${view.rwaAsset ? ` or ${view.rwaAsset}` : ""} can be deposited, got ${intent.token}`);
 	const aU = view.price(intent.token, U, intent.amount);
 	const debtDelta = intent.targetLeverage === void 0 ? require_onchain_accounts_intents_math.proportionalDebt(view, aU) : require_onchain_accounts_intents_math.debtForLeverage(view.collateral + aU, intent.targetLeverage) - view.debt;
-	if (debtDelta < 0n) throw new require_onchain_validation_refusal.IntentPreviewError("leverageOutOfRange", void 0, `deposit: target leverage ${intent.targetLeverage} would require repaying debt`);
-	require_onchain_accounts_intents_math.assertDebtInBand(view.sdk, view.debt + debtDelta, view.band, U);
+	if (debtDelta < 0n) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_operation_errors.leverageOutOfRange(), `deposit: target leverage ${intent.targetLeverage} would require repaying debt`);
+	require_onchain_accounts_intents_math.assertDebtLimits(view.sdk, view.debt + debtDelta, view.debtLimits, U);
 	const T = intent.positionToken ?? positionToken(view, "deposit");
 	const depositStays = require_onchain_accounts_intents_utils_common.eq(intent.token, T);
 	return [
@@ -66,15 +70,15 @@ function planRepay(intent, view) {
 	assertPositive(intent.amount, "repay");
 	const U = view.underlying;
 	const fundsInU = require_onchain_accounts_intents_utils_common.eq(intent.token, U);
-	if (!fundsInU && !(view.rwaAsset && require_onchain_accounts_intents_utils_common.eq(intent.token, view.rwaAsset))) throw new require_onchain_validation_refusal.IntentPreviewError("unsupportedCollateralToken", { token: require_onchain_validation_token.toToken(view.sdk, intent.token) }, `repay: only ${U}${view.rwaAsset ? ` or ${view.rwaAsset}` : ""} can be repaid with, got ${intent.token}`);
-	if (view.debt <= 0n) throw new require_onchain_validation_refusal.IntentPreviewError("debtOutOfRange", {
-		requested: require_onchain_validation_token.toTokenAmount(view.sdk, U, view.debt),
-		minDebt: require_onchain_validation_token.toTokenAmount(view.sdk, U, view.band.minDebt),
-		maxDebt: require_onchain_validation_token.toTokenAmount(view.sdk, U, view.band.maxDebt)
-	}, "repay: the account owes nothing");
+	if (!fundsInU && !(view.rwaAsset && require_onchain_accounts_intents_utils_common.eq(intent.token, view.rwaAsset))) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_prepare_errors.unsupportedCollateralToken(require_onchain_validation_helpers_token.toToken(view.sdk, intent.token)), `repay: only ${U}${view.rwaAsset ? ` or ${view.rwaAsset}` : ""} can be repaid with, got ${intent.token}`);
+	if (view.debt <= 0n) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_operation_errors.debtOutOfRange({
+		requested: require_onchain_validation_helpers_token.toTokenAmount(view.sdk, U, view.debt),
+		minDebt: require_onchain_validation_helpers_token.toTokenAmount(view.sdk, U, view.debtLimits.minDebt),
+		maxDebt: require_onchain_validation_helpers_token.toTokenAmount(view.sdk, U, view.debtLimits.maxDebt)
+	}), "repay: the account owes nothing");
 	const funding = everything(intent.amount) ? view.price(U, intent.token, withMargin(view.debt)) : intent.amount;
 	const repaid = min(view.price(intent.token, U, funding), view.debt);
-	require_onchain_accounts_intents_math.assertDebtInBand(view.sdk, view.debt - repaid, view.band, view.underlying);
+	require_onchain_accounts_intents_math.assertDebtLimits(view.sdk, view.debt - repaid, view.debtLimits, view.underlying);
 	return [
 		add(intent.token, funding, intent.value),
 		...fundsInU ? [] : [convert(intent.token, U, funding)],
@@ -100,21 +104,21 @@ function planWithdraw(intent, view) {
 	if (require_onchain_accounts_intents_utils_common.eq(T, U)) return [
 		convert(S, U, view.price(U, S, WU + dD)),
 		repay(dD, intent.amount),
-		...payout(view, U, intent.amount, intent.to)
+		...withdraw(view, U, intent.amount, intent.to)
 	];
 	return [
 		convert(S, U, view.price(U, S, dD)),
 		repay(dD),
 		convert(S, T, view.price(U, S, WU)),
-		...payout(view, T, RAISED, intent.to)
+		...withdraw(view, T, RAISED, intent.to)
 	];
 }
 /**
 * Intent 2.1 against a source that cannot be sold on a DEX.
 *
 * Some collateral only converts through its issuer — a Securitize dsToken, a
-* Mellow share — which answers a redemption request now and pays out days
-* later. The trade is unchanged; what changes is that the proceeds do not exist
+* Mellow share — which answers a redemption request now and settles days
+* later. The trade is unchanged; what changes is that the money does not exist
 * yet, so this half only requests the redemption:
 *
 * ```
@@ -130,7 +134,7 @@ function planWithdrawDelayed(intent, view) {
 	const { U, T, S, WU, dD, all } = withdrawShape(intent, view);
 	if (all) {
 		const held = view.balanceOf(S);
-		if (held <= 0n) throw new require_onchain_validation_refusal.IntentPreviewError("insufficientSourceBalance", void 0, `withdraw: account holds no ${S} to redeem`);
+		if (held <= 0n) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_operation_errors.insufficientBalance(), `withdraw: account holds no ${S} to redeem`);
 		return [{
 			kind: "request",
 			token: S,
@@ -142,13 +146,13 @@ function planWithdrawDelayed(intent, view) {
 			}
 		}];
 	}
-	if (!require_onchain_accounts_intents_utils_common.eq(T, U) && !(view.rwaAsset && require_onchain_accounts_intents_utils_common.eq(T, view.rwaAsset))) throw new require_onchain_validation_refusal.IntentPreviewError("noDelayedRoute", { token: require_onchain_validation_token.toToken(view.sdk, T) }, `withdraw: a delayed route cannot pay out in ${T}`);
-	const payoutIsSource = require_onchain_accounts_intents_utils_common.eq(T, S);
+	if (!require_onchain_accounts_intents_utils_common.eq(T, U) && !(view.rwaAsset && require_onchain_accounts_intents_utils_common.eq(T, view.rwaAsset))) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_prepare_errors.noDelayedRoute(require_onchain_validation_helpers_token.toToken(view.sdk, T)), `withdraw: a delayed route cannot withdraw in ${T}`);
+	const tokenOutIsSource = require_onchain_accounts_intents_utils_common.eq(T, S);
 	return [{
 		kind: "request",
 		token: S,
-		amount: view.price(U, S, payoutIsSource ? dD : WU + dD),
-		reserve: payoutIsSource ? intent.amount : 0n,
+		amount: view.price(U, S, tokenOutIsSource ? dD : WU + dD),
+		reserve: tokenOutIsSource ? intent.amount : 0n,
 		record: {
 			type: "WITHDRAW_COLLATERAL",
 			to: intent.to,
@@ -168,9 +172,9 @@ function planWithdrawDelayed(intent, view) {
 */
 function planAdjustLeverageDelayed(intent, view) {
 	const { U, delta } = leverageShape(intent, view);
-	if (delta >= 0n) throw new require_onchain_validation_refusal.IntentPreviewError("noDelayedRoute", void 0, "adjustLeverage: only deleveraging can settle with a delay");
+	if (delta >= 0n) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_prepare_errors.noDelayedRoute(), "adjustLeverage: only deleveraging can settle with a delay");
 	const shortfall = -delta - view.balanceOf(U);
-	if (shortfall <= 0n) throw new require_onchain_validation_refusal.IntentPreviewError("noDelayedRoute", void 0, "adjustLeverage: idle underlying covers the repayment, nothing to redeem");
+	if (shortfall <= 0n) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_prepare_errors.noDelayedRoute(), "adjustLeverage: idle underlying covers the repayment, nothing to redeem");
 	const T = intent.token ?? positionToken(view, "adjustLeverage");
 	return [{
 		kind: "request",
@@ -189,20 +193,20 @@ function planFinishDecreaseLeverage(claimable, claimed, view) {
 	];
 }
 /**
-* The claim is split between the promised payout `W` and the debt the leading
-* half deferred: the payout is served first, the debt gets what is left, so a
-* routing shortfall shows as leverage a touch above target rather than as a
-* payout the wallet was promised and did not get.
+* The claim is split between the promised withdrawal `W` and the debt the
+* leading half deferred: `W` is served first, the debt gets what is left, so a
+* bad quote shows as leverage a touch above target rather than as a wallet paid
+* less than it was promised.
 */
 function planFinishWithdraw(intent, claimable, claimed, view) {
 	const U = view.underlying;
 	const T = intent.withdrawToken;
 	const W = intent.withdrawAmount;
-	if (!require_onchain_accounts_intents_utils_common.eq(T, U) && !(view.rwaAsset && require_onchain_accounts_intents_utils_common.eq(T, view.rwaAsset))) throw new require_onchain_validation_refusal.IntentPreviewError("noDelayedRoute", { token: require_onchain_validation_token.toToken(view.sdk, T) }, `finishWithdraw: cannot pay out in ${T}`);
+	if (!require_onchain_accounts_intents_utils_common.eq(T, U) && !(view.rwaAsset && require_onchain_accounts_intents_utils_common.eq(T, view.rwaAsset))) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_prepare_errors.noDelayedRoute(require_onchain_validation_helpers_token.toToken(view.sdk, T)), `finishWithdraw: cannot withdraw in ${T}`);
 	if (intent.debtRepaid === 0n) return [
 		claim(claimable),
 		convert(claimed.token, T, claimed.amount),
-		...payout(view, T, {
+		...withdraw(view, T, {
 			raised: true,
 			max: W
 		}, intent.to)
@@ -214,13 +218,13 @@ function planFinishWithdraw(intent, claimable, claimed, view) {
 			raised: true,
 			max: intent.debtRepaid
 		}),
-		...payout(view, T, W, intent.to)
+		...withdraw(view, T, W, intent.to)
 	];
 	if (require_onchain_accounts_intents_utils_common.eq(T, U)) return [
 		claim(claimable),
 		convert(claimed.token, U, claimed.amount),
 		repay(intent.debtRepaid, W),
-		...payout(view, U, {
+		...withdraw(view, U, {
 			raised: true,
 			max: W
 		}, intent.to)
@@ -234,7 +238,7 @@ function planFinishWithdraw(intent, claimable, claimed, view) {
 			max: intent.debtRepaid
 		}),
 		convert(claimed.token, T, reserved),
-		...payout(view, T, {
+		...withdraw(view, T, {
 			raised: true,
 			max: W
 		}, intent.to)
@@ -242,7 +246,7 @@ function planFinishWithdraw(intent, claimable, claimed, view) {
 }
 /**
 * The tail of an exit: the claim lands, everything the account holds is sold
-* into the underlying, the loan is settled out of the proceeds and the rest
+* into the underlying, the loan is settled out of what it sells for and the rest
 * goes to the wallet. The account survives it, empty and owing nothing.
 *
 * Nothing is quoted from the request — the same shape {@link planWithdraw}
@@ -268,7 +272,7 @@ function planFinishClaimOnly(claimable) {
 	return [claim(claimable)];
 }
 /**
-* What a withdrawal comes down to: the payout `W` of `T` priced in the
+* What a withdrawal comes down to: the withdrawal `W` of `T` priced in the
 * underlying, the debt `dD` that keeps leverage flat, and the source `S` both
 * are funded from. Shared so that the instant and the delayed leading half
 * cannot disagree on the amounts.
@@ -290,7 +294,7 @@ function withdrawShape(intent, view) {
 		};
 	}
 	const WU = view.price(T, U, intent.amount);
-	if (WU <= 0n) throw new require_onchain_validation_refusal.IntentPreviewError("insufficientSourceBalance", void 0, `withdraw: cannot price ${intent.amount} of ${T}`);
+	if (WU <= 0n) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_operation_errors.insufficientBalance(), `withdraw: cannot price ${intent.amount} of ${T}`);
 	if (WU >= view.collateral) {
 		assertHasValue(view);
 		return {
@@ -303,7 +307,7 @@ function withdrawShape(intent, view) {
 		};
 	}
 	const dD = require_onchain_accounts_intents_math.proportionalDebt(view, WU);
-	require_onchain_accounts_intents_math.assertDebtInBand(view.sdk, view.debt - dD, view.band, view.underlying);
+	require_onchain_accounts_intents_math.assertDebtLimits(view.sdk, view.debt - dD, view.debtLimits, view.underlying);
 	return {
 		U,
 		T,
@@ -320,9 +324,9 @@ function withdrawShape(intent, view) {
 */
 function leverageShape(intent, view) {
 	require_onchain_accounts_intents_math.assertLeverageAtLeastOne(intent.targetLeverage);
-	if (view.collateral <= 0n) throw new require_onchain_validation_refusal.IntentPreviewError("insufficientSourceBalance", void 0, "adjustLeverage: account has no collateral to lever");
+	if (view.collateral <= 0n) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_operation_errors.insufficientBalance(), "adjustLeverage: account has no collateral to lever");
 	const target = require_onchain_accounts_intents_math.debtForLeverage(view.collateral, intent.targetLeverage);
-	require_onchain_accounts_intents_math.assertDebtInBand(view.sdk, target, view.band, view.underlying);
+	require_onchain_accounts_intents_math.assertDebtLimits(view.sdk, target, view.debtLimits, view.underlying);
 	return {
 		U: view.underlying,
 		delta: target - view.debt
@@ -372,7 +376,7 @@ const min = (a, b) => a < b ? a : b;
 * Hands `amount` of `token` to `to`. The wrapped underlying of an RWA market
 * cannot leave the account, so it is unwrapped into the raw asset on the way.
 */
-function payout(view, token, amount, to) {
+function withdraw(view, token, amount, to) {
 	if (view.rwaAsset && require_onchain_accounts_intents_utils_common.eq(token, view.underlying)) return [convert(view.underlying, view.rwaAsset, amount), {
 		kind: "withdraw",
 		token: view.rwaAsset,
@@ -388,20 +392,20 @@ function payout(view, token, amount, to) {
 }
 function positionToken(view, flow) {
 	const pick = view.fattest([view.underlying]);
-	if (!pick) throw new require_onchain_validation_refusal.IntentPreviewError("insufficientSourceBalance", void 0, `${flow}: no position token on the account`);
+	if (!pick) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_operation_errors.insufficientBalance(), `${flow}: no position token on the account`);
 	return pick;
 }
 function sourceToken(view) {
 	const pick = view.fattest();
-	if (!pick) throw new require_onchain_validation_refusal.IntentPreviewError("insufficientSourceBalance", void 0, "withdraw: account has no spendable balance");
+	if (!pick) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_operation_errors.insufficientBalance(), "withdraw: account has no spendable balance");
 	return pick;
 }
 /** An account whose debt has eaten its collateral has nothing to hand over. */
 function assertHasValue(view) {
-	if (view.collateral <= 0n) throw new require_onchain_validation_refusal.IntentPreviewError("insufficientSourceBalance", void 0, `withdraw: nothing to withdraw, net value is ${view.collateral}`);
+	if (view.collateral <= 0n) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_operation_errors.insufficientBalance(), `withdraw: nothing to withdraw, net value is ${view.collateral}`);
 }
 function assertPositive(amount, flow) {
-	if (amount <= 0n) throw new require_onchain_validation_refusal.IntentPreviewError("insufficientSourceBalance", void 0, `${flow}: amount must be positive`);
+	if (amount <= 0n) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_operation_errors.insufficientBalance(), `${flow}: amount must be positive`);
 }
 //#endregion
 exports.RAISED = RAISED;