@gearbox-protocol/sdk 17.12.2 → 17.13.0-next.10

package/dist/esm/offchain/analytics/OffchainAnalyticsPositions.js

@@ -1,4 +1,4 @@
-import { analyticsPositionListQuerySchema, analyticsPositionPageSchema } from "../../model/analytics.schema.js";
+import { analyticsPositionFilterOptionsQuerySchema, analyticsPositionFilterOptionsSchema, analyticsPositionListQuerySchema, analyticsPositionPageSchema } from "../../model/analytics.schema.js";
 import { AbstractOffchainNamespace } from "../AbstractOffchainNamespace.js";
 import { z } from "zod/v4";
 //#region src/offchain/analytics/OffchainAnalyticsPositions.ts
@@ -7,6 +7,14 @@ var OffchainAnalyticsPositions = class extends AbstractOffchainNamespace {
 	constructor(options) {
 		super("OffchainAnalyticsPositions", options);
 	}
+	/** {@inheritDoc IOffchainAnalyticsPositions.filterOptions} */
+	async filterOptions(filter) {
+		return this.get({
+			path: "/v2/analytics/positions/filter-options",
+			query: z.encode(analyticsPositionFilterOptionsQuerySchema, { chainIds: this.scopedChainIds(filter) }),
+			schema: analyticsPositionFilterOptionsSchema
+		});
+	}
 	/** {@inheritDoc IOffchainAnalyticsPositions.list} */
 	async list(options) {
 		return this.get({

package/dist/esm/offchain/notices/index.js

@@ -1,2 +1 @@
-import { OffchainNotices } from "./OffchainNotices.js";
-export { OffchainNotices };
+export { OffchainNotices } from "./OffchainNotices.js";

package/dist/esm/offchain/opportunities/index.js

@@ -1,3 +1,2 @@
-import { OffchainOpportunities } from "./OffchainOpportunities.js";
+export { OffchainOpportunities } from "./OffchainOpportunities.js";
 import "./types.js";
-export { OffchainOpportunities };

package/dist/esm/offchain/positions/index.js

@@ -1,3 +1,2 @@
-import { OffchainPositions } from "./OffchainPositions.js";
+export { OffchainPositions } from "./OffchainPositions.js";
 import "./types.js";
-export { OffchainPositions };

package/dist/esm/onchain/abi/index.js

@@ -1,2 +1 @@
-import { boundedPriceFeedAbi, bptStablePriceFeedAbi, bptWeightedPriceFeedAbi, chainlinkReadableAggregatorAbi, compositePriceFeedAbi, constantPriceFeedAbi, curveCryptoLpPriceFeedAbi, curveStableLpPriceFeedAbi, curveUsdPriceFeedAbi, erc4626PriceFeedAbi, iBalancerStablePoolAbi, iBalancerWeightedPoolAbi, iCurvePoolAbi, iMellowVaultAbi, iRedstonePriceFeedEventsAbi, ilpPriceFeedAbi, ilpPriceFeedEventsAbi, iwstEthAbi, iyVaultAbi, mellowLrtPriceFeedAbi, pendleTWAPPTPriceFeedAbi, pythPriceFeedAbi, redstonePriceFeedAbi, wstEthPriceFeedAbi, yearnPriceFeedAbi, zeroPriceFeedAbi } from "./oracles.js";
-export { boundedPriceFeedAbi, bptStablePriceFeedAbi, bptWeightedPriceFeedAbi, chainlinkReadableAggregatorAbi, compositePriceFeedAbi, constantPriceFeedAbi, curveCryptoLpPriceFeedAbi, curveStableLpPriceFeedAbi, curveUsdPriceFeedAbi, erc4626PriceFeedAbi, iBalancerStablePoolAbi, iBalancerWeightedPoolAbi, iCurvePoolAbi, iMellowVaultAbi, iRedstonePriceFeedEventsAbi, ilpPriceFeedAbi, ilpPriceFeedEventsAbi, iwstEthAbi, iyVaultAbi, mellowLrtPriceFeedAbi, pendleTWAPPTPriceFeedAbi, pythPriceFeedAbi, redstonePriceFeedAbi, wstEthPriceFeedAbi, yearnPriceFeedAbi, zeroPriceFeedAbi };
+export { boundedPriceFeedAbi, bptStablePriceFeedAbi, bptWeightedPriceFeedAbi, chainlinkReadableAggregatorAbi, compositePriceFeedAbi, constantPriceFeedAbi, curveCryptoLpPriceFeedAbi, curveStableLpPriceFeedAbi, curveUsdPriceFeedAbi, erc4626PriceFeedAbi, iBalancerStablePoolAbi, iBalancerWeightedPoolAbi, iCurvePoolAbi, iMellowVaultAbi, iRedstonePriceFeedEventsAbi, ilpPriceFeedAbi, ilpPriceFeedEventsAbi, iwstEthAbi, iyVaultAbi, mellowLrtPriceFeedAbi, pendleTWAPPTPriceFeedAbi, pythPriceFeedAbi, redstonePriceFeedAbi, wstEthPriceFeedAbi, yearnPriceFeedAbi, zeroPriceFeedAbi } from "./oracles.js";

package/dist/esm/onchain/accounts/CreditAccountsServiceV310.js

@@ -93,43 +93,6 @@ var CreditAccountsServiceV310 = class extends SDKConstruct {
 		return Object.values(r);
 	}
 	/**
-	* {@inheritDoc ICreditAccountsService.fullyLiquidate}
-	**/
-	async fullyLiquidate(props) {
-		const { account, to, slippage = 50n, keepAssets, ignoreReservePrices, applyLossPolicy, debtOnly } = props;
-		const cm = this.sdk.marketRegister.findCreditManager(account.creditManager);
-		const routerCloseResult = await this.sdk.routerFor(account).findBestClosePath({
-			creditAccount: account,
-			creditManager: cm.creditManager,
-			slippage,
-			keepAssets,
-			debtOnly
-		});
-		const calls = await this.prependPriceUpdates(account.creditManager, routerCloseResult.calls, account, { ignoreReservePrices });
-		let lossPolicyData;
-		if (applyLossPolicy) {
-			lossPolicyData = await this.sdk.marketRegister.findByCreditManager(account.creditManager).lossPolicy.getLiquidationData(account.creditAccount);
-			this.logger?.debug({ lossPolicyData }, "loss policy data");
-		}
-		return {
-			tx: cm.creditFacade.liquidateCreditAccount(account.creditAccount, to, calls, lossPolicyData),
-			calls,
-			routerCloseResult,
-			lossPolicyData,
-			creditFacade: cm.creditFacade
-		};
-	}
-	/**
-	* {@inheritDoc ICreditAccountsService.partiallyLiquidate}
-	*/
-	async partiallyLiquidate(props) {
-		const { account, to } = props;
-		const cm = this.sdk.marketRegister.findCreditManager(account.creditManager);
-		const { tokenOut, repaidAmount, minSeizedAmount } = cm.partialLiquidationParams(account, props);
-		const updates = await this.getOnDemandPriceUpdates(account, true);
-		return cm.creditFacade.partiallyLiquidateCreditAccount(account.creditAccount, tokenOut, repaidAmount, minSeizedAmount, to, updates);
-	}
-	/**
 	* {@inheritDoc ICreditAccountsService.assembleCloseCreditAccountCalls}
 	*/
 	async assembleCloseCreditAccountCalls({ creditAccount: ca, routerCalls, assetsToWithdraw, to }) {

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

@@ -10,6 +10,7 @@ import { fetchCreditAccountSlice, toCreditAccountSlice } from "./intents/utils/c
 import { DIRECT_TRANSFERS_QUOTA, calcDefaultQuota, calcQuotaUpdate, calcRecommendedQuota, maxAmountForQuota, roundUpQuota } from "./quota-utils.js";
 import { CreditAccountOperationsService } from "./intents/index.js";
 import { LIQUIDATION_APPROVAL_BUFFER, LIQUIDATION_COMPRESSOR_V313_ADDRESS } from "./liquidations/constants.js";
+import { optimalPartialLiquidation, partialLiquidationParams } from "./liquidations/partialLiquidation.js";
 import { LiquidationsService } from "./liquidations/LiquidationsService.js";
 import { MultichainLiquidationsService } from "./liquidations/MultichainLiquidationsService.js";
 import "./liquidations/index.js";
@@ -25,4 +26,4 @@ import { toWithdrawalStatus } from "./withdrawal-compressor/types.js";
 import { WithdrawalCompressorV313Contract } from "./withdrawal-compressor/WithdrawalCompressorV313Contract.js";
 import { createWithdrawalCompressor } from "./withdrawal-compressor/createWithdrawalCompressor.js";
 import "./withdrawal-compressor/index.js";
-export { AbstractWithdrawalCompressorContract, AccountBotsService, CreditAccountCompressor, CreditAccountCompressorV310Contract, CreditAccountOperationsService, CreditAccountsServiceV310, DELAYED_INTENT_TYPES, DELAYED_INTENT_VERSION, DIRECT_TRANSFERS_QUOTA, LIQUIDATION_APPROVAL_BUFFER, LIQUIDATION_COMPRESSOR_V313_ADDRESS, LiquidationsService, MultichainLiquidationsService, PeripheryCompressorV310Contract, RedemptionLoggerV310Contract, WithdrawalCompressorV310Contract, WithdrawalCompressorV311Contract, WithdrawalCompressorV313Contract, calcDefaultQuota, calcQuotaUpdate, calcRecommendedQuota, createRedemptionLogger, createWithdrawalCompressor, decodeDelayedIntent, encodeDelayedIntent, fetchCreditAccountSlice, getWithdrawalCompressorAddress, iCreditAccountAbi, isPhantomToken, maxAmountForQuota, roundUpQuota, toClaimableWithdrawal, toCreditAccountSlice, toPendingWithdrawal, toRequestableWithdrawal, toWithdrawalStatus };
+export { AbstractWithdrawalCompressorContract, AccountBotsService, CreditAccountCompressor, CreditAccountCompressorV310Contract, CreditAccountOperationsService, CreditAccountsServiceV310, DELAYED_INTENT_TYPES, DELAYED_INTENT_VERSION, DIRECT_TRANSFERS_QUOTA, LIQUIDATION_APPROVAL_BUFFER, LIQUIDATION_COMPRESSOR_V313_ADDRESS, LiquidationsService, MultichainLiquidationsService, PeripheryCompressorV310Contract, RedemptionLoggerV310Contract, WithdrawalCompressorV310Contract, WithdrawalCompressorV311Contract, WithdrawalCompressorV313Contract, calcDefaultQuota, calcQuotaUpdate, calcRecommendedQuota, createRedemptionLogger, createWithdrawalCompressor, decodeDelayedIntent, encodeDelayedIntent, fetchCreditAccountSlice, getWithdrawalCompressorAddress, iCreditAccountAbi, isPhantomToken, maxAmountForQuota, optimalPartialLiquidation, partialLiquidationParams, roundUpQuota, toClaimableWithdrawal, toCreditAccountSlice, toPendingWithdrawal, toRequestableWithdrawal, toWithdrawalStatus };

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

@@ -16,7 +16,7 @@ import { calcLeverageBand } from "./leverage-band.js";
 import { maxBorrow } from "./maxBorrow.js";
 import { maxWithdrawCollateral } from "./maxWithdrawCollateral.js";
 import { buildOpenStrategyState } from "./open-strategy.js";
-import { planAddCollateral, planAdjustLeverage, planAdjustLeverageDelayed, planDeposit, planRepay, planWithdraw, planWithdrawAsset, planWithdrawDelayed } from "./plan.js";
+import { planAddCollateral, planAdjustLeverage, planAdjustLeverageDelayed, planDeposit, planRepay, planUpdateQuota, planWithdraw, planWithdrawAsset, planWithdrawDelayed } from "./plan.js";
 import { withdrawLimits } from "./withdraw-limits.js";
 import { realize } from "./realize.js";
 import { planTail, projectTail } from "./tail.js";
@@ -64,6 +64,7 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 				case "DEPOSIT": return planDeposit(intent, view);
 				case "REPAY": return planRepay(intent, view);
 				case "WITHDRAW": return planWithdraw(intent, view);
+				case "UPDATE_QUOTA": return planUpdateQuota(intent, view);
 				default: throw new Error(`${intent.type} - not implemented`);
 			}
 		}, limits));

package/dist/esm/onchain/accounts/intents/operations.js

@@ -67,7 +67,7 @@ function buildQuotaUpdateOperation(input) {
 	const quotaAssets = [...update.quotaIncrease, ...update.quotaDecrease];
 	const calls = quotaAssets.length === 0 ? [] : sdk.accounts.prepareUpdateQuotas(creditAccount.creditFacade, {
 		averageQuota: quotaAssets,
-		minQuota: quotaAssets
+		minQuota: input.minQuota ?? quotaAssets
 	});
 	return {
 		type: "changeQuota",

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

@@ -1,4 +1,4 @@
-import { MAX_UINT256, PERCENTAGE_FACTOR } from "../../constants/math.js";
+import { MAX_UINT256, PERCENTAGE_FACTOR, isZeroBalance } from "../../constants/math.js";
 import "../../constants/index.js";
 import { debtOutOfRange, insufficientBalance, leverageOutOfRange } from "../../../model/errors/operation-errors.js";
 import { noDelayedRoute, unsupportedCollateralToken } from "../../../model/errors/prepare-errors.js";
@@ -86,6 +86,26 @@ function planRepay(intent, view) {
 	];
 }
 /**
+* One token's quota changes; no balance moves and debt is untouched.
+*
+* Only a token the account holds can be quoted here, and only on an account
+* that owes something: the facade refuses any quota change at zero debt.
+*/
+function planUpdateQuota(intent, view) {
+	const U = view.underlying;
+	if (eq(intent.token, U) || isZeroBalance(view.balanceOf(intent.token))) throw new IntentPreviewError(unsupportedCollateralToken(toToken(view.sdk, intent.token)), `updateQuota: ${intent.token} is the underlying or not held by the account`);
+	if (view.debt <= 0n) throw new IntentPreviewError(debtOutOfRange({
+		requested: toTokenAmount(view.sdk, U, 0n),
+		minDebt: toTokenAmount(view.sdk, U, view.debtLimits.minDebt),
+		maxDebt: toTokenAmount(view.sdk, U, view.debtLimits.maxDebt)
+	}), "updateQuota: the account has zero debt");
+	return [{
+		kind: "updateQuota",
+		token: intent.token,
+		quota: intent.quota
+	}];
+}
+/**
 * Intent 2.1: `W` of value leaves, debt shrinks by `D0 · W / C0` so leverage
 * holds. Both are funded by the source `S`.
 */
@@ -407,4 +427,4 @@ function assertPositive(amount, flow) {
 	if (amount <= 0n) throw new IntentPreviewError(insufficientBalance(), `${flow}: amount must be positive`);
 }
 //#endregion
-export { RAISED, planAddCollateral, planAdjustLeverage, planAdjustLeverageDelayed, planDeposit, planFinishClaimOnly, planFinishCloseAccount, planFinishDecreaseLeverage, planFinishWithdraw, planRepay, planWithdraw, planWithdrawAsset, planWithdrawDelayed };
+export { RAISED, planAddCollateral, planAdjustLeverage, planAdjustLeverageDelayed, planDeposit, planFinishClaimOnly, planFinishCloseAccount, planFinishDecreaseLeverage, planFinishWithdraw, planRepay, planUpdateQuota, planWithdraw, planWithdrawAsset, planWithdrawDelayed };

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

@@ -13,6 +13,7 @@ import { collectPriceImpact } from "./utils/price-impact.js";
 import { clearedQuotas, getQuotasForUpdate, quotasAfterUpdate, withDirectTransferQuota } from "./utils/quotas-for-update.js";
 import { createRouterPaths } from "./utils/router-path.js";
 import { buildAddCollateralOperation, buildClaimDelayedWithdrawalOperation, buildCloseSwapOperation, buildDecreaseDebtOperation, buildIncreaseDebtOperation, buildQuotaUpdateOperation, buildStartDelayedWithdrawalOperation, buildSwapOperation, buildUnwrapRwaCollateralOperation, buildWithdrawCollateralOperation, buildWrapRwaCollateralOperation, instantOutput } from "./operations.js";
+import { resolveQuotaUpdate } from "./resolveQuotaUpdate.js";
 import { withdrawLimits } from "./withdraw-limits.js";
 //#region src/onchain/accounts/intents/realize.ts
 /**
@@ -98,10 +99,11 @@ async function realize(steps, props) {
 		traded.returnedUnd += underlyingValue(returned);
 	};
 	/**
-	* Set by a `clearQuotas` step, which settles the quotas mid-walk instead of
-	* at the end — and settles them at none, whatever the balances turn out to be.
+	* Set by a step that settles the quotas itself, mid-walk instead of at the
+	* end, whatever the balances turn out to be: `clearQuotas` at none,
+	* `updateQuota` at the one the intent names.
 	*/
-	let cleared;
+	let plannedQuotas;
 	/**
 	* Whether anything leaves the account, which is what makes the credit manager
 	* judge the closing collateral check at safe prices.
@@ -147,14 +149,34 @@ async function realize(steps, props) {
 			}));
 			break;
 		}
-		case "clearQuotas":
-			cleared = clearedQuotas(creditAccount.tokens);
+		case "clearQuotas": {
+			const cleared = clearedQuotas(creditAccount.tokens);
+			plannedQuotas = cleared;
 			if (cleared.quotaDecrease.length > 0) push(buildQuotaUpdateOperation({
 				update: cleared,
 				creditAccount,
 				sdk
 			}));
 			break;
+		}
+		case "updateQuota": {
+			const { update, minQuota } = resolveQuotaUpdate({
+				sdk,
+				creditAccount,
+				token: step.token,
+				quota: step.quota,
+				quotaReserve,
+				limits: props.limits
+			});
+			plannedQuotas = update;
+			push(buildQuotaUpdateOperation({
+				update,
+				creditAccount,
+				sdk,
+				minQuota
+			}));
+			break;
+		}
 		case "convert": {
 			const amount = amountOf(step.amount);
 			if (amount <= 0n) {
@@ -335,7 +357,7 @@ async function realize(steps, props) {
 	const floor = ledger.snapshot();
 	const { assets, debt } = floor;
 	const projected = expected.snapshot();
-	const quotas = cleared ?? withDirectTransferQuota(getQuotasForUpdate({
+	const quotas = plannedQuotas ?? withDirectTransferQuota(getQuotasForUpdate({
 		assetsBefore: creditAccount.tokens,
 		assetsAfter: assets,
 		initialQuotas: creditAccount.tokens,
@@ -398,7 +420,7 @@ async function realize(steps, props) {
 		after: projected.assets,
 		limits: props.limits
 	});
-	if (!cleared && quotas.quotaIncrease.length + quotas.quotaDecrease.length > 0) {
+	if (!plannedQuotas && quotas.quotaIncrease.length + quotas.quotaDecrease.length > 0) {
 		assertQuotaAvailable(sdk, market, quotas.quotaIncrease, props.limits);
 		push(buildQuotaUpdateOperation({
 			update: quotas,

package/dist/esm/onchain/accounts/intents/resolveQuotaUpdate.js

@@ -0,0 +1,148 @@
+import { BigIntMath } from "../../utils/bigint-math.js";
+import { MAX_QUOTA_MULTIPLIER, MIN_INT96, PERCENTAGE_FACTOR } from "../../constants/math.js";
+import { toToken } from "../../validation/helpers/token.js";
+import { checkForbiddenToken } from "../../validation/checks/checkForbiddenToken.js";
+import { checkMaxQuota } from "../../validation/checks/checkMaxQuota.js";
+import { checkQuotaActive } from "../../validation/checks/checkQuotaActive.js";
+import { checkQuotaChange } from "../../validation/checks/checkQuotaChange.js";
+import { checkQuotaLimit } from "../../validation/checks/checkQuotaLimit.js";
+import { raise } from "../../validation/raise.js";
+import "../../validation/index.js";
+import { eq } from "./utils/common.js";
+import { assertQuotaAvailable } from "./guards.js";
+import { roundUpQuota } from "../quota-utils.js";
+import { resizedQuota } from "./utils/quotas-for-update.js";
+//#region src/onchain/accounts/intents/resolveQuotaUpdate.ts
+/**
+* Synchronous calculation from the SDK's loaded market state; no RPC reads.
+* @throws IntentPreviewError when quota validation rejects the change.
+*
+* The single `updateQuota` an `UPDATE_QUOTA` intent sends, checked against
+* what the facade and the quota keeper would revert on.
+*
+* A target is taken as named and refused when the market cannot meet it. A
+* sized quota is held to what the market can give instead: an increase is capped
+* at the pool's available quota, and `minQuota` accepts a partial fill so long as the
+* token stays enabled.
+*/
+function resolveQuotaUpdate(props) {
+	const { sdk, creditAccount, quotaReserve, limits } = props;
+	const suite = sdk.marketRegister.findCreditManager(creditAccount.creditManager);
+	const { market } = suite;
+	const { pqk } = market.pool;
+	const tokenLc = props.token.toLowerCase();
+	const token = toToken(sdk, tokenLc);
+	const underlying = toToken(sdk, market.pool.underlying);
+	const current = creditAccount.tokens.find((t) => eq(t.token, tokenLc))?.quota ?? 0n;
+	raise(checkQuotaActive({
+		token,
+		isActive: pqk.quotas.get(tokenLc)?.isActive ?? false
+	}), `updateQuota: ${tokenLc} has no active quota`);
+	let resolved;
+	if (props.quota === void 0) {
+		const price = (from, to, amount) => market.priceOracle.safeConvert(from, to, amount).value;
+		resolved = sizedChange(current, resizedQuota({
+			token: tokenLc,
+			assets: creditAccount.tokens,
+			initialQuotas: creditAccount.tokens,
+			quotaReserve,
+			underlyingToken: market.pool.underlying,
+			liquidationThresholds: suite.creditManager.liquidationThresholds,
+			quotas: pqk.quotas,
+			maxDebt: suite.creditFacade.maxDebt,
+			convert: price
+		}), tokenLc, roundUpQuota(pqk.quotaAvailable(tokenLc)));
+		if (resolved.change === 0n && resolved.requested > current) raise(checkQuotaLimit({
+			token,
+			requested: resolved.requested - current,
+			available: 0n,
+			...limits,
+			underlying
+		}), `updateQuota: the pool has no quota left for ${tokenLc}`);
+	} else resolved = targetChange(current, props.quota);
+	const { requested, change, resulting } = resolved;
+	raise(checkQuotaChange({
+		token,
+		current,
+		requested,
+		change,
+		underlying
+	}), `updateQuota: ${requested} rounds to the current ${current}`);
+	if (change > 0n) raise(checkForbiddenToken({
+		token,
+		isForbidden: suite.isForbidden(tokenLc)
+	}), `updateQuota: ${tokenLc} is forbidden, its quota cannot grow`);
+	if (props.quota !== void 0) {
+		const maxQuota = MAX_QUOTA_MULTIPLIER * suite.creditFacade.maxDebt;
+		raise(checkMaxQuota({
+			token,
+			requested: resulting,
+			maxQuota,
+			underlying
+		}), `updateQuota: ${resulting} exceeds maxQuota ${maxQuota}`);
+		if (change > 0n) assertQuotaAvailable(sdk, market, [{
+			token: tokenLc,
+			balance: change
+		}], limits);
+	}
+	const entry = {
+		token: tokenLc,
+		balance: change
+	};
+	return {
+		update: {
+			desiredQuota: { [tokenLc]: {
+				token: tokenLc,
+				balance: resulting
+			} },
+			quotaIncrease: change > 0n ? [entry] : [],
+			quotaDecrease: change < 0n ? [entry] : []
+		},
+		minQuota: [{
+			token: tokenLc,
+			balance: resolved.minQuota
+		}]
+	};
+}
+function targetChange(current, quota) {
+	const target = BigIntMath.max(quota, 0n);
+	if (target === 0n) return {
+		requested: 0n,
+		change: current > 0n ? MIN_INT96 : 0n,
+		resulting: 0n,
+		minQuota: 0n
+	};
+	const change = roundUpQuota(target - current);
+	return {
+		requested: target,
+		change,
+		resulting: current + change,
+		minQuota: current + change
+	};
+}
+/**
+* Reads the one token's change back out of {@link resizedQuota}, then caps an
+* increase at `available`.
+*/
+function sizedChange(current, sized, token, available) {
+	const requested = sized.desiredQuota[token]?.balance ?? current;
+	const decrease = sized.quotaDecrease.find((a) => a.token === token)?.balance;
+	if (decrease !== void 0) {
+		const resulting = decrease === -39614081257132168796771975168n ? 0n : current + decrease;
+		return {
+			requested,
+			change: decrease,
+			resulting,
+			minQuota: resulting
+		};
+	}
+	const increase = BigIntMath.min(sized.quotaIncrease.find((a) => a.token === token)?.balance ?? 0n, available);
+	return {
+		requested,
+		change: increase,
+		resulting: current + increase,
+		minQuota: increase > 0n ? BigIntMath.max(current, PERCENTAGE_FACTOR) : current
+	};
+}
+//#endregion
+export { resolveQuotaUpdate };

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

@@ -340,6 +340,7 @@ function buildMockSdk(args) {
 			} }
 		},
 		marketRegister: {
+			creditManagers: [creditManagerSuite],
 			findByCreditManager: vi.fn(() => market),
 			findCreditManager: vi.fn(() => creditManagerSuite)
 		},

