@gearbox-protocol/sdk 16.0.0-next.4 → 16.0.0-next.6

package/dist/esm/onchain/accounts/intents/utils/pick-token.js

@@ -0,0 +1,68 @@
+import { NON_STRATEGY_PHANTOM_TOKEN_TYPES } from "../../../base/token-types.js";
+import { eq } from "./common.js";
+import { convertAmount } from "./convert-amount.js";
+//#region src/onchain/accounts/intents/utils/pick-token.ts
+/** Prefix marking every phantom-token contract type in the registry. */
+const PHANTOM_TOKEN_PREFIX = "PHANTOM_TOKEN::";
+/**
+* Whether `token` is a phantom (a non-transferable position marker such as a
+* pending delayed withdrawal).
+*
+* Reads `contractType` directly instead of going through
+* `TokensMeta.isPhantomToken`, which throws when extended token data has not
+* been loaded. Here an unknown token is simply treated as non-phantom.
+*/
+function isPhantomToken(sdk, token) {
+	return !!sdk.tokensMeta.get(token)?.contractType?.startsWith(PHANTOM_TOKEN_PREFIX);
+}
+const REDEMPTION_PHANTOM_TOKEN_TYPES = new Set(NON_STRATEGY_PHANTOM_TOKEN_TYPES);
+/**
+* Whether `token` is the phantom of a redemption in flight, rather than one of
+* the phantoms a position is simply held in (Convex, Infrared, staking
+* rewards), which the router sells like any other balance.
+*
+* Only the former stands between an account and being emptied: it cannot be
+* sold and it cannot leave until its claim has landed.
+*/
+function isRedemptionPhantomToken(sdk, token) {
+	const contractType = sdk.tokensMeta.get(token)?.contractType;
+	return !!contractType && REDEMPTION_PHANTOM_TOKEN_TYPES.has(contractType);
+}
+/**
+* Account balances that can actually back an operation, richest first.
+*
+* Phantoms are dropped because a pending delayed withdrawal cannot be spent:
+* it has to be claimed first, in a transaction of its own.
+*/
+function rankAccountTokens(args) {
+	const { creditAccount, sdk, exclude = [] } = args;
+	const convert = convertAmount(sdk, creditAccount.creditManager);
+	const candidates = [];
+	for (const t of creditAccount.tokens) {
+		if (t.balance <= 0n) continue;
+		if (exclude.some((e) => eq(e, t.token))) continue;
+		if (isPhantomToken(sdk, t.token)) continue;
+		candidates.push({
+			token: t.token,
+			balance: t.balance,
+			valueInUnderlying: convert(t.token, creditAccount.underlying, t.balance)
+		});
+	}
+	candidates.sort((a, b) => {
+		if (a.valueInUnderlying !== b.valueInUnderlying) return a.valueInUnderlying > b.valueInUnderlying ? -1 : 1;
+		return a.token < b.token ? -1 : a.token > b.token ? 1 : 0;
+	});
+	return candidates;
+}
+/**
+* Default working token for flows that do not get one from the caller: the
+* most valuable non-phantom balance on the account.
+*
+* Used for the source of a partial withdraw and the position leg of a leverage
+* adjustment, both of which the caller may override explicitly.
+*/
+function pickFattestNonPhantomToken(args) {
+	return rankAccountTokens(args)[0];
+}
+//#endregion
+export { isPhantomToken, isRedemptionPhantomToken, pickFattestNonPhantomToken, rankAccountTokens };

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

