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

package/dist/esm/onchain/validation/checks.js

@@ -0,0 +1,230 @@
+//#region src/onchain/validation/checks.ts
+/**
+* Every verdict the protocol can pass on an operation, as values.
+*
+* Each check is handed the numbers it compares — never a suite, a market or an
+* SDK — so the engine, `checkOperation` and the strategy lists share one
+* implementation.
+*
+* Ladders stay with the caller because they differ deliberately: the engine
+* reports the tightest ceiling it found, the account-opening path the first one
+* exceeded in its own order.
+*/
+/** A factor at or below this is refused; kept for the callers that size on it. */
+const MIN_HF_LIMITED = 10100n;
+/** The same bar as a `required` argument — the lowest factor that passes. */
+const MIN_HEALTH_FACTOR_FORM = 10101;
+/** The bar the facade itself enforces: an account may end exactly at 1.0. */
+const MIN_HEALTH_FACTOR_FACADE = 1e4;
+/**
+* The safe-price bar a form holds an account to. A step above the facade's,
+* because a factor of exactly 1.0 at safe prices is already a refusal.
+*/
+const MIN_SAFE_HEALTH_FACTOR_FORM = 10001;
+/** A refusal names what a limit was measured in, never what it is worth. */
+function amountOf(token, value) {
+	return {
+		token,
+		value,
+		valueUsd: null
+	};
+}
+/** The credit manager takes no multicall while it is paused. */
+function checkCreditManagerPaused(args) {
+	if (!args.isPaused) return null;
+	return {
+		reason: "marketPaused",
+		detail: { creditManager: args.creditManager }
+	};
+}
+/** Past its expiration date the facade takes no more multicalls. */
+function checkMarketExpired(args) {
+	if (!args.isExpired) return null;
+	return {
+		reason: "marketExpired",
+		detail: {
+			creditManager: args.creditManager,
+			expirationDate: args.expirationDate
+		}
+	};
+}
+/** A paused pool neither takes deposits nor pays out. */
+function checkPoolPaused(args) {
+	return args.isPaused ? {
+		reason: "marketPaused",
+		detail: { pool: args.pool }
+	} : null;
+}
+/**
+* A pool winding down still pays out, so only what puts money in is refused.
+*/
+function checkPoolSunset(args) {
+	return args.isSunset && args.isDeposit ? {
+		reason: "poolSunset",
+		detail: { pool: args.pool }
+	} : null;
+}
+/**
+* What the pool will hand over, against what is asked for.
+*
+* `binding` and `available` are the caller's answer to "which ceiling stands in
+* the way", not this check's: see the ladder note above. `solutionAmount` is
+* the largest position still openable, left out when none is.
+*/
+function checkBorrowLimit(args) {
+	if (args.requested <= args.available) return null;
+	return {
+		reason: "insufficientPoolLiquidity",
+		detail: {
+			requested: amountOf(args.underlying, args.requested),
+			available: amountOf(args.underlying, args.available),
+			binding: args.binding,
+			...args.solutionAmount === void 0 ? {} : { solutionAmount: amountOf(args.underlying, args.solutionAmount) }
+		}
+	};
+}
+/**
+* What the pool can pay out, against what is being taken out.
+*
+* The operator is not `checkBorrowLimit`'s: a pool holding exactly the amount
+* asked for still cannot serve it, so equality is already a refusal. That is
+* the rule the legacy withdrawal validator enforced and it is preserved to the
+* unit.
+*/
+function checkPoolPayout(args) {
+	if (args.requested < args.available) return null;
+	return {
+		reason: "insufficientPoolLiquidity",
+		detail: {
+			requested: amountOf(args.underlying, args.requested),
+			available: amountOf(args.underlying, args.available),
+			binding: "poolAvailableLiquidity"
+		}
+	};
+}
+/**
+* A debt the facade would revert on.
+*
+* `allowZero` is the one place the two callers genuinely disagree: an account
+* being adjusted may end owing nothing, while one being opened may not — so the
+* exemption is stated rather than assumed.
+*/
+function checkDebtInBand(args) {
+	const { debt, minDebt, maxDebt, underlying, allowZero } = args;
+	if (!(debt > maxDebt || debt < minDebt && !(allowZero && debt === 0n))) return null;
+	return {
+		reason: "debtOutOfRange",
+		detail: {
+			requested: amountOf(underlying, debt),
+			minDebt: amountOf(underlying, minDebt),
+			maxDebt: amountOf(underlying, maxDebt)
+		}
+	};
+}
+/** Leverage below 1x is not a position, it is a withdrawal. */
+function checkLeverageAtLeastOne(args) {
+	return args.leverage < args.min ? {
+		reason: "leverageOutOfRange",
+		detail: {
+			requested: args.leverage,
+			min: args.min
+		}
+	} : null;
+}
+/**
+* The account against its debt, at whichever bar the caller holds it to.
+*
+* An unread factor counts as failing: a check that cannot see the number is not
+* evidence that the number is fine.
+*/
+function checkCollateralised(args) {
+	const { healthFactor, required, safePrices, improvesFrom } = args;
+	if (healthFactor === void 0) return {
+		reason: "insufficientCollateral",
+		detail: {
+			healthFactor: 0,
+			required,
+			safePrices
+		}
+	};
+	if (healthFactor >= required || improvesFrom !== void 0 && healthFactor > improvesFrom) return null;
+	return {
+		reason: "insufficientCollateral",
+		detail: {
+			healthFactor,
+			required,
+			safePrices
+		}
+	};
+}
+/** A token the market will not let the account hold. */
+function checkForbiddenToken(args) {
+	return args.isForbidden ? {
+		reason: "forbiddenToken",
+		detail: { token: args.token }
+	} : null;
+}
+/**
+* The room the keeper still has for a token's quota, in the underlying.
+*
+* `requested` is absent for a token the market opened no quota for at all —
+* nothing was weighed against a limit, the token simply counts as no collateral.
+*/
+function checkQuotaLimit(args) {
+	const { token, requested, available, underlying } = args;
+	if (requested !== void 0 && requested <= available) return null;
+	return {
+		reason: "quotaLimitReached",
+		detail: {
+			token,
+			requested: requested === void 0 ? void 0 : amountOf(underlying, requested),
+			available: amountOf(underlying, available)
+		}
+	};
+}
+/** How many quoted tokens the facade enables at once. */
+function checkQuotaCount(args) {
+	return args.count > args.max ? {
+		reason: "quotaCountExceeded",
+		detail: {
+			count: args.count,
+			max: args.max
+		}
+	} : null;
+}
+/** What the operation is funded from, against what is there. */
+function checkFunding(args) {
+	const { token, required, held } = args;
+	if (required <= held) return null;
+	return {
+		reason: "insufficientSourceBalance",
+		detail: {
+			required: amountOf(token, required),
+			held: amountOf(token, held)
+		}
+	};
+}
+/**
+* The SDK could not replay the transaction.
+*
+* Only the 1xxx class lands here. A 2xxx error says the transaction is fine and
+* the SDK could not fully evaluate it, which is a caveat on the numbers rather
+* than a reason to refuse — it stays on the preview for the caller to surface.
+*/
+function checkPreviewError(error) {
+	if (!error || !isMalformedPreviewError(error)) return null;
+	return {
+		reason: "malformedTransaction",
+		detail: error
+	};
+}
+/**
+* The class boundary the preview error codes are written against: 1xxx means
+* the transaction itself is malformed, 2xxx that only the evaluation was
+* incomplete. A range, so a future 1007 classifies itself.
+*/
+function isMalformedPreviewError(error) {
+	return error.code >= 1e3 && error.code < 2e3;
+}
+//#endregion
+export { MIN_HEALTH_FACTOR_FACADE, MIN_HEALTH_FACTOR_FORM, MIN_HF_LIMITED, MIN_SAFE_HEALTH_FACTOR_FORM, amountOf, checkBorrowLimit, checkCollateralised, checkCreditManagerPaused, checkDebtInBand, checkForbiddenToken, checkFunding, checkLeverageAtLeastOne, checkMarketExpired, checkPoolPaused, checkPoolPayout, checkPoolSunset, checkPreviewError, checkQuotaCount, checkQuotaLimit, isMalformedPreviewError };

