@gearbox-protocol/sdk 15.1.0-next.1 → 15.1.0-next.10

package/dist/cjs/sdk/positions/PositionsService.js

@@ -1,9 +1,21 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_utils_AddressMap = require("../utils/AddressMap.js");
+require("../constants/math.js");
+require("../constants/index.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_sdk_market_credit_dominantCollateral = require("../market/credit/dominantCollateral.js");
 const require_model_filters = require("../../model/filters.js");
 const require_model_positions = require("../../model/positions.js");
 require("../../model/index.js");
+require("../market/index.js");
+const require_sdk_positions_calcBorrowRate = require("./calcBorrowRate.js");
+const require_sdk_positions_calcHealthFactor = require("./calcHealthFactor.js");
+const require_sdk_positions_calcLiquidationPrice = require("./calcLiquidationPrice.js");
+const require_sdk_positions_calcTimeToLiquidationMs = require("./calcTimeToLiquidationMs.js");
+const require_sdk_positions_types = require("./types.js");
 //#region src/sdk/positions/PositionsService.ts
 /**
 * The `positions` read model of one chain: everything a wallet holds in the
@@ -28,7 +40,7 @@ var PositionsService = class extends require_sdk_base_SDKConstruct.SDKConstruct
 				wallet,
 				blockNumber
 			}) : Promise.resolve([]),
-			wanted("strategy") ? this.sdk.accounts.listPositions({
+			wanted("strategy") ? this.listStrategyPositions({
 				owner: wallet,
 				includeZeroDebt: !require_model_filters.isFilterSet(isZeroDebt) || isZeroDebt,
 				blockNumber
@@ -44,6 +56,206 @@ var PositionsService = class extends require_sdk_base_SDKConstruct.SDKConstruct
 			...liquidation
 		].filter((row) => require_model_positions.matchesPositionFilter(row, filter));
 	}
+	/**
+	* Describes all credit accounts of a wallet as strategy positions.
+	*
+	* @param props - {@link ListStrategyPositionsProps}
+	**/
+	async listStrategyPositions(props) {
+		const { owner, includeZeroDebt, blockNumber } = props;
+		const describable = (await this.sdk.accounts.getBorrowerCreditAccounts(owner, { includeZeroDebt }, blockNumber)).filter((ca) => {
+			if (!ca.success) this.logger?.warn(`cannot describe position of ${this.labelAddress(ca.creditAccount)}: collateral computation failed`);
+			return ca.success;
+		});
+		const withdrawals = await Promise.all(describable.map((ca) => this.#accountWithdrawals(ca, blockNumber)));
+		return describable.map((ca, i) => this.#toStrategyPosition(ca, withdrawals[i] ?? new require_sdk_utils_AddressMap.AddressMap()));
+	}
+	/**
+	* Health factor of an account state, in basis points (`10000` = 1.0).
+	**/
+	healthFactor(snapshot, options) {
+		const data = this.#marketData(snapshot);
+		return require_sdk_positions_calcHealthFactor.calcHealthFactor({
+			snapshot,
+			underlying: data.underlying,
+			decimals: data.decimals,
+			prices: data.prices,
+			reservePrices: data.reservePrices,
+			safePrices: options?.safePrices,
+			liquidationThresholds: data.liquidationThresholds,
+			activeQuotas: data.activeQuotas
+		});
+	}
+	/**
+	* Cost of an account state's debt, broken down into the pool's base rate
+	* and per-token quota rates.
+	**/
+	borrowRate(snapshot) {
+		const data = this.#marketData(snapshot);
+		return require_sdk_positions_calcBorrowRate.calcBorrowRate({
+			snapshot,
+			baseInterestRate: data.baseInterestRate,
+			feeInterest: data.feeInterest,
+			quotaRates: data.quotaRates
+		});
+	}
+	/**
+	* Estimated milliseconds until the account's health factor decays to
+	* `10000` under its current borrow rate, or `null` when the debt carries
+	* no rate (or the account is already liquidatable).
+	**/
+	timeToLiquidation(snapshot) {
+		const data = this.#marketData(snapshot);
+		return require_sdk_positions_calcTimeToLiquidationMs.calcTimeToLiquidationMs(require_sdk_positions_calcHealthFactor.calcHealthFactor({
+			snapshot,
+			underlying: data.underlying,
+			decimals: data.decimals,
+			prices: data.prices,
+			liquidationThresholds: data.liquidationThresholds,
+			activeQuotas: data.activeQuotas
+		}), BigInt(require_sdk_positions_calcBorrowRate.calcBorrowRate({
+			snapshot,
+			baseInterestRate: data.baseInterestRate,
+			feeInterest: data.feeInterest,
+			quotaRates: data.quotaRates
+		}).totalOnDebt));
+	}
+	/**
+	* Price of the single non-underlying collateral at which the account
+	* becomes liquidatable, or `null` when the account holds zero or several
+	* non-underlying assets.
+	**/
+	liquidationPrice(snapshot) {
+		const data = this.#marketData(snapshot);
+		return require_sdk_positions_calcLiquidationPrice.calcLiquidationPrice({
+			snapshot,
+			underlying: data.underlying,
+			decimals: data.decimals,
+			liquidationThresholds: data.liquidationThresholds
+		});
+	}
+	/**
+	* Builds one strategy position from an account snapshot.
+	*
+	* @param withdrawals - Delayed withdrawals of the account, keyed by the
+	* phantom token that represents them on it.
+	**/
+	#toStrategyPosition(ca, withdrawals) {
+		const suite = this.sdk.marketRegister.findCreditManager(ca.creditManager);
+		const { market } = suite;
+		const { priceOracle } = market;
+		const { pool } = market.pool;
+		const token = this.sdk.tokensMeta.mustGetToken(market.unwrappedUnderlying);
+		const totalDebtValue = ca.debt + ca.accruedInterest + ca.accruedFees;
+		const collateral = require_sdk_market_credit_dominantCollateral.dominantCollateral(ca, market);
+		const snapshot = require_sdk_positions_types.accountSnapshotFromCreditAccountData(ca);
+		const borrowRate = this.borrowRate(snapshot);
+		const timeToLiquidation = this.timeToLiquidation(snapshot);
+		const liquidationPrice = this.liquidationPrice(snapshot);
+		return {
+			kind: "strategy",
+			chainId: this.sdk.chainId,
+			creditManager: ca.creditManager,
+			creditAccount: ca.creditAccount,
+			name: collateral ? suite.strategyName(collateral) : token.symbol,
+			targetCollateral: collateral ? this.sdk.tokensMeta.mustGetToken(collateral) : null,
+			leverage: require_sdk_market_math.calcPositionLeverage(ca.totalValue, totalDebtValue),
+			borrowApy: require_sdk_market_math.calcBorrowApy(pool.baseInterestRate, suite.creditManager.feeInterest),
+			totalDebt: {
+				token,
+				value: totalDebtValue,
+				valueUsd: require_sdk_market_math.usdToNumber(ca.totalDebtUSD)
+			},
+			totalValue: {
+				token,
+				value: ca.totalValue,
+				valueUsd: require_sdk_market_math.usdToNumber(ca.totalValueUSD)
+			},
+			healthFactor: require_sdk_market_math.healthFactorBps(ca.healthFactor),
+			borrowRate,
+			timeToLiquidation,
+			liquidationPrice,
+			collaterals: ca.tokens.flatMap((t) => {
+				if ((t.mask & ca.enabledTokensMask) === 0n || t.balance <= 10n) return [];
+				return [{
+					collateral: priceOracle.toTokenAmount(t.token, t.balance),
+					quota: priceOracle.toTokenAmount(market.underlying, t.quota),
+					withdrawals: withdrawals.get(t.token) ?? []
+				}];
+			})
+		};
+	}
+	/**
+	* Delayed withdrawals of one account, keyed by the phantom token that
+	* represents them on it, so that each collateral row can pick up its own.
+	**/
+	async #accountWithdrawals(ca, blockNumber) {
+		const compressor = this.sdk.withdrawalCompressor;
+		const byPhantomToken = new require_sdk_utils_AddressMap.AddressMap(void 0, "accountWithdrawals");
+		const holdsPhantomToken = ca.tokens.some((t) => t.balance > 10n && compressor?.getWithdrawalSourceToken(t.token) !== void 0);
+		if (!compressor || !holdsPhantomToken) return byPhantomToken;
+		const { priceOracle } = this.sdk.marketRegister.findByCreditManager(ca.creditManager);
+		const { claimable, pending } = await compressor.getCurrentWithdrawals(ca.creditAccount, blockNumber);
+		const add = (w, outputs, claimableAt) => {
+			const assets = outputs.map((o) => ({
+				isDelayed: true,
+				...priceOracle.toTokenAmount(o.token, o.amount),
+				redeemer: w.redeemer,
+				claimableAt: claimableAt === void 0 ? void 0 : Number(claimableAt)
+			}));
+			byPhantomToken.upsert(w.withdrawalPhantomToken, [...byPhantomToken.get(w.withdrawalPhantomToken) ?? [], ...assets]);
+		};
+		for (const w of claimable) add(w, w.outputs);
+		for (const w of pending) add(w, w.expectedOutputs, w.claimableAt);
+		return byPhantomToken;
+	}
+	/**
+	* Collects decimals, prices and thresholds for the snapshot's tokens plus
+	* the market underlying, even when the account holds no underlying balance.
+	**/
+	#marketData(snapshot) {
+		const market = this.sdk.marketRegister.findByCreditManager(snapshot.creditManager);
+		const cm = this.sdk.marketRegister.findCreditManager(snapshot.creditManager).creditManager;
+		const { priceOracle } = market;
+		const underlying = market.pool.underlying;
+		const { pqk, pool } = market.pool;
+		const tokens = [underlying];
+		for (const a of snapshot.assets) tokens.push(a.token);
+		for (const q of snapshot.quotas) tokens.push(q.token);
+		const decimals = {};
+		const prices = {};
+		const reservePrices = {};
+		const liquidationThresholds = {};
+		const activeQuotas = {};
+		const quotaRates = {};
+		for (const token of tokens) {
+			const meta = this.sdk.tokensMeta.get(token);
+			if (meta) decimals[token] = meta.decimals;
+			try {
+				prices[token] = priceOracle.mainPrice(token);
+			} catch {}
+			try {
+				reservePrices[token] = priceOracle.reservePrice(token);
+			} catch {}
+			const lt = cm.liquidationThresholds.get(token);
+			if (lt !== void 0) liquidationThresholds[token] = lt;
+			if (pqk.hasActiveQuota(token)) {
+				activeQuotas[token] = true;
+				quotaRates[token] = pqk.quotaRate(token);
+			}
+		}
+		return {
+			underlying,
+			decimals,
+			prices,
+			reservePrices,
+			liquidationThresholds,
+			activeQuotas,
+			quotaRates,
+			baseInterestRate: pool.baseInterestRate,
+			feeInterest: cm.feeInterest
+		};
+	}
 };
 //#endregion
 exports.PositionsService = PositionsService;