package/dist/esm/onchain/accounts/intents/tests/update-quota.fixtures.js

@@ -0,0 +1,92 @@
+import { MIN_INT96 } from "../../../constants/math.js";
+import { ANY, buildFixtureCreditAccount, buildMarketSdk, caToken, valueInUnd } from "../testing/market.js";
+//#region src/onchain/accounts/intents/tests/update-quota.fixtures.ts
+/**
+* Start update-quota fixtures.
+*
+* The account holds 1000 UND and 2000 ANY (another 1000 UND) against 500 UND of
+* debt. Nothing moves, so every case is a single `changeQuota` and the totals
+* stand still.
+*/
+const BASE_UND = 100000000000n;
+const BALANCE_ANY = 2000000000000000000000n;
+const DEBT = 50000000000n;
+/** What 2000 ANY is sized to: 1000 UND × 92%. */
+const SIZED_ANY = 92000000000n;
+const TOTAL_VALUE = BASE_UND + valueInUnd(BALANCE_ANY, ANY);
+/** Omitted quota on an unquoted balance: bought at balance × LT. */
+const case_auto_increase = {
+	intent: {
+		type: "UPDATE_QUOTA",
+		token: ANY
+	},
+	current: 0n,
+	ops: [{
+		type: "changeQuota",
+		quotaIncrease: [{
+			token: ANY,
+			balance: SIZED_ANY
+		}],
+		quotaDecrease: [],
+		desiredQuota: {}
+	}],
+	quotaAfter: SIZED_ANY,
+	minQuota: 10000n
+};
+/** A lower target: the quota drops to exactly it. */
+const case_target_decrease = {
+	intent: {
+		type: "UPDATE_QUOTA",
+		token: ANY,
+		quota: 40000000000n
+	},
+	current: SIZED_ANY,
+	ops: [{
+		type: "changeQuota",
+		quotaIncrease: [],
+		quotaDecrease: [{
+			token: ANY,
+			balance: 40000000000n - SIZED_ANY
+		}],
+		desiredQuota: {}
+	}],
+	quotaAfter: 40000000000n,
+	minQuota: 40000000000n
+};
+/** Target 0: the quota is reset with the sentinel. */
+const case_target_disable = {
+	intent: {
+		type: "UPDATE_QUOTA",
+		token: ANY,
+		quota: 0n
+	},
+	current: SIZED_ANY,
+	ops: [{
+		type: "changeQuota",
+		quotaIncrease: [],
+		quotaDecrease: [{
+			token: ANY,
+			balance: MIN_INT96
+		}],
+		desiredQuota: {}
+	}],
+	quotaAfter: 0n,
+	minQuota: 0n
+};
+function buildUpdateQuotaSdk(c) {
+	return buildMarketSdk(c.extras);
+}
+function buildUpdateQuotaProps(c, sdk) {
+	return {
+		intent: c.intent,
+		creditAccount: buildFixtureCreditAccount({
+			totalDebt: c.totalDebt ?? 50000000000n,
+			tokens: [...c.others ?? [caToken("0x3333333333333333333333333333333333333333", 100000000000n)], caToken(ANY, BALANCE_ANY, c.current)]
+		}),
+		sdk,
+		quotaReserve: void 0,
+		slippage: void 0
+	};
+}
+//#endregion
+export { BALANCE_ANY, BASE_UND, DEBT, SIZED_ANY, TOTAL_VALUE, buildUpdateQuotaProps, buildUpdateQuotaSdk, case_auto_increase, case_target_decrease, case_target_disable };

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

