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

package/dist/esm/preview/preview/{buildDelayedPreview.js → buildDelayedStrategyPositionOperationPreview.js}

@@ -1,24 +1,24 @@
 import { AssetsMap } from "../../onchain/utils/AssetsMap.js";
 import { BigIntMath } from "../../onchain/utils/bigint-math.js";
 import { DUST_THRESHOLD } from "../../onchain/constants/math.js";
-import { calcPositionLeverage } from "../../onchain/market/math.js";
-import { ERROR_UNPRICEABLE_TOKEN } from "../../model/previews.js";
+import { asEstimated } from "../../model/previews.js";
 import "../../model/index.js";
+import { unpriceableTokenError } from "../../onchain/market/oracle/errors.js";
 import "../../onchain/index.js";
-import "../../common-utils/index.js";
 import { isAddressEqual } from "viem";
-//#region src/preview/preview/buildDelayedPreview.ts
+//#region src/preview/preview/buildDelayedStrategyPositionOperationPreview.ts
 /**
 * Builds the best-effort preview of the account state after the detected
 * delayed withdrawal is claimed and its intent (if any) is resumed:
 * 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; tokens it cannot price contribute
-* nothing and set a non-fatal `ERROR_UNPRICEABLE_TOKEN` error on the
+* 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.
 *
-* The changes (e.g. `debtChange`) are reported relative to the account
+* The changes (e.g. `totalDebtChange`) are reported relative to the account
 * state before the whole transaction.
 *
 * @param afterInstant - Account state after the instant part of the
@@ -30,7 +30,7 @@ import { isAddressEqual } from "viem";
 * @param sdk - Market data source for the position metrics of the resulting
 * state; read synchronously, no network access.
 */
