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

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

@@ -51,6 +51,31 @@ var PoolV310Contract = class extends require_onchain_base_BaseContract.BaseContr
 		return this.totalSupply * this.dieselRate / require_onchain_constants_math.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 / require_onchain_constants_math.RAY;
+	}
+	/**
+	* {@inheritDoc IPoolContract.underlyingToShares}
+	*/
+	underlyingToShares(underlying, roundUp = false) {
+		if (this.dieselRate === 0n) return underlying;
+		return roundUp ? (underlying * require_onchain_constants_math.RAY + this.dieselRate - 1n) / this.dieselRate : underlying * require_onchain_constants_math.RAY / this.dieselRate;
+	}
+	/**
 	* {@inheritDoc IPoolContract.unwrappedUnderlying}
 	*/
 	get unwrappedUnderlying() {

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

@@ -149,9 +149,10 @@ var SecuritizeRWAFactory = class extends require_onchain_base_BaseContract.BaseC
 	/**
 	* {@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/cjs/onchain/market/zapper/ZapperContract.js

@@ -2,7 +2,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_abi_iZapper = require("../../../abi/iZapper.js");
 const require_onchain_base_BaseContract = require("../../base/BaseContract.js");
 require("../../base/index.js");
-const require_onchain_market_zapper_errors = require("./errors.js");
+const require_model_result = require("../../../model/result.js");
+require("../../../model/index.js");
 //#region src/onchain/market/zapper/ZapperContract.ts
 /**
 * Base contract for every Gearbox zapper. Specialized zappers (e.g.
@@ -33,8 +34,9 @@ var ZapperContract = class extends require_onchain_base_BaseContract.BaseContrac
 		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);
@@ -43,7 +45,7 @@ var ZapperContract = class extends require_onchain_base_BaseContract.BaseContrac
 		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 require_model_result.sdkOk({
 			operation: "Deposit",
 			pool,
 			zapper,
@@ -51,16 +53,21 @@ var ZapperContract = class extends require_onchain_base_BaseContract.BaseContrac
 			assets: rawArgs.tokenInAmount ?? value ?? 0n,
 			underlying,
 			referralCode: rawArgs.referralCode
-		};
-		if (parsed.functionName.startsWith("redeem")) return {
+		});
+		if (parsed.functionName.startsWith("redeem")) return require_model_result.sdkOk({
 			operation: "Redeem",
 			pool,
 			zapper,
 			receiver,
 			shares: rawArgs.tokenOutAmount,
 			underlying
-		};
-		throw new require_onchain_market_zapper_errors.UnsupportedZapperFunctionError(zapper, parsed.functionName);
+		});
+		return require_model_result.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/cjs/onchain/market/zapper/errors.js

@@ -1,18 +1 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-//#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
-exports.UnsupportedZapperFunctionError = UnsupportedZapperFunctionError;

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

@@ -1,12 +1,11 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_onchain_market_zapper_errors = require("./errors.js");
 const require_onchain_market_zapper_ZapperContract = require("./ZapperContract.js");
 const require_onchain_market_zapper_IERC20ZapperContract = require("./IERC20ZapperContract.js");
 const require_onchain_market_zapper_IETHZapperContract = require("./IETHZapperContract.js");
 const require_onchain_market_zapper_createZapper = require("./createZapper.js");
+require("./errors.js");
 require("./types.js");
 exports.IERC20ZapperContract = require_onchain_market_zapper_IERC20ZapperContract.IERC20ZapperContract;
 exports.IETHZapperContract = require_onchain_market_zapper_IETHZapperContract.IETHZapperContract;
-exports.UnsupportedZapperFunctionError = require_onchain_market_zapper_errors.UnsupportedZapperFunctionError;
 exports.ZapperContract = require_onchain_market_zapper_ZapperContract.ZapperContract;
 exports.createZapper = require_onchain_market_zapper_createZapper.createZapper;

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

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_onchain_opportunities_MultichainOpportunitiesService = require("./MultichainOpportunitiesService.js");
 const require_onchain_opportunities_OpportunitiesService = require("./OpportunitiesService.js");
+require("./types.js");
 exports.MultichainOpportunitiesService = require_onchain_opportunities_MultichainOpportunitiesService.MultichainOpportunitiesService;
 exports.OpportunitiesService = require_onchain_opportunities_OpportunitiesService.OpportunitiesService;

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

@@ -21,6 +21,14 @@ require("../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 require_onchain_base_SDKConstruct.SDKConstruct {
 	/**
 	* {@inheritDoc IPoolsService.getDepositTokensIn}
@@ -126,7 +134,9 @@ var PoolService = class extends require_onchain_base_SDKConstruct.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,
@@ -135,14 +145,8 @@ var PoolService = class extends require_onchain_base_SDKConstruct.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
 		};
 	}
@@ -151,7 +155,9 @@ var PoolService = class extends require_onchain_base_SDKConstruct.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,
@@ -160,16 +166,10 @@ var PoolService = class extends require_onchain_base_SDKConstruct.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 * require_onchain_constants_math.PERCENTAGE_FACTOR / (require_onchain_constants_math.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)
 		};
 	}
 	/**
@@ -177,7 +177,9 @@ var PoolService = class extends require_onchain_base_SDKConstruct.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,
@@ -186,16 +188,10 @@ var PoolService = class extends require_onchain_base_SDKConstruct.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) * (require_onchain_constants_math.PERCENTAGE_FACTOR - pool.pool.withdrawFee) / require_onchain_constants_math.PERCENTAGE_FACTOR),
 			zapper: zapper?.baseParams.addr,
-			availableLiquidity: pool.pool.availableLiquidity * LIQUIDITY_SAFETY_NUM / LIQUIDITY_SAFETY_DENOM
+			availableLiquidity: payoutCeiling(market)
 		};
 	}
 	/**
@@ -225,7 +221,7 @@ var PoolService = class extends require_onchain_base_SDKConstruct.SDKConstruct {
 		}
 		const poolContract = this.sdk.marketRegister.findByPool(pool).pool.pool;
 		if (meta.zapper instanceof require_onchain_market_zapper_IETHZapperContract.IETHZapperContract || meta.zapper instanceof require_onchain_market_zapper_IERC20ZapperContract.IERC20ZapperContract) {
-			const shares = mode === "withdraw" ? toSharesUp(poolContract, amount) : amount;
+			const shares = mode === "withdraw" ? poolContract.underlyingToShares(amount * require_onchain_constants_math.PERCENTAGE_FACTOR / (require_onchain_constants_math.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,
@@ -419,45 +415,10 @@ var PoolService = class extends require_onchain_base_SDKConstruct.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 / require_onchain_constants_math.RAY)
-			},
+			netValue: market.toUnderlyingAmount(pool.sharesToUnderlying(shares)),
 			apy: { organicApy: require_onchain_market_math.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 * require_onchain_constants_math.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 * require_onchain_constants_math.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 / require_onchain_constants_math.RAY) * (require_onchain_constants_math.PERCENTAGE_FACTOR - withdrawFee) / require_onchain_constants_math.PERCENTAGE_FACTOR;
-}
 //#endregion
 exports.PoolService = PoolService;
-exports.toShares = toShares;
-exports.toSharesUp = toSharesUp;

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

@@ -2,5 +2,3 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_onchain_pools_PoolService = require("./PoolService.js");
 require("./types.js");
 exports.PoolService = require_onchain_pools_PoolService.PoolService;
-exports.toShares = require_onchain_pools_PoolService.toShares;
-exports.toSharesUp = require_onchain_pools_PoolService.toSharesUp;

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

@@ -23,6 +23,21 @@ var MultichainPositionsService = class extends require_onchain_base_MultichainCo
 			})
 		});
 	}
+	/**
+	* 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
 exports.MultichainPositionsService = MultichainPositionsService;

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

@@ -1,16 +1,15 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_onchain_utils_AddressMap = require("../utils/AddressMap.js");
-const require_onchain_chain_chains = require("../chain/chains.js");
 require("../constants/math.js");
 require("../constants/index.js");
 require("../utils/index.js");
 const require_onchain_base_SDKConstruct = require("../base/SDKConstruct.js");
 require("../base/index.js");
 const require_onchain_market_math = require("../market/math.js");
-const require_onchain_market_strategyName = require("../market/strategyName.js");
 const require_model_filters = require("../../model/filters.js");
 const require_model_positions = require("../../model/positions.js");
 require("../../model/index.js");
+const require_onchain_market_oracle_collateralPriceInUnderlying = require("../market/oracle/collateralPriceInUnderlying.js");
 const require_onchain_market_pool_math = require("../market/pool/math.js");
 const require_onchain_positions_calcBorrowRate = require("./calcBorrowRate.js");
 const require_onchain_positions_calcHealthFactor = require("./calcHealthFactor.js");
@@ -64,12 +63,23 @@ var PositionsService = class extends require_onchain_base_SDKConstruct.SDKConstr
 	**/
 	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_onchain_utils_AddressMap.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 require_onchain_utils_AddressMap.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).