@@ -0,0 +1,169 @@
+import { MIN_INT96 } from "../../../constants/math.js";
+import { TypedObjectUtils } from "../../../utils/mappers.js";
+import { calcQuotaUpdate } from "../../../../common-utils/utils/creditAccount/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 }) {
+	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, {
+			...a,
+			token: tokenLc
+		}];
+	});
+	const initialQuotasRecord = TypedObjectUtils.fromEntries(initialQuotasLc);
+	const liquidationThresholds = TypedObjectUtils.fromEntries(liquidationThresholdsMap.entries().map(([token, lt]) => [token.toLowerCase(), BigInt(lt)]));
+	const quotas = TypedObjectUtils.fromEntries(quotasMap.values().map((q) => {
+		const token = q.token.toLowerCase();
+		return [token, {
+			token,
+			rate: BigInt(q.rate),
+			quotaIncreaseFee: BigInt(q.quotaIncreaseFee),
+			totalQuoted: q.totalQuoted,
+			limit: q.limit,
+			isActive: q.isActive
+		}];
+	}));
+	const assetsWithAmountInTarget = getBalancesAfterWithFullySpent(assetsAfterLc, spend, initialQuotasRecord).map((a) => {
+		return {
+			...a,
+			amountInTarget: convert(a.token, underlyingTokenLc, a.balance)
+		};
+	});
+	const quotaResult = calcQuotaUpdate({
+		quotas,
+		initialQuotas: initialQuotasRecord,
+		assetsAfterUpdate: constructAssetRecord(assetsWithAmountInTarget),
+		allowedToObtain: constructAssetRecord(obtain),
+		allowedToSpend: constructAssetRecord(spend),
+		quotaReserve: BigInt(quotaReserve),
+		maxDebt,
+		liquidationThresholds,
+		calcModification: void 0
+	});
+	return filterQuotaUpdates(quotaResult.desiredQuota, quotaResult.quotaIncrease, quotaResult.quotaDecrease, [...new Set([...spend, ...obtain].map((q) => q.token)).values()]);
+}
+/**
+* The update that leaves the account holding no quota at all.
+*
+* Sits beside {@link getQuotasForUpdate} rather than inside it because the two
+* answer different questions: that one sizes quotas to the balances an
+* operation leaves behind, this one is asked for by a plan that ends the loan,
+* where the right size is none whatever the balances are.
+*
+* `MIN_INT96` is the protocol's "reset" sentinel, which is how a decrease says
+* "all of it" instead of naming an amount that interest may have moved.
+*/
+function clearedQuotas(initialQuotas) {
+	const quoted = initialQuotas.filter((q) => q.quota > 0n).map((q) => q.token.toLowerCase());
+	return {
+		desiredQuota: TypedObjectUtils.fromEntries(quoted.map((token) => [token, {
+			token,
+			balance: 0n
+		}])),
+		quotaIncrease: [],
+		quotaDecrease: quoted.map((token) => ({
+			token,
+			balance: MIN_INT96
+		}))
+	};
+}
+/**
+* The quotas the account stands at once an update lands: the ones it came with,
+* with the ones the update names written over them.
+*
+* An update only names the tokens its operation touched — see
+* {@link filterQuotaUpdates} — and the quotas of everything else keep standing,
+* so the update alone is not the account's quota set. Quotas that end at zero
+* are dropped: a token with no quota is a token the account is not quoted for.
+*/
+function quotasAfterUpdate(initialQuotas, desiredQuota) {
+	const after = {};
+	for (const q of initialQuotas) {
+		const token = q.token.toLowerCase();
+		if (q.quota > 0n) after[token] = {
+			token,
+			balance: q.quota
+		};
+	}
+	for (const [token, quota] of TypedObjectUtils.entries(desiredQuota)) if (quota.balance > 0n) after[token] = quota;
+	else delete after[token];
+	return after;
+}
+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]));
+	const tokens = /* @__PURE__ */ new Set([...before.keys(), ...after.keys()]);
+	const spend = [];
+	const obtain = [];
+	for (const token of tokens) {
+		const delta = (after.get(token) ?? 0n) - (before.get(token) ?? 0n);
+		if (delta > 0n) obtain.push({
+			token,
+			balance: delta
+		});
+		else if (delta < 0n) spend.push({
+			token,
+			balance: -delta
+		});
+	}
+	return {
+		spend,
+		obtain
+	};
+}
+/**
+* SDK `getSingleQuotaChange` requires `assetAfter` to emit quota decreases.
+* Simulation drops zero balances, so fully spent collaterals (e.g. claim
+* phantom) vanish — reinsert them with balance 0 when they still have
+* initial quota so `calcQuotaUpdate` can zero / remove that quota.
+*/
+function getBalancesAfterWithFullySpent(assetsAfter, tokensSpend, initialQuotas) {
+	const assetsAfterRecord = new Map(assetsAfter.map((a) => [a.token, a]));
+	for (const s of tokensSpend) {
+		if (assetsAfterRecord.has(s.token)) continue;
+		if ((initialQuotas[s.token]?.quota ?? 0n) > 0n) assetsAfterRecord.set(s.token, {
+			token: s.token,
+			balance: 0n
+		});
+	}
+	return [...assetsAfterRecord.values()];
+}
+/**
+* Restricts quota updates to only tokens that were intended to change.
+*/
+function filterQuotaUpdates(desiredQuota, quotaIncrease, quotaDecrease, tokensToUpdate) {
+	if (tokensToUpdate.length === 0) return {
+		desiredQuota: {},
+		quotaIncrease: [],
+		quotaDecrease: []
+	};
+	const allowed = new Set(tokensToUpdate);
+	const restrictedDesired = {};
+	for (const token of tokensToUpdate) {
+		const asset = desiredQuota[token];
+		if (asset) restrictedDesired[token] = asset;
+	}
+	return {
+		desiredQuota: restrictedDesired,
+		quotaIncrease: quotaIncrease.filter((a) => allowed.has(a.token)),
+		quotaDecrease: quotaDecrease.filter((a) => allowed.has(a.token))
+	};
+}
+function constructAssetRecord(a) {
+	return a.reduce((acc, asset) => {
+		acc[asset.token] = asset;
+		return acc;
+	}, {});
+}
+//#endregion
+export { clearedQuotas, getQuotasForUpdate, quotasAfterUpdate };

