@gearbox-protocol/sdk 16.0.0-next.51 → 16.0.0-next.52

package/dist/esm/onchain/market/oracle/TestPriceOracle.mock.js

@@ -0,0 +1,213 @@
+import { iPriceOracleV310Abi } from "../../../abi/310/generated.js";
+import { getChain } from "../../chain/chains.js";
+import "../../chain/index.js";
+import "../../constants/address-provider.js";
+import "../../constants/math.js";
+import "../../constants/index.js";
+import { toBN } from "../../utils/formatter.js";
+import "../../utils/index.js";
+import { ChainContractsRegister } from "../../base/ChainContractsRegister.js";
+import "../../base/index.js";
+import { PriceFeedRef } from "../pricefeeds/PriceFeedRef.js";
+import "../pricefeeds/index.js";
+import { PriceOracleBaseContract } from "./PriceOracleBaseContract.js";
+import { bytesToHex, createPublicClient, custom, getAddress, hexToBytes } from "viem";
+//#region src/onchain/market/oracle/TestPriceOracle.mock.ts
+/**
+* Well-known mainnet tokens for tests. The oracle prefills their metadata;
+* a seed can then be as small as `{ price: 2000 }`.
+**/
+const MockTokens = {
+	WETH: getAddress("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2"),
+	USDC: getAddress("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"),
+	DAI: getAddress("0x6B175474E89094C44Da98b954EedeAC495271d0F"),
+	cbETH: getAddress("0xBe9895146f7AF43049ca1c1AE358B0541Ea49704"),
+	dcUSDC: getAddress("0x50A9C808cd114E8fEA72f03aE2B1A8825677D56D"),
+	ACRED: getAddress("0x17418038ecF73BA4026c4f428547BF099706F27B"),
+	srpACRED_USDC: getAddress("0xe4a38b653B2580C9D72a50F190Ddd6E2d2D2a412")
+};
+const MOCK_TOKEN_META = {
+	[MockTokens.WETH]: {
+		decimals: 18,
+		symbol: "WETH",
+		name: "Wrapped Ether"
+	},
+	[MockTokens.USDC]: {
+		decimals: 6,
+		symbol: "USDC",
+		name: "USD Coin"
+	},
+	[MockTokens.DAI]: {
+		decimals: 18,
+		symbol: "DAI",
+		name: "Dai Stablecoin"
+	},
+	[MockTokens.cbETH]: {
+		decimals: 18,
+		symbol: "cbETH",
+		name: "Coinbase Wrapped Staked ETH"
+	},
+	[MockTokens.dcUSDC]: {
+		decimals: 6,
+		symbol: "dcUSDC",
+		name: "Default compliant USD Coin"
+	},
+	[MockTokens.ACRED]: {
+		decimals: 6,
+		symbol: "ACRED",
+		name: "Apollo Diversified Credit Securitize Fund"
+	},
+	[MockTokens.srpACRED_USDC]: {
+		decimals: 6,
+		symbol: "srpACRED_USDC",
+		name: "Securitize pending redemption Apollo Diversified Credit Securitize Fund to USD Coin"
+	}
+};
+const TEST_ORACLE_ADDRESS = getAddress("0x040ac1e000000000000000000000000000000310");
+const FAILED_ANSWER = {
+	price: 0n,
+	success: false,
+	updatedAt: 0n
+};
+/**
+* Register whose client rejects any RPC request: the oracle never talks to a
+* node. `addressProvider.getAddress` answers `AP_WETH_TOKEN` with mainnet WETH
+* so `#priceableToken` and `safeConvertMinUSD` exercise their real native
+* branches.
+**/
+var TestOracleSdk = class extends ChainContractsRegister {
+	addressProvider = { getAddress: (contract, version) => {
+		if (contract === "WETH_TOKEN") return MockTokens.WETH;
+		throw new Error(`Address ${contract}, version: ${version} not found`);
+	} };
+	priceFeeds = { generatePriceFeedsUpdateTxs: () => {
+		throw new Error("TestPriceOracle: no priceFeeds");
+	} };
+};
+/**
+* A real {@link PriceOracleBaseContract} seeded from plain records, for tests.
+*
+* Conversion, safe-price fallback, and native-through-WETH all run the
+* production code. Feed-tree methods (`priceFeedData`, `priceUpdatesFor*`, …)
+* are not wired and throw if touched.
+**/
+var TestPriceOracle = class extends PriceOracleBaseContract {
+	constructor(tokens = {}) {
+		const register = new TestOracleSdk(createPublicClient({
+			chain: getChain("Mainnet"),
+			transport: custom({ request: async () => {
+				throw new Error("not implemented");
+			} })
+		}));
+		super(register, {
+			abi: iPriceOracleV310Abi,
+			addr: TEST_ORACLE_ADDRESS,
+			name: "TestPriceOracle"
+		}, {
+			priceFeedMap: [],
+			priceFeedTree: []
+		});
+		for (const [token, meta] of Object.entries(MOCK_TOKEN_META)) {
+			const addr = getAddress(token);
+			this.register.tokensMeta.upsert(addr, {
+				addr,
+				...meta
+			});
+		}
+		for (const [token, cfg] of Object.entries(tokens)) this.addToken(token, cfg);
+	}
+	/**
+	* Registers token meta and optional feed answers. Chainable, like all
+	* modifiers.
+	**/
+	addToken(token, cfg) {
+		const addr = getAddress(token);
+		const known = MOCK_TOKEN_META[addr];
+		const symbol = cfg.symbol ?? known?.symbol ?? `T_${addr.slice(2, 8)}`;
+		this.register.tokensMeta.upsert(addr, {
+			addr,
+			symbol,
+			name: cfg.name ?? known?.name ?? symbol,
+			decimals: cfg.decimals ?? known?.decimals ?? 18
+		});
+		if (cfg.price !== void 0) this.setMainPrice(addr, cfg.price);
+		if (cfg.reservePrice !== void 0) this.setReservePrice(addr, cfg.reservePrice);
+		return this;
+	}
+	setMainPrice(token, price) {
+		this.#setAnswer(token, "main", rawPrice(price));
+		return this;
+	}
+	setReservePrice(token, price) {
+		this.#setAnswer(token, "reserve", rawPrice(price));
+		return this;
+	}
+	/**
+	* Feed stays configured, its answer failed — {@link PriceFeedAnswerMap.price}
+	* throws. Distinct from {@link removeMainFeed}.
+	**/
+	failMainAnswer(token) {
+		this.#failAnswer(token, "main");
+		return this;
+	}
+	/**
+	* Feed stays configured, its answer failed. Distinct from
+	* {@link removeReserveFeed}: `safeConvertMinUSD` treats a present-but-failed
+	* reserve feed as an error, and a missing one as an untrusted 0.
+	**/
+	failReserveAnswer(token) {
+		this.#failAnswer(token, "reserve");
+		return this;
+	}
+	/**
+	* No main feed at all: distinct from a failed answer.
+	**/
+	removeMainFeed(token) {
+		this.mainPriceFeeds.delete(token);
+		this.mainPrices.delete(token);
+		return this;
+	}
+	/**
+	* No reserve feed at all: distinct from a failed answer, and what
+	* `safeConvertMinUSD` treats as an untrusted token (value 0, no error).
+	**/
+	removeReserveFeed(token) {
+		this.reservePriceFeeds.delete(token);
+		this.reservePrices.delete(token);
+		return this;
+	}
+	async updateAndConvert(_from, _to, _amount) {
+		throw new Error("TestPriceOracle: updateAndConvert needs a node");
+	}
+	#setAnswer(token, kind, price) {
+		this.#ensureFeed(token, kind);
+		this.#answers(kind).upsert(token, {
+			price,
+			success: true,
+			updatedAt: 0n
+		});
+	}
+	#failAnswer(token, kind) {
+		this.#ensureFeed(token, kind);
+		this.#answers(kind).upsert(token, FAILED_ANSWER);
+	}
+	#ensureFeed(token, kind) {
+		const feeds = kind === "main" ? this.mainPriceFeeds : this.reservePriceFeeds;
+		if (!feeds.has(token)) feeds.upsert(token, new PriceFeedRef(this.register, feedAddr(token, kind), 0));
+	}
+	#answers(kind) {
+		return kind === "main" ? this.mainPrices : this.reservePrices;
+	}
+};
+/** Human USD → 8-decimal fixed point; bigint passes through. */
+function rawPrice(price) {
+	return typeof price === "bigint" ? price : toBN(String(price), 8);
+}
+/** Deterministic unused address per token feed; never resolved. */
+function feedAddr(token, kind) {
+	const bytes = hexToBytes(getAddress(token));
+	bytes[0] = kind === "main" ? 254 : 253;
+	return getAddress(bytesToHex(bytes));
+}
+//#endregion
+export { MockTokens, TEST_ORACLE_ADDRESS, TestPriceOracle };

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

