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

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

@@ -1,8 +1,12 @@
 import { SDKConstruct } from "../../base/SDKConstruct.js";
-import { MIN_HF_LIMITED } from "../../validation/checks.js";
-import { IntentPreviewError, refuse } from "../../validation/refusal.js";
+import { unsupportedTokenPair } from "../../../model/errors/prepare-errors.js";
+import { sdkErr } from "../../../model/result.js";
+import "../../../model/index.js";
+import { MIN_HF_LIMITED } from "../../validation/helpers/health-factor-limits.js";
+import { IntentPreviewError } from "../../validation/raise.js";
+import "../../validation/index.js";
 import { isPhantomToken } from "./utils/pick-token.js";
-import { assertMarketOperable, borrowable } from "./guards.js";
+import { assertMarketOperable } from "./guards.js";
 import { calcLeverageBand } from "./leverage-band.js";
 import { maxProportionalWithdrawal } from "./math.js";
 import { maxWithdrawCollateral } from "./maxWithdrawCollateral.js";
@@ -25,7 +29,7 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	* 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)
 	*/
@@ -46,8 +50,8 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	}
 	/**
 	* 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.
@@ -63,7 +67,7 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	maxWithdraw(props) {
 		const view = accountView(props.creditAccount, props.sdk);
 		return {
-			partial: maxProportionalWithdrawal(view, view.band),
+			partial: maxProportionalWithdrawal(view, view.debtLimits),
 			exit: view.collateral > 0n ? view.collateral : 0n
 		};
 	}
@@ -88,8 +92,8 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	*
 	* 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
@@ -108,9 +112,9 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	* 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
@@ -130,8 +134,8 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	*
 	* 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.
 	*
@@ -143,7 +147,7 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	*
 	* @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) {
@@ -179,7 +183,7 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 				delayed
 			};
 		} catch (e) {
-			return asFailure(e);
+			return asSDKError(e);
 		}
 	}
 	/**
@@ -189,7 +193,7 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	* 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
@@ -199,31 +203,31 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	*
 	* @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
+			...sdkErr(chosen),
+			errors
 		};
 	}
 	/**
@@ -236,7 +240,7 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	* 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.
 	*
@@ -275,7 +279,7 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	*
 	* @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) {
@@ -285,7 +289,7 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 				state: await buildOpenStrategyState(props)
 			};
 		} catch (e) {
-			return asFailure(e);
+			return asSDKError(e);
 		}
 	}
 	/** Plan → realise → wrap. Unviable requests become `{ ok: false }`. */
@@ -306,7 +310,7 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 				delayed
 			};
 		} catch (e) {
-			return asFailure(e);
+			return asSDKError(e);
 		}
 	}
 };
@@ -322,16 +326,16 @@ function plain(result) {
 	};
 }
 /** Unviable requests are values; anything else is a genuine failure. */