package/dist/esm/onchain/validation/index.js

@@ -0,0 +1,4 @@
+import { MIN_HEALTH_FACTOR_FACADE, MIN_HEALTH_FACTOR_FORM, MIN_HF_LIMITED, MIN_SAFE_HEALTH_FACTOR_FORM, amountOf, checkBorrowLimit, checkCollateralised, checkCreditManagerPaused, checkDebtInBand, checkForbiddenToken, checkFunding, checkLeverageAtLeastOne, checkMarketExpired, checkPoolPaused, checkPoolPayout, checkPoolSunset, checkPreviewError, checkQuotaCount, checkQuotaLimit, isMalformedPreviewError } from "./checks.js";
+import { IntentPreviewError, raise, refuse } from "./refusal.js";
+import { toToken, toTokenAmount } from "./token.js";
+export { IntentPreviewError, MIN_HEALTH_FACTOR_FACADE, MIN_HEALTH_FACTOR_FORM, MIN_HF_LIMITED, MIN_SAFE_HEALTH_FACTOR_FORM, amountOf, checkBorrowLimit, checkCollateralised, checkCreditManagerPaused, checkDebtInBand, checkForbiddenToken, checkFunding, checkLeverageAtLeastOne, checkMarketExpired, checkPoolPaused, checkPoolPayout, checkPoolSunset, checkPreviewError, checkQuotaCount, checkQuotaLimit, isMalformedPreviewError, raise, refuse, toToken, toTokenAmount };

