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

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

@@ -0,0 +1,176 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_accounts_intents_utils_common = require("./common.js");
+const require_onchain_accounts_intents_utils_price_impact = require("./price-impact.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 });
+	const { priceOracle } = sdk.marketRegister.findByCreditManager(creditAccount.creditManager);
+	const quoteSwap = (input) => {
+		const spending = [{
+			token: input.tokenIn,
+			balance: input.amount + input.keep
+		}];
+		return input.keep > 0n ? router.findManyToOnePath({
+			creditAccount: require_onchain_accounts_intents_utils_common.toRouterCaSlice(creditAccount, spending),
+			creditManager: cmSlice,
+			expectedBalances: spending,
+			leftoverBalances: [{
+				token: input.tokenIn,
+				balance: input.keep
+			}],
+			target: input.tokenOut,
+			slippage
+		}) : router.findOneTokenPath({
+			creditAccount: require_onchain_accounts_intents_utils_common.toRouterCaSlice(creditAccount, spending),
+			creditManager: cmSlice,
+			tokenIn: input.tokenIn,
+			tokenOut: input.tokenOut,
+			amount: input.amount,
+			slippage
+		});
+	};
+	const quoteClose = (balances) => router.findBestClosePath({
+		creditAccount: require_onchain_accounts_intents_utils_common.toRouterCaSlice(creditAccount, balances),
+		creditManager: cmSlice,
+		balances: {
+			expectedBalances: balances,
+			leftoverBalances: [],
+			tokensToClaim: []
+		},
+		slippage
+	});
+	const quoteOpen = (expectedBalances, leftoverBalances, target) => router.findOpenStrategyPath({
+		creditManager: cmSlice,
+		expectedBalances,
+		leftoverBalances,
+		target,
+		slippage
+	});
+	return {
+		async swap({ tokenIn, tokenOut, amount, keep = 0n }) {
+			if (amount <= 0n) return {
+				amount: 0n,
+				minAmount: 0n,
+				calls: [],
+				probe: void 0
+			};
+			if (keep < 0n) throw new Error(`swap: spending ${amount} of ${tokenIn} exceeds its balance`);
+			const probe = require_onchain_accounts_intents_utils_price_impact.startProbe({
+				basket: [{
+					token: tokenIn,
+					balance: amount
+				}],
+				tokenOut,
+				oracle: priceOracle,
+				route: async ([only]) => {
+					if (!only) return 0n;
+					return (await quoteSwap({
+						tokenIn: only.token,
+						tokenOut,
+						amount: only.balance,
+						keep: 0n
+					})).amount;
+				}
+			});
+			const leg = await quoteSwap({
+				tokenIn,
+				tokenOut,
+				amount,
+				keep
+			});
+			return {
+				...leg,
+				probe: probe && {
+					...probe,
+					realAmount: leg.amount
+				}
+			};
+		},
+		async closeAll({ balances }) {
+			const probe = require_onchain_accounts_intents_utils_price_impact.startProbe({
+				basket: balances,
+				tokenOut: creditAccount.underlying,
+				oracle: priceOracle,
+				route: async (quoted) => (await quoteClose(quoted)).amount
+			});
+			const { amount, minAmount, calls } = await quoteClose(balances);
+			const leg = {
+				amount,
+				minAmount,
+				calls: [...calls]
+			};
+			return {
+				...leg,
+				probe: probe && {
+					...probe,
+					realAmount: leg.amount
+				}
+			};
+		},
+		async openStrategy({ expectedBalances, leftoverBalances, target }) {
+			const probe = require_onchain_accounts_intents_utils_price_impact.startProbe({
+				basket: expectedBalances,
+				tokenOut: target,
+				oracle: priceOracle,
+				route: async (balances) => (await quoteOpen(balances, [], target)).amount
+			});
+			const leg = await quoteOpen(expectedBalances, leftoverBalances, target);
+			return {
+				...leg,
+				probe: probe && {
+					...probe,
+					realAmount: leg.amount
+				}
+			};
+		}
+	};
+}
+/**
+* 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 oracle = sdk.marketRegister.findByCreditManager(creditAccount.creditManager).priceOracle;
+	const price = (from, to, amount) => oracle.safeConvert(from, to, amount) ?? 0n;
+	const estimate = (amount) => ({
+		amount,
+		minAmount: amount,
+		calls: [],
+		probe: void 0
+	});
+	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
+exports.createOraclePaths = createOraclePaths;
+exports.createRouterPaths = createRouterPaths;

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

@@ -0,0 +1,39 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_accounts_intents_utils_common = require("./utils/common.js");
+const require_onchain_accounts_intents_utils_pick_token = require("./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 market oracle: an unpriceable token contributes 0n rather
+* than throwing.
+*/
+function accountView(creditAccount, sdk) {
+	const { underlying, creditManager } = creditAccount;
+	const oracle = sdk.marketRegister.findByCreditManager(creditManager).priceOracle;
+	const price = (from, to, amount) => oracle.safeConvert(from, to, amount) ?? 0n;
+	const { creditFacade } = sdk.marketRegister.findCreditManager(creditManager);
+	let totalValue = 0n;
+	for (const t of creditAccount.tokens) totalValue += price(t.token, underlying, t.balance);
+	return {
+		underlying,
+		sdk,
+		rwaAsset: sdk.tokensMeta.rwaUnderlyings.get(underlying)?.asset,
+		debt: creditAccount.totalDebt,
+		collateral: totalValue - creditAccount.totalDebt,
+		band: {
+			minDebt: creditFacade.minDebt,
+			maxDebt: creditFacade.maxDebt
+		},
+		balanceOf: (token) => creditAccount.tokens.find((t) => require_onchain_accounts_intents_utils_common.eq(t.token, token))?.balance ?? 0n,
+		price,
+		fattest: (exclude) => require_onchain_accounts_intents_utils_pick_token.pickFattestNonPhantomToken({
+			creditAccount,
+			sdk,
+			exclude
+		})?.token
+	};
+}
+//#endregion
+exports.accountView = accountView;

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

