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

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

@@ -0,0 +1,149 @@
+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_validation_helpers_token = require("../../validation/helpers/token.js");
+const require_onchain_validation_checks_checkForbiddenToken = require("../../validation/checks/checkForbiddenToken.js");
+const require_onchain_validation_checks_checkMaxQuota = require("../../validation/checks/checkMaxQuota.js");
+const require_onchain_validation_checks_checkQuotaActive = require("../../validation/checks/checkQuotaActive.js");
+const require_onchain_validation_checks_checkQuotaChange = require("../../validation/checks/checkQuotaChange.js");
+const require_onchain_validation_checks_checkQuotaLimit = require("../../validation/checks/checkQuotaLimit.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");
+const require_onchain_accounts_intents_guards = require("./guards.js");
+const require_onchain_accounts_quota_utils = require("../quota-utils.js");
+const require_onchain_accounts_intents_utils_quotas_for_update = require("./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 = require_onchain_validation_helpers_token.toToken(sdk, tokenLc);
+	const underlying = require_onchain_validation_helpers_token.toToken(sdk, market.pool.underlying);
+	const current = creditAccount.tokens.find((t) => require_onchain_accounts_intents_utils_common.eq(t.token, tokenLc))?.quota ?? 0n;
+	require_onchain_validation_raise.raise(require_onchain_validation_checks_checkQuotaActive.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, require_onchain_accounts_intents_utils_quotas_for_update.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, require_onchain_accounts_quota_utils.roundUpQuota(pqk.quotaAvailable(tokenLc)));
+		if (resolved.change === 0n && resolved.requested > current) require_onchain_validation_raise.raise(require_onchain_validation_checks_checkQuotaLimit.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;
+	require_onchain_validation_raise.raise(require_onchain_validation_checks_checkQuotaChange.checkQuotaChange({
+		token,
+		current,
+		requested,
+		change,
+		underlying
+	}), `updateQuota: ${requested} rounds to the current ${current}`);
+	if (change > 0n) require_onchain_validation_raise.raise(require_onchain_validation_checks_checkForbiddenToken.checkForbiddenToken({
+		token,
+		isForbidden: suite.isForbidden(tokenLc)
+	}), `updateQuota: ${tokenLc} is forbidden, its quota cannot grow`);
+	if (props.quota !== void 0) {
+		const maxQuota = require_onchain_constants_math.MAX_QUOTA_MULTIPLIER * suite.creditFacade.maxDebt;
+		require_onchain_validation_raise.raise(require_onchain_validation_checks_checkMaxQuota.checkMaxQuota({
+			token,
+			requested: resulting,
+			maxQuota,
+			underlying
+		}), `updateQuota: ${resulting} exceeds maxQuota ${maxQuota}`);
+		if (change > 0n) require_onchain_accounts_intents_guards.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 = require_onchain_utils_bigint_math.BigIntMath.max(quota, 0n);
+	if (target === 0n) return {
+		requested: 0n,
+		change: current > 0n ? require_onchain_constants_math.MIN_INT96 : 0n,
+		resulting: 0n,
+		minQuota: 0n
+	};
+	const change = require_onchain_accounts_quota_utils.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 = require_onchain_utils_bigint_math.BigIntMath.min(sized.quotaIncrease.find((a) => a.token === token)?.balance ?? 0n, available);
+	return {
+		requested,
+		change: increase,
+		resulting: current + increase,
+		minQuota: increase > 0n ? require_onchain_utils_bigint_math.BigIntMath.max(current, require_onchain_constants_math.PERCENTAGE_FACTOR) : current
+	};
+}
+//#endregion
+exports.resolveQuotaUpdate = resolveQuotaUpdate;

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

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

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

@@ -0,0 +1,102 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_constants_math = require("../../../constants/math.js");
+const require_market = require("../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 + require_market.valueInUnd(BALANCE_ANY, require_market.ANY);
+/** Omitted quota on an unquoted balance: bought at balance × LT. */
+const case_auto_increase = {
+	intent: {
+		type: "UPDATE_QUOTA",
+		token: require_market.ANY
+	},
+	current: 0n,
+	ops: [{
+		type: "changeQuota",
+		quotaIncrease: [{
+			token: require_market.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: require_market.ANY,
+		quota: 40000000000n
+	},
+	current: SIZED_ANY,
+	ops: [{
+		type: "changeQuota",
+		quotaIncrease: [],
+		quotaDecrease: [{
+			token: require_market.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: require_market.ANY,
+		quota: 0n
+	},
+	current: SIZED_ANY,
+	ops: [{
+		type: "changeQuota",
+		quotaIncrease: [],
+		quotaDecrease: [{
+			token: require_market.ANY,
+			balance: require_onchain_constants_math.MIN_INT96
+		}],
+		desiredQuota: {}
+	}],
+	quotaAfter: 0n,
+	minQuota: 0n
+};
+function buildUpdateQuotaSdk(c) {
+	return require_market.buildMarketSdk(c.extras);
+}
+function buildUpdateQuotaProps(c, sdk) {
+	return {
+		intent: c.intent,
+		creditAccount: require_market.buildFixtureCreditAccount({
+			totalDebt: c.totalDebt ?? 50000000000n,
+			tokens: [...c.others ?? [require_market.caToken("0x3333333333333333333333333333333333333333", 100000000000n)], require_market.caToken(require_market.ANY, BALANCE_ANY, c.current)]
+		}),
+		sdk,
+		quotaReserve: void 0,
+		slippage: void 0
+	};
+}
+//#endregion
+exports.BALANCE_ANY = BALANCE_ANY;
+exports.BASE_UND = BASE_UND;
+exports.DEBT = DEBT;
+exports.SIZED_ANY = SIZED_ANY;
+exports.TOTAL_VALUE = TOTAL_VALUE;
+exports.buildUpdateQuotaProps = buildUpdateQuotaProps;
+exports.buildUpdateQuotaSdk = buildUpdateQuotaSdk;
+exports.case_auto_increase = case_auto_increase;
+exports.case_target_decrease = case_target_decrease;
+exports.case_target_disable = case_target_disable;

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

@@ -27,6 +27,7 @@ exports.pickFattestNonPhantomToken = require_onchain_accounts_intents_utils_pick
 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.resizedQuota = require_onchain_accounts_intents_utils_quotas_for_update.resizedQuota;
 exports.resolveCreditManager = require_onchain_accounts_intents_utils_common.resolveCreditManager;
 exports.startProbe = require_onchain_accounts_intents_utils_price_impact.startProbe;
 exports.toCreditAccountSlice = require_onchain_accounts_intents_utils_credit_account_slice.toCreditAccountSlice;

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

@@ -5,17 +5,28 @@ 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 }) {
+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, {
@@ -131,6 +142,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]));
@@ -238,4 +255,5 @@ exports.clearedQuotas = clearedQuotas;
 exports.getQuotasForUpdate = getQuotasForUpdate;
 exports.quotaIncreaseLimit = quotaIncreaseLimit;
 exports.quotasAfterUpdate = quotasAfterUpdate;
+exports.resizedQuota = resizedQuota;
 exports.withDirectTransferQuota = withDirectTransferQuota;

package/dist/cjs/onchain/accounts/liquidations/LiquidationsService.js

@@ -21,7 +21,9 @@ const require_onchain_market_rwa_securitize_SecuritizeLiquidatorContract = requi
 require("../../market/rwa/securitize/index.js");
 require("../../market/index.js");
 const require_onchain_accounts_liquidations_constants = require("./constants.js");
+const require_onchain_accounts_liquidations_partialLiquidation = require("./partialLiquidation.js");
 const require_onchain_accounts_liquidations_skipLiquidatableAccount = require("./skipLiquidatableAccount.js");
+let viem = require("viem");
 //#region src/onchain/accounts/liquidations/LiquidationsService.ts
 /**
 * Service for discovering liquidatable credit accounts and previewing manual
@@ -70,7 +72,8 @@ var LiquidationsService = class extends require_onchain_base_SDKConstruct.SDKCon
 			isCreditAccountFrozen: data.isCreditAccountFrozen,
 			kycProtocol: data.kycProtocol || void 0,
 			kycToken: require_onchain_utils_hex.hexEq(data.kycToken, "0x0000000000000000000000000000000000000000") ? void 0 : this.sdk.tokensMeta.getToken(data.kycToken),
-			approve: this.#liquidationApproval(data, suite, priceOracle)
+			approve: this.#liquidationApproval(data, suite, priceOracle),
+			isPartial: false
 		};
 	}
 	/**
@@ -88,6 +91,130 @@ var LiquidationsService = class extends require_onchain_base_SDKConstruct.SDKCon
 		};
 	}
 	/**
+	* Builds the transaction that fully liquidates a credit account, repaying
+	* the debt by swapping the account's own collateral through the router.
+	* The underlying left after the swaps is sent to `to`.
+	**/
+	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.sdk.accounts.prependPriceUpdates(account.creditManager, routerCloseResult.calls, account, { ignoreReservePrices });
+		let lossPolicyData;
+		if (applyLossPolicy) {
+			lossPolicyData = await cm.market.lossPolicy.getLiquidationData(account.creditAccount);
+			this.logger?.debug({ lossPolicyData }, "loss policy data");
+		}
+		return {
+			tx: cm.creditFacade.liquidateCreditAccount(account.creditAccount, to, calls, lossPolicyData),
+			calls,
+			routerCloseResult
+		};
+	}
+	/**
+	* Details of a partial liquidation of a credit account, in the shape of a
+	* full one: what the liquidator pays, what it receives and what it must
+	* approve, plus {@link LiquidationDetails.isPartiallyLiquidatable}.
+	*
+	* A local estimate, not onchain read: no price feed updates are applied, so
+	* `ignoreReservePrices` has no effect here.
+	* Parameters left out of `props` are derived from current state.
+	*
+	* @throws For markets with a wrapped RWA underlying (Securitize), for a
+	* `tokenOut` that cannot be seized, and when no `tokenOut` can be picked.
+	**/
+	async getPartialLiquidationDetails(props) {
+		const { creditAccount, liquidator, blockNumber } = props;
+		const ca = await this.#getCreditAccountData(creditAccount, blockNumber);
+		const suite = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+		const { priceOracle } = suite.market;
+		const { underlying } = suite;
+		const { tokenOut, repaidAmount, isPartiallyLiquidatable } = this.#getPartialLiquidationParams(ca, suite, props);
+		const { liquidationDiscount } = suite.liquidationFees();
+		const seizedValue = repaidAmount * require_onchain_constants_math.PERCENTAGE_FACTOR / BigInt(liquidationDiscount);
+		const seizedAmount = priceOracle.convert(underlying, tokenOut, repaidAmount) * require_onchain_constants_math.PERCENTAGE_FACTOR / BigInt(liquidationDiscount);
+		const nft = await suite.degenNFT();
+		let isLiquidatorEligible = !nft;
+		if (nft && liquidator) {
+			const requirements = await nft.getOpenAccountRequirements(liquidator, { tokenOutAddress: tokenOut });
+			isLiquidatorEligible = nft.isRegistered(requirements);
+		}
+		const [kycToken] = nft && !isLiquidatorEligible ? await nft.getTokens() : [];
+		return {
+			...this.#buildAccount(ca, suite),
+			repaymentAmount: priceOracle.toTokenAmount(underlying, repaidAmount),
+			estimatedProfit: priceOracle.toTokenAmount(underlying, seizedValue - repaidAmount),
+			isDelayed: false,
+			receivedAssets: [{
+				isDelayed: false,
+				...priceOracle.toTokenAmount(tokenOut, seizedAmount),
+				token: this.sdk.tokensMeta.mustGetToken(this.sdk.tokensMeta.depositedToken(tokenOut))
+			}],
+			isLiquidatorEligible,
+			kycProtocol: isLiquidatorEligible ? void 0 : nft?.protocol,
+			kycToken: kycToken ? this.sdk.tokensMeta.getToken(kycToken) : void 0,
+			isCreditAccountFrozen: false,
+			approve: repaidAmount === 0n ? void 0 : {
+				spender: suite.creditManager.address,
+				...priceOracle.toTokenAmount(underlying, repaidAmount * (require_onchain_constants_math.PERCENTAGE_FACTOR + require_onchain_accounts_liquidations_constants.LIQUIDATION_APPROVAL_BUFFER) / require_onchain_constants_math.PERCENTAGE_FACTOR)
+			},
+			isPartiallyLiquidatable,
+			isPartial: true
+		};
+	}
+	/**
+	* Builds the transaction that partially liquidates a credit account,
+	* repaying part of its debt from the liquidator's funds in exchange for
+	* discounted collateral sent to the liquidator. Parameters left out of
+	* `props` are derived from current state.
+	*
+	* @throws For markets with a wrapped RWA underlying (Securitize), for a
+	* `tokenOut` that cannot be seized, when no `tokenOut` can be picked, and
+	* when the account cannot be partially liquidated, see
+	* {@link LiquidationDetails.isPartiallyLiquidatable}.
+	**/
+	async buildPartialLiquidationTx(props) {
+		const { creditAccount, liquidator, ignoreReservePrices, blockNumber } = props;
+		const ca = await this.#getCreditAccountData(creditAccount, blockNumber);
+		const suite = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+		const params = this.#getPartialLiquidationParams(ca, suite, props);
+		if (!params.isPartiallyLiquidatable) throw new Error(`credit account ${this.labelAddress(creditAccount)} cannot be partially liquidated`);
+		const updates = await this.sdk.accounts.getOnDemandPriceUpdates(ca, ignoreReservePrices);
+		const tx = suite.creditFacade.partiallyLiquidateCreditAccount(ca.creditAccount, params.tokenOut, params.repaidAmount, params.minSeizedAmount, liquidator, updates);
+		this.logger?.debug(`built tx to partially liquidate credit account ${this.labelAddress(creditAccount)} to ${this.labelAddress(liquidator)}`);
+		return {
+			to: tx.to,
+			callData: tx.callData
+		};
+	}
+	/**
+	* Optimal partial liquidation of a credit account: the collateral to seize
+	* and the amounts that bring its health factor close to `optimalHF`.
+	*
+	* @param ca - Credit account to partially liquidate.
+	* @param optimalHF - Health factor to aim for, in basis points. Defaults to
+	* {@link CreditSuite.optimalHFForPartialLiquidation}.
+	* @param liquidationThresholds - Liquidation thresholds to use instead of
+	* the credit manager's cached ones, for example LTs just set on a fork.
+	* @throws If no `tokenOut` can be picked.
+	**/
+	getOptimalPartialLiquidation(ca, optimalHF, liquidationThresholds) {
+		const suite = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+		return require_onchain_accounts_liquidations_partialLiquidation.optimalPartialLiquidation({
+			suite,
+			account: ca,
+			optimalHF,
+			exclude: (token) => this.#isUnseizable(suite, token),
+			liquidationThresholds
+		});
+	}
+	/**
 	* Returns the status of delayed-withdrawal positions (redemption receipts)
 	* owned by a liquidator wallet: what is receivable, how much, and when it
 	* becomes claimable.
@@ -209,11 +336,42 @@ var LiquidationsService = class extends require_onchain_base_SDKConstruct.SDKCon
 	#liquidationApproval(data, suite, priceOracle) {
 		const { requiredToken, requiredAmount, liquidationCall } = data;
 		if (requiredAmount === 0n) return;
+		const spender = require_onchain_utils_hex.hexEq(liquidationCall.target, suite.creditFacade.address) ? suite.creditManager.address : liquidationCall.target;
+		const bufferedAmount = requiredAmount * (require_onchain_constants_math.PERCENTAGE_FACTOR + require_onchain_accounts_liquidations_constants.LIQUIDATION_APPROVAL_BUFFER) / require_onchain_constants_math.PERCENTAGE_FACTOR;
 		return {
-			spender: require_onchain_utils_hex.hexEq(liquidationCall.target, suite.creditFacade.address) ? suite.creditManager.address : liquidationCall.target,
-			...priceOracle.toTokenAmount(requiredToken, requiredAmount * (require_onchain_constants_math.PERCENTAGE_FACTOR + require_onchain_accounts_liquidations_constants.LIQUIDATION_APPROVAL_BUFFER) / require_onchain_constants_math.PERCENTAGE_FACTOR)
+			spender,
+			...priceOracle.toTokenAmount(requiredToken, bufferedAmount)
 		};
 	}
+	/**
+	* Everything a partial liquidation of a credit account needs, with any
+	* parameter the caller pinned down taken as given and the rest derived from
+	* current state. A derived `tokenOut` is never a token that cannot be seized.
+	*
+	* @throws For markets with a wrapped RWA underlying (Securitize), whose
+	* repayment the liquidator cannot fund, for a `tokenOut` that cannot be
+	* seized (a withdrawal phantom token, which does not redeem instantly, or a
+	* phantom token that unwraps to the underlying), if a derived `tokenOut`
+	* cannot be picked, and if the seized token is not a collateral token of the
+	* credit manager.
+	**/
+	#getPartialLiquidationParams(ca, suite, overrides) {
+		const label = this.labelAddress(ca.creditAccount);
+		if (this.sdk.tokensMeta.isRWAUnderlying(this.sdk.tokensMeta.mustGet(suite.underlying))) throw new Error(`cannot partially liquidate ${label}: markets with a wrapped RWA underlying are not supported`);
+		if (overrides.tokenOut && this.#isUnseizable(suite, overrides.tokenOut)) throw new Error(`cannot partially liquidate ${label}: ${this.labelAddress(overrides.tokenOut)} cannot be seized`);
+		return require_onchain_accounts_liquidations_partialLiquidation.partialLiquidationParams({
+			suite,
+			account: ca,
+			overrides,
+			exclude: (token) => this.#isUnseizable(suite, token)
+		});
+	}
+	/**
+	* The facade reverts when a phantom tokenOut unwraps to the underlying
+	**/
+	#isUnseizable(suite, token) {
+		return this.#isWithdrawalPhantom(token) || (0, viem.isAddressEqual)(this.sdk.tokensMeta.depositedToken(token), suite.underlying);
+	}
 	async #getCreditAccountData(creditAccount, blockNumber) {
 		const ca = await this.sdk.accounts.getCreditAccountData(creditAccount, blockNumber);
 		if (!ca) throw new Error(`credit account ${creditAccount} not found`);
@@ -279,11 +437,23 @@ var LiquidationsService = class extends require_onchain_base_SDKConstruct.SDKCon
 				value: estimatedProfit,
 				valueUsd: usd(estimatedProfit)
 			},
-			isDelayed: ca.tokens.some((t) => t.balance > 10n && !!this.sdk.withdrawalCompressor?.getWithdrawalSourceToken(t.token)),
+			isDelayed: ca.tokens.some((t) => t.balance > 10n && this.#isWithdrawalPhantom(t.token)),
 			paused: suite.creditFacade.isPaused,
-			rwa: market.rwa
+			rwa: market.rwa,
+			isPartiallyLiquidatable: this.#isPartiallyLiquidatable(ca, suite)
 		};
 	}
+	#isPartiallyLiquidatable(ca, suite) {
+		try {
+			return this.#getPartialLiquidationParams(ca, suite, {}).isPartiallyLiquidatable;
+		} catch (e) {
+			this.logger?.debug(e, `credit account ${this.labelAddress(ca.creditAccount)} cannot be partially liquidated`);
+			return false;
+		}
+	}
+	#isWithdrawalPhantom(token) {
+		return !!this.sdk.withdrawalCompressor?.getWithdrawalSourceToken(token);
+	}
 	#mainAsset(ca, market, fallback) {
 		const asset = require_onchain_market_credit_collateralUtils.dominantCollateral(ca, market);
 		if (!asset) return fallback;

