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

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 };

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

@@ -22,6 +22,7 @@ import "../../market/index.js";
 import { LIQUIDATION_APPROVAL_BUFFER, LIQUIDATION_COMPRESSOR_V313_ADDRESS } from "./constants.js";
 import { optimalPartialLiquidation, partialLiquidationParams } from "./partialLiquidation.js";
 import { skipLiquidatableAccount } from "./skipLiquidatableAccount.js";
+import { isAddressEqual } from "viem";
 //#region src/onchain/accounts/liquidations/LiquidationsService.ts
 /**
 * Service for discovering liquidatable credit accounts and previewing manual
@@ -70,7 +71,8 @@ var LiquidationsService = class extends SDKConstruct {
 			isCreditAccountFrozen: data.isCreditAccountFrozen,
 			kycProtocol: data.kycProtocol || void 0,
 			kycToken: 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,41 +90,127 @@ var LiquidationsService = class extends SDKConstruct {
 		};
 	}
 	/**
+	* 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 * PERCENTAGE_FACTOR / BigInt(liquidationDiscount);
+		const seizedAmount = priceOracle.convert(underlying, tokenOut, repaidAmount) * 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 * (PERCENTAGE_FACTOR + LIQUIDATION_APPROVAL_BUFFER) / 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`.
 	*
-	* Prices come from the last synced oracle state and `ca`, not from fresh
-	* price updates. Withdrawal phantom tokens are never seized.
-	*
 	* @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) {
+	getOptimalPartialLiquidation(ca, optimalHF, liquidationThresholds) {
+		const suite = this.sdk.marketRegister.findCreditManager(ca.creditManager);
 		return optimalPartialLiquidation({
-			suite: this.sdk.marketRegister.findCreditManager(ca.creditManager),
+			suite,
 			account: ca,
 			optimalHF,
-			exclude: (token) => this.#isWithdrawalPhantom(token)
-		});
-	}
-	/**
-	* 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 withdrawal phantom token.
-	*
-	* @param ca - Credit account to partially liquidate.
-	* @param overrides - Parameters to use instead of the derived defaults.
-	* @throws If a derived `tokenOut` cannot be picked, or if the seized token is
-	* not a collateral token of the credit manager.
-	**/
-	getPartialLiquidationParams(ca, overrides) {
-		return partialLiquidationParams({
-			suite: this.sdk.marketRegister.findCreditManager(ca.creditManager),
-			account: ca,
-			overrides,
-			exclude: (token) => this.#isWithdrawalPhantom(token)
+			exclude: (token) => this.#isUnseizable(suite, token),
+			liquidationThresholds
 		});
 	}
 	/**
@@ -247,11 +335,42 @@ var LiquidationsService = class extends SDKConstruct {
 	#liquidationApproval(data, suite, priceOracle) {
 		const { requiredToken, requiredAmount, liquidationCall } = data;
 		if (requiredAmount === 0n) return;
+		const spender = hexEq(liquidationCall.target, suite.creditFacade.address) ? suite.creditManager.address : liquidationCall.target;
+		const bufferedAmount = requiredAmount * (PERCENTAGE_FACTOR + LIQUIDATION_APPROVAL_BUFFER) / PERCENTAGE_FACTOR;
 		return {
-			spender: hexEq(liquidationCall.target, suite.creditFacade.address) ? suite.creditManager.address : liquidationCall.target,
-			...priceOracle.toTokenAmount(requiredToken, requiredAmount * (PERCENTAGE_FACTOR + LIQUIDATION_APPROVAL_BUFFER) / 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 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) || 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`);
@@ -319,9 +438,18 @@ var LiquidationsService = class extends SDKConstruct {
 			},
 			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);
 	}

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

@@ -52,6 +52,34 @@ var MultichainLiquidationsService = class extends MultichainConstruct {
 		});
 	}
 	/**
+	* {@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/esm/onchain/accounts/liquidations/constants.js

@@ -3,7 +3,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/esm/onchain/accounts/liquidations/partialLiquidation.js

@@ -1,3 +1,5 @@
+import { WAD } from "../../constants/math.js";
+import "../../constants/index.js";
 import { minSeizedAmount, optimalPartialLiquidationAmounts } from "../../market/math.js";
 import { dominantCollateral } from "../../market/credit/collateralUtils.js";
 import "../../market/index.js";
@@ -11,11 +13,11 @@ import "../../market/index.js";
 *
 * @throws If no `tokenOut` can be picked.
 **/