package/dist/esm/onchain/{accounts/intents → validation}/refusal.js

@@ -1,4 +1,4 @@
-//#region src/onchain/accounts/intents/refusal.ts
+//#region src/onchain/validation/refusal.ts
 /** Builds the refusal a caller sees. */
 function refuse(reason, detail) {
 	return {
@@ -22,5 +22,15 @@ var IntentPreviewError = class extends Error {
 		this.detail = detail;
 	}
 };
+/**
+* Throws the issue a check found, with the sentence the engine logs for it.
+*
+* Returns normally when there is nothing to raise, so it cannot narrow a type
+* the way a bare `throw` does — a site that guards a value for the code below
+* it keeps throwing directly.
+*/
+function raise(issue, message) {
+	if (issue) throw new IntentPreviewError(issue.reason, issue.detail, message);
+}
 //#endregion
-export { IntentPreviewError, refuse };
+export { IntentPreviewError, raise, refuse };

package/dist/esm/onchain/validation/token.js

@@ -0,0 +1,27 @@
+import { shortAddress } from "../utils/formatter.js";
+import { amountOf } from "./checks.js";
+//#region src/onchain/validation/token.ts
+/**
+* The token behind an address, for the refusal details that inline one.
+*
+* A token the registry does not know falls back to its own shortened address
+* as a symbol and `decimals: 0` — an unknown token has no scale, and guessing
+* 18 would silently misformat every amount denominated in it.
+*/
+function toToken(sdk, address) {
+	const known = sdk.tokensMeta.getToken(address);
+	if (known) return known;
+	return {
+		chainId: sdk.chainId,
+		address,
+		symbol: shortAddress(address),
+		name: "",
+		decimals: 0
+	};
+}
+/** {@link toToken} plus an amount denominated in it. */
+function toTokenAmount(sdk, address, value) {
+	return amountOf(toToken(sdk, address), value);
+}
+//#endregion
+export { toToken, toTokenAmount };

package/dist/esm/preview/index.js

@@ -1,4 +1,5 @@
 import { UnsupportedZapperFunctionError } from "../onchain/market/zapper/errors.js";
+import { IntentPreviewError, raise, refuse } from "../onchain/validation/refusal.js";
 import { TransferAlignmentError, UnexpectedFacadeEventOrderError, UnknownAdapterError, UnknownFacadeCallError, WithdrawCollateralAlignmentError } from "./trace/errors.js";
 import { extractAdapterCallTraces } from "./trace/extractAdapterCallTraces.js";
 import { extractTransfers } from "./trace/extractTransfers.js";
@@ -31,4 +32,7 @@ import { previewCloseOrRepayCreditAccount } from "./preview/previewCloseOrRepayC
 import { previewOperation } from "./preview/previewOperation.js";
 import "./preview/index.js";
 import "./types.js";
-export { AllowancePrerequisite, BalancePrerequisite, CreditAccountState, Prerequisite, RWAOpenRequirementsPrerequisite, TransferAlignmentError, UnexpectedFacadeEventOrderError, UnknownAdapterError, UnknownFacadeCallError, UnsupportedOperationError, UnsupportedPoolFunctionError, UnsupportedTargetError, UnsupportedZapperFunctionError, WithdrawCollateralAlignmentError, buildDelayedPreview, checkPrerequisites, classifyCloseOrRepay, classifyInnerOperations, detectDelayedClaim, detectDelayedOperation, extractAdapterCallTraces, extractTransfers, findFacadeCalls, isCloseOrRepay, isPoolOperation, isRWAOperation, makeReplayState, parseFacadeOperationCalldata, parseOperationCalldata, parsePoolOperationCalldata, parseRWAFactoryOperationCalldata, previewAdjustCreditAccount, previewCloseOrRepayCreditAccount, previewOperation, replayInnerOperations, replayMulticall, resolveDelayedClaimIntent };
+import { checkOperation, collateralIssuesOf } from "./validate/checkOperation.js";
+import { checkSimulation } from "./validate/checkSimulation.js";
+import "./validate/index.js";
+export { AllowancePrerequisite, BalancePrerequisite, CreditAccountState, IntentPreviewError, Prerequisite, RWAOpenRequirementsPrerequisite, TransferAlignmentError, UnexpectedFacadeEventOrderError, UnknownAdapterError, UnknownFacadeCallError, UnsupportedOperationError, UnsupportedPoolFunctionError, UnsupportedTargetError, UnsupportedZapperFunctionError, WithdrawCollateralAlignmentError, buildDelayedPreview, checkOperation, checkPrerequisites, checkSimulation, classifyCloseOrRepay, classifyInnerOperations, collateralIssuesOf, detectDelayedClaim, detectDelayedOperation, extractAdapterCallTraces, extractTransfers, findFacadeCalls, isCloseOrRepay, isPoolOperation, isRWAOperation, makeReplayState, parseFacadeOperationCalldata, parseOperationCalldata, parsePoolOperationCalldata, parseRWAFactoryOperationCalldata, previewAdjustCreditAccount, previewCloseOrRepayCreditAccount, previewOperation, raise, refuse, replayInnerOperations, replayMulticall, resolveDelayedClaimIntent };

package/dist/esm/preview/preview/buildDelayedPreview.js

@@ -203,6 +203,7 @@ function buildAdjustPreview(post, before, collateralWithdrawn, converter, sdk) {
 		assetsChange: post.balances.difference(before.balances).toAssets(DUST_THRESHOLD).map((a) => oracle.toTokenAmount(a.token, a.balance)),
 		error: converter.error,
 		healthFactor: sdk.positions.healthFactor(snap),
+		safeHealthFactor: sdk.positions.healthFactor(snap, { safePrices: true }),
 		borrowRate: sdk.positions.borrowRate(snap, { availableLiquidityChange: before.totalDebt - post.totalDebt }),
 		timeToLiquidation: sdk.positions.timeToLiquidation(snap, { availableLiquidityChange: before.totalDebt - post.totalDebt }),
 		liquidationPrice: sdk.positions.liquidationPrice(snap),

package/dist/esm/preview/preview/previewAdjustCreditAccount.js

@@ -60,6 +60,7 @@ async function previewAdjustCreditAccount(input, operation, options) {
 		assetsChange: assetsChange.map((a) => oracle.toTokenAmount(a.token, a.balance)),
 		error,
 		healthFactor: sdk.positions.healthFactor(snap),
+		safeHealthFactor: sdk.positions.healthFactor(snap, { safePrices: true }),
 		borrowRate: sdk.positions.borrowRate(snap, { availableLiquidityChange: before.totalDebt - account.totalDebt }),
 		timeToLiquidation: sdk.positions.timeToLiquidation(snap, { availableLiquidityChange: before.totalDebt - account.totalDebt }),
 		liquidationPrice: sdk.positions.liquidationPrice(snap),

package/dist/esm/preview/preview/previewOpenCreditAccount.js

@@ -50,6 +50,7 @@ async function previewOpenCreditAccount(input, operation) {
 		assets: assets.map((a) => oracle.toTokenAmount(a.token, a.balance)),
 		error,
 		healthFactor: sdk.positions.healthFactor(snap),
+		safeHealthFactor: sdk.positions.healthFactor(snap, { safePrices: true }),
 		borrowRate: sdk.positions.borrowRate(snap, { availableLiquidityChange: -account.totalDebt }),
 		timeToLiquidation: sdk.positions.timeToLiquidation(snap, { availableLiquidityChange: -account.totalDebt }),
 		liquidationPrice: sdk.positions.liquidationPrice(snap),

package/dist/esm/preview/simulate/simulatePoolOperation.js

@@ -1,5 +1,5 @@
-import { iPoolV310Abi } from "../../abi/310/generated.js";
 import { iZapperAbi } from "../../abi/iZapper.js";
+import { iPoolV310Abi } from "../../abi/310/generated.js";
 import { asPreviewSimulationError } from "./errors.js";
 //#region src/preview/simulate/simulatePoolOperation.ts
 function previewRead(operation) {

package/dist/esm/preview/trace/extractTransfers.js

@@ -1,6 +1,6 @@
+import { ierc20Abi } from "../../abi/iERC20.js";
 import { iCreditFacadeV310Abi } from "../../abi/310/generated.js";
 import { AddressMap } from "../../onchain/utils/AddressMap.js";
-import { ierc20Abi } from "../../abi/iERC20.js";
 import "../../onchain/index.js";
 import { UnexpectedFacadeEventOrderError } from "./errors.js";
 import { getAddress, isAddressEqual, parseEventLogs } from "viem";

package/dist/esm/preview/validate/checkOperation.js

@@ -0,0 +1,171 @@
+import { checkBorrowLimit, checkCollateralised, checkCreditManagerPaused, checkDebtInBand, checkForbiddenToken, checkFunding, checkMarketExpired, checkPoolPaused, checkPoolPayout, checkPoolSunset, checkPreviewError, checkQuotaCount, checkQuotaLimit } from "../../onchain/validation/checks.js";
+import { toToken } from "../../onchain/validation/token.js";
+import { borrowable } from "../../onchain/accounts/intents/guards.js";
+import "../../onchain/index.js";
+import { isAddressEqual } from "viem";
+//#region src/preview/validate/checkOperation.ts
+/**
+* Whether a parsed operation may be signed at all — the protocol state that
+* `checkPrerequisites` leaves out, since that one covers only what the sender
+* can fix themselves.
+*
+* Synchronous: the preview carries the numbers and the market is attached.
+* Reports the most fundamental issue it finds and stops there, which is the one
+* a caller acts on.
+*/
+function checkOperation(input, options = {}) {
+	const { sdk, preview } = input;
+	const malformed = checkPreviewError("error" in preview ? preview.error : void 0);
+	if (malformed) return malformed;
+	switch (preview.operation) {
+		case "Deposit":
+		case "Mint": return poolIssues(sdk, preview, options, true);
+		case "Withdraw":
+		case "Redeem": return poolIssues(sdk, preview, options, false);
+		case "DelayedCreditAccountOperation": return checkOperation({
+			sdk,
+			preview: preview.instantPreview
+		}, options);
+		case "OpenCreditAccount":
+		case "RWAOpenCreditAccount":
+		case "AdjustCreditAccount": return creditIssues(sdk, preview, options);
+		case "CloseCreditAccount":
+		case "RepayCreditAccount": return marketIssues(sdk, preview.creditManager);
+	}
+}
+function poolIssues(sdk, preview, options, isDeposit) {
+	const market = sdk.marketRegister.findByPool(preview.pool);
+	return checkPoolPaused({
+		isPaused: market.pool.pool.isPaused,
+		pool: preview.pool
+	}) || checkPoolSunset({
+		isSunset: market.sunset,
+		isDeposit,
+		pool: preview.pool
+	}) || (isDeposit ? null : checkPoolPayout({
+		requested: preview.tokenOut.value,
+		available: market.pool.pool.availableLiquidity,
+		underlying: preview.tokenOut.token
+	})) || fundingIssue(options, [preview.tokenIn]);
+}
+/** What the market itself refuses, whatever the operation does. */
+function marketIssues(sdk, creditManager) {
+	const suite = sdk.marketRegister.findCreditManager(creditManager);
+	return checkCreditManagerPaused({
+		isPaused: suite.isPaused,
+		creditManager
+	}) || checkMarketExpired({
+		isExpired: suite.isExpired,
+		creditManager,
+		expirationDate: suite.creditFacade.expirationDate
+	});
+}
+function creditIssues(sdk, preview, options) {
+	const suite = sdk.marketRegister.findCreditManager(preview.creditManager);
+	const market = suite.market;
+	const underlying = toToken(sdk, market.pool.underlying);
+	const isOpening = preview.operation === "OpenCreditAccount" || preview.operation === "RWAOpenCreditAccount";
+	return marketIssues(sdk, preview.creditManager) || checkDebtInBand({
+		debt: preview.debt,
+		minDebt: suite.creditFacade.minDebt,
+		maxDebt: suite.creditFacade.maxDebt,
+		underlying,
+		allowZero: !isOpening
+	}) || borrowIssue(suite, preview, underlying) || forbiddenIssue(suite, preview) || checkQuotaCount({
+		count: preview.quotas.filter((q) => q.value > 0n).length,
+		max: suite.creditManager.maxEnabledTokens
+	}) || quotaIssue(market, preview, underlying) || (preview.debt === 0n ? null : collateralIssue(preview, options)) || fundingIssue(options, collateralOf(preview));
+}
+/**
+* What the transaction draws, against what the market can lend right now.
+*
+* Only a draw is weighed: repaying, or leaving the debt alone, can never exceed
+* a ceiling. Opening borrows the whole debt; adjusting borrows `debtChange`.
+*
+* The engine holds every simulation to this already (`assertCanBorrow`), so
+* this is here for the transactions it never saw — a pasted calldata reaches
+* the confirm screen with nothing else standing between it and a revert.
+*/
+function borrowIssue(suite, preview, underlying) {
+	const drawn = preview.operation === "AdjustCreditAccount" ? preview.debtChange : preview.debt;
+	if (drawn <= 0n) return null;
+	const { limit, binding } = borrowable(suite);
+	return checkBorrowLimit({
+		requested: drawn,
+		available: limit,
+		binding,
+		underlying
+	});
+}
+/** The account against whichever bars the caller holds it to. */
+function collateralIssue(preview, options) {
+	return collateralIssuesOf({
+		healthFactor: preview.healthFactor,
+		safeHealthFactor: preview.safeHealthFactor
+	}, options);
+}
+/** The wallet's side of the operation, against the balances it was given. */
+function fundingIssue(options, puts) {
+	const { balances } = options;
+	if (!balances) return null;
+	for (const { token, value } of puts) {
+		const issue = checkFunding({
+			token,
+			required: value,
+			held: balances.get(token.address) ?? 0n
+		});
+		if (issue) return issue;
+	}
+	return null;
+}
+/** What the wallet puts in, which is what its balances have to cover. */
+function collateralOf(preview) {
+	if ("collateral" in preview) return preview.collateral;
+	if ("collateralAdded" in preview) return preview.collateralAdded;
+	return [];
+}
+function forbiddenIssue(suite, preview) {
+	const obtained = preview.operation === "AdjustCreditAccount" ? preview.assetsChange : preview.assets;
+	const forbidden = suite.forbiddenTokens;
+	for (const asset of obtained) {
+		if (asset.value <= 0n) continue;
+		const issue = checkForbiddenToken({
+			token: asset.token,
+			isForbidden: forbidden.some((f) => isAddressEqual(f, asset.token.address))
+		});
+		if (issue) return issue;
+	}
+	return null;
+}
+function quotaIssue(market, preview, underlying) {
+	const increases = preview.operation === "AdjustCreditAccount" ? preview.quotasChange : preview.quotas;
+	const { pqk } = market.pool;
+	for (const q of increases) {
+		if (q.value <= 0n) continue;
+		const quota = pqk.hasActiveQuota(q.token.address) ? pqk.quotas.get(q.token.address) : void 0;
+		const issue = checkQuotaLimit({
+			token: q.token,
+			requested: quota ? q.value : void 0,
+			available: (quota?.limit ?? 0n) - (quota?.totalQuoted ?? 0n),
+			underlying
+		});
+		if (issue) return issue;
+	}
+	return null;
+}
+/** The two collateral bars, shared by the preview and the simulation paths. */
+function collateralIssuesOf(factors, options) {
+	const { minHealthFactor, minSafeHealthFactor, currentHealthFactor } = options;
+	return (minHealthFactor === void 0 ? null : checkCollateralised({
+		healthFactor: factors.healthFactor,
+		required: minHealthFactor,
+		safePrices: false,
+		improvesFrom: currentHealthFactor
+	})) || (minSafeHealthFactor === void 0 || factors.safeHealthFactor === void 0 ? null : checkCollateralised({
+		healthFactor: factors.safeHealthFactor,
+		required: minSafeHealthFactor,
+		safePrices: true
+	}));
+}
+//#endregion
+export { checkOperation, collateralIssuesOf };

package/dist/esm/preview/validate/checkSimulation.js

@@ -0,0 +1,51 @@
+import { checkCreditManagerPaused, checkDebtInBand, checkMarketExpired, checkQuotaCount } from "../../onchain/validation/checks.js";
+import { toToken } from "../../onchain/validation/token.js";
+import "../../onchain/index.js";
+import { collateralIssuesOf } from "./checkOperation.js";
+//#region src/preview/validate/checkSimulation.ts
+/**
+* Whether a simulated operation clears the caller's own bars.
+*
+* The engine holds an account to the facade's `1.0`, because its guards answer
+* "would this revert". A form is wiser to ask for more, and the engine's own
+* note says so — a caller wanting the stricter bar applies it itself. This is
+* that second opinion, over the numbers the engine already reported.
+*
+* Three of the checks below the engine does not make at all: both health-factor
+* bars are its own `1.0`, and the quota count it never weighs. The other two run
+* against the same numbers the engine used, and are here so that a change in the
+* engine cannot pass silently.
+*
+* What is deliberately absent: the forbidden-token, quota-limit and funding
+* checks all need the *delta* an operation applies, and `OperationState` reports
+* only the state after it. Weighing them against absolutes would refuse a
+* forbidden token the account merely holds, or a quota the operation never
+* touched. The engine performed all three during the walk, so a simulation that
+* came back `ok` has already passed them.
+*/
+function checkSimulation(input, options = {}) {
+	const { sdk, state, creditManager } = input;
+	const suite = sdk.marketRegister.findCreditManager(creditManager);
+	return checkCreditManagerPaused({
+		isPaused: suite.isPaused,
+		creditManager
+	}) || checkMarketExpired({
+		isExpired: suite.isExpired,
+		creditManager,
+		expirationDate: suite.creditFacade.expirationDate
+	}) || checkDebtInBand({
+		debt: state.accountDebt,
+		minDebt: suite.creditFacade.minDebt,
+		maxDebt: suite.creditFacade.maxDebt,
+		underlying: toToken(sdk, suite.market.pool.underlying),
+		allowZero: true
+	}) || checkQuotaCount({
+		count: Object.values(state.quotas).filter((q) => q.balance > 0n).length,
+		max: suite.creditManager.maxEnabledTokens
+	}) || (state.accountDebt === 0n ? null : collateralIssuesOf({
+		healthFactor: state.healthFactor,
+		safeHealthFactor: state.safeHealthFactor
+	}, options));
+}
+//#endregion
+export { checkSimulation };

package/dist/esm/preview/validate/index.js

@@ -0,0 +1,3 @@
+import { checkOperation, collateralIssuesOf } from "./checkOperation.js";
+import { checkSimulation } from "./checkSimulation.js";
+export { checkOperation, checkSimulation, collateralIssuesOf };

package/dist/esm/sdk/index.js

@@ -1,3 +1,4 @@
+import { IntentPreviewError, raise, refuse } from "../onchain/validation/refusal.js";
 import { AllSourcesFailedError } from "./errors/AllSourcesFailedError.js";
 import { SourceChainMismatchError } from "./errors/SourceChainMismatchError.js";
 import { assertSameChains } from "./errors/assertSameChains.js";
@@ -24,4 +25,4 @@ import { PreviewNamespace } from "./preview/PreviewNamespace.js";
 import "./preview/index.js";
 import { DEFAULT_MAX_STATE_AGE, GearboxSDK } from "./GearboxSDK.js";
 import "./types.js";
-export { AbstractNamespace, AllSourcesFailedError, DEFAULT_MAX_OFFCHAIN_LAG, DEFAULT_MAX_STATE_AGE, ExecuteApi, GearboxSDK, LiquidationsNamespace, MissingSourceError, NoSourceServedError, OpportunitiesNamespace, PositionsNamespace, PrepareApi, PreviewNamespace, SourceChainMismatchError, SourceUnavailableError, assertSameChains, everyChainFailed, filterResponse, mergeChainList, mergeChainOne };
+export { AbstractNamespace, AllSourcesFailedError, DEFAULT_MAX_OFFCHAIN_LAG, DEFAULT_MAX_STATE_AGE, ExecuteApi, GearboxSDK, IntentPreviewError, LiquidationsNamespace, MissingSourceError, NoSourceServedError, OpportunitiesNamespace, PositionsNamespace, PrepareApi, PreviewNamespace, SourceChainMismatchError, SourceUnavailableError, assertSameChains, everyChainFailed, filterResponse, mergeChainList, mergeChainOne, raise, refuse };