@gearbox-protocol/sdk 14.12.0-next.65 → 14.12.0-next.67

package/dist/cjs/rewards/rewards/extra-apy.js

@@ -1,10 +1,10 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_runtime = require("../../_virtual/_rolldown/runtime.js");
+const require_sdk_utils_bigint_math = require("../../sdk/utils/bigint-math.js");
 const require_sdk_chain_chains = require("../../sdk/chain/chains.js");
 const require_sdk_constants_math = require("../../sdk/constants/math.js");
 const require_sdk_utils_formatter = require("../../sdk/utils/formatter.js");
 require("../../sdk/index.js");
-const require_common_utils_utils_bigint_math = require("../../common-utils/utils/bigint-math.js");
 require("../../common-utils/index.js");
 let axios = require("axios");
 axios = require_runtime.__toESM(axios);
@@ -64,7 +64,7 @@ var PoolPointsAPI = class PoolPointsAPI {
 		const { decimals: underlyingDecimals = 18 } = tokensList.get(pool.pool.pool.underlying) || {};
 		const underlyingFactor = 10n ** BigInt(underlyingDecimals);
 		const points = (tokenBalanceInPool?.balance || 0n) * defaultPoints / (pool.pool.pool.expectedLiquidity * targetFactor / underlyingFactor);
-		return require_common_utils_utils_bigint_math.BigIntMath.min(points, defaultPoints);
+		return require_sdk_utils_bigint_math.BigIntMath.min(points, defaultPoints);
 	}
 };
 //#endregion

package/dist/cjs/sdk/MultichainSDK.js

@@ -1,11 +1,13 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_sdk_chain_chains = require("./chain/chains.js");
+const require_sdk_core_errors = require("./core/errors.js");
 const require_sdk_market_pricefeeds_updates_PriceUpdatesCache = require("./market/pricefeeds/updates/PriceUpdatesCache.js");
 require("./market/pricefeeds/updates/index.js");
 const require_sdk_accounts_liquidations_MultichainLiquidationsService = require("./accounts/liquidations/MultichainLiquidationsService.js");
 require("./accounts/index.js");
-const require_sdk_core_errors = require("./core/errors.js");
 require("./core/index.js");
+const require_sdk_opportunities_MultichainOpportunitiesService = require("./opportunities/MultichainOpportunitiesService.js");
+require("./opportunities/index.js");
 const require_sdk_OnchainSDK = require("./OnchainSDK.js");
 //#region src/sdk/MultichainSDK.ts
 /**
@@ -23,6 +25,11 @@ var MultichainSDK = class {
 	* configured chains.
 	*/
 	liquidations;
