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

package/dist/esm/onchain/market/pool/PoolV310Contract.js

@@ -1,4 +1,3 @@
-import { iPausableAbi } from "../../../abi/iPausable.js";
 import { iPoolV310Abi } from "../../../abi/310/generated.js";
 import { AddressMap } from "../../utils/AddressMap.js";
 import { RAY } from "../../constants/math.js";
@@ -8,6 +7,7 @@ import "../../utils/index.js";
 import { SdkRWADataNotLoadedError } from "../../core/errors.js";
 import { BaseContract } from "../../base/BaseContract.js";
 import "../../base/index.js";
+import { iPausableAbi } from "../../../abi/iPausable.js";
 //#region src/onchain/market/pool/PoolV310Contract.ts
 const abi = [...iPoolV310Abi, ...iPausableAbi];
 var PoolV310Contract = class extends BaseContract {
@@ -50,6 +50,31 @@ var PoolV310Contract = class extends BaseContract {
 		return this.totalSupply * this.dieselRate / RAY;
 	}
 	/**
+	* {@inheritDoc IPoolContract.getShareBalance}
+	*/
+	async getShareBalance(wallet, blockNumber) {
+		return this.client.readContract({
+			address: this.address,
+			abi: this.abi,
+			functionName: "balanceOf",
+			args: [wallet],
+			blockNumber
+		});
+	}
+	/**
+	* {@inheritDoc IPoolContract.sharesToUnderlying}
+	*/
+	sharesToUnderlying(shares) {
+		return this.dieselRate === 0n ? shares : shares * this.dieselRate / RAY;
+	}
+	/**
+	* {@inheritDoc IPoolContract.underlyingToShares}
+	*/
+	underlyingToShares(underlying, roundUp = false) {
+		if (this.dieselRate === 0n) return underlying;
+		return roundUp ? (underlying * RAY + this.dieselRate - 1n) / this.dieselRate : underlying * RAY / this.dieselRate;
+	}
+	/**
 	* {@inheritDoc IPoolContract.unwrappedUnderlying}
 	*/
 	get unwrappedUnderlying() {

package/dist/esm/onchain/market/rwa/securitize/SecuritizeRWAFactory.js

@@ -148,9 +148,10 @@ var SecuritizeRWAFactory = class extends BaseContract {
 	/**
 	* {@inheritDoc IRWAFactory.getInvestor}
 	*/
-	async getInvestor(creditAccount, fromCache) {
+	async getInvestor(creditAccount, options) {
+		const { fromCache, blockNumber } = options ?? {};
 		if (fromCache && this.#investorCache.has(creditAccount)) return this.#investorCache.mustGet(creditAccount);
-		const investor = await this.contract.read.getInvestor([creditAccount]);
+		const investor = await this.contract.read.getInvestor([creditAccount], { blockNumber });
 		if (fromCache) this.#investorCache.upsert(creditAccount, investor);
 		return investor;
 	}

package/dist/esm/onchain/market/zapper/IETHZapperContract.js

@@ -1,5 +1,5 @@
-import { iethZapperAbi } from "../../../abi/iETHZapper.js";
 import { ZapperContract } from "./ZapperContract.js";
+import { iethZapperAbi } from "../../../abi/iETHZapper.js";
 //#region src/onchain/market/zapper/IETHZapperContract.ts
 const abi = iethZapperAbi;
 var IETHZapperContract = class extends ZapperContract {

package/dist/esm/onchain/market/zapper/ZapperContract.js

@@ -1,7 +1,8 @@
-import { iZapperAbi } from "../../../abi/iZapper.js";
 import { BaseContract } from "../../base/BaseContract.js";
 import "../../base/index.js";
-import { UnsupportedZapperFunctionError } from "./errors.js";
+import { sdkErr, sdkOk } from "../../../model/result.js";
+import "../../../model/index.js";
+import { iZapperAbi } from "../../../abi/iZapper.js";
 //#region src/onchain/market/zapper/ZapperContract.ts
 /**
 * Base contract for every Gearbox zapper. Specialized zappers (e.g.
@@ -32,8 +33,9 @@ var ZapperContract = class extends BaseContract {
 		this.tokenOut = data.tokenOut;
 	}
 	/**
-	* Decodes zapper calldata into {@link ParsedZapperOperation}.
-	* Throws {@link UnsupportedZapperFunctionError} for unknown selectors.
+	* Decodes zapper calldata into {@link ParsedZapperOperation} behind `ok`,
+	* or refuses with {@link UnsupportedZapperFunctionError} for unknown
+	* selectors.
 	*/
 	parseOperation(calldata, value) {
 		const parsed = this.parseFunctionDataV2(calldata);
@@ -42,7 +44,7 @@ var ZapperContract = class extends BaseContract {
 		const zapper = this.address;
 		const underlying = this.sdk.marketRegister.findByPool(pool).underlying;
 		const receiver = rawArgs.receiver;
-		if (parsed.functionName.startsWith("deposit")) return {
+		if (parsed.functionName.startsWith("deposit")) return sdkOk({
 			operation: "Deposit",
 			pool,
 			zapper,
@@ -50,16 +52,21 @@ var ZapperContract = class extends BaseContract {
 			assets: rawArgs.tokenInAmount ?? value ?? 0n,
 			underlying,
 			referralCode: rawArgs.referralCode
-		};
-		if (parsed.functionName.startsWith("redeem")) return {
+		});
+		if (parsed.functionName.startsWith("redeem")) return sdkOk({
 			operation: "Redeem",
 			pool,
 			zapper,
 			receiver,
 			shares: rawArgs.tokenOutAmount,
 			underlying
-		};
-		throw new UnsupportedZapperFunctionError(zapper, parsed.functionName);
+		});
+		return sdkErr({
+			code: "unsupportedZapperFunction",
+			message: `unsupported zapper function "${parsed.functionName}" on ${zapper}`,
+			zapper,
+			functionName: parsed.functionName
+		});
 	}
 	/**
 	* Redeems pool shares (diesel tokens) for the underlying asset via this zapper.

package/dist/esm/onchain/market/zapper/errors.js

@@ -1,17 +1 @@
-//#region src/onchain/market/zapper/errors.ts
-/**
-* Thrown when a zapper call uses a function other than a known
-* `deposit`/`redeem` variant.
-*/
-var UnsupportedZapperFunctionError = class extends Error {
-	zapper;
-	functionName;
-	constructor(zapper, functionName) {
-		super(`unsupported zapper function "${functionName}" on ${zapper}`);
-		this.name = "UnsupportedZapperFunctionError";
-		this.zapper = zapper;
-		this.functionName = functionName;
-	}
-};
-//#endregion
-export { UnsupportedZapperFunctionError };
+export {};

package/dist/esm/onchain/market/zapper/index.js

@@ -1,7 +1,7 @@
-import { UnsupportedZapperFunctionError } from "./errors.js";
 import { ZapperContract } from "./ZapperContract.js";
 import { IERC20ZapperContract } from "./IERC20ZapperContract.js";
 import { IETHZapperContract } from "./IETHZapperContract.js";
 import { createZapper } from "./createZapper.js";
+import "./errors.js";
 import "./types.js";
-export { IERC20ZapperContract, IETHZapperContract, UnsupportedZapperFunctionError, ZapperContract, createZapper };
+export { IERC20ZapperContract, IETHZapperContract, ZapperContract, createZapper };

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

@@ -1,3 +1,4 @@
 import { MultichainOpportunitiesService } from "./MultichainOpportunitiesService.js";
 import { OpportunitiesService } from "./OpportunitiesService.js";
+import "./types.js";
 export { MultichainOpportunitiesService, OpportunitiesService };

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

@@ -1,7 +1,7 @@
 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);