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

package/dist/esm/onchain/validation/bundles/checkRWAOpenRequirements.js

@@ -0,0 +1,32 @@
+import { rwaOpenRequirementsNotMet } from "../../../model/errors/operation-errors.js";
+import { unexpectedFailure } from "../../../model/errors/prepare-errors.js";
+import "../../../model/index.js";
+import { toToken } from "../helpers/token.js";
+import "../helpers/index.js";
+//#region src/onchain/validation/bundles/checkRWAOpenRequirements.ts
+/**
+* The RWA factory is satisfied that `wallet` may open on `token` with the
+* registration args already on the transaction.
+*/
+async function checkRWAOpenRequirements(input) {
+	const { sdk, wallet, creditManager, token, providedArgs } = input;
+	try {
+		const requirements = await sdk.accounts.getOpenAccountRequirements(wallet, creditManager, { tokenOutAddress: token });
+		if (!requirements) return [];
+		const { rwaFactory } = sdk.marketRegister.findByCreditManager(creditManager);
+		if (!rwaFactory) throw new Error(`no RWA factory for credit manager ${creditManager}`);
+		const missing = rwaFactory.getMissingRequirements(requirements, providedArgs);
+		if (!missing && requirements.securitizeTokensToRegister.length === 0) return [];
+		return [rwaOpenRequirementsNotMet({
+			token: toToken(sdk, token),
+			creditManager,
+			factory: rwaFactory.address,
+			requirements,
+			...missing === void 0 ? {} : { missing }
+		})];
+	} catch (cause) {
+		return [unexpectedFailure(cause, "read the RWA opening requirements")];
+	}
+}
+//#endregion
+export { checkRWAOpenRequirements };

package/dist/esm/onchain/validation/bundles/checkRWAOpening.js

@@ -0,0 +1,23 @@
+import { AddressSet } from "../../utils/AddressSet.js";
+import { checkRWAOpenRequirements } from "./checkRWAOpenRequirements.js";
+//#region src/onchain/validation/bundles/checkRWAOpening.ts
+/**
+* Per factory-gated token among `collateralAdded ∪ quotas`, whether the
+* borrower still has to register or sign before this opening can land.
+*/
+async function checkRWAOpening(input) {
+	const { sdk, preview, sender } = input;
+	const { rwaFactory } = sdk.marketRegister.findByCreditManager(preview.creditManager);
+	if (!rwaFactory) return [];
+	const gated = new AddressSet(rwaFactory.getTokens());
+	const candidates = new AddressSet([...preview.collateralAdded.map((a) => a.token.address), ...preview.quotas.map((q) => q.token.address)]);
+	return (await Promise.all([...candidates].filter((token) => gated.has(token)).map((token) => checkRWAOpenRequirements({
+		sdk,
+		wallet: sender,
+		creditManager: preview.creditManager,
+		token,
+		providedArgs: preview.rwaArgs
+	})))).flat();
+}
+//#endregion
+export { checkRWAOpening };

package/dist/esm/onchain/validation/bundles/checkWallet.js

@@ -0,0 +1,21 @@
+import "../../constants/addresses.js";
+import "../../constants/index.js";
+import { checkWalletAllowance } from "./checkWalletAllowance.js";
+import { checkWalletBalance } from "./checkWalletBalance.js";
+import { isAddressEqual } from "viem";
+//#region src/onchain/validation/bundles/checkWallet.ts
+/**
+* The wallet's whole side for one token: always the balance; the allowance
+* only when it can matter (an ERC-20, with a spender who is not the holder).
+*/
+async function checkWallet(input) {
+	const { spender, ...rest } = input;
+	const needsAllowance = spender !== void 0 && !isAddressEqual(rest.token, "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE") && !isAddressEqual(spender, rest.holder);
+	return (await Promise.all([checkWalletBalance(rest), needsAllowance ? checkWalletAllowance({
+		...rest,
+		owner: rest.holder,
+		spender
+	}) : []])).flat();
+}
+//#endregion
+export { checkWallet };

