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

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

@@ -1,5 +1,6 @@
 import { AddressMap } from "../../utils/AddressMap.js";
 import { AddressSet } from "../../utils/AddressSet.js";
+import { BigIntMath } from "../../utils/bigint-math.js";
 import { AP_PRICE_FEED_COMPRESSOR, AP_WETH_TOKEN } from "../../constants/address-provider.js";
 import { NATIVE_ADDRESS } from "../../constants/addresses.js";
 import "../../constants/math.js";
@@ -10,10 +11,13 @@ import "../../utils/index.js";
 import { BaseContract } from "../../base/BaseContract.js";
 import "../../base/index.js";
 import { usdToNumber } from "../math.js";
+import { safeValue } from "../../../model/result.js";
+import "../../../model/index.js";
 import { priceFeedCompressorAbi } from "../../../abi/compressors/priceFeedCompressor.js";
 import { PriceFeedRef } from "../pricefeeds/PriceFeedRef.js";
 import { getRawPriceUpdates } from "../pricefeeds/getRawPriceUpdates.js";
 import "../pricefeeds/index.js";
+import { unpriceableTokenError } from "./errors.js";
 import PriceFeedAnswerMap from "./PriceFeedAnswerMap.js";
 import { isAddressEqual, stringToHex } from "viem";
 import { format, formatDistanceToNow } from "date-fns";
@@ -141,10 +145,13 @@ var PriceOracleBaseContract = class extends BaseContract {
 	**/
 	safeConvert(from, to, amount) {
 		try {
-			return this.convert(from, to, amount);
-		} catch (e) {
-			this.logger?.debug(`cannot convert ${this.labelAddress(from)} to ${this.labelAddress(to)}: ${e}`);
-			return null;
+			return { value: this.convert(from, to, amount) };
+		} catch {
+			try {
+				return { value: this.convert(from, to, amount, true) };
+			} catch {
+				return safeValue(0n, unpriceableTokenError(from));
+			}
 		}
 	}
 	/**
@@ -152,26 +159,72 @@ var PriceOracleBaseContract = class extends BaseContract {
 	**/
 	safeConvertToUSD(token, amount) {
 		try {
-			return this.convertToUSD(token, amount);
-		} catch (e) {
-			this.logger?.debug(`cannot price ${this.labelAddress(token)}: ${e}`);
-			return null;
+			return { value: this.convertToUSD(token, amount) };
+		} catch {
+			try {
+				return { value: this.convertToUSD(token, amount, true) };
+			} catch {
+				return safeValue(0n, unpriceableTokenError(token));
+			}
+		}
+	}
+	/**
+	* {@inheritDoc IPriceOracleContract.safeConvertMinUSD}
+	**/
+	safeConvertMinUSD(token, amount) {
+		let main;
+		try {
+			main = this.convertToUSD(token, amount);
+		} catch {
+			return safeValue(0n, unpriceableTokenError(token));
+		}
+		let feedToken = token;
+		if (isAddressEqual(token, "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE")) try {
+			feedToken = this.sdk.addressProvider.getAddress(AP_WETH_TOKEN, 0);
+		} catch {}
+		if (!this.reservePriceFeeds.has(feedToken)) return { value: 0n };
+		try {
+			return { value: BigIntMath.min(main, this.convertToUSD(token, amount, true)) };
+		} catch {
+			return safeValue(0n, unpriceableTokenError(token));
+		}
+	}
+	/**
+	* {@inheritDoc IPriceOracleContract.safeConvertFromUSD}
+	**/
+	safeConvertFromUSD(token, amount) {
+		try {
+			return { value: this.convertFromUSD(token, amount) };
+		} catch {
+			try {
+				return { value: this.convertFromUSD(token, amount, true) };
+			} catch {
+				return safeValue(0n, unpriceableTokenError(token));
+			}
 		}
 	}
 	/**
-	* {@inheritDoc IPriceOracleContract.safeUsdValue}
+	* {@inheritDoc IPriceOracleContract.safeConvertAssets}
 	**/
-	safeUsdValue(token, amount) {
-		const usd = this.safeConvertToUSD(token, amount);
-		return usd === null ? null : usdToNumber(usd);
+	safeConvertAssets(assets, to) {
+		let value = 0n;
+		let error;
+		for (const { token, balance } of assets) {
+			if (balance <= 10n) continue;
+			const converted = this.safeConvert(token, to, balance);
+			value += converted.value;
+			error ??= converted.error;
+		}
+		return safeValue(value, error);
 	}
 	/**
 	* {@inheritDoc IPriceOracleContract.toAmount}
 	**/
 	toAmount = (token, value) => {
+		const priced = this.safeConvertToUSD(token, value);
 		return {
 			value,
-			valueUsd: this.safeUsdValue(token, value)
+			valueUsd: priced.error ? null : usdToNumber(priced.value)
 		};
 	};
 	/**

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/market/pool/PoolV310Contract.js

@@ -1,3 +1,4 @@
+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";
@@ -7,7 +8,6 @@ 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 {

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

@@ -1,5 +1,5 @@
-import { ZapperContract } from "./ZapperContract.js";
 import { iethZapperAbi } from "../../../abi/iETHZapper.js";
+import { ZapperContract } from "./ZapperContract.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,8 +1,8 @@
+import { iZapperAbi } from "../../../abi/iZapper.js";
 import { BaseContract } from "../../base/BaseContract.js";
 import "../../base/index.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.

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/onchain/utils/viem/simulateWithPriceUpdates.js

@@ -1,6 +1,6 @@
 import { errorAbis } from "../../../abi/errors.js";
-import { generateCastTraceCall } from "./cast.js";
 import { iUpdatablePriceFeedAbi } from "../../../abi/iUpdatablePriceFeed.js";
+import { generateCastTraceCall } from "./cast.js";
 import { simulateMulticall } from "./simulateMulticall.js";
 import { BaseError, CallExecutionError, ContractFunctionRevertedError, decodeFunctionData, decodeFunctionResult, encodeFunctionData, parseAbi } from "viem";
 import { getAction, parseAccount } from "viem/utils";

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",