-function asFailure(e) {
-	if (e instanceof IntentPreviewError) return refuse(e.reason, e.detail);
-	if (isUnroutable(e)) return refuse("unsupportedTokenPair", void 0);
+function asSDKError(e) {
+	if (e instanceof IntentPreviewError) return sdkErr(e.error);
+	if (isUnroutable(e)) return sdkErr(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.
 */
@@ -340,4 +344,4 @@ function isUnroutable(e) {
 	return false;
 }
 //#endregion
-export { CreditAccountOperationsService, borrowable, fetchCreditAccountSlice, isPhantomToken, toCreditAccountSlice };
+export { CreditAccountOperationsService, fetchCreditAccountSlice, isPhantomToken, toCreditAccountSlice };

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

@@ -7,7 +7,7 @@ import { LEVERAGE_DECIMALS } from "../../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/esm/onchain/accounts/intents/math.js

@@ -1,8 +1,12 @@
 import { BigIntMath } from "../../utils/bigint-math.js";
 import { LEVERAGE_DECIMALS } from "../../constants/math.js";
-import { checkDebtInBand, checkLeverageAtLeastOne } from "../../validation/checks.js";
-import { IntentPreviewError, raise } from "../../validation/refusal.js";
-import { toToken } from "../../validation/token.js";
+import { insufficientBalance } from "../../../model/errors/operation-errors.js";
+import "../../../model/index.js";
+import { toToken } from "../../validation/helpers/token.js";
+import { checkDebtLimits } from "../../validation/checks/checkDebtLimits.js";
+import { checkLeverage } from "../../validation/checks/checkLeverage.js";
+import { IntentPreviewError, raise } from "../../validation/raise.js";
+import "../../validation/index.js";
 //#region src/onchain/accounts/intents/math.ts
 /** Debt that realises `leverage` on `collateral`: `D = C · (L − 1)`. */
 function debtForLeverage(collateral, leverage) {
@@ -16,30 +20,30 @@ 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", void 0, "cannot preserve leverage on an account with no collateral");
+	if (position.collateral <= 0n) throw new IntentPreviewError(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 = 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) {
-	raise(checkLeverageAtLeastOne({
+	raise(checkLeverage({
 		leverage,
 		min: LEVERAGE_DECIMALS
 	}), `target leverage ${leverage} is below 1x`);
@@ -48,14 +52,14 @@ 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) {
-	raise(checkDebtInBand({
+function assertDebtLimits(sdk, debt, debtLimits, underlying) {
+	raise(checkDebtLimits({
 		debt,
-		minDebt: band.minDebt,
-		maxDebt: band.maxDebt,
+		minDebt: debtLimits.minDebt,
+		maxDebt: debtLimits.maxDebt,
 		underlying: 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
-export { assertDebtInBand, assertLeverageAtLeastOne, debtForLeverage, maxProportionalWithdrawal, proportionalDebt };
+export { assertDebtLimits, assertLeverageAtLeastOne, debtForLeverage, maxProportionalWithdrawal, proportionalDebt };

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

@@ -1,6 +1,8 @@
-import { IntentPreviewError } from "../../validation/refusal.js";
-import { assertCanBorrow, assertCollateralised, assertGrowthAllowed, assertMarketOperable, assertQuotaHeadroom } from "./guards.js";
-import { assertDebtInBand, assertLeverageAtLeastOne, debtForLeverage } from "./math.js";
+import { insufficientBalance } from "../../../model/errors/operation-errors.js";
+import "../../../model/index.js";
+import { IntentPreviewError } from "../../validation/raise.js";
+import { assertCanBorrow, assertCollateralised, assertGrowthAllowed, assertMarketOperable, assertQuotaAvailable } from "./guards.js";
+import { assertDebtLimits, assertLeverageAtLeastOne, debtForLeverage } from "./math.js";
 import { collectPriceImpact } from "./utils/price-impact.js";
 import { getQuotasForUpdate } from "./utils/quotas-for-update.js";
 import { createRouterPaths } from "./utils/router-path.js";
@@ -33,7 +35,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 IntentPreviewError("insufficientSourceBalance", void 0, "openStrategy: collateral is worth nothing in underlying");
+	if (margin <= 0n) throw new IntentPreviewError(insufficientBalance(), "openStrategy: collateral is worth nothing in underlying");
 	const debt = debtForLeverage(margin, leverage);
 	const account = existing ?? {
 		creditAccount: NO_ACCOUNT,
@@ -45,7 +47,7 @@ async function buildOpenStrategyState(props) {
 		totalDebt: 0n,
 		tokens: []
 	};
-	assertDebtInBand(sdk, debt, suite.creditFacade, underlying);
+	assertDebtLimits(sdk, debt, suite.creditFacade, underlying);
 	assertCanBorrow(sdk, suite, debt);
 	const paths = createRouterPaths({
 		sdk,
@@ -81,7 +83,7 @@ async function buildOpenStrategyState(props) {
 		before: [],
 		after: averageAssets
 	});
-	assertQuotaHeadroom(sdk, market, averageQuota);
+	assertQuotaAvailable(sdk, market, averageQuota);
 	const snapshot = {
 		creditManager,
 		assets: averageAssets,

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

@@ -1,9 +1,12 @@
 import { MAX_UINT256, PERCENTAGE_FACTOR } from "../../constants/math.js";
 import "../../constants/index.js";
-import { IntentPreviewError } from "../../validation/refusal.js";
-import { toToken, toTokenAmount } from "../../validation/token.js";
+import { debtOutOfRange, insufficientBalance, leverageOutOfRange } from "../../../model/errors/operation-errors.js";
+import { noDelayedRoute, unsupportedCollateralToken } from "../../../model/errors/prepare-errors.js";
+import "../../../model/index.js";
+import { toToken, toTokenAmount } from "../../validation/helpers/token.js";
+import { IntentPreviewError } from "../../validation/raise.js";
 import { eq } from "./utils/common.js";
-import { assertDebtInBand, assertLeverageAtLeastOne, debtForLeverage, proportionalDebt } from "./math.js";
+import { assertDebtLimits, assertLeverageAtLeastOne, debtForLeverage, proportionalDebt } from "./math.js";
 //#region src/onchain/accounts/intents/plan.ts
 /** Whatever the previous convert produced. */
 const RAISED = { raised: true };
@@ -15,7 +18,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) {
@@ -24,21 +27,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 && eq(T, U)) throw new IntentPreviewError("insufficientSourceBalance", {
+	if (shortfall > 0n && eq(T, U)) throw new IntentPreviewError(insufficientBalance({
 		required: toTokenAmount(view.sdk, U, -delta),
-		held: toTokenAmount(view.sdk, U, view.balanceOf(U))
-	}, `adjustLeverage: needs ${-delta} underlying, account holds ${view.balanceOf(U)}`);
+		held: 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 (!eq(intent.token, U) && !(view.rwaAsset && eq(intent.token, view.rwaAsset))) throw new IntentPreviewError("unsupportedCollateralToken", { token: toToken(view.sdk, intent.token) }, `deposit: only ${U}${view.rwaAsset ? ` or ${view.rwaAsset}` : ""} can be deposited, got ${intent.token}`);
+	if (!eq(intent.token, U) && !(view.rwaAsset && eq(intent.token, view.rwaAsset))) throw new IntentPreviewError(unsupportedCollateralToken(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 ? proportionalDebt(view, aU) : debtForLeverage(view.collateral + aU, intent.targetLeverage) - view.debt;
-	if (debtDelta < 0n) throw new IntentPreviewError("leverageOutOfRange", void 0, `deposit: target leverage ${intent.targetLeverage} would require repaying debt`);
-	assertDebtInBand(view.sdk, view.debt + debtDelta, view.band, U);
+	if (debtDelta < 0n) throw new IntentPreviewError(leverageOutOfRange(), `deposit: target leverage ${intent.targetLeverage} would require repaying debt`);
+	assertDebtLimits(view.sdk, view.debt + debtDelta, view.debtLimits, U);
 	const T = intent.positionToken ?? positionToken(view, "deposit");
 	const depositStays = eq(intent.token, T);
 	return [
@@ -65,15 +69,15 @@ function planRepay(intent, view) {
 	assertPositive(intent.amount, "repay");
 	const U = view.underlying;
 	const fundsInU = eq(intent.token, U);
-	if (!fundsInU && !(view.rwaAsset && eq(intent.token, view.rwaAsset))) throw new IntentPreviewError("unsupportedCollateralToken", { 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 IntentPreviewError("debtOutOfRange", {
+	if (!fundsInU && !(view.rwaAsset && eq(intent.token, view.rwaAsset))) throw new IntentPreviewError(unsupportedCollateralToken(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 IntentPreviewError(debtOutOfRange({
 		requested: toTokenAmount(view.sdk, U, view.debt),
-		minDebt: toTokenAmount(view.sdk, U, view.band.minDebt),
-		maxDebt: toTokenAmount(view.sdk, U, view.band.maxDebt)
-	}, "repay: the account owes nothing");
+		minDebt: toTokenAmount(view.sdk, U, view.debtLimits.minDebt),
+		maxDebt: 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);
-	assertDebtInBand(view.sdk, view.debt - repaid, view.band, view.underlying);
+	assertDebtLimits(view.sdk, view.debt - repaid, view.debtLimits, view.underlying);
 	return [
 		add(intent.token, funding, intent.value),
 		...fundsInU ? [] : [convert(intent.token, U, funding)],
@@ -99,21 +103,21 @@ function planWithdraw(intent, view) {
 	if (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:
 *
 * ```
@@ -129,7 +133,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 IntentPreviewError("insufficientSourceBalance", void 0, `withdraw: account holds no ${S} to redeem`);
+		if (held <= 0n) throw new IntentPreviewError(insufficientBalance(), `withdraw: account holds no ${S} to redeem`);
 		return [{
 			kind: "request",
 			token: S,
@@ -141,13 +145,13 @@ function planWithdrawDelayed(intent, view) {
 			}
 		}];
 	}
-	if (!eq(T, U) && !(view.rwaAsset && eq(T, view.rwaAsset))) throw new IntentPreviewError("noDelayedRoute", { token: toToken(view.sdk, T) }, `withdraw: a delayed route cannot pay out in ${T}`);
-	const payoutIsSource = eq(T, S);
+	if (!eq(T, U) && !(view.rwaAsset && eq(T, view.rwaAsset))) throw new IntentPreviewError(noDelayedRoute(toToken(view.sdk, T)), `withdraw: a delayed route cannot withdraw in ${T}`);
+	const tokenOutIsSource = 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,
@@ -167,9 +171,9 @@ function planWithdrawDelayed(intent, view) {
 */
 function planAdjustLeverageDelayed(intent, view) {
 	const { U, delta } = leverageShape(intent, view);
-	if (delta >= 0n) throw new IntentPreviewError("noDelayedRoute", void 0, "adjustLeverage: only deleveraging can settle with a delay");
+	if (delta >= 0n) throw new IntentPreviewError(noDelayedRoute(), "adjustLeverage: only deleveraging can settle with a delay");
 	const shortfall = -delta - view.balanceOf(U);
-	if (shortfall <= 0n) throw new IntentPreviewError("noDelayedRoute", void 0, "adjustLeverage: idle underlying covers the repayment, nothing to redeem");
+	if (shortfall <= 0n) throw new IntentPreviewError(noDelayedRoute(), "adjustLeverage: idle underlying covers the repayment, nothing to redeem");
 	const T = intent.token ?? positionToken(view, "adjustLeverage");
 	return [{
 		kind: "request",
@@ -188,20 +192,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 (!eq(T, U) && !(view.rwaAsset && eq(T, view.rwaAsset))) throw new IntentPreviewError("noDelayedRoute", { token: toToken(view.sdk, T) }, `finishWithdraw: cannot pay out in ${T}`);
+	if (!eq(T, U) && !(view.rwaAsset && eq(T, view.rwaAsset))) throw new IntentPreviewError(noDelayedRoute(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)
@@ -213,13 +217,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 (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)
@@ -233,7 +237,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)
@@ -241,7 +245,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}
@@ -267,7 +271,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.
@@ -289,7 +293,7 @@ function withdrawShape(intent, view) {
 		};
 	}
 	const WU = view.price(T, U, intent.amount);
-	if (WU <= 0n) throw new IntentPreviewError("insufficientSourceBalance", void 0, `withdraw: cannot price ${intent.amount} of ${T}`);
+	if (WU <= 0n) throw new IntentPreviewError(insufficientBalance(), `withdraw: cannot price ${intent.amount} of ${T}`);
 	if (WU >= view.collateral) {
 		assertHasValue(view);
 		return {
@@ -302,7 +306,7 @@ function withdrawShape(intent, view) {
 		};
 	}
 	const dD = proportionalDebt(view, WU);
-	assertDebtInBand(view.sdk, view.debt - dD, view.band, view.underlying);
+	assertDebtLimits(view.sdk, view.debt - dD, view.debtLimits, view.underlying);
 	return {
 		U,
 		T,
@@ -319,9 +323,9 @@ function withdrawShape(intent, view) {
 */
 function leverageShape(intent, view) {
 	assertLeverageAtLeastOne(intent.targetLeverage);
-	if (view.collateral <= 0n) throw new IntentPreviewError("insufficientSourceBalance", void 0, "adjustLeverage: account has no collateral to lever");
+	if (view.collateral <= 0n) throw new IntentPreviewError(insufficientBalance(), "adjustLeverage: account has no collateral to lever");
 	const target = debtForLeverage(view.collateral, intent.targetLeverage);
-	assertDebtInBand(view.sdk, target, view.band, view.underlying);
+	assertDebtLimits(view.sdk, target, view.debtLimits, view.underlying);
 	return {
 		U: view.underlying,
 		delta: target - view.debt
@@ -371,7 +375,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 && eq(token, view.underlying)) return [convert(view.underlying, view.rwaAsset, amount), {
 		kind: "withdraw",
 		token: view.rwaAsset,
@@ -387,20 +391,20 @@ function payout(view, token, amount, to) {
 }
 function positionToken(view, flow) {
 	const pick = view.fattest([view.underlying]);
-	if (!pick) throw new IntentPreviewError("insufficientSourceBalance", void 0, `${flow}: no position token on the account`);
+	if (!pick) throw new IntentPreviewError(insufficientBalance(), `${flow}: no position token on the account`);
 	return pick;
 }
 function sourceToken(view) {
 	const pick = view.fattest();
-	if (!pick) throw new IntentPreviewError("insufficientSourceBalance", void 0, "withdraw: account has no spendable balance");
+	if (!pick) throw new IntentPreviewError(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 IntentPreviewError("insufficientSourceBalance", void 0, `withdraw: nothing to withdraw, net value is ${view.collateral}`);
+	if (view.collateral <= 0n) throw new IntentPreviewError(insufficientBalance(), `withdraw: nothing to withdraw, net value is ${view.collateral}`);
 }
 function assertPositive(amount, flow) {
-	if (amount <= 0n) throw new IntentPreviewError("insufficientSourceBalance", void 0, `${flow}: amount must be positive`);
+	if (amount <= 0n) throw new IntentPreviewError(insufficientBalance(), `${flow}: amount must be positive`);
 }
 //#endregion
 export { RAISED, planAddCollateral, planAdjustLeverage, planAdjustLeverageDelayed, planDeposit, planFinishClaimOnly, planFinishCloseAccount, planFinishDecreaseLeverage, planFinishWithdraw, planRepay, planWithdraw, planWithdrawAsset, planWithdrawDelayed };