@@ -1,6 +1,6 @@
 import { collateralPriceInUnderlying } from "./collateralPriceInUnderlying.js";
+import { unpriceableTokenError } from "./errors.js";
 import { PriceOracleV310Contract } from "./PriceOracleV310Contract.js";
 import { createPriceOracle } from "./createPriceOracle.js";
-import { unpriceableTokenError } from "./errors.js";
 import "./types.js";
 export { PriceOracleV310Contract, collateralPriceInUnderlying, createPriceOracle, unpriceableTokenError };

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

@@ -292,15 +292,12 @@ var PositionsService = class extends SDKConstruct {
 				quota: priceOracle.toTokenAmount(market.underlying, t.quota),
 				withdrawals: withdrawals.get(t.token) ?? []
 			});
-			if (recomputeTotals) {
-				const usd = priceOracle.safeConvertToUSD(t.token, t.balance) || 0n;
-				totalValueUSD += usd;
-			}
+			if (recomputeTotals) totalValueUSD += priceOracle.safeConvertToUSD(t.token, t.balance).value;
 		}
-		if (recomputeTotals) totalValue = market.valueInUnderlying(ca.tokens.map((t) => ({
+		if (recomputeTotals) totalValue = priceOracle.safeConvertAssets(ca.tokens.map((t) => ({
 			token: t.token,
 			balance: t.balance
-		}))).value;
+		})), market.underlying).value;
 		const snapshot = {
 			...accountSnapshotFromCreditAccountData(ca),
 			totalValue
@@ -308,7 +305,8 @@ var PositionsService = class extends SDKConstruct {
 		const borrowRate = this.borrowRate(snapshot);
 		const timeToLiquidation = this.timeToLiquidation(snapshot);
 		const liquidationPrice = this.liquidationPrice(snapshot);
-		const totalDebtUSD = priceFailed ? priceOracle.safeConvertToUSD(market.underlying, totalDebtValue) ?? 0n : ca.totalDebtUSD;
+		let totalDebtUSD = ca.totalDebtUSD;
+		if (priceFailed) totalDebtUSD = priceOracle.safeConvertToUSD(market.underlying, totalDebtValue).value;
 		return {
 			kind: "strategy",
 			chainId: this.sdk.chainId,

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/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/preview/preview/buildDelayedStrategyPositionOperationPreview.js

@@ -3,7 +3,6 @@ import { BigIntMath } from "../../onchain/utils/bigint-math.js";
 import { DUST_THRESHOLD } from "../../onchain/constants/math.js";
 import { asEstimated } from "../../model/previews.js";
 import "../../model/index.js";
-import { unpriceableTokenError } from "../../onchain/market/oracle/errors.js";
 import "../../onchain/index.js";
 import { isAddressEqual } from "viem";
 //#region src/preview/preview/buildDelayedStrategyPositionOperationPreview.ts
@@ -13,10 +12,9 @@ import { isAddressEqual } from "viem";
 * the claim itself followed by the intent-specific tail
 *
 * Pure function: the input states are never mutated and no network access is performed.
-* Swaps are estimated with the injected conversion; remaining holdings are
-* priced by `MarketSuite.valueInUnderlying`. Tokens that cannot be priced
-* contribute nothing and set a non-fatal `unpriceableToken` warning on the
-* preview.
+* Swaps and remaining holdings are priced by the market oracle. Tokens that
+* cannot be priced contribute nothing and set a non-fatal `unpriceableToken`
+* warning on the preview.
 *
 * The changes (e.g. `totalDebtChange`) are reported relative to the account
 * state before the whole transaction.
@@ -30,36 +28,26 @@ import { isAddressEqual } from "viem";
 * @param sdk - Market data source for the position metrics of the resulting
 * state; read synchronously, no network access.
 */
-function buildDelayedStrategyPositionOperationPreview(afterInstant, before, detected, convert, receivedToken, sdk) {
+function buildDelayedStrategyPositionOperationPreview(afterInstant, before, detected, receivedToken, sdk) {
 	const { request, intent } = detected;
 	const post = afterInstant.clone();
-	const converter = makeSafeConverter(convert);
+	const oracle = sdk.marketRegister.findByCreditManager(post.creditManager).priceOracle;
+	let warning;
+	const convert = (from, to, amount) => {
+		const priced = oracle.safeConvert(from, to, amount);
+		warning ??= priced.error;
+		return priced.value;
+	};
 	const claimed = applyClaim(post, request);
 	const collateralWithdrawn = new AssetsMap();
 	switch (intent?.type) {
-		case "CLOSE_ACCOUNT": return buildClosePreview(post, converter, receivedToken, sdk);
+		case "CLOSE_ACCOUNT": return buildClosePreview(post, receivedToken, sdk, warning);
 		case "DECREASE_LEVERAGE":
-			repayFromClaim(post, request.claimToken, converter.convert, claimed);
+			repayFromClaim(post, request.claimToken, convert, claimed);
 			break;
-		case "WITHDRAW_COLLATERAL": applyWithdrawCollateral(post, request, intent, converter, collateralWithdrawn);
+		case "WITHDRAW_COLLATERAL": applyWithdrawCollateral(post, request, intent, convert, collateralWithdrawn);
 	}
-	return buildAdjustPreview(post, before, collateralWithdrawn, converter, sdk);
-}
-function makeSafeConverter(convert) {
-	let warning;
-	return {
-		convert: (token, to, amount) => {
-			try {
-				return convert(token, to, amount);
-			} catch {
-				warning ??= unpriceableTokenError(token);
-				return 0n;
-			}
-		},
-		get warning() {
-			return warning;
-		}
-	};
+	return buildAdjustPreview(post, before, collateralWithdrawn, sdk, warning);
 }
 /**
 * Claim step, common to all intents: burns the phantom token (balance and
@@ -105,7 +93,7 @@ function applyClaim(post, request) {
 *    debt with them, but no more than the intent's `debtRepaid` target;
 *    whatever is not spent on repayment stays on the account as underlying.
 */
-function applyWithdrawCollateral(post, request, intent, converter, collateralWithdrawn) {
+function applyWithdrawCollateral(post, request, intent, convert, collateralWithdrawn) {
 	const { withdrawToken, withdrawAmount, debtRepaid } = intent;
 	const { claimToken } = request;
 	const sameToken = isAddressEqual(withdrawToken, claimToken);
@@ -115,19 +103,19 @@ function applyWithdrawCollateral(post, request, intent, converter, collateralWit
 	const missing = withdrawAmount - fromBalance;
 	if (missing > 0n && !sameToken) {
 		const available = post.balances.getOrZero(claimToken);
-		const cost = converter.convert(withdrawToken, claimToken, missing);
+		const cost = convert(withdrawToken, claimToken, missing);
 		if (cost > 0n && cost <= available) {
 			post.balances.dec(claimToken, cost);
 			withdrawn += missing;
 		} else if (available > 0n) {
 			post.balances.dec(claimToken, available);
-			withdrawn += converter.convert(claimToken, withdrawToken, available);
+			withdrawn += convert(claimToken, withdrawToken, available);
 		}
 	}
 	if (withdrawn > 0n) collateralWithdrawn.upsert(withdrawToken, withdrawn);
 	const remaining = post.balances.getOrZero(claimToken);
 	if (remaining > 0n) {
-		const proceeds = converter.convert(claimToken, post.underlying, remaining);
+		const proceeds = convert(claimToken, post.underlying, remaining);
 		post.balances.dec(claimToken, remaining);
 		post.balances.inc(post.underlying, proceeds);
 		post.repay(BigIntMath.min(proceeds, debtRepaid));
@@ -151,10 +139,10 @@ function repayFromClaim(post, claimToken, convert, amount) {
 * underlying, the debt is repaid in full and the remainder is withdrawn to
 * the user as `receivedToken`.
 */
-function buildClosePreview(post, converter, receivedToken, sdk) {
+function buildClosePreview(post, receivedToken, sdk, warning) {
 	const market = sdk.marketRegister.findByCreditManager(post.creditManager);
-	const priced = market.valueInUnderlying(post.balances.toAssets(), 0n);
 	const oracle = market.priceOracle;
+	const priced = oracle.safeConvertAssets(post.balances.toAssets(), market.underlying);
 	const suite = sdk.marketRegister.findCreditManager(post.creditManager);
 	return {
 		operation: "CloseCreditAccount",
@@ -170,15 +158,15 @@ function buildClosePreview(post, converter, receivedToken, sdk) {
 		name: suite.accountStrategyName(post.creditAccount),
 		targetCollateral: suite.accountTargetCollateral(post.creditAccount),
 		receivedAmount: oracle.toTokenAmount(receivedToken, BigIntMath.max(priced.value - post.totalDebt, 0n)),
-		warning: converter.warning ?? (priced.unpriceable ? unpriceableTokenError(priced.unpriceable) : void 0)
+		warning: warning ?? priced.error
 	};
 }
-function buildAdjustPreview(post, before, collateralWithdrawn, converter, sdk) {
+function buildAdjustPreview(post, before, collateralWithdrawn, sdk, warning) {
 	const market = sdk.marketRegister.findByCreditManager(post.creditManager);
-	const priced = market.valueInUnderlying(post.balances.toAssets());
+	const oracle = market.priceOracle;
+	const priced = oracle.safeConvertAssets(post.balances.toAssets(), market.underlying);
 	const snap = post.toSnapshot(priced.value);
 	const suite = sdk.marketRegister.findCreditManager(post.creditManager);
-	const oracle = market.priceOracle;
 	return {
 		operation: "AdjustCreditAccount",
 		...asEstimated(sdk.positions.projection(snap, { availableLiquidityChange: before.totalDebt - post.totalDebt })),
@@ -193,7 +181,7 @@ function buildAdjustPreview(post, before, collateralWithdrawn, converter, sdk) {
 			...oracle.toAmount(market.underlying, q.balance)
 		})),
 		assetsChange: post.balances.difference(before.balances).toAssets(DUST_THRESHOLD).map((a) => oracle.toTokenAmount(a.token, a.balance)),
-		warning: converter.warning ?? (priced.unpriceable ? unpriceableTokenError(priced.unpriceable) : void 0)
+		warning: warning ?? priced.error
 	};
 }
 //#endregion

package/dist/esm/preview/preview/previewAdjustStrategyPosition.js

@@ -2,7 +2,6 @@ import { AP_WETH_TOKEN } from "../../onchain/constants/address-provider.js";
 import { DUST_THRESHOLD } from "../../onchain/constants/math.js";
 import { asEstimated } from "../../model/previews.js";
 import "../../model/index.js";
-import { unpriceableTokenError } from "../../onchain/market/oracle/errors.js";
 import "../../onchain/index.js";
 import { replayMulticall } from "./replayMulticall.js";
 import { unwrapNativeCollateral } from "./unwrapNativeCollateral.js";
@@ -25,8 +24,8 @@ function previewAdjustStrategyPosition(input, operation, options) {
 	const { assets: collateralAdded, warning: unwrapWarning } = unwrapNativeCollateral(after.collateralAdded.toAssets(), value, sdk.addressProvider.getAddress(AP_WETH_TOKEN, 0));
 	warning ??= unwrapWarning;
 	const assetsChange = account.balances.difference(before.balances).toAssets(DUST_THRESHOLD);
-	const priced = market.valueInUnderlying(account.balances.toAssets());
-	if (priced.unpriceable) warning ??= unpriceableTokenError(priced.unpriceable);
+	const priced = oracle.safeConvertAssets(account.balances.toAssets(), market.underlying);
+	warning ??= priced.error;
 	const snap = account.toSnapshot(priced.value);
 	return {
 		operation: "AdjustCreditAccount",

package/dist/esm/preview/preview/previewExitOrRepayStrategyPosition.js

@@ -2,7 +2,6 @@ import { AP_WETH_TOKEN } from "../../onchain/constants/address-provider.js";
 import "../../onchain/constants/math.js";
 import { asEstimated } from "../../model/previews.js";
 import "../../model/index.js";
-import { unpriceableTokenError } from "../../onchain/market/oracle/errors.js";
 import "../../onchain/index.js";
 import { classifyCloseOrRepay } from "./detectCloseOrRepay.js";
 import { replayMulticall } from "./replayMulticall.js";
@@ -28,8 +27,8 @@ function previewCloseCreditAccount(input, operation, permanent, replay) {
 	const { before, after, warning: replayWarning } = replay;
 	const account = after.account;
 	let warning = replayWarning;
-	const priced = market.valueInUnderlying(account.balances.toAssets());
-	if (priced.unpriceable) warning ??= unpriceableTokenError(priced.unpriceable);
+	const priced = market.priceOracle.safeConvertAssets(account.balances.toAssets(), market.underlying);
+	warning ??= priced.error;
 	const suite = sdk.marketRegister.findCreditManager(operation.creditManager);
 	let receivedToken = market.underlying;
 	for (const m of operation.multicall) if (m.operation === "WithdrawCollateral" && m.amount === 115792089237316195423570985008687907853269984665640564039457584007913129639935n) {
@@ -59,8 +58,8 @@ function previewRepayCreditAccount(input, operation, permanent, replay) {
 	const account = after.account;
 	const { assets: collateralAdded, warning: unwrapWarning } = unwrapNativeCollateral(after.collateralAdded.toAssets(), value, sdk.addressProvider.getAddress(AP_WETH_TOKEN, 0));
 	let warning = replayWarning ?? unwrapWarning;
-	const priced = market.valueInUnderlying(account.balances.toAssets());
-	if (priced.unpriceable) warning ??= unpriceableTokenError(priced.unpriceable);
+	const priced = market.priceOracle.safeConvertAssets(account.balances.toAssets(), market.underlying);
+	warning ??= priced.error;
 	const suite = sdk.marketRegister.findCreditManager(operation.creditManager);
 	return {
 		operation: "RepayCreditAccount",

package/dist/esm/preview/preview/previewOpenStrategyPosition.js

@@ -1,7 +1,6 @@
 import { AP_WETH_TOKEN } from "../../onchain/constants/address-provider.js";
 import { asEstimated } from "../../model/previews.js";
 import "../../model/index.js";
-import { unpriceableTokenError } from "../../onchain/market/oracle/errors.js";
 import "../../onchain/index.js";
 import { CreditAccountState } from "./CreditAccountState.js";
 import { makeReplayState, replayInnerOperations } from "./replayInnerOperations.js";
@@ -16,12 +15,9 @@ function previewOpenStrategyPosition(input, operation) {
 	const account = state.account;
 	let priceWarning;
 	const netValue = state.collateralAdded.sum((token, balance) => {
-		try {
-			return oracle.convert(token, market.underlying, balance);
-		} catch {
-			priceWarning ??= unpriceableTokenError(token);
-			return 0n;
-		}
+		const priced = oracle.safeConvert(token, market.underlying, balance);
+		priceWarning ??= priced.error;
+		return priced.value;
 	});
 	const { assets: collateral, warning: unwrapWarning } = unwrapNativeCollateral(state.collateralAdded.toAssets(), value, sdk.addressProvider.getAddress(AP_WETH_TOKEN, 0));
 	warning ??= unwrapWarning ?? priceWarning;

package/dist/esm/preview/preview/previewOperation.js

@@ -80,7 +80,6 @@ async function previewMulticallOperation(input, operation, options) {
 	}
 	const { before, after } = replayMulticall(sdk, operation, options);
 	const market = sdk.marketRegister.findByCreditManager(operation.creditManager);
-	const convert = (token, to, amount) => market.priceOracle.convert(token, to, amount);
 	const meta = sdk.tokensMeta.get(market.underlying);
 	const receivedToken = meta && sdk.tokensMeta.isRWAUnderlying(meta) ? meta.asset : market.underlying;
 	const suite = sdk.marketRegister.findCreditManager(operation.creditManager);
@@ -93,7 +92,7 @@ async function previewMulticallOperation(input, operation, options) {
 		intent: delayed.intent,
 		estClaimableAt: estimateClaimableAt(sdk, delayed.request.phantomToken),
 		instantPreview,
-		delayedPreview: buildDelayedStrategyPositionOperationPreview(after.account, before, delayed, convert, receivedToken, sdk)
+		delayedPreview: buildDelayedStrategyPositionOperationPreview(after.account, before, delayed, receivedToken, sdk)
 	});
 }
 //#endregion

package/dist/types/model/index.d.ts

@@ -20,7 +20,7 @@ import { borrowRateBreakdownSchema, pnlBreakdownSchema, pointsProgramPnLSchema,
 import { amountSchema, assetTypeSchema, bpsSchema, chainIdSchema, leverageSchema, timestampSchema, tokenAmountSchema, tokenSchema, txCallSchema, underlyingTokenSchema } from "./primitives.schema.js";
 import { ChainFailed, ChainMetadata, ChainScoped, ChainSucceeded, DataResponse, DataSource, ResponseMetadata } from "./response.js";
 import { chainFailedSchema, chainMetadataSchema, chainSucceededSchema, dataSourceSchema, responseMetadataSchema, responseSchema } from "./response.schema.js";
-import { SDKError, SDKResult, SDKReturn, isSDKError, sdkErr, sdkOk } from "./result.js";
+import { SDKError, SDKResult, SDKReturn, SafeValue, isSDKError, safeValue, sdkErr, sdkOk } from "./result.js";
 import { PositionClaimableWithdrawal, PositionPendingWithdrawal, PositionWithdrawals, WithdrawalOutputAmount } from "./withdrawals.js";
 import { positionClaimableWithdrawalSchema, positionPendingWithdrawalSchema, positionWithdrawalsSchema, withdrawalOutputAmountSchema } from "./withdrawals.schema.js";
-export { AccountHoldings, AccountMetrics, AccountProjection, AccountStateChange, AdapterCallOutsideBracketError, AdjustStrategyPositionPreview, Amount, ApyBreakdown, Asset, AssetType, BorrowRateBreakdown, Bps, CHART_METRIC_UNITS, CHART_RANGES, CHART_UNAVAILABLE_CODES, ChainFailed, ChainId, ChainMetadata, ChainScoped, ChainScopedFilter, ChainSucceeded, ChartBundle, ChartDenomination, ChartMetric, ChartQuery, ChartRange, ChartSeries, ChartSeriesOk, ChartSeriesUnavailable, ChartUnavailableCode, ChartUnit, ChartValue, ChartWindow, CompareTag, CompareTolerance, CreditOperationMarket, Curator, CuratorName, DataResponse, DataSource, DelayedAddCollateralIntent, DelayedCloseAccountIntent, DelayedDecreaseLeverageIntent, DelayedDepositAndIncreaseLeverageIntent, DelayedDepositIntent, DelayedIncreaseLeverageIntent, DelayedIntent, DelayedReceivedAsset, DelayedStrategyPositionOperationPreview, DelayedWithdrawCollateralIntent, Estimated, EstimatedProjection, ExitStrategyPositionPreview, FILTER_ALL, FilterAll, Filterable, GridSampling, IGearboxError, InstantReceivedAsset, InstantStrategyPositionOperationPreview, InvalidTransactionValueError, Leverage, LiquidatableAccount, LiquidatableAccountFilter, LiquidationApproval, LiquidationDetails, LiquidationPosition, MalformedBracketError, MalformedBracketKind, MalformedPreviewError, NonAdapterCallInBracketError, Notice, NoticeKind, NoticeSubject, OpenStrategyPositionPreview, OperationPreview, OperationPreviewError, Opportunity, OpportunityBase, OpportunityChartMetric, OpportunityDetail, OpportunityFilter, OpportunityId, OpportunityKey, OpportunityKind, OpportunityTotals, POOL_OPPORTUNITY_CHART_METRICS, POOL_POSITION_CHART_METRICS, PnlBreakdown, PointRewards, PointsProgram, PointsProgramPnL, PointsRewardsPnL, PoolOperationType, PoolOpportunity, PoolOpportunityChartMetric, PoolOpportunityDetail, PoolOpportunityKey, PoolOpportunityRef, PoolPosition, PoolPositionChartMetric, PoolPositionKey, PoolPositionOperationPreview, PoolPositionRef, Position, PositionChartMetric, PositionClaimableWithdrawal, PositionCollateral, PositionFilter, PositionId, PositionKey, PositionKind, PositionPendingWithdrawal, PositionTransaction, PositionTransactionKind, PositionWithdrawals, PositionsTotals, PreviewOperationInput, PreviewOperationOptions, PriceFeedData, PriceFeedSummary, QuotaAsset, RateCurve, RateCurvePoint, ReceivedAsset, RepayStrategyPositionPreview, ResponseMetadata, Rewards, RewardsPnL, RoutedField, SDKError, SDKResult, SDKReturn, STRATEGY_OPPORTUNITY_CHART_METRICS, STRATEGY_POSITION_CHART_METRICS, STRATEGY_POSITION_COLLATERAL_ERROR, StrategyOpportunity, StrategyOpportunityChartMetric, StrategyOpportunityDetail, StrategyOpportunityKey, StrategyOpportunityRef, StrategyPosition, StrategyPositionChartMetric, StrategyPositionKey, StrategyPositionRef, Timestamp, Token, TokenAmount, TokenQuotaRate, TokenRewards, TokenRewardsPnL, ToleranceCompareTag, TxCall, UnderlyingToken, UnpreviewableAdapterCallError, UnsupportedOutOfBracketCallError, WithdrawalOutputAmount, amountSchema, apyBreakdownSchema, asEstimated, assetTypeSchema, backendPreferred, booleanParamSchema, borrowRateBreakdownSchema, bpsSchema, chainFailedSchema, chainIdSchema, chainMetadataSchema, chainSucceededSchema, chartBundleSchemaFor, chartDenominationSchema, chartMetricSchema, chartQueryCodec, chartQueryParamsSchema, chartQuerySchema, chartRangeSchema, chartSeriesSchema, chartValueSchema, chartWindowSchema, compareTagOf, curatorNameSchema, curatorSchema, dataSourceSchema, delayedReceivedAssetSchema, encodeFlag, filterAllSchema, filterable, instantReceivedAssetSchema, isFilterSet, isSDKError, leverageSchema, liquidatableAccountFilterSchema, liquidatableAccountSchema, liquidationApprovalSchema, liquidationDetailsSchema, liquidationPositionId, liquidationPositionSchema, matchesLiquidatableAccountFilter, matchesOpportunityFilter, matchesPositionFilter, noticeKindSchema, noticeSchema, offchainOnly, onchainOnly, opportunityBaseSchema, opportunityDetailSchema, opportunityFilterQueryParamsSchema, opportunityFilterQuerySchema, opportunityFilterSchema, opportunityId, opportunityKeySchema, opportunityKindSchema, opportunitySchema, opportunityTotalsSchema, pnlBreakdownSchema, pointRewardsSchema, pointsProgramPnLSchema, pointsProgramSchema, pointsRewardsPnLSchema, poolOpportunityChartMetricSchema, poolOpportunityDetailSchema, poolOpportunityId, poolOpportunityKeySchema, poolOpportunitySchema, poolPositionChartMetricSchema, poolPositionId, poolPositionKeySchema, poolPositionSchema, positionClaimableWithdrawalSchema, positionCollateralSchema, positionFilterQueryParamsSchema, positionFilterQuerySchema, positionFilterSchema, positionId, positionKeySchema, positionKindSchema, positionPendingWithdrawalSchema, positionSchema, positionTransactionKindSchema, positionTransactionSchema, positionWithdrawalsSchema, positionsTotalsSchema, priceFeedDataSchema, priceFeedSummarySchema, quotaAssetSchema, rateCurvePointSchema, rateCurveSchema, receivedAssetSchema, responseMetadataSchema, responseSchema, rewardsPnLSchema, rewardsSchema, sdkErr, sdkOk, strategyOpportunityChartMetricSchema, strategyOpportunityDetailSchema, strategyOpportunityId, strategyOpportunityKeySchema, strategyOpportunitySchema, strategyPositionChartMetricSchema, strategyPositionId, strategyPositionKeySchema, strategyPositionSchema, timestampSchema, tokenAmountSchema, tokenQuotaRateSchema, tokenRewardsPnLSchema, tokenRewardsSchema, tokenSchema, tolerance, txCallSchema, underlyingTokenSchema, withdrawalOutputAmountSchema };
+export { AccountHoldings, AccountMetrics, AccountProjection, AccountStateChange, AdapterCallOutsideBracketError, AdjustStrategyPositionPreview, Amount, ApyBreakdown, Asset, AssetType, BorrowRateBreakdown, Bps, CHART_METRIC_UNITS, CHART_RANGES, CHART_UNAVAILABLE_CODES, ChainFailed, ChainId, ChainMetadata, ChainScoped, ChainScopedFilter, ChainSucceeded, ChartBundle, ChartDenomination, ChartMetric, ChartQuery, ChartRange, ChartSeries, ChartSeriesOk, ChartSeriesUnavailable, ChartUnavailableCode, ChartUnit, ChartValue, ChartWindow, CompareTag, CompareTolerance, CreditOperationMarket, Curator, CuratorName, DataResponse, DataSource, DelayedAddCollateralIntent, DelayedCloseAccountIntent, DelayedDecreaseLeverageIntent, DelayedDepositAndIncreaseLeverageIntent, DelayedDepositIntent, DelayedIncreaseLeverageIntent, DelayedIntent, DelayedReceivedAsset, DelayedStrategyPositionOperationPreview, DelayedWithdrawCollateralIntent, Estimated, EstimatedProjection, ExitStrategyPositionPreview, FILTER_ALL, FilterAll, Filterable, GridSampling, IGearboxError, InstantReceivedAsset, InstantStrategyPositionOperationPreview, InvalidTransactionValueError, Leverage, LiquidatableAccount, LiquidatableAccountFilter, LiquidationApproval, LiquidationDetails, LiquidationPosition, MalformedBracketError, MalformedBracketKind, MalformedPreviewError, NonAdapterCallInBracketError, Notice, NoticeKind, NoticeSubject, OpenStrategyPositionPreview, OperationPreview, OperationPreviewError, Opportunity, OpportunityBase, OpportunityChartMetric, OpportunityDetail, OpportunityFilter, OpportunityId, OpportunityKey, OpportunityKind, OpportunityTotals, POOL_OPPORTUNITY_CHART_METRICS, POOL_POSITION_CHART_METRICS, PnlBreakdown, PointRewards, PointsProgram, PointsProgramPnL, PointsRewardsPnL, PoolOperationType, PoolOpportunity, PoolOpportunityChartMetric, PoolOpportunityDetail, PoolOpportunityKey, PoolOpportunityRef, PoolPosition, PoolPositionChartMetric, PoolPositionKey, PoolPositionOperationPreview, PoolPositionRef, Position, PositionChartMetric, PositionClaimableWithdrawal, PositionCollateral, PositionFilter, PositionId, PositionKey, PositionKind, PositionPendingWithdrawal, PositionTransaction, PositionTransactionKind, PositionWithdrawals, PositionsTotals, PreviewOperationInput, PreviewOperationOptions, PriceFeedData, PriceFeedSummary, QuotaAsset, RateCurve, RateCurvePoint, ReceivedAsset, RepayStrategyPositionPreview, ResponseMetadata, Rewards, RewardsPnL, RoutedField, SDKError, SDKResult, SDKReturn, STRATEGY_OPPORTUNITY_CHART_METRICS, STRATEGY_POSITION_CHART_METRICS, STRATEGY_POSITION_COLLATERAL_ERROR, SafeValue, StrategyOpportunity, StrategyOpportunityChartMetric, StrategyOpportunityDetail, StrategyOpportunityKey, StrategyOpportunityRef, StrategyPosition, StrategyPositionChartMetric, StrategyPositionKey, StrategyPositionRef, Timestamp, Token, TokenAmount, TokenQuotaRate, TokenRewards, TokenRewardsPnL, ToleranceCompareTag, TxCall, UnderlyingToken, UnpreviewableAdapterCallError, UnsupportedOutOfBracketCallError, WithdrawalOutputAmount, amountSchema, apyBreakdownSchema, asEstimated, assetTypeSchema, backendPreferred, booleanParamSchema, borrowRateBreakdownSchema, bpsSchema, chainFailedSchema, chainIdSchema, chainMetadataSchema, chainSucceededSchema, chartBundleSchemaFor, chartDenominationSchema, chartMetricSchema, chartQueryCodec, chartQueryParamsSchema, chartQuerySchema, chartRangeSchema, chartSeriesSchema, chartValueSchema, chartWindowSchema, compareTagOf, curatorNameSchema, curatorSchema, dataSourceSchema, delayedReceivedAssetSchema, encodeFlag, filterAllSchema, filterable, instantReceivedAssetSchema, isFilterSet, isSDKError, leverageSchema, liquidatableAccountFilterSchema, liquidatableAccountSchema, liquidationApprovalSchema, liquidationDetailsSchema, liquidationPositionId, liquidationPositionSchema, matchesLiquidatableAccountFilter, matchesOpportunityFilter, matchesPositionFilter, noticeKindSchema, noticeSchema, offchainOnly, onchainOnly, opportunityBaseSchema, opportunityDetailSchema, opportunityFilterQueryParamsSchema, opportunityFilterQuerySchema, opportunityFilterSchema, opportunityId, opportunityKeySchema, opportunityKindSchema, opportunitySchema, opportunityTotalsSchema, pnlBreakdownSchema, pointRewardsSchema, pointsProgramPnLSchema, pointsProgramSchema, pointsRewardsPnLSchema, poolOpportunityChartMetricSchema, poolOpportunityDetailSchema, poolOpportunityId, poolOpportunityKeySchema, poolOpportunitySchema, poolPositionChartMetricSchema, poolPositionId, poolPositionKeySchema, poolPositionSchema, positionClaimableWithdrawalSchema, positionCollateralSchema, positionFilterQueryParamsSchema, positionFilterQuerySchema, positionFilterSchema, positionId, positionKeySchema, positionKindSchema, positionPendingWithdrawalSchema, positionSchema, positionTransactionKindSchema, positionTransactionSchema, positionWithdrawalsSchema, positionsTotalsSchema, priceFeedDataSchema, priceFeedSummarySchema, quotaAssetSchema, rateCurvePointSchema, rateCurveSchema, receivedAssetSchema, responseMetadataSchema, responseSchema, rewardsPnLSchema, rewardsSchema, safeValue, sdkErr, sdkOk, strategyOpportunityChartMetricSchema, strategyOpportunityDetailSchema, strategyOpportunityId, strategyOpportunityKeySchema, strategyOpportunitySchema, strategyPositionChartMetricSchema, strategyPositionId, strategyPositionKeySchema, strategyPositionSchema, timestampSchema, tokenAmountSchema, tokenQuotaRateSchema, tokenRewardsPnLSchema, tokenRewardsSchema, tokenSchema, tolerance, txCallSchema, underlyingTokenSchema, withdrawalOutputAmountSchema };

package/dist/types/model/previews.d.ts

@@ -290,9 +290,10 @@ interface AccountMetrics {
    **/
   healthFactor: Bps;
   /**
-   * The same factor with collateral valued at safe prices — the lower of each
-   * token's main and reserve oracle feeds, which is what the credit manager
-   * switches to for a call that hands funds over.
+   * The same factor with collateral valued at safe prices — `min` of each
+   * token's main and reserve feeds (0 when there is no reserve), which is
+   * what the credit manager switches to for a call that hands funds over.
+   * The underlying is always priced at the main feed.
    *
    * Always reported, whether or not the operation in question hands anything
    * over: which of the two factors decides a transaction is a property of the

package/dist/types/model/result.d.ts

@@ -35,6 +35,21 @@ interface SDKError<E extends IGearboxError = IGearboxError> {
  * to handle, checked by the compiler.
  **/
 type SDKReturn<T, E extends IGearboxError> = SDKResult<T> | SDKError<E>;
+/**
+ * Best-effort result: `value` is always present (zero / empty when nothing
+ * worked), `error` is set when it was degraded.
+ *
+ * Opposite of {@link SDKReturn}, which is exclusive (ok XOR error: a refusal).
+ * Later safe-priced figures reuse this type.
+ **/
+interface SafeValue<T, E extends IGearboxError = IGearboxError> {
+  value: T;
+  error?: E;
+}
+/**
+ * Builds a {@link SafeValue}. Omits `error` when the value was not degraded.
+ **/
+declare function safeValue<T, E extends IGearboxError = IGearboxError>(value: T, error?: E): SafeValue<T, E>;
 /** The success half, built. */
 declare function sdkOk<T>(data: T): SDKResult<T>;
 /** The failure half, built. */
@@ -45,4 +60,4 @@ declare function sdkErr<E extends IGearboxError>(error: E): SDKError<E>;
  **/
 declare function isSDKError<T, E extends IGearboxError>(answer: SDKReturn<T, E>): answer is SDKError<E>;
 //#endregion
-export { SDKError, SDKResult, SDKReturn, isSDKError, sdkErr, sdkOk };
+export { SDKError, SDKResult, SDKReturn, SafeValue, isSDKError, safeValue, sdkErr, sdkOk };