@gearbox-protocol/sdk 16.2.0 → 16.3.0-next.2

package/dist/cjs/onchain/preview/preview/previewOperation.js

@@ -0,0 +1,119 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_model_errors_prepare_errors = require("../../../model/errors/prepare-errors.js");
+const require_model_result = require("../../../model/result.js");
+require("../../../model/index.js");
+const require_onchain_preview_parse_parseOperationCalldata = require("../parse/parseOperationCalldata.js");
+const require_onchain_preview_parse_types = require("../parse/types.js");
+require("../parse/index.js");
+const require_onchain_preview_preview_buildDelayedStrategyPositionOperationPreview = require("./buildDelayedStrategyPositionOperationPreview.js");
+const require_onchain_preview_preview_detectCloseOrRepay = require("./detectCloseOrRepay.js");
+const require_onchain_preview_preview_detectDelayedClaim = require("./detectDelayedClaim.js");
+const require_onchain_preview_preview_detectDelayedOperation = require("./detectDelayedOperation.js");
+const require_onchain_preview_preview_estimateClaimableAt = require("./estimateClaimableAt.js");
+const require_onchain_preview_preview_previewAdjustStrategyPosition = require("./previewAdjustStrategyPosition.js");
+const require_onchain_preview_preview_previewExitOrRepayStrategyPosition = require("./previewExitOrRepayStrategyPosition.js");
+const require_onchain_preview_preview_previewOpenStrategyPosition = require("./previewOpenStrategyPosition.js");
+const require_onchain_preview_preview_previewPoolPositionOperation = require("./previewPoolPositionOperation.js");
+const require_onchain_preview_preview_replayMulticall = require("./replayMulticall.js");
+//#region src/onchain/preview/preview/previewOperation.ts
+/**
+* Previews a raw operation calldata: decodes it into a typed operation and
+* assembles an operation-specific, human-displayable preview.
+*
+* Answers an {@link SDKReturn} envelope: the preview behind `ok: true`, or —
+* when the transaction is one the previewer refuses to read — a
+* {@link PreviewOperationError} behind `ok: false`. A thrown exception
+* still means the SDK could not do its job (a read failed), not a refusal
+* of the transaction.
+*
+* `input.chainId` and `sdk` both name the chain; the engine does not read
+* `input.chainId`.
+*/
+async function previewOperation(sdk, input, options, creditAccount) {
+	const parsed = require_onchain_preview_parse_parseOperationCalldata.parseOperationCalldata(sdk, input);
+	if (!parsed.ok) return parsed;
+	const operation = parsed.data;
+	if (require_onchain_preview_parse_types.isPoolOperation(operation)) return require_onchain_preview_preview_previewPoolPositionOperation.previewPoolPositionOperation(sdk, operation, options);
+	if (operation.operation === "OpenCreditAccount" || operation.operation === "RWAOpenCreditAccount") return require_onchain_preview_preview_previewOpenStrategyPosition.previewOpenStrategyPosition(sdk, input, operation);
+	if (operation.operation === "CloseCreditAccount") {
+		const resolved = await resolveCreditAccount(sdk, operation, options, creditAccount);
+		if (!resolved.ok) return resolved;
+		const replayed = require_onchain_preview_preview_replayMulticall.replayMulticall(sdk, operation, resolved.data);
+		if (!replayed.ok) return replayed;
+		const preview = require_onchain_preview_preview_previewExitOrRepayStrategyPosition.previewExitOrRepayStrategyPosition(sdk, input, operation, true, replayed.data);
+		if (!preview.ok) return preview;
+		const intent = await require_onchain_preview_preview_detectDelayedClaim.resolveDelayedClaimIntent(sdk, operation.multicall, options?.blockNumber);
+		if (!intent.ok) return intent;
+		preview.data.intent = intent.data;
+		return preview;
+	}
+	if (operation.operation === "MultiCall" || operation.operation === "BotMulticall" || operation.operation === "RWAMulticall") {
+		const resolved = await resolveCreditAccount(sdk, operation, options, creditAccount);
+		if (!resolved.ok) return resolved;
+		const replayed = require_onchain_preview_preview_replayMulticall.replayMulticall(sdk, operation, resolved.data);
+		if (!replayed.ok) return replayed;
+		return previewMulticallOperation(sdk, input, operation, replayed.data, options?.blockNumber);
+	}
+	return require_model_result.sdkErr({
+		code: "unsupportedOperation",
+		message: `operation "${operation.operation}" is not supported by previewOperation`,
+		operation: operation.operation
+	});
+}
+/**
+* Resolves the pre-state of the credit account an operation targets: uses the
+* injected state when present, otherwise fetches it from the credit account
+* compressor.
+*/
+async function resolveCreditAccount(sdk, operation, options, creditAccount) {
+	let resolved = creditAccount;
+	if (!resolved) resolved = await sdk.accounts.getCreditAccountData(operation.creditAccount, options?.blockNumber);
+	if (!resolved) return require_model_result.sdkErr(require_model_errors_prepare_errors.creditAccountNotFound(operation.creditAccount));
+	return require_model_result.sdkOk(resolved);
+}
+/**
+* Previews a plain/bot/RWA multicall: classifies the instant preview
+* (zero-debt closure/repay vs adjustment) and, when the multicall requests a
+* delayed withdrawal, wraps the instant preview into a
+* `DelayedCreditAccountOperation` together with the best-effort preview of
+* the state after the withdrawal is claimed.
+*/
+async function previewMulticallOperation(sdk, input, operation, replay, blockNumber) {
+	let instantPreview;
+	if (require_onchain_preview_preview_detectCloseOrRepay.isCloseOrRepay(operation.multicall)) {
+		const instant = require_onchain_preview_preview_previewExitOrRepayStrategyPosition.previewExitOrRepayStrategyPosition(sdk, input, operation, false, replay);
+		if (!instant.ok) return instant;
+		instantPreview = instant.data;
+	} else {
+		const instant = require_onchain_preview_preview_previewAdjustStrategyPosition.previewAdjustStrategyPosition(sdk, input, operation, replay);
+		if (!instant.ok) return instant;
+		instantPreview = instant.data;
+	}
+	const detected = require_onchain_preview_preview_detectDelayedOperation.detectDelayedOperation(sdk, operation.multicall);
+	if (!detected.ok) return detected;
+	const delayed = detected.data;
+	if (!delayed) {
+		const intent = await require_onchain_preview_preview_detectDelayedClaim.resolveDelayedClaimIntent(sdk, operation.multicall, blockNumber);
+		if (!intent.ok) return intent;
+		instantPreview.intent = intent.data;
+		return require_model_result.sdkOk(instantPreview);
+	}
+	const { before, after } = replay;
+	const market = sdk.marketRegister.findByCreditManager(operation.creditManager);
+	const meta = sdk.tokensMeta.get(market.underlying);
+	const receivedToken = meta && sdk.tokensMeta.isRWAUnderlying(meta) ? meta.asset : market.underlying;
+	const suite = sdk.marketRegister.findCreditManager(operation.creditManager);
+	return require_model_result.sdkOk({
+		operation: "DelayedCreditAccountOperation",
+		creditAccount: operation.creditAccount,
+		...suite.creditOperationMarket(),
+		name: suite.accountStrategyName(operation.creditAccount),
+		targetCollateral: suite.accountTargetCollateral(operation.creditAccount),
+		intent: delayed.intent,
+		estClaimableAt: require_onchain_preview_preview_estimateClaimableAt.estimateClaimableAt(sdk, delayed.request.phantomToken),
+		instantPreview,
+		delayedPreview: require_onchain_preview_preview_buildDelayedStrategyPositionOperationPreview.buildDelayedStrategyPositionOperationPreview(after.account, before, delayed, receivedToken, sdk)
+	});
+}
+//#endregion
+exports.previewOperation = previewOperation;

