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

package/dist/esm/sdk/MultichainSDK.js

@@ -1,10 +1,12 @@
 import { getNetworkType } from "./chain/chains.js";
+import { ChainNotConfiguredError, SdkMissingChainStateError, SdkStateVersionMismatchError, SdkSyncFailedError } from "./core/errors.js";
 import { PriceUpdatesCache } from "./market/pricefeeds/updates/PriceUpdatesCache.js";
 import "./market/pricefeeds/updates/index.js";
 import { MultichainLiquidationsService } from "./accounts/liquidations/MultichainLiquidationsService.js";
 import "./accounts/index.js";
-import { SdkMissingChainStateError, SdkStateVersionMismatchError, SdkSyncFailedError } from "./core/errors.js";
 import "./core/index.js";
+import { MultichainOpportunitiesService } from "./opportunities/MultichainOpportunitiesService.js";
+import "./opportunities/index.js";
 import { OnchainSDK } from "./OnchainSDK.js";
 //#region src/sdk/MultichainSDK.ts
 /**
@@ -22,6 +24,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;
@@ -39,6 +46,7 @@ var MultichainSDK = class {
 			this.#chains.set(network, sdk);
 		}
 		this.liquidations = new MultichainLiquidationsService(this);
+		this.opportunities = new MultichainOpportunitiesService(this);
 	}
 	/**
 	* Attach all configured chains in parallel.
@@ -127,7 +135,7 @@ var MultichainSDK = class {
 		if (typeof networkOrChainId === "number") network = 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 ChainNotConfiguredError(networkOrChainId);
 		return sdk;
 	}
 	/**
@@ -137,6 +145,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/esm/sdk/OnchainSDK.js

@@ -8,6 +8,7 @@ import { formatTimestamp } from "./utils/formatter.js";
 import { toAddress } from "./utils/toAddress.js";
 import "./utils/index.js";
 import { ChainContractsRegister } from "./base/ChainContractsRegister.js";
+import { SdkAlreadyAttachedError, SdkChainMismatchError, SdkNotAttachedError, SdkStateVersionMismatchError } from "./core/errors.js";
 import "./base/index.js";
 import { executeDelegatedMulticalls } from "./utils/viem/executeDelegatedMulticalls.js";
 import "./utils/viem/index.js";
@@ -22,8 +23,9 @@ import { createRedemptionLogger } from "./accounts/withdrawal-compressor/createR
 import { createWithdrawalCompressor } from "./accounts/withdrawal-compressor/createWithdrawalCompressor.js";
 import "./accounts/index.js";
 import { createAddressProvider, hydrateAddressProvider } from "./core/createAddressProvider.js";
-import { SdkAlreadyAttachedError, SdkChainMismatchError, SdkNotAttachedError, SdkStateVersionMismatchError } from "./core/errors.js";
 import "./core/index.js";
+import { OpportunitiesService } from "./opportunities/OpportunitiesService.js";
+import "./opportunities/index.js";
 import { PluginStateVersionError } from "./plugins/errors.js";
 import "./plugins/index.js";
 import { PoolService } from "./pools/PoolService.js";
@@ -106,6 +108,10 @@ var OnchainSDK = class extends ChainContractsRegister {
 	*/
 	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.