package/dist/esm/onchain/validation/bundles/checkWalletAllowance.js

@@ -0,0 +1,31 @@
+import { ierc20Abi } from "../../../abi/iERC20.js";
+import { insufficientAllowance } from "../../../model/errors/operation-errors.js";
+import { unexpectedFailure } from "../../../model/errors/prepare-errors.js";
+import "../../../model/index.js";
+import { toToken, toTokenAmount } from "../helpers/token.js";
+import "../helpers/index.js";
+//#region src/onchain/validation/bundles/checkWalletAllowance.ts
+/** `owner` has approved `spender` for at least `required` of `token`. */
+async function checkWalletAllowance(input) {
+	const { sdk, token, owner, spender, required, blockNumber } = input;
+	try {
+		const allowed = await sdk.client.readContract({
+			address: token,
+			abi: ierc20Abi,
+			functionName: "allowance",
+			args: [owner, spender],
+			blockNumber
+		});
+		return allowed >= required ? [] : [insufficientAllowance({
+			owner,
+			spender,
+			required: toTokenAmount(sdk, token, required),
+			allowed: toTokenAmount(sdk, token, allowed)
+		})];
+	} catch (cause) {
+		const { symbol } = toToken(sdk, token);
+		return [unexpectedFailure(cause, `read the ${symbol} allowance`)];
+	}
+}
+//#endregion
+export { checkWalletAllowance };

package/dist/esm/onchain/validation/bundles/checkWalletBalance.js

@@ -0,0 +1,40 @@
+import { ierc20Abi } from "../../../abi/iERC20.js";
+import "../../constants/addresses.js";
+import "../../constants/index.js";
+import { insufficientBalance } from "../../../model/errors/operation-errors.js";
+import { unexpectedFailure } from "../../../model/errors/prepare-errors.js";
+import "../../../model/index.js";
+import { amountOf } from "../helpers/amount.js";
+import { toToken } from "../helpers/token.js";
+import "../helpers/index.js";
+import { isAddressEqual } from "viem";
+//#region src/onchain/validation/bundles/checkWalletBalance.ts
+/** `holder` holds at least `required` of `token` (ERC-20 or native). */
+async function checkWalletBalance(input) {
+	const { sdk, token, holder, required, blockNumber } = input;
+	try {
+		const held = isAddressEqual(token, "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE") ? await sdk.client.getBalance({
+			address: holder,
+			blockNumber
+		}) : await sdk.client.readContract({
+			address: token,
+			abi: ierc20Abi,
+			functionName: "balanceOf",
+			args: [holder],
+			blockNumber
+		});
+		if (required <= held) return [];
+		const meta = toToken(sdk, token);
+		return [insufficientBalance({
+			required: amountOf(meta, required),
+			held: amountOf(meta, held),
+			holderKind: "wallet",
+			holder
+		})];
+	} catch (cause) {
+		const { symbol } = toToken(sdk, token);
+		return [unexpectedFailure(cause, `read the ${symbol} balance`)];
+	}
+}
+//#endregion
+export { checkWalletBalance };

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