package/dist/cjs/onchain/accounts/liquidations/MultichainLiquidationsService.js

@@ -53,6 +53,34 @@ var MultichainLiquidationsService = class extends require_onchain_base_Multichai
 		});
 	}
 	/**
+	* {@inheritDoc LiquidationsService.getPartialLiquidationDetails}
+	**/
+	async getPartialLiquidationDetails(props) {
+		return this.queryChain({
+			network: props.network,
+			block: props.blockNumber ?? "latest",
+			run: (sdk, block) => sdk.liquidations.getPartialLiquidationDetails({
+				...props,
+				blockNumber: block.blockNumber
+			})
+		});
+	}
+	/**
+	* {@inheritDoc LiquidationsService.buildPartialLiquidationTx}
+	*
+	* The reported block is the one the transaction was built against.
+	**/
+	async buildPartialLiquidationTx(props) {
+		return this.queryChain({
+			network: props.network,
+			block: props.blockNumber ?? "latest",
+			run: (sdk, block) => sdk.liquidations.buildPartialLiquidationTx({
+				...props,
+				blockNumber: block.blockNumber
+			})
+		});
+	}
+	/**
 	* Liquidation positions of all queried chains, see
 	* {@link LiquidationsService.getLiquidationPositions}.
 	**/

package/dist/cjs/onchain/accounts/liquidations/constants.js

