@gearbox-protocol/sdk 15.1.0-next.2 → 15.1.0-next.21

package/dist/esm/sdk/pools/PoolService.js

@@ -1,7 +1,7 @@
 import { ierc20Abi } from "../../abi/iERC20.js";
 import { AddressSet } from "../utils/AddressSet.js";
 import "../constants/addresses.js";
-import { RAY } from "../constants/math.js";
+import { PERCENTAGE_FACTOR, RAY } from "../constants/math.js";
 import "../constants/index.js";
 import { hexEq } from "../utils/hex.js";
 import "../utils/index.js";
@@ -14,6 +14,12 @@ import { IERC20ZapperContract } from "../market/zapper/IERC20ZapperContract.js";
 import { IETHZapperContract } from "../market/zapper/IETHZapperContract.js";
 import "../market/index.js";
 //#region src/sdk/pools/PoolService.ts
+/**
+* Haircut on reported pool liquidity, so a withdrawal sized against the reported
+* figure is not defeated by rounding in the share conversion.
+*/
+const LIQUIDITY_SAFETY_NUM = 99999n;
+const LIQUIDITY_SAFETY_DENOM = 100000n;
 var PoolService = class extends SDKConstruct {
 	/**
 	* {@inheritDoc IPoolsService.getDepositTokensIn}
@@ -115,10 +121,87 @@ var PoolService = class extends SDKConstruct {
 		return this.#withdrawalTokensOut(pool, tokenIn, true);
 	}
 	/**
+	* {@inheritDoc IPoolsService.simulateDeposit}
+	*/
+	simulateDeposit(props) {
+		const { pool: poolAddr, amount } = props;
+		const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
+		const tokenIn = props.tokenIn ?? pool.underlying;
+		const tokenOut = this.#resolveTokenOut(props.tokenOut, () => this.getDepositTokensOut(poolAddr, tokenIn), {
+			poolAddr,
+			tokenIn,
+			operation: "deposit"
+		});
+		const { zapper } = this.getDepositMetadata(poolAddr, tokenIn, tokenOut);
+		return {
+			tokenIn: {
+				token: tokenIn,
+				balance: amount
+			},
+			tokenOut: {
+				token: tokenOut,
+				balance: toShares(pool.pool, amount)
+			},
+			zapper: zapper?.baseParams.addr
+		};
+	}
+	/**
+	* {@inheritDoc IPoolsService.simulateWithdraw}
+	*/
+	simulateWithdraw(props) {
+		const { pool: poolAddr, amount } = props;
+		const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
+		const tokenIn = props.tokenIn ?? poolAddr;
+		const tokenOut = this.#resolveTokenOut(props.tokenOut, () => this.getWithdrawalTokensOut(poolAddr, tokenIn), {
+			poolAddr,
+			tokenIn,
+			operation: "withdrawal"
+		});
+		const { zapper } = this.getWithdrawalMetadata(poolAddr, tokenIn, tokenOut);
+		return {
+			tokenIn: {
+				token: tokenIn,
+				balance: toSharesUp(pool.pool, amount)
+			},
+			tokenOut: {
+				token: tokenOut,
+				balance: amount
+			},
+			zapper: zapper?.baseParams.addr,
+			availableLiquidity: pool.pool.availableLiquidity * LIQUIDITY_SAFETY_NUM / LIQUIDITY_SAFETY_DENOM
+		};
+	}
+	/**
+	* {@inheritDoc IPoolsService.simulateRedeem}
+	*/
+	simulateRedeem(props) {
+		const { pool: poolAddr, amount } = props;
+		const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
+		const tokenIn = props.tokenIn ?? poolAddr;
+		const tokenOut = this.#resolveTokenOut(props.tokenOut, () => this.getWithdrawalTokensOut(poolAddr, tokenIn), {
+			poolAddr,
+			tokenIn,
+			operation: "withdrawal"
+		});
+		const { zapper } = this.getWithdrawalMetadata(poolAddr, tokenIn, tokenOut);
+		return {
+			tokenIn: {
+				token: tokenIn,
+				balance: amount
+			},
+			tokenOut: {
+				token: tokenOut,
+				balance: toAssets(pool.pool, amount)
+			},
+			zapper: zapper?.baseParams.addr,
+			availableLiquidity: pool.pool.availableLiquidity * LIQUIDITY_SAFETY_NUM / LIQUIDITY_SAFETY_DENOM
+		};
+	}
+	/**
 	* {@inheritDoc IPoolsService.removeLiquidity}
 	*/
 	removeLiquidity(props) {
-		const { pool, amount, meta, wallet, permit } = props;
+		const { pool, amount, meta, wallet, permit, mode = "withdraw" } = props;
 		const underlying = this.#describeUnderlying(pool);
 		if (this.sdk.tokensMeta.isRWAUnderlying(underlying)) {
 			if (underlying.contractType === "RWA_UNDERLYING::ON_DEMAND") {
@@ -139,8 +222,10 @@ var PoolService = class extends SDKConstruct {
 				};
 			}
 		}
+		const poolContract = this.sdk.marketRegister.findByPool(pool).pool.pool;
 		if (meta.zapper instanceof IETHZapperContract || meta.zapper instanceof IERC20ZapperContract) {
-			const tx = permit ? meta.zapper.redeemWithPermit(amount, wallet, permit.deadline, permit.v, permit.r, permit.s) : meta.zapper.redeem(amount, wallet);
+			const shares = mode === "withdraw" ? toSharesUp(poolContract, amount) : amount;
+			const tx = permit ? meta.zapper.redeemWithPermit(shares, wallet, permit.deadline, permit.v, permit.r, permit.s) : meta.zapper.redeem(shares, wallet);
 			return {
 				tx,
 				calls: [{
@@ -149,7 +234,7 @@ var PoolService = class extends SDKConstruct {
 				}]
 			};
 		}
-		const tx = this.sdk.marketRegister.findByPool(pool).pool.pool.redeem(amount, wallet, wallet);
+		const tx = mode === "withdraw" ? poolContract.withdraw(amount, wallet, wallet) : poolContract.redeem(amount, wallet, wallet);
 		return {
 			tx,
 			calls: [{
@@ -309,6 +394,18 @@ var PoolService = class extends SDKConstruct {
 			type
 		};
 	}
+	/**
+	* Picks the route output when the caller left it open.
+	*
+	* Only an unambiguous single route can be defaulted: with several outputs the
+	* choice is the caller's, and with none there is no route to preview.
+	*/
+	#resolveTokenOut(requested, candidates, ctx) {
+		if (requested) return requested;
+		const options = candidates();
+		if (options.length !== 1) throw new Error(`tokenOut is required: ${options.length} ${ctx.operation} routes from ${this.labelAddress(ctx.tokenIn)} on pool ${this.labelAddress(ctx.poolAddr)}`);
+		return options[0];
+	}
 	#describeUnderlying(pool) {
 		const market = this.sdk.marketRegister.findByPool(pool);
 		return this.sdk.tokensMeta.mustGet(market.underlying);
@@ -317,7 +414,7 @@ var PoolService = class extends SDKConstruct {
 		const { pool } = market.pool;
 		return {
 			kind: "pool",
-			name: market.poolName,
+			name: this.sdk.tokensMeta.mustGetToken(pool.address).name,
 			chainId: this.chainId,
 			pool: pool.address,
 			netValue: {
@@ -328,5 +425,35 @@ var PoolService = class extends SDKConstruct {
 		};
 	}
 };
+/**
+* Shares minted for `assets`, as `previewDeposit` would report them.
+*
+* Both directions convert through the diesel rate — underlying per RAY of
+* shares — because that is the rate the pool itself divides by, and the only
+* exact one the SDK holds: `totalAssets` is this rate multiplied out, so
+* converting back through it costs a wei on large amounts. Rounds down, as
+* minting does.
+*/
+function toShares(pool, assets) {
+	const { dieselRate } = pool;
+	return dieselRate === 0n ? assets : assets * RAY / dieselRate;
+}
+/**
+* Shares a withdrawal of `assets` burns, as `previewWithdraw` would report
+* them: {@link toShares} rounded the other way, since the burn has to cover
+* the payout the caller asked for.
+*/
+function toSharesUp(pool, assets) {
+	const { dieselRate } = pool;
+	return dieselRate === 0n ? assets : (assets * RAY + dieselRate - 1n) / dieselRate;
+}
+/**
+* Underlying paid out for `shares`, as `previewRedeem` would report it:
+* {@link toShares} run backwards, less the pool's withdrawal fee.
+*/
+function toAssets(pool, shares) {
+	const { dieselRate, withdrawFee } = pool;
+	return (dieselRate === 0n ? shares : shares * dieselRate / RAY) * (PERCENTAGE_FACTOR - withdrawFee) / PERCENTAGE_FACTOR;
+}
 //#endregion
-export { PoolService };
+export { PoolService, toShares, toSharesUp };

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

@@ -1,3 +1,3 @@
-import { PoolService } from "./PoolService.js";
+import { PoolService, toShares, toSharesUp } from "./PoolService.js";
 import "./types.js";
-export { PoolService };
+export { PoolService, toShares, toSharesUp };

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

@@ -1,8 +1,20 @@
+import { AddressMap } from "../utils/AddressMap.js";
+import { getAccountTargetCollateral } from "../chain/chains.js";
+import "../constants/math.js";
+import "../constants/index.js";
+import "../utils/index.js";
 import { SDKConstruct } from "../base/SDKConstruct.js";
 import "../base/index.js";
+import { calcBorrowApy, calcPositionLeverage, healthFactorBps, usdToNumber } from "../market/math.js";
+import { strategyName } from "../market/strategyName.js";
 import { isFilterSet } from "../../model/filters.js";
 import { matchesPositionFilter } from "../../model/positions.js";
 import "../../model/index.js";
+import { calcBorrowRate } from "./calcBorrowRate.js";
+import { calcHealthFactor } from "./calcHealthFactor.js";
+import { calcLiquidationPrice } from "./calcLiquidationPrice.js";
+import { calcTimeToLiquidationMs } from "./calcTimeToLiquidationMs.js";
+import { accountSnapshotFromCreditAccountData } from "./types.js";
 //#region src/sdk/positions/PositionsService.ts
 /**
 * The `positions` read model of one chain: everything a wallet holds in the
@@ -27,7 +39,7 @@ var PositionsService = class extends SDKConstruct {
 				wallet,
 				blockNumber
 			}) : Promise.resolve([]),
-			wanted("strategy") ? this.sdk.accounts.listPositions({
+			wanted("strategy") ? this.listStrategyPositions({
 				owner: wallet,
 				includeZeroDebt: !isFilterSet(isZeroDebt) || isZeroDebt,
 				blockNumber
@@ -43,6 +55,208 @@ var PositionsService = class extends SDKConstruct {
 			...liquidation
 		].filter((row) => 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 AddressMap()));
+	}
+	/**
+	* Health factor of an account state, in basis points (`10000` = 1.0).
+	**/
+	healthFactor(snapshot, options) {
+		const data = this.#marketData(snapshot);
+		return 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 calcBorrowRate({
+			snapshot,
+			baseInterestRate: data.baseInterestRate,
+			feeInterest: data.feeInterest,
+			quotaRates: data.quotaRates,
+			resolveToken: (address) => this.sdk.tokensMeta.mustGetToken(address)
+		});
+	}
+	/**
+	* 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 calcTimeToLiquidationMs(calcHealthFactor({
+			snapshot,
+			underlying: data.underlying,
+			decimals: data.decimals,
+			prices: data.prices,
+			liquidationThresholds: data.liquidationThresholds,
+			activeQuotas: data.activeQuotas
+		}), BigInt(calcBorrowRate({
+			snapshot,
+			baseInterestRate: data.baseInterestRate,
+			feeInterest: data.feeInterest,
+			quotaRates: data.quotaRates,
+			resolveToken: (address) => this.sdk.tokensMeta.mustGetToken(address)
+		}).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 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 target = getAccountTargetCollateral(ca.creditAccount, this.sdk.chainId) ?? suite.strategyTargetCollateral;
+		const snapshot = 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: target ? strategyName(this.sdk.tokensMeta.mustGetToken(target), token, this.sdk.chainId) : token.symbol,
+			targetCollateral: target ? this.sdk.tokensMeta.mustGetToken(target) : null,
+			leverage: calcPositionLeverage(ca.totalValue, totalDebtValue),
+			borrowApy: calcBorrowApy(pool.baseInterestRate, suite.creditManager.feeInterest),
+			totalDebt: {
+				token,
+				value: totalDebtValue,
+				valueUsd: usdToNumber(ca.totalDebtUSD)
+			},
+			totalValue: {
+				token,
+				value: ca.totalValue,
+				valueUsd: usdToNumber(ca.totalValueUSD)
+			},
+			healthFactor: healthFactorBps(ca.healthFactor),
+			borrowRate,
+			timeToLiquidation,
+			liquidationPrice,
+			collaterals: ca.tokens.flatMap((t) => {
+				if (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 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
 export { PositionsService };

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

@@ -0,0 +1,45 @@
+import { AddressMap } from "../utils/AddressMap.js";
+import { PERCENTAGE_FACTOR } from "../constants/math.js";
+import { calcBorrowApy } from "../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, resolveToken } = props;
+	const { quotas, totalDebt, totalValue } = snapshot;
+	const rates = new AddressMap(Object.entries(quotaRates));
+	const base = calcBorrowApy(baseInterestRate, feeInterest);
+	const fee = 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 / PERCENTAGE_FACTOR;
+		perQuota.push({
+			token: resolveToken(q.token),
+			rate: totalValue > 0n ? Number(withFee / totalValue) : 0
+		});
+	}
+	const quotaRateSumWithFee = quotaRateSum * fee / 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
+export { calcBorrowRate };

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

@@ -0,0 +1,51 @@
+import { AddressMap } from "../utils/AddressMap.js";
+import { BigIntMath } from "../utils/bigint-math.js";
+import { MAX_UINT16, PERCENTAGE_FACTOR } from "../constants/math.js";
+import { isAddressEqual } from "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(MAX_UINT16);
+	const decimalsByToken = new AddressMap(Object.entries(decimals));
+	const pricesByToken = new AddressMap(Object.entries(prices));
+	const reservePricesByToken = new AddressMap(Object.entries(reservePrices));
+	const lts = new AddressMap(Object.entries(liquidationThresholds));
+	const active = new 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 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) => isAddressEqual(q.token, token));
+		const quotaBalance = quota && (active.get(token) ?? false) ? quota.balance : 0n;
+		const quotaWeighted = (convertToUSD(underlying, quotaBalance) ?? 0n) * PERCENTAGE_FACTOR;
+		return acc + (quota ? BigIntMath.min(quotaWeighted, tokenLtWeighted) : tokenLtWeighted);
+	}, 0n);
+	const borrowedMoney = convertToUSD(underlying, snapshot.totalDebt) ?? 0n;
+	const hf = borrowedMoney > 0n ? assetMoney / borrowedMoney : 0n;
+	return Number(hf);
+}
+//#endregion
+export { calcHealthFactor };

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

@@ -0,0 +1,22 @@
+import "../constants/math.js";
+import { calcLiquidationPriceForTarget } from "./calcLiquidationPriceForTarget.js";
+import { isAddressEqual } from "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 && !isAddressEqual(a.token, underlying));
+	if (targets.length !== 1) return null;
+	return calcLiquidationPriceForTarget({
+		...props,
+		targetToken: targets[0].token
+	});
+}
+//#endregion
+export { calcLiquidationPrice };

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

@@ -0,0 +1,29 @@
+import { AddressMap } from "../utils/AddressMap.js";
+import { PERCENTAGE_FACTOR, PRICE_DECIMALS, WAD } from "../constants/math.js";
+import { isAddressEqual } from "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 AddressMap(Object.entries(decimals));
+	const lts = new AddressMap(Object.entries(liquidationThresholds));
+	const underlyingDecimals = decimalsByToken.get(underlying) ?? 18;
+	const underlyingBalance = snapshot.assets.find((a) => isAddressEqual(a.token, underlying))?.balance ?? 0n;
+	const ltUnderlying = BigInt(lts.get(underlying) ?? 0);
+	const effectiveDebt = (snapshot.totalDebt - underlyingBalance * ltUnderlying / PERCENTAGE_FACTOR) * WAD / 10n ** BigInt(underlyingDecimals);
+	const targetDecimals = decimalsByToken.get(targetToken) ?? 18;
+	const targetBalance = snapshot.assets.find((a) => isAddressEqual(a.token, targetToken))?.balance ?? 0n;
+	const effectiveTargetBalance = targetBalance * WAD / 10n ** BigInt(targetDecimals);
+	const lpLT = BigInt(lts.get(targetToken) ?? 0);
+	if (targetBalance <= 10n || lpLT <= 0n) return 0n;
+	return effectiveDebt * PRICE_DECIMALS * PERCENTAGE_FACTOR / (effectiveTargetBalance * lpLT);
+}
+//#endregion
+export { calcLiquidationPriceForTarget };

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

@@ -0,0 +1,18 @@
+import { PERCENTAGE_FACTOR, SECONDS_PER_YEAR } from "../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) - PERCENTAGE_FACTOR) * (BigInt(SECONDS_PER_YEAR) * PERCENTAGE_FACTOR / totalBorrowRateOnDebt) * 1000n / PERCENTAGE_FACTOR;
+}
+//#endregion
+export { calcTimeToLiquidationMs };

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

@@ -1,4 +1,9 @@
+import { calcBorrowRate } from "./calcBorrowRate.js";
+import { calcHealthFactor } from "./calcHealthFactor.js";
+import { calcLiquidationPriceForTarget } from "./calcLiquidationPriceForTarget.js";
+import { calcLiquidationPrice } from "./calcLiquidationPrice.js";
+import { calcTimeToLiquidationMs } from "./calcTimeToLiquidationMs.js";
 import { MultichainPositionsService } from "./MultichainPositionsService.js";
+import { accountSnapshotFromCreditAccountData } from "./types.js";
 import { PositionsService } from "./PositionsService.js";
-import "./types.js";
-export { MultichainPositionsService, PositionsService };
+export { MultichainPositionsService, PositionsService, accountSnapshotFromCreditAccountData, calcBorrowRate, calcHealthFactor, calcLiquidationPrice, calcLiquidationPriceForTarget, calcTimeToLiquidationMs };

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

@@ -1 +1,29 @@
-export {};
+import "../constants/math.js";
+//#region src/sdk/positions/types.ts
+/**
+* Builds an {@link AccountSnapshot} from on-chain credit account data
+**/
+function accountSnapshotFromCreditAccountData(ca) {
+	const assets = [];
+	const quotas = [];
+	for (const t of ca.tokens) {
+		if (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
+export { accountSnapshotFromCreditAccountData };

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

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