@gearbox-protocol/sdk 16.3.2 → 16.4.0-next.2

package/dist/cjs/dev/midasUtils.js

@@ -10,24 +10,14 @@ const iMidasPausableVaultAbi = (0, viem.parseAbi)([
 	"function paused() external view returns (bool)",
 	"function pause() external",
 	"function unpause() external",
-	"function fnPaused(bytes4 fn) external view returns (bool)",
-	"function pauseFn(bytes4 fn) external",
-	"function unpauseFn(bytes4 fn) external",
 	"function pauseAdminRole() external view returns (bytes32)",
 	"function accessControl() external view returns (address)"
 ]);
 const iMidasAccessControlAbi = (0, viem.parseAbi)(["function hasRole(bytes32 role, address account) external view returns (bool)", "function grantRole(bytes32 role, address account) external"]);
 /**
-* Selector for `DepositVault.depositInstant(address,uint256,uint256,bytes32)`,
-* the 4-arg mint Gearbox adapters encode. Distinct from the custom-recipient
-* overload.
-*/
-const DEPOSIT_INSTANT_SELECTOR = (0, viem.toFunctionSelector)("depositInstant(address,uint256,uint256,bytes32)");
-/**
-* Unpauses a Midas issuance vault on an anvil fork so that `depositInstant`
-* stops reverting with `Pausable: paused` (global) or `Pausable: fn paused`
-* (per-selector), and returns a callback that restores the original pause
-* state of each layer that was cleared.
+* Unpauses a globally paused Midas issuance vault on an anvil fork, so that
+* `depositInstant` stops reverting with `Pausable: paused`, and returns a
+* callback that restores the original pause state.
 *
 * Impersonates `admin` and grants it `pauseAdminRole()` when missing, same as
 * `greenlistMidasGateway` does with the greenlist roles. The grant is not
@@ -35,20 +25,11 @@ const DEPOSIT_INSTANT_SELECTOR = (0, viem.toFunctionSelector)("depositInstant(ad
 */
 async function unpauseMidasIssuanceVault(props) {
 	const { anvil, vault, admin, logger } = props;
-	const [paused, depositInstantPaused] = await anvil.multicall({
-		allowFailure: false,
-		contracts: [{
-			address: vault,
-			abi: iMidasPausableVaultAbi,
-			functionName: "paused"
-		}, {
-			address: vault,
-			abi: iMidasPausableVaultAbi,
-			functionName: "fnPaused",
-			args: [DEPOSIT_INSTANT_SELECTOR]
-		}]
-	});
-	if (!paused && !depositInstantPaused) {
+	if (!await anvil.readContract({
+		address: vault,
+		abi: iMidasPausableVaultAbi,
+		functionName: "paused"
+	})) {
 		logger?.debug(`midas: issuance vault ${vault} is not paused`);
 		return async () => {};
 	}
@@ -70,7 +51,7 @@ async function unpauseMidasIssuanceVault(props) {
 		functionName: "hasRole",
 		args: [pauseAdminRole, admin]
 	});
-	logger?.debug(`midas: unpausing issuance vault ${vault} as ${admin}, access control ${accessControl}, pause admin role ${pauseAdminRole}` + (paused ? ", global" : "") + (depositInstantPaused ? ", depositInstant" : ""));
+	logger?.debug(`midas: unpausing issuance vault ${vault} as ${admin}, access control ${accessControl}, pause admin role ${pauseAdminRole}`);
 	await anvil.impersonateAccount({ address: admin });
 	try {
 		await anvil.setBalance({
@@ -88,21 +69,13 @@ async function unpauseMidasIssuanceVault(props) {
 			});
 			logger?.debug(`midas: granted pause admin role to ${admin}`);
 		}
-		if (paused) await require_dev_kycUtils.writeAndWait(anvil, {
+		await require_dev_kycUtils.writeAndWait(anvil, {
 			account: admin,
 			chain: anvil.chain,
 			address: vault,
 			abi: iMidasPausableVaultAbi,
 			functionName: "unpause"
 		});
-		if (depositInstantPaused) await require_dev_kycUtils.writeAndWait(anvil, {
-			account: admin,
-			chain: anvil.chain,
-			address: vault,
-			abi: iMidasPausableVaultAbi,
-			functionName: "unpauseFn",
-			args: [DEPOSIT_INSTANT_SELECTOR]
-		});
 	} finally {
 		await anvil.stopImpersonatingAccount({ address: admin });
 	}
@@ -117,21 +90,13 @@ async function unpauseMidasIssuanceVault(props) {
 				address: admin,
 				value: (0, viem.parseEther)("100")
 			});
-			if (paused) await require_dev_kycUtils.writeAndWait(anvil, {
+			await require_dev_kycUtils.writeAndWait(anvil, {
 				account: admin,
 				chain: anvil.chain,
 				address: vault,
 				abi: iMidasPausableVaultAbi,
 				functionName: "pause"
 			});
-			if (depositInstantPaused) await require_dev_kycUtils.writeAndWait(anvil, {
-				account: admin,
-				chain: anvil.chain,
-				address: vault,
-				abi: iMidasPausableVaultAbi,
-				functionName: "pauseFn",
-				args: [DEPOSIT_INSTANT_SELECTOR]
-			});
 		} catch (e) {
 			logger?.warn(`midas: failed to pause issuance vault ${vault} back: ${e}`);
 		} finally {

package/dist/cjs/model/errors/index.js

@@ -28,6 +28,7 @@ exports.poolPaused = require_model_errors_operation_errors.poolPaused;
 exports.poolSunset = require_model_errors_operation_errors.poolSunset;
 exports.quotaCountExceeded = require_model_errors_operation_errors.quotaCountExceeded;
 exports.quotaLimitReached = require_model_errors_operation_errors.quotaLimitReached;
+exports.reservePriceLimited = require_model_errors_operation_errors.reservePriceLimited;
 exports.rwaOpenRequirementsNotMet = require_model_errors_operation_errors.rwaOpenRequirementsNotMet;
 exports.unexpectedFailure = require_model_errors_prepare_errors.unexpectedFailure;
 exports.unpriceableTokenError = require_model_errors_oracle_errors.unpriceableTokenError;

package/dist/cjs/model/errors/operation-errors.js

@@ -67,6 +67,14 @@ function insufficientCollateral(args) {
 		...args
 	};
 }
+/** {@inheritDoc ReservePriceLimitedError} */
+function reservePriceLimited(args) {
+	return {
+		code: "reservePriceLimited",
+		message: `The reserve price feed values this collateral below what the operation pays out: the account covers its debt at ${args.atMainPrices} on the main feed and only ${args.healthFactor} at the reserve one, below ${args.healthFactorThreshold}.`,
+		...args
+	};
+}
 /** {@inheritDoc ForbiddenTokenError} */
 function forbiddenToken(token) {
 	return {
@@ -132,4 +140,5 @@ exports.poolPaused = poolPaused;
 exports.poolSunset = poolSunset;
 exports.quotaCountExceeded = quotaCountExceeded;
 exports.quotaLimitReached = quotaLimitReached;
+exports.reservePriceLimited = reservePriceLimited;
 exports.rwaOpenRequirementsNotMet = rwaOpenRequirementsNotMet;

package/dist/cjs/model/index.js

@@ -175,6 +175,7 @@ exports.quotaLimitReached = require_model_errors_operation_errors.quotaLimitReac
 exports.rateCurvePointSchema = require_model_opportunities_schema.rateCurvePointSchema;
 exports.rateCurveSchema = require_model_opportunities_schema.rateCurveSchema;
 exports.receivedAssetSchema = require_model_liquidations_schema.receivedAssetSchema;
+exports.reservePriceLimited = require_model_errors_operation_errors.reservePriceLimited;
 exports.responseMetadataSchema = require_model_response_schema.responseMetadataSchema;
 exports.responseSchema = require_model_response_schema.responseSchema;
 exports.rewardsPnLSchema = require_model_positions_schema.rewardsPnLSchema;

package/dist/cjs/onchain/accounts/intents/collateral-money.js

@@ -0,0 +1,41 @@
+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");
+require("../../utils/index.js");
+const require_onchain_accounts_intents_utils_common = require("./utils/common.js");
+//#region src/onchain/accounts/intents/collateral-money.ts
+/** {@inheritDoc CollateralMoney} */
+function collateralMoney(creditAccount, sdk) {
+	const { market, creditManager } = sdk.marketRegister.findCreditManager(creditAccount.creditManager);
+	const { priceOracle } = market;
+	const { pqk } = market.pool;
+	const underlying = market.pool.underlying;
+	const masked = creditAccount.enabledTokensMask !== 0n;
+	const mainUsd = (token, amount) => {
+		try {
+			return priceOracle.convertToUSD(token, amount);
+		} catch {
+			return;
+		}
+	};
+	const lt = (token) => BigInt(creditManager.liquidationThresholds.get(token) ?? 0);
+	const checkedUsd = (holding) => require_onchain_accounts_intents_utils_common.eq(holding.token, underlying) ? mainUsd(holding.token, holding.balance) ?? 0n : priceOracle.safeConvertMinUSD(holding.token, holding.balance).value;
+	/** A quota is underlying-denominated, and a closed market backs nothing. */
+	const quotaMoney = (holding) => pqk.hasActiveQuota(holding.token) ? (mainUsd(underlying, holding.quota) ?? 0n) * require_onchain_constants_math.PERCENTAGE_FACTOR : 0n;
+	const weigh = (holding) => {
+		const weighted = checkedUsd(holding) * lt(holding.token);
+		if (holding.quota === 0n) return weighted;
+		return require_onchain_utils_bigint_math.BigIntMath.min(quotaMoney(holding), weighted);
+	};
+	return {
+		underlying,
+		counts: (holding) => holding.balance > 10n && (!masked || (holding.mask & creditAccount.enabledTokensMask) !== 0n),
+		weigh,
+		quotaMoney,
+		mainUsd,
+		checkedUsd,
+		lt
+	};
+}
+//#endregion
+exports.collateralMoney = collateralMoney;

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

@@ -7,6 +7,7 @@ const require_onchain_validation_checks_checkCreditManagerPaused = require("../.
 const require_onchain_validation_checks_checkForbiddenToken = require("../../validation/checks/checkForbiddenToken.js");
 const require_onchain_validation_checks_checkMarketExpired = require("../../validation/checks/checkMarketExpired.js");
 const require_onchain_validation_checks_checkQuotaLimit = require("../../validation/checks/checkQuotaLimit.js");
+const require_onchain_validation_checks_checkReservePriceLimited = require("../../validation/checks/checkReservePriceLimited.js");
 const require_onchain_validation_raise = require("../../validation/raise.js");
 require("../../validation/index.js");
 const require_onchain_accounts_intents_utils_common = require("./utils/common.js");
@@ -112,13 +113,24 @@ function assertGrowthAllowed(args) {
 * whose reserve feed the SDK cannot read keeps its main price, so a plan can
 * still be refused on-chain after passing here.
 */
-function assertCollateralised(healthFactorBps, safePrices) {
+function assertCollateralised(healthFactorBps, safePrices, atSafePrices) {
 	const healthFactorThreshold = require_onchain_validation_helpers_health_factor_limits.MIN_HEALTH_FACTOR_FACADE;
-	require_onchain_validation_raise.raise(require_onchain_validation_checks_checkCollateralised.checkCollateralised({
+	const errors = require_onchain_validation_checks_checkCollateralised.checkCollateralised({
 		healthFactor: healthFactorBps,
 		healthFactorThreshold,
 		safePrices
-	}), `the account would end at a health factor of ${healthFactorBps}, below ${healthFactorThreshold}`);
+	});
+	if (errors.length === 0) return;
+	if (safePrices && atSafePrices) {
+		const { atMainPrices, withdrawable } = atSafePrices();
+		require_onchain_validation_raise.raise(require_onchain_validation_checks_checkReservePriceLimited.checkReservePriceLimited({
+			healthFactor: healthFactorBps,
+			atMainPrices,
+			healthFactorThreshold,
+			withdrawable
+		}), `the account covers its debt at ${atMainPrices} on the main feed and only ${healthFactorBps} at the reserve one, below ${healthFactorThreshold}`);
+	}
+	require_onchain_validation_raise.raise(errors, `the account would end at a health factor of ${healthFactorBps}, below ${healthFactorThreshold}`);
 }
 /**
 * A quota can only be raised as far as the market still has room for: past the

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

@@ -9,13 +9,13 @@ require("../../validation/index.js");
 const require_onchain_accounts_intents_utils_pick_token = require("./utils/pick-token.js");
 const require_onchain_accounts_intents_guards = require("./guards.js");
 const require_onchain_accounts_intents_leverage_band = require("./leverage-band.js");
-const require_onchain_accounts_intents_math = require("./math.js");
 const require_onchain_accounts_intents_maxWithdrawCollateral = require("./maxWithdrawCollateral.js");
 const require_onchain_accounts_intents_utils_credit_account_slice = require("./utils/credit-account-slice.js");
 const require_onchain_accounts_intents_open_strategy = require("./open-strategy.js");
 const require_onchain_accounts_intents_plan = require("./plan.js");
-const require_onchain_accounts_intents_realize = require("./realize.js");
 const require_onchain_accounts_intents_view = require("./view.js");
+const require_onchain_accounts_intents_withdraw_limits = require("./withdraw-limits.js");
+const require_onchain_accounts_intents_realize = require("./realize.js");
 const require_onchain_accounts_intents_tail = require("./tail.js");
 //#region src/onchain/accounts/intents/index.ts
 /**
@@ -51,26 +51,29 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 	}
 	/**
 	* Both ends of what a `WITHDRAW` can take out, in underlying: the largest
-	* partial withdrawal that keeps leverage and stays inside the facade's
-	* `debtLimits`, and the net value an exit hands over. They are reported together
-	* because a withdraw form needs both — the range it may offer, and the one
-	* amount past it that is allowed — and because the distance between them is
-	* the account's own, not a constant a caller could assume.
+	* partial withdrawal that keeps leverage, and the net value an exit hands
+	* over. They are reported together because a withdraw form needs both — the
+	* range it may offer, and the one amount past it that is allowed — and
+	* because the distance between them is the account's own, not a constant a
+	* caller could assume.
 	*
-	* Takes no target health factor, unlike {@link maxWithdrawCollateral}: a
-	* proportional withdrawal leaves the factor where it found it, and the
-	* facade's `minDebt` is what bounds it.
+	* Two rules bound the partial end and both are reported: the facade's
+	* `debtLimits` as `partial`, and the safe-price collateral check on top of
+	* it as `safePartial`. The second is the one to offer — see
+	* {@link WithdrawCeilings}.
 	*
-	* @param props - Account slice and the SDK holding its market
-	* @returns The two ceilings, see {@link WithdrawCeilings} for the gap between
-	* them
+	* Takes no target health factor, unlike {@link maxWithdrawCollateral}. A
+	* proportional withdrawal leaves the factor where it found it, so there is
+	* no room to choose: what these answer to is the facade's own threshold,
+	* which is also what {@link startIntent} refuses against.
+	*
+	* @param props - Account slice, the SDK holding its market, and optionally
+	* the collateral the withdrawal would be funded from
+	* @returns The three limits, see {@link WithdrawCeilings} for the gap
+	* between them
 	*/
 	maxWithdraw(props) {
-		const view = require_onchain_accounts_intents_view.accountView(props.creditAccount, props.sdk);
-		return {
-			partial: require_onchain_accounts_intents_math.maxProportionalWithdrawal(view, view.debtLimits),
-			exit: view.collateral > 0n ? view.collateral : 0n
-		};
+		return require_onchain_accounts_intents_withdraw_limits.withdrawLimits(props);
 	}
 	/**
 	* Debt a `REPAY` would have to cover to settle the account, in underlying

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

@@ -1,22 +1,18 @@
 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");
+require("../../constants/math.js");
 require("../../utils/index.js");
 const require_onchain_accounts_intents_utils_common = require("./utils/common.js");
+const require_onchain_accounts_intents_collateral_money = require("./collateral-money.js");
 //#region src/onchain/accounts/intents/maxWithdrawCollateral.ts
 /**
 * Largest amount of one collateral the account can withdraw while its health
 * factor stays at or above `targetHF`.
 *
 * This is the collateral check solved for one balance, and it counts what that
-* check counts: a holding backed by a quota contributes the lesser of the
-* quota and its threshold-weighted value, an unquoted one — the underlying —
-* its weighted value alone, and dust or a disabled balance nothing at all.
-* Collateral is valued at the protocol safe price (`min` of the two feeds,
-* 0 when there is no reserve), the way the facade values a call that hands
-* funds over; the underlying is exempt and is valued at the main feed, as
-* `CreditManagerV3._safeConvertToUSD` does. The debt is valued at the main
-* feed, as the check does. Zero debt frees the whole balance.
+* check counts — see {@link collateralMoney} for the valuation, safe prices
+* included. The debt is valued at the main feed, as the check does. Zero debt
+* frees the whole balance.
 *
 * Rounding always favours the account, so the answer clears the check rather
 * than landing a wei short of it.
@@ -27,49 +23,27 @@ const require_onchain_accounts_intents_utils_common = require("./utils/common.js
 **/
 function maxWithdrawCollateral(props) {
 	const { creditAccount, sdk, token, targetHF } = props;
-	const { market, creditManager } = sdk.marketRegister.findCreditManager(creditAccount.creditManager);
-	const { priceOracle } = market;
-	const { pqk } = market.pool;
-	const underlying = market.pool.underlying;
 	const target = creditAccount.tokens.find((t) => require_onchain_accounts_intents_utils_common.eq(t.token, token));
 	if (!target || target.balance <= 10n) return 0n;
 	if (creditAccount.totalDebt === 0n) return target.balance;
-	const masked = creditAccount.enabledTokensMask !== 0n;
-	const counts = (t) => t.balance > 10n && (!masked || (t.mask & creditAccount.enabledTokensMask) !== 0n);
-	/** What a holding backs, in the check's units: USD × PERCENTAGE_FACTOR. */
-	const weigh = (t) => {
-		const lt = BigInt(creditManager.liquidationThresholds.get(t.token) ?? 0);
-		const weighted = (require_onchain_accounts_intents_utils_common.eq(t.token, underlying) ? usd(priceOracle, t.token, t.balance) ?? 0n : priceOracle.safeConvertMinUSD(t.token, t.balance).value) * lt;
-		if (t.quota === 0n) return weighted;
-		return require_onchain_utils_bigint_math.BigIntMath.min(quotaUsd(t) * require_onchain_constants_math.PERCENTAGE_FACTOR, weighted);
-	};
-	/** A quota is underlying-denominated, and a closed market backs nothing. */
-	const quotaUsd = (t) => pqk.hasActiveQuota(t.token) ? usd(priceOracle, underlying, t.quota) ?? 0n : 0n;
+	const money = require_onchain_accounts_intents_collateral_money.collateralMoney(creditAccount, sdk);
 	let otherMoney = 0n;
 	for (const t of creditAccount.tokens) {
-		if (require_onchain_accounts_intents_utils_common.eq(t.token, token) || !counts(t)) continue;
-		otherMoney += weigh(t);
+		if (require_onchain_accounts_intents_utils_common.eq(t.token, token) || !money.counts(t)) continue;
+		otherMoney += money.weigh(t);
 	}
-	const borrowed = usd(priceOracle, underlying, creditAccount.totalDebt);
+	const borrowed = money.mainUsd(money.underlying, creditAccount.totalDebt);
 	if (borrowed === void 0 || borrowed <= 0n) return 0n;
 	const required = borrowed * targetHF;
 	if (required <= otherMoney) return target.balance;
 	const shortfall = required - otherMoney;
-	if (target.quota > 0n && quotaUsd(target) * 10000n < shortfall) return 0n;
-	const targetLt = BigInt(creditManager.liquidationThresholds.get(target.token) ?? 0);
-	const targetUsd = require_onchain_accounts_intents_utils_common.eq(target.token, underlying) ? usd(priceOracle, target.token, target.balance) ?? 0n : priceOracle.safeConvertMinUSD(target.token, target.balance).value;
+	if (target.quota > 0n && money.quotaMoney(target) < shortfall) return 0n;
+	const targetLt = money.lt(target.token);
+	const targetUsd = money.checkedUsd(target);
 	if (targetLt === 0n || targetUsd === 0n) return 0n;
 	const keptUsd = require_onchain_utils_bigint_math.BigIntMath.ceilDiv(shortfall, targetLt);
 	const kept = require_onchain_utils_bigint_math.BigIntMath.ceilDiv(target.balance * keptUsd, targetUsd);
 	return kept >= target.balance ? 0n : target.balance - kept;
 }
-/** USD value at the main feed, or `undefined` when the token has no price. */
-function usd(oracle, token, amount) {
-	try {
-		return oracle.convertToUSD(token, amount);
-	} catch {
-		return;
-	}
-}
 //#endregion
 exports.maxWithdrawCollateral = maxWithdrawCollateral;

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

@@ -12,6 +12,7 @@ const require_onchain_accounts_intents_utils_price_impact = require("./utils/pri
 const require_onchain_accounts_intents_utils_quotas_for_update = require("./utils/quotas-for-update.js");
 const require_onchain_accounts_intents_utils_router_path = require("./utils/router-path.js");
 const require_onchain_accounts_intents_operations = require("./operations.js");
+const require_onchain_accounts_intents_withdraw_limits = require("./withdraw-limits.js");
 //#region src/onchain/accounts/intents/realize.ts
 /**
 * Turns a plan into operations: the one place that talks to the router, knows
@@ -320,11 +321,18 @@ async function realize(steps, props) {
 		totalValue: projected.totalValue
 	};
 	const projection = sdk.positions.projection(snapshot, { availableLiquidityChange: creditAccount.totalDebt - debt });
-	require_onchain_accounts_intents_guards.assertCollateralised(sdk.positions.healthFactor({
+	const settled = {
 		...snapshot,
 		assets,
 		totalValue: floor.totalValue
-	}, { safePrices: withdrawsCollateral }), withdrawsCollateral);
+	};
+	require_onchain_accounts_intents_guards.assertCollateralised(sdk.positions.healthFactor(settled, { safePrices: withdrawsCollateral }), withdrawsCollateral, () => ({
+		atMainPrices: sdk.positions.healthFactor(settled, { safePrices: false }),
+		withdrawable: require_onchain_validation_helpers_token.toTokenAmount(sdk, underlying, require_onchain_accounts_intents_withdraw_limits.withdrawLimits({
+			creditAccount,
+			sdk
+		}).safePartial)
+	}));
 	const priceImpact = await require_onchain_accounts_intents_utils_price_impact.collectPriceImpact(probes, {
 		totalValue: projected.totalValue,
 		netValue: projected.totalValue - debt,

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

@@ -8,8 +8,8 @@ const require_onchain_accounts_intents_utils_common = require("./utils/common.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");
-const require_onchain_accounts_intents_realize = require("./realize.js");
 const require_onchain_accounts_intents_view = require("./view.js");
+const require_onchain_accounts_intents_realize = require("./realize.js");
 //#region src/onchain/accounts/intents/tail.ts
 /**
 * The second half of a delayed intent: the claim, then whatever the intent

package/dist/cjs/onchain/accounts/intents/withdraw-limits.js

@@ -0,0 +1,97 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_utils_bigint_math = require("../../utils/bigint-math.js");
+require("../../utils/index.js");
+const require_onchain_validation_helpers_health_factor_limits = require("../../validation/helpers/health-factor-limits.js");
+require("../../validation/index.js");
+const require_onchain_accounts_intents_utils_common = require("./utils/common.js");
+const require_onchain_accounts_intents_collateral_money = require("./collateral-money.js");
+const require_onchain_accounts_intents_math = require("./math.js");
+const require_onchain_accounts_intents_view = require("./view.js");
+//#region src/onchain/accounts/intents/withdraw-limits.ts
+/**
+* Every limit a `WITHDRAW` answers to, in underlying units.
+*
+* The one place they are assembled, so the figure a form is offered and the
+* figure the collateral guard names when it turns a withdrawal down cannot
+* drift apart: `CreditAccountOperationsService` reports this, and the guard
+* quotes it back.
+*
+* @param props - Account slice, the SDK holding its market, and optionally the
+* collateral the withdrawal would be funded from
+* @returns The three limits, see {@link WithdrawCeilings}
+**/
+function withdrawLimits(props) {
+	const { creditAccount, sdk } = props;
+	const view = require_onchain_accounts_intents_view.accountView(creditAccount, sdk);
+	const partial = require_onchain_accounts_intents_math.maxProportionalWithdrawal(view, view.debtLimits);
+	const safe = maxSafeWithdrawal({
+		...props,
+		targetHF: BigInt(require_onchain_validation_helpers_health_factor_limits.MIN_HEALTH_FACTOR_FACADE)
+	});
+	return {
+		partial,
+		safePartial: require_onchain_utils_bigint_math.BigIntMath.min(partial, safe),
+		exit: view.collateral > 0n ? view.collateral : 0n
+	};
+}
+/**
+* Largest proportional withdrawal the safe-price collateral check still clears,
+* in underlying units.
+*
+* A withdrawal hands funds over, so the facade weighs the account it leaves
+* behind at safe prices rather than main ones — see {@link collateralMoney}.
+* That is a second limit on top of the facade's `debtLimits`, and the two are
+* independent: a caller wanting the amount a form may actually offer takes the
+* lesser of this and `maxProportionalWithdrawal`.
+*
+* The arithmetic is the check solved for the amount. Taking `W` out at fixed
+* leverage repays `dD = D·W/C`, so `W·TVL/C` of value is sold out of the source
+* token; each dollar of that sale costs the check the source's threshold times
+* its safe-to-main price ratio, while the repayment relieves `targetHF` per
+* dollar of debt. Both terms are linear in `W`, which is why one division
+* answers instead of a search — and why the answer is exact rather than a
+* bound, as long as the plan really does fund itself from `sourceToken`.
+*
+* Two consequences worth stating, because they surprise:
+*
+* - An account whose collateral is entirely a token the reserve feed marks
+*   down cannot withdraw at all once it is under the threshold. A proportional
+*   withdrawal scales collateral and debt together, so it leaves the safe-price
+*   factor exactly where it found it — no amount climbs back over.
+* - Leaving entirely is never refused for this reason: the exit settles the
+*   debt instead of shrinking it, and a check with no debt to divide by has
+*   nothing to refuse.
+*
+* @returns Amount in underlying units. The account's net value when safe prices
+* do not limit the withdrawal at all, so the caller's `min` is a no-op; `0n`
+* when the account already sits below `targetHF` at safe prices, and only the
+* exit is left
+**/
+function maxSafeWithdrawal(props) {
+	const { creditAccount, sdk, targetHF } = props;
+	const view = require_onchain_accounts_intents_view.accountView(creditAccount, sdk);
+	if (view.collateral <= 0n) return 0n;
+	if (view.debt === 0n) return view.collateral;
+	const money = require_onchain_accounts_intents_collateral_money.collateralMoney(creditAccount, sdk);
+	const source = props.sourceToken ?? view.fattest();
+	const holding = source === void 0 ? void 0 : creditAccount.tokens.find((t) => require_onchain_accounts_intents_utils_common.eq(t.token, source));
+	if (!holding) return view.collateral;
+	let total = 0n;
+	for (const t of creditAccount.tokens) if (money.counts(t)) total += money.weigh(t);
+	const debtUsd = money.mainUsd(money.underlying, view.debt);
+	if (debtUsd === void 0 || debtUsd <= 0n) return view.collateral;
+	const slack = total - debtUsd * targetHF;
+	if (slack < 0n) return 0n;
+	const sourceMainUsd = money.mainUsd(holding.token, holding.balance);
+	if (sourceMainUsd === void 0 || sourceMainUsd <= 0n) return view.collateral;
+	const sourceRate = money.lt(holding.token) * money.checkedUsd(holding);
+	const tvlUsd = money.mainUsd(money.underlying, view.collateral + view.debt);
+	if (tvlUsd === void 0) return view.collateral;
+	const drain = sourceRate * tvlUsd - targetHF * debtUsd * sourceMainUsd;
+	if (drain <= 0n) return view.collateral;
+	const limit = view.collateral * slack * sourceMainUsd / drain;
+	return limit < view.collateral ? limit : view.collateral;
+}
+//#endregion
+exports.maxSafeWithdrawal = maxSafeWithdrawal;
+exports.withdrawLimits = withdrawLimits;

package/dist/cjs/onchain/index.js

@@ -213,6 +213,7 @@ const require_onchain_validation_checks_checkPoolPaused = require("./validation/
 const require_onchain_validation_checks_checkPoolSunset = require("./validation/checks/checkPoolSunset.js");
 const require_onchain_validation_checks_checkQuotaCount = require("./validation/checks/checkQuotaCount.js");
 const require_onchain_validation_checks_checkQuotaLimit = require("./validation/checks/checkQuotaLimit.js");
+const require_onchain_validation_checks_checkReservePriceLimited = require("./validation/checks/checkReservePriceLimited.js");
 const require_onchain_validation_bundles_checkAccountQuotas = require("./validation/bundles/checkAccountQuotas.js");
 const require_onchain_validation_bundles_checkWalletAllowance = require("./validation/bundles/checkWalletAllowance.js");
 const require_onchain_validation_bundles_checkWalletBalance = require("./validation/bundles/checkWalletBalance.js");
@@ -586,6 +587,7 @@ exports.checkQuotaCount = require_onchain_validation_checks_checkQuotaCount.chec
 exports.checkQuotaLimit = require_onchain_validation_checks_checkQuotaLimit.checkQuotaLimit;
 exports.checkRWAOpenRequirements = require_onchain_validation_bundles_checkRWAOpenRequirements.checkRWAOpenRequirements;
 exports.checkRWAOpening = require_onchain_validation_bundles_checkRWAOpening.checkRWAOpening;
+exports.checkReservePriceLimited = require_onchain_validation_checks_checkReservePriceLimited.checkReservePriceLimited;
 exports.checkSimulation = require_onchain_validation_checkSimulation.checkSimulation;
 exports.checkWallet = require_onchain_validation_bundles_checkWallet.checkWallet;
 exports.checkWalletAllowance = require_onchain_validation_bundles_checkWalletAllowance.checkWalletAllowance;

package/dist/cjs/onchain/market/adapters/abi/conctructorAbi.js

@@ -20,7 +20,7 @@ const adapterConstructorAbi = {
 	["INFINIFI_GATEWAY"]: { 310: require_onchain_market_adapters_abi_conctructorAbiPatterns.BASIC_ADAPTER_ABI },
 	["LIDO_V1"]: { 310: require_onchain_market_adapters_abi_conctructorAbiPatterns.BASIC_ADAPTER_ABI },
 	["LIDO_WSTETH_V1"]: { 310: require_onchain_market_adapters_abi_conctructorAbiPatterns.BASIC_ADAPTER_ABI },
-	["MIDAS_GATEWAY"]: { 311: require_onchain_market_adapters_abi_conctructorAbiPatterns.REFERER_ID_ADAPTER_ABI },
+	["MIDAS_GATEWAY"]: { 311: require_onchain_market_adapters_abi_conctructorAbiPatterns.BASIC_ADAPTER_ABI },
 	["MIDAS_REDEMPTION_VAULT"]: {
 		310: require_onchain_market_adapters_abi_conctructorAbiPatterns.BASIC_ADAPTER_ABI,
 		311: require_onchain_market_adapters_abi_conctructorAbiPatterns.BASIC_ADAPTER_ABI

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

@@ -3,25 +3,22 @@ const require_onchain_constants_address_provider = require("../../constants/addr
 const require_model_previews = require("../../../model/previews.js");
 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_unwrapNativeCollateral = require("./unwrapNativeCollateral.js");
-const require_onchain_preview_preview_replayInnerOperations = require("./replayInnerOperations.js");
 //#region src/onchain/preview/preview/previewOpenStrategyPosition.ts
-function previewOpenStrategyPosition(sdk, input, operation) {
+function previewOpenStrategyPosition(sdk, input, operation, replay) {
 	const { value = 0n } = input;
 	const market = sdk.marketRegister.findByCreditManager(operation.creditManager);
 	const oracle = market.priceOracle;
-	const state = require_onchain_preview_preview_replayInnerOperations.makeReplayState(require_onchain_preview_preview_CreditAccountState.CreditAccountState.beforeOpen(operation.creditManager, market.underlying));
-	const replayError = require_onchain_preview_preview_replayInnerOperations.replayInnerOperations(sdk, operation.multicall, state);
-	if (replayError) return require_model_result.sdkErr(replayError);
-	const account = state.account;
+	const { before, after } = replay;
+	const account = after.account;
 	let warning;
-	const netValue = state.collateralAdded.sum((token, balance) => {
+	const price = (token, balance) => {
 		const priced = oracle.safeConvert(token, market.underlying, balance);
 		warning ??= priced.error;
 		return priced.value;
-	});
-	const unwrapped = require_onchain_preview_preview_unwrapNativeCollateral.unwrapNativeCollateral(state.collateralAdded.toAssets(), value, sdk.addressProvider.getAddress(require_onchain_constants_address_provider.AP_WETH_TOKEN, 0));
+	};
+	const netValue = before.balances.sum(price) + after.collateralAdded.sum(price);
+	const unwrapped = require_onchain_preview_preview_unwrapNativeCollateral.unwrapNativeCollateral(after.collateralAdded.toAssets(), value, sdk.addressProvider.getAddress(require_onchain_constants_address_provider.AP_WETH_TOKEN, 0));
 	if (!unwrapped.ok) return unwrapped;
 	const collateral = unwrapped.data;
 	const snap = account.toSnapshot(netValue + account.totalDebt);
@@ -32,14 +29,11 @@ function previewOpenStrategyPosition(sdk, input, operation) {
 		collateralAdded: collateral.map((a) => oracle.toTokenAmount(a.token, a.balance)),
 		warning
 	};
-	if (operation.operation === "RWAOpenCreditAccount") return require_model_result.sdkOk({
-		...projection,
-		operation: "RWAOpenCreditAccount",
-		rwaArgs: operation.args
-	});
 	return require_model_result.sdkOk({
 		...projection,
-		operation: "OpenCreditAccount"
+		operation: "OpenCreditAccount",
+		...operation.operation === "MultiCall" || operation.operation === "BotMulticall" || operation.operation === "RWAMulticall" ? { creditAccount: operation.creditAccount } : {},
+		..."args" in operation ? { rwaArgs: operation.args } : {}
 	});
 }
 /**