@@ -6,6 +6,6 @@ import { calcBorrowedAmountPlusInterestAndFees } from "./borrowed-amount-plus-in
 import { fetchCreditAccountSlice, toCreditAccountSlice, unopenedAccountSlice } from "./credit-account-slice.js";
 import { OperationLedger } from "./ledger.js";
 import { collectPriceImpact, lossRate, startProbe } from "./price-impact.js";
-import { clearedQuotas, getQuotasForUpdate, quotaIncreaseLimit, quotasAfterUpdate, withDirectTransferQuota } from "./quotas-for-update.js";
+import { clearedQuotas, getQuotasForUpdate, quotaIncreaseLimit, quotasAfterUpdate, resizedQuota, withDirectTransferQuota } from "./quotas-for-update.js";
 import { createOraclePaths, createRouterPaths } from "./router-path.js";
-export { OperationLedger, adjustStateToSnapshot, assembleOperationCalls, calcBorrowedAmountPlusInterestAndFees, clearedQuotas, collectPriceImpact, createOraclePaths, createRouterPaths, eq, fetchCreditAccountSlice, getQuotasForUpdate, isPhantomToken, isRedemptionPhantomToken, lossRate, pickFattestNonPhantomToken, quotaIncreaseLimit, quotasAfterUpdate, rankAccountTokens, resolveCreditManager, startProbe, toCreditAccountSlice, toRouterCaSlice, toTargetDecimals, unopenedAccountSlice, withDirectTransferQuota };
+export { OperationLedger, adjustStateToSnapshot, assembleOperationCalls, calcBorrowedAmountPlusInterestAndFees, clearedQuotas, collectPriceImpact, createOraclePaths, createRouterPaths, eq, fetchCreditAccountSlice, getQuotasForUpdate, isPhantomToken, isRedemptionPhantomToken, lossRate, pickFattestNonPhantomToken, quotaIncreaseLimit, quotasAfterUpdate, rankAccountTokens, resizedQuota, resolveCreditManager, startProbe, toCreditAccountSlice, toRouterCaSlice, toTargetDecimals, unopenedAccountSlice, withDirectTransferQuota };

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

