@gearbox-protocol/sdk 16.0.0-next.9 → 16.0.0

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

@@ -1,7 +1,7 @@
-import { AddressSet } from "../utils/AddressSet.js";
 import { ierc20Abi } from "../../abi/iERC20.js";
+import { AddressSet } from "../utils/AddressSet.js";
 import "../constants/addresses.js";
-import { PERCENTAGE_FACTOR, RAY } from "../constants/math.js";
+import { PERCENTAGE_FACTOR } from "../constants/math.js";
 import "../constants/index.js";
 import { hexEq } from "../utils/hex.js";
 import "../utils/index.js";
@@ -20,6 +20,14 @@ import "../market/index.js";
 */
 const LIQUIDITY_SAFETY_NUM = 99999n;
 const LIQUIDITY_SAFETY_DENOM = 100000n;
+/**
+* What the pool can actually pay out right now, shaved by a hair so a
+* withdrawal sized against it does not fail on rounding.
+**/
+function payoutCeiling(market) {
+	const { pool } = market;
+	return market.priceOracle.toAmount(pool.underlying, pool.pool.availableLiquidity * LIQUIDITY_SAFETY_NUM / LIQUIDITY_SAFETY_DENOM);
+}
 var PoolService = class extends SDKConstruct {
 	/**
 	* {@inheritDoc IPoolsService.getDepositTokensIn}
@@ -125,7 +133,9 @@ var PoolService = class extends SDKConstruct {
 	*/
 	simulateDeposit(props) {
 		const { pool: poolAddr, amount } = props;
-		const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
+		const market = this.sdk.marketRegister.findByPool(poolAddr);
+		const { pool } = market;
+		const { toTokenAmount } = market.priceOracle;
 		const tokenIn = props.tokenIn ?? pool.underlying;
 		const tokenOut = this.#resolveTokenOut(props.tokenOut, () => this.getDepositTokensOut(poolAddr, tokenIn), {
 			poolAddr,
@@ -134,14 +144,8 @@ var PoolService = class extends SDKConstruct {
 		});
 		const { zapper } = this.getDepositMetadata(poolAddr, tokenIn, tokenOut);
 		return {
-			tokenIn: {
-				token: tokenIn,
-				balance: amount
-			},
-			tokenOut: {
-				token: tokenOut,
-				balance: toShares(pool.pool, amount)
-			},
+			tokenIn: toTokenAmount(tokenIn, amount),
+			tokenOut: toTokenAmount(tokenOut, pool.pool.underlyingToShares(amount)),
 			zapper: zapper?.baseParams.addr
 		};
 	}
