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

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");
@@ -7,7 +9,10 @@ const require_onchain_accounts_intents_utils_quotas_for_update = require("./util
 const require_onchain_accounts_intents_utils_router_path = require("./utils/router-path.js");
 require("./utils/index.js");
 //#region src/onchain/accounts/intents/open-strategy.ts
-/** Stand-in account address: nothing exists on chain until the tx lands. */
+/**
+* Stand-in account address, used when the opening creates its own account:
+* nothing exists on chain until the tx lands.
+*/
 const NO_ACCOUNT = "0x0000000000000000000000000000000000000000";
 /**
 * Builds the state opening a leveraged position out of wallet collateral would
@@ -22,7 +27,8 @@ const NO_ACCOUNT = "0x0000000000000000000000000000000000000000";
 * `sdk.accounts.openCA`.
 */
 async function buildOpenStrategyState(props) {
-	const { sdk, creditManager, collateral, targetToken, leverage, slippage = 0, quotaReserve, leftoverBalances = [] } = props;
+	if (props.empty) return emptyOpenState(props);
+	const { sdk, creditManager, collateral, targetToken, leverage, slippage = 0, quotaReserve, leftoverBalances = [], creditAccount: existing } = props;
 	require_onchain_accounts_intents_math.assertLeverageAtLeastOne(leverage);
 	const suite = sdk.marketRegister.findCreditManager(creditManager);
 	const market = sdk.marketRegister.findByCreditManager(creditManager);
@@ -30,9 +36,9 @@ 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 = {
+	const account = existing ?? {
 		creditAccount: NO_ACCOUNT,
 		creditManager: creditManager.toLowerCase(),
 		creditFacade: suite.creditFacade.address.toLowerCase(),
@@ -42,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,
@@ -78,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,
@@ -101,7 +107,37 @@ async function buildOpenStrategyState(props) {
 		minAssets: minAssets.map(priced),
 		averageQuota,
 		minQuota,
-		calls: [...leg.calls]
+		calls: [...leg.calls],
+		creditAccount: existing?.creditAccount
+	};
+}
+/**
+* The opening that holds an account and nothing else.
+*
+* Taken before the walk rather than threaded through it: the router has no
+* guard for an empty basket and would still make its `eth_call`, and every
+* assertion below reads amounts that are not there.
+*/
+async function emptyOpenState(props) {
+	const { sdk, creditManager } = props;
+	require_onchain_accounts_intents_guards.assertMarketOperable(sdk.marketRegister.findCreditManager(creditManager));
+	const snapshot = {
+		creditManager,
+		assets: [],
+		quotas: [],
+		totalDebt: 0n,
+		totalValue: 0n
+	};
+	const { assets: _assets, quotas: _quotas, ...projection } = sdk.positions.projection(snapshot, { availableLiquidityChange: 0n });
+	return {
+		...projection,
+		currentPrice: sdk.positions.currentPrice(snapshot),
+		priceImpact: void 0,
+		averageAssets: [],
+		minAssets: [],
+		averageQuota: [],
+		minQuota: [],
+		calls: []
 	};
 }
 /** Collateral plus the borrowed underlying, folded into one balance per token. */

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;

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

@@ -1,6 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-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_utils_pick_token = require("./utils/pick-token.js");
 const require_onchain_accounts_intents_guards = require("./guards.js");
@@ -42,8 +45,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 require_onchain_accounts_intents_utils_ledger.OperationLedger(start);
 	/**
@@ -78,14 +81,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 require_onchain_validation_refusal.IntentPreviewError("insufficientSourceBalance", {
-			required: require_onchain_validation_token.toTokenAmount(sdk, token, amount),
-			held: require_onchain_validation_token.toTokenAmount(sdk, token, held)
-		}, `${what}: needs ${amount} of ${token}, account holds ${held}`);
+		if (amount <= 0n || held < amount) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_operation_errors.insufficientBalance({
+			required: require_onchain_validation_helpers_token.toTokenAmount(sdk, token, amount),
+			held: require_onchain_validation_helpers_token.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":
@@ -174,7 +179,7 @@ async function realize(steps, props) {
 		case "closeAll": {
 			const balances = ledger.snapshot().assets.filter((a) => !require_onchain_accounts_intents_utils_common.eq(a.token, underlying) && a.balance > DUST);
 			const pending = balances.find((a) => require_onchain_accounts_intents_utils_pick_token.isRedemptionPhantomToken(sdk, a.token));
-			if (pending) throw new require_onchain_validation_refusal.IntentPreviewError("withdrawalInProgress", { inFlight: require_onchain_validation_token.toTokenAmount(sdk, pending.token, pending.balance) }, `closeAll: ${pending.token} is a pending withdrawal, claim it first`);
+			if (pending) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_prepare_errors.withdrawalInProgress(require_onchain_validation_helpers_token.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);
@@ -201,7 +206,7 @@ async function realize(steps, props) {
 		case "withdraw": {
 			const amount = amountOf(step.amount);
 			assertHolds(step.token, amount, "withdraw");
-			paysOut = true;
+			withdrawsCollateral = true;
 			push(require_onchain_accounts_intents_operations.buildWithdrawCollateralOperation({
 				token: step.token,
 				amount,
@@ -213,7 +218,7 @@ async function realize(steps, props) {
 		}
 		case "request": {
 			const asset = await delayedConfig(sdk, creditAccount, step.token);
-			if (ledger.balanceOf(asset.withdrawalPhantomToken) > 0n) throw new require_onchain_validation_refusal.IntentPreviewError("withdrawalInProgress", { inFlight: require_onchain_validation_token.toTokenAmount(sdk, asset.withdrawalPhantomToken, ledger.balanceOf(asset.withdrawalPhantomToken)) }, `request: ${asset.withdrawalPhantomToken} already holds a pending withdrawal`);
+			if (ledger.balanceOf(asset.withdrawalPhantomToken) > 0n) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_prepare_errors.withdrawalInProgress(require_onchain_validation_helpers_token.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,
@@ -249,7 +254,7 @@ async function realize(steps, props) {
 			raised = require_onchain_accounts_intents_operations.instantOutput(step.claimable.outputs)?.amount ?? 0n;
 			break;
 		case "sweep": {
-			paysOut = true;
+			withdrawsCollateral = true;
 			const wrapped = ledger.balanceOf(underlying);
 			if (rwaAsset && wrapped > 0n) push(await require_onchain_accounts_intents_operations.buildUnwrapRwaCollateralOperation({
 				tokenIn: underlying,
@@ -260,7 +265,7 @@ async function realize(steps, props) {
 				sdk
 			}));
 			for (const { token, balance } of ledger.snapshot().assets) {
-				const payout = require_onchain_accounts_intents_operations.buildWithdrawCollateralOperation({
+				const withdrawal = require_onchain_accounts_intents_operations.buildWithdrawCollateralOperation({
 					token,
 					amount: balance,
 					to: step.to,
@@ -268,8 +273,8 @@ async function realize(steps, props) {
 					creditAccount,
 					sdk
 				});
-				push(payout, {
-					...payout,
+				push(withdrawal, {
+					...withdrawal,
 					amount: expected.balanceOf(token)
 				});
 			}
@@ -298,7 +303,7 @@ async function realize(steps, props) {
 		convert: price
 	});
 	if (!cleared && quotas.quotaIncrease.length + quotas.quotaDecrease.length > 0) {
-		require_onchain_accounts_intents_guards.assertQuotaHeadroom(sdk, market, quotas.quotaIncrease);
+		require_onchain_accounts_intents_guards.assertQuotaAvailable(sdk, market, quotas.quotaIncrease);
 		push(require_onchain_accounts_intents_operations.buildQuotaUpdateOperation({
 			update: quotas,
 			creditAccount,
@@ -319,7 +324,7 @@ async function realize(steps, props) {
 		...snapshot,
 		assets,
 		totalValue: floor.totalValue
-	}, { safePrices: paysOut }), paysOut);
+	}, { safePrices: withdrawsCollateral }), withdrawsCollateral);
 	const priceImpact = await require_onchain_accounts_intents_utils_price_impact.collectPriceImpact(probes, {
 		totalValue: projected.totalValue,
 		netValue: projected.totalValue - debt,
@@ -348,13 +353,10 @@ async function realize(steps, props) {
 */
 async function delayedConfig(sdk, creditAccount, token) {
 	const compressor = sdk.withdrawalCompressor;
-	if (!compressor) throw new require_onchain_validation_refusal.IntentPreviewError("noDelayedRoute", { token: require_onchain_validation_token.toToken(sdk, token) }, "request: chain has no withdrawal compressor");
+	if (!compressor) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_prepare_errors.noDelayedRoute(require_onchain_validation_helpers_token.toToken(sdk, token)), "request: chain has no withdrawal compressor");
 	const assets = await compressor.findWithdrawableAssets(creditAccount.creditManager, token);
-	if (assets.length === 0) throw new require_onchain_validation_refusal.IntentPreviewError("noDelayedRoute", { token: require_onchain_validation_token.toToken(sdk, token) }, `request: ${token} has no delayed withdrawal config`);
-	if (assets.length > 1) throw new require_onchain_validation_refusal.IntentPreviewError("multipleDelayedWithdrawals", {
-		token: require_onchain_validation_token.toToken(sdk, token),
-		venues: assets.length
-	}, `request: ${token} has ${assets.length} delayed withdrawal configs`);
+	if (assets.length === 0) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_prepare_errors.noDelayedRoute(require_onchain_validation_helpers_token.toToken(sdk, token)), `request: ${token} has no delayed withdrawal config`);
+	if (assets.length > 1) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_prepare_errors.multipleDelayedWithdrawals(require_onchain_validation_helpers_token.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/cjs/onchain/accounts/intents/tail.js

@@ -1,6 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-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_utils_router_path = require("./utils/router-path.js");
 const require_onchain_accounts_intents_plan = require("./plan.js");
@@ -17,14 +20,14 @@ const require_onchain_accounts_intents_view = require("./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 = require_onchain_accounts_intents_operations.instantOutput(claimable.outputs);
-		if (!output) throw new require_onchain_validation_refusal.IntentPreviewError("insufficientSourceBalance", void 0, "finishIntent: the claim credits nothing to spend");
+		if (!output) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_operation_errors.insufficientBalance(), "finishIntent: the claim credits nothing to spend");
 		return output;
 	};
 	const queued = claimable.outputs.find((o) => o.isDelayed && o.amount > 0n);
@@ -52,12 +55,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,
@@ -69,7 +72,7 @@ const whole = (steps) => ({
 */
 function partialTail(args) {
 	const { intent, claimable, queued, view } = args;
-	const inFlight = require_onchain_validation_token.toTokenAmount(view.sdk, queued.token, queued.amount);
+	const inFlight = require_onchain_validation_helpers_token.toTokenAmount(view.sdk, queued.token, queued.amount);
 	const claimed = require_onchain_accounts_intents_operations.instantOutput(claimable.outputs);
 	if (!claimed) return {
 		steps: require_onchain_accounts_intents_plan.planFinishClaimOnly(claimable),
@@ -124,7 +127,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.
 */
@@ -144,7 +147,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.
 *
@@ -161,7 +164,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 require_onchain_validation_refusal.IntentPreviewError("noRecordedIntent", void 0, "projectTail: the request queued nothing to claim");
+	if (!queued || !claim) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_prepare_errors.noRecordedIntent(), "projectTail: the request queued nothing to claim");
 	const next = sliceAfter(creditAccount, delayed.afterRequest);
 	const { steps } = planTail({
 		intent: delayed.record,
@@ -185,7 +188,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/cjs/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: require_onchain_market_credit_CreditSuite.CreditSuite.prototype.totalLiquidationDiscount,
 		creditOperationMarket: require_onchain_market_credit_CreditSuite.CreditSuite.prototype.creditOperationMarket,
+		isForbidden: require_onchain_market_credit_CreditSuite.CreditSuite.prototype.isForbidden,
+		maxBorrowAmount: require_onchain_market_credit_CreditSuite.CreditSuite.prototype.maxBorrowAmount,
 		creditManager: {
 			address: args.creditManager,
 			liquidationThresholds,