@@ -4,7 +4,7 @@ const LIQUIDATION_COMPRESSOR_V313_ADDRESS = "0xB70C4500a0afF02107eB983a348F22492
 /**
 * Headroom (in bps) added on top of the amount the liquidation pulls when
 * building the liquidator's approval, so that the transaction does not revert
-* when prices move between the preview and the execution.
+* when prices move or interest accrues between the preview and the execution.
 **/
 const LIQUIDATION_APPROVAL_BUFFER = 50n;
 //#endregion

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

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_onchain_accounts_liquidations_constants = require("./constants.js");
+const require_onchain_accounts_liquidations_partialLiquidation = require("./partialLiquidation.js");
 const require_onchain_accounts_liquidations_LiquidationsService = require("./LiquidationsService.js");
 const require_onchain_accounts_liquidations_MultichainLiquidationsService = require("./MultichainLiquidationsService.js");
 require("./types.js");
@@ -7,3 +8,5 @@ exports.LIQUIDATION_APPROVAL_BUFFER = require_onchain_accounts_liquidations_cons
 exports.LIQUIDATION_COMPRESSOR_V313_ADDRESS = require_onchain_accounts_liquidations_constants.LIQUIDATION_COMPRESSOR_V313_ADDRESS;
 exports.LiquidationsService = require_onchain_accounts_liquidations_LiquidationsService.LiquidationsService;
 exports.MultichainLiquidationsService = require_onchain_accounts_liquidations_MultichainLiquidationsService.MultichainLiquidationsService;
+exports.optimalPartialLiquidation = require_onchain_accounts_liquidations_partialLiquidation.optimalPartialLiquidation;
+exports.partialLiquidationParams = require_onchain_accounts_liquidations_partialLiquidation.partialLiquidationParams;