@@ -4,17 +4,28 @@ import { TypedObjectUtils } from "../../../utils/mappers.js";
 import "../../../constants/index.js";
 import { DIRECT_TRANSFERS_QUOTA, calcQuotaUpdate, maxAmountForQuota, roundUpQuota } from "../../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 }) {
+function getQuotasForUpdate(props) {
+	const assetsAfterLc = lowercased(props.assetsAfter);
+	const { spend, obtain } = collectQuotaChange(lowercased(props.assetsBefore), assetsAfterLc);
+	return sizeQuotas(assetsAfterLc, spend, obtain, props);
+}
+/**
+* The update that sizes one token's quota to the balance the account holds of
+* it, whatever moved.
+*
+* Sits beside {@link getQuotasForUpdate} because that one only resizes what an
+* operation spent or obtained, and an operation that changes a quota alone
+* moves no balance at all.
+*/
+function resizedQuota(props) {
+	const entry = [{
+		token: props.token.toLowerCase(),
+		balance: 0n
+	}];
+	return sizeQuotas(lowercased(props.assets), entry, entry, props);
+}
+function sizeQuotas(assetsAfterLc, spend, obtain, { initialQuotas, quotaReserve = 0, liquidationThresholds: liquidationThresholdsMap, quotas: quotasMap, maxDebt, underlyingToken, convert }) {
 	const underlyingTokenLc = underlyingToken.toLowerCase();
-	const assetsBeforeLc = assetsBefore.map((a) => ({
-		...a,
-		token: a.token.toLowerCase()
-	}));
-	const assetsAfterLc = assetsAfter.map((a) => ({
-		...a,
-		token: a.token.toLowerCase()
-	}));
-	const { spend, obtain } = collectQuotaChange(assetsBeforeLc, assetsAfterLc);
 	const initialQuotasLc = initialQuotas.map((a) => {
 		const tokenLc = a.token.toLowerCase();
 		return [tokenLc, {
@@ -130,6 +141,12 @@ function quotasAfterUpdate(initialQuotas, desiredQuota) {
 	else delete after[token];
 	return after;
 }
+function lowercased(assets) {
+	return assets.map((a) => ({
+		...a,
+		token: a.token.toLowerCase()
+	}));
+}
 function collectQuotaChange(assetsBefore, assetsAfter) {
 	const before = new Map(assetsBefore.map((a) => [a.token, a.balance]));
 	const after = new Map(assetsAfter.map((a) => [a.token, a.balance]));
@@ -233,4 +250,4 @@ function quotaIncreaseLimit({ suite, token, balance, initialQuotas, quotaReserve
 	return { value: increaseResult.value - (purchaseValue.value >= excessTokenIncrease ? 1n : 0n) };
 }
 //#endregion
-export { clearedQuotas, getQuotasForUpdate, quotaIncreaseLimit, quotasAfterUpdate, withDirectTransferQuota };
+export { clearedQuotas, getQuotasForUpdate, quotaIncreaseLimit, quotasAfterUpdate, resizedQuota, withDirectTransferQuota };