@@ -126,6 +132,7 @@ var OnchainSDK = class extends ChainContractsRegister {
 		this.accounts = new CreditAccountsServiceV310(this);
 		this.pools = new PoolService(this);
 		this.liquidations = new LiquidationsService(this);
+		this.opportunities = new OpportunitiesService(this);
 		this.#withdrawalCompressor = createWithdrawalCompressor(this);
 	}
 	/**

package/dist/esm/sdk/accounts/CreditAccountsServiceV310.js

@@ -1,9 +1,9 @@
+import { iBaseRewardPoolAbi } from "../../abi/iBaseRewardPool.js";
+import { ierc4626AdapterAbi } from "../../abi/ierc4626Adapter.js";
 import { iBotListV310Abi, iCreditFacadeMulticallV310Abi } from "../../abi/310/generated.js";
 import { creditAccountCompressorAbi } from "../../abi/compressors/creditAccountCompressor.js";
 import { peripheryCompressorAbi } from "../../abi/compressors/peripheryCompressor.js";
 import { rewardsCompressorAbi } from "../../abi/compressors/rewardsCompressor.js";
-import { iBaseRewardPoolAbi } from "../../abi/iBaseRewardPool.js";
-import { ierc4626AdapterAbi } from "../../abi/ierc4626Adapter.js";
 import { iRWAFactoryAbi } from "../../abi/rwa/iRWAFactory.js";
 import { AddressMap } from "../utils/AddressMap.js";
 import { AddressSet } from "../utils/AddressSet.js";

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

@@ -1,5 +1,5 @@
 import { CreditAccountsServiceV310 } from "./CreditAccountsServiceV310.js";
-import { LIQUIDATION_COMPRESSOR_V313_ADDRESS } from "./liquidations/constants.js";
+import { DUST_THRESHOLD, LIQUIDATION_APPROVAL_BUFFER, LIQUIDATION_COMPRESSOR_V313_ADDRESS } from "./liquidations/constants.js";
 import { LiquidationsService } from "./liquidations/LiquidationsService.js";
 import { MultichainLiquidationsService } from "./liquidations/MultichainLiquidationsService.js";
 import "./liquidations/index.js";
@@ -16,4 +16,4 @@ import { toWithdrawalStatus } from "./withdrawal-compressor/types.js";
 import { WithdrawalCompressorV313Contract } from "./withdrawal-compressor/WithdrawalCompressorV313Contract.js";
 import { createWithdrawalCompressor } from "./withdrawal-compressor/createWithdrawalCompressor.js";
 import "./withdrawal-compressor/index.js";
-export { AbstractWithdrawalCompressorContract, CreditAccountsServiceV310, DELAYED_INTENT_TYPES, DELAYED_INTENT_VERSION, InvalidDelayedIntentError, LIQUIDATION_COMPRESSOR_V313_ADDRESS, LiquidationsService, MultichainLiquidationsService, RedemptionLoggerV310Contract, WithdrawalCompressorV310Contract, WithdrawalCompressorV311Contract, WithdrawalCompressorV313Contract, createRedemptionLogger, createWithdrawalCompressor, decodeDelayedIntent, encodeDelayedIntent, getWithdrawalCompressorAddress, iCreditAccountAbi, toClaimableWithdrawal, toPendingWithdrawal, toRequestableWithdrawal, toWithdrawalStatus };
+export { AbstractWithdrawalCompressorContract, CreditAccountsServiceV310, DELAYED_INTENT_TYPES, DELAYED_INTENT_VERSION, DUST_THRESHOLD, InvalidDelayedIntentError, LIQUIDATION_APPROVAL_BUFFER, LIQUIDATION_COMPRESSOR_V313_ADDRESS, LiquidationsService, MultichainLiquidationsService, RedemptionLoggerV310Contract, WithdrawalCompressorV310Contract, WithdrawalCompressorV311Contract, WithdrawalCompressorV313Contract, createRedemptionLogger, createWithdrawalCompressor, decodeDelayedIntent, encodeDelayedIntent, getWithdrawalCompressorAddress, iCreditAccountAbi, toClaimableWithdrawal, toPendingWithdrawal, toRequestableWithdrawal, toWithdrawalStatus };

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

@@ -1,109 +1,121 @@
+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 { WAD } from "../../constants/math.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 { 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 { LIQUIDATION_COMPRESSOR_V313_ADDRESS } from "./constants.js";
-import { iLiquidationCompressorV313Abi } from "../../../abi/ILiquidationCompressorV313.js";
-import { calcEstimatedProfit, calcRepaymentAmount, liquidationCallToRawTx, pickMainAsset, toLiquidationApproval, toLiquidatorWithdrawals, toReceivedAssets } from "./helpers.js";
+import { LIQUIDATION_APPROVAL_BUFFER, LIQUIDATION_COMPRESSOR_V313_ADDRESS } from "./constants.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 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: WAD - 1n,
 			includeZeroDebt: false
 		});
-		const seen = new 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 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 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) => 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: hexEq(data.requiredToken, "0x0000000000000000000000000000000000000000") ? account.totalValue.token : data.requiredToken,
-				balance: data.requiredAmount
-			},
+			repaymentAmount: priceOracle.toTokenAmount(hexEq(data.requiredToken, "0x0000000000000000000000000000000000000000") ? account.totalValue.token.address : data.requiredToken, data.requiredAmount),
 			isDelayed: data.expectedOutputs.some((o) => o.delayed),
-			receivedAssets: toReceivedAssets(data.expectedOutputs),
+			receivedAssets: this.#receivedAssets(data.expectedOutputs, priceOracle),
 			isLiquidatorEligible: data.isLiquidatorEligible,
 			isCreditAccountFrozen: data.isCreditAccountFrozen,
 			kycProtocol: data.kycProtocol || void 0,
-			kycToken: hexEq(data.kycToken, "0x0000000000000000000000000000000000000000") ? void 0 : data.kycToken,
-			approve: toLiquidationApproval({
-				target: data.liquidationCall.target,
-				creditFacade: suite.creditFacade.address,
-				creditManager: ca.creditManager,
-				token: data.requiredToken,
-				amount: data.requiredAmount
-			})
+			kycToken: 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 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 AddressSet(compressor.getWithdrawableAssets().map((a) => a.withdrawalPhantomToken));
-		const current = await compressor.getExternalAccountCurrentWithdrawals(props.liquidator, ...phantomTokens.asArray());
-		return 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;
@@ -120,14 +132,6 @@ var LiquidationsService = class extends SDKConstruct {
 		});
 		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;
@@ -142,20 +146,64 @@ var LiquidationsService = class extends SDKConstruct {
 				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: 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) {
 		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 = ADDRESS_0X0, ignoreReservePrices) {
 		const priceUpdates = await this.sdk.accounts.getOnDemandPriceUpdates(ca, ignoreReservePrices);
 		const { result } = await this.client.simulateContract({
@@ -170,10 +218,6 @@ var LiquidationsService = class extends SDKConstruct {
 		});
 		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) {
@@ -185,58 +229,58 @@ var LiquidationsService = class extends SDKConstruct {
 		}
 		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 = 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) / 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,
-			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: usdToNumber(ca.totalValueUSD)
 			},
-			totalValueUSD: ca.totalValueUSD,
 			repaymentAmount: {
-				token: unwrappedUnderlying,
-				balance: calcRepaymentAmount(ca.totalValue, liquidationDiscount)
+				token,
+				value: repaymentAmount,
+				valueUsd: usd(repaymentAmount)
 			},
 			estimatedProfit: {
-				token: unwrappedUnderlying,
-				balance: 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 (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
 export { LiquidationsService };

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

@@ -1,65 +1,59 @@
+import { MultichainConstruct } from "../../base/MultichainConstruct.js";
+import "../../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 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/esm/sdk/accounts/liquidations/constants.js

@@ -1,4 +1,15 @@
 //#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
-export { LIQUIDATION_COMPRESSOR_V313_ADDRESS };
+export { DUST_THRESHOLD, LIQUIDATION_APPROVAL_BUFFER, LIQUIDATION_COMPRESSOR_V313_ADDRESS };

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

@@ -1,5 +1,5 @@
-import { LIQUIDATION_COMPRESSOR_V313_ADDRESS } from "./constants.js";
+import { DUST_THRESHOLD, LIQUIDATION_APPROVAL_BUFFER, LIQUIDATION_COMPRESSOR_V313_ADDRESS } from "./constants.js";
 import { LiquidationsService } from "./LiquidationsService.js";
 import { MultichainLiquidationsService } from "./MultichainLiquidationsService.js";
 import "./types.js";
-export { LIQUIDATION_COMPRESSOR_V313_ADDRESS, LiquidationsService, MultichainLiquidationsService };
+export { DUST_THRESHOLD, LIQUIDATION_APPROVAL_BUFFER, LIQUIDATION_COMPRESSOR_V313_ADDRESS, LiquidationsService, MultichainLiquidationsService };

package/dist/esm/sdk/accounts/withdrawal-compressor/RedemptionLoggerV310Contract.js

@@ -1,7 +1,7 @@
+import { iRedemptionLoggerV310Abi } from "../../../abi/iRedemptionLoggerV310.js";
 import { BaseContract } from "../../base/BaseContract.js";
 import "../../base/index.js";
 import { decodeDelayedIntent } from "./intent-codec.js";
-import { iRedemptionLoggerV310Abi } from "../../../abi/iRedemptionLoggerV310.js";
 import { InvalidDelayedIntentError } from "./errors.js";
 //#region src/sdk/accounts/withdrawal-compressor/RedemptionLoggerV310Contract.ts
 const abi = iRedemptionLoggerV310Abi;

package/dist/esm/sdk/accounts/withdrawal-compressor/WithdrawalCompressorV310Contract.js

@@ -1,5 +1,5 @@
-import { AbstractWithdrawalCompressorContract } from "./AbstractWithdrawalCompressorContract.js";
 import { iWithdrawalCompressorV310Abi } from "../../../abi/IWithdrawalCompressorV310.js";
+import { AbstractWithdrawalCompressorContract } from "./AbstractWithdrawalCompressorContract.js";
 //#region src/sdk/accounts/withdrawal-compressor/WithdrawalCompressorV310Contract.ts
 const abi = iWithdrawalCompressorV310Abi;
 /**

package/dist/esm/sdk/accounts/withdrawal-compressor/WithdrawalCompressorV311Contract.js

@@ -1,5 +1,5 @@
-import { AbstractWithdrawalCompressorContract } from "./AbstractWithdrawalCompressorContract.js";
 import { iWithdrawalCompressorV311Abi } from "../../../abi/IWithdrawalCompressorV311.js";
+import { AbstractWithdrawalCompressorContract } from "./AbstractWithdrawalCompressorContract.js";
 //#region src/sdk/accounts/withdrawal-compressor/WithdrawalCompressorV311Contract.ts
 const abi = iWithdrawalCompressorV311Abi;
 /**

package/dist/esm/sdk/accounts/withdrawal-compressor/WithdrawalCompressorV313Contract.js

@@ -1,6 +1,6 @@
+import { iWithdrawalCompressorV313Abi } from "../../../abi/IWithdrawalCompressorV313.js";
 import { encodeDelayedIntent } from "./intent-codec.js";
 import { AbstractWithdrawalCompressorContract, iCreditAccountAbi, toClaimableWithdrawal, toPendingWithdrawal, toRequestableWithdrawal } from "./AbstractWithdrawalCompressorContract.js";
-import { iWithdrawalCompressorV313Abi } from "../../../abi/IWithdrawalCompressorV313.js";
 import { toWithdrawalStatus } from "./types.js";
 //#region src/sdk/accounts/withdrawal-compressor/WithdrawalCompressorV313Contract.ts
 const abi = iWithdrawalCompressorV313Abi;