package/dist/cjs/sdk/positions/calcBorrowRate.js

@@ -0,0 +1,43 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_utils_AddressMap = require("../utils/AddressMap.js");
+const require_sdk_constants_math = require("../constants/math.js");
+const require_sdk_market_math = require("../market/math.js");
+//#region src/sdk/positions/calcBorrowRate.ts
+/**
+* Cost of an account state's debt, broken down into the pool's base rate and
+* per-token quota rates.
+*
+* The base rate is the market's current borrow APY (the pool's base rate plus
+* the credit manager's interest fee) — the same value `borrowApy` reports on
+* a position; it is not recomputed for the projected pool liquidity. Quota
+* contributions are `quotaBalance * quotaRate` with the interest fee on top,
+* normalized against the total value (`total`, `quotas`) and against the
+* debt (`totalOnDebt`, the rate the debt itself grows at). Formulas are in
+* parity with the frontend's `BorrowRateUtils`.
+**/
+function calcBorrowRate(props) {
+	const { snapshot, baseInterestRate, feeInterest, quotaRates } = props;
+	const { quotas, totalDebt, totalValue } = snapshot;
+	const rates = new require_sdk_utils_AddressMap.AddressMap(Object.entries(quotaRates));
+	const base = require_sdk_market_math.calcBorrowApy(baseInterestRate, feeInterest);
+	const fee = require_sdk_constants_math.PERCENTAGE_FACTOR + BigInt(feeInterest);
+	let quotaRateSum = 0n;
+	const perQuota = {};
+	for (const q of quotas) {
+		if (q.balance <= 10n) continue;
+		const rate = rates.get(q.token);
+		const rateBalance = rate === void 0 ? 0n : q.balance * BigInt(rate);
+		quotaRateSum += rateBalance;
+		const withFee = rateBalance * fee / require_sdk_constants_math.PERCENTAGE_FACTOR;
+		perQuota[q.token] = totalValue > 0n ? Number(withFee / totalValue) : 0;
+	}
+	const quotaRateSumWithFee = quotaRateSum * fee / require_sdk_constants_math.PERCENTAGE_FACTOR;
+	return {
+		total: totalValue > 0n ? Number(totalDebt * BigInt(base) / totalValue) + Number(quotaRateSumWithFee / totalValue) : 0,
+		totalOnDebt: totalDebt > 0n ? base + Number(quotaRateSumWithFee / totalDebt) : 0,
+		base,
+		quotas: perQuota
+	};
+}
+//#endregion
+exports.calcBorrowRate = calcBorrowRate;