package/dist/cjs/{preview/simulate/simulatePoolOperation.js → onchain/preview/preview/previewPoolPositionOperation.js}

@@ -1,10 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_abi_iZapper = require("../../abi/iZapper.js");
-const require_abi_310_generated = require("../../abi/310/generated.js");
-const require_model_result = require("../../model/result.js");
-require("../../model/index.js");
-const require_preview_simulate_errors = require("./errors.js");
-//#region src/preview/simulate/simulatePoolOperation.ts
+const require_abi_iERC20 = require("../../../abi/iERC20.js");
+const require_abi_iZapper = require("../../../abi/iZapper.js");
+const require_abi_310_generated = require("../../../abi/310/generated.js");
+const require_model_result = require("../../../model/result.js");
+require("../../../model/index.js");
+//#region src/onchain/preview/preview/previewPoolPositionOperation.ts
 function previewRead(operation) {
 	switch (operation.operation) {
 		case "Deposit": return {
@@ -74,36 +74,50 @@ function amountsInOut(operation, previewAmount) {
 		};
 	}
 }
-/**
-* Simulates a pool deposit/mint/withdraw/redeem (direct or zapper-routed) and
-* returns the resulting token amounts going in and out. Throws a
-* {@link PreviewSimulationError} with the decoded revert when the preview read
-* fails.
-*
-* Performs the matching preview read (the pool's ERC4626
-* `previewDeposit`/`previewMint`/`previewWithdraw`/`previewRedeem`, or the
-* zapper's `previewDeposit`/`previewRedeem`) to convert the calldata-known
-* amount into its counterpart. It works on every network the SDK supports.
-*
-* It does not execute the calldata, so it ignores balance/allowance
-* prerequisites (preview reads succeed regardless).
-*/
-async function simulatePoolOperation(input, options = {}) {
-	const { sdk, operation } = input;
-	const { blockNumber, logger } = options;
+async function previewPoolPositionOperation(sdk, operation, options) {
+	const { tokenIn, tokenOut } = operation;
+	const market = sdk.marketRegister.findByPool(operation.pool);
+	const pool = market.pool.pool;
+	const holder = "owner" in operation ? operation.owner : operation.receiver;
+	let previewAmount;
+	let shares;
 	try {
-		const previewAmount = await sdk.client.readContract({
-			blockNumber,
-			...previewContract(operation)
+		[previewAmount, shares] = await sdk.client.multicall({
+			contracts: [previewContract(operation), {
+				address: operation.pool,
+				abi: require_abi_iERC20.ierc20Abi,
+				functionName: "balanceOf",
+				args: [holder]
+			}],
+			allowFailure: false,
+			batchSize: 0,
+			blockNumber: options?.blockNumber
 		});
-		return require_model_result.sdkOk(amountsInOut(operation, previewAmount));
 	} catch (cause) {
-		const error = require_preview_simulate_errors.asPreviewSimulationError(cause, "multicall");
-		logger?.error(error, "pool operation simulation failed");
+		const error = {
+			code: "poolOperationPreviewError",
+			message: cause instanceof Error ? cause.message : String(cause),
+			pool: operation.pool,
+			cause: cause instanceof Error ? cause : new Error(String(cause))
+		};
 		return require_model_result.sdkErr(error);
 	}
+	const sim = amountsInOut(operation, previewAmount);
+	const inflow = operation.operation === "Deposit" || operation.operation === "Mint";
+	const after = shares + (inflow ? sim.amountOut : -sim.amountIn);
+	return require_model_result.sdkOk({
+		operation: operation.operation,
+		pool: operation.pool,
+		zapper: operation.zapper,
+		holder,
+		name: sdk.tokensMeta.mustGetToken(operation.pool).name,
+		underlyingToken: market.underlyingToken,
+		shareRate: pool.dieselRate,
+		tokenIn: market.priceOracle.toTokenAmount(tokenIn, sim.amountIn),
+		tokenOut: market.priceOracle.toTokenAmount(tokenOut, sim.amountOut),
+		curator: market.curator,
+		netValue: market.toUnderlyingAmount(pool.sharesToUnderlying(after > 0n ? after : 0n))
+	});
 }
 //#endregion
-exports.amountsInOut = amountsInOut;
-exports.previewContract = previewContract;
-exports.simulatePoolOperation = simulatePoolOperation;
+exports.previewPoolPositionOperation = previewPoolPositionOperation;

package/dist/cjs/onchain/preview/preview/replayInnerOperations.js

@@ -0,0 +1,109 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_utils_AssetsMap = require("../../utils/AssetsMap.js");
+require("../../constants/math.js");
+const require_onchain_market_adapters_contracts_AbstractAdapter = require("../../market/adapters/contracts/AbstractAdapter.js");
+const require_model_errors_preview_errors = require("../../../model/errors/preview-errors.js");
+require("../../../model/index.js");
+//#region src/onchain/preview/preview/replayInnerOperations.ts
+/**
+* Creates a {@link ReplayState} around the given account seed, with empty
+* bookkeeping.
+*/
+function makeReplayState(account) {
+	return {
+		account,
+		collateralAdded: new require_onchain_utils_AssetsMap.AssetsMap(),
+		collateralWithdrawn: new require_onchain_utils_AssetsMap.AssetsMap()
+	};
+}
+/**
+* Replays a credit-facade multicall over `state`, mutating it in place in
+* facade execution order. The result is the *minimal guaranteed* post-state.
+*
+* The function assumes that the call was generated by our frontend using
+* router/withdrawal compressor, otherwise it answers the error on a malformed
+* multicall; state is left as replayed up to that op.
+*
+* @returns `undefined` on success, the error on a malformed multicall.
+*/
+function replayInnerOperations(sdk, multicall, state) {
+	let inBracket = false;
+	for (const op of multicall) switch (op.operation) {
+		case "AddCollateral":
+			applyAddCollateral(state, op);
+			break;
+		case "WithdrawCollateral":
+			applyWithdrawCollateral(state, op);
+			break;
+		case "IncreaseBorrowedAmount":
+			state.account.increaseDebt(op.amount);
+			break;
+		case "DecreaseBorrowedAmount":
+			state.account.repay(op.amount);
+			break;
+		case "UpdateQuota":
+			state.account.updateQuota(op.token, op.change);
+			break;
+		case "StoreExpectedBalances":
+			if (inBracket) return require_model_errors_preview_errors.malformedTransaction("nested storeExpectedBalances/compareBalances bracket");
+			inBracket = true;
+			for (const { token, balance } of op.deltas) state.account.balances.inc(token, balance);
+			break;
+		case "CompareBalances":
+			if (!inBracket) return require_model_errors_preview_errors.malformedTransaction("compareBalances without a preceding storeExpectedBalances");
+			inBracket = false;
+			break;
+		case "Execute": {
+			const error = applyExecute(sdk, op, inBracket, state.account.balances);
+			if (error) return error;
+			break;
+		}
+	}
+	if (inBracket) return require_model_errors_preview_errors.malformedTransaction("storeExpectedBalances without a matching compareBalances");
+}
+function applyAddCollateral(state, op) {
+	state.collateralAdded.inc(op.token, op.amount);
+	state.account.balances.inc(op.token, op.amount);
+}
+/**
+* `MAX_UINT256` is the facade sentinel for "withdraw the entire balance", so
+* it is resolved against the running balance at the point of the call.
+*/
+function applyWithdrawCollateral(state, op) {
+	const running = state.account.balances.getOrZero(op.token);
+	const amount = op.amount === 115792089237316195423570985008687907853269984665640564039457584007913129639935n ? running > 0n ? running : 0n : op.amount;
+	state.account.balances.dec(op.token, amount);
+	state.collateralWithdrawn.inc(op.token, amount);
+}
+/**
+* Replays an adapter `Execute` call against the running balances.
+*
+* Inside a bracket, the adapter's balance changes are previewed via
+* {@link AbstractAdapterContract.previewBalanceChanges}. Outside a bracket,
+* only calls that {@link AbstractAdapterContract.replayOutOfBracketCall}
+* accepts are allowed; nothing enforces the outcome of any other out-of-bracket
+* adapter call on-chain, so its effect on balances cannot be previewed.
+*/
+function applyExecute(sdk, op, inBracket, balances) {
+	const adapter = sdk.getContract(op.adapter);
+	if (!inBracket) {
+		if (adapter instanceof require_onchain_market_adapters_contracts_AbstractAdapter.AbstractAdapterContract) try {
+			if (adapter.replayOutOfBracketCall(balances, op.calldata)) return;
+		} catch (e) {
+			const cause = e instanceof Error ? e : new Error(String(e));
+			return require_model_errors_preview_errors.malformedTransaction(`cannot replay out-of-bracket call to ${op.adapter}: ${cause.message}`, cause);
+		}
+		return require_model_errors_preview_errors.malformedTransaction(`call to ${op.adapter} outside of a storeExpectedBalances/compareBalances bracket`);
+	}
+	if (!(adapter instanceof require_onchain_market_adapters_contracts_AbstractAdapter.AbstractAdapterContract)) return require_model_errors_preview_errors.malformedTransaction(`call to ${op.adapter} between storeExpectedBalances and compareBalances is not an adapter call`);
+	try {
+		adapter.previewBalanceChanges(balances, op.calldata);
+		return;
+	} catch (e) {
+		const cause = e instanceof Error ? e : new Error(String(e));
+		return require_model_errors_preview_errors.malformedTransaction(`cannot replay adapter call to ${op.adapter}: ${cause.message}`, cause);
+	}
+}
+//#endregion
+exports.makeReplayState = makeReplayState;
+exports.replayInnerOperations = replayInnerOperations;

package/dist/cjs/onchain/preview/preview/replayMulticall.js

@@ -0,0 +1,22 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_model_result = require("../../../model/result.js");
+require("../../../model/index.js");
+const require_onchain_preview_preview_CreditAccountState = require("./CreditAccountState.js");
+const require_onchain_preview_preview_replayInnerOperations = require("./replayInnerOperations.js");
+//#region src/onchain/preview/preview/replayMulticall.ts
+/**
+* Replays the operation's multicall over the account's pre-resolved
+* pre-state via {@link replayInnerOperations}.
+*/
+function replayMulticall(sdk, operation, creditAccount) {
+	const before = require_onchain_preview_preview_CreditAccountState.CreditAccountState.fromCreditAccountData(creditAccount);
+	const after = require_onchain_preview_preview_replayInnerOperations.makeReplayState(before.clone());
+	const error = require_onchain_preview_preview_replayInnerOperations.replayInnerOperations(sdk, operation.multicall, after);
+	if (error) return require_model_result.sdkErr(error);
+	return require_model_result.sdkOk({
+		before,
+		after
+	});
+}
+//#endregion
+exports.replayMulticall = replayMulticall;

package/dist/cjs/{preview → onchain/preview}/preview/unwrapNativeCollateral.js

@@ -1,9 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_onchain_utils_AssetsMap = require("../../onchain/utils/AssetsMap.js");
-const require_onchain_constants_addresses = require("../../onchain/constants/addresses.js");
-require("../../onchain/index.js");
-const require_preview_preview_errors = require("./errors.js");
-//#region src/preview/preview/unwrapNativeCollateral.ts
+const require_onchain_utils_AssetsMap = require("../../utils/AssetsMap.js");
+const require_onchain_constants_addresses = require("../../constants/addresses.js");
+const require_model_errors_preview_errors = require("../../../model/errors/preview-errors.js");
+const require_model_result = require("../../../model/result.js");
+require("../../../model/index.js");
+//#region src/onchain/preview/preview/unwrapNativeCollateral.ts
 /**
 * Represents the transaction's attached native value as a `NATIVE_ADDRESS`
 * entry in the collateral list.
@@ -15,26 +16,22 @@ const require_preview_preview_errors = require("./errors.js");
 * reaches zero). Other entries are preserved.
 *
 * When `nativeAmount` is positive but the WETH collateral is missing or
-* smaller than it, the transaction is malformed: the collateral is returned
-* as-is (no unwrapping) together with an `invalidTransactionValue` warning.
+* smaller than it, the transaction is malformed.
 *
 * @param collateral - Collateral assets as declared by the multicall.
 * @param nativeAmount - Transaction `msg.value`.
 * @param wethToken - Wrapped native token address.
 * @returns Collateral with the native amount unwrapped from the WETH entry,
-* plus the warning on a malformed transaction value.
+* or `malformedTransaction` when `msg.value` does not fit the declared WETH.
 */
 function unwrapNativeCollateral(collateral, nativeAmount, wethToken) {
-	if (nativeAmount === 0n) return { assets: collateral };
+	if (nativeAmount === 0n) return require_model_result.sdkOk(collateral);
 	const balances = new require_onchain_utils_AssetsMap.AssetsMap(collateral);
 	const wethBalance = balances.get(wethToken) ?? 0n;
-	if (wethBalance < nativeAmount) return {
-		assets: collateral,
-		warning: require_preview_preview_errors.invalidTransactionValueError(nativeAmount, wethBalance)
-	};
+	if (wethBalance < nativeAmount) return require_model_result.sdkErr(require_model_errors_preview_errors.malformedTransaction(`transaction value ${nativeAmount} exceeds WETH collateral ${wethBalance}`));
 	balances.upsert(wethToken, wethBalance === nativeAmount ? void 0 : wethBalance - nativeAmount);
 	balances.inc(require_onchain_constants_addresses.NATIVE_ADDRESS, nativeAmount);
-	return { assets: balances.toAssets() };
+	return require_model_result.sdkOk(balances.toAssets());
 }
 //#endregion
 exports.unwrapNativeCollateral = unwrapNativeCollateral;

package/dist/cjs/onchain/validation/bundles/checkAccountQuotas.js

@@ -0,0 +1,20 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_validation_checks_checkQuotaCount = require("../checks/checkQuotaCount.js");
+require("../checks/index.js");
+//#region src/onchain/validation/bundles/checkAccountQuotas.ts
+/**
+* How many quoted tokens the account would end up holding, against the number
+* the facade enables at once.
+*
+* Reads nothing but the projected account, so a parsed transaction and a
+* simulated one are held to it by the same code — including the reading that a
+* quota the operation zeroed out is no longer held.
+*/
+function checkAccountQuotas(suite, account) {
+	return require_onchain_validation_checks_checkQuotaCount.checkQuotaCount({
+		count: account.quotas.filter((q) => q.value > 0n).length,
+		max: suite.creditManager.maxEnabledTokens
+	});
+}
+//#endregion
+exports.checkAccountQuotas = checkAccountQuotas;

package/dist/cjs/onchain/validation/bundles/checkCollateralFunding.js

@@ -0,0 +1,59 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_utils_AssetsMap = require("../../utils/AssetsMap.js");
+const require_onchain_constants_address_provider = require("../../constants/address-provider.js");
+const require_onchain_constants_addresses = require("../../constants/addresses.js");
+require("../../constants/index.js");
+const require_model_errors_prepare_errors = require("../../../model/errors/prepare-errors.js");
+require("../../../model/index.js");
+const require_onchain_validation_bundles_checkWalletAllowance = require("./checkWalletAllowance.js");
+const require_onchain_validation_bundles_checkWalletBalance = require("./checkWalletBalance.js");
+//#region src/onchain/validation/bundles/checkCollateralFunding.ts
+/**
+* What the wallet must hold and have approved for the collateral the
+* operation adds. Native value is already split out of `collateralAdded` as a
+* `NATIVE_ADDRESS` entry; the facade wraps it into WETH, so the WETH allowance
+* covers both halves.
+*/
+async function checkCollateralFunding(input) {
+	const { sdk, preview, sender, blockNumber } = input;
+	const held = new require_onchain_utils_AssetsMap.AssetsMap(preview.collateralAdded.map((a) => ({
+		token: a.token.address,
+		balance: a.value
+	})));
+	if (held.size === 0) return [];
+	let spender;
+	try {
+		if (preview.operation === "OpenCreditAccount" || preview.operation === "RWAOpenCreditAccount") spender = await sdk.accounts.getApprovalAddress({
+			creditManager: preview.creditManager,
+			borrower: sender
+		});
+		else spender = await sdk.accounts.getApprovalAddress({
+			creditManager: preview.creditManager,
+			creditAccount: preview.creditAccount
+		});
+	} catch (cause) {
+		return [require_model_errors_prepare_errors.unexpectedFailure(cause, "resolve the approval address")];
+	}
+	const approved = held.clone();
+	const native = approved.get("0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE") ?? 0n;
+	if (native > 0n) {
+		approved.delete(require_onchain_constants_addresses.NATIVE_ADDRESS);
+		approved.inc(sdk.addressProvider.getAddress(require_onchain_constants_address_provider.AP_WETH_TOKEN, 0), native);
+	}
+	return (await Promise.all([...held.entries().map(([token, required]) => require_onchain_validation_bundles_checkWalletBalance.checkWalletBalance({
+		sdk,
+		token,
+		holder: sender,
+		required,
+		blockNumber
+	})), ...approved.entries().map(([token, required]) => require_onchain_validation_bundles_checkWalletAllowance.checkWalletAllowance({
+		sdk,
+		token,
+		owner: sender,
+		spender,
+		required,
+		blockNumber
+	}))])).flat();
+}
+//#endregion
+exports.checkCollateralFunding = checkCollateralFunding;

package/dist/cjs/onchain/validation/bundles/checkCreditOperation.js

@@ -0,0 +1,65 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_validation_helpers_token = require("../helpers/token.js");
+require("../helpers/index.js");
+const require_onchain_validation_checks_checkDebtLimits = require("../checks/checkDebtLimits.js");
+require("../checks/index.js");
+const require_onchain_validation_bundles_checkAccountQuotas = require("./checkAccountQuotas.js");
+const require_onchain_validation_bundles_checkCollateralFunding = require("./checkCollateralFunding.js");
+const require_onchain_validation_bundles_checkDraw = require("./checkDraw.js");
+const require_onchain_validation_bundles_checkHealthFactors = require("./checkHealthFactors.js");
+const require_onchain_validation_bundles_checkMarket = require("./checkMarket.js");
+const require_onchain_validation_bundles_checkObtained = require("./checkObtained.js");
+const require_onchain_validation_bundles_checkQuotasAsked = require("./checkQuotasAsked.js");
+const require_onchain_validation_bundles_checkRWAOpening = require("./checkRWAOpening.js");
+//#region src/onchain/validation/bundles/checkCreditOperation.ts
+/**
+* What the protocol stops a credit operation for, then what the wallet still
+* has to hold, approve or sign.
+*
+* The array is in check order, most fundamental first: the market's own state,
+* then what the facade would revert on, then what the operation asks the
+* market for, then the account it leaves behind, and last the wallet's side.
+*/
+async function checkCreditOperation(args) {
+	const { sdk, preview, sender, blockNumber, ...thresholds } = args;
+	const suite = sdk.marketRegister.findCreditManager(preview.creditManager);
+	const market = suite.market;
+	const underlying = require_onchain_validation_helpers_token.toToken(sdk, market.pool.underlying);
+	const isOpening = preview.operation === "OpenCreditAccount" || preview.operation === "RWAOpenCreditAccount";
+	const protocol = [
+		...require_onchain_validation_bundles_checkMarket.checkMarket(suite),
+		...require_onchain_validation_checks_checkDebtLimits.checkDebtLimits({
+			debt: preview.totalDebt.value,
+			minDebt: suite.creditFacade.minDebt,
+			maxDebt: suite.creditFacade.maxDebt,
+			underlying,
+			allowZero: !isOpening
+		}),
+		...require_onchain_validation_bundles_checkDraw.checkDraw(suite, preview, underlying),
+		...require_onchain_validation_bundles_checkObtained.checkObtained(suite, preview),
+		...require_onchain_validation_bundles_checkAccountQuotas.checkAccountQuotas(suite, preview),
+		...require_onchain_validation_bundles_checkQuotasAsked.checkQuotasAsked(market, preview, underlying),
+		...require_onchain_validation_bundles_checkHealthFactors.checkHealthFactors({
+			totalDebt: preview.totalDebt,
+			healthFactor: preview.estHealthFactor,
+			safeHealthFactor: preview.estSafeHealthFactor
+		}, thresholds)
+	];
+	const [funding, rwa] = await Promise.all([require_onchain_validation_bundles_checkCollateralFunding.checkCollateralFunding({
+		sdk,
+		preview,
+		sender,
+		blockNumber
+	}), preview.operation === "RWAOpenCreditAccount" ? require_onchain_validation_bundles_checkRWAOpening.checkRWAOpening({
+		sdk,
+		preview,
+		sender
+	}) : []]);
+	return [
+		...protocol,
+		...funding,
+		...rwa
+	];
+}
+//#endregion
+exports.checkCreditOperation = checkCreditOperation;

package/dist/cjs/onchain/validation/bundles/checkDraw.js

@@ -0,0 +1,28 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_validation_checks_checkBorrowLimit = require("../checks/checkBorrowLimit.js");
+require("../checks/index.js");
+//#region src/onchain/validation/bundles/checkDraw.ts
+/**
+* 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
+* `totalDebtChange`.
+*
+* 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 checkDraw(suite, preview, underlying) {
+	const drawn = preview.operation === "AdjustCreditAccount" ? preview.totalDebtChange.value : preview.totalDebt.value;
+	if (drawn <= 0n) return [];
+	const { value, limit } = suite.maxBorrowAmount();
+	return require_onchain_validation_checks_checkBorrowLimit.checkBorrowLimit({
+		requested: drawn,
+		available: value,
+		limit,
+		underlying
+	});
+}
+//#endregion
+exports.checkDraw = checkDraw;

package/dist/cjs/onchain/validation/bundles/checkHealthFactors.js

@@ -0,0 +1,27 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_validation_checks_checkCollateralised = require("../checks/checkCollateralised.js");
+require("../checks/index.js");
+//#region src/onchain/validation/bundles/checkHealthFactors.ts
+/**
+* The account against whichever thresholds the caller holds it to, so a parsed
+* transaction and a simulated one are weighed by the same code.
+*
+* A loan-free account is nothing to weigh: the health factor reports its
+* zero-debt sentinel and no threshold applies.
+*/
+function checkHealthFactors(account, thresholds) {
+	const { minHealthFactor, minSafeHealthFactor, currentHealthFactor } = thresholds;
+	if (account.totalDebt.value === 0n) return [];
+	return [...minHealthFactor === void 0 ? [] : require_onchain_validation_checks_checkCollateralised.checkCollateralised({
+		healthFactor: account.healthFactor,
+		healthFactorThreshold: minHealthFactor,
+		safePrices: false,
+		improvesFrom: currentHealthFactor
+	}), ...minSafeHealthFactor === void 0 ? [] : require_onchain_validation_checks_checkCollateralised.checkCollateralised({
+		healthFactor: account.safeHealthFactor,
+		healthFactorThreshold: minSafeHealthFactor,
+		safePrices: true
+	})];
+}
+//#endregion
+exports.checkHealthFactors = checkHealthFactors;

package/dist/cjs/onchain/validation/bundles/checkLiquidationEligibility.js

@@ -0,0 +1,33 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_validation_checks_checkCreditAccountFrozen = require("../checks/checkCreditAccountFrozen.js");
+const require_onchain_validation_checks_checkEmergencyLiquidator = require("../checks/checkEmergencyLiquidator.js");
+const require_onchain_validation_checks_checkLiquidatorEligible = require("../checks/checkLiquidatorEligible.js");
+require("../checks/index.js");
+//#region src/onchain/validation/bundles/checkLiquidationEligibility.ts
+/**
+* Whether this wallet may liquidate this account, from the facts the
+* compressor already reported and the market's emergency-liquidator list.
+*/
+function checkLiquidationEligibility(input) {
+	const { sdk, details, liquidator } = input;
+	const market = sdk.marketRegister.findByCreditManager(details.creditManager);
+	return [
+		...require_onchain_validation_checks_checkCreditAccountFrozen.checkCreditAccountFrozen({
+			frozen: details.isCreditAccountFrozen,
+			creditAccount: details.creditAccount
+		}),
+		...require_onchain_validation_checks_checkEmergencyLiquidator.checkEmergencyLiquidator({
+			paused: details.paused,
+			isEmergencyLiquidator: market.isEmergencyLiquidator(liquidator),
+			creditManager: details.creditManager,
+			liquidator
+		}),
+		...require_onchain_validation_checks_checkLiquidatorEligible.checkLiquidatorEligible({
+			eligible: details.isLiquidatorEligible,
+			kycProtocol: details.kycProtocol,
+			kycToken: details.kycToken
+		})
+	];
+}
+//#endregion
+exports.checkLiquidationEligibility = checkLiquidationEligibility;