@@ -0,0 +1,18 @@
+import { checkAccountQuotas } from "./checkAccountQuotas.js";
+import { checkWalletAllowance } from "./checkWalletAllowance.js";
+import { checkWalletBalance } from "./checkWalletBalance.js";
+import { checkCollateralFunding } from "./checkCollateralFunding.js";
+import { checkDraw } from "./checkDraw.js";
+import { checkHealthFactors } from "./checkHealthFactors.js";
+import { checkMarket } from "./checkMarket.js";
+import { checkObtained } from "./checkObtained.js";
+import { checkQuotasAsked } from "./checkQuotasAsked.js";
+import { checkRWAOpenRequirements } from "./checkRWAOpenRequirements.js";
+import { checkRWAOpening } from "./checkRWAOpening.js";
+import { checkCreditOperation } from "./checkCreditOperation.js";
+import { checkLiquidationEligibility } from "./checkLiquidationEligibility.js";
+import { checkLiquidationFunding } from "./checkLiquidationFunding.js";
+import { checkWallet } from "./checkWallet.js";
+import { checkPoolFunding } from "./checkPoolFunding.js";
+import { checkPoolOperation } from "./checkPoolOperation.js";
+export { checkAccountQuotas, checkCollateralFunding, checkCreditOperation, checkDraw, checkHealthFactors, checkLiquidationEligibility, checkLiquidationFunding, checkMarket, checkObtained, checkPoolFunding, checkPoolOperation, checkQuotasAsked, checkRWAOpenRequirements, checkRWAOpening, checkWallet, checkWalletAllowance, checkWalletBalance };

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

@@ -0,0 +1,21 @@
+import { checkLiquidationEligibility } from "./bundles/checkLiquidationEligibility.js";
+import { checkLiquidationFunding } from "./bundles/checkLiquidationFunding.js";
+//#region src/onchain/validation/checkLiquidation.ts
+/**
+* Whether `liquidator` may send a full liquidation of this account
+*/
+async function checkLiquidation(sdk, input, options = {}) {
+	const { details, liquidator } = input;
+	return [...checkLiquidationEligibility({
+		sdk,
+		details,
+		liquidator
+	}), ...await checkLiquidationFunding({
+		sdk,
+		details,
+		liquidator,
+		blockNumber: options.blockNumber
+	})];
+}
+//#endregion
+export { checkLiquidation };

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

@@ -0,0 +1,61 @@
+import { checkCollateralFunding } from "./bundles/checkCollateralFunding.js";
+import { checkMarket } from "./bundles/checkMarket.js";
+import { checkCreditOperation } from "./bundles/checkCreditOperation.js";
+import { checkPoolFunding } from "./bundles/checkPoolFunding.js";
+import { checkPoolOperation } from "./bundles/checkPoolOperation.js";
+//#region src/onchain/validation/checkOperation.ts
+/**
+* Whether a parsed operation may be signed by `sender`: protocol state first,
+* then what the wallet has to approve, hold or sign.
+*
+* The array is in check order, most fundamental first, so a caller with room
+* for one verdict reports the first entry. Approve and sign errors are picked
+* out by `code`, not by position.
+*/
+async function checkOperation(input, options = {}) {
+	const { sdk, preview, sender } = input;
+	const { blockNumber, ...thresholds } = options;
+	const wallet = {
+		sdk,
+		sender,
+		blockNumber
+	};
+	switch (preview.operation) {
+		case "Deposit":
+		case "Mint":
+		case "Withdraw":
+		case "Redeem": {
+			const isDeposit = preview.operation === "Deposit" || preview.operation === "Mint";
+			return [...checkPoolOperation({
+				sdk,
+				pool: preview.pool,
+				isDeposit,
+				tokenOut: preview.tokenOut
+			}), ...await checkPoolFunding({
+				...wallet,
+				preview
+			})];
+		}
+		case "DelayedCreditAccountOperation": return checkOperation({
+			sdk,
+			preview: preview.instantPreview,
+			sender
+		}, options);
+		case "OpenCreditAccount":
+		case "RWAOpenCreditAccount":
+		case "AdjustCreditAccount": return checkCreditOperation({
+			sdk,
+			preview,
+			sender,
+			blockNumber,
+			...thresholds
+		});
+		case "RepayCreditAccount": return [...checkMarket(sdk.marketRegister.findCreditManager(preview.creditManager)), ...await checkCollateralFunding({
+			...wallet,
+			preview
+		})];
+		case "CloseCreditAccount": return checkMarket(sdk.marketRegister.findCreditManager(preview.creditManager));
+	}
+}
+//#endregion
+export { checkOperation };

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