package/dist/cjs/sdk/positions/calcHealthFactor.js

@@ -0,0 +1,52 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_utils_AddressMap = require("../utils/AddressMap.js");
+const require_sdk_utils_bigint_math = require("../utils/bigint-math.js");
+const require_sdk_constants_math = require("../constants/math.js");
+let viem = require("viem");
+//#region src/sdk/positions/calcHealthFactor.ts
+/**
+* Health factor of an account state, in basis points (`10000` = 1.0).
+*
+* Collateral is valued under liquidation thresholds, with quoted tokens
+* capped by their quota, and compared against the debt's value. An account
+* with no debt reports `65535` (`MAX_UINT16`), the contract's own sentinel
+* scaled down. Formulas are in parity with the legacy `calcHealthFactor`.
+* Tokens with no price in {@link CalcHealthFactorProps.prices} contribute
+* nothing.
+**/
+function calcHealthFactor(props) {
+	const { snapshot, underlying, decimals, prices, reservePrices = {}, safePrices = false, liquidationThresholds, activeQuotas } = props;
+	if (snapshot.totalDebt === 0n) return Number(require_sdk_constants_math.MAX_UINT16);
+	const decimalsByToken = new require_sdk_utils_AddressMap.AddressMap(Object.entries(decimals));
+	const pricesByToken = new require_sdk_utils_AddressMap.AddressMap(Object.entries(prices));
+	const reservePricesByToken = new require_sdk_utils_AddressMap.AddressMap(Object.entries(reservePrices));
+	const lts = new require_sdk_utils_AddressMap.AddressMap(Object.entries(liquidationThresholds));
+	const active = new require_sdk_utils_AddressMap.AddressMap(Object.entries(activeQuotas));
+	const priceOf = (token, forCollateral) => {
+		const main = pricesByToken.get(token);
+		if (!safePrices || !forCollateral) return main;
+		const reserve = reservePricesByToken.get(token);
+		if (main !== void 0 && reserve !== void 0) return require_sdk_utils_bigint_math.BigIntMath.min(main, reserve);
+		return main ?? reserve;
+	};
+	const convertToUSD = (token, amount, forCollateral = false) => {
+		const price = priceOf(token, forCollateral);
+		if (price === void 0) return null;
+		const scale = 10n ** BigInt(decimalsByToken.get(token) ?? 18);
+		return amount * price / scale;
+	};
+	const assetMoney = snapshot.assets.reduce((acc, { token, balance }) => {
+		if (balance <= 10n) return acc;
+		const lt = BigInt(lts.get(token) ?? 0);
+		const tokenLtWeighted = (convertToUSD(token, balance, true) ?? 0n) * lt;
+		const quota = snapshot.quotas.find((q) => (0, viem.isAddressEqual)(q.token, token));
+		const quotaBalance = quota && (active.get(token) ?? false) ? quota.balance : 0n;
+		const quotaWeighted = (convertToUSD(underlying, quotaBalance) ?? 0n) * require_sdk_constants_math.PERCENTAGE_FACTOR;
+		return acc + (quota ? require_sdk_utils_bigint_math.BigIntMath.min(quotaWeighted, tokenLtWeighted) : tokenLtWeighted);
+	}, 0n);
+	const borrowedMoney = convertToUSD(underlying, snapshot.totalDebt) ?? 0n;
+	const hf = borrowedMoney > 0n ? assetMoney / borrowedMoney : 0n;
+	return Number(hf);
+}
+//#endregion
+exports.calcHealthFactor = calcHealthFactor;

