@gearbox-protocol/sdk 16.0.0-next.5 → 16.0.0-next.51

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

@@ -1,6 +1,9 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_utils_bigint_math = require("../../utils/bigint-math.js");
 const require_onchain_constants_math = require("../../constants/math.js");
-const require_onchain_accounts_intents_types = require("./types.js");
+const require_onchain_validation_checks = require("../../validation/checks.js");
+const require_onchain_validation_refusal = require("../../validation/refusal.js");
+const require_onchain_validation_token = require("../../validation/token.js");
 //#region src/onchain/accounts/intents/math.ts
 /** Debt that realises `leverage` on `collateral`: `D = C · (L − 1)`. */
 function debtForLeverage(collateral, leverage) {
@@ -14,7 +17,7 @@ function debtForLeverage(collateral, leverage) {
 * it, so no rounding is introduced on the way.
 */
 function proportionalDebt(position, collateralDelta) {
-	if (position.collateral <= 0n) throw new require_onchain_accounts_intents_types.IntentPreviewError("insufficientSourceBalance", "cannot preserve leverage on an account with no collateral");
+	if (position.collateral <= 0n) throw new require_onchain_validation_refusal.IntentPreviewError("insufficientSourceBalance", void 0, "cannot preserve leverage on an account with no collateral");
 	return position.debt * collateralDelta / position.collateral;
 }
 /**
@@ -32,21 +35,28 @@ function maxProportionalWithdrawal(position, band) {
 	if (debt === 0n) return allButLast;
 	const repayable = debt - band.minDebt;
 	if (repayable < 0n) return 0n;
-	const bound = ceilDiv(collateral * (repayable + 1n), debt) - 1n;
+	const bound = require_onchain_utils_bigint_math.BigIntMath.ceilDiv(collateral * (repayable + 1n), debt) - 1n;
 	return bound < allButLast ? bound : allButLast;
 }
-const ceilDiv = (a, b) => (a + b - 1n) / b;
 /** Total leverage cannot drop below 1x — that would be negative debt. */
 function assertLeverageAtLeastOne(leverage) {
-	if (leverage < 100n) throw new require_onchain_accounts_intents_types.IntentPreviewError("leverageOutOfRange", `target leverage ${leverage} is below 1x`);
+	require_onchain_validation_refusal.raise(require_onchain_validation_checks.checkLeverageAtLeastOne({
+		leverage,
+		min: require_onchain_constants_math.LEVERAGE_DECIMALS
+	}), `target leverage ${leverage} is below 1x`);
 }
 /**
 * Rejects a debt the facade would revert on: zero is always fine (no loan at
 * all), anything else has to sit inside `[minDebt, maxDebt]`.
 */
-function assertDebtInBand(debt, band) {
-	if (debt > band.maxDebt) throw new require_onchain_accounts_intents_types.IntentPreviewError("debtOutOfRange", `debt ${debt} exceeds maxDebt ${band.maxDebt}`);
-	if (debt > 0n && debt < band.minDebt) throw new require_onchain_accounts_intents_types.IntentPreviewError("debtOutOfRange", `debt ${debt} is below minDebt ${band.minDebt}`);
+function assertDebtInBand(sdk, debt, band, underlying) {
+	require_onchain_validation_refusal.raise(require_onchain_validation_checks.checkDebtInBand({
+		debt,
+		minDebt: band.minDebt,
+		maxDebt: band.maxDebt,
+		underlying: require_onchain_validation_token.toToken(sdk, underlying),
+		allowZero: true
+	}), debt > band.maxDebt ? `debt ${debt} exceeds maxDebt ${band.maxDebt}` : `debt ${debt} is below minDebt ${band.minDebt}`);
 }
 //#endregion
 exports.assertDebtInBand = assertDebtInBand;

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

@@ -31,7 +31,7 @@ function maxWithdrawCollateral(props) {
 	const underlying = market.pool.underlying;
 	const target = creditAccount.tokens.find((t) => require_onchain_accounts_intents_utils_common.eq(t.token, token));
 	if (!target || target.balance <= 10n) return 0n;
-	if (creditAccount.accountDebt === 0n) return target.balance;
+	if (creditAccount.totalDebt === 0n) return target.balance;
 	const masked = creditAccount.enabledTokensMask !== 0n;
 	const counts = (t) => t.balance > 10n && (!masked || (t.mask & creditAccount.enabledTokensMask) !== 0n);
 	/** What a holding backs, in the check's units: USD × PERCENTAGE_FACTOR. */
@@ -48,7 +48,7 @@ function maxWithdrawCollateral(props) {
 		if (require_onchain_accounts_intents_utils_common.eq(t.token, token) || !counts(t)) continue;
 		otherMoney += weigh(t);
 	}
-	const borrowed = usd(priceOracle, underlying, creditAccount.accountDebt);
+	const borrowed = usd(priceOracle, underlying, creditAccount.totalDebt);
 	if (borrowed === void 0 || borrowed <= 0n) return 0n;
 	const required = borrowed * targetHF;
 	if (required <= otherMoney) return target.balance;
@@ -57,8 +57,8 @@ function maxWithdrawCollateral(props) {
 	const targetLt = BigInt(creditManager.liquidationThresholds.get(target.token) ?? 0);
 	const targetUsd = safeUsd(priceOracle, target.token, target.balance);
 	if (targetLt === 0n || !targetUsd) return 0n;
-	const keptUsd = ceilDiv(shortfall, targetLt);
-	const kept = ceilDiv(target.balance * keptUsd, targetUsd);
+	const keptUsd = require_onchain_utils_bigint_math.BigIntMath.ceilDiv(shortfall, targetLt);
+	const kept = require_onchain_utils_bigint_math.BigIntMath.ceilDiv(target.balance * keptUsd, targetUsd);
 	return kept >= target.balance ? 0n : target.balance - kept;
 }
 /** USD value at the main feed, or `undefined` when the token has no price. */
@@ -82,8 +82,5 @@ function safeUsd(oracle, token, amount) {
 		return main;
 	}
 }
-function ceilDiv(a, b) {
-	return (a + b - 1n) / b;
-}
 //#endregion
 exports.maxWithdrawCollateral = maxWithdrawCollateral;

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

@@ -1,9 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-require("../../constants/math.js");
-const require_onchain_accounts_intents_types = require("./types.js");
-const require_onchain_accounts_intents_utils_convert_amount = require("./utils/convert-amount.js");
+const require_onchain_validation_refusal = require("../../validation/refusal.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");
 const require_onchain_accounts_intents_utils_quotas_for_update = require("./utils/quotas-for-update.js");
 const require_onchain_accounts_intents_utils_router_path = require("./utils/router-path.js");
 require("./utils/index.js");
@@ -11,7 +10,8 @@ require("./utils/index.js");
 /** Stand-in account address: nothing exists on chain until the tx lands. */
 const NO_ACCOUNT = "0x0000000000000000000000000000000000000000";
 /**
-* Previews opening a leveraged position out of wallet collateral.
+* Builds the state opening a leveraged position out of wallet collateral would
+* reach.
 *
 * Debt follows from the target leverage against the supplied margin
 * (`debt = margin * (L - 1)`, `totalValue = margin * L`); the collateral and the
@@ -21,16 +21,16 @@ const NO_ACCOUNT = "0x0000000000000000000000000000000000000000";
 * no operation list — the caller passes the numbers and calls straight to
 * `sdk.accounts.openCA`.
 */
-async function previewOpenStrategy(props) {
+async function buildOpenStrategyState(props) {
 	const { sdk, creditManager, collateral, targetToken, leverage, slippage = 0, quotaReserve, leftoverBalances = [] } = props;
-	if (leverage < 100n) throw new require_onchain_accounts_intents_types.IntentPreviewError("leverageOutOfRange", `openStrategy: leverage ${leverage} is below 1x`);
+	require_onchain_accounts_intents_math.assertLeverageAtLeastOne(leverage);
 	const suite = sdk.marketRegister.findCreditManager(creditManager);
 	const market = sdk.marketRegister.findByCreditManager(creditManager);
 	require_onchain_accounts_intents_guards.assertMarketOperable(suite);
 	const underlying = market.pool.underlying.toLowerCase();
-	const convert = require_onchain_accounts_intents_utils_convert_amount.convertAmount(sdk, creditManager);
+	const convert = (from, to, amount) => market.priceOracle.safeConvert(from, to, amount) ?? 0n;
 	const margin = collateral.reduce((acc, a) => acc + convert(a.token, underlying, a.balance), 0n);
-	if (margin <= 0n) throw new require_onchain_accounts_intents_types.IntentPreviewError("insufficientSourceBalance", "openStrategy: collateral is worth nothing in underlying");
+	if (margin <= 0n) throw new require_onchain_validation_refusal.IntentPreviewError("insufficientSourceBalance", void 0, "openStrategy: collateral is worth nothing in underlying");
 	const debt = require_onchain_accounts_intents_math.debtForLeverage(margin, leverage);
 	const account = {
 		creditAccount: NO_ACCOUNT,
@@ -39,17 +39,19 @@ async function previewOpenStrategy(props) {
 		underlying,
 		enabledTokensMask: 0n,
 		totalDebtUSD: 0n,
-		accountDebt: 0n,
+		totalDebt: 0n,
 		tokens: []
 	};
-	require_onchain_accounts_intents_math.assertDebtInBand(debt, suite.creditFacade);
-	require_onchain_accounts_intents_guards.assertCanBorrow(suite, debt);
-	const leg = await require_onchain_accounts_intents_utils_router_path.createRouterPaths({
+	require_onchain_accounts_intents_math.assertDebtInBand(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,
 		creditAccount: account,
 		slippage
-	}).openStrategy({
-		expectedBalances: mergeExpectedBalances(collateral, underlying, debt),
+	});
+	const expectedBalances = mergeExpectedBalances(collateral, underlying, debt);
+	const leg = await paths.openStrategy({
+		expectedBalances,
 		leftoverBalances,
 		target: targetToken
 	});
@@ -76,7 +78,7 @@ async function previewOpenStrategy(props) {
 		before: [],
 		after: averageAssets
 	});
-	require_onchain_accounts_intents_guards.assertQuotaHeadroom(market, averageQuota);
+	require_onchain_accounts_intents_guards.assertQuotaHeadroom(sdk, market, averageQuota);
 	const snapshot = {
 		creditManager,
 		assets: averageAssets,
@@ -84,24 +86,22 @@ async function previewOpenStrategy(props) {
 		totalDebt: debt,
 		totalValue: margin + debt
 	};
-	const projectedPool = { availableLiquidityChange: -debt };
-	const metrics = {
-		healthFactor: sdk.positions.healthFactor(snapshot),
-		borrowRate: sdk.positions.borrowRate(snapshot, projectedPool),
-		timeToLiquidation: sdk.positions.timeToLiquidation(snapshot, projectedPool),
-		liquidationPrice: sdk.positions.liquidationPrice(snapshot)
-	};
-	require_onchain_accounts_intents_guards.assertCollateralised(metrics.healthFactor);
-	return {
-		debt,
-		collateral: margin,
+	const { assets: _assets, quotas: _quotas, ...projection } = sdk.positions.projection(snapshot, { availableLiquidityChange: -debt });
+	require_onchain_accounts_intents_guards.assertCollateralised(projection.healthFactor, false);
+	const priceImpact = await require_onchain_accounts_intents_utils_price_impact.collectPriceImpact(leg.probe ? [leg.probe] : [], {
 		totalValue: margin + debt,
+		netValue: margin,
+		toUnderlying: (from, amount) => convert(from, underlying, amount)
+	});
+	return {
+		...projection,
+		currentPrice: sdk.positions.currentPrice(snapshot),
+		priceImpact,
 		averageAssets: averageAssets.map(priced),
 		minAssets: minAssets.map(priced),
 		averageQuota,
 		minQuota,
-		calls: [...leg.calls],
-		...metrics
+		calls: [...leg.calls]
 	};
 }
 /** Collateral plus the borrowed underlying, folded into one balance per token. */
@@ -131,4 +131,4 @@ function toAssets(balances) {
 	}));
 }
 //#endregion
-exports.previewOpenStrategy = previewOpenStrategy;
+exports.buildOpenStrategyState = buildOpenStrategyState;

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

@@ -1,7 +1,8 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_onchain_constants_math = require("../../constants/math.js");
 require("../../constants/index.js");
-const require_onchain_accounts_intents_types = require("./types.js");
+const require_onchain_validation_refusal = require("../../validation/refusal.js");
+const require_onchain_validation_token = require("../../validation/token.js");
 const require_onchain_accounts_intents_utils_common = require("./utils/common.js");
 const require_onchain_accounts_intents_math = require("./math.js");
 //#region src/onchain/accounts/intents/plan.ts
@@ -24,18 +25,21 @@ 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_accounts_intents_types.IntentPreviewError("insufficientSourceBalance", `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_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)}`);
 	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_accounts_intents_types.IntentPreviewError("unsupportedCollateralToken", `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_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}`);
 	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_accounts_intents_types.IntentPreviewError("leverageOutOfRange", `deposit: target leverage ${intent.targetLeverage} would require repaying debt`);
-	require_onchain_accounts_intents_math.assertDebtInBand(view.debt + debtDelta, view.band);
+	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);
 	const T = intent.positionToken ?? positionToken(view, "deposit");
 	const depositStays = require_onchain_accounts_intents_utils_common.eq(intent.token, T);
 	return [
@@ -62,11 +66,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_accounts_intents_types.IntentPreviewError("unsupportedCollateralToken", `repay: only ${U}${view.rwaAsset ? ` or ${view.rwaAsset}` : ""} can be repaid with, got ${intent.token}`);
-	if (view.debt <= 0n) throw new require_onchain_accounts_intents_types.IntentPreviewError("debtOutOfRange", "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_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");
 	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.debt - repaid, view.band);
+	require_onchain_accounts_intents_math.assertDebtInBand(view.sdk, view.debt - repaid, view.band, view.underlying);
 	return [
 		add(intent.token, funding, intent.value),
 		...fundsInU ? [] : [convert(intent.token, U, funding)],
@@ -122,7 +130,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_accounts_intents_types.IntentPreviewError("insufficientSourceBalance", `withdraw: account holds no ${S} to redeem`);
+		if (held <= 0n) throw new require_onchain_validation_refusal.IntentPreviewError("insufficientSourceBalance", void 0, `withdraw: account holds no ${S} to redeem`);
 		return [{
 			kind: "request",
 			token: S,
@@ -134,7 +142,7 @@ 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_accounts_intents_types.IntentPreviewError("noDelayedRoute", `withdraw: a delayed route 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_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);
 	return [{
 		kind: "request",
@@ -160,9 +168,9 @@ function planWithdrawDelayed(intent, view) {
 */
 function planAdjustLeverageDelayed(intent, view) {
 	const { U, delta } = leverageShape(intent, view);
-	if (delta >= 0n) throw new require_onchain_accounts_intents_types.IntentPreviewError("noDelayedRoute", "adjustLeverage: only deleveraging can settle with a delay");
+	if (delta >= 0n) throw new require_onchain_validation_refusal.IntentPreviewError("noDelayedRoute", void 0, "adjustLeverage: only deleveraging can settle with a delay");
 	const shortfall = -delta - view.balanceOf(U);
-	if (shortfall <= 0n) throw new require_onchain_accounts_intents_types.IntentPreviewError("noDelayedRoute", "adjustLeverage: idle underlying covers the repayment, nothing to redeem");
+	if (shortfall <= 0n) throw new require_onchain_validation_refusal.IntentPreviewError("noDelayedRoute", void 0, "adjustLeverage: idle underlying covers the repayment, nothing to redeem");
 	const T = intent.token ?? positionToken(view, "adjustLeverage");
 	return [{
 		kind: "request",
@@ -190,7 +198,7 @@ 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_accounts_intents_types.IntentPreviewError("noDelayedRoute", `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_refusal.IntentPreviewError("noDelayedRoute", { token: require_onchain_validation_token.toToken(view.sdk, T) }, `finishWithdraw: cannot pay out in ${T}`);
 	if (intent.debtRepaid === 0n) return [
 		claim(claimable),
 		convert(claimed.token, T, claimed.amount),
@@ -282,7 +290,7 @@ function withdrawShape(intent, view) {
 		};
 	}
 	const WU = view.price(T, U, intent.amount);
-	if (WU <= 0n) throw new require_onchain_accounts_intents_types.IntentPreviewError("insufficientSourceBalance", `withdraw: cannot price ${intent.amount} of ${T}`);
+	if (WU <= 0n) throw new require_onchain_validation_refusal.IntentPreviewError("insufficientSourceBalance", void 0, `withdraw: cannot price ${intent.amount} of ${T}`);
 	if (WU >= view.collateral) {
 		assertHasValue(view);
 		return {
@@ -295,7 +303,7 @@ function withdrawShape(intent, view) {
 		};
 	}
 	const dD = require_onchain_accounts_intents_math.proportionalDebt(view, WU);
-	require_onchain_accounts_intents_math.assertDebtInBand(view.debt - dD, view.band);
+	require_onchain_accounts_intents_math.assertDebtInBand(view.sdk, view.debt - dD, view.band, view.underlying);
 	return {
 		U,
 		T,
@@ -312,9 +320,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_accounts_intents_types.IntentPreviewError("insufficientSourceBalance", "adjustLeverage: account has no collateral to lever");
+	if (view.collateral <= 0n) throw new require_onchain_validation_refusal.IntentPreviewError("insufficientSourceBalance", void 0, "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(target, view.band);
+	require_onchain_accounts_intents_math.assertDebtInBand(view.sdk, target, view.band, view.underlying);
 	return {
 		U: view.underlying,
 		delta: target - view.debt
@@ -380,20 +388,20 @@ function payout(view, token, amount, to) {
 }
 function positionToken(view, flow) {
 	const pick = view.fattest([view.underlying]);
-	if (!pick) throw new require_onchain_accounts_intents_types.IntentPreviewError("insufficientSourceBalance", `${flow}: no position token on the account`);
+	if (!pick) throw new require_onchain_validation_refusal.IntentPreviewError("insufficientSourceBalance", void 0, `${flow}: no position token on the account`);
 	return pick;
 }
 function sourceToken(view) {
 	const pick = view.fattest();
-	if (!pick) throw new require_onchain_accounts_intents_types.IntentPreviewError("insufficientSourceBalance", "withdraw: account has no spendable balance");
+	if (!pick) throw new require_onchain_validation_refusal.IntentPreviewError("insufficientSourceBalance", void 0, "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_accounts_intents_types.IntentPreviewError("insufficientSourceBalance", `withdraw: nothing to withdraw, net value is ${view.collateral}`);
+	if (view.collateral <= 0n) throw new require_onchain_validation_refusal.IntentPreviewError("insufficientSourceBalance", void 0, `withdraw: nothing to withdraw, net value is ${view.collateral}`);
 }
 function assertPositive(amount, flow) {
-	if (amount <= 0n) throw new require_onchain_accounts_intents_types.IntentPreviewError("insufficientSourceBalance", `${flow}: amount must be positive`);
+	if (amount <= 0n) throw new require_onchain_validation_refusal.IntentPreviewError("insufficientSourceBalance", void 0, `${flow}: amount must be positive`);
 }
 //#endregion
 exports.RAISED = RAISED;

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

@@ -1,11 +1,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_onchain_market_math = require("../../market/math.js");
-const require_onchain_accounts_intents_types = require("./types.js");
+const require_onchain_validation_refusal = require("../../validation/refusal.js");
+const require_onchain_validation_token = require("../../validation/token.js");
 const require_onchain_accounts_intents_utils_common = require("./utils/common.js");
-const require_onchain_accounts_intents_utils_convert_amount = require("./utils/convert-amount.js");
 const require_onchain_accounts_intents_utils_pick_token = require("./utils/pick-token.js");
 const require_onchain_accounts_intents_guards = require("./guards.js");
 const require_onchain_accounts_intents_utils_ledger = require("./utils/ledger.js");
+const require_onchain_accounts_intents_utils_price_impact = require("./utils/price-impact.js");
 const require_onchain_accounts_intents_utils_quotas_for_update = require("./utils/quotas-for-update.js");
 const require_onchain_accounts_intents_utils_router_path = require("./utils/router-path.js");
 const require_onchain_accounts_intents_operations = require("./operations.js");
@@ -24,25 +24,47 @@ async function realize(steps, props) {
 	const { creditAccount, sdk, slippage, quotaReserve } = props;
 	const { underlying } = creditAccount;
 	const rwaAsset = sdk.tokensMeta.rwaUnderlyings.get(underlying)?.asset;
-	const price = require_onchain_accounts_intents_utils_convert_amount.convertAmount(sdk, creditAccount.creditManager);
 	const paths = props.paths ?? require_onchain_accounts_intents_utils_router_path.createRouterPaths({
 		sdk,
 		creditAccount,
 		slippage
 	});
 	const market = sdk.marketRegister.findByCreditManager(creditAccount.creditManager);
+	const price = (from, to, amount) => market.priceOracle.safeConvert(from, to, amount) ?? 0n;
 	const suite = sdk.marketRegister.findCreditManager(creditAccount.creditManager);
-	const ledger = new require_onchain_accounts_intents_utils_ledger.OperationLedger({
+	const start = {
 		initialAssets: creditAccount.tokens,
 		underlying,
-		debt: creditAccount.accountDebt,
+		debt: creditAccount.totalDebt,
 		convert: price
-	});
+	};
+	/**
+	* 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.
+	*/
+	const ledger = new require_onchain_accounts_intents_utils_ledger.OperationLedger(start);
+	/**
+	* The same walk with every routed leg counted at the amount the pathfinder
+	* expects to return. Nothing is built from it: it is where the position
+	* actually lands, so it is what the reported state is read off.
+	*/
+	const expected = new require_onchain_accounts_intents_utils_ledger.OperationLedger(start);
 	const operations = [];
-	const push = (op) => {
+	/**
+	* @param asExpected - The operation as the expected branch sees it, for the
+	* legs where the two differ. Defaults to the operation itself, which is the
+	* case for everything whose amount the calldata fixes.
+	*/
+	const push = (op, asExpected = op) => {
 		operations.push(op);
 		ledger.apply(op);
+		expected.apply(asExpected);
 	};
+	/** One per routed leg, each already awaiting its quote; folded after the guards. */
+	const probes = [];
 	/** Output of the last convert or claim, for `RAISED` amounts. */
 	let raised = 0n;
 	/** The request, before the walk's end state can be attached to it. */
@@ -60,7 +82,10 @@ async function realize(steps, props) {
 	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_accounts_intents_types.IntentPreviewError("insufficientSourceBalance", `${what}: needs ${amount} of ${token}, account holds ${held}`);
+		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}`);
 	};
 	for (const step of steps) switch (step.kind) {
 		case "add":
@@ -73,7 +98,7 @@ async function realize(steps, props) {
 			}));
 			break;
 		case "borrow":
-			require_onchain_accounts_intents_guards.assertCanBorrow(suite, step.amount);
+			require_onchain_accounts_intents_guards.assertCanBorrow(sdk, suite, step.amount);
 			push(require_onchain_accounts_intents_operations.buildIncreaseDebtOperation({
 				amount: step.amount,
 				creditAccount,
@@ -131,28 +156,44 @@ async function realize(steps, props) {
 				amount,
 				keep: held - amount
 			});
-			push(require_onchain_accounts_intents_operations.buildSwapOperation({
+			if (leg.probe) probes.push(leg.probe);
+			const swap = require_onchain_accounts_intents_operations.buildSwapOperation({
 				tokenIn: step.from,
 				amountIn: amount,
 				tokenOut: step.to,
 				amountOut: leg.minAmount,
 				calls: leg.calls
-			}));
+			});
+			push(swap, {
+				...swap,
+				amountOut: leg.amount
+			});
 			raised = leg.minAmount;
 			break;
 		}
 		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_accounts_intents_types.IntentPreviewError("withdrawalInProgress", `closeAll: ${pending.token} is a pending withdrawal, claim it first`);
+			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 (balances.length > 0) {
 				const leg = await paths.closeAll({ balances });
-				if (leg.calls.length > 0 || leg.minAmount > 0n) push(require_onchain_accounts_intents_operations.buildCloseSwapOperation({
-					from: balances,
-					tokenOut: underlying,
-					amountOut: leg.minAmount,
-					calls: leg.calls
-				}));
+				if (leg.probe) probes.push(leg.probe);
+				if (leg.calls.length > 0 || leg.minAmount > 0n) {
+					const sale = require_onchain_accounts_intents_operations.buildCloseSwapOperation({
+						from: balances,
+						tokenOut: underlying,
+						amountOut: leg.minAmount,
+						calls: leg.calls
+					});
+					push(sale, {
+						...sale,
+						from: balances.map((a) => ({
+							token: a.token,
+							balance: expected.balanceOf(a.token)
+						})),
+						amountOut: leg.amount
+					});
+				}
 			}
 			raised = ledger.balanceOf(underlying);
 			break;
@@ -172,7 +213,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_accounts_intents_types.IntentPreviewError("withdrawalInProgress", `request: ${asset.withdrawalPhantomToken} already holds a pending withdrawal`);
+			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`);
 			assertHolds(step.token, step.amount + step.reserve, "request");
 			const preview = await sdk.accounts.previewDelayedWithdrawal({
 				creditAccount: creditAccount.creditAccount,
@@ -218,24 +259,32 @@ async function realize(steps, props) {
 				creditAccount,
 				sdk
 			}));
-			for (const { token, balance } of ledger.snapshot().assets) push(require_onchain_accounts_intents_operations.buildWithdrawCollateralOperation({
-				token,
-				amount: balance,
-				to: step.to,
-				all: true,
-				creditAccount,
-				sdk
-			}));
+			for (const { token, balance } of ledger.snapshot().assets) {
+				const payout = require_onchain_accounts_intents_operations.buildWithdrawCollateralOperation({
+					token,
+					amount: balance,
+					to: step.to,
+					all: true,
+					creditAccount,
+					sdk
+				});
+				push(payout, {
+					...payout,
+					amount: expected.balanceOf(token)
+				});
+			}
 			break;
 		}
 	}
-	const { assets, totalValue, debt } = ledger.snapshot();
+	const floor = ledger.snapshot();
+	const { assets, debt } = floor;
+	const projected = expected.snapshot();
 	require_onchain_accounts_intents_guards.assertGrowthAllowed({
 		sdk,
 		suite,
 		market,
 		before: creditAccount.tokens,
-		after: assets
+		after: projected.assets
 	});
 	const quotas = cleared ?? require_onchain_accounts_intents_utils_quotas_for_update.getQuotasForUpdate({
 		assetsBefore: creditAccount.tokens,
@@ -249,7 +298,7 @@ async function realize(steps, props) {
 		convert: price
 	});
 	if (!cleared && quotas.quotaIncrease.length + quotas.quotaDecrease.length > 0) {
-		require_onchain_accounts_intents_guards.assertQuotaHeadroom(market, quotas.quotaIncrease);
+		require_onchain_accounts_intents_guards.assertQuotaHeadroom(sdk, market, quotas.quotaIncrease);
 		push(require_onchain_accounts_intents_operations.buildQuotaUpdateOperation({
 			update: quotas,
 			creditAccount,
@@ -257,28 +306,29 @@ async function realize(steps, props) {
 		}));
 	}
 	const quotasAfter = require_onchain_accounts_intents_utils_quotas_for_update.quotasAfterUpdate(creditAccount.tokens, quotas.desiredQuota);
+	const quoted = Object.values(quotasAfter);
 	const snapshot = {
 		creditManager: creditAccount.creditManager,
-		assets,
-		quotas: Object.values(quotasAfter),
+		assets: projected.assets,
+		quotas: quoted,
 		totalDebt: debt,
-		totalValue
-	};
-	const projectedPool = { availableLiquidityChange: creditAccount.accountDebt - debt };
-	const metrics = {
-		healthFactor: sdk.positions.healthFactor(snapshot),
-		borrowRate: sdk.positions.borrowRate(snapshot, projectedPool),
-		timeToLiquidation: sdk.positions.timeToLiquidation(snapshot, projectedPool),
-		liquidationPrice: sdk.positions.liquidationPrice(snapshot)
+		totalValue: projected.totalValue
 	};
-	require_onchain_accounts_intents_guards.assertCollateralised(paysOut ? sdk.positions.healthFactor(snapshot, { safePrices: true }) : metrics.healthFactor);
+	const projection = sdk.positions.projection(snapshot, { availableLiquidityChange: creditAccount.totalDebt - debt });
+	require_onchain_accounts_intents_guards.assertCollateralised(sdk.positions.healthFactor({
+		...snapshot,
+		assets,
+		totalValue: floor.totalValue
+	}, { safePrices: paysOut }), paysOut);
+	const priceImpact = await require_onchain_accounts_intents_utils_price_impact.collectPriceImpact(probes, {
+		totalValue: projected.totalValue,
+		netValue: projected.totalValue - debt,
+		toUnderlying: (from, amount) => price(from, underlying, amount)
+	});
 	const state = {
-		totalValue,
-		accountDebt: debt,
-		leverage: require_onchain_market_math.calcPositionLeverage(totalValue, debt),
-		assets: assets.map((a) => market.priceOracle.toTokenAmount(a.token, a.balance)),
-		quotas: quotasAfter,
-		...metrics
+		...projection,
+		priceImpact,
+		currentPrice: sdk.positions.currentPrice(snapshot)
 	};
 	return {
 		operations,
@@ -298,10 +348,13 @@ async function realize(steps, props) {
 */
 async function delayedConfig(sdk, creditAccount, token) {
 	const compressor = sdk.withdrawalCompressor;
-	if (!compressor) throw new require_onchain_accounts_intents_types.IntentPreviewError("noDelayedRoute", "request: chain has no withdrawal compressor");
+	if (!compressor) throw new require_onchain_validation_refusal.IntentPreviewError("noDelayedRoute", { token: require_onchain_validation_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_accounts_intents_types.IntentPreviewError("noDelayedRoute", `request: ${token} has no delayed withdrawal config`);
-	if (assets.length > 1) throw new require_onchain_accounts_intents_types.IntentPreviewError("multipleDelayedWithdrawals", `request: ${token} has ${assets.length} delayed withdrawal configs`);
+	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`);
 	return assets[0];
 }
 const callsOf = (operations) => operations.flatMap((op) => op.calls);