+	/**
+	* Namespace for the pool and strategy opportunities of all configured
+	* chains.
+	*/
+	opportunities;
 	constructor(options) {
 		this.#chains = /* @__PURE__ */ new Map();
 		this.#logger = options.logger;
@@ -40,6 +47,7 @@ var MultichainSDK = class {
 			this.#chains.set(network, sdk);
 		}
 		this.liquidations = new require_sdk_accounts_liquidations_MultichainLiquidationsService.MultichainLiquidationsService(this);
+		this.opportunities = new require_sdk_opportunities_MultichainOpportunitiesService.MultichainOpportunitiesService(this);
 	}
 	/**
 	* Attach all configured chains in parallel.
@@ -128,7 +136,7 @@ var MultichainSDK = class {
 		if (typeof networkOrChainId === "number") network = require_sdk_chain_chains.getNetworkType(networkOrChainId);
 		else network = networkOrChainId;
 		const sdk = this.#chains.get(network);
-		if (!sdk) throw new Error(`Chain ${String(networkOrChainId)} is not configured in this MultichainSDK`);
+		if (!sdk) throw new require_sdk_core_errors.ChainNotConfiguredError(networkOrChainId);
 		return sdk;
 	}
 	/**
@@ -138,6 +146,14 @@ var MultichainSDK = class {
 		return this.#chains;
 	}
 	/**
+	* Shared logger, used for messages that are not attributable to a single
+	* chain. Per-chain messages should use the logger of the corresponding
+	* {@link OnchainSDK}.
+	**/
+	get logger() {
+		return this.#logger;
+	}
+	/**
 	* Sync state for all chains in parallel.
 	*
 	* @param opts - Sync options.

package/dist/cjs/sdk/OnchainSDK.js

@@ -9,6 +9,7 @@ const require_sdk_utils_formatter = require("./utils/formatter.js");
 const require_sdk_utils_toAddress = require("./utils/toAddress.js");
 require("./utils/index.js");
 const require_sdk_base_ChainContractsRegister = require("./base/ChainContractsRegister.js");
+const require_sdk_core_errors = require("./core/errors.js");
 require("./base/index.js");
 const require_sdk_utils_viem_executeDelegatedMulticalls = require("./utils/viem/executeDelegatedMulticalls.js");
 require("./utils/viem/index.js");
@@ -23,8 +24,9 @@ const require_sdk_accounts_withdrawal_compressor_createRedemptionLogger = requir
 const require_sdk_accounts_withdrawal_compressor_createWithdrawalCompressor = require("./accounts/withdrawal-compressor/createWithdrawalCompressor.js");
 require("./accounts/index.js");
 const require_sdk_core_createAddressProvider = require("./core/createAddressProvider.js");
-const require_sdk_core_errors = require("./core/errors.js");
 require("./core/index.js");
+const require_sdk_opportunities_OpportunitiesService = require("./opportunities/OpportunitiesService.js");
+require("./opportunities/index.js");
 const require_sdk_plugins_errors = require("./plugins/errors.js");
 require("./plugins/index.js");
 const require_sdk_pools_PoolService = require("./pools/PoolService.js");
@@ -107,6 +109,10 @@ var OnchainSDK = class extends require_sdk_base_ChainContractsRegister.ChainCont
 	*/
 	liquidations;
 	/**
+	* Namespace for the pool and strategy opportunities of this chain.
+	*/
+	opportunities;
+	/**
 	* @param network - Gearbox network type (e.g. `"Mainnet"`, `"Monad"`).
 	* @param clientOptions - Connection options (RPC URLs, transport, or client).
 	* @param options - SDK configuration options.
@@ -127,6 +133,7 @@ var OnchainSDK = class extends require_sdk_base_ChainContractsRegister.ChainCont
 		this.accounts = new require_sdk_accounts_CreditAccountsServiceV310.CreditAccountsServiceV310(this);
 		this.pools = new require_sdk_pools_PoolService.PoolService(this);
 		this.liquidations = new require_sdk_accounts_liquidations_LiquidationsService.LiquidationsService(this);
+		this.opportunities = new require_sdk_opportunities_OpportunitiesService.OpportunitiesService(this);
 		this.#withdrawalCompressor = require_sdk_accounts_withdrawal_compressor_createWithdrawalCompressor.createWithdrawalCompressor(this);
 	}
 	/**

package/dist/cjs/sdk/accounts/index.js

@@ -21,7 +21,9 @@ exports.AbstractWithdrawalCompressorContract = require_sdk_accounts_withdrawal_c
 exports.CreditAccountsServiceV310 = require_sdk_accounts_CreditAccountsServiceV310.CreditAccountsServiceV310;
 exports.DELAYED_INTENT_TYPES = require_sdk_accounts_withdrawal_compressor_intent_codec.DELAYED_INTENT_TYPES;
 exports.DELAYED_INTENT_VERSION = require_sdk_accounts_withdrawal_compressor_intent_codec.DELAYED_INTENT_VERSION;
+exports.DUST_THRESHOLD = require_sdk_accounts_liquidations_constants.DUST_THRESHOLD;
 exports.InvalidDelayedIntentError = require_sdk_accounts_withdrawal_compressor_errors.InvalidDelayedIntentError;
+exports.LIQUIDATION_APPROVAL_BUFFER = require_sdk_accounts_liquidations_constants.LIQUIDATION_APPROVAL_BUFFER;
 exports.LIQUIDATION_COMPRESSOR_V313_ADDRESS = require_sdk_accounts_liquidations_constants.LIQUIDATION_COMPRESSOR_V313_ADDRESS;
 exports.LiquidationsService = require_sdk_accounts_liquidations_LiquidationsService.LiquidationsService;
 exports.MultichainLiquidationsService = require_sdk_accounts_liquidations_MultichainLiquidationsService.MultichainLiquidationsService;

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

@@ -9,6 +9,9 @@ const require_sdk_utils_hex = require("../../utils/hex.js");
 require("../../utils/index.js");
 const require_sdk_base_SDKConstruct = require("../../base/SDKConstruct.js");
 require("../../base/index.js");
+const require_sdk_market_math = require("../../market/math.js");
+const require_model_liquidations = require("../../../model/liquidations.js");
+require("../../../model/index.js");
 const require_sdk_market_rwa_midas_constants = require("../../market/rwa/midas/constants.js");
 const require_sdk_market_rwa_midas_MidasLiquidatorContract = require("../../market/rwa/midas/MidasLiquidatorContract.js");
 require("../../market/rwa/midas/index.js");
@@ -16,95 +19,104 @@ const require_sdk_market_rwa_securitize_constants = require("../../market/rwa/se
 const require_sdk_market_rwa_securitize_SecuritizeLiquidatorContract = require("../../market/rwa/securitize/SecuritizeLiquidatorContract.js");
 require("../../market/rwa/securitize/index.js");
 const require_sdk_accounts_liquidations_constants = require("./constants.js");
-const require_sdk_accounts_liquidations_helpers = require("./helpers.js");
 //#region src/sdk/accounts/liquidations/LiquidationsService.ts
 /**
-* Per-chain implementation of {@link ILiquidationsService}.
-*
-* Discovers liquidatable credit accounts (health factor below 1 plus accounts
-* of expired credit managers with outstanding debt) and previews what a
-* manual liquidation pays and receives.
+* Service for discovering liquidatable credit accounts and previewing manual
+* liquidations.
 **/
 var LiquidationsService = class extends require_sdk_base_SDKConstruct.SDKConstruct {
 	/**
-	* {@inheritDoc ILiquidationsService.getLiquidatableAccounts}
+	* 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) {
 		await this.sdk.withdrawalCompressor?.loadWithdrawableAssets();
-		const accounts = await this.sdk.accounts.getCreditAccounts({
+		const unhealthy = await this.sdk.accounts.getCreditAccounts({
 			maxHealthFactor: require_sdk_constants_math.WAD - 1n,
 			includeZeroDebt: false
 		});
-		const seen = new require_sdk_utils_AddressSet.AddressSet(accounts.map((ca) => ca.creditAccount));
-		for (const ca of await this.#getExpiredCreditAccounts()) if (!seen.has(ca.creditAccount)) {
-			seen.add(ca.creditAccount);
-			accounts.push(ca);
-		}
-		const rows = [];
-		for (const ca of accounts) {
-			if (!ca.success) continue;
-			rows.push(this.#buildAccount(ca));
-		}
-		const allowedAssets = props?.assets?.length ? new require_sdk_utils_AddressSet.AddressSet(props.assets) : void 0;
-		return rows.filter((row) => {
-			if (props?.delayed !== void 0 && row.isDelayed !== props.delayed) return false;
-			if (allowedAssets && !allowedAssets.has(row.asset)) return false;
-			return true;
-		});
+		const seen = new require_sdk_utils_AddressSet.AddressSet(unhealthy.map((ca) => ca.creditAccount));
+		let expired = await this.#getExpiredCreditAccounts();
+		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) => require_model_liquidations.matchesLiquidatableAccountFilter(row, props));
 	}
 	/**
-	* {@inheritDoc ILiquidationsService.getLiquidationDetails}
+	* 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 } = props;
 		const ca = await this.#getCreditAccountData(creditAccount);
+		const suite = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+		const { priceOracle } = suite.market;
 		await this.sdk.withdrawalCompressor?.loadWithdrawableAssets();
-		const account = this.#buildAccount(ca);
+		const account = this.#buildAccount(ca, suite);
 		const data = await this.#getLiquidationData(ca, liquidator, ignoreReservePrices);
-		const suite = this.sdk.marketRegister.findCreditManager(ca.creditManager);
 		return {
 			...account,
-			repaymentAmount: {
-				token: require_sdk_utils_hex.hexEq(data.requiredToken, "0x0000000000000000000000000000000000000000") ? account.totalValue.token : data.requiredToken,
-				balance: data.requiredAmount
-			},
+			repaymentAmount: priceOracle.toTokenAmount(require_sdk_utils_hex.hexEq(data.requiredToken, "0x0000000000000000000000000000000000000000") ? account.totalValue.token.address : data.requiredToken, data.requiredAmount),
 			isDelayed: data.expectedOutputs.some((o) => o.delayed),
-			receivedAssets: require_sdk_accounts_liquidations_helpers.toReceivedAssets(data.expectedOutputs),
+			receivedAssets: this.#receivedAssets(data.expectedOutputs, priceOracle),
 			isLiquidatorEligible: data.isLiquidatorEligible,
 			isCreditAccountFrozen: data.isCreditAccountFrozen,
 			kycProtocol: data.kycProtocol || void 0,
-			kycToken: require_sdk_utils_hex.hexEq(data.kycToken, "0x0000000000000000000000000000000000000000") ? void 0 : data.kycToken,
-			approve: require_sdk_accounts_liquidations_helpers.toLiquidationApproval({
-				target: data.liquidationCall.target,
-				creditFacade: suite.creditFacade.address,
-				creditManager: ca.creditManager,
-				token: data.requiredToken,
-				amount: data.requiredAmount
-			})
+			kycToken: require_sdk_utils_hex.hexEq(data.kycToken, "0x0000000000000000000000000000000000000000") ? void 0 : this.sdk.tokensMeta.getToken(data.kycToken),
+			approve: this.#liquidationApproval(data, suite, priceOracle)
 		};
 	}
 	/**
-	* {@inheritDoc ILiquidationsService.buildLiquidationTx}
+	* 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 } = props;
 		const ca = await this.#getCreditAccountData(creditAccount);
-		const data = await this.#getLiquidationData(ca, liquidator, ignoreReservePrices);
-		return require_sdk_accounts_liquidations_helpers.liquidationCallToRawTx(data.liquidationCall, `liquidate credit account ${this.labelAddress(creditAccount)} to ${this.labelAddress(liquidator)}`);
+		const { liquidationCall } = await this.#getLiquidationData(ca, liquidator, ignoreReservePrices);
+		this.logger?.debug(`built tx to liquidate credit account ${this.labelAddress(creditAccount)} to ${this.labelAddress(liquidator)}`);
+		return {
+			to: liquidationCall.target,
+			callData: liquidationCall.callData
+		};
 	}
 	/**
-	* {@inheritDoc ILiquidationsService.getLiquidatorWithdrawals}
+	* 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 getLiquidatorWithdrawals(props) {
+	async getLiquidationPositions(props) {
 		const compressor = this.sdk.withdrawalCompressor;
 		if (!compressor) return [];
 		await compressor.loadWithdrawableAssets();
 		const phantomTokens = new require_sdk_utils_AddressSet.AddressSet(compressor.getWithdrawableAssets().map((a) => a.withdrawalPhantomToken));
-		const current = await compressor.getExternalAccountCurrentWithdrawals(props.liquidator, ...phantomTokens.asArray());
-		return require_sdk_accounts_liquidations_helpers.toLiquidatorWithdrawals(current, this.sdk.networkType, this.sdk.chainId);
+		const { claimable, pending } = await compressor.getExternalAccountCurrentWithdrawals(props.liquidator, ...phantomTokens.asArray());
+		const chainId = this.sdk.chainId;
+		return [...claimable.map((w) => ({
+			chainId,
+			sourceToken: this.sdk.tokensMeta.mustGetToken(w.token),
+			output: this.#withdrawalOutput(w.outputs, w.token),
+			claimTx: this.#claimTx(w.claimCalls, w.token),
+			redeemer: w.redeemer
+		})), ...pending.map((w) => ({
+			chainId,
+			sourceToken: this.sdk.tokensMeta.mustGetToken(w.token),
+			output: this.#withdrawalOutput(w.expectedOutputs, w.token),
+			claimableAt: Number(w.claimableAt),
+			redeemer: w.redeemer
+		}))];
 	}
 	/**
-	* {@inheritDoc ILiquidationsService.loadRWALiquidators}
+	* 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() {
 		const configurators = this.sdk.marketRegister.marketConfigurators;
@@ -121,14 +133,6 @@ var LiquidationsService = class extends require_sdk_base_SDKConstruct.SDKConstru
 		});
 		for (const info of resp.flat()) this.#createRWALiquidator(info);
 	}
-	/**
-	* Instantiates the liquidator contract, which registers it and labels its
-	* address (see `BaseContract`).
-	*
-	* @param info - Liquidator discovered by the compressor. The same gateway
-	* can be configured in several credit managers, so duplicates are expected
-	* and skipped.
-	**/
 	#createRWALiquidator(info) {
 		const liquidator = info.liquidatorAddress;
 		if (this.sdk.getContract(liquidator)) return;
@@ -143,20 +147,64 @@ var LiquidationsService = class extends require_sdk_base_SDKConstruct.SDKConstru
 				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
+		};
+	}
+	#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,
+				redeemerAddress: require_sdk_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_sdk_utils_hex.hexEq(liquidationCall.target, suite.creditFacade.address) ? suite.creditManager.address : liquidationCall.target,
+			...priceOracle.toTokenAmount(requiredToken, requiredAmount * (require_sdk_constants_math.PERCENTAGE_FACTOR + require_sdk_accounts_liquidations_constants.LIQUIDATION_APPROVAL_BUFFER) / require_sdk_constants_math.PERCENTAGE_FACTOR)
+		};
+	}
 	async #getCreditAccountData(creditAccount) {
 		const ca = await this.sdk.accounts.getCreditAccountData(creditAccount);
 		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;
 	}