package/dist/cjs/sdk/positions/calcLiquidationPrice.js

@@ -0,0 +1,23 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../constants/math.js");
+const require_sdk_positions_calcLiquidationPriceForTarget = require("./calcLiquidationPriceForTarget.js");
+let viem = require("viem");
+//#region src/sdk/positions/calcLiquidationPrice.ts
+/**
+* Liquidation price of an account state's target collateral, in the oracle's
+* 8-decimal (`PRICE_DECIMALS`) fixed point.
+*
+* As the frontend does, a liquidation price only exists when the account
+* holds exactly one non-dust non-underlying asset; otherwise `null`.
+**/
+function calcLiquidationPrice(props) {
+	const { snapshot, underlying } = props;
+	const targets = snapshot.assets.filter((a) => a.balance > 10n && !(0, viem.isAddressEqual)(a.token, underlying));
+	if (targets.length !== 1) return null;
+	return require_sdk_positions_calcLiquidationPriceForTarget.calcLiquidationPriceForTarget({
+		...props,
+		targetToken: targets[0].token
+	});
+}
+//#endregion
+exports.calcLiquidationPrice = calcLiquidationPrice;

package/dist/cjs/sdk/positions/calcLiquidationPriceForTarget.js

@@ -0,0 +1,30 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_utils_AddressMap = require("../utils/AddressMap.js");
+const require_sdk_constants_math = require("../constants/math.js");
+let viem = require("viem");
+//#region src/sdk/positions/calcLiquidationPriceForTarget.ts
+/**
+* Liquidation price of an explicitly named collateral token, in
+* `PRICE_DECIMALS` fixed point; `0n` when the account holds none of it or the
+* token has no liquidation threshold. Formula is in parity with the legacy
+* `liquidationPrice`: the effective debt (debt less the underlying balance's
+* contribution under its threshold) over the threshold-weighted target
+* balance.
+**/
+function calcLiquidationPriceForTarget(props) {
+	const { snapshot, targetToken, underlying, decimals, liquidationThresholds } = props;
+	const decimalsByToken = new require_sdk_utils_AddressMap.AddressMap(Object.entries(decimals));
+	const lts = new require_sdk_utils_AddressMap.AddressMap(Object.entries(liquidationThresholds));
+	const underlyingDecimals = decimalsByToken.get(underlying) ?? 18;
+	const underlyingBalance = snapshot.assets.find((a) => (0, viem.isAddressEqual)(a.token, underlying))?.balance ?? 0n;
+	const ltUnderlying = BigInt(lts.get(underlying) ?? 0);
+	const effectiveDebt = (snapshot.totalDebt - underlyingBalance * ltUnderlying / require_sdk_constants_math.PERCENTAGE_FACTOR) * require_sdk_constants_math.WAD / 10n ** BigInt(underlyingDecimals);
+	const targetDecimals = decimalsByToken.get(targetToken) ?? 18;
+	const targetBalance = snapshot.assets.find((a) => (0, viem.isAddressEqual)(a.token, targetToken))?.balance ?? 0n;
+	const effectiveTargetBalance = targetBalance * require_sdk_constants_math.WAD / 10n ** BigInt(targetDecimals);
+	const lpLT = BigInt(lts.get(targetToken) ?? 0);
+	if (targetBalance <= 10n || lpLT <= 0n) return 0n;
+	return effectiveDebt * require_sdk_constants_math.PRICE_DECIMALS * require_sdk_constants_math.PERCENTAGE_FACTOR / (effectiveTargetBalance * lpLT);
+}
+//#endregion
+exports.calcLiquidationPriceForTarget = calcLiquidationPriceForTarget;