@@ -167,6 +177,98 @@ var PositionsService = class extends require_onchain_base_SDKConstruct.SDKConstr
 		});
 	}
 	/**
+	* 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 = require_onchain_positions_calcLiquidationPrice.soleNonUnderlyingCollateral(snapshot, underlying);
+		if (!collateral) return null;
+		return require_onchain_market_oracle_collateralPriceInUnderlying.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) => require_onchain_positions_calcHealthFactor.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 = require_onchain_positions_calcBorrowRate.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: require_onchain_positions_calcTimeToLiquidationMs.calcTimeToLiquidationMs(healthFactor, BigInt(borrowRate.totalOnDebt)),
+			liquidationPrice: require_onchain_positions_calcLiquidationPrice.calcLiquidationPrice({
+				snapshot,
+				underlying: data.underlying,
+				decimals: data.decimals,
+				liquidationThresholds: data.liquidationThresholds
+			}),
+			leverage: require_onchain_market_math.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
@@ -177,17 +279,13 @@ var PositionsService = class extends require_onchain_base_SDKConstruct.SDKConstr
 		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 = require_onchain_chain_chains.getAccountTargetCollateral(ca.creditAccount, this.sdk.chainId) ?? suite.strategyTargetCollateral;
-		const snapshot = require_onchain_positions_types.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({
@@ -195,38 +293,47 @@ var PositionsService = class extends require_onchain_base_SDKConstruct.SDKConstr
 				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 = {
+			...require_onchain_positions_types.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 ? require_onchain_market_strategyName.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: require_onchain_market_math.calcPositionLeverage(totalValue, totalDebtValue),
 			borrowApy: require_onchain_market_math.calcBorrowApy(pool.baseInterestRate, suite.creditManager.feeInterest),
 			totalDebt: {
 				token,
 				value: totalDebtValue,
-				valueUsd: require_onchain_market_math.usdToNumber(ca.totalDebtUSD)
+				valueUsd: require_onchain_market_math.usdToNumber(totalDebtUSD)
 			},
 			totalValue: {
 				token,
 				value: totalValue,
 				valueUsd: require_onchain_market_math.usdToNumber(totalValueUSD)
 			},
-			healthFactor: require_onchain_market_math.healthFactorBps(ca.healthFactor),
+			healthFactor: priceFailed ? this.healthFactor(snapshot) : require_onchain_market_math.healthFactorBps(ca.healthFactor),
 			borrowRate,
 			timeToLiquidation,
 			liquidationPrice,
-			collaterals
+			collaterals,
+			...priceFailed ? { error: require_model_positions.STRATEGY_POSITION_COLLATERAL_ERROR } : {}
 		};
 	}
 	/**
@@ -254,6 +361,53 @@ var PositionsService = class extends require_onchain_base_SDKConstruct.SDKConstr
 		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/cjs/onchain/positions/calcHealthFactor.js

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

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

@@ -11,13 +11,23 @@ let viem = require("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 && !(0, viem.isAddressEqual)(a.token, underlying));
-	if (targets.length !== 1) return null;
+	const targetToken = soleNonUnderlyingCollateral(props.snapshot, props.underlying);
+	if (!targetToken) return null;
 	return require_onchain_positions_calcLiquidationPriceForTarget.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 && !(0, viem.isAddressEqual)(a.token, underlying));
+	return targets.length === 1 ? targets[0].token : null;
+}
 //#endregion
 exports.calcLiquidationPrice = calcLiquidationPrice;
+exports.soleNonUnderlyingCollateral = soleNonUnderlyingCollateral;

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

@@ -15,3 +15,4 @@ exports.calcHealthFactor = require_onchain_positions_calcHealthFactor.calcHealth
 exports.calcLiquidationPrice = require_onchain_positions_calcLiquidationPrice.calcLiquidationPrice;
 exports.calcLiquidationPriceForTarget = require_onchain_positions_calcLiquidationPriceForTarget.calcLiquidationPriceForTarget;
 exports.calcTimeToLiquidationMs = require_onchain_positions_calcTimeToLiquidationMs.calcTimeToLiquidationMs;
+exports.soleNonUnderlyingCollateral = require_onchain_positions_calcLiquidationPrice.soleNonUnderlyingCollateral;