-	/**
-	* Previews the liquidation via the liquidation compressor.
-	*
-	* @param ca - Credit account to liquidate
-	* @param liquidator - Liquidator wallet, zero address when not known: it only
-	* affects the KYC eligibility fields and the receiver encoded into the calls
-	* @param ignoreReservePrices - Exclude reserve price feeds from the updates
-	**/
 	async #getLiquidationData(ca, liquidator = require_sdk_constants_addresses.ADDRESS_0X0, ignoreReservePrices) {
 		const priceUpdates = await this.sdk.accounts.getOnDemandPriceUpdates(ca, ignoreReservePrices);
 		const { result } = await this.client.simulateContract({
@@ -171,10 +219,6 @@ var LiquidationsService = class extends require_sdk_base_SDKConstruct.SDKConstru
 		});
 		return result;
 	}
-	/**
-	* Accounts of expired credit managers with outstanding debt are liquidatable
-	* regardless of their health factor.
-	**/
 	async #getExpiredCreditAccounts() {
 		const expiredCMs = [];
 		for (const market of this.sdk.marketRegister.markets) {
@@ -186,58 +230,58 @@ var LiquidationsService = class extends require_sdk_base_SDKConstruct.SDKConstru
 		}
 		if (expiredCMs.length === 0) return [];
 		this.logger?.debug(`getting credit accounts of ${expiredCMs.length} expired credit managers`);