package/dist/cjs/sdk/positions/calcTimeToLiquidationMs.js

@@ -0,0 +1,19 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_constants_math = require("../constants/math.js");
+//#region src/sdk/positions/calcTimeToLiquidationMs.ts
+/**
+* Estimated milliseconds until `healthFactorBps` decays to `10000` (1.0)
+* while the debt grows at `totalBorrowRateOnDebt`, in the same `Bps` scale
+* (`10000` = 100%) as {@link BorrowRateBreakdown.totalOnDebt} reports it —
+* not the legacy `PERCENTAGE_FACTOR_1KK` (`1_000_000` = 100%) scale the
+* pre-rewrite frontend fed into its own `getTimeToLiquidation`.
+*
+* `null` when the account is already at or under the liquidation threshold,
+* or when the debt carries no borrow rate at all.
+**/
+function calcTimeToLiquidationMs(healthFactorBps, totalBorrowRateOnDebt) {
+	if (BigInt(healthFactorBps) <= 10000n || totalBorrowRateOnDebt === 0n) return null;
+	return (BigInt(healthFactorBps) - require_sdk_constants_math.PERCENTAGE_FACTOR) * (BigInt(require_sdk_constants_math.SECONDS_PER_YEAR) * require_sdk_constants_math.PERCENTAGE_FACTOR / totalBorrowRateOnDebt) * 1000n / require_sdk_constants_math.PERCENTAGE_FACTOR;
+}
+//#endregion
+exports.calcTimeToLiquidationMs = calcTimeToLiquidationMs;

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

@@ -1,6 +1,17 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_positions_calcBorrowRate = require("./calcBorrowRate.js");
+const require_sdk_positions_calcHealthFactor = require("./calcHealthFactor.js");
+const require_sdk_positions_calcLiquidationPriceForTarget = require("./calcLiquidationPriceForTarget.js");
+const require_sdk_positions_calcLiquidationPrice = require("./calcLiquidationPrice.js");
+const require_sdk_positions_calcTimeToLiquidationMs = require("./calcTimeToLiquidationMs.js");
 const require_sdk_positions_MultichainPositionsService = require("./MultichainPositionsService.js");