-function buildDelayedPreview(afterInstant, before, detected, convert, receivedToken, sdk) {
+function buildDelayedStrategyPositionOperationPreview(afterInstant, before, detected, convert, receivedToken, sdk) {
 	const { request, intent } = detected;
 	const post = afterInstant.clone();
 	const converter = makeSafeConverter(convert);
@@ -46,21 +46,18 @@ function buildDelayedPreview(afterInstant, before, detected, convert, receivedTo
 	return buildAdjustPreview(post, before, collateralWithdrawn, converter, sdk);
 }
 function makeSafeConverter(convert) {
-	let error;
+	let warning;
 	return {
 		convert: (token, to, amount) => {
 			try {
 				return convert(token, to, amount);
 			} catch {
-				error ??= {
-					code: ERROR_UNPRICEABLE_TOKEN,
-					message: `cannot price token ${token}`
-				};
+				warning ??= unpriceableTokenError(token);
 				return 0n;
 			}
 		},
-		get error() {
-			return error;
+		get warning() {
+			return warning;
 		}
 	};
 }
@@ -150,64 +147,54 @@ function repayFromClaim(post, claimToken, convert, amount) {
 	post.repay(received);
 }
 /**
-* Oracle estimate of the account's total value in the underlying, ignoring
-* balances at or below `dust`.
-*/
-function totalValueInUnderlying(post, convert, dust) {
-	return post.balances.sum((token, balance) => balance > dust ? convert(token, post.underlying, balance) : 0n);
-}
-/**
 * `CLOSE_ACCOUNT` operation tail: everything is swapped into the
 * underlying, the debt is repaid in full and the remainder is withdrawn to
 * the user as `receivedToken`.
 */
 function buildClosePreview(post, converter, receivedToken, sdk) {
-	const totalValue = totalValueInUnderlying(post, converter.convert, 0n);
-	const oracle = sdk.marketRegister.findByCreditManager(post.creditManager).priceOracle;
+	const market = sdk.marketRegister.findByCreditManager(post.creditManager);
+	const priced = market.valueInUnderlying(post.balances.toAssets(), 0n);
+	const oracle = market.priceOracle;
+	const suite = sdk.marketRegister.findCreditManager(post.creditManager);
 	return {
 		operation: "CloseCreditAccount",
 		permanent: false,
-		creditManager: post.creditManager,
-		name: sdk.marketRegister.findCreditManager(post.creditManager).name,
+		...asEstimated(sdk.positions.projection({
+			creditManager: post.creditManager,
+			assets: [],
+			quotas: [],
+			totalDebt: 0n,
+			totalValue: 0n
+		}, { availableLiquidityChange: post.totalDebt })),
 		creditAccount: post.creditAccount,
-		receivedAmount: oracle.toTokenAmount(receivedToken, BigIntMath.max(totalValue - post.totalDebt, 0n)),
-		error: converter.error
+		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)
 	};
 }
 function buildAdjustPreview(post, before, collateralWithdrawn, converter, sdk) {
-	const totalValue = totalValueInUnderlying(post, converter.convert, DUST_THRESHOLD);
-	const assets = post.balances.toAssets(DUST_THRESHOLD);
-	const quotas = post.quotas.toAssets(0n);
-	const snap = post.toSnapshot(totalValue);
 	const market = sdk.marketRegister.findByCreditManager(post.creditManager);
+	const priced = market.valueInUnderlying(post.balances.toAssets());
+	const snap = post.toSnapshot(priced.value);
+	const suite = sdk.marketRegister.findCreditManager(post.creditManager);
 	const oracle = market.priceOracle;
 	return {
 		operation: "AdjustCreditAccount",
-		creditManager: post.creditManager,
-		name: sdk.marketRegister.findCreditManager(post.creditManager).name,
+		...asEstimated(sdk.positions.projection(snap, { availableLiquidityChange: before.totalDebt - post.totalDebt })),
 		creditAccount: post.creditAccount,
+		name: suite.accountStrategyName(post.creditAccount),
+		targetCollateral: suite.accountTargetCollateral(post.creditAccount),
 		collateralAdded: [],
 		collateralWithdrawn: collateralWithdrawn.toAssets().map((a) => oracle.toTokenAmount(a.token, a.balance)),
-		totalValue,
-		debt: post.totalDebt,
-		debtChange: post.totalDebt - before.totalDebt,
-		quotas: quotas.map((q) => ({
-			token: sdk.tokensMeta.mustGetToken(q.token),
-			...oracle.toAmount(market.underlying, q.balance)
-		})),
+		totalDebtChange: market.toUnderlyingAmount(post.totalDebt - before.totalDebt),
 		quotasChange: post.quotas.difference(before.quotas).toAssets().map((q) => ({
 			token: sdk.tokensMeta.mustGetToken(q.token),
 			...oracle.toAmount(market.underlying, q.balance)
 		})),
-		assets: assets.map((a) => oracle.toTokenAmount(a.token, a.balance)),
 		assetsChange: post.balances.difference(before.balances).toAssets(DUST_THRESHOLD).map((a) => oracle.toTokenAmount(a.token, a.balance)),
-		error: converter.error,
-		healthFactor: sdk.positions.healthFactor(snap),
-		borrowRate: sdk.positions.borrowRate(snap, { availableLiquidityChange: before.totalDebt - post.totalDebt }),
-		timeToLiquidation: sdk.positions.timeToLiquidation(snap, { availableLiquidityChange: before.totalDebt - post.totalDebt }),
-		liquidationPrice: sdk.positions.liquidationPrice(snap),
-		leverage: calcPositionLeverage(totalValue, post.totalDebt)
+		warning: converter.warning ?? (priced.unpriceable ? unpriceableTokenError(priced.unpriceable) : void 0)
 	};
 }
 //#endregion
-export { buildDelayedPreview };
+export { buildDelayedStrategyPositionOperationPreview };

package/dist/esm/preview/preview/detectDelayedClaim.js

@@ -1,4 +1,6 @@
 import { AbstractAdapterContract } from "../../onchain/market/adapters/contracts/AbstractAdapter.js";
+import { sdkOk } from "../../model/result.js";
+import "../../model/index.js";
 import "../../onchain/index.js";
 //#region src/preview/preview/detectDelayedClaim.ts
 /**
@@ -29,16 +31,16 @@ function detectDelayedClaim(sdk, multicall) {
 * @param sdk - Attached SDK.
 * @param multicall - Parsed inner operations of the multicall.
 * @param blockNumber - Optional block number to read the log at.
-* @returns The decoded intent, or `undefined` when the multicall claims
-* nothing, the redemption logger is not deployed, or the log carries no
-* intent.
-* @throws InvalidDelayedIntentError when the logged `extraData` is non-empty
-* but cannot be decoded as a `DelayedIntent`.
+* @returns The decoded intent behind `ok` (`undefined` when the multicall
+* claims nothing, the redemption logger is not deployed, or the log carries
+* no intent), or the `invalidDelayedIntent` refusal when the logged
+* `extraData` is non-empty but cannot be decoded as a `DelayedIntent`.
 */
 async function resolveDelayedClaimIntent(sdk, multicall, blockNumber) {
 	const claim = detectDelayedClaim(sdk, multicall);
-	if (!claim) return;
-	return sdk.redemptionLogger?.getDelayedIntent(claim.redeemer, blockNumber);
+	const logger = sdk.redemptionLogger;
+	if (!claim || !logger) return sdkOk(void 0);
+	return logger.getDelayedIntent(claim.redeemer, blockNumber);
 }
 //#endregion
 export { detectDelayedClaim, resolveDelayedClaimIntent };

package/dist/esm/preview/preview/detectDelayedOperation.js

@@ -1,6 +1,7 @@
 import { AbstractAdapterContract } from "../../onchain/market/adapters/contracts/AbstractAdapter.js";
+import { sdkErr, sdkOk } from "../../model/result.js";
+import "../../model/index.js";
 import { decodeDelayedIntent } from "../../onchain/accounts/withdrawal-compressor/intent-codec.js";
-import { InvalidDelayedIntentError } from "../../onchain/accounts/withdrawal-compressor/errors.js";
 import "../../onchain/index.js";
 import { isAddressEqual } from "viem";
 //#region src/preview/preview/detectDelayedOperation.ts
@@ -35,13 +36,19 @@ function detectDelayedOperation(sdk, multicall) {
 		if (request.extraData && request.extraData !== "0x") try {
 			intent = decodeDelayedIntent(request.extraData);
 		} catch (e) {
-			throw new InvalidDelayedIntentError(request.extraData, e);
+			return sdkErr({
+				code: "invalidDelayedIntent",
+				message: `cannot decode delayed intent from extraData ${request.extraData}`,
+				extraData: request.extraData,
+				cause: e instanceof Error ? e : new Error(String(e))
+			});
 		}
-		return {
+		return sdkOk({
 			request,
 			intent
-		};
+		});
 	}
+	return sdkOk(void 0);
 }
 //#endregion
 export { detectDelayedOperation };

package/dist/esm/preview/preview/errors.js

@@ -1,16 +1,79 @@
 //#region src/preview/preview/errors.ts
-/**
-* Thrown by `previewOperation` for parsed operations it cannot preview yet.
-* Currently only pool operations and credit account opening are supported.
-*/
-var UnsupportedOperationError = class extends Error {
-	/** The parsed operation kind (the `operation` discriminant). */
-	operation;
-	constructor(operation) {
-		super(`operation "${operation}" is not supported by previewOperation`);
-		this.name = "UnsupportedOperationError";
-		this.operation = operation;
-	}
+const MALFORMED_BRACKET_MESSAGE = {
+	nested: "nested storeExpectedBalances/compareBalances bracket",
+	unmatchedCompare: "compareBalances without a preceding storeExpectedBalances",
+	unmatchedStore: "storeExpectedBalances without a matching compareBalances"
 };
+/**
+* Builds a {@link MalformedBracketError} for the given bracket invariant.
+**/
+function malformedBracketError(kind) {
+	return {
+		code: "malformedBracket",
+		message: MALFORMED_BRACKET_MESSAGE[kind],
+		kind
+	};
+}
+/**
+* Builds an {@link AdapterCallOutsideBracketError} for `adapter`.
+**/
+function adapterCallOutsideBracketError(adapter) {
+	return {
+		code: "adapterCallOutsideBracket",
+		message: `call to ${adapter} outside of a storeExpectedBalances/compareBalances bracket`,
+		adapter
+	};
+}
+/**
+* Builds a {@link NonAdapterCallInBracketError} for `target`.
+**/
+function nonAdapterCallInBracketError(target) {
+	return {
+		code: "nonAdapterCallInBracket",
+		message: `call to ${target} between storeExpectedBalances and compareBalances is not an adapter call`,
+		target
+	};
+}
+function asCause(cause) {
+	return cause instanceof Error ? cause : new Error(String(cause));
+}
+/**
+* Builds an {@link UnpreviewableAdapterCallError} for a bracketed adapter
+* call that could not be replayed.
+**/
+function unpreviewableAdapterCallError(adapter, cause) {
+	const err = asCause(cause);
+	return {
+		code: "unpreviewableAdapterCall",
+		message: err.message,
+		adapter,
+		cause: err
+	};
+}
+/**
+* Builds an {@link UnsupportedOutOfBracketCallError} for an allowed
+* out-of-bracket adapter call that could not be replayed.
+**/
+function unsupportedOutOfBracketCallError(adapter, cause) {
+	const err = asCause(cause);
+	return {
+		code: "unsupportedOutOfBracketCall",
+		message: err.message,
+		adapter,
+		cause: err
+	};
+}
+/**
+* Builds an {@link InvalidTransactionValueError} when `msg.value` does not
+* fit into the declared WETH collateral.
+**/
+function invalidTransactionValueError(value, wethCollateral) {
+	return {
+		code: "invalidTransactionValue",
+		message: `transaction value ${value} exceeds WETH collateral ${wethCollateral}`,
+		value,
+		wethCollateral
+	};
+}
 //#endregion
-export { UnsupportedOperationError };
+export { adapterCallOutsideBracketError, invalidTransactionValueError, malformedBracketError, nonAdapterCallInBracketError, unpreviewableAdapterCallError, unsupportedOutOfBracketCallError };

package/dist/esm/preview/preview/estimateClaimableAt.js

@@ -0,0 +1,20 @@
+import { isAddressEqual } from "viem";
+//#region src/preview/preview/estimateClaimableAt.ts
+/**
+* Estimates when a newly requested delayed withdrawal becomes claimable:
+* `now + withdrawalLength` of the cached withdrawable asset whose phantom
+* token matches `phantomToken`. Same formula as
+* `getWithdrawalRequestResult().claimableAt`.
+*
+* Returns `undefined` when the withdrawal compressor is missing, its assets
+* cache is not loaded, or no asset matches the phantom token.
+*/
+function estimateClaimableAt(sdk, phantomToken) {
+	const compressor = sdk.withdrawalCompressor;
+	if (!compressor?.state) return;
+	const asset = compressor.getWithdrawableAssets().find((a) => isAddressEqual(a.withdrawalPhantomToken, phantomToken));
+	if (!asset) return;
+	return Math.floor(Date.now() / 1e3) + Number(asset.withdrawalLength);
+}
+//#endregion
+export { estimateClaimableAt };

package/dist/esm/preview/preview/index.js

@@ -1,12 +1,13 @@
-import { buildDelayedPreview } from "./buildDelayedPreview.js";
+import { buildDelayedStrategyPositionOperationPreview } from "./buildDelayedStrategyPositionOperationPreview.js";
 import { CreditAccountState } from "./CreditAccountState.js";
 import { classifyCloseOrRepay, isCloseOrRepay } from "./detectCloseOrRepay.js";
 import { detectDelayedClaim, resolveDelayedClaimIntent } from "./detectDelayedClaim.js";
 import { detectDelayedOperation } from "./detectDelayedOperation.js";
-import { UnsupportedOperationError } from "./errors.js";
+import { adapterCallOutsideBracketError, invalidTransactionValueError, malformedBracketError, nonAdapterCallInBracketError, unpreviewableAdapterCallError, unsupportedOutOfBracketCallError } from "./errors.js";
+import { estimateClaimableAt } from "./estimateClaimableAt.js";
 import { makeReplayState, replayInnerOperations } from "./replayInnerOperations.js";
 import { replayMulticall } from "./replayMulticall.js";
-import { previewAdjustCreditAccount } from "./previewAdjustCreditAccount.js";
-import { previewCloseOrRepayCreditAccount } from "./previewCloseOrRepayCreditAccount.js";
+import { previewAdjustStrategyPosition } from "./previewAdjustStrategyPosition.js";
+import { previewExitOrRepayStrategyPosition } from "./previewExitOrRepayStrategyPosition.js";
 import { previewOperation } from "./previewOperation.js";
-export { CreditAccountState, UnsupportedOperationError, buildDelayedPreview, classifyCloseOrRepay, detectDelayedClaim, detectDelayedOperation, isCloseOrRepay, makeReplayState, previewAdjustCreditAccount, previewCloseOrRepayCreditAccount, previewOperation, replayInnerOperations, replayMulticall, resolveDelayedClaimIntent };
+export { CreditAccountState, adapterCallOutsideBracketError, buildDelayedStrategyPositionOperationPreview, classifyCloseOrRepay, detectDelayedClaim, detectDelayedOperation, estimateClaimableAt, invalidTransactionValueError, isCloseOrRepay, makeReplayState, malformedBracketError, nonAdapterCallInBracketError, previewAdjustStrategyPosition, previewExitOrRepayStrategyPosition, previewOperation, replayInnerOperations, replayMulticall, resolveDelayedClaimIntent, unpreviewableAdapterCallError, unsupportedOutOfBracketCallError };

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

@@ -0,0 +1,49 @@
+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";
+//#region src/preview/preview/previewAdjustStrategyPosition.ts
+/**
+* Previews a `multicall`/`botMulticall` operation on an existing credit
+* account: threads the multicall through {@link replayMulticall} over the
+* pre-resolved account state (`options.creditAccount`) and reports the
+* minimal guaranteed post-state alongside the changes relative to the
+* pre-state.
+*/
+function previewAdjustStrategyPosition(input, operation, options) {
+	const { sdk, value = 0n } = input;
+	const market = sdk.marketRegister.findByCreditManager(operation.creditManager);
+	const suite = sdk.marketRegister.findCreditManager(operation.creditManager);
+	const oracle = market.priceOracle;
+	const { before, after, warning: replayWarning } = replayMulticall(sdk, operation, options);
+	const account = after.account;
+	let warning = replayWarning;
+	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 snap = account.toSnapshot(priced.value);
+	return {
+		operation: "AdjustCreditAccount",
+		...asEstimated(sdk.positions.projection(snap, { availableLiquidityChange: before.totalDebt - account.totalDebt })),
+		creditAccount: operation.creditAccount,
+		name: suite.accountStrategyName(operation.creditAccount),
+		targetCollateral: suite.accountTargetCollateral(operation.creditAccount),
+		collateralAdded: collateralAdded.map((a) => oracle.toTokenAmount(a.token, a.balance)),
+		collateralWithdrawn: after.collateralWithdrawn.toAssets().map((a) => oracle.toTokenAmount(a.token, a.balance)),
+		totalDebtChange: market.toUnderlyingAmount(account.totalDebt - before.totalDebt),
+		quotasChange: account.quotas.difference(before.quotas).toAssets().map((q) => ({
+			token: sdk.tokensMeta.mustGetToken(q.token),
+			...oracle.toAmount(market.underlying, q.balance)
+		})),
+		assetsChange: assetsChange.map((a) => oracle.toTokenAmount(a.token, a.balance)),
+		warning
+	};
+}
+//#endregion
+export { previewAdjustStrategyPosition };

package/dist/esm/preview/preview/{previewCloseOrRepayCreditAccount.js → previewExitOrRepayStrategyPosition.js}

@@ -1,17 +1,20 @@
 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";
 import { unwrapNativeCollateral } from "./unwrapNativeCollateral.js";
-//#region src/preview/preview/previewCloseOrRepayCreditAccount.ts
-async function previewCloseOrRepayCreditAccount(input, operation, permanent, options) {
+//#region src/preview/preview/previewExitOrRepayStrategyPosition.ts
+function previewExitOrRepayStrategyPosition(input, operation, permanent, options) {
 	const { sdk } = input;
 	const market = sdk.marketRegister.findByCreditManager(operation.creditManager);
 	const exitTokens = [market.underlying];
 	const meta = sdk.tokensMeta.get(market.underlying);
 	if (meta && sdk.tokensMeta.isRWAUnderlying(meta)) exitTokens.push(meta.asset);
-	const replay = await replayMulticall(sdk, operation, options);
+	const replay = replayMulticall(sdk, operation, options);
 	return classifyCloseOrRepay(operation.multicall, exitTokens) === "close" ? previewCloseCreditAccount(input, operation, permanent, replay) : previewRepayCreditAccount(input, operation, permanent, replay);
 }
 /**
@@ -22,7 +25,12 @@ async function previewCloseOrRepayCreditAccount(input, operation, permanent, opt
 function previewCloseCreditAccount(input, operation, permanent, replay) {
 	const { sdk } = input;
 	const market = sdk.marketRegister.findByCreditManager(operation.creditManager);
-	const { after, error } = 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 suite = sdk.marketRegister.findCreditManager(operation.creditManager);
 	let receivedToken = market.underlying;
 	for (const m of operation.multicall) if (m.operation === "WithdrawCollateral" && m.amount === 115792089237316195423570985008687907853269984665640564039457584007913129639935n) {
 		receivedToken = m.token;
@@ -31,11 +39,12 @@ function previewCloseCreditAccount(input, operation, permanent, replay) {
 	return {
 		operation: "CloseCreditAccount",
 		permanent,
-		creditManager: operation.creditManager,
-		name: sdk.marketRegister.findCreditManager(operation.creditManager).name,
+		...asEstimated(sdk.positions.projection(account.toSnapshot(priced.value), { availableLiquidityChange: before.totalDebt - account.totalDebt })),
 		creditAccount: operation.creditAccount,
+		name: suite.accountStrategyName(operation.creditAccount),
+		targetCollateral: suite.accountTargetCollateral(operation.creditAccount),
 		receivedAmount: market.priceOracle.toTokenAmount(receivedToken, after.collateralWithdrawn.getOrZero(receivedToken)),
-		error
+		warning
 	};
 }
 /**
@@ -46,20 +55,25 @@ function previewCloseCreditAccount(input, operation, permanent, replay) {
 function previewRepayCreditAccount(input, operation, permanent, replay) {
 	const { sdk, value = 0n } = input;
 	const market = sdk.marketRegister.findByCreditManager(operation.creditManager);
-	const { before, after, error: replayError } = replay;
-	const { assets: collateralAdded, error: unwrapError } = unwrapNativeCollateral(after.collateralAdded.toAssets(), value, sdk.addressProvider.getAddress(AP_WETH_TOKEN, 0));
-	const error = replayError ?? unwrapError;
+	const { before, after, warning: replayWarning } = 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 suite = sdk.marketRegister.findCreditManager(operation.creditManager);
 	return {
 		operation: "RepayCreditAccount",
 		permanent,
-		creditManager: operation.creditManager,
-		name: sdk.marketRegister.findCreditManager(operation.creditManager).name,
+		...asEstimated(sdk.positions.projection(account.toSnapshot(priced.value), { availableLiquidityChange: before.totalDebt - account.totalDebt })),
 		creditAccount: operation.creditAccount,
+		name: suite.accountStrategyName(operation.creditAccount),
+		targetCollateral: suite.accountTargetCollateral(operation.creditAccount),
 		collateralAdded: collateralAdded.map((a) => market.priceOracle.toTokenAmount(a.token, a.balance)),
-		debtRepaid: before.totalDebt - after.account.totalDebt,
+		debtRepaid: market.toUnderlyingAmount(before.totalDebt - account.totalDebt),
 		collateralWithdrawn: after.collateralWithdrawn.toAssets().map((a) => market.priceOracle.toTokenAmount(a.token, a.balance)),
-		error
+		warning
 	};
 }
 //#endregion
-export { previewCloseOrRepayCreditAccount };
+export { previewExitOrRepayStrategyPosition };

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

@@ -0,0 +1,53 @@
+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";
+import { unwrapNativeCollateral } from "./unwrapNativeCollateral.js";
+//#region src/preview/preview/previewOpenStrategyPosition.ts
+function previewOpenStrategyPosition(input, operation) {
+	const { sdk, value = 0n } = input;
+	const market = sdk.marketRegister.findByCreditManager(operation.creditManager);
+	const oracle = market.priceOracle;
+	const state = makeReplayState(CreditAccountState.beforeOpen(operation.creditManager, market.underlying));
+	let warning = replayInnerOperations(sdk, operation.multicall, state);
+	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 { assets: collateral, warning: unwrapWarning } = unwrapNativeCollateral(state.collateralAdded.toAssets(), value, sdk.addressProvider.getAddress(AP_WETH_TOKEN, 0));
+	warning ??= unwrapWarning ?? priceWarning;
+	const snap = account.toSnapshot(netValue + account.totalDebt);
+	const targetAsset = inferTargetAsset(operation.multicall, account.balances);
+	return {
+		operation: operation.operation,
+		...asEstimated(sdk.positions.projection(snap, { availableLiquidityChange: -account.totalDebt })),
+		targetCollateral: targetAsset ? oracle.toTokenAmount(targetAsset.token, targetAsset.balance) : void 0,
+		collateralAdded: collateral.map((a) => oracle.toTokenAmount(a.token, a.balance)),
+		warning
+	};
+}
+/**
+* Infers the strategy target token of an account opening: the first quoted
+* token (first `UpdateQuota` with a positive change), with its balance taken
+* from the computed assets. Returns `undefined` when nothing is quoted.
+*/
+function inferTargetAsset(multicall, balances) {
+	for (const op of multicall) if (op.operation === "UpdateQuota" && op.change > 0n) {
+		const balance = balances.get(op.token);
+		return balance ? {
+			token: op.token,
+			balance
+		} : void 0;
+	}
+}
+//#endregion
+export { previewOpenStrategyPosition };