package/dist/esm/onchain/accounts/intents/utils/router-path.js

@@ -0,0 +1,116 @@
+import { toRouterCaSlice } from "./common.js";
+import { convertAmount } from "./convert-amount.js";
+//#region src/onchain/accounts/intents/utils/router-path.ts
+/**
+* The engine's only door to the pathfinder.
+*
+* Deliberately not a quoter abstraction with an oracle-priced twin: paths are
+* always resolved on-chain, because a preview whose swap amounts came from
+* oracle prices could not produce the calldata that realises them.
+*/
+function createRouterPaths(args) {
+	const { sdk, creditAccount, slippage } = args;
+	const suite = sdk.marketRegister.findCreditManager(creditAccount.creditManager);
+	const cmSlice = {
+		address: suite.creditManager.address.toLowerCase(),
+		creditFacade: suite.creditFacade.address.toLowerCase(),
+		collateralTokens: suite.creditManager.collateralTokens.map((t) => t.toLowerCase())
+	};
+	const router = sdk.routerFor({ creditFacade: suite.creditFacade.address });
+	return {
+		async swap({ tokenIn, tokenOut, amount, keep = 0n }) {
+			if (amount <= 0n) return {
+				amount: 0n,
+				minAmount: 0n,
+				calls: []
+			};
+			if (keep < 0n) throw new Error(`swap: spending ${amount} of ${tokenIn} exceeds its balance`);
+			if (keep > 0n) {
+				const expectedBalances = [{
+					token: tokenIn,
+					balance: amount + keep
+				}];
+				return router.findManyToOnePath({
+					creditAccount: toRouterCaSlice(creditAccount, expectedBalances),
+					creditManager: cmSlice,
+					expectedBalances,
+					leftoverBalances: [{
+						token: tokenIn,
+						balance: keep
+					}],
+					target: tokenOut,
+					slippage
+				});
+			}
+			return router.findOneTokenPath({
+				creditAccount: toRouterCaSlice(creditAccount, [{
+					token: tokenIn,
+					balance: amount
+				}]),
+				creditManager: cmSlice,
+				tokenIn,
+				tokenOut,
+				amount,
+				slippage
+			});
+		},
+		async closeAll({ balances }) {
+			const { amount, minAmount, calls } = await router.findBestClosePath({
+				creditAccount: toRouterCaSlice(creditAccount, balances),
+				creditManager: cmSlice,
+				balances: {
+					expectedBalances: balances,
+					leftoverBalances: [],
+					tokensToClaim: []
+				},
+				slippage
+			});
+			return {
+				amount,
+				minAmount,
+				calls: [...calls]
+			};
+		},
+		async openStrategy({ expectedBalances, leftoverBalances, target }) {
+			return router.findOpenStrategyPath({
+				creditManager: cmSlice,
+				expectedBalances,
+				leftoverBalances,
+				target,
+				slippage
+			});
+		}
+	};
+}
+/**
+* The same door, priced by the oracle and opening onto no calldata.
+*
+* For a leg that cannot be quoted yet: the tail of a redemption trades funds
+* that do not exist, along a route the pathfinder will only be able to build
+* once they do. Asking it now would price a swap of nothing, so the amounts
+* come from the oracle instead — an estimate with no slippage floor, which is
+* all a projection days out can honestly be — and the walk yields a state
+* rather than a transaction.
+*/
+function createOraclePaths(args) {
+	const { sdk, creditAccount } = args;
+	const price = convertAmount(sdk, creditAccount.creditManager);
+	const estimate = (amount) => ({
+		amount,
+		minAmount: amount,
+		calls: []
+	});
+	return {
+		async swap({ tokenIn, tokenOut, amount }) {
+			return estimate(amount > 0n ? price(tokenIn, tokenOut, amount) : 0n);
+		},
+		async closeAll({ balances }) {
+			return estimate(balances.reduce((sum, b) => sum + price(b.token, creditAccount.underlying, b.balance), 0n));
+		},
+		async openStrategy() {
+			throw new Error("oracle paths: opening a position is never projected");
+		}
+	};
+}
+//#endregion
+export { createOraclePaths, createRouterPaths };

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