+const require_sdk_positions_types = require("./types.js");
 const require_sdk_positions_PositionsService = require("./PositionsService.js");
-require("./types.js");
 exports.MultichainPositionsService = require_sdk_positions_MultichainPositionsService.MultichainPositionsService;
 exports.PositionsService = require_sdk_positions_PositionsService.PositionsService;
+exports.accountSnapshotFromCreditAccountData = require_sdk_positions_types.accountSnapshotFromCreditAccountData;
+exports.calcBorrowRate = require_sdk_positions_calcBorrowRate.calcBorrowRate;
+exports.calcHealthFactor = require_sdk_positions_calcHealthFactor.calcHealthFactor;
+exports.calcLiquidationPrice = require_sdk_positions_calcLiquidationPrice.calcLiquidationPrice;
+exports.calcLiquidationPriceForTarget = require_sdk_positions_calcLiquidationPriceForTarget.calcLiquidationPriceForTarget;
+exports.calcTimeToLiquidationMs = require_sdk_positions_calcTimeToLiquidationMs.calcTimeToLiquidationMs;

package/dist/cjs/sdk/positions/types.js

@@ -1 +1,32 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("../constants/math.js");
+//#region src/sdk/positions/types.ts
+/**
+* Builds an {@link AccountSnapshot} from on-chain credit account data: the
+* enabled, above-dust tokens become assets and quotas, and `totalDebt` is
+* principal plus accrued interest and fees.
+**/
+function accountSnapshotFromCreditAccountData(ca) {
+	const assets = [];
+	const quotas = [];
+	for (const t of ca.tokens) {
+		if ((t.mask & ca.enabledTokensMask) === 0n || t.balance <= 10n) continue;
+		assets.push({
+			token: t.token,
+			balance: t.balance
+		});
+		quotas.push({
+			token: t.token,
+			balance: t.quota
+		});
+	}
+	return {
+		creditManager: ca.creditManager,
+		assets,
+		quotas,
+		totalDebt: ca.debt + ca.accruedInterest + ca.accruedFees,
+		totalValue: ca.totalValue
+	};
+}
+//#endregion
+exports.accountSnapshotFromCreditAccountData = accountSnapshotFromCreditAccountData;

package/dist/cjs/sdk/utils/abi-decode.js

@@ -28,7 +28,7 @@ function functionArgsToMap(abi, functionName, args) {
 		name: functionName,
 		args
 	});
