@gearbox-protocol/sdk 17.10.0 → 17.10.1-next.1

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

@@ -55,6 +55,7 @@ exports.fetchCreditAccountSlice = require_onchain_accounts_intents_utils_credit_
 exports.getWithdrawalCompressorAddress = require_onchain_accounts_withdrawal_compressor_addresses.getWithdrawalCompressorAddress;
 exports.iCreditAccountAbi = require_onchain_accounts_withdrawal_compressor_AbstractWithdrawalCompressorContract.iCreditAccountAbi;
 exports.isPhantomToken = require_onchain_accounts_intents_utils_pick_token.isPhantomToken;
+exports.maxAmountForQuota = require_onchain_accounts_quota_utils.maxAmountForQuota;
 exports.roundUpQuota = require_onchain_accounts_quota_utils.roundUpQuota;
 exports.toClaimableWithdrawal = require_onchain_accounts_withdrawal_compressor_AbstractWithdrawalCompressorContract.toClaimableWithdrawal;
 exports.toCreditAccountSlice = require_onchain_accounts_intents_utils_credit_account_slice.toCreditAccountSlice;

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

@@ -53,7 +53,7 @@ function assertCanBorrow(sdk, suite, amount, options = {}) {
 		available: maxBorrowAmount.amount.value,
 		limit: maxBorrowAmount.limit,
 		underlying: require_onchain_validation_helpers_token.toToken(sdk, suite.market.pool.underlying),
-		getCollateralLimits: options.getCollateralLimits
+		...options
 	}), `borrow: ${amount} exceeds what the pool can lend now (${maxBorrowAmount.amount.value})`);
 }
 /**
@@ -82,6 +82,7 @@ function assertGrowthAllowed(args) {
 			token: require_onchain_validation_helpers_token.toToken(sdk, token),
 			requested: void 0,
 			available: 0n,
+			...args.limits,
 			underlying: require_onchain_validation_helpers_token.toToken(sdk, underlying)
 		}), `${token} takes no quota in this market, so it counts as no collateral`);
 	}
@@ -139,7 +140,7 @@ function assertCollateralised(healthFactorBps, safePrices, atSafePrices) {
 * A quota can only be raised as far as the market still has room for: past the
 * token's limit the keeper takes nothing more, whoever is asking.
 */
-function assertQuotaAvailable(sdk, market, increases) {
+function assertQuotaAvailable(sdk, market, increases, options = {}) {
 	const underlying = market.pool.underlying;
 	const { pqk } = market.pool;
 	for (const { token, balance } of increases) {
@@ -149,6 +150,7 @@ function assertQuotaAvailable(sdk, market, increases) {
 			token: require_onchain_validation_helpers_token.toToken(sdk, token),
 			requested: balance,
 			available: left,
+			...options,
 			underlying: require_onchain_validation_helpers_token.toToken(sdk, underlying)
 		}), `${token} has ${left} of quota left, the plan needs ${balance}`);
 	}

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

@@ -1,4 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_constants_math = require("../../constants/math.js");
 const require_onchain_base_SDKConstruct = require("../../base/SDKConstruct.js");
 const require_model_errors_prepare_errors = require("../../../model/errors/prepare-errors.js");
 const require_model_result = require("../../../model/result.js");
@@ -13,6 +14,7 @@ const require_onchain_accounts_intents_borrow = require("./borrow.js");
 const require_onchain_accounts_intents_leverage_band = require("./leverage-band.js");
 const require_onchain_accounts_intents_maxBorrow = require("./maxBorrow.js");
 const require_onchain_accounts_intents_maxWithdrawCollateral = require("./maxWithdrawCollateral.js");