@@ -150,7 +154,9 @@ var PoolService = class extends SDKConstruct {
 	*/
 	simulateWithdraw(props) {
 		const { pool: poolAddr, amount } = props;
-		const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
+		const market = this.sdk.marketRegister.findByPool(poolAddr);
+		const { pool } = market;
+		const { toTokenAmount } = market.priceOracle;
 		const tokenIn = props.tokenIn ?? poolAddr;
 		const tokenOut = this.#resolveTokenOut(props.tokenOut, () => this.getWithdrawalTokensOut(poolAddr, tokenIn), {
 			poolAddr,
@@ -159,16 +165,10 @@ var PoolService = class extends SDKConstruct {
 		});
 		const { zapper } = this.getWithdrawalMetadata(poolAddr, tokenIn, tokenOut);
 		return {
-			tokenIn: {
-				token: tokenIn,
-				balance: toSharesUp(pool.pool, amount)
-			},
-			tokenOut: {
-				token: tokenOut,
-				balance: amount
-			},
+			tokenIn: toTokenAmount(tokenIn, pool.pool.underlyingToShares(amount * PERCENTAGE_FACTOR / (PERCENTAGE_FACTOR - pool.pool.withdrawFee), true)),
+			tokenOut: toTokenAmount(tokenOut, amount),
 			zapper: zapper?.baseParams.addr,
-			availableLiquidity: pool.pool.availableLiquidity * LIQUIDITY_SAFETY_NUM / LIQUIDITY_SAFETY_DENOM
+			availableLiquidity: payoutCeiling(market)
 		};
 	}
 	/**
@@ -176,7 +176,9 @@ var PoolService = class extends SDKConstruct {
 	*/
 	simulateRedeem(props) {
 		const { pool: poolAddr, amount } = props;
-		const { pool } = this.sdk.marketRegister.findByPool(poolAddr);
+		const market = this.sdk.marketRegister.findByPool(poolAddr);
+		const { pool } = market;
+		const { toTokenAmount } = market.priceOracle;
 		const tokenIn = props.tokenIn ?? poolAddr;
 		const tokenOut = this.#resolveTokenOut(props.tokenOut, () => this.getWithdrawalTokensOut(poolAddr, tokenIn), {
 			poolAddr,
@@ -185,16 +187,10 @@ var PoolService = class extends SDKConstruct {
 		});
 		const { zapper } = this.getWithdrawalMetadata(poolAddr, tokenIn, tokenOut);
 		return {
-			tokenIn: {
-				token: tokenIn,
-				balance: amount
-			},
-			tokenOut: {
-				token: tokenOut,
-				balance: toAssets(pool.pool, amount)
-			},
+			tokenIn: toTokenAmount(tokenIn, amount),
+			tokenOut: toTokenAmount(tokenOut, pool.pool.sharesToUnderlying(amount) * (PERCENTAGE_FACTOR - pool.pool.withdrawFee) / PERCENTAGE_FACTOR),
 			zapper: zapper?.baseParams.addr,
-			availableLiquidity: pool.pool.availableLiquidity * LIQUIDITY_SAFETY_NUM / LIQUIDITY_SAFETY_DENOM
+			availableLiquidity: payoutCeiling(market)
 		};
 	}
 	/**
@@ -224,7 +220,7 @@ var PoolService = class extends SDKConstruct {
 		}
 		const poolContract = this.sdk.marketRegister.findByPool(pool).pool.pool;
 		if (meta.zapper instanceof IETHZapperContract || meta.zapper instanceof IERC20ZapperContract) {
-			const shares = mode === "withdraw" ? toSharesUp(poolContract, amount) : amount;
+			const shares = mode === "withdraw" ? poolContract.underlyingToShares(amount * PERCENTAGE_FACTOR / (PERCENTAGE_FACTOR - poolContract.withdrawFee), true) : amount;
 			const tx = permit ? meta.zapper.redeemWithPermit(shares, wallet, permit.deadline, permit.v, permit.r, permit.s) : meta.zapper.redeem(shares, wallet);
 			return {
 				tx,
@@ -418,43 +414,10 @@ var PoolService = class extends SDKConstruct {
 			chainId: this.chainId,
 			pool: pool.address,
 			underlyingToken: market.underlyingToken,
-			netValue: {
-				token: this.sdk.tokensMeta.mustGetToken(market.unwrappedUnderlying),
-				...market.priceOracle.toAmount(market.underlying, shares * pool.dieselRate / RAY)
-			},
+			netValue: market.toUnderlyingAmount(pool.sharesToUnderlying(shares)),
 			apy: { organicApy: rayToBps(pool.supplyRate) }
 		};
 	}
 };
-/**
-* 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, toShares, toSharesUp };
+export { PoolService };

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

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

package/dist/esm/onchain/positions/MultichainPositionsService.js

@@ -22,6 +22,21 @@ var MultichainPositionsService = class extends MultichainConstruct {
 			})
 		});
 	}
+	/**
+	* Delayed withdrawals of one credit account, see
+	* {@link PositionsService.getCurrentWithdrawals}.
+	**/
+	async getCurrentWithdrawals(props) {
+		return this.queryChain({
+			network: props.chainId,
+			block: props.blockNumber ?? "latest",
+			run: (sdk, block) => sdk.positions.getCurrentWithdrawals({
+				creditAccount: props.creditAccount,
+				creditManager: props.creditManager,
+				blockNumber: block.blockNumber
+			})
+		});
+	}
 };
 //#endregion
 export { MultichainPositionsService };

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

