@gearbox-protocol/sdk 16.3.1-next.1 → 16.3.2-next.1

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/validation/checks/checkReservePriceLimited.js

@@ -0,0 +1,30 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_model_errors_operation_errors = require("../../../model/errors/operation-errors.js");
+require("../../../model/index.js");
+//#region src/onchain/validation/checks/checkReservePriceLimited.ts
+/**
+* Whether a failed collateral check is the reserve price feed's doing.
+*
+* A call that hands funds over is weighed at safe prices — `min` of a token's
+* two feeds, and nothing at all where governance registered no reserve feed —
+* so an account that covers its debt at the main feed can still be refused.
+* The two are worth telling apart: a position that is genuinely too small is
+* fixed by adding collateral or requesting less, while this one is a valuation
+* the account does not control, and requesting less only helps as far as
+* `withdrawable` says it does.
+*
+* Runs after `checkCollateralised` and answers only when that one refused, so
+* the caller keeps its own threshold rather than restating it here.
+*/
+function checkReservePriceLimited(args) {
+	const { healthFactor, atMainPrices, healthFactorThreshold, withdrawable } = args;
+	if (healthFactor >= healthFactorThreshold || atMainPrices < healthFactorThreshold) return [];
+	return [require_model_errors_operation_errors.reservePriceLimited({
+		healthFactor,
+		atMainPrices,
+		healthFactorThreshold,
+		withdrawable
+	})];
+}
+//#endregion
+exports.checkReservePriceLimited = checkReservePriceLimited;

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