-		const result = [];
-		for (const creditManager of expiredCMs) {
-			const accounts = await this.sdk.accounts.getCreditAccounts({
-				creditManager,
-				includeZeroDebt: false
-			});
-			result.push(...accounts);
-		}
-		return result;
+		return (await Promise.all(expiredCMs.map((creditManager) => this.sdk.accounts.getCreditAccounts({
+			creditManager,
+			includeZeroDebt: false
+		})))).flat();
 	}
-	/**
-	* Requires the compressor's withdrawable assets cache to be loaded
-	* (see `loadWithdrawableAssets`) so that phantom token lookups are sync.
-	**/
-	#buildAccount(ca) {
-		const compressor = this.sdk.withdrawalCompressor;
-		const suite = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+	#buildAccount(ca, suite = this.sdk.marketRegister.findCreditManager(ca.creditManager)) {
 		const market = suite.market;
-		const meta = this.sdk.tokensMeta.get(suite.underlying);
-		const unwrappedUnderlying = meta && this.sdk.tokensMeta.isRWAUnderlying(meta) ? meta.asset : suite.underlying;
+		const unwrappedUnderlying = this.sdk.tokensMeta.unwrapRWA(suite.underlying);
 		const liquidationDiscount = suite.isExpired ? suite.creditManager.liquidationDiscountExpired : suite.creditManager.liquidationDiscount;