@@ -1,19 +1,18 @@
 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 { bpsToRay, 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 { STRATEGY_POSITION_COLLATERAL_ERROR, matchesPositionFilter } from "../../model/positions.js";
 import "../../model/index.js";
+import { collateralPriceInUnderlying } from "../market/oracle/collateralPriceInUnderlying.js";
 import { borrowRateAtUtilization, utilizationAfterLiquidityChange } from "../market/pool/math.js";
 import { calcBorrowRate } from "./calcBorrowRate.js";
 import { calcHealthFactor } from "./calcHealthFactor.js";
-import { calcLiquidationPrice } from "./calcLiquidationPrice.js";
+import { calcLiquidationPrice, soleNonUnderlyingCollateral } from "./calcLiquidationPrice.js";
 import { calcTimeToLiquidationMs } from "./calcTimeToLiquidationMs.js";
 import { accountSnapshotFromCreditAccountData } from "./types.js";
 //#region src/onchain/positions/PositionsService.ts
@@ -63,12 +62,23 @@ var PositionsService = class extends SDKConstruct {
 	**/
 	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()));
+		const accounts = await this.sdk.accounts.getBorrowerCreditAccounts(owner, { includeZeroDebt }, blockNumber);
+		const withdrawals = await Promise.all(accounts.map((ca) => this.#accountWithdrawals(ca, blockNumber)));
+		return accounts.map((ca, i) => this.#toStrategyPosition(ca, withdrawals[i] ?? new AddressMap()));
+	}
+	/**
+	* Returns delayed withdrawals of a strategy position
+	**/
+	async getCurrentWithdrawals(props) {
+		const { creditAccount, creditManager, blockNumber } = props;
+		const empty = {
+			claimable: [],
+			pending: []
+		};
+		const compressor = this.sdk.withdrawalCompressor;
+		if (!compressor?.getWithdrawableAssets(creditManager).length) return empty;
+		const { priceOracle } = this.sdk.marketRegister.findByCreditManager(creditManager);
+		return this.#toPositionWithdrawals(await compressor.getCurrentWithdrawals(creditAccount, blockNumber), priceOracle);
 	}
 	/**
 	* Health factor of an account state, in basis points (`10000` = 1.0).
@@ -166,6 +176,98 @@ var PositionsService = class extends SDKConstruct {
 		});
 	}
 	/**
+	* What the collateral {@link liquidationPrice} is quoted for costs in the
+	* market underlying right now, in the same `PRICE_DECIMALS` fixed point —
+	* the pair a form shows beside the liquidation price. `null` under exactly
+	* the conditions that leave the liquidation price `null`, plus an oracle
+	* that cannot answer for either side.
+	**/
+	currentPrice(snapshot) {
+		const market = this.sdk.marketRegister.findByCreditManager(snapshot.creditManager);
+		const underlying = market.pool.underlying;
+		const collateral = soleNonUnderlyingCollateral(snapshot, underlying);
+		if (!collateral) return null;
+		return collateralPriceInUnderlying(market.priceOracle, collateral, underlying);
+	}
+	/**
+	* Every derived number of an account state at once — the whole
+	* {@link AccountMetrics} half of a projection.
+	*
+	* This is what both halves of the SDK fill their answers from: `prepare`, for
+	* a state it walked an intent into, and `preview`, for one it replayed out of
+	* calldata. One snapshot in, one set of metrics out, so the two descriptions
+	* of the same operation cannot disagree because one of them grew its own
+	* formula.
+	*
+	* Identical to the four methods above field for field, and cheaper than
+	* calling them one by one: the market data is collected once, and the health
+	* factor and borrow rate the time to liquidation decays at are the very ones
+	* reported beside it.
+	**/
+	metrics(snapshot, options) {
+		const data = this.#marketData(snapshot);
+		const factor = (safePrices) => calcHealthFactor({
+			snapshot,
+			underlying: data.underlying,
+			decimals: data.decimals,
+			prices: data.prices,
+			reservePrices: data.reservePrices,
+			safePrices,
+			liquidationThresholds: data.liquidationThresholds,
+			activeQuotas: data.activeQuotas
+		});
+		const healthFactor = factor(false);
+		const borrowRate = calcBorrowRate({
+			snapshot,
+			baseInterestRate: this.#baseInterestRate(snapshot, data, options),
+			feeInterest: data.feeInterest,
+			quotaRates: data.quotaRates,
+			resolveToken: (address) => this.sdk.tokensMeta.mustGetToken(address)
+		});
+		return {
+			healthFactor,
+			safeHealthFactor: factor(true),
+			borrowRate,
+			timeToLiquidation: calcTimeToLiquidationMs(healthFactor, BigInt(borrowRate.totalOnDebt)),
+			liquidationPrice: calcLiquidationPrice({
+				snapshot,
+				underlying: data.underlying,
+				decimals: data.decimals,
+				liquidationThresholds: data.liquidationThresholds
+			}),
+			leverage: calcPositionLeverage(snapshot.totalValue, snapshot.totalDebt)
+		};
+	}
+	/**
+	* A projected account state as both halves of the SDK report it: the holdings
+	* priced and named, and the metrics of {@link PositionsService.metrics}.
+	*
+	* The snapshot is taken at its word — what it lists is what comes back, so a
+	* caller that drops dust before the walk reports an account without it, and
+	* one that keeps wei reports them. That is the whole of the policy left to
+	* the caller; everything downstream of the balances is decided here.
+	*
+	* @param options - The operation's effect on the pool, for the rate the
+	* metrics are quoted at, see {@link ProjectedPoolOptions}.
+	**/
+	projection(snapshot, options) {
+		const { creditManager, totalValue, totalDebt } = snapshot;
+		const market = this.sdk.marketRegister.findByCreditManager(creditManager);
+		const { priceOracle } = market;
+		return {
+			...this.sdk.marketRegister.findCreditManager(creditManager).creditOperationMarket(),
+			totalValue: market.toUnderlyingAmount(totalValue),
+			totalDebt: market.toUnderlyingAmount(totalDebt),
+			netValue: market.toUnderlyingAmount(totalValue - totalDebt),
+			assets: snapshot.assets.map((a) => priceOracle.toTokenAmount(a.token, a.balance)),
+			quotas: snapshot.quotas.map((q) => ({
+				token: this.sdk.tokensMeta.mustGetToken(q.token),
+				...priceOracle.toAmount(market.underlying, q.balance)
+			})),
+			...this.metrics(snapshot, options)
+		};
+	}
+	/**
 	* Builds one strategy position from an account snapshot.
 	*
 	* @param withdrawals - Delayed withdrawals of the account, keyed by the
@@ -176,17 +278,13 @@ var PositionsService = class extends SDKConstruct {
 		const { market } = suite;
 		const { priceOracle } = market;
 		const { pool } = market.pool;
-		const token = market.underlyingToken;
+		const token = suite.underlyingToken;
 		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);
-		const zeroDebt = ca.debt === 0n;
+		const priceFailed = !ca.success;
+		const recomputeTotals = ca.debt === 0n || priceFailed;
 		const collaterals = [];
-		let totalValue = zeroDebt ? 0n : ca.totalValue;
-		let totalValueUSD = zeroDebt ? 0n : ca.totalValueUSD;
+		let totalValue = recomputeTotals ? 0n : ca.totalValue;
+		let totalValueUSD = recomputeTotals ? 0n : ca.totalValueUSD;
 		for (const t of ca.tokens) {
 			if (t.balance <= 10n) continue;
 			collaterals.push({
@@ -194,38 +292,47 @@ var PositionsService = class extends SDKConstruct {
 				quota: priceOracle.toTokenAmount(market.underlying, t.quota),
 				withdrawals: withdrawals.get(t.token) ?? []
 			});
-			if (zeroDebt) {
-				const value = priceOracle.safeConvert(t.token, market.underlying, t.balance) || 0n;
-				totalValue += value;
-				const usd = priceOracle.safeConvertToUSD(t.token, t.balance) || 0n;
-				totalValueUSD += usd;
-			}
+			if (recomputeTotals) totalValueUSD += priceOracle.safeConvertToUSD(t.token, t.balance).value;
 		}
+		if (recomputeTotals) totalValue = priceOracle.safeConvertAssets(ca.tokens.map((t) => ({
+			token: t.token,
+			balance: t.balance
+		})), market.underlying).value;
+		const snapshot = {
+			...accountSnapshotFromCreditAccountData(ca),
+			totalValue
+		};
+		const borrowRate = this.borrowRate(snapshot);
+		const timeToLiquidation = this.timeToLiquidation(snapshot);
+		const liquidationPrice = this.liquidationPrice(snapshot);
+		let totalDebtUSD = ca.totalDebtUSD;
+		if (priceFailed) totalDebtUSD = priceOracle.safeConvertToUSD(market.underlying, totalDebtValue).value;
 		return {
 			kind: "strategy",
 			chainId: this.sdk.chainId,
 			creditManager: ca.creditManager,
 			creditAccount: ca.creditAccount,
 			underlyingToken: token,
-			name: target ? strategyName(this.sdk.tokensMeta.mustGetToken(target), token) : token.symbol,
-			targetCollateral: target ? this.sdk.tokensMeta.mustGetToken(target) : null,
+			name: suite.accountStrategyName(ca.creditAccount),
+			targetCollateral: suite.accountTargetCollateral(ca.creditAccount),
 			leverage: calcPositionLeverage(totalValue, totalDebtValue),
 			borrowApy: calcBorrowApy(pool.baseInterestRate, suite.creditManager.feeInterest),
 			totalDebt: {
 				token,
 				value: totalDebtValue,
-				valueUsd: usdToNumber(ca.totalDebtUSD)
+				valueUsd: usdToNumber(totalDebtUSD)
 			},
 			totalValue: {
 				token,
 				value: totalValue,
 				valueUsd: usdToNumber(totalValueUSD)
 			},
-			healthFactor: healthFactorBps(ca.healthFactor),
+			healthFactor: priceFailed ? this.healthFactor(snapshot) : healthFactorBps(ca.healthFactor),
 			borrowRate,
 			timeToLiquidation,
 			liquidationPrice,
-			collaterals
+			collaterals,
+			...priceFailed ? { error: STRATEGY_POSITION_COLLATERAL_ERROR } : {}
 		};
 	}
 	/**
@@ -253,6 +360,53 @@ var PositionsService = class extends SDKConstruct {
 		return byPhantomToken;
 	}
 	/**
+	* Maps compressor withdrawals into the read model's vocabulary.
+	**/
+	#toPositionWithdrawals(raw, priceOracle) {
+		return {
+			claimable: raw.claimable.map((w) => this.#toPositionClaimableWithdrawal(w, priceOracle)),
+			pending: raw.pending.map((w) => this.#toPositionPendingWithdrawal(w, priceOracle))
+		};
+	}
+	#toPositionClaimableWithdrawal(w, priceOracle) {
+		return {
+			sourceToken: this.sdk.tokensMeta.mustGetToken(w.token),
+			withdrawalPhantomToken: priceOracle.toTokenAmount(w.withdrawalPhantomToken, w.withdrawalTokenSpent),
+			outputs: w.outputs.map((o) => ({
+				...priceOracle.toTokenAmount(o.token, o.amount),
+				isDelayed: o.isDelayed
+			})),
+			claimCall: this.#claimTx(w.claimCalls, w.token),
+			redeemer: w.redeemer,
+			intent: w.intent
+		};
+	}
+	#toPositionPendingWithdrawal(w, priceOracle) {
+		return {
+			sourceToken: this.sdk.tokensMeta.mustGetToken(w.token),
+			withdrawalPhantomToken: this.sdk.tokensMeta.mustGetToken(w.withdrawalPhantomToken),
+			expectedOutputs: w.expectedOutputs.map((o) => ({
+				...priceOracle.toTokenAmount(o.token, o.amount),
+				isDelayed: o.isDelayed
+			})),
+			claimableAt: Number(w.claimableAt),
+			redeemer: w.redeemer,
+			intent: w.intent
+		};
+	}
+	/**
+	* Subcompressors always report exactly one adapter call per claimable
+	* withdrawal.
+	**/
+	#claimTx(claimCalls, sourceToken) {
+		const call = claimCalls[0];
+		if (claimCalls.length !== 1 || !call) throw new Error(`expected exactly one claim call for withdrawal of ${sourceToken}, got ${claimCalls.length}`);
+		return {
+			to: call.target,
+			callData: call.callData
+		};
+	}
+	/**
 	* Collects decimals, prices and thresholds for the snapshot's tokens plus
 	* the market underlying, even when the account holds no underlying balance.
 	**/

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

