@gearbox-protocol/sdk 16.0.0-next.18 → 16.0.0-next.19

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

@@ -1,7 +1,7 @@
 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_refusal = require("./refusal.js");
+const require_onchain_validation_checks = require("../../validation/checks.js");
+const require_onchain_validation_refusal = require("../../validation/refusal.js");
+const require_onchain_validation_token = require("../../validation/token.js");
 const require_onchain_accounts_intents_utils_common = require("./utils/common.js");
 const require_onchain_accounts_intents_utils_pick_token = require("./utils/pick-token.js");
 //#region src/onchain/accounts/intents/guards.ts
@@ -25,11 +25,15 @@ const require_onchain_accounts_intents_utils_pick_token = require("./utils/pick-
 */
 function assertMarketOperable(suite) {
 	const creditManager = suite.creditManager.address;
-	if (suite.isPaused) throw new require_onchain_accounts_intents_refusal.IntentPreviewError("marketPaused", { creditManager }, `${creditManager} is paused`);
-	if (suite.isExpired) throw new require_onchain_accounts_intents_refusal.IntentPreviewError("marketExpired", {
+	require_onchain_validation_refusal.raise(require_onchain_validation_checks.checkCreditManagerPaused({
+		isPaused: suite.isPaused,
+		creditManager
+	}), `${creditManager} is paused`);
+	require_onchain_validation_refusal.raise(require_onchain_validation_checks.checkMarketExpired({
+		isExpired: suite.isExpired,
 		creditManager,
 		expirationDate: suite.creditFacade.expirationDate
-	}, `${creditManager} expired at ${suite.creditFacade.expirationDate}`);
+	}), `${creditManager} expired at ${suite.creditFacade.expirationDate}`);
 }
 /**
 * What the pool will hand this manager in one transaction: the tightest of its
@@ -40,30 +44,35 @@ function assertMarketOperable(suite) {
 function borrowable(suite) {
 	const { pool } = suite.market.pool;
 	const { maxDebtPerBlockMultiplier, maxDebt } = suite.creditFacade;
-	if (maxDebtPerBlockMultiplier === 0) return 0n;
+	if (maxDebtPerBlockMultiplier === 0) return {
+		limit: 0n,
+		binding: "facadePerBlockCap"
+	};
 	const available = pool.creditManagerDebtParams.get(suite.creditManager.address)?.available;
 	return [
-		pool.availableLiquidity,
-		maxDebt * BigInt(maxDebtPerBlockMultiplier),
-		...available === void 0 ? [] : [available]
-	].reduce((a, b) => a < b ? a : b);
+		{
+			limit: pool.availableLiquidity,
+			binding: "poolAvailableLiquidity"
+		},
+		{
+			limit: maxDebt * BigInt(maxDebtPerBlockMultiplier),
+			binding: "facadePerBlockCap"
+		},
+		...available === void 0 ? [] : [{
+			limit: available,
+			binding: "managerDebtAvailable"
+		}]
+	].reduce((a, b) => b.limit < a.limit ? b : a);
 }
 /** The pool has to be able to lend what the plan means to draw. */
-function assertCanBorrow(suite, amount) {
-	const limit = borrowable(suite);
-	if (amount > limit) {
-		const token = suite.market.pool.underlying;
-		throw new require_onchain_accounts_intents_refusal.IntentPreviewError("insufficientPoolLiquidity", {
-			requested: {
-				token,
-				balance: amount
-			},
-			available: {
-				token,
-				balance: limit
-			}
-		}, `borrow: ${amount} exceeds what the pool can lend now (${limit})`);
-	}
+function assertCanBorrow(sdk, suite, amount) {
+	const { limit, binding } = borrowable(suite);
+	require_onchain_validation_refusal.raise(require_onchain_validation_checks.checkBorrowLimit({
+		requested: amount,
+		available: limit,
+		binding,
+		underlying: require_onchain_validation_token.toToken(sdk, suite.market.pool.underlying)
+	}), `borrow: ${amount} exceeds what the pool can lend now (${limit})`);
 }
 /**
 * What the account is allowed to end up holding more of than it started with.
@@ -83,16 +92,17 @@ function assertGrowthAllowed(args) {
 	const underlying = market.pool.underlying;
 	for (const { token, balance } of after) {
 		if (balance <= (before.find((a) => require_onchain_accounts_intents_utils_common.eq(a.token, token))?.balance ?? 0n)) continue;
-		if (forbidden.some((f) => require_onchain_accounts_intents_utils_common.eq(f, token))) throw new require_onchain_accounts_intents_refusal.IntentPreviewError("forbiddenToken", { token }, `${token} is forbidden in this market and the plan buys more of it`);
+		require_onchain_validation_refusal.raise(require_onchain_validation_checks.checkForbiddenToken({
+			token: require_onchain_validation_token.toToken(sdk, token),
+			isForbidden: forbidden.some((f) => require_onchain_accounts_intents_utils_common.eq(f, token))
+		}), `${token} is forbidden in this market and the plan buys more of it`);
 		if (require_onchain_accounts_intents_utils_common.eq(token, underlying) || require_onchain_accounts_intents_utils_pick_token.isPhantomToken(sdk, token)) continue;
-		if (!market.pool.pqk.hasActiveQuota(token)) throw new require_onchain_accounts_intents_refusal.IntentPreviewError("quotaLimitReached", {
-			token,
+		if (!market.pool.pqk.hasActiveQuota(token)) require_onchain_validation_refusal.raise(require_onchain_validation_checks.checkQuotaLimit({
+			token: require_onchain_validation_token.toToken(sdk, token),
 			requested: void 0,
-			available: {
-				token: underlying,
-				balance: 0n
-			}
-		}, `${token} takes no quota in this market, so it counts as no collateral`);
+			available: 0n,
+			underlying: require_onchain_validation_token.toToken(sdk, underlying)
+		}), `${token} takes no quota in this market, so it counts as no collateral`);
 	}
 }
 /**
@@ -107,7 +117,7 @@ function assertGrowthAllowed(args) {
 * - here, `1.0` — what the facade enforces, so what a plan must clear to land;
 * - `maxWithdrawCollateral` sizes at `MIN_HF_LIMITED + 2` — a *sizing* helper
 *   leaving headroom, which is not the same as a validity check;
-* - `validateHF` refuses at or below `MIN_HF_LIMITED` — a form's own caution.
+* - a form refuses at or below `MIN_HF_LIMITED` (`MIN_HEALTH_FACTOR_FORM`).
 *
 * Raising this one to `MIN_HF_LIMITED` was tried and reverted: it made
 * `maxWithdraw` hand back a ceiling this guard then refused, and it blocked
@@ -125,35 +135,30 @@ function assertGrowthAllowed(args) {
 * still be refused on-chain after passing here.
 */
 function assertCollateralised(healthFactorBps, safePrices) {
-	const required = Number(require_onchain_constants_math.PERCENTAGE_FACTOR);
-	if (healthFactorBps < required) throw new require_onchain_accounts_intents_refusal.IntentPreviewError("insufficientCollateral", {
+	const required = require_onchain_validation_checks.MIN_HEALTH_FACTOR_FACADE;
+	require_onchain_validation_refusal.raise(require_onchain_validation_checks.checkCollateralised({
 		healthFactor: healthFactorBps,
 		required,
 		safePrices
-	}, `the account would end at a health factor of ${healthFactorBps}, below ${required}`);
+	}), `the account would end at a health factor of ${healthFactorBps}, below ${required}`);
 }
 /**
 * A quota can only be raised as far as the market still has room for: past the
 * token's limit the keeper takes nothing more, whoever is asking.
 */
-function assertQuotaHeadroom(market, increases) {
+function assertQuotaHeadroom(sdk, market, increases) {
 	const underlying = market.pool.underlying;
 	for (const { token, balance } of increases) {
 		if (balance <= 0n) continue;
 		const quota = market.pool.pqk.quotas.get(token);
 		if (!quota) continue;
 		const left = quota.limit - quota.totalQuoted;
-		if (balance > left) throw new require_onchain_accounts_intents_refusal.IntentPreviewError("quotaLimitReached", {
-			token,
-			requested: {
-				token: underlying,
-				balance
-			},
-			available: {
-				token: underlying,
-				balance: left
-			}
-		}, `${token} has ${left} of quota left, the plan needs ${balance}`);
+		require_onchain_validation_refusal.raise(require_onchain_validation_checks.checkQuotaLimit({
+			token: require_onchain_validation_token.toToken(sdk, token),
+			requested: balance,
+			available: left,
+			underlying: require_onchain_validation_token.toToken(sdk, underlying)
+		}), `${token} has ${left} of quota left, the plan needs ${balance}`);
 	}
 }
 //#endregion

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

@@ -1,7 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_onchain_base_SDKConstruct = require("../../base/SDKConstruct.js");
-const require_common_utils_utils_validation_validate_hf = require("../../../common-utils/utils/validation/validate-hf.js");
-const require_onchain_accounts_intents_refusal = require("./refusal.js");
+const require_onchain_validation_checks = require("../../validation/checks.js");
+const require_onchain_validation_refusal = require("../../validation/refusal.js");
 const require_onchain_accounts_intents_guards = require("./guards.js");
 const require_onchain_accounts_intents_utils_credit_account_slice = require("./utils/credit-account-slice.js");
 const require_onchain_accounts_intents_leverage_band = require("./leverage-band.js");
@@ -104,7 +104,7 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 	* activity come from the account's market, valued the way the facade values
 	* a call that pays out; zero debt frees the whole balance.
 	*
-	* The default is {@link MIN_HF_LIMITED}, the bar `validateHF` holds an
+	* The default is {@link MIN_HF_LIMITED}, the bar a form holds an
 	* account to.
 	*
 	* @param props - Account slice, the SDK holding its market, the collateral
@@ -112,7 +112,7 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 	* @returns Amount in the token's units; `0n` when nothing can leave
 	*/
 	maxWithdrawCollateral(props) {
-		const { targetHF = require_common_utils_utils_validation_validate_hf.MIN_HF_LIMITED, ...rest } = props;
+		const { targetHF = require_onchain_validation_checks.MIN_HF_LIMITED, ...rest } = props;
 		return require_onchain_accounts_intents_maxWithdrawCollateral.maxWithdrawCollateral({
 			...rest,
 			targetHF: targetHF + 2n
@@ -298,8 +298,8 @@ function plain(result) {
 }
 /** Unviable requests are values; anything else is a genuine failure. */
 function asFailure(e) {
-	if (e instanceof require_onchain_accounts_intents_refusal.IntentPreviewError) return require_onchain_accounts_intents_refusal.refuse(e.reason, e.detail);
-	if (isUnroutable(e)) return require_onchain_accounts_intents_refusal.refuse("unsupportedTokenPair", void 0);
+	if (e instanceof require_onchain_validation_refusal.IntentPreviewError) return require_onchain_validation_refusal.refuse(e.reason, e.detail);
+	if (isUnroutable(e)) return require_onchain_validation_refusal.refuse("unsupportedTokenPair", void 0);
 	throw e;
 }
 /**
@@ -316,7 +316,6 @@ function isUnroutable(e) {
 }
 //#endregion
 exports.CreditAccountOperationsService = CreditAccountOperationsService;
-exports.IntentPreviewError = require_onchain_accounts_intents_refusal.IntentPreviewError;
+exports.borrowable = require_onchain_accounts_intents_guards.borrowable;
 exports.fetchCreditAccountSlice = require_onchain_accounts_intents_utils_credit_account_slice.fetchCreditAccountSlice;
-exports.refuse = require_onchain_accounts_intents_refusal.refuse;
 exports.toCreditAccountSlice = require_onchain_accounts_intents_utils_credit_account_slice.toCreditAccountSlice;

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

@@ -1,7 +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_refusal = require("./refusal.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) {
@@ -15,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_refusal.IntentPreviewError("insufficientSourceBalance", void 0, "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;
 }
 /**
@@ -38,32 +40,23 @@ function maxProportionalWithdrawal(position, band) {
 }
 /** Total leverage cannot drop below 1x — that would be negative debt. */
 function assertLeverageAtLeastOne(leverage) {
-	if (leverage < 100n) throw new require_onchain_accounts_intents_refusal.IntentPreviewError("leverageOutOfRange", {
-		requested: leverage,
+	require_onchain_validation_refusal.raise(require_onchain_validation_checks.checkLeverageAtLeastOne({
+		leverage,
 		min: require_onchain_constants_math.LEVERAGE_DECIMALS
-	}, `target leverage ${leverage} is below 1x`);
+	}), `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, underlying) {
-	const detail = {
-		requested: {
-			token: underlying,
-			balance: debt
-		},
-		minDebt: {
-			token: underlying,
-			balance: band.minDebt
-		},
-		maxDebt: {
-			token: underlying,
-			balance: band.maxDebt
-		}
-	};
-	if (debt > band.maxDebt) throw new require_onchain_accounts_intents_refusal.IntentPreviewError("debtOutOfRange", detail, `debt ${debt} exceeds maxDebt ${band.maxDebt}`);
-	if (debt > 0n && debt < band.minDebt) throw new require_onchain_accounts_intents_refusal.IntentPreviewError("debtOutOfRange", detail, `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/open-strategy.js

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_onchain_accounts_intents_refusal = require("./refusal.js");
+const require_onchain_validation_refusal = require("../../validation/refusal.js");
 const require_onchain_accounts_intents_utils_convert_amount = require("./utils/convert-amount.js");
 const require_onchain_accounts_intents_guards = require("./guards.js");
 const require_onchain_accounts_intents_utils_price_impact = require("./utils/price-impact.js");
@@ -30,7 +30,7 @@ async function previewOpenStrategy(props) {
 	const underlying = market.pool.underlying.toLowerCase();
 	const convert = require_onchain_accounts_intents_utils_convert_amount.convertAmount(sdk, creditManager);
 	const margin = collateral.reduce((acc, a) => acc + convert(a.token, underlying, a.balance), 0n);
-	if (margin <= 0n) throw new require_onchain_accounts_intents_refusal.IntentPreviewError("insufficientSourceBalance", void 0, "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,
@@ -42,8 +42,8 @@ async function previewOpenStrategy(props) {
 		accountDebt: 0n,
 		tokens: []
 	};
-	require_onchain_accounts_intents_math.assertDebtInBand(debt, suite.creditFacade, underlying);
-	require_onchain_accounts_intents_guards.assertCanBorrow(suite, debt);
+	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,
@@ -78,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,

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_refusal = require("./refusal.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,15 +25,9 @@ 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_refusal.IntentPreviewError("insufficientSourceBalance", {
-		required: {
-			token: U,
-			balance: -delta
-		},
-		held: {
-			token: U,
-			balance: 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)];
 }
@@ -40,11 +35,11 @@ function planAdjustLeverage(intent, view) {
 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_refusal.IntentPreviewError("unsupportedCollateralToken", { token: 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_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_refusal.IntentPreviewError("leverageOutOfRange", void 0, `deposit: target leverage ${intent.targetLeverage} would require repaying debt`);
-	require_onchain_accounts_intents_math.assertDebtInBand(view.debt + debtDelta, view.band, U);
+	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 [
@@ -71,24 +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_refusal.IntentPreviewError("unsupportedCollateralToken", { token: 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_accounts_intents_refusal.IntentPreviewError("debtOutOfRange", {
-		requested: {
-			token: U,
-			balance: view.debt
-		},
-		minDebt: {
-			token: U,
-			balance: view.band.minDebt
-		},
-		maxDebt: {
-			token: U,
-			balance: view.band.maxDebt
-		}
+	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, U);
+	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)],
@@ -144,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_refusal.IntentPreviewError("insufficientSourceBalance", void 0, `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,
@@ -156,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_refusal.IntentPreviewError("noDelayedRoute", { token: T }, `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",
@@ -182,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_refusal.IntentPreviewError("noDelayedRoute", void 0, "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_refusal.IntentPreviewError("noDelayedRoute", void 0, "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",
@@ -212,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_refusal.IntentPreviewError("noDelayedRoute", { token: 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_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),
@@ -304,7 +290,7 @@ function withdrawShape(intent, view) {
 		};
 	}
 	const WU = view.price(T, U, intent.amount);
-	if (WU <= 0n) throw new require_onchain_accounts_intents_refusal.IntentPreviewError("insufficientSourceBalance", void 0, `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 {
@@ -317,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, U);
+	require_onchain_accounts_intents_math.assertDebtInBand(view.sdk, view.debt - dD, view.band, view.underlying);
 	return {
 		U,
 		T,
@@ -334,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_refusal.IntentPreviewError("insufficientSourceBalance", void 0, "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, view.underlying);
+	require_onchain_accounts_intents_math.assertDebtInBand(view.sdk, target, view.band, view.underlying);
 	return {
 		U: view.underlying,
 		delta: target - view.debt
@@ -402,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_refusal.IntentPreviewError("insufficientSourceBalance", void 0, `${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_refusal.IntentPreviewError("insufficientSourceBalance", void 0, "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_refusal.IntentPreviewError("insufficientSourceBalance", void 0, `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_refusal.IntentPreviewError("insufficientSourceBalance", void 0, `${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,6 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_onchain_market_math = require("../../market/math.js");
-const require_onchain_accounts_intents_refusal = require("./refusal.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");
@@ -63,15 +64,9 @@ 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_refusal.IntentPreviewError("insufficientSourceBalance", {
-			required: {
-				token,
-				balance: amount
-			},
-			held: {
-				token,
-				balance: 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) {
@@ -85,7 +80,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,
@@ -157,7 +152,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_accounts_intents_refusal.IntentPreviewError("withdrawalInProgress", { inFlight: pending }, `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.probe) probes.push(leg.probe);
@@ -186,10 +181,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_refusal.IntentPreviewError("withdrawalInProgress", { inFlight: {
-				token: asset.withdrawalPhantomToken,
-				balance: ledger.balanceOf(asset.withdrawalPhantomToken)
-			} }, `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,
@@ -266,7 +258,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,
@@ -284,6 +276,7 @@ async function realize(steps, props) {
 	const projectedPool = { availableLiquidityChange: creditAccount.accountDebt - debt };
 	const metrics = {
 		healthFactor: sdk.positions.healthFactor(snapshot),
+		safeHealthFactor: paysOut ? sdk.positions.healthFactor(snapshot, { safePrices: true }) : void 0,
 		borrowRate: sdk.positions.borrowRate(snapshot, projectedPool),
 		timeToLiquidation: sdk.positions.timeToLiquidation(snapshot, projectedPool),
 		liquidationPrice: sdk.positions.liquidationPrice(snapshot)
@@ -321,11 +314,11 @@ async function realize(steps, props) {
 */
 async function delayedConfig(sdk, creditAccount, token) {
 	const compressor = sdk.withdrawalCompressor;
-	if (!compressor) throw new require_onchain_accounts_intents_refusal.IntentPreviewError("noDelayedRoute", { token }, "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_refusal.IntentPreviewError("noDelayedRoute", { token }, `request: ${token} has no delayed withdrawal config`);
-	if (assets.length > 1) throw new require_onchain_accounts_intents_refusal.IntentPreviewError("multipleDelayedWithdrawals", {
-		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`);
 	return assets[0];

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

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_onchain_accounts_intents_refusal = require("./refusal.js");
+const require_onchain_validation_refusal = require("../../validation/refusal.js");
 const require_onchain_accounts_intents_utils_router_path = require("./utils/router-path.js");
 const require_onchain_accounts_intents_plan = require("./plan.js");
 const require_onchain_accounts_intents_operations = require("./operations.js");
@@ -18,7 +18,7 @@ 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_accounts_intents_refusal.IntentPreviewError("insufficientSourceBalance", void 0, "finishIntent: the claim credits nothing to spend");
+		if (!output) throw new require_onchain_validation_refusal.IntentPreviewError("insufficientSourceBalance", void 0, "finishIntent: the claim credits nothing to spend");
 		return output;
 	};
 	switch (intent.type) {

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

@@ -297,6 +297,7 @@ function buildMockSdk(args) {
 				decimals: decimalsOf(token),
 				contractType: phantoms.has(token.toLowerCase()) ? "PHANTOM_TOKEN::SECURITIZE_RD" : void 0
 			}),
+			getToken: tokenOf,
 			mustGetToken: tokenOf,
 			rwaUnderlyings: { get: (token) => {
 				const asset = args.rwaAssets?.[token.toLowerCase()];

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

@@ -18,6 +18,7 @@ function accountView(creditAccount, sdk) {
 	for (const t of creditAccount.tokens) totalValue += price(t.token, underlying, t.balance);
 	return {
 		underlying,
+		sdk,
 		rwaAsset: sdk.tokensMeta.rwaUnderlyings.get(underlying)?.asset,
 		debt: creditAccount.accountDebt,
 		collateral: totalValue - creditAccount.accountDebt,

package/dist/cjs/onchain/constants/index.js

@@ -72,3 +72,4 @@ exports.botPermissionsToString = require_onchain_constants_bot_permissions.botPe
 exports.halfRAY = require_onchain_constants_math.halfRAY;
 exports.isV310 = require_onchain_constants_versions.isV310;
 exports.isVersionRange = require_onchain_constants_versions.isVersionRange;
+exports.isZeroBalance = require_onchain_constants_math.isZeroBalance;

package/dist/cjs/onchain/constants/math.js

@@ -21,6 +21,16 @@ const SLIPPAGE_DECIMALS = 100n;
 * Token balances at or below this threshold are treated as dust and ignored.
 **/
 const DUST_THRESHOLD = 10n;
+/**
+* Whether a balance is nothing worth acting on.
+*
+* The threshold is a dust floor, not a zero test: rounding leaves amounts that
+* are technically non-zero and worthless, and a form that offered to spend one
+* would build a transaction nobody wants.
+*/
+function isZeroBalance(balance) {
+	return (balance ?? 0n) <= DUST_THRESHOLD;
+}
 //#endregion
 exports.DUST_THRESHOLD = DUST_THRESHOLD;
 exports.LEVERAGE_DECIMALS = LEVERAGE_DECIMALS;
@@ -40,3 +50,4 @@ exports.SLIPPAGE_DECIMALS = SLIPPAGE_DECIMALS;
 exports.WAD = WAD;
 exports.WAD_DECIMALS_POW = WAD_DECIMALS_POW;
 exports.halfRAY = halfRAY;
+exports.isZeroBalance = isZeroBalance;