-		let asset = require_sdk_accounts_liquidations_helpers.pickMainAsset(ca, (token, balance) => {
-			try {
-				return market.priceOracle.convert(token, market.underlying, balance);
-			} catch {
-				return 0n;
-			}
-		});
-		if (asset) asset = compressor?.getWithdrawalSourceToken(asset) ?? asset;
-		else asset = unwrappedUnderlying;
+		const repaymentAmount = ca.totalValue * BigInt(liquidationDiscount) / require_sdk_constants_math.PERCENTAGE_FACTOR;
+		const estimatedProfit = ca.totalValue - repaymentAmount;
+		const token = this.sdk.tokensMeta.mustGetToken(unwrappedUnderlying);
+		const usd = (part) => ca.totalValue > 0n ? require_sdk_market_math.usdToNumber(ca.totalValueUSD * part / ca.totalValue) : 0;
 		return {
+			chainId: this.sdk.chainId,
 			creditAccount: ca.creditAccount,
 			creditManager: ca.creditManager,
-			network: this.sdk.networkType,
-			asset,
+			asset: this.sdk.tokensMeta.mustGetToken(this.#mainAsset(ca, market, unwrappedUnderlying)),
 			totalValue: {
-				token: unwrappedUnderlying,
-				balance: ca.totalValue
+				token,
+				value: ca.totalValue,
+				valueUsd: require_sdk_market_math.usdToNumber(ca.totalValueUSD)
 			},
-			totalValueUSD: ca.totalValueUSD,
 			repaymentAmount: {
-				token: unwrappedUnderlying,
-				balance: require_sdk_accounts_liquidations_helpers.calcRepaymentAmount(ca.totalValue, liquidationDiscount)
+				token,
+				value: repaymentAmount,
+				valueUsd: usd(repaymentAmount)
 			},
 			estimatedProfit: {
-				token: unwrappedUnderlying,
-				balance: require_sdk_accounts_liquidations_helpers.calcEstimatedProfit(ca.totalValue, liquidationDiscount)
+				token,
+				value: estimatedProfit,
+				valueUsd: usd(estimatedProfit)
 			},
-			isDelayed: ca.tokens.some((t) => t.balance > 10n && !!compressor?.getWithdrawalSourceToken(t.token)),
-			paused: suite.creditFacade.isPaused
+			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) {
+		let bestValue = 0;
+		let asset;
+		for (const t of ca.tokens) {
+			if (require_sdk_utils_hex.hexEq(t.token, ca.underlying) || (t.mask & ca.enabledTokensMask) === 0n || t.balance <= 10n) continue;
+			const value = market.priceOracle.safeUsdValue(t.token, t.balance) ?? 0;
+			if (value > bestValue) {
+				bestValue = value;
+				asset = t.token;
+			}
+		}
+		if (!asset) return fallback;
+		return this.sdk.withdrawalCompressor?.getWithdrawalSourceToken(asset) ?? asset;
+	}
 };
 //#endregion
 exports.LiquidationsService = LiquidationsService;

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

