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

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;

package/dist/cjs/sdk/base/MultichainConstruct.js

@@ -0,0 +1,80 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_core_errors = require("../core/errors.js");
+//#region src/sdk/base/MultichainConstruct.ts
+/**
+* @internal
+* Base class for services that fan out over the chains of a
+* {@link MultichainSDK}, the cross-chain counterpart of {@link SDKConstruct}.
+*
+* Requests are soft-failing: a chain that rejects (including a chain that is
+* not configured in the SDK) is logged as a warning and contributes no payload,
+* while the remaining chains still return their results. Every queried chain is
+* reported in {@link MultichainResult.meta}.
+*
+* @typeParam Plugins - Map of attached plugin types.
+**/
+var MultichainConstruct = class {
+	sdk;
+	constructor(sdk) {
+		this.sdk = sdk;
+	}
+	/**
+	* Fans out a request that returns a list, concatenating the lists of all
+	* chains that responded successfully.
+	**/
+	async queryChains(props) {
+		const { values, meta } = await this.#settle(props);
+		return {
+			result: values.flat(),
+			meta
+		};
+	}
+	/**
+	* Fans out a request with no payload, reporting the outcome of every queried
+	* chain in {@link MultichainResult.meta}.
+	**/
+	async runChains(props) {
+		const { meta } = await this.#settle(props);
+		return {
+			result: void 0,
+			meta
+		};
+	}
+	/**
+	* Runs the request on all queried chains in parallel. Duplicate networks are
+	* queried once, and {@link SettledChains.meta} follows the requested order.
+	**/
+	async #settle({ networks, label, run }) {
+		const requested = networks ? [...new Set(networks)] : [...this.sdk.chains.keys()];
+		const settled = await Promise.allSettled(requested.map(async (network) => {
+			const chainSdk = this.sdk.chains.get(network);
+			if (!chainSdk) throw new require_sdk_core_errors.ChainNotConfiguredError(network);
+			return run(chainSdk);
+		}));
+		const values = [];
+		const meta = [];
+		settled.forEach((result, i) => {
+			const network = requested[i];
+			if (result.status === "fulfilled") {
+				values.push(result.value);
+				meta.push({
+					network,
+					status: "success"
+				});
+				return;
+			}
+			(this.sdk.chains.get(network)?.logger ?? this.sdk.logger)?.warn(result.reason, `failed to ${label} on ${network}`);
+			meta.push({
+				network,
+				status: "error",
+				error: result.reason
+			});
+		});
+		return {
+			values,
+			meta
+		};
+	}
+};
+//#endregion
+exports.MultichainConstruct = MultichainConstruct;

package/dist/cjs/sdk/base/TokensMeta.js

@@ -4,6 +4,7 @@ const require_abi_iVersion = require("../../abi/iVersion.js");
 const require_sdk_utils_AddressMap = require("../utils/AddressMap.js");
 const require_sdk_utils_AddressSet = require("../utils/AddressSet.js");
 const require_sdk_utils_bytes32ToString = require("../utils/bytes32ToString.js");
+const require_sdk_chain_chains = require("../chain/chains.js");
 const require_sdk_utils_formatter = require("../utils/formatter.js");
 require("../utils/index.js");
 //#region src/sdk/base/TokensMeta.ts
@@ -91,6 +92,56 @@ var TokensMeta = class extends require_sdk_utils_AddressMap.AddressMap {
 		for (const [token, meta] of this.entries()) if (this.isRWAUnderlying(meta)) result.upsert(token, meta);
 		return result;
 	}
+	/**
+	* Describes a token the way the shared read model does.
+	*
+	* @param address - Token address.
+	* @throws If the token is not in the registry.
+	*/
+	mustGetToken(address) {
+		const meta = this.mustGet(address);
+		return {
+			chainId: this.#client.chain.id,
+			address: meta.addr,
+			symbol: meta.symbol,
+			name: meta.name,
+			decimals: meta.decimals,
+			assetType: require_sdk_chain_chains.getAssetType(meta.addr, this.#networkType)
+		};
+	}
+	/**
+	* Like {@link mustGetToken}, but returns `undefined` instead of throwing when the
+	* token is not in the registry.
+	*
+	* @param address - Token address.
+	*/
+	getToken(address) {
+		return this.get(address) ? this.mustGetToken(address) : void 0;
+	}
+	/**
+	* The token an RWA wrapper holds, or the token itself when it is not one.
+	*
+	* An RWA market borrows a compliance wrapper (e.g. `dcUSDC`) that converts
+	* one-for-one with the token behind it (`USDC`), and only that token means
+	* anything to a reader. Pricing still goes through the wrapper, which is what
+	* a market's oracle knows.
+	*
+	* @param token - Token address, wrapper or not.
+	*/
+	unwrapRWA(token) {
+		const meta = this.get(token);
+		if (!meta || !this.isRWAUnderlying(meta)) return token;
+		if (!this.has(meta.asset)) {
+			this.#logger?.debug(`no token meta for ${meta.asset} wrapped by ${token}, reporting the wrapper instead`);
+			return token;
+		}
+		return meta.asset;
+	}
+	get #networkType() {
+		const { chain } = this.#client;
+		if ("network" in chain) return chain.network;
+		throw new Error(`chain ${chain.id} is not a Gearbox SDK chain`);
+	}
 	formatBN(arg0, arg1, arg2) {
 		const token = typeof arg0 === "object" ? arg0.token : arg0;
 		const amount = typeof arg0 === "object" ? arg0.balance : arg1;

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

@@ -4,6 +4,7 @@ const require_sdk_base_ChainContractsRegister = require("./ChainContractsRegiste
 const require_sdk_base_Construct = require("./Construct.js");
 const require_sdk_base_BaseContract = require("./BaseContract.js");
 const require_sdk_base_errors = require("./errors.js");
+const require_sdk_base_MultichainConstruct = require("./MultichainConstruct.js");
 const require_sdk_base_PlaceholderContract = require("./PlaceholderContract.js");
 const require_sdk_base_SDKConstruct = require("./SDKConstruct.js");
 const require_sdk_base_token_types = require("./token-types.js");
@@ -13,6 +14,7 @@ exports.ChainContractsRegister = require_sdk_base_ChainContractsRegister.ChainCo
 exports.Construct = require_sdk_base_Construct.Construct;
 exports.ContractParseError = require_sdk_base_BaseContract.ContractParseError;
 exports.MissingSerializedParamsError = require_sdk_base_errors.MissingSerializedParamsError;
+exports.MultichainConstruct = require_sdk_base_MultichainConstruct.MultichainConstruct;
 exports.PHANTOM_TOKEN_CONTRACT_TYPES = require_sdk_base_token_types.PHANTOM_TOKEN_CONTRACT_TYPES;
 exports.PlaceholderContract = require_sdk_base_PlaceholderContract.PlaceholderContract;
 exports.RWA_ON_DEMAND_LP_MONOPOLIZED = require_sdk_base_token_types.RWA_ON_DEMAND_LP_MONOPOLIZED;