@@ -23,10 +23,11 @@ function calcHealthFactor(props) {
 	const active = new AddressMap(Object.entries(activeQuotas));
 	const priceOf = (token, forCollateral) => {
 		const main = pricesByToken.get(token);
-		if (!safePrices || !forCollateral) return main;
+		if (!safePrices || !forCollateral || isAddressEqual(token, underlying)) return main;
+		if (main === void 0) return;
 		const reserve = reservePricesByToken.get(token);
-		if (main !== void 0 && reserve !== void 0) return BigIntMath.min(main, reserve);
-		return main ?? reserve;
+		if (reserve === void 0) return 0n;
+		return BigIntMath.min(main, reserve);
 	};
 	const convertToUSD = (token, amount, forCollateral = false) => {
 		const price = priceOf(token, forCollateral);

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

@@ -10,13 +10,22 @@ import { isAddressEqual } from "viem";
 * 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;
+	const targetToken = soleNonUnderlyingCollateral(props.snapshot, props.underlying);
+	if (!targetToken) return null;
 	return calcLiquidationPriceForTarget({
 		...props,
-		targetToken: targets[0].token
+		targetToken
 	});
 }
+/**
+* The one collateral a liquidation price — and the current price beside it —
+* can be quoted for: the account's single non-dust, non-underlying asset.
+* `null` when it holds none or several, which is the case neither figure
+* exists for.
+**/
+function soleNonUnderlyingCollateral(snapshot, underlying) {
+	const targets = snapshot.assets.filter((a) => a.balance > 10n && !isAddressEqual(a.token, underlying));
+	return targets.length === 1 ? targets[0].token : null;
+}
 //#endregion
-export { calcLiquidationPrice };
+export { calcLiquidationPrice, soleNonUnderlyingCollateral };

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

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

package/dist/esm/onchain/router/AbstractRouterContract.js

@@ -85,7 +85,7 @@ var AbstractRouterContract = class extends BaseContract {
 			leftoverBalances.upsert(token, limitLeftover(balance, token) ?? balance);
 			if (isEnabled && !keepAssets.has(token)) usdBalances.push({
 				token,
-				balance: this.safeConvertToUSD(priceOracle, token, balance)
+				balance: priceOracle.safeConvertToUSD(token, balance).value
 			});
 		}
 		usdBalances.sort((a, b) => {
@@ -98,7 +98,7 @@ var AbstractRouterContract = class extends BaseContract {
 		const lt = this.sdk.marketRegister.findCreditManager(ca.creditManager).creditManager.liquidationThresholds.mustGet(highestToken.token);
 		const requiredDebtUSD = ca.totalDebtUSD * PERCENTAGE_FACTOR / BigInt(lt);
 		if (highestToken.balance < requiredDebtUSD) return;
-		const tokenAmount = this.safeConvertFromUSD(priceOracle, highestToken.token, requiredDebtUSD);
+		const tokenAmount = priceOracle.safeConvertFromUSD(highestToken.token, requiredDebtUSD).value;
 		if (tokenAmount === 0n) return;
 		let leftoverBalance = leftoverBalances.get(highestToken.token) ?? 0n;
 		leftoverBalance -= tokenAmount;
@@ -113,28 +113,6 @@ var AbstractRouterContract = class extends BaseContract {
 			tokensToClaim: new AssetsMap()
 		};
 	}
-	safeConvertToUSD(priceOracle, token, balance) {
-		try {
-			return priceOracle.convertToUSD(token, balance);
-		} catch {
-			try {
-				return priceOracle.convertToUSD(token, balance, true);
-			} catch {
-				return 0n;
-			}
-		}
-	}
-	safeConvertFromUSD(priceOracle, token, balance) {
-		try {
-			return priceOracle.convertFromUSD(token, balance);
-		} catch {
-			try {
-				return priceOracle.convertFromUSD(token, balance, true);
-			} catch {
-				return 0n;
-			}
-		}
-	}
 };
 //#endregion
 export { AbstractRouterContract };

package/dist/esm/onchain/router/RouterV310Contract.js

@@ -227,7 +227,7 @@ var RouterV310Contract = class extends AbstractRouterContract {
 		}).map(({ token, balance }) => {
 			return {
 				token,
-				balance: this.#convertToUSDForSort(priceOracle, token, balance)
+				balance: priceOracle.safeConvertToUSD(token, balance).value
 			};
 		}).sort((a, b) => {
 			return a.balance > b.balance ? -1 : 1;
@@ -240,17 +240,6 @@ var RouterV310Contract = class extends AbstractRouterContract {
 		for (const [token, numSplits] of this.#numSplits.entries()) map.upsert(token, numSplits);
 		return (token) => map.get(token) ?? 1n;
 	}
-	/**
-	* Tries to get some value even when prices are broken, since it's only needed for sorting
-	* @param oracle
-	* @param token
-	* @param amount
-	* @returns
-	*/
-	#convertToUSDForSort(oracle, token, amount) {
-		const scale = 10n ** BigInt(this.tokensMeta.get(token)?.decimals ?? 0);
-		return amount * (oracle.mainPrices.get(token)?.price || oracle.reservePrices.get(token)?.price || scale) / scale;
-	}
 	#debugTokenData(tData) {
 		return tData.map((t) => ({
 			token: this.labelAddress(t.token),

package/dist/esm/onchain/utils/index.js

@@ -15,6 +15,7 @@ import { fmtBinaryMask, formatBN, formatBNvalue, formatDuration, formatLeverage,
 import { hexEq } from "./hex.js";
 import { retry } from "./retry.js";
 import { toAddress } from "./toAddress.js";
+import { EXECUTE_BYTES_SELECTOR, collectTraces, findCallTo, findCallWithInput, findExecuteBytes, resolveProtocolCall } from "./trace.js";
 import "./type-utils.js";
 import { ZodAddress, ZodBigInt, ZodHex } from "./zod.js";
-export { AddressMap, AddressSet, AssetsMap, BigIntMath, TypedObjectUtils, ZodAddress, ZodBigInt, ZodHex, bytes32ToString, childLogger, createRawTx, etherscanApiUrl, etherscanUrl, filterDust, filterDustUSD, fmtBinaryMask, formatBN, formatBNvalue, formatDuration, formatLeverage, formatNumberToString_, formatPercentage, formatTimestamp, functionArgsToMap, functionArgsToRecord, getFunctionSignature, hexEq, isDust, json_parse, json_stringify, numberWithCommas, percentFmt, rayToNumber, retry, shortAddress, shortHash, toAddress, toBN, toBigInt, toSignificant };
+export { AddressMap, AddressSet, AssetsMap, BigIntMath, EXECUTE_BYTES_SELECTOR, TypedObjectUtils, ZodAddress, ZodBigInt, ZodHex, bytes32ToString, childLogger, collectTraces, createRawTx, etherscanApiUrl, etherscanUrl, filterDust, filterDustUSD, findCallTo, findCallWithInput, findExecuteBytes, fmtBinaryMask, formatBN, formatBNvalue, formatDuration, formatLeverage, formatNumberToString_, formatPercentage, formatTimestamp, functionArgsToMap, functionArgsToRecord, getFunctionSignature, hexEq, isDust, json_parse, json_stringify, numberWithCommas, percentFmt, rayToNumber, resolveProtocolCall, retry, shortAddress, shortHash, toAddress, toBN, toBigInt, toSignificant };

package/dist/esm/{common-utils → onchain}/utils/trace.js

@@ -1,5 +1,5 @@
 import { decodeAbiParameters, getAddress, isAddressEqual } from "viem";
-//#region src/common-utils/utils/trace.ts
+//#region src/onchain/utils/trace.ts
 /**
 * Selector of `CreditManagerV3.execute(bytes)` (`0x09c5eabe`).
 *