@@ -1,66 +1,60 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_base_MultichainConstruct = require("../../base/MultichainConstruct.js");
+require("../../base/index.js");
 //#region src/sdk/accounts/liquidations/MultichainLiquidationsService.ts
 /**
-* Cross-chain implementation of {@link ILiquidationsService}.
+* Cross-chain counterpart of {@link LiquidationsService}.
 *
-* Aggregates liquidatable accounts over all chains configured in
-* {@link MultichainSDK} (optionally restricted via
-* {@link MultichainNetworksProps.networks}). A failed chain is logged as
-* a warning and skipped, so one dead RPC does not empty the whole list.
+* Fans out over all chains configured in {@link MultichainSDK} (optionally
+* restricted via {@link MultichainNetworksProps.networks}). A failed chain is
+* logged as a warning and skipped, so one dead RPC does not empty the whole
+* list; its failure is reported in {@link MultichainResult.meta}. Networks that
+* are not configured in the SDK are reported there the same way.
 **/
-var MultichainLiquidationsService = class {
-	#sdk;
-	constructor(sdk) {
-		this.#sdk = sdk;
-	}
+var MultichainLiquidationsService = class extends require_sdk_base_MultichainConstruct.MultichainConstruct {
 	/**
-	* {@inheritDoc ILiquidationsService.getLiquidatableAccounts}
+	* Accounts of all queried chains, see
+	* {@link LiquidationsService.getLiquidatableAccounts}.
 	**/
 	async getLiquidatableAccounts(props) {
-		const chains = [...this.#sdk.chains.entries()].filter(([network]) => !props?.networks || props.networks.includes(network));
-		const results = await Promise.allSettled(chains.map(([, chainSdk]) => chainSdk.liquidations.getLiquidatableAccounts(props)));
-		const accounts = [];
-		results.forEach((result, i) => {
-			const [network, chainSdk] = chains[i];
-			if (result.status === "fulfilled") accounts.push(...result.value);
-			else chainSdk.logger?.warn(result.reason, `failed to get liquidatable accounts on ${network}`);
+		return this.queryChains({
+			networks: props?.networks,
+			label: "get liquidatable accounts",
+			run: (sdk) => sdk.liquidations.getLiquidatableAccounts(props)
 		});
-		return accounts;
 	}
 	/**
-	* {@inheritDoc ILiquidationsService.getLiquidationDetails}
+	* {@inheritDoc LiquidationsService.getLiquidationDetails}
 	**/
 	async getLiquidationDetails(props) {
-		return this.#sdk.chain(props.network).liquidations.getLiquidationDetails(props);
+		return this.sdk.chain(props.network).liquidations.getLiquidationDetails(props);
 	}
 	/**
-	* {@inheritDoc ILiquidationsService.buildLiquidationTx}
+	* {@inheritDoc LiquidationsService.buildLiquidationTx}
 	**/
 	async buildLiquidationTx(props) {
-		return this.#sdk.chain(props.network).liquidations.buildLiquidationTx(props);
+		return this.sdk.chain(props.network).liquidations.buildLiquidationTx(props);
 	}
 	/**
-	* {@inheritDoc ILiquidationsService.getLiquidatorWithdrawals}
+	* Liquidation positions of all queried chains, see
+	* {@link LiquidationsService.getLiquidationPositions}.
 	**/
-	async getLiquidatorWithdrawals(props) {
-		const chains = [...this.#sdk.chains.entries()].filter(([network]) => !props.networks || props.networks.includes(network));
-		const results = await Promise.allSettled(chains.map(([, chainSdk]) => chainSdk.liquidations.getLiquidatorWithdrawals(props)));
-		const withdrawals = [];
-		results.forEach((result, i) => {
-			const [network, chainSdk] = chains[i];
-			if (result.status === "fulfilled") withdrawals.push(...result.value);
-			else chainSdk.logger?.warn(result.reason, `failed to get liquidator withdrawals on ${network}`);
+	async getLiquidationPositions(props) {
+		return this.queryChains({
+			networks: props.networks,
+			label: "get liquidation positions",
+			run: (sdk) => sdk.liquidations.getLiquidationPositions(props)
 		});
-		return withdrawals;
 	}
 	/**
-	* {@inheritDoc ILiquidationsService.loadRWALiquidators}
+	* Loads the liquidators of all queried chains, see
+	* {@link LiquidationsService.loadRWALiquidators}.
 	**/
 	async loadRWALiquidators(props) {
-		const chains = [...this.#sdk.chains.entries()].filter(([network]) => !props?.networks || props.networks.includes(network));
-		(await Promise.allSettled(chains.map(([, chainSdk]) => chainSdk.liquidations.loadRWALiquidators()))).forEach((result, i) => {
-			const [network, chainSdk] = chains[i];
-			if (result.status === "rejected") chainSdk.logger?.warn(result.reason, `failed to load RWA liquidators on ${network}`);
+		return this.runChains({
+			networks: props?.networks,
+			label: "load RWA liquidators",
+			run: (sdk) => sdk.liquidations.loadRWALiquidators()
 		});
 	}
 };

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

@@ -1,5 +1,18 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 //#region src/sdk/accounts/liquidations/constants.ts
 const LIQUIDATION_COMPRESSOR_V313_ADDRESS = "0xB70C4500a0afF02107eB983a348F22492fB6dC94";
+/**
+* Token balances at or below this threshold are treated as dust and ignored,
+* consistent with the rest of the SDK (see `filterDust`).
+**/
+const DUST_THRESHOLD = 10n;
+/**
+* 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.DUST_THRESHOLD = DUST_THRESHOLD;
+exports.LIQUIDATION_APPROVAL_BUFFER = LIQUIDATION_APPROVAL_BUFFER;
 exports.LIQUIDATION_COMPRESSOR_V313_ADDRESS = LIQUIDATION_COMPRESSOR_V313_ADDRESS;

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

@@ -3,6 +3,8 @@ const require_sdk_accounts_liquidations_constants = require("./constants.js");
 const require_sdk_accounts_liquidations_LiquidationsService = require("./LiquidationsService.js");
 const require_sdk_accounts_liquidations_MultichainLiquidationsService = require("./MultichainLiquidationsService.js");
 require("./types.js");
+exports.DUST_THRESHOLD = require_sdk_accounts_liquidations_constants.DUST_THRESHOLD;
+exports.LIQUIDATION_APPROVAL_BUFFER = require_sdk_accounts_liquidations_constants.LIQUIDATION_APPROVAL_BUFFER;
 exports.LIQUIDATION_COMPRESSOR_V313_ADDRESS = require_sdk_accounts_liquidations_constants.LIQUIDATION_COMPRESSOR_V313_ADDRESS;
 exports.LiquidationsService = require_sdk_accounts_liquidations_LiquidationsService.LiquidationsService;
 exports.MultichainLiquidationsService = require_sdk_accounts_liquidations_MultichainLiquidationsService.MultichainLiquidationsService;