+const require_onchain_accounts_intents_strategyLimits = require("./strategyLimits.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_view = require("./view.js");
@@ -37,9 +39,25 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 	* balance)
 	*/
 	async startIntent(props) {
+		const { intent, sdk, creditAccount, quotaReserve } = props;
+		let current;
+		let limits = {};
+		if (intent.type === "DEPOSIT" || intent.type === "ADJUST_LEVERAGE") {
+			current = require_onchain_accounts_intents_view.accountView(creditAccount, sdk);
+			limits = require_onchain_accounts_intents_strategyLimits.strategyLimits({
+				...intent,
+				suite: sdk.marketRegister.findCreditManager(creditAccount.creditManager),
+				view: current,
+				initialQuotas: creditAccount.tokens,
+				quotaReserve
+			});
+		}
 		return plain(await this.#preview(props, () => {
 			const { intent } = props;
-			const view = require_onchain_accounts_intents_view.accountView(props.creditAccount, props.sdk);
+			const view = {
+				...current ?? require_onchain_accounts_intents_view.accountView(props.creditAccount, props.sdk),
+				limits
+			};
 			switch (intent.type) {
 				case "ADD_COLLATERAL": return require_onchain_accounts_intents_plan.planAddCollateral(intent);
 				case "WITHDRAW_ASSET": return require_onchain_accounts_intents_plan.planWithdrawAsset(intent, view);
@@ -49,7 +67,7 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 				case "WITHDRAW": return require_onchain_accounts_intents_plan.planWithdraw(intent, view);
 				default: throw new Error(`${intent.type} - not implemented`);
 			}
-		}));
+		}, limits));
 	}
 	/**
 	* Both ends of what a `WITHDRAW` can take out, in underlying: the largest
@@ -191,14 +209,28 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 	*/
 	async startDelayedIntent(props) {
 		const { intent } = props;
+		const current = require_onchain_accounts_intents_view.accountView(props.creditAccount, props.sdk);
+		const repayFromSource = current.debt - current.balanceOf(current.underlying);
+		const maximum = intent.type === "ADJUST_LEVERAGE" && current.collateral > 0n && repayFromSource > 0n ? require_onchain_constants_math.LEVERAGE_DECIMALS + (repayFromSource * require_onchain_constants_math.LEVERAGE_DECIMALS - 1n) / current.collateral : void 0;
+		const limits = intent.type === "ADJUST_LEVERAGE" && maximum !== void 0 ? require_onchain_accounts_intents_strategyLimits.strategyLimits({
+			...intent,
+			suite: props.sdk.marketRegister.findCreditManager(props.creditAccount.creditManager),
+			view: current,
+			initialQuotas: props.creditAccount.tokens,
+			quotaReserve: props.quotaReserve,
+			maxLeverage: maximum
+		}) : {};
 		const result = await this.#preview(props, () => {
-			const view = require_onchain_accounts_intents_view.accountView(props.creditAccount, props.sdk);
+			const view = {
+				...current,
+				limits
+			};
 			switch (intent.type) {
 				case "ADJUST_LEVERAGE": return require_onchain_accounts_intents_plan.planAdjustLeverageDelayed(intent, view);
 				case "WITHDRAW": return require_onchain_accounts_intents_plan.planWithdrawDelayed(intent, view);
 				default: throw new Error(`${intent.type} - cannot be delayed`);
 			}
-		});
+		}, limits);
 		if (!result.ok) return result;
 		const { delayed } = result;
 		if (!delayed) throw new Error("startDelayedIntent: plan started no withdrawal");
@@ -214,7 +246,8 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 				delayed,
 				creditAccount: props.creditAccount,
 				sdk: props.sdk,
-				quotaReserve: props.quotaReserve
+				quotaReserve: props.quotaReserve,
+				limits
 			});
 			return {
 				...result,
@@ -400,7 +433,7 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 		}
 	}
 	/** Plan → realise → wrap. Unviable requests become `{ ok: false }`. */