@@ -0,0 +1,37 @@
+import { eq } from "./utils/common.js";
+import { convertAmount } from "./utils/convert-amount.js";
+import { pickFattestNonPhantomToken } from "./utils/pick-token.js";
+//#region src/onchain/accounts/intents/view.ts
+/**
+* The account as the planners see it: a handful of numbers in underlying units
+* plus balance / price lookups. Read once per preview.
+*
+* TVL uses the RWA-aware conversion so an `rwa.asset` balance without a direct
+* pool price still counts at its wrapped value instead of throwing.
+*/
+function accountView(creditAccount, sdk) {
+	const { underlying, creditManager } = creditAccount;
+	const price = convertAmount(sdk, creditManager);
+	const { creditFacade } = sdk.marketRegister.findCreditManager(creditManager);
+	let totalValue = 0n;
+	for (const t of creditAccount.tokens) totalValue += price(t.token, underlying, t.balance);
+	return {
+		underlying,
+		rwaAsset: sdk.tokensMeta.rwaUnderlyings.get(underlying)?.asset,
+		debt: creditAccount.accountDebt,
+		collateral: totalValue - creditAccount.accountDebt,
+		band: {
+			minDebt: creditFacade.minDebt,
+			maxDebt: creditFacade.maxDebt
+		},
+		balanceOf: (token) => creditAccount.tokens.find((t) => eq(t.token, token))?.balance ?? 0n,
+		price,
+		fattest: (exclude) => pickFattestNonPhantomToken({
+			creditAccount,
+			sdk,
+			exclude
+		})?.token
+	};
+}
+//#endregion
+export { accountView };

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