-function optimalPartialLiquidation({ suite, account, optimalHF = suite.optimalHFForPartialLiquidation(account), exclude }) {
+function optimalPartialLiquidation({ suite, account, optimalHF = suite.optimalHFForPartialLiquidation(account), exclude, liquidationThresholds }) {
 	const tokenOut = bestTokenOut(suite, account, exclude);
 	return {
 		tokenOut,
-		...optimalAmounts(suite, account, tokenOut, optimalHF)
+		...optimalAmounts(suite, account, tokenOut, optimalHF, liquidationThresholds)
 	};
 }
 /**
@@ -28,12 +30,15 @@ function optimalPartialLiquidation({ suite, account, optimalHF = suite.optimalHF
 function partialLiquidationParams({ suite, account, overrides = {}, exclude }) {
 	const tokenOut = overrides.tokenOut ?? bestTokenOut(suite, account, exclude);
 	const optimalHF = overrides.optimalHF ?? suite.optimalHFForPartialLiquidation(account);
-	const repaidAmount = overrides.repaidAmount ?? optimalAmounts(suite, account, tokenOut, optimalHF).repaidAmount;
+	const { market } = suite;
+	const { optimalAmount, isOptimalRepayable } = optimalAmounts(suite, account, tokenOut, optimalHF);
+	const repaidAmount = overrides.repaidAmount ?? optimalAmount;
 	return {
 		tokenOut,
 		optimalHF,
 		repaidAmount,
-		minSeizedAmount: overrides.minSeizedAmount ?? minSeizedAmountOf(suite, tokenOut, repaidAmount)
+		minSeizedAmount: overrides.minSeizedAmount ?? minSeizedAmount(market.priceOracle.convert(market.underlying, tokenOut, repaidAmount), suite.liquidationFees().liquidationDiscount),
+		isPartiallyLiquidatable: (account.healthFactor < WAD || suite.isExpired) && isOptimalRepayable && optimalAmount > 0n
 	};
 }
 function bestTokenOut(suite, account, exclude) {
@@ -44,10 +49,10 @@ function bestTokenOut(suite, account, exclude) {
 /**
 * @throws If `tokenOut` is not a collateral token of the credit manager.
 **/
-function optimalAmounts(suite, account, tokenOut, optimalHF) {
+function optimalAmounts(suite, account, tokenOut, optimalHF, liquidationThresholds) {
 	const { creditManager: cm, market } = suite;
 	const { feeLiquidation, liquidationDiscount } = suite.liquidationFees();
-	const ltTokenOut = cm.liquidationThresholds.get(tokenOut);
+	const ltTokenOut = liquidationThresholds?.get(tokenOut) ?? cm.liquidationThresholds.get(tokenOut);
 	if (ltTokenOut === void 0) throw new Error(`token ${suite.register.labelAddress(tokenOut)} is not a collateral token in credit manager ${suite.register.labelAddress(cm.address)}`);
 	return optimalPartialLiquidationAmounts({
 		totalDebt: account.debt + account.accruedInterest + account.accruedFees,
@@ -59,14 +64,5 @@ function optimalAmounts(suite, account, tokenOut, optimalHF) {
 		ltTokenOut: BigInt(ltTokenOut)
 	});
 }
-/**
-* Minimum amount of `token` that must be seized when repaying `repaidAmount`
-* of underlying.
-**/
-function minSeizedAmountOf(suite, token, repaidAmount) {
-	const { market } = suite;
-	const tokenAmount = market.priceOracle.convert(market.underlying, token, repaidAmount);
-	return minSeizedAmount(tokenAmount, suite.liquidationFees().liquidationDiscount);
-}
 //#endregion
 export { optimalPartialLiquidation, partialLiquidationParams };