-	async #preview(props, plan) {
+	async #preview(props, plan, limits = {}) {
 		const draft = props.draft ?? {};
 		try {
 			const suite = props.sdk.marketRegister.findCreditManager(props.creditAccount.creditManager);
@@ -411,7 +444,8 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 				sdk: props.sdk,
 				slippage: props.slippage ?? 0,
 				quotaReserve: props.quotaReserve,
-				draft
+				draft,
+				limits
 			});
 			return {
 				ok: true,

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

@@ -1,7 +1,6 @@
 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/index.js");
 const require_model_errors_operation_errors = require("../../../model/errors/operation-errors.js");
 require("../../../model/index.js");
 const require_onchain_validation_helpers_token = require("../../validation/helpers/token.js");
@@ -59,58 +58,18 @@ function assertLeverageAtLeastOne(leverage) {
 * may end owing nothing, an opening may not.
 */
 function assertDebtLimits(sdk, debt, debtLimits, underlying, options = {}) {
-	const { allowZero = true, getCollateralLimits, maxBorrowAmount } = options;
+	const { allowZero = true, ...rest } = options;
 	require_onchain_validation_raise.raise(require_onchain_validation_checks_checkDebtLimits.checkDebtLimits({
 		debt,
-		minDebt: debtLimits.minDebt,
-		maxDebt: debtLimits.maxDebt,
+		...debtLimits,
 		underlying: require_onchain_validation_helpers_token.toToken(sdk, underlying),
 		allowZero,
-		getCollateralLimits,
-		maxBorrowAmount
+		...rest
 	}), debt > debtLimits.maxDebt ? `debt ${debt} exceeds maxDebt ${debtLimits.maxDebt}` : `debt ${debt} is below minDebt ${debtLimits.minDebt}`);
 }
-/** Finds single-token Open amounts whose projected debt fits the market limits. */
-function openCollateralForDebtLimits({ suite, collateral, leverage }) {
-	if (collateral.length !== 1 || leverage <= 100n) return void 0;
-	const [{ token }] = collateral;
-	const { market } = suite;
-	const limits = {
-		minDebt: suite.creditFacade.minDebt,
-		maxDebt: suite.maxBorrowAmount().amount.value
-	};
-	if (limits.maxDebt < limits.minDebt) return void 0;
-	const debtAt = (amount) => {
-		const converted = market.priceOracle.safeConvert(token, market.pool.underlying, amount);
-		return converted.error ? void 0 : debtForLeverage(converted.value, leverage);
-	};
-	const lastDebt = debtAt(require_onchain_constants_math.MAX_UINT256);
-	if (lastDebt === void 0 || lastDebt < limits.minDebt) return void 0;
-	const firstAtLeast = (threshold) => {
-		let low = 0n;
-		let high = require_onchain_constants_math.MAX_UINT256;
-		while (low < high) {
-			const middle = (low + high) / 2n;
-			const debt = debtAt(middle);
-			if (debt === void 0) return void 0;
-			if (debt < threshold) low = middle + 1n;
-			else high = middle;
-		}
-		return low;
-	};
-	const min = firstAtLeast(limits.minDebt > 0n ? limits.minDebt : 1n);
-	const above = lastDebt > limits.maxDebt ? firstAtLeast(limits.maxDebt + 1n) : void 0;
-	if (min === void 0 || lastDebt > limits.maxDebt && above === void 0) return void 0;
-	const max = above === void 0 ? require_onchain_constants_math.MAX_UINT256 : above - 1n;
-	return min <= max ? {
-		min: market.priceOracle.toTokenAmount(token, min),
-		max: market.priceOracle.toTokenAmount(token, max)
-	} : void 0;
-}
 //#endregion
 exports.assertDebtLimits = assertDebtLimits;
 exports.assertLeverageAtLeastOne = assertLeverageAtLeastOne;
 exports.debtForLeverage = debtForLeverage;
 exports.maxProportionalWithdrawal = maxProportionalWithdrawal;
-exports.openCollateralForDebtLimits = openCollateralForDebtLimits;
 exports.proportionalDebt = proportionalDebt;

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

@@ -87,7 +87,13 @@ function maxBorrow(props) {
 	if (lends < suite.creditFacade.minDebt) return 0n;
 	const ceiling = require_onchain_utils_bigint_math.BigIntMath.min(priceOracle.safeConvertFromUSD(underlying, backed / targetHF).value, lends);
 	const unwrapsPayout = !!rwaAsset && require_onchain_accounts_intents_utils_common.eq(borrowToken, rwaAsset);
-	return require_onchain_accounts_intents_utils_common.eq(borrowToken, underlying) ? ceiling : unwrapsPayout ? require_onchain_accounts_intents_utils_common.toTargetDecimals(ceiling, underlying, borrowToken, sdk) : priceOracle.safeConvert(underlying, borrowToken, ceiling).value;
+	if (require_onchain_accounts_intents_utils_common.eq(borrowToken, underlying)) return ceiling;
+	if (unwrapsPayout) return require_onchain_accounts_intents_utils_common.toTargetDecimals(ceiling, underlying, borrowToken, sdk);
+	const payout = priceOracle.safeConvert(underlying, borrowToken, ceiling);
+	if (payout.error) return 0n;
+	const debt = priceOracle.safeConvert(borrowToken, underlying, payout.value);
+	if (debt.error) return 0n;
+	return require_onchain_utils_bigint_math.BigIntMath.max(payout.value - (debt.value > ceiling ? 1n : 0n), 0n);
 }
 //#endregion
 exports.maxBorrow = maxBorrow;

package/dist/cjs/onchain/accounts/intents/open-strategy.js

@@ -9,6 +9,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");
 require("./utils/index.js");
+const require_onchain_accounts_intents_strategyLimits = require("./strategyLimits.js");
 //#region src/onchain/accounts/intents/open-strategy.ts
 /**
 * Builds the state opening a leveraged position out of wallet collateral would
@@ -45,17 +46,20 @@ async function buildOpenStrategyState(props) {
 		creditFacade: suite.creditFacade.address,
 		underlying
 	});
-	const getCollateralLimits = () => require_onchain_accounts_intents_math.openCollateralForDebtLimits({
+	const options = leftoverBalances.length || existing?.tokens.some((t) => t.balance > 0n) ? void 0 : require_onchain_accounts_intents_strategyLimits.strategyLimits({
+		type: "OPEN",
 		suite,
 		collateral,
-		leverage
+		leverage,
+		targetToken,
+		quotaReserve
 	});
 	require_onchain_accounts_intents_math.assertDebtLimits(sdk, debt, suite.creditFacade, underlying, {
+		...options,
 		allowZero: false,
-		maxBorrowAmount: suite.maxBorrowAmount(),
-		getCollateralLimits
+		maxBorrowAmount: suite.maxBorrowAmount()
 	});
-	require_onchain_accounts_intents_guards.assertCanBorrow(sdk, suite, debt, { getCollateralLimits });
+	require_onchain_accounts_intents_guards.assertCanBorrow(sdk, suite, debt, options);
 	const paths = require_onchain_accounts_intents_utils_router_path.createRouterPaths({
 		sdk,
 		creditAccount: account,
@@ -124,9 +128,10 @@ async function buildOpenStrategyState(props) {
 		suite,
 		market,
 		before: [],
-		after: averageAssets
+		after: averageAssets,
+		limits: options
 	});
-	require_onchain_accounts_intents_guards.assertQuotaAvailable(sdk, market, averageQuota);
+	require_onchain_accounts_intents_guards.assertQuotaAvailable(sdk, market, averageQuota, options);
 	const projection = reached ?? settle();
 	require_onchain_accounts_intents_guards.assertCollateralised(projection.healthFactor, false);
 	const priceImpact = await require_onchain_accounts_intents_utils_price_impact.collectPriceImpact(leg.probe ? [leg.probe] : [], {

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

@@ -43,7 +43,7 @@ function planDeposit(intent, view) {
 	const aU = view.price(intent.token, U, intent.amount);
 	const debtDelta = intent.targetLeverage === void 0 ? require_onchain_accounts_intents_math.proportionalDebt(view, aU) : require_onchain_accounts_intents_math.debtForLeverage(view.collateral + aU, intent.targetLeverage) - view.debt;
 	if (debtDelta < 0n) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_operation_errors.leverageOutOfRange(), `deposit: target leverage ${intent.targetLeverage} would require repaying debt`);
-	require_onchain_accounts_intents_math.assertDebtLimits(view.sdk, view.debt + debtDelta, view.debtLimits, U);
+	require_onchain_accounts_intents_math.assertDebtLimits(view.sdk, view.debt + debtDelta, view.debtLimits, U, view.limits);
 	const T = intent.positionToken ?? positionToken(view, "deposit");
 	const depositStays = require_onchain_accounts_intents_utils_common.eq(intent.token, T);
 	return [
@@ -78,7 +78,7 @@ function planRepay(intent, view) {
 	}), "repay: the account owes nothing");
 	const funding = everything(intent.amount) ? view.price(U, intent.token, withMargin(view.debt)) : intent.amount;
 	const repaid = min(view.price(intent.token, U, funding), view.debt);
-	require_onchain_accounts_intents_math.assertDebtLimits(view.sdk, view.debt - repaid, view.debtLimits, view.underlying);
+	require_onchain_accounts_intents_math.assertDebtLimits(view.sdk, view.debt - repaid, view.debtLimits, view.underlying, view.limits);
 	return [
 		add(intent.token, funding, intent.value),
 		...fundsInU ? [] : [convert(intent.token, U, funding)],
@@ -307,7 +307,7 @@ function withdrawShape(intent, view) {
 		};
 	}
 	const dD = require_onchain_accounts_intents_math.proportionalDebt(view, WU);
-	require_onchain_accounts_intents_math.assertDebtLimits(view.sdk, view.debt - dD, view.debtLimits, view.underlying);
+	require_onchain_accounts_intents_math.assertDebtLimits(view.sdk, view.debt - dD, view.debtLimits, view.underlying, view.limits);
 	return {
 		U,
 		T,
@@ -326,7 +326,7 @@ function leverageShape(intent, view) {
 	require_onchain_accounts_intents_math.assertLeverageAtLeastOne(intent.targetLeverage);
 	if (view.collateral <= 0n) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_operation_errors.insufficientBalance(), "adjustLeverage: account has no collateral to lever");
 	const target = require_onchain_accounts_intents_math.debtForLeverage(view.collateral, intent.targetLeverage);
-	require_onchain_accounts_intents_math.assertDebtLimits(view.sdk, target, view.debtLimits, view.underlying);
+	require_onchain_accounts_intents_math.assertDebtLimits(view.sdk, target, view.debtLimits, view.underlying, view.limits);
 	return {
 		U: view.underlying,
 		delta: target - view.debt

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

@@ -131,7 +131,7 @@ async function realize(steps, props) {
 			}));
 			break;
 		case "borrow":
-			require_onchain_accounts_intents_guards.assertCanBorrow(sdk, suite, step.amount);
+			require_onchain_accounts_intents_guards.assertCanBorrow(sdk, suite, step.amount, props.limits);
 			push(require_onchain_accounts_intents_operations.buildIncreaseDebtOperation({
 				amount: step.amount,
 				creditAccount,
@@ -395,10 +395,11 @@ async function realize(steps, props) {
 		suite,
 		market,
 		before: creditAccount.tokens,
-		after: projected.assets
+		after: projected.assets,
+		limits: props.limits
 	});
 	if (!cleared && quotas.quotaIncrease.length + quotas.quotaDecrease.length > 0) {
-		require_onchain_accounts_intents_guards.assertQuotaAvailable(sdk, market, quotas.quotaIncrease);
+		require_onchain_accounts_intents_guards.assertQuotaAvailable(sdk, market, quotas.quotaIncrease, props.limits);
 		push(require_onchain_accounts_intents_operations.buildQuotaUpdateOperation({
 			update: quotas,
 			creditAccount,

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

@@ -0,0 +1,159 @@
+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/index.js");
+const require_onchain_accounts_intents_utils_quotas_for_update = require("./utils/quotas-for-update.js");
+//#region src/onchain/accounts/intents/strategyLimits.ts
+/** Independent input bounds supplied to debt, liquidity and quota errors. */
+function strategyLimits(props) {
+	const { suite, quotaReserve } = props;
+	const { market } = suite;
+	const { priceOracle: oracle } = market;
+	switch (props.type) {
+		case "OPEN": {
+			const { collateral, leverage, targetToken } = props;
+			if (collateral.length !== 1 || leverage <= 100n) return {};
+			const [{ token }] = collateral;
+			const minDebt = suite.creditFacade.minDebt;
+			const maxDebt = suite.maxBorrowAmount().amount.value;
+			if (maxDebt < minDebt) return {};
+			const minCollateralForDebt = (debt) => {
+				const collateralUnderlying = require_onchain_utils_bigint_math.BigIntMath.ceilDiv(debt * require_onchain_constants_math.LEVERAGE_DECIMALS, leverage - require_onchain_constants_math.LEVERAGE_DECIMALS);
+				const result = oracle.safeConvert(market.pool.underlying, token, collateralUnderlying - 1n);
+				if (result.error) return void 0;
+				const valuation = oracle.safeConvert(token, market.pool.underlying, result.value);
+				if (valuation.error) return void 0;
+				const collateral = result.value + (valuation.value < collateralUnderlying ? 1n : 0n);
+				const checked = oracle.safeConvert(token, market.pool.underlying, collateral);
+				return checked.error || checked.value < collateralUnderlying ? void 0 : collateral;
+			};
+			if (oracle.safeConvert(token, market.pool.underlying, 1n).error) return {};
+			const minCollateral = minCollateralForDebt(require_onchain_utils_bigint_math.BigIntMath.max(minDebt, 1n));
+			const excessCollateral = minCollateralForDebt(maxDebt + 1n);
+			if (minCollateral === void 0 || excessCollateral === void 0 || minCollateral > 115792089237316195423570985008687907853269984665640564039457584007913129639935n) return {};
+			const maxCollateral = require_onchain_utils_bigint_math.BigIntMath.min(require_onchain_constants_math.MAX_UINT256, excessCollateral - 1n);
+			let maxCollateralByQuota;
+			if (!market.isUnderlyingLike(targetToken) && !market.pool.pqk.hasActiveQuota(targetToken)) maxCollateralByQuota = 0n;
+			else {
+				const quotaResult = require_onchain_accounts_intents_utils_quotas_for_update.quotaIncreaseLimit({
+					suite,
+					token: targetToken,
+					balance: 0n,
+					initialQuotas: [],
+					quotaReserve
+				});
+				if (!quotaResult.error && quotaResult.value !== void 0) {
+					const excessUnderlying = require_onchain_utils_bigint_math.BigIntMath.ceilDiv((require_onchain_utils_bigint_math.BigIntMath.max(quotaResult.value, 0n) + 1n) * require_onchain_constants_math.LEVERAGE_DECIMALS, leverage);
+					const result = oracle.safeConvert(market.pool.underlying, token, excessUnderlying - 1n);
+					if (!result.error) {
+						const valuation = oracle.safeConvert(token, market.pool.underlying, result.value);
+						if (!valuation.error) {
+							const collateral = result.value - (valuation.value >= excessUnderlying ? 1n : 0n);
+							maxCollateralByQuota = require_onchain_utils_bigint_math.BigIntMath.min(require_onchain_constants_math.MAX_UINT256, require_onchain_utils_bigint_math.BigIntMath.max(collateral, 0n));
+						}
+					}
+				}
+			}
+			return {
+				collateralLimits: minCollateral <= maxCollateral ? {
+					min: oracle.toTokenAmount(token, minCollateral),
+					max: oracle.toTokenAmount(token, maxCollateral)
+				} : void 0,
+				quotaLimits: maxCollateralByQuota === void 0 ? void 0 : { collateralMax: oracle.toTokenAmount(token, maxCollateralByQuota) }
+			};
+		}
+		case "DEPOSIT": {
+			const { view, token, positionToken, initialQuotas, targetLeverage } = props;
+			if (targetLeverage !== void 0 || view.collateral <= 0n) return {};
+			const minDebt = require_onchain_utils_bigint_math.BigIntMath.max(view.debt, suite.creditFacade.minDebt);
+			const maxDebt = require_onchain_utils_bigint_math.BigIntMath.min(suite.creditFacade.maxDebt, view.debt + suite.maxBorrowAmount().amount.value);
+			const minCollateralForDebt = (debt) => {
+				if (debt <= view.debt) return 0n;
+				if (view.debt === 0n) return void 0;
+				const collateralUnderlying = require_onchain_utils_bigint_math.BigIntMath.ceilDiv((debt - view.debt) * view.collateral, view.debt);
+				const result = oracle.safeConvert(view.underlying, token, collateralUnderlying - 1n);
+				if (result.error) return void 0;
+				const valuation = oracle.safeConvert(token, view.underlying, result.value);
+				if (valuation.error) return void 0;
+				const collateral = result.value + (valuation.value < collateralUnderlying ? 1n : 0n);
+				const checked = oracle.safeConvert(token, view.underlying, collateral);
+				return checked.error || checked.value < collateralUnderlying ? void 0 : collateral;
+			};
+			const debtFloorCollateral = minCollateralForDebt(minDebt);
+			const minCollateral = debtFloorCollateral === void 0 ? void 0 : require_onchain_utils_bigint_math.BigIntMath.max(1n, debtFloorCollateral);
+			const excessCollateral = debtFloorCollateral === void 0 ? void 0 : minCollateralForDebt(maxDebt + 1n);
+			const maxCollateral = excessCollateral === void 0 ? require_onchain_constants_math.MAX_UINT256 : require_onchain_utils_bigint_math.BigIntMath.min(require_onchain_constants_math.MAX_UINT256, excessCollateral - 1n);
+			const position = positionToken ?? view.fattest([view.underlying]);
+			let maxCollateralByQuota;
+			if (position) {
+				if (!market.isUnderlyingLike(position) && !market.pool.pqk.hasActiveQuota(position)) maxCollateralByQuota = 0n;
+				else {
+					const quotaResult = require_onchain_accounts_intents_utils_quotas_for_update.quotaIncreaseLimit({
+						suite,
+						token: position,
+						balance: view.balanceOf(position),
+						initialQuotas,
+						quotaReserve,
+						rwaAsset: view.rwaAsset
+					});
+					maxCollateralByQuota = require_onchain_constants_math.MAX_UINT256;
+					if (!quotaResult.error && quotaResult.value !== void 0) {
+						const excessUnderlying = require_onchain_utils_bigint_math.BigIntMath.ceilDiv((quotaResult.value + 1n) * view.collateral, view.collateral + view.debt);
+						const result = oracle.safeConvert(view.underlying, token, require_onchain_utils_bigint_math.BigIntMath.max(excessUnderlying - 1n, 0n));
+						maxCollateralByQuota = void 0;
+						if (!result.error) {
+							const valuation = oracle.safeConvert(token, view.underlying, result.value);
+							if (!valuation.error) {
+								const collateral = result.value - (valuation.value >= excessUnderlying ? 1n : 0n);
+								maxCollateralByQuota = require_onchain_utils_bigint_math.BigIntMath.min(require_onchain_constants_math.MAX_UINT256, require_onchain_utils_bigint_math.BigIntMath.max(collateral, 0n));
+							}
+						}
+					}
+				}
+			}
+			return {
+				collateralLimits: minCollateral !== void 0 && minCollateral <= maxCollateral ? {
+					min: oracle.toTokenAmount(token, minCollateral),
+					max: oracle.toTokenAmount(token, maxCollateral)
+				} : void 0,
+				quotaLimits: maxCollateralByQuota === void 0 ? void 0 : { collateralMax: oracle.toTokenAmount(token, maxCollateralByQuota) }
+			};
+		}
+		case "ADJUST_LEVERAGE": {
+			const { view, token, initialQuotas, targetLeverage, maxLeverage = require_onchain_constants_math.MAX_UINT256 } = props;
+			if (view.collateral <= 0n || targetLeverage < 100n) return {};
+			const maxDebt = require_onchain_utils_bigint_math.BigIntMath.min(suite.creditFacade.maxDebt, view.debt + suite.maxBorrowAmount().amount.value);
+			const minLeverage = require_onchain_utils_bigint_math.BigIntMath.max(require_onchain_constants_math.LEVERAGE_DECIMALS + 1n, require_onchain_constants_math.LEVERAGE_DECIMALS + require_onchain_utils_bigint_math.BigIntMath.ceilDiv(suite.creditFacade.minDebt * require_onchain_constants_math.LEVERAGE_DECIMALS, view.collateral));
+			const debtMaxLeverage = require_onchain_utils_bigint_math.BigIntMath.min(maxLeverage, require_onchain_constants_math.LEVERAGE_DECIMALS + require_onchain_utils_bigint_math.BigIntMath.ceilDiv((maxDebt + 1n) * require_onchain_constants_math.LEVERAGE_DECIMALS, view.collateral) - 1n);
+			const position = token ?? view.fattest([view.underlying]);
+			let maxLeverageByQuota;
+			if (position) {
+				if (!market.isUnderlyingLike(position) && !market.pool.pqk.hasActiveQuota(position)) maxLeverageByQuota = require_onchain_constants_math.LEVERAGE_DECIMALS;
+				else {
+					const quotaResult = require_onchain_accounts_intents_utils_quotas_for_update.quotaIncreaseLimit({
+						suite,
+						token: position,
+						balance: view.balanceOf(position),
+						initialQuotas,
+						quotaReserve,
+						rwaAsset: view.rwaAsset
+					});
+					maxLeverageByQuota = maxLeverage;
+					if (!quotaResult.error && quotaResult.value !== void 0) {
+						const quotaMaxDebt = view.debt + quotaResult.value;
+						maxLeverageByQuota = require_onchain_utils_bigint_math.BigIntMath.min(maxLeverage, require_onchain_constants_math.LEVERAGE_DECIMALS + require_onchain_utils_bigint_math.BigIntMath.ceilDiv((quotaMaxDebt + 1n) * require_onchain_constants_math.LEVERAGE_DECIMALS, view.collateral) - 1n);
+					}
+				}
+			}
+			return {
+				leverageLimits: minLeverage <= debtMaxLeverage ? {
+					min: minLeverage,
+					max: debtMaxLeverage
+				} : void 0,
+				quotaLimits: maxLeverageByQuota === void 0 ? void 0 : { leverageMax: maxLeverageByQuota }
+			};
+		}
+	}
+}
+//#endregion
+exports.strategyLimits = strategyLimits;

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

@@ -169,13 +169,17 @@ async function projectTail(args) {
 	const { steps } = planTail({
 		intent: delayed.record,
 		claimable: projectedClaimable(request, queued.token, queued.amount, claim),
-		view: require_onchain_accounts_intents_view.accountView(next, sdk)
+		view: {
+			...require_onchain_accounts_intents_view.accountView(next, sdk),
+			limits: args.limits
+		}
 	});
 	const { state, operations } = await require_onchain_accounts_intents_realize.realize(steps, {
 		creditAccount: next,
 		sdk,
 		slippage: 0,
 		quotaReserve,
+		limits: args.limits,
 		paths: require_onchain_accounts_intents_utils_router_path.createOraclePaths({
 			sdk,
 			creditAccount: next

package/dist/cjs/onchain/accounts/intents/testing/sdk-mock.js

@@ -148,6 +148,10 @@ function buildMockSdk(args) {
 	});
 	const market = {
 		toUnderlyingAmount,
+		isUnderlyingLike: (token) => {
+			const address = token.toLowerCase();
+			return address === args.underlying.toLowerCase() || address === args.rwaAssets?.[args.underlying.toLowerCase()]?.toLowerCase();
+		},
 		/** {@inheritDoc MarketSuite.curator} */
 		curator: MOCK_CURATOR,
 		/** {@inheritDoc MarketSuite.underlying} */

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

@@ -24,6 +24,7 @@ exports.isPhantomToken = require_onchain_accounts_intents_utils_pick_token.isPha
 exports.isRedemptionPhantomToken = require_onchain_accounts_intents_utils_pick_token.isRedemptionPhantomToken;
 exports.lossRate = require_onchain_accounts_intents_utils_price_impact.lossRate;
 exports.pickFattestNonPhantomToken = require_onchain_accounts_intents_utils_pick_token.pickFattestNonPhantomToken;
+exports.quotaIncreaseLimit = require_onchain_accounts_intents_utils_quotas_for_update.quotaIncreaseLimit;
 exports.quotasAfterUpdate = require_onchain_accounts_intents_utils_quotas_for_update.quotasAfterUpdate;
 exports.rankAccountTokens = require_onchain_accounts_intents_utils_pick_token.rankAccountTokens;
 exports.resolveCreditManager = require_onchain_accounts_intents_utils_common.resolveCreditManager;

package/dist/cjs/onchain/accounts/intents/utils/quotas-for-update.js

@@ -1,6 +1,8 @@
 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");
 const require_onchain_utils_mappers = require("../../../utils/mappers.js");
+require("../../../constants/index.js");
 const require_onchain_accounts_quota_utils = require("../../quota-utils.js");
 //#region src/onchain/accounts/intents/utils/quotas-for-update.ts
 function getQuotasForUpdate({ assetsBefore, assetsAfter, initialQuotas, quotaReserve = 0, liquidationThresholds: liquidationThresholdsMap, quotas: quotasMap, maxDebt, underlyingToken, convert }) {
@@ -195,8 +197,45 @@ function constructAssetRecord(a) {
 		return acc;
 	}, {});
 }
+/** Largest additional underlying amount whose purchase fits this token's quota. */
+function quotaIncreaseLimit({ suite, token, balance, initialQuotas, quotaReserve = 0, rwaAsset }) {
+	const { market } = suite;
+	if (market.isUnderlyingLike(token)) return { value: void 0 };
+	const oracle = market.priceOracle;
+	const purchaseResult = oracle.safeConvert(market.pool.underlying, token, require_onchain_constants_math.MAX_UINT256);
+	if (purchaseResult.error) return purchaseResult;
+	const valuationResult = oracle.safeConvert(token, market.pool.underlying, require_onchain_constants_math.MAX_UINT256);
+	if (valuationResult.error) return valuationResult;
+	if (purchaseResult.value === 0n || valuationResult.value === 0n) return { value: void 0 };
+	const maxQuotaValue = require_onchain_accounts_quota_utils.maxAmountForQuota({
+		available: market.pool.pqk.quotaAvailable(token),
+		initialQuota: initialQuotas.find((q) => q.token.toLowerCase() === token.toLowerCase())?.quota ?? 0n,
+		totalInitialQuota: initialQuotas.reduce((sum, q) => sum + require_onchain_accounts_quota_utils.roundUpQuota(q.quota), 0n),
+		maxDebt: suite.creditFacade.maxDebt,
+		lt: BigInt(suite.creditManager.liquidationThresholds.get(token) ?? 0),
+		quotaReserve: BigInt(quotaReserve)
+	});
+	if (maxQuotaValue === void 0) return { value: void 0 };
+	const quotaBalanceResult = oracle.safeConvert(market.pool.underlying, token, maxQuotaValue);
+	if (quotaBalanceResult.error) return quotaBalanceResult;
+	const quotaValueResult = oracle.safeConvert(token, market.pool.underlying, quotaBalanceResult.value);
+	if (quotaValueResult.error) return quotaValueResult;
+	const availableTokenIncrease = quotaBalanceResult.value - (quotaValueResult.value > maxQuotaValue ? 1n : 0n) - balance;
+	const excessTokenIncrease = require_onchain_utils_bigint_math.BigIntMath.max(availableTokenIncrease, 0n) + 1n;
+	if (rwaAsset?.toLowerCase() === token.toLowerCase()) {
+		const underlyingScale = 10n ** BigInt(suite.sdk.tokensMeta.decimals(market.pool.underlying));
+		const tokenScale = 10n ** BigInt(suite.sdk.tokensMeta.decimals(token));
+		return { value: require_onchain_utils_bigint_math.BigIntMath.ceilDiv(excessTokenIncrease * underlyingScale, tokenScale) - 1n };
+	}
+	const increaseResult = oracle.safeConvert(token, market.pool.underlying, excessTokenIncrease - 1n);
+	if (increaseResult.error) return increaseResult;
+	const purchaseValue = oracle.safeConvert(market.pool.underlying, token, increaseResult.value);
+	if (purchaseValue.error) return purchaseValue;
+	return { value: increaseResult.value - (purchaseValue.value >= excessTokenIncrease ? 1n : 0n) };
+}
 //#endregion
 exports.clearedQuotas = clearedQuotas;
 exports.getQuotasForUpdate = getQuotasForUpdate;
+exports.quotaIncreaseLimit = quotaIncreaseLimit;
 exports.quotasAfterUpdate = quotasAfterUpdate;
 exports.withDirectTransferQuota = withDirectTransferQuota;

package/dist/cjs/onchain/accounts/quota-utils.js

@@ -43,6 +43,14 @@ function calcRecommendedQuota({ amount, debt, lt, quotaReserve }) {
 function calcDefaultQuota({ amount, lt, quotaReserve }) {
 	return roundUpQuota(amount * lt / require_onchain_constants_math.PERCENTAGE_FACTOR * (require_onchain_constants_math.PERCENTAGE_FACTOR + quotaReserve) / require_onchain_constants_math.PERCENTAGE_FACTOR);
 }
+/** Inverse of default quota rounding, including the account-wide increase cap. */
+function maxAmountForQuota({ available, initialQuota, totalInitialQuota, maxDebt, lt, quotaReserve }) {
+	const increaseCap = roundUpQuota(require_onchain_utils_bigint_math.BigIntMath.max(roundUpQuota(maxDebt * 2n) - totalInitialQuota, 0n));
+	if (lt === 0n || increaseCap <= available) return void 0;
+	const desired = roundUpQuota(initialQuota) + roundUpQuota(available) + require_onchain_constants_math.PERCENTAGE_FACTOR - 1n;
+	const base = require_onchain_utils_bigint_math.BigIntMath.ceilDiv((desired + 1n) * require_onchain_constants_math.PERCENTAGE_FACTOR, require_onchain_constants_math.PERCENTAGE_FACTOR + quotaReserve) - 1n;
+	return require_onchain_utils_bigint_math.BigIntMath.ceilDiv((base + 1n) * require_onchain_constants_math.PERCENTAGE_FACTOR, lt) - 1n;
+}
 /**
 * Produces desired quota state and explicit increase/decrease actions.
 *
@@ -147,4 +155,5 @@ exports.DIRECT_TRANSFERS_QUOTA = DIRECT_TRANSFERS_QUOTA;
 exports.calcDefaultQuota = calcDefaultQuota;
 exports.calcQuotaUpdate = calcQuotaUpdate;
 exports.calcRecommendedQuota = calcRecommendedQuota;
+exports.maxAmountForQuota = maxAmountForQuota;
 exports.roundUpQuota = roundUpQuota;

package/dist/cjs/onchain/index.js

@@ -766,6 +766,7 @@ exports.json_parse = require_onchain_utils_json.json_parse;
 exports.json_stringify = require_onchain_utils_json.json_stringify;
 exports.lidoV1_WETHGatewayAbi = require_onchain_market_adapters_abi_targetContractAbi.lidoV1_WETHGatewayAbi;
 exports.makeReplayState = require_onchain_preview_preview_replayInnerOperations.makeReplayState;
+exports.maxAmountForQuota = require_onchain_accounts_quota_utils.maxAmountForQuota;
 exports.mellowDvvAdapterAbi = require_onchain_market_adapters_abi_adapters_mellowDvvAdapter.mellowDvvAdapterAbi;
 exports.midasGreenlistsAccount = require_onchain_preview_preview_midasGreenlistsAccount.midasGreenlistsAccount;
 exports.minSeizedAmount = require_onchain_market_math.minSeizedAmount;