@@ -0,0 +1,294 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_abi_ILiquidationCompressorV313 = require("../../../abi/ILiquidationCompressorV313.js");
+const require_onchain_utils_AddressSet = require("../../utils/AddressSet.js");
+const require_onchain_utils_bytes32ToString = require("../../utils/bytes32ToString.js");
+const require_onchain_constants_addresses = require("../../constants/addresses.js");
+const require_onchain_constants_math = require("../../constants/math.js");
+require("../../constants/index.js");
+const require_onchain_utils_hex = require("../../utils/hex.js");
+require("../../utils/index.js");
+const require_onchain_base_SDKConstruct = require("../../base/SDKConstruct.js");
+require("../../base/index.js");
+const require_onchain_market_math = require("../../market/math.js");
+const require_onchain_market_credit_collateralUtils = require("../../market/credit/collateralUtils.js");
+const require_model_liquidations = require("../../../model/liquidations.js");
+require("../../../model/index.js");
+const require_onchain_market_rwa_midas_constants = require("../../market/rwa/midas/constants.js");
+const require_onchain_market_rwa_midas_MidasLiquidatorContract = require("../../market/rwa/midas/MidasLiquidatorContract.js");
+require("../../market/rwa/midas/index.js");
+const require_onchain_market_rwa_securitize_constants = require("../../market/rwa/securitize/constants.js");
+const require_onchain_market_rwa_securitize_SecuritizeLiquidatorContract = require("../../market/rwa/securitize/SecuritizeLiquidatorContract.js");
+require("../../market/rwa/securitize/index.js");
+require("../../market/index.js");
+const require_onchain_accounts_liquidations_constants = require("./constants.js");
+const require_onchain_accounts_liquidations_skipLiquidatableAccount = require("./skipLiquidatableAccount.js");
+//#region src/onchain/accounts/liquidations/LiquidationsService.ts
+/**
+* Service for discovering liquidatable credit accounts and previewing manual
+* liquidations.
+**/
+var LiquidationsService = class extends require_onchain_base_SDKConstruct.SDKConstruct {
+	/**
+	* Returns all liquidatable credit accounts: accounts with health factor
+	* below 1 plus accounts of expired credit managers with outstanding debt.
+	**/
+	async getLiquidatableAccounts(props) {
+		const unhealthy = await this.sdk.accounts.getCreditAccounts({
+			maxHealthFactor: require_onchain_constants_math.WAD - 1n,
+			includeZeroDebt: false
+		}, props?.blockNumber);
+		const seen = new require_onchain_utils_AddressSet.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 (require_onchain_accounts_liquidations_skipLiquidatableAccount.skipLiquidatableAccount(ca, (token) => this.sdk.tokensMeta.get(token)?.contractType)) {
+				this.logger?.warn(`skipping liquidatable account ${ca.creditAccount}`);
+				return [];
+			}
+			return [this.#buildAccount(ca)];
+		}).filter((row) => require_model_liquidations.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(require_onchain_utils_hex.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: require_onchain_utils_hex.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 require_onchain_utils_AddressSet.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: require_onchain_accounts_liquidations_constants.LIQUIDATION_COMPRESSOR_V313_ADDRESS,
+				abi: require_abi_ILiquidationCompressorV313.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 (require_onchain_utils_bytes32ToString.bytes32ToString(info.contractType)) {
+			case require_onchain_market_rwa_securitize_constants.RWA_LIQUIDATOR_SECURITIZE:
+				new require_onchain_market_rwa_securitize_SecuritizeLiquidatorContract.SecuritizeLiquidatorContract(this.sdk, liquidator);
+				this.logger?.debug(`registered Securitize liquidator ${liquidator}`);
+				return;
+			case require_onchain_market_rwa_midas_constants.RWA_LIQUIDATOR_MIDAS:
+				new require_onchain_market_rwa_midas_MidasLiquidatorContract.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: require_onchain_utils_hex.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: 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)
+		};
+	}
+	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 = require_onchain_constants_addresses.ADDRESS_0X0, ignoreReservePrices, blockNumber) {
+		const priceUpdates = await this.sdk.accounts.getOnDemandPriceUpdates(ca, ignoreReservePrices);
+		const { result } = await this.client.simulateContract({
+			address: require_onchain_accounts_liquidations_constants.LIQUIDATION_COMPRESSOR_V313_ADDRESS,
+			abi: require_abi_ILiquidationCompressorV313.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.liquidationFees();
+		const repaymentAmount = ca.totalValue * BigInt(liquidationDiscount) / require_onchain_constants_math.PERCENTAGE_FACTOR;
+		const estimatedProfit = ca.totalValue - repaymentAmount;
+		const token = this.sdk.tokensMeta.mustGetToken(unwrappedUnderlying);
+		const usd = (part) => ca.totalValue > 0n ? require_onchain_market_math.usdToNumber(ca.totalValueUSD * part / ca.totalValue) : 0;
+		return {
+			...suite.creditOperationMarket(),
+			chainId: this.sdk.chainId,
+			creditAccount: ca.creditAccount,
+			asset: this.sdk.tokensMeta.mustGetToken(this.#mainAsset(ca, market, unwrappedUnderlying)),
+			totalValue: {
+				token,
+				value: ca.totalValue,
+				valueUsd: require_onchain_market_math.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 = require_onchain_market_credit_collateralUtils.dominantCollateral(ca, market);
+		if (!asset) return fallback;
+		return this.sdk.withdrawalCompressor?.getWithdrawalSourceToken(asset) ?? asset;
+	}
+};
+//#endregion
+exports.LiquidationsService = LiquidationsService;

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

@@ -0,0 +1,86 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_base_MultichainConstruct = require("../../base/MultichainConstruct.js");
+require("../../base/index.js");
+//#region src/onchain/accounts/liquidations/MultichainLiquidationsService.ts
+/**
+* Cross-chain counterpart of {@link LiquidationsService}. These reads are live,
+* so each chain is pinned to its own freshly fetched head.
+**/
+var MultichainLiquidationsService = class extends require_onchain_base_MultichainConstruct.MultichainConstruct {
+	/**
+	* Accounts of all queried chains, see
+	* {@link LiquidationsService.getLiquidatableAccounts}.
+	**/
+	async getLiquidatableAccounts(props) {
+		return this.queryChains({
+			chainIds: props?.chainIds,
+			label: "get liquidatable accounts",
+			block: "latest",
+			run: (sdk, block) => sdk.liquidations.getLiquidatableAccounts({
+				...props,
+				blockNumber: block.blockNumber
+			})
+		});
+	}
+	/**
+	* {@inheritDoc LiquidationsService.getLiquidationDetails}
+	*
+	* Throws when the chain cannot answer.
+	**/
+	async getLiquidationDetails(props) {
+		return this.queryChain({
+			network: props.network,
+			block: props.blockNumber ?? "latest",
+			run: (sdk, block) => sdk.liquidations.getLiquidationDetails({
+				...props,
+				blockNumber: block.blockNumber
+			})
+		});
+	}
+	/**
+	* {@inheritDoc LiquidationsService.buildLiquidationTx}
+	*
+	* The reported block is the one the transaction was built against.
+	**/
+	async buildLiquidationTx(props) {
+		return this.queryChain({
+			network: props.network,
+			block: props.blockNumber ?? "latest",
+			run: (sdk, block) => sdk.liquidations.buildLiquidationTx({
+				...props,
+				blockNumber: block.blockNumber
+			})
+		});
+	}
+	/**
+	* Liquidation positions of all queried chains, see
+	* {@link LiquidationsService.getLiquidationPositions}.
+	**/
+	async getLiquidationPositions(props) {
+		return this.queryChains({
+			chainIds: props.chainIds,
+			label: "get liquidation positions",
+			block: "latest",
+			run: (sdk, block) => sdk.liquidations.getLiquidationPositions({
+				...props,
+				blockNumber: block.blockNumber
+			})
+		});
+	}
+	/**
+	* Loads the liquidators of all queried chains, see
+	* {@link LiquidationsService.loadRWALiquidators}.
+	*
+	* Nothing consumes the block of a cache warm-up, so this one is left on the
+	* loaded snapshot.
+	**/
+	async loadRWALiquidators(props) {
+		return this.runChains({
+			chainIds: props?.chainIds,
+			label: "load RWA liquidators",
+			run: (sdk) => sdk.liquidations.loadRWALiquidators()
+		});
+	}
+};
+//#endregion
+exports.MultichainLiquidationsService = MultichainLiquidationsService;

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

@@ -0,0 +1,12 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/onchain/accounts/liquidations/constants.ts
+const LIQUIDATION_COMPRESSOR_V313_ADDRESS = "0xB70C4500a0afF02107eB983a348F22492fB6dC94";
+/**
+* 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.
+**/
+const LIQUIDATION_APPROVAL_BUFFER = 50n;
+//#endregion
+exports.LIQUIDATION_APPROVAL_BUFFER = LIQUIDATION_APPROVAL_BUFFER;
+exports.LIQUIDATION_COMPRESSOR_V313_ADDRESS = LIQUIDATION_COMPRESSOR_V313_ADDRESS;

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

@@ -0,0 +1,9 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_accounts_liquidations_constants = require("./constants.js");
+const require_onchain_accounts_liquidations_LiquidationsService = require("./LiquidationsService.js");
+const require_onchain_accounts_liquidations_MultichainLiquidationsService = require("./MultichainLiquidationsService.js");
+require("./types.js");
+exports.LIQUIDATION_APPROVAL_BUFFER = require_onchain_accounts_liquidations_constants.LIQUIDATION_APPROVAL_BUFFER;
+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;

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

@@ -0,0 +1,12 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/onchain/accounts/liquidations/skipLiquidatableAccount.ts
+/**
+* Whether a credit account should be dropped from the liquidatable list:
+* collateral computation failed, or it holds a Mellow withdrawal phantom
+* token above dust (no liquidation subcompressor for that type).
+**/
+function skipLiquidatableAccount(account, getContractType) {
+	return !account.success || account.tokens.some((t) => getContractType(t.token) === "PHANTOM_TOKEN::MELLOW_WITHDRAWAL");
+}
+//#endregion
+exports.skipLiquidatableAccount = skipLiquidatableAccount;