@@ -0,0 +1,293 @@
+import { iLiquidationCompressorV313Abi } from "../../../abi/ILiquidationCompressorV313.js";
+import { AddressSet } from "../../utils/AddressSet.js";
+import { bytes32ToString } from "../../utils/bytes32ToString.js";
+import { ADDRESS_0X0 } from "../../constants/addresses.js";
+import { PERCENTAGE_FACTOR, WAD } from "../../constants/math.js";
+import "../../constants/index.js";
+import { hexEq } from "../../utils/hex.js";
+import "../../utils/index.js";
+import { SDKConstruct } from "../../base/SDKConstruct.js";
+import "../../base/index.js";
+import { usdToNumber } from "../../market/math.js";
+import { dominantCollateral } from "../../market/credit/collateralUtils.js";
+import { matchesLiquidatableAccountFilter } from "../../../model/liquidations.js";
+import "../../../model/index.js";
+import { RWA_LIQUIDATOR_MIDAS } from "../../market/rwa/midas/constants.js";
+import { MidasLiquidatorContract } from "../../market/rwa/midas/MidasLiquidatorContract.js";
+import "../../market/rwa/midas/index.js";
+import { RWA_LIQUIDATOR_SECURITIZE } from "../../market/rwa/securitize/constants.js";
+import { SecuritizeLiquidatorContract } from "../../market/rwa/securitize/SecuritizeLiquidatorContract.js";
+import "../../market/rwa/securitize/index.js";
+import "../../market/index.js";
+import { LIQUIDATION_APPROVAL_BUFFER, LIQUIDATION_COMPRESSOR_V313_ADDRESS } from "./constants.js";
+//#region src/onchain/accounts/liquidations/LiquidationsService.ts
+/**
+* Service for discovering liquidatable credit accounts and previewing manual
+* liquidations.
+**/
+var LiquidationsService = class extends SDKConstruct {
+	/**
+	* Returns all liquidatable credit accounts: accounts with health factor
+	* below 1 plus accounts of expired credit managers with outstanding debt.
+	* Accounts whose collateral computation failed are excluded.
+	**/
+	async getLiquidatableAccounts(props) {
+		const unhealthy = await this.sdk.accounts.getCreditAccounts({
+			maxHealthFactor: WAD - 1n,
+			includeZeroDebt: false
+		}, props?.blockNumber);
+		const seen = new AddressSet(unhealthy.map((ca) => ca.creditAccount));
+		let expired = await this.#getExpiredCreditAccounts(props?.blockNumber);
+		expired = expired.filter((ca) => !seen.has(ca.creditAccount));
+		return [...unhealthy, ...expired].flatMap((ca) => {
+			if (!ca.success) {
+				this.logger?.warn(`cannot compute liquidation details for ${ca.creditAccount}: collateral computation failed`);
+				return [];
+			}
+			return [this.#buildAccount(ca)];
+		}).filter((row) => matchesLiquidatableAccountFilter(row, props));
+	}
+	/**
+	* Returns detailed information about a liquidatable credit account,
+	* including the full list of assets the liquidator receives.
+	*
+	* @throws When the account is not found or its collateral computation fails.
+	**/
+	async getLiquidationDetails(props) {
+		const { creditAccount, liquidator, ignoreReservePrices, blockNumber } = props;
+		const ca = await this.#getCreditAccountData(creditAccount, blockNumber);
+		const suite = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+		const { priceOracle } = suite.market;
+		const account = this.#buildAccount(ca, suite);
+		const data = await this.#getLiquidationData(ca, liquidator, ignoreReservePrices, blockNumber);
+		return {
+			...account,
+			repaymentAmount: priceOracle.toTokenAmount(hexEq(data.requiredToken, "0x0000000000000000000000000000000000000000") ? account.totalValue.token.address : data.requiredToken, data.requiredAmount),
+			isDelayed: data.expectedOutputs.some((o) => o.delayed),
+			receivedAssets: this.#receivedAssets(data.expectedOutputs, priceOracle),
+			isLiquidatorEligible: data.isLiquidatorEligible,
+			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)
+		};
+	}
+	/**
+	* Builds the transaction that fully liquidates a credit account, repaying
+	* the debt from own funds and receiving the collateral from the credit account.
+	**/
+	async buildLiquidationTx(props) {
+		const { creditAccount, liquidator, ignoreReservePrices, blockNumber } = props;
+		const ca = await this.#getCreditAccountData(creditAccount, blockNumber);
+		const { liquidationCall } = await this.#getLiquidationData(ca, liquidator, ignoreReservePrices, blockNumber);
+		this.logger?.debug(`built tx to liquidate credit account ${this.labelAddress(creditAccount)} to ${this.labelAddress(liquidator)}`);
+		return {
+			to: liquidationCall.target,
+			callData: liquidationCall.callData
+		};
+	}
+	/**
+	* Returns the status of delayed-withdrawal positions (redemption receipts)
+	* owned by a liquidator wallet: what is receivable, how much, and when it
+	* becomes claimable.
+	**/
+	async getLiquidationPositions(props) {
+		const compressor = this.sdk.withdrawalCompressor;
+		if (!compressor) return [];
+		const phantomTokens = new AddressSet(compressor.getWithdrawableAssets().map((a) => a.withdrawalPhantomToken));
+		const { claimable, pending } = await compressor.getExternalAccountCurrentWithdrawals({
+			account: props.liquidator,
+			withdrawalTokens: phantomTokens.asArray(),
+			blockNumber: props.blockNumber
+		});
+		return [...claimable.map((w) => ({
+			...this.#liquidationPosition(w.token, w.outputs),
+			claimTx: this.#claimTx(w.claimCalls, w.token),
+			redeemer: w.redeemer
+		})), ...pending.map((w) => ({
+			...this.#liquidationPosition(w.token, w.expectedOutputs),
+			claimableAt: Number(w.claimableAt),
+			redeemer: w.redeemer
+		}))];
+	}
+	/**
+	* Discovers the dedicated RWA liquidator contracts (Securitize, Midas)
+	* deployed for the markets of the chain and registers them in the SDK
+	* contracts register.
+	**/
+	async loadRWALiquidators(props) {
+		const configurators = this.sdk.marketRegister.marketConfigurators;
+		if (configurators.length === 0) return;
+		const resp = await this.client.multicall({
+			contracts: configurators.map((mc) => ({
+				address: LIQUIDATION_COMPRESSOR_V313_ADDRESS,
+				abi: iLiquidationCompressorV313Abi,
+				functionName: "getRWALiquidators",
+				args: [mc.address]
+			})),
+			allowFailure: false,
+			batchSize: 0,
+			blockNumber: props?.blockNumber
+		});
+		for (const info of resp.flat()) this.#createRWALiquidator(info);
+	}
+	#createRWALiquidator(info) {
+		const liquidator = info.liquidatorAddress;
+		if (this.sdk.getContract(liquidator)) return;
+		switch (bytes32ToString(info.contractType)) {
+			case RWA_LIQUIDATOR_SECURITIZE:
+				new SecuritizeLiquidatorContract(this.sdk, liquidator);
+				this.logger?.debug(`registered Securitize liquidator ${liquidator}`);
+				return;
+			case RWA_LIQUIDATOR_MIDAS:
+				new MidasLiquidatorContract(this.sdk, liquidator);
+				this.logger?.debug(`registered Midas liquidator ${liquidator}`);
+				return;
+		}
+	}
+	#anyMarketTokenAmount(token, value) {
+		const meta = this.sdk.tokensMeta.mustGetToken(token);
+		for (const market of this.sdk.marketRegister.markets) {
+			const valueUsd = market.priceOracle.safeUsdValue(token, value);
+			if (valueUsd !== null) return {
+				token: meta,
+				value,
+				valueUsd
+			};
+		}
+		return {
+			token: meta,
+			value,
+			valueUsd: null
+		};
+	}
+	/**
+	* The part a claimable and a pending withdrawal describe the same way. What
+	* separates them — the claim transaction and the moment it becomes
+	* available — is added by the caller.
+	**/
+	#liquidationPosition(token, outputs) {
+		const sourceToken = this.sdk.tokensMeta.mustGetToken(token);
+		const output = this.#withdrawalOutput(outputs, token);
+		return {
+			kind: "liquidation",
+			name: `${sourceToken.symbol} → ${output.token.symbol}`,
+			chainId: this.sdk.chainId,
+			sourceToken,
+			output
+		};
+	}
+	#withdrawalOutput(outputs, sourceToken) {
+		const [output] = outputs;
+		if (outputs.length !== 1 || !output) throw new Error(`expected exactly one output for withdrawal of ${sourceToken}, got ${outputs.length}`);
+		return this.#anyMarketTokenAmount(output.token, output.amount);
+	}
+	#claimTx(claimCalls, sourceToken) {
+		if (claimCalls.length > 1) throw new Error(`expected at most one claim call for withdrawal of ${sourceToken}, got ${claimCalls.length}`);
+		const [call] = claimCalls;
+		return call ? {
+			to: call.target,
+			callData: call.callData
+		} : void 0;
+	}
+	#receivedAssets(outputs, priceOracle) {
+		return outputs.map((o) => {
+			const amount = priceOracle.toTokenAmount(o.token, o.amount);
+			if (!o.delayed) return {
+				isDelayed: false,
+				...amount
+			};
+			return {
+				isDelayed: true,
+				...amount,
+				redeemer: hexEq(o.redeemerAddress, "0x0000000000000000000000000000000000000000") ? void 0 : o.redeemerAddress,
+				claimableAt: o.claimableAt === 0n ? void 0 : Number(o.claimableAt)
+			};
+		});
+	}
+	#liquidationApproval(data, suite, priceOracle) {
+		const { requiredToken, requiredAmount, liquidationCall } = data;
+		if (requiredAmount === 0n) return;
+		return {
+			spender: hexEq(liquidationCall.target, suite.creditFacade.address) ? suite.creditManager.address : liquidationCall.target,
+			...priceOracle.toTokenAmount(requiredToken, requiredAmount * (PERCENTAGE_FACTOR + LIQUIDATION_APPROVAL_BUFFER) / PERCENTAGE_FACTOR)
+		};
+	}
+	async #getCreditAccountData(creditAccount, blockNumber) {
+		const ca = await this.sdk.accounts.getCreditAccountData(creditAccount, blockNumber);
+		if (!ca) throw new Error(`credit account ${creditAccount} not found`);
+		if (!ca.success) throw new Error(`cannot compute liquidation details for ${creditAccount}: collateral computation failed`);
+		return ca;
+	}
+	async #getLiquidationData(ca, liquidator = ADDRESS_0X0, ignoreReservePrices, blockNumber) {
+		const priceUpdates = await this.sdk.accounts.getOnDemandPriceUpdates(ca, ignoreReservePrices);
+		const { result } = await this.client.simulateContract({
+			address: LIQUIDATION_COMPRESSOR_V313_ADDRESS,
+			abi: iLiquidationCompressorV313Abi,
+			functionName: "getLiquidationData",
+			args: [
+				liquidator,
+				ca.creditAccount,
+				priceUpdates
+			],
+			blockNumber
+		});
+		return result;
+	}
+	async #getExpiredCreditAccounts(blockNumber) {
+		const expiredCMs = [];
+		for (const market of this.sdk.marketRegister.markets) {
+			if (market.pool.pool.totalBorrowed === 0n) continue;
+			for (const cm of market.creditManagers) {
+				const borrowed = market.pool.pool.creditManagerDebtParams.get(cm.creditManager.address)?.borrowed ?? 0n;
+				if (cm.isExpired && borrowed > 0n) expiredCMs.push(cm.creditManager.address);
+			}
+		}
+		if (expiredCMs.length === 0) return [];
+		this.logger?.debug(`getting credit accounts of ${expiredCMs.length} expired credit managers`);
+		return (await Promise.all(expiredCMs.map((creditManager) => this.sdk.accounts.getCreditAccounts({
+			creditManager,
+			includeZeroDebt: false
+		}, blockNumber)))).flat();
+	}
+	#buildAccount(ca, suite = this.sdk.marketRegister.findCreditManager(ca.creditManager)) {
+		const market = suite.market;
+		const unwrappedUnderlying = this.sdk.tokensMeta.unwrapRWA(suite.underlying);
+		const liquidationDiscount = suite.isExpired ? suite.creditManager.liquidationDiscountExpired : suite.creditManager.liquidationDiscount;
+		const repaymentAmount = ca.totalValue * BigInt(liquidationDiscount) / PERCENTAGE_FACTOR;
+		const estimatedProfit = ca.totalValue - repaymentAmount;
+		const token = this.sdk.tokensMeta.mustGetToken(unwrappedUnderlying);
+		const usd = (part) => ca.totalValue > 0n ? usdToNumber(ca.totalValueUSD * part / ca.totalValue) : 0;
+		return {
+			chainId: this.sdk.chainId,
+			creditAccount: ca.creditAccount,
+			creditManager: ca.creditManager,
+			asset: this.sdk.tokensMeta.mustGetToken(this.#mainAsset(ca, market, unwrappedUnderlying)),
+			totalValue: {
+				token,
+				value: ca.totalValue,
+				valueUsd: usdToNumber(ca.totalValueUSD)
+			},
+			repaymentAmount: {
+				token,
+				value: repaymentAmount,
+				valueUsd: usd(repaymentAmount)
+			},
+			estimatedProfit: {
+				token,
+				value: estimatedProfit,
+				valueUsd: usd(estimatedProfit)
+			},
+			isDelayed: ca.tokens.some((t) => t.balance > 10n && !!this.sdk.withdrawalCompressor?.getWithdrawalSourceToken(t.token)),
+			paused: suite.creditFacade.isPaused,
+			rwa: market.rwa
+		};
+	}
+	#mainAsset(ca, market, fallback) {
+		const asset = dominantCollateral(ca, market);
+		if (!asset) return fallback;
+		return this.sdk.withdrawalCompressor?.getWithdrawalSourceToken(asset) ?? asset;
+	}
+};
+//#endregion
+export { LiquidationsService };