-	if (!abiItem || abiItem.type !== "function") throw new viem.AbiFunctionNotFoundError(functionName);
+	if (abiItem?.type !== "function") throw new viem.AbiFunctionNotFoundError(functionName);
 	const namedArgs = {};
 	if (Array.isArray(args)) args.forEach((value, i) => {
 		const input = abiItem.inputs?.[i];
@@ -51,7 +51,7 @@ function functionArgsToRecord(abi, functionName, args) {
 		name: functionName,
 		args
 	});
-	if (!abiItem || abiItem.type !== "function") throw new viem.AbiFunctionNotFoundError(functionName);
+	if (abiItem?.type !== "function") throw new viem.AbiFunctionNotFoundError(functionName);
 	const namedArgs = {};
 	if (Array.isArray(args)) args.forEach((value, i) => {
 		const key = (abiItem.inputs?.[i])?.name || `${i}`;

package/dist/cjs/sdk/utils/viem/executeMulticallBatches.js

@@ -0,0 +1,32 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+//#region src/sdk/utils/viem/executeMulticallBatches.ts
+/**
+* Executes the calls of several {@link MulticallBatch}es as a single multicall
+* aggregate and dispatches each batch its own slice of the results.
+*
+* Failures are allowed per call: loaders in a batch decide themselves how to
+* treat a reverted call (e.g. `contractType()` reverting on a plain ERC-20 is
+* expected). Use {@link executeDelegatedMulticalls} instead when the calls need
+* price updates applied first.
+*
+* @param client - Viem public client.
+* @param batches - Batches to execute together, empty ones are allowed.
+* @param opts - Block number forwarded to the multicall.
+**/
+async function executeMulticallBatches(client, batches, opts = {}) {
+	const contracts = batches.flatMap((b) => b.contracts);
+	if (!contracts.length) return;
+	const results = await client.multicall({
+		contracts,
+		allowFailure: true,
+		batchSize: 0,
+		blockNumber: opts.blockNumber
+	});
+	let offset = 0;
+	for (const batch of batches) {
+		batch.onResults(results.slice(offset, offset + batch.contracts.length));
+		offset += batch.contracts.length;
+	}
+}
+//#endregion
+exports.executeMulticallBatches = executeMulticallBatches;

package/dist/cjs/sdk/utils/viem/index.js

@@ -1,6 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_sdk_utils_viem_cast = require("./cast.js");
 const require_sdk_utils_viem_simulateCall = require("./simulateCall.js");
+const require_sdk_utils_viem_executeMulticallBatches = require("./executeMulticallBatches.js");
 const require_sdk_utils_viem_simulateMulticall = require("./simulateMulticall.js");
 const require_sdk_utils_viem_simulateWithPriceUpdates = require("./simulateWithPriceUpdates.js");
 const require_sdk_utils_viem_executeDelegatedMulticalls = require("./executeDelegatedMulticalls.js");
@@ -10,6 +11,7 @@ exports.SimulateWithPriceUpdatesError = require_sdk_utils_viem_simulateWithPrice
 exports.SimulationError = require_sdk_utils_viem_simulateCall.SimulationError;
 exports.estimateRawTxGas = require_sdk_utils_viem_sendRawTx.estimateRawTxGas;
 exports.executeDelegatedMulticalls = require_sdk_utils_viem_executeDelegatedMulticalls.executeDelegatedMulticalls;
+exports.executeMulticallBatches = require_sdk_utils_viem_executeMulticallBatches.executeMulticallBatches;
 exports.generateCastTraceCall = require_sdk_utils_viem_cast.generateCastTraceCall;
 exports.getCastTraceArgs = require_sdk_utils_viem_cast.getCastTraceArgs;
 exports.getSimulateWithPriceUpdatesError = require_sdk_utils_viem_simulateWithPriceUpdates.getSimulateWithPriceUpdatesError;

package/dist/esm/abi/iExpirable.js

@@ -0,0 +1,14 @@
+//#region src/abi/iExpirable.ts
+const iExpirableAbi = [{
+	type: "function",
+	inputs: [],
+	name: "isExpired",
+	outputs: [{
+		name: "",
+		internalType: "bool",
+		type: "bool"
+	}],
+	stateMutability: "view"
+}];
+//#endregion
+export { iExpirableAbi };

package/dist/esm/common-utils/utils/apy/get-single-quota-borrow-rate.js

@@ -4,6 +4,8 @@ import { calcQuotaBorrowRate } from "../creditAccount/calc-quota-borrow-rate.js"
 /**
 * Under the hood sums up rates for all given quotas and then multiplies them by 1+feeInterest,
 * but it is expected that the ONLY quota will be passed
+*
+* @deprecated Use `calcBorrowRate` from `sdk/positions` instead.
 */
 function getSingleQuotaBorrowRate(props) {
 	const qr = calcQuotaBorrowRate(props);

package/dist/esm/common-utils/utils/creditAccount/calc-health-factor.js

@@ -1,9 +1,5 @@
-import { BigIntMath } from "../../../sdk/utils/bigint-math.js";
-import { PERCENTAGE_FACTOR, PRICE_DECIMALS } from "../../../sdk/constants/math.js";
-import "../../../sdk/index.js";
-import { PriceUtils } from "../price-math.js";
+import { calcHealthFactor as calcHealthFactor$1 } from "../../../sdk/positions/calcHealthFactor.js";
 //#region src/common-utils/utils/creditAccount/calc-health-factor.ts
-const MAX_UINT16 = 65535;
 /**
 * Computes account health factor in percentage-factor units.
 *
@@ -14,25 +10,31 @@ const MAX_UINT16 = 65535;
 * @param props Credit account balances, quotas, prices, thresholds, and debt context.
 * @returns Health factor as a number in `PERCENTAGE_FACTOR` scale,
 * or `65535` when debt is zero.
+*
+* @deprecated Use `calcHealthFactor` from `sdk/positions` instead; this
+* wrapper only maps the legacy props onto an `AccountSnapshot`.
 */
 function calcHealthFactor({ assets, quotas, quotasInfo, liquidationThresholds, underlyingToken, debt, prices, tokensList }) {
-	if (debt === 0n) return MAX_UINT16;
-	const underlyingDecimals = tokensList[underlyingToken]?.decimals || 18;
-	const underlyingPrice = prices[underlyingToken] || 0n;
-	const assetMoney = assets.reduce((acc, { token: tokenAddress, balance: amount }) => {
-		const tokenDecimals = tokensList[tokenAddress]?.decimals || 18;
-		const lt = liquidationThresholds[tokenAddress] || 0n;
-		const price = prices[tokenAddress] || 0n;
-		const tokenLtMoney = PriceUtils.calcTotalPrice(price, amount, tokenDecimals) * lt / PERCENTAGE_FACTOR;
-		const { isActive = false } = quotasInfo?.[tokenAddress] || {};
-		const quota = quotas[tokenAddress];
-		const quotaBalance = isActive ? quota?.balance || 0n : 0n;
-		const quotaMoney = PriceUtils.calcTotalPrice(underlyingPrice, quotaBalance, underlyingDecimals);
-		return acc + (quota ? BigIntMath.min(quotaMoney, tokenLtMoney) : tokenLtMoney);
-	}, 0n);
-	const borrowedMoney = PriceUtils.calcTotalPrice(underlyingPrice || PRICE_DECIMALS, debt, underlyingDecimals);
-	const hfInPercent = borrowedMoney > 0n ? assetMoney * PERCENTAGE_FACTOR / borrowedMoney : 0n;
-	return Number(hfInPercent);
+	const decimals = {};
+	for (const [token, meta] of Object.entries(tokensList)) decimals[token] = meta.decimals;
+	const lts = {};
+	for (const [token, lt] of Object.entries(liquidationThresholds)) lts[token] = Number(lt);
+	const activeQuotas = {};
+	for (const [token, info] of Object.entries(quotasInfo)) if (info?.isActive) activeQuotas[token] = true;
+	return calcHealthFactor$1({
+		snapshot: {
+			creditManager: underlyingToken,
+			assets,
+			quotas: Object.values(quotas),
+			totalDebt: debt,
+			totalValue: 0n
+		},
+		underlying: underlyingToken,
+		decimals,
+		prices,
+		liquidationThresholds: lts,
+		activeQuotas
+	});
 }
 //#endregion
 export { calcHealthFactor };

package/dist/esm/common-utils/utils/creditAccount/calc-quota-borrow-rate.js

@@ -8,6 +8,8 @@
 *
 * @param props Quota balances and per-token quota rates.
 * @returns Sum of `balance * rate` terms in percentage-factor scale.
+*
+* @deprecated Use `calcBorrowRate` from `sdk/positions` instead.
 */
 function calcQuotaBorrowRate({ quotas, quotaRates }) {
 	return Object.values(quotas).reduce((acc, { token, balance }) => {

package/dist/esm/common-utils/utils/creditAccount/get-time-to-liquidation.js

@@ -1,5 +1,4 @@
-import { PERCENTAGE_DECIMALS, PERCENTAGE_FACTOR, SECONDS_PER_YEAR } from "../../../sdk/constants/math.js";
-import "../../../sdk/index.js";
+import { calcTimeToLiquidationMs } from "../../../sdk/positions/calcTimeToLiquidationMs.js";
 //#region src/common-utils/utils/creditAccount/get-time-to-liquidation.ts
 /**
 * Estimates time remaining until health factor reaches liquidation level.
@@ -8,13 +7,17 @@ import "../../../sdk/index.js";
 * and returns a millisecond duration until `healthFactor` decays to `1.0`
 * (`PERCENTAGE_FACTOR` in internal scale).
 *
-* @param props Current health factor and `totalBorrowRate * debt` term.
+* @param props Current health factor and `totalBorrowRate_debt`, both `Bps`
+* (`10000` = 100%) — not the legacy `PERCENTAGE_FACTOR_1KK` (`1_000_000` =
+* 100%) scale the pre-rewrite frontend fed this under the same name.
 * @returns Milliseconds to liquidation as `bigint`, or `null` when already at/under
 * liquidation threshold or when borrow-rate exposure is zero.
+*
+* @deprecated Use `calcTimeToLiquidationMs` from `sdk/positions` instead;
+* this wrapper only forwards to the new implementation.
 */
 function getTimeToLiquidation({ healthFactor, totalBorrowRate_debt }) {
-	if (healthFactor <= 10000n || totalBorrowRate_debt === 0n) return null;
-	return (BigInt(healthFactor) - PERCENTAGE_FACTOR) * (BigInt(SECONDS_PER_YEAR) * PERCENTAGE_FACTOR * PERCENTAGE_DECIMALS / totalBorrowRate_debt) * 1000n / PERCENTAGE_FACTOR;
+	return calcTimeToLiquidationMs(healthFactor, totalBorrowRate_debt);
 }
 //#endregion
 export { getTimeToLiquidation };