@@ -0,0 +1,59 @@
+import { toToken } from "./helpers/token.js";
+import "./helpers/index.js";
+import { checkDebtLimits } from "./checks/checkDebtLimits.js";
+import "./checks/index.js";
+import { checkAccountQuotas } from "./bundles/checkAccountQuotas.js";
+import { checkHealthFactors } from "./bundles/checkHealthFactors.js";
+import { checkMarket } from "./bundles/checkMarket.js";
+import { checkPoolOperation } from "./bundles/checkPoolOperation.js";
+//#region src/onchain/validation/checkSimulation.ts
+/**
+* Whether a simulated operation clears the caller's own thresholds.
+*
+* 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 threshold applies it itself.
+* This is that second opinion, over the numbers the engine already reported.
+*
+* Three of the checks on a credit account the engine does not make at all:
+* both health-factor thresholds 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 stop 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.
+*
+* A pool operation has no account to weigh, so what is left is the pool's own
+* state — which the engine does not read either.
+*/
+function checkSimulation(sdk, input, options = {}) {
+	if ("pool" in input) {
+		const { pool, state, isDeposit } = input;
+		return checkPoolOperation({
+			sdk,
+			pool,
+			isDeposit,
+			tokenOut: state.tokenOut
+		});
+	}
+	const { state } = input;
+	const suite = sdk.marketRegister.findCreditManager(state.creditManager);
+	return [
+		...checkMarket(suite),
+		...checkDebtLimits({
+			debt: state.totalDebt.value,
+			minDebt: suite.creditFacade.minDebt,
+			maxDebt: suite.creditFacade.maxDebt,
+			underlying: toToken(sdk, suite.market.pool.underlying),
+			allowZero: true
+		}),
+		...checkAccountQuotas(suite, state),
+		...checkHealthFactors(state, options)
+	];
+}
+//#endregion
+export { checkSimulation };

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

@@ -0,0 +1,24 @@
+import { insufficientPoolLiquidity } from "../../../model/errors/operation-errors.js";
+import "../../../model/index.js";
+import { amountOf } from "../helpers/amount.js";
+import "../helpers/index.js";
+//#region src/onchain/validation/checks/checkBorrowLimit.ts
+/**
+* What the pool will hand over, against what is asked for.
+*
+* `available` and `limit` are the caller's reading of which limit is in the
+* way; this check only compares. `maxBorrowAmount` is the largest debt still
+* takeable, left out when none is.
+*/
+function checkBorrowLimit(args) {
+	const { requested, available, limit, underlying, maxBorrowAmount } = args;
+	if (requested <= available) return [];
+	return [insufficientPoolLiquidity({
+		requested: amountOf(underlying, requested),
+		available: amountOf(underlying, available),
+		limit,
+		...maxBorrowAmount === void 0 ? {} : { maxBorrowAmount: amountOf(underlying, maxBorrowAmount) }
+	})];
+}
+//#endregion
+export { checkBorrowLimit };

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

@@ -0,0 +1,25 @@
+import { insufficientCollateral } from "../../../model/errors/operation-errors.js";
+import "../../../model/index.js";
+//#region src/onchain/validation/checks/checkCollateralised.ts
+/**
+* The account against its debt, at whichever threshold 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, healthFactorThreshold, safePrices, improvesFrom } = args;
+	if (healthFactor === void 0) return [insufficientCollateral({
+		healthFactor: 0,
+		healthFactorThreshold,
+		safePrices
+	})];
+	if (healthFactor >= healthFactorThreshold || improvesFrom !== void 0 && healthFactor > improvesFrom) return [];
+	return [insufficientCollateral({
+		healthFactor,
+		healthFactorThreshold,
+		safePrices
+	})];
+}
+//#endregion
+export { checkCollateralised };

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

@@ -0,0 +1,9 @@
+import { creditAccountFrozen } from "../../../model/errors/liquidation-errors.js";
+import "../../../model/index.js";
+//#region src/onchain/validation/checks/checkCreditAccountFrozen.ts
+/** An RWA factory freeze stops the account's collateral from moving. */
+function checkCreditAccountFrozen(args) {
+	return args.frozen ? [creditAccountFrozen(args.creditAccount)] : [];
+}
+//#endregion
+export { checkCreditAccountFrozen };

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

