@gearbox-protocol/sdk 16.1.2 → 16.3.0-next.1

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 };

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

@@ -1,8 +1,11 @@
-import { IntentPreviewError } from "../../validation/refusal.js";
-import { toToken, toTokenAmount } from "../../validation/token.js";
+import { insufficientBalance } from "../../../model/errors/operation-errors.js";
+import { multipleDelayedWithdrawals, noDelayedRoute, withdrawalInProgress } 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, toTargetDecimals } from "./utils/common.js";
 import { isRedemptionPhantomToken } from "./utils/pick-token.js";
-import { assertCanBorrow, assertCollateralised, assertGrowthAllowed, assertQuotaHeadroom } from "./guards.js";
+import { assertCanBorrow, assertCollateralised, assertGrowthAllowed, assertQuotaAvailable } from "./guards.js";
 import { OperationLedger } from "./utils/ledger.js";
 import { collectPriceImpact } from "./utils/price-impact.js";
 import { clearedQuotas, getQuotasForUpdate, quotasAfterUpdate } from "./utils/quotas-for-update.js";
@@ -41,8 +44,8 @@ async function realize(steps, props) {
 	* The floor: every routed leg counted at the amount it guarantees. This is
 	* what the calls are built from — a repayment may only spend underlying the
 	* route promises to have raised — and what the guards are answered on, since
-	* a floor that does not clear the facade's bar is a transaction that can
-	* revert.
+	* a floor that does not clear the facade's threshold is a transaction that
+	* can revert.
 	*/
 	const ledger = new OperationLedger(start);
 	/**
@@ -77,14 +80,16 @@ async function realize(steps, props) {
 	* Whether anything leaves the account, which is what makes the credit manager
 	* judge the closing collateral check at safe prices.
 	*/
-	let paysOut = false;
+	let withdrawsCollateral = false;
 	const amountOf = (a) => typeof a === "bigint" ? a : min(raised, a.max ?? raised);
 	const assertHolds = (token, amount, what) => {
 		const held = ledger.balanceOf(token);
-		if (amount <= 0n || held < amount) throw new IntentPreviewError("insufficientSourceBalance", {
+		if (amount <= 0n || held < amount) throw new IntentPreviewError(insufficientBalance({
 			required: toTokenAmount(sdk, token, amount),
-			held: toTokenAmount(sdk, token, held)
-		}, `${what}: needs ${amount} of ${token}, account holds ${held}`);
+			held: toTokenAmount(sdk, token, held),
+			holderKind: "creditAccount",
+			holder: creditAccount.creditAccount
+		}), `${what}: needs ${amount} of ${token}, account holds ${held}`);
 	};
 	for (const step of steps) switch (step.kind) {
 		case "add":
@@ -173,7 +178,7 @@ async function realize(steps, props) {
 		case "closeAll": {
 			const balances = ledger.snapshot().assets.filter((a) => !eq(a.token, underlying) && a.balance > DUST);
 			const pending = balances.find((a) => isRedemptionPhantomToken(sdk, a.token));
-			if (pending) throw new IntentPreviewError("withdrawalInProgress", { inFlight: toTokenAmount(sdk, pending.token, pending.balance) }, `closeAll: ${pending.token} is a pending withdrawal, claim it first`);
+			if (pending) throw new IntentPreviewError(withdrawalInProgress(toTokenAmount(sdk, pending.token, pending.balance)), `closeAll: ${pending.token} is a pending withdrawal, claim it first`);
 			if (balances.length > 0) {
 				const leg = await paths.closeAll({ balances });
 				if (leg.probe) probes.push(leg.probe);
@@ -200,7 +205,7 @@ async function realize(steps, props) {
 		case "withdraw": {
 			const amount = amountOf(step.amount);
 			assertHolds(step.token, amount, "withdraw");
-			paysOut = true;
+			withdrawsCollateral = true;
 			push(buildWithdrawCollateralOperation({
 				token: step.token,
 				amount,
@@ -212,7 +217,7 @@ async function realize(steps, props) {
 		}
 		case "request": {
 			const asset = await delayedConfig(sdk, creditAccount, step.token);
-			if (ledger.balanceOf(asset.withdrawalPhantomToken) > 0n) throw new IntentPreviewError("withdrawalInProgress", { inFlight: toTokenAmount(sdk, asset.withdrawalPhantomToken, ledger.balanceOf(asset.withdrawalPhantomToken)) }, `request: ${asset.withdrawalPhantomToken} already holds a pending withdrawal`);
+			if (ledger.balanceOf(asset.withdrawalPhantomToken) > 0n) throw new IntentPreviewError(withdrawalInProgress(toTokenAmount(sdk, asset.withdrawalPhantomToken, ledger.balanceOf(asset.withdrawalPhantomToken))), `request: ${asset.withdrawalPhantomToken} already holds a pending withdrawal`);
 			assertHolds(step.token, step.amount + step.reserve, "request");
 			const preview = await sdk.accounts.previewDelayedWithdrawal({
 				creditAccount: creditAccount.creditAccount,
@@ -248,7 +253,7 @@ async function realize(steps, props) {
 			raised = instantOutput(step.claimable.outputs)?.amount ?? 0n;
 			break;
 		case "sweep": {
-			paysOut = true;
+			withdrawsCollateral = true;
 			const wrapped = ledger.balanceOf(underlying);
 			if (rwaAsset && wrapped > 0n) push(await buildUnwrapRwaCollateralOperation({
 				tokenIn: underlying,
@@ -259,7 +264,7 @@ async function realize(steps, props) {
 				sdk
 			}));
 			for (const { token, balance } of ledger.snapshot().assets) {
-				const payout = buildWithdrawCollateralOperation({
+				const withdrawal = buildWithdrawCollateralOperation({
 					token,
 					amount: balance,
 					to: step.to,
@@ -267,8 +272,8 @@ async function realize(steps, props) {
 					creditAccount,
 					sdk
 				});
-				push(payout, {
-					...payout,
+				push(withdrawal, {
+					...withdrawal,
 					amount: expected.balanceOf(token)
 				});
 			}
@@ -297,7 +302,7 @@ async function realize(steps, props) {
 		convert: price
 	});
 	if (!cleared && quotas.quotaIncrease.length + quotas.quotaDecrease.length > 0) {
-		assertQuotaHeadroom(sdk, market, quotas.quotaIncrease);
+		assertQuotaAvailable(sdk, market, quotas.quotaIncrease);
 		push(buildQuotaUpdateOperation({
 			update: quotas,
 			creditAccount,
@@ -318,7 +323,7 @@ async function realize(steps, props) {
 		...snapshot,
 		assets,
 		totalValue: floor.totalValue
-	}, { safePrices: paysOut }), paysOut);
+	}, { safePrices: withdrawsCollateral }), withdrawsCollateral);
 	const priceImpact = await collectPriceImpact(probes, {
 		totalValue: projected.totalValue,
 		netValue: projected.totalValue - debt,
@@ -347,13 +352,10 @@ async function realize(steps, props) {
 */
 async function delayedConfig(sdk, creditAccount, token) {
 	const compressor = sdk.withdrawalCompressor;
-	if (!compressor) throw new IntentPreviewError("noDelayedRoute", { token: toToken(sdk, token) }, "request: chain has no withdrawal compressor");
+	if (!compressor) throw new IntentPreviewError(noDelayedRoute(toToken(sdk, token)), "request: chain has no withdrawal compressor");
 	const assets = await compressor.findWithdrawableAssets(creditAccount.creditManager, token);
-	if (assets.length === 0) throw new IntentPreviewError("noDelayedRoute", { token: toToken(sdk, token) }, `request: ${token} has no delayed withdrawal config`);
-	if (assets.length > 1) throw new IntentPreviewError("multipleDelayedWithdrawals", {
-		token: toToken(sdk, token),
-		venues: assets.length
-	}, `request: ${token} has ${assets.length} delayed withdrawal configs`);
+	if (assets.length === 0) throw new IntentPreviewError(noDelayedRoute(toToken(sdk, token)), `request: ${token} has no delayed withdrawal config`);
+	if (assets.length > 1) throw new IntentPreviewError(multipleDelayedWithdrawals(toToken(sdk, token), assets.length), `request: ${token} has ${assets.length} delayed withdrawal configs`);
 	return assets[0];
 }
 const callsOf = (operations) => operations.flatMap((op) => op.calls);

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

@@ -1,5 +1,8 @@
-import { IntentPreviewError } from "../../validation/refusal.js";
-import { toTokenAmount } from "../../validation/token.js";
+import { insufficientBalance } from "../../../model/errors/operation-errors.js";
+import { noRecordedIntent } from "../../../model/errors/prepare-errors.js";
+import "../../../model/index.js";
+import { toTokenAmount } from "../../validation/helpers/token.js";
+import { IntentPreviewError } from "../../validation/raise.js";
 import { toTargetDecimals } from "./utils/common.js";
 import { createOraclePaths } from "./utils/router-path.js";
 import { planFinishClaimOnly, planFinishCloseAccount, planFinishDecreaseLeverage, planFinishWithdraw } from "./plan.js";
@@ -16,14 +19,14 @@ import { accountView } from "./view.js";
 * tail as it is projected the moment the request is made.
 *
 * A claim that brought only part of what was queued is served in proportion,
-* see {@link partialTail}: the intent's payout and its repayment are cut to the
+* see {@link partialTail}: the intent's withdrawal and its repayment are cut to the
 * share that arrived, and the rest of both is handed to the next claim.
 */
 function planTail(args) {
 	const { intent, claimable, view } = args;
 	const claimed = () => {
 		const output = instantOutput(claimable.outputs);
-		if (!output) throw new IntentPreviewError("insufficientSourceBalance", void 0, "finishIntent: the claim credits nothing to spend");
+		if (!output) throw new IntentPreviewError(insufficientBalance(), "finishIntent: the claim credits nothing to spend");
 		return output;
 	};
 	const queued = claimable.outputs.find((o) => o.isDelayed && o.amount > 0n);
@@ -51,12 +54,12 @@ const whole = (steps) => ({
 /**
 * The tail of a claim that settled only part of the withdrawal it matured.
 *
-* Only a legacy Mellow multivault answers one this way — it pays out what its
+* Only a legacy Mellow multivault answers one this way — it hands over what its
 * subvaults hold liquid and queues the rest — and the engine cannot finish an
 * intent it has been given a fraction of the funds for. So the fraction is what
-* it serves: the payout and the repayment are cut in the proportion that
+* it serves: the withdrawal and the repayment are cut in the proportion that
 * arrived, which keeps the withdrawal at the fixed leverage it was asked for
-* instead of paying the wallet out first and deleveraging a claim later, and
+* instead of paying the wallet first and deleveraging a claim later, and
 * the untouched half of each is carried to the next claim by the remainder.
 *
 * Two intents cannot be served in part at all. An exit sells the account whole,
@@ -123,7 +126,7 @@ function partialTail(args) {
 * How much of the redemption this claim was: what it credited, over that plus
 * what it left queued.
 *
-* The phantom stands for its payout one for one — the same reading the request
+* The phantom stands for its claim one for one — the same reading the request
 * side takes when it names the claim it expects — so only the decimals of the
 * two have to be reconciled before they can be added up.
 */
@@ -143,7 +146,7 @@ function part(amount, share) {
 *
 * A request is only half a withdrawal, so the state it lands in is not the
 * answer to "what does this do to my position": the debt is still there, the
-* payout has not been made, and the position sits in a phantom token. What the
+* withdrawal has not been made, and the position sits in a phantom token. What the
 * caller means is the far side — and that side can be walked now, because the
 * request already fixes the claim it will be finished from.
 *
@@ -160,7 +163,7 @@ async function projectTail(args) {
 	const { request, delayed, creditAccount, sdk, quotaReserve } = args;
 	const { claim } = delayed;
 	const queued = request.outputs.find((o) => o.isDelayed);
-	if (!queued || !claim) throw new IntentPreviewError("noRecordedIntent", void 0, "projectTail: the request queued nothing to claim");
+	if (!queued || !claim) throw new IntentPreviewError(noRecordedIntent(), "projectTail: the request queued nothing to claim");
 	const next = sliceAfter(creditAccount, delayed.afterRequest);
 	const { steps } = planTail({
 		intent: delayed.record,
@@ -184,7 +187,7 @@ async function projectTail(args) {
 }
 /**
 * The matured withdrawal the tail will be built from, as the request implies
-* it: the phantom it created is burned and the venue's payout takes its place.
+* it: the phantom it created is burned and the claim takes its place.
 * It carries no claim calls — those are read from the chain when the claim is
 * real, and nothing here is going to be sent.
 */

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

@@ -122,6 +122,7 @@ function buildMockSdk(args) {
 	const quotaOf = (token) => args.quotas[token.toLowerCase()] ?? args.quotas[token];
 	const quotas = {
 		values: () => Object.values(args.quotas).map(fullQuota),
+		has: (token) => quotaOf(token) !== void 0,
 		get: (token) => {
 			const q = quotaOf(token);
 			return q === void 0 ? void 0 : fullQuota(q);
@@ -158,6 +159,10 @@ function buildMockSdk(args) {
 				hasActiveQuota: (token) => {
 					const q = quotaOf(token);
 					return !!q?.isActive && q.limit > 0n;
+				},
+				quotaAvailable: (token) => {
+					const q = quotas.get(token);
+					return q === void 0 ? 0n : q.limit - q.totalQuoted;
 				}
 			},
 			pool: {
@@ -191,6 +196,8 @@ function buildMockSdk(args) {
 		liquidationFees: () => MOCK_LIQUIDATION_FEES,
 		totalLiquidationDiscount: CreditSuite.prototype.totalLiquidationDiscount,
 		creditOperationMarket: CreditSuite.prototype.creditOperationMarket,
+		isForbidden: CreditSuite.prototype.isForbidden,
+		maxBorrowAmount: CreditSuite.prototype.maxBorrowAmount,
 		creditManager: {
 			address: args.creditManager,
 			liquidationThresholds,

package/dist/esm/onchain/accounts/intents/tests/finish-withdraw.fixtures.js

@@ -109,11 +109,11 @@ const M4_LT = 9200n;
 const m4QuotaOf = (balance) => balance * M4_LT / 10000n;
 /** Matrix baseline debt: 8U. */
 const M4_DEBT = 800000000n;
-/** Matrix payout W: 1U. */
+/** Matrix withdrawal W: 1U. */
 const M4_W = 100000000n;
 /** Proportional repayment `dD = D0 * W / C0` = 4U. */
 const M4_DD = 400000000n;
-/** Payout plus repayment: 5U redeemed by the leading half. */
+/** Withdrawal plus repayment: 5U redeemed by the leading half. */
 const M4_SPEND = 500000000n;
 /** Quotable withdrawal phantom: `POS2`, 1:1 with `POS`. */
 const M4_PHANTOM = POS2;
@@ -153,10 +153,10 @@ function m4PhantomQuotaResetOp() {
 /**
 * Matrix 4.3 tail — the claim pays `UND` directly.
 *
-* MATRIX MISMATCH: the matrix pays out first — `claim →
+* MATRIX MISMATCH: the matrix withdraws first — `claim →
 * withdrawCollateral(min(W, claim.amount)) → decreaseDebt(rest) →
-* changeQuota`. The engine repays before paying out (`repay(debtRepaid,
-* keep: W)` precedes the payout leg in `planFinishWithdraw`):
+* changeQuota`. The engine repays before withdrawing (`repay(debtRepaid,
+* keep: W)` precedes the withdrawal leg in `planFinishWithdraw`):
 * `claim → decreaseDebt(dD) → withdrawCollateral(W) → changeQuota`.
 * Amounts are identical; only the order differs.
 */
@@ -216,7 +216,7 @@ const case_matrix_4_4_tail = {
 	]
 };
 /**
-* Matrix 4.5 tail — 4.3 on the RWA market: unwrap before the payout.
+* Matrix 4.5 tail — 4.3 on the RWA market: unwrap before the withdrawal.
 *
 * MATRIX MISMATCH: same ordering divergence as 4.3 — the matrix expects
 * `claim → unwrapRwaCollateral → withdrawCollateral(RWA) → decreaseDebt →

package/dist/esm/onchain/accounts/intents/tests/withdraw.fixtures.js

@@ -15,7 +15,7 @@ const LT = 9200n;
 const quotaOf = (balance) => balance * LT / 10000n;
 /** 100 UND of value leaving the account. */
 const W = 10000000000n;
-/** Payout plus proportional repayment. */
+/** Withdrawal plus proportional repayment. */
 const SPEND = 2n * W;
 const TVL_BEFORE = 200000000000n;
 const DEBT_BEFORE = 100000000000n;
@@ -49,7 +49,7 @@ const case_und_und = {
 		to: WALLET
 	}]
 };
-/** Row 2 — S = U, T = POS: repay, then route the payout out of the underlying. */
+/** Row 2 — S = U, T = POS: repay, then route the withdrawal out of the underlying. */
 const case_und_pos = {
 	...base,
 	intent: {
@@ -215,8 +215,8 @@ const case_pos_pos2 = {
 		}
 	]
 };
-/** RWA market: the underlying payout is force-unwrapped to the asset. */
-const case_rwa_payout = {
+/** RWA market: the underlying withdrawal is force-unwrapped to the asset. */
+const case_rwa_pos_und = {
 	...base,
 	intent: {
 		type: "WITHDRAW",
@@ -267,18 +267,18 @@ const case_rwa_payout = {
 /** Matrix baseline: 10A of position against 8U of debt (2U collateral at 5x). */
 const M4_BALANCE = 1000000000n;
 const M4_DEBT = 800000000n;
-/** Matrix payout W: 1U. */
+/** Matrix withdrawal W: 1U. */
 const M4_W = 100000000n;
 /** Proportional repayment `dD = D0 * W / C0` = 4U. */
 const M4_DD = 400000000n;
-/** Payout plus repayment: 5U liquidated in total. */
+/** Withdrawal plus repayment: 5U liquidated in total. */
 const M4_SPEND = 500000000n;
 /**
-* Matrix 4.1 — withdraw 1U, source `POS`, payout `UND`.
+* Matrix 4.1 — withdraw 1U, source `POS`, tokenOut `UND`.
 *
-* MATRIX MISMATCH: the matrix pays out first — `swap → withdrawCollateral →
-* decreaseDebt → changeQuota`. The engine repays before paying out
-* (`repay(dD, keep: W)` precedes the payout leg in `planWithdraw`):
+* MATRIX MISMATCH: the matrix withdraws first — `swap → withdrawCollateral →
+* decreaseDebt → changeQuota`. The engine repays before withdrawing
+* (`repay(dD, keep: W)` precedes the withdrawal leg in `planWithdraw`):
 * `swap → decreaseDebt → withdrawCollateral → changeQuota`. Amounts are
 * identical; only the order differs.
 */
@@ -325,7 +325,7 @@ const case_matrix_4_1 = {
 	]
 };
 /**
-* Matrix 4.2 — 4.1 on the RWA market: the payout is unwrapped on the way out.
+* Matrix 4.2 — 4.1 on the RWA market: the withdrawal is unwrapped on the way out.
 *
 * MATRIX MISMATCH: same ordering divergence as 4.1 — the matrix expects
 * `swap → unwrapRwaCollateral → withdrawCollateral(RWA) → decreaseDebt →
@@ -399,4 +399,4 @@ function buildWithdrawProps(c, sdk) {
 	};
 }
 //#endregion
-export { DEBT_AFTER, DEBT_BEFORE, M4_BALANCE, M4_DD, M4_DEBT, M4_SPEND, M4_W, QUOTA_AFTER, QUOTA_BEFORE, QUOTA_DELTA, SPEND, TVL_AFTER, TVL_BEFORE, W, buildWithdrawProps, buildWithdrawSdk, case_matrix_4_1, case_matrix_4_2, case_pos_pos, case_pos_pos2, case_pos_und, case_rwa_payout, case_und_pos, case_und_und };
+export { DEBT_AFTER, DEBT_BEFORE, M4_BALANCE, M4_DD, M4_DEBT, M4_SPEND, M4_W, QUOTA_AFTER, QUOTA_BEFORE, QUOTA_DELTA, SPEND, TVL_AFTER, TVL_BEFORE, W, buildWithdrawProps, buildWithdrawSdk, case_matrix_4_1, case_matrix_4_2, case_pos_pos, case_pos_pos2, case_pos_und, case_rwa_pos_und, case_und_pos, case_und_und };

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

@@ -21,7 +21,7 @@ function accountView(creditAccount, sdk) {
 		rwaAsset: sdk.tokensMeta.rwaUnderlyings.get(underlying)?.asset,
 		debt: creditAccount.totalDebt,
 		collateral: totalValue - creditAccount.totalDebt,
-		band: {
+		debtLimits: {
 			minDebt: creditFacade.minDebt,
 			maxDebt: creditFacade.maxDebt
 		},

package/dist/esm/onchain/accounts/withdrawal-compressor/index.js

@@ -8,5 +8,4 @@ import { WithdrawalCompressorV311Contract } from "./WithdrawalCompressorV311Cont
 import { toWithdrawalStatus } from "./types.js";
 import { WithdrawalCompressorV313Contract } from "./WithdrawalCompressorV313Contract.js";
 import { createWithdrawalCompressor } from "./createWithdrawalCompressor.js";
-import "./errors.js";
 export { AbstractWithdrawalCompressorContract, DELAYED_INTENT_TYPES, DELAYED_INTENT_VERSION, RedemptionLoggerV310Contract, WithdrawalCompressorV310Contract, WithdrawalCompressorV311Contract, WithdrawalCompressorV313Contract, createRedemptionLogger, createWithdrawalCompressor, decodeDelayedIntent, encodeDelayedIntent, getWithdrawalCompressorAddress, iCreditAccountAbi, toClaimableWithdrawal, toPendingWithdrawal, toRequestableWithdrawal, toWithdrawalStatus };