@@ -14,6 +14,7 @@ const require_onchain_validation_checks_checkPoolPaused = require("./checkPoolPa
 const require_onchain_validation_checks_checkPoolSunset = require("./checkPoolSunset.js");
 const require_onchain_validation_checks_checkQuotaCount = require("./checkQuotaCount.js");
 const require_onchain_validation_checks_checkQuotaLimit = require("./checkQuotaLimit.js");
+const require_onchain_validation_checks_checkReservePriceLimited = require("./checkReservePriceLimited.js");
 exports.checkBorrowLimit = require_onchain_validation_checks_checkBorrowLimit.checkBorrowLimit;
 exports.checkCollateralised = require_onchain_validation_checks_checkCollateralised.checkCollateralised;
 exports.checkCreditAccountFrozen = require_onchain_validation_checks_checkCreditAccountFrozen.checkCreditAccountFrozen;
@@ -29,3 +30,4 @@ exports.checkPoolPaused = require_onchain_validation_checks_checkPoolPaused.chec
 exports.checkPoolSunset = require_onchain_validation_checks_checkPoolSunset.checkPoolSunset;
 exports.checkQuotaCount = require_onchain_validation_checks_checkQuotaCount.checkQuotaCount;
 exports.checkQuotaLimit = require_onchain_validation_checks_checkQuotaLimit.checkQuotaLimit;
+exports.checkReservePriceLimited = require_onchain_validation_checks_checkReservePriceLimited.checkReservePriceLimited;

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

@@ -18,6 +18,7 @@ const require_onchain_validation_checks_checkPoolPaused = require("./checks/chec
 const require_onchain_validation_checks_checkPoolSunset = require("./checks/checkPoolSunset.js");
 const require_onchain_validation_checks_checkQuotaCount = require("./checks/checkQuotaCount.js");
 const require_onchain_validation_checks_checkQuotaLimit = require("./checks/checkQuotaLimit.js");
+const require_onchain_validation_checks_checkReservePriceLimited = require("./checks/checkReservePriceLimited.js");
 require("./checks/index.js");
 const require_onchain_validation_bundles_checkAccountQuotas = require("./bundles/checkAccountQuotas.js");
 const require_onchain_validation_bundles_checkWalletAllowance = require("./bundles/checkWalletAllowance.js");
@@ -77,6 +78,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/plugins/bots/BotsPlugin.js

@@ -0,0 +1,107 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_utils_AddressMap = require("../../onchain/utils/AddressMap.js");
+const require_onchain_chain_chains = require("../../onchain/chain/chains.js");
+const require_onchain_constants_address_provider = require("../../onchain/constants/address-provider.js");
+const require_onchain_utils_hex = require("../../onchain/utils/hex.js");
+const require_onchain_plugins_BasePlugin = require("../../onchain/plugins/BasePlugin.js");
+require("../../onchain/index.js");
+const require_abi_310_iBytecodeRepository = require("../../abi/310/iBytecodeRepository.js");
+const require_plugins_bots_abi_iPartialLiquidationBotV310 = require("./abi/iPartialLiquidationBotV310.js");
+const require_plugins_bots_config = require("./config.js");
+const require_plugins_bots_types = require("./types.js");
+const require_plugins_bots_PartialLiquidationBotV310Contract = require("./PartialLiquidationBotV310Contract.js");
+let viem = require("viem");
+//#region src/plugins/bots/BotsPlugin.ts
+var BotsPlugin = class extends require_onchain_plugins_BasePlugin.BasePlugin {
+	#bots;
+	get loaded() {
+		return !!this.#bots;
+	}
+	get bots() {
+		return this.#bots?.values() ?? [];
+	}
+	async load(force) {
+		if (!force && this.loaded) return this.state;
+		const treasury = this.sdk.addressProvider.getAddress(require_onchain_constants_address_provider.AP_TREASURY);
+		const bcr = this.sdk.addressProvider.getAddress(require_onchain_constants_address_provider.AP_BYTECODE_REPOSITORY);
+		const configs = require_plugins_bots_config.PARTIAL_LIQUIDATION_BOT_CONFIGS[this.sdk.networkType] ?? [];
+		this.#bots = new require_onchain_utils_AddressMap.AddressMap();
+		if (!configs.length) return this.state;
+		const deployedBots = await this.client.multicall({
+			contracts: configs.map((config) => ({
+				address: bcr,
+				abi: require_abi_310_iBytecodeRepository.iBytecodeRepositoryAbi,
+				functionName: "computeAddress",
+				args: [
+					(0, viem.stringToHex)(require_plugins_bots_types.BOT_PARTIAL_LIQUIDATION, { size: 32 }),
+					310,
+					(0, viem.encodeAbiParameters)(require_plugins_bots_types.BOT_PARAMS_ABI, [
+						treasury,
+						config.minHealthFactor,
+						config.maxHealthFactor,
+						config.premiumScaleFactor,
+						config.feeScaleFactor
+					]),
+					(0, viem.stringToHex)(require_plugins_bots_config.PARTIAL_LIQUIDATION_BOT_SALT, { size: 32 }),
+					require_plugins_bots_config.PARTIAL_LIQUIDATION_BOT_DEPLOYER
+				]
+			})),
+			allowFailure: true,
+			blockNumber: this.sdk.currentBlock,
+			batchSize: 0
+		});
+		const expectedBots = new require_onchain_utils_AddressMap.AddressMap();
+		for (let i = 0; i < configs.length; i++) {
+			const b = deployedBots[i];
+			const { minHealthFactor, maxHealthFactor } = configs[i];
+			if (b.status === "success") {
+				expectedBots.upsert(b.result, {
+					...configs[i],
+					treasury
+				});
+				this.logger?.debug(`expected bot [${minHealthFactor}, ${maxHealthFactor}] at ${b.result}`);
+			} else this.logger?.error(`failed compute address for bot [${minHealthFactor}, ${maxHealthFactor}]`, b.error);
+		}
+		const botAddrs = expectedBots.keys();
+		const serializedBots = await this.client.multicall({
+			contracts: botAddrs.map((address) => ({
+				address,
+				abi: require_plugins_bots_abi_iPartialLiquidationBotV310.iPartialLiquidationBotV310Abi,
+				functionName: "serialize"
+			})),
+			allowFailure: true,
+			blockNumber: this.sdk.currentBlock,
+			batchSize: 0
+		});
+		for (let i = 0; i < botAddrs.length; i++) {
+			const serialized = serializedBots[i];
+			const expected = expectedBots.mustGet(botAddrs[i]);
+			if (serialized.status === "success") {
+				const bot = new require_plugins_bots_PartialLiquidationBotV310Contract.PartialLiquidationBotV310Contract(this.sdk, {
+					addr: botAddrs[i],
+					version: BigInt(310),
+					contractType: require_plugins_bots_types.BOT_PARTIAL_LIQUIDATION,
+					serializedParams: serialized.result
+				});
+				if (!require_onchain_utils_hex.hexEq(treasury, expected.treasury) || bot.minHealthFactor !== expected.minHealthFactor || bot.maxHealthFactor !== expected.maxHealthFactor || bot.premiumScaleFactor !== expected.premiumScaleFactor || bot.feeScaleFactor !== expected.feeScaleFactor) this.logger?.error(`serialized bot ${botAddrs[i]} does not match expected bot`, serialized.error);
+				else this.#bots.upsert(botAddrs[i], bot);
+			}
+		}
+		return this.state;
+	}
+	stateHuman(raw) {
+		return { bots: this.#bots?.values().map((bot) => bot.stateHuman(raw)) ?? [] };
+	}
+	get state() {
+		return { bots: this.#bots?.values().map((bot) => bot.state) ?? [] };
+	}
+	hydrate(state) {
+		this.#bots = new require_onchain_utils_AddressMap.AddressMap();
+		for (const botState of state.bots) this.#bots.upsert(botState.addr, new require_plugins_bots_PartialLiquidationBotV310Contract.PartialLiquidationBotV310Contract(this.sdk, botState));
+	}
+	static getMigrationBotData(chainId) {
+		return chainId === require_onchain_chain_chains.chains.Mainnet.id ? require_plugins_bots_config.LEGACY_MIGRATION_BOT : void 0;
+	}
+};
+//#endregion
+exports.BotsPlugin = BotsPlugin;