@@ -0,0 +1,9 @@
+import { creditManagerPaused } from "../../../model/errors/operation-errors.js";
+import "../../../model/index.js";
+//#region src/onchain/validation/checks/checkCreditManagerPaused.ts
+/** The credit manager takes no multicall while it is paused. */
+function checkCreditManagerPaused(args) {
+	return args.isPaused ? [creditManagerPaused(args.creditManager)] : [];
+}
+//#endregion
+export { checkCreditManagerPaused };

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

@@ -0,0 +1,17 @@
+import { debtOutOfRange } from "../../../model/errors/operation-errors.js";
+import "../../../model/index.js";
+import { amountOf } from "../helpers/amount.js";
+import "../helpers/index.js";
+//#region src/onchain/validation/checks/checkDebtLimits.ts
+/** A debt the facade would revert on. */
+function checkDebtLimits(args) {
+	const { debt, minDebt, maxDebt, underlying, allowZero } = args;
+	if (!(debt > maxDebt || debt < minDebt && !(allowZero && debt === 0n))) return [];
+	return [debtOutOfRange({
+		requested: amountOf(underlying, debt),
+		minDebt: amountOf(underlying, minDebt),
+		maxDebt: amountOf(underlying, maxDebt)
+	})];
+}
+//#endregion
+export { checkDebtLimits };

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

@@ -0,0 +1,12 @@
+import { notEmergencyLiquidator } from "../../../model/errors/liquidation-errors.js";
+import "../../../model/index.js";
+//#region src/onchain/validation/checks/checkEmergencyLiquidator.ts
+/**
+* A paused market only accepts liquidations from its emergency liquidators.
+* An unpaused market does not consult the list.
+*/
+function checkEmergencyLiquidator(args) {
+	return args.paused && !args.isEmergencyLiquidator ? [notEmergencyLiquidator(args.creditManager, args.liquidator)] : [];
+}
+//#endregion
+export { checkEmergencyLiquidator };

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

@@ -0,0 +1,9 @@
+import { forbiddenToken } from "../../../model/errors/operation-errors.js";
+import "../../../model/index.js";
+//#region src/onchain/validation/checks/checkForbiddenToken.ts
+/** A token the market will not let the account hold more of. */
+function checkForbiddenToken(args) {
+	return args.isForbidden ? [forbiddenToken(args.token)] : [];
+}
+//#endregion
+export { checkForbiddenToken };

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

@@ -0,0 +1,12 @@
+import { leverageOutOfRange } from "../../../model/errors/operation-errors.js";
+import "../../../model/index.js";
+//#region src/onchain/validation/checks/checkLeverage.ts
+/** Leverage below 1x is not a position, it is a withdrawal. */
+function checkLeverage(args) {
+	return args.leverage < args.min ? [leverageOutOfRange({
+		requested: args.leverage,
+		min: args.min
+	})] : [];
+}
+//#endregion
+export { checkLeverage };

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

@@ -0,0 +1,9 @@
+import { liquidatorNotEligible } from "../../../model/errors/liquidation-errors.js";
+import "../../../model/index.js";
+//#region src/onchain/validation/checks/checkLiquidatorEligible.ts
+/** The compressor's KYC check of this wallet against the liquidated assets. */
+function checkLiquidatorEligible(args) {
+	return args.eligible ? [] : [liquidatorNotEligible(args.kycProtocol, args.kycToken)];
+}
+//#endregion
+export { checkLiquidatorEligible };

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

@@ -0,0 +1,9 @@
+import { marketExpired } from "../../../model/errors/operation-errors.js";
+import "../../../model/index.js";
+//#region src/onchain/validation/checks/checkMarketExpired.ts
+/** Past its expiration date the facade takes no more multicalls. */
+function checkMarketExpired(args) {
+	return args.isExpired ? [marketExpired(args.creditManager, args.expirationDate)] : [];
+}
+//#endregion
+export { checkMarketExpired };

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

@@ -0,0 +1,24 @@
+import { insufficientPoolLiquidity } from "../../../model/errors/operation-errors.js";
+import "../../../model/index.js";
+import { amountOf } from "../helpers/amount.js";
+import "../helpers/index.js";
+//#region src/onchain/validation/checks/checkPoolLiquidity.ts
+/**
+* What the pool holds, against what is being taken out of it.
+*
+* 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 checkPoolLiquidity(args) {
+	const { requested, available, underlying } = args;
+	if (requested < available) return [];
+	return [insufficientPoolLiquidity({
+		requested: amountOf(underlying, requested),
+		available: amountOf(underlying, available),
+		limit: "poolAvailableLiquidity"
+	})];
+}
+//#endregion
+export { checkPoolLiquidity };

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

@@ -0,0 +1,9 @@
+import { poolPaused } from "../../../model/errors/operation-errors.js";
+import "../../../model/index.js";
+//#region src/onchain/validation/checks/checkPoolPaused.ts
+/** A paused pool neither takes deposits nor serves withdrawals. */
+function checkPoolPaused(args) {
+	return args.isPaused ? [poolPaused(args.pool)] : [];
+}
+//#endregion
+export { checkPoolPaused };

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

@@ -0,0 +1,9 @@
+import { poolSunset } from "../../../model/errors/operation-errors.js";
+import "../../../model/index.js";
+//#region src/onchain/validation/checks/checkPoolSunset.ts
+/** A pool winding down still serves withdrawals, so only what puts money in is refused. */
+function checkPoolSunset(args) {
+	return args.isSunset && args.isDeposit ? [poolSunset(args.pool)] : [];
+}
+//#endregion
+export { checkPoolSunset };

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

@@ -0,0 +1,9 @@
+import { quotaCountExceeded } from "../../../model/errors/operation-errors.js";
+import "../../../model/index.js";
+//#region src/onchain/validation/checks/checkQuotaCount.ts
+/** How many quoted tokens the facade enables at once. */
+function checkQuotaCount(args) {
+	return args.count > args.max ? [quotaCountExceeded(args.count, args.max)] : [];
+}
+//#endregion
+export { checkQuotaCount };

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

@@ -0,0 +1,17 @@
+import { quotaLimitReached } from "../../../model/errors/operation-errors.js";
+import "../../../model/index.js";
+import { amountOf } from "../helpers/amount.js";
+import "../helpers/index.js";
+//#region src/onchain/validation/checks/checkQuotaLimit.ts
+/** The room the keeper still has for a token's quota, in the underlying. */
+function checkQuotaLimit(args) {
+	const { token, requested, available, underlying } = args;
+	if (requested !== void 0 && requested <= available) return [];
+	return [quotaLimitReached({
+		token,
+		requested: requested === void 0 ? void 0 : amountOf(underlying, requested),
+		available: amountOf(underlying, available)
+	})];
+}
+//#endregion
+export { checkQuotaLimit };

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

@@ -0,0 +1,16 @@
+import { checkBorrowLimit } from "./checkBorrowLimit.js";
+import { checkCollateralised } from "./checkCollateralised.js";
+import { checkCreditAccountFrozen } from "./checkCreditAccountFrozen.js";
+import { checkCreditManagerPaused } from "./checkCreditManagerPaused.js";
+import { checkDebtLimits } from "./checkDebtLimits.js";
+import { checkEmergencyLiquidator } from "./checkEmergencyLiquidator.js";
+import { checkForbiddenToken } from "./checkForbiddenToken.js";
+import { checkLeverage } from "./checkLeverage.js";
+import { checkLiquidatorEligible } from "./checkLiquidatorEligible.js";
+import { checkMarketExpired } from "./checkMarketExpired.js";
+import { checkPoolLiquidity } from "./checkPoolLiquidity.js";
+import { checkPoolPaused } from "./checkPoolPaused.js";
+import { checkPoolSunset } from "./checkPoolSunset.js";
+import { checkQuotaCount } from "./checkQuotaCount.js";
+import { checkQuotaLimit } from "./checkQuotaLimit.js";
+export { checkBorrowLimit, checkCollateralised, checkCreditAccountFrozen, checkCreditManagerPaused, checkDebtLimits, checkEmergencyLiquidator, checkForbiddenToken, checkLeverage, checkLiquidatorEligible, checkMarketExpired, checkPoolLiquidity, checkPoolPaused, checkPoolSunset, checkQuotaCount, checkQuotaLimit };

package/dist/esm/onchain/validation/helpers/amount.js

@@ -0,0 +1,11 @@
+//#region src/onchain/validation/helpers/amount.ts
+/** A check names what a limit was measured in, never what it is worth. */
+function amountOf(token, value) {
+	return {
+		token,
+		value,
+		valueUsd: null
+	};
+}
+//#endregion
+export { amountOf };

package/dist/esm/onchain/validation/helpers/health-factor-limits.js

@@ -0,0 +1,21 @@
+//#region src/onchain/validation/helpers/health-factor-limits.ts
+/**
+* The health-factor thresholds this codebase holds an account to.
+*
+* They are deliberately different numbers for different jobs: the facade's is
+* what a transaction must clear to land, a form's is what makes a position
+* worth signing, and a sizing helper leaves a margin above both.
+**/
+/** A factor at or below this is refused; kept for the callers that size on it. */
+const MIN_HF_LIMITED = 10100n;
+/** The same threshold as a `required` argument — the lowest factor that passes. */
+const MIN_HEALTH_FACTOR_FORM = 10101;
+/** The threshold the facade itself enforces: an account may end exactly at 1.0. */
+const MIN_HEALTH_FACTOR_FACADE = 1e4;
+/**
+* The safe-price threshold a form holds an account to. A step above the
+* facade's, because a factor of exactly 1.0 at safe prices is already refused.
+**/
+const MIN_SAFE_HEALTH_FACTOR_FORM = 10001;
+//#endregion
+export { MIN_HEALTH_FACTOR_FACADE, MIN_HEALTH_FACTOR_FORM, MIN_HF_LIMITED, MIN_SAFE_HEALTH_FACTOR_FORM };

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

@@ -0,0 +1,4 @@
+import { amountOf } from "./amount.js";
+import { MIN_HEALTH_FACTOR_FACADE, MIN_HEALTH_FACTOR_FORM, MIN_HF_LIMITED, MIN_SAFE_HEALTH_FACTOR_FORM } from "./health-factor-limits.js";
+import { toToken, toTokenAmount } from "./token.js";
+export { MIN_HEALTH_FACTOR_FACADE, MIN_HEALTH_FACTOR_FORM, MIN_HF_LIMITED, MIN_SAFE_HEALTH_FACTOR_FORM, amountOf, toToken, toTokenAmount };

package/dist/esm/onchain/validation/{token.js → helpers/token.js}

@@ -1,6 +1,6 @@
-import { shortAddress } from "../utils/formatter.js";
-import { amountOf } from "./checks.js";
-//#region src/onchain/validation/token.ts
+import { shortAddress } from "../../utils/formatter.js";
+import { amountOf } from "./amount.js";
+//#region src/onchain/validation/helpers/token.ts
 /**
 * The token behind an address, for the refusal details that inline one.
 *