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

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 };

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

@@ -1,33 +1,49 @@
+import { isSDKError, sdkErr, sdkOk } from "../../model/result.js";
+import "../../model/index.js";
 import { parseOperationCalldata } from "../parse/parseOperationCalldata.js";
 import { isPoolOperation } from "../parse/types.js";
 import "../parse/index.js";
-import { buildDelayedPreview } from "./buildDelayedPreview.js";
+import { buildDelayedStrategyPositionOperationPreview } from "./buildDelayedStrategyPositionOperationPreview.js";
 import { isCloseOrRepay } from "./detectCloseOrRepay.js";
 import { resolveDelayedClaimIntent } from "./detectDelayedClaim.js";
 import { detectDelayedOperation } from "./detectDelayedOperation.js";
-import { UnsupportedOperationError } from "./errors.js";
+import { estimateClaimableAt } from "./estimateClaimableAt.js";
 import { replayMulticall } from "./replayMulticall.js";
-import { previewAdjustCreditAccount } from "./previewAdjustCreditAccount.js";
-import { previewCloseOrRepayCreditAccount } from "./previewCloseOrRepayCreditAccount.js";
-import { previewOpenCreditAccount } from "./previewOpenCreditAccount.js";
-import { previewPoolOperation } from "./previewPoolOperation.js";
+import { previewAdjustStrategyPosition } from "./previewAdjustStrategyPosition.js";
+import { previewExitOrRepayStrategyPosition } from "./previewExitOrRepayStrategyPosition.js";
+import { previewOpenStrategyPosition } from "./previewOpenStrategyPosition.js";
+import { previewPoolPositionOperation } from "./previewPoolPositionOperation.js";
 //#region src/preview/preview/previewOperation.ts
 /**
 * Previews a raw operation calldata: decodes it into a typed operation and
 * assembles an operation-specific, human-displayable preview.
+*
+* Answers an {@link SDKReturn} envelope: the preview behind `ok: true`, or —
+* when the transaction is one the previewer refuses to read — a
+* {@link PreviewOperationError} behind `ok: false`. A thrown exception
+* still means the SDK could not do its job (a read failed, the targeted
+* credit account could not be resolved), not a refusal of the transaction.
 */
 async function previewOperation(input, options) {
-	const operation = parseOperationCalldata(input);
-	if (isPoolOperation(operation)) return previewPoolOperation(input, operation, options);
-	if (operation.operation === "OpenCreditAccount" || operation.operation === "RWAOpenCreditAccount") return previewOpenCreditAccount(input, operation);
+	const parsed = parseOperationCalldata(input);
+	if (isSDKError(parsed)) return parsed;
+	const operation = parsed.data;
+	if (isPoolOperation(operation)) return previewPoolPositionOperation(input, operation, options);
+	if (operation.operation === "OpenCreditAccount" || operation.operation === "RWAOpenCreditAccount") return sdkOk(await previewOpenStrategyPosition(input, operation));
 	if (operation.operation === "CloseCreditAccount") {
 		const resolved = await resolveCreditAccount(input, operation, options);
-		const preview = await previewCloseOrRepayCreditAccount(input, operation, true, resolved);
-		preview.intent = await resolveDelayedClaimIntent(input.sdk, operation.multicall, options?.blockNumber);
-		return preview;
+		const preview = previewExitOrRepayStrategyPosition(input, operation, true, resolved);
+		const intent = await resolveDelayedClaimIntent(input.sdk, operation.multicall, options?.blockNumber);
+		if (isSDKError(intent)) return intent;
+		preview.intent = intent.data;
+		return sdkOk(preview);
 	}
 	if (operation.operation === "MultiCall" || operation.operation === "BotMulticall" || operation.operation === "RWAMulticall") return previewMulticallOperation(input, operation, await resolveCreditAccount(input, operation, options));
-	throw new UnsupportedOperationError(operation.operation);
+	return sdkErr({
+		code: "unsupportedOperation",
+		message: `operation "${operation.operation}" is not supported by previewOperation`,
+		operation: operation.operation
+	});
 }
 /**
 * Resolves the pre-state of the credit account an operation targets: uses the
@@ -52,26 +68,33 @@ async function resolveCreditAccount(input, operation, options) {
 */
 async function previewMulticallOperation(input, operation, options) {
 	const { sdk } = input;
-	const instantPreview = isCloseOrRepay(operation.multicall) ? await previewCloseOrRepayCreditAccount(input, operation, false, options) : await previewAdjustCreditAccount(input, operation, options);
-	const delayed = detectDelayedOperation(sdk, operation.multicall);
+	const instantPreview = isCloseOrRepay(operation.multicall) ? previewExitOrRepayStrategyPosition(input, operation, false, options) : previewAdjustStrategyPosition(input, operation, options);
+	const detected = detectDelayedOperation(sdk, operation.multicall);
+	if (isSDKError(detected)) return detected;
+	const delayed = detected.data;
 	if (!delayed) {
-		instantPreview.intent = await resolveDelayedClaimIntent(sdk, operation.multicall, options?.blockNumber);
-		return instantPreview;
+		const intent = await resolveDelayedClaimIntent(sdk, operation.multicall, options?.blockNumber);
+		if (isSDKError(intent)) return intent;
+		instantPreview.intent = intent.data;
+		return sdkOk(instantPreview);
 	}
-	const { before, after } = await replayMulticall(sdk, 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;
-	return {
+	const suite = sdk.marketRegister.findCreditManager(operation.creditManager);
+	return sdkOk({
 		operation: "DelayedCreditAccountOperation",
 		creditAccount: operation.creditAccount,
-		creditManager: operation.creditManager,
-		name: sdk.marketRegister.findCreditManager(operation.creditManager).name,
+		...suite.creditOperationMarket(),
+		name: suite.accountStrategyName(operation.creditAccount),
+		targetCollateral: suite.accountTargetCollateral(operation.creditAccount),
 		intent: delayed.intent,
+		estClaimableAt: estimateClaimableAt(sdk, delayed.request.phantomToken),
 		instantPreview,
-		delayedPreview: buildDelayedPreview(after.account, before, delayed, convert, receivedToken, sdk)
-	};
+		delayedPreview: buildDelayedStrategyPositionOperationPreview(after.account, before, delayed, convert, receivedToken, sdk)
+	});
 }
 //#endregion
 export { previewOperation };

package/dist/esm/preview/preview/previewPoolPositionOperation.js

@@ -0,0 +1,48 @@
+import { ierc20Abi } from "../../abi/iERC20.js";
+import { sdkErr, sdkOk } from "../../model/result.js";
+import "../../model/index.js";
+import { asPreviewSimulationError } from "../simulate/errors.js";
+import { amountsInOut, previewContract } from "../simulate/simulatePoolOperation.js";
+//#region src/preview/preview/previewPoolPositionOperation.ts
+async function previewPoolPositionOperation(input, operation, options) {
+	const { sdk } = input;
+	const { tokenIn, tokenOut } = operation;
+	const market = sdk.marketRegister.findByPool(operation.pool);
+	const pool = market.pool.pool;
+	const holder = "owner" in operation ? operation.owner : operation.receiver;
+	let previewAmount;
+	let shares;
+	try {
+		[previewAmount, shares] = await sdk.client.multicall({
+			contracts: [previewContract(operation), {
+				address: operation.pool,
+				abi: ierc20Abi,
+				functionName: "balanceOf",
+				args: [holder]
+			}],
+			allowFailure: false,
+			batchSize: 0,
+			blockNumber: options?.blockNumber
+		});
+	} catch (cause) {
+		const error = asPreviewSimulationError(cause, "multicall");
+		options?.logger?.error(error, "pool operation simulation failed");
+		return sdkErr(error);
+	}
+	const sim = amountsInOut(operation, previewAmount);
+	const inflow = operation.operation === "Deposit" || operation.operation === "Mint";
+	const after = shares + (inflow ? sim.amountOut : -sim.amountIn);
+	return sdkOk({
+		operation: operation.operation,
+		pool: operation.pool,
+		name: sdk.tokensMeta.mustGetToken(operation.pool).name,
+		underlyingToken: market.underlyingToken,
+		shareRate: pool.dieselRate,
+		tokenIn: market.priceOracle.toTokenAmount(tokenIn, sim.amountIn),
+		tokenOut: market.priceOracle.toTokenAmount(tokenOut, sim.amountOut),
+		curator: market.curator,
+		netValue: market.toUnderlyingAmount(pool.sharesToUnderlying(after > 0n ? after : 0n))
+	});
+}
+//#endregion
+export { previewPoolPositionOperation };

package/dist/esm/preview/preview/replayInnerOperations.js

@@ -1,11 +1,8 @@
 import { AssetsMap } from "../../onchain/utils/AssetsMap.js";
 import "../../onchain/constants/math.js";
 import { AbstractAdapterContract } from "../../onchain/market/adapters/contracts/AbstractAdapter.js";
-import { ERC4626AdapterContract } from "../../onchain/market/adapters/contracts/ERC4626AdapterContract.js";
-import { ERROR_ADAPTER_CALL_OUTSIDE_BRACKET, ERROR_MALFORMED_BRACKET, ERROR_NON_ADAPTER_CALL_IN_BRACKET, ERROR_UNPREVIEWABLE_ADAPTER_CALL, ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP } from "../../model/previews.js";
-import "../../model/index.js";
 import "../../onchain/index.js";
-import { applyRWAWrapUnwrap } from "./applyRWAWrapUnwrap.js";
+import { adapterCallOutsideBracketError, malformedBracketError, nonAdapterCallInBracketError, unpreviewableAdapterCallError, unsupportedOutOfBracketCallError } from "./errors.js";
 //#region src/preview/preview/replayInnerOperations.ts
 /**
 * Creates a {@link ReplayState} around the given account seed, with empty
@@ -23,16 +20,16 @@ function makeReplayState(account) {
 * facade execution order. The result is the *minimal guaranteed* post-state.
 *
 * The function assumes that the call was generated by our frontend using
-* router/withdrawal compressor, otherwise it returns an error, but still
+* router/withdrawal compressor, otherwise it returns a warning, but still
 * proceeds best-effort.
 *
-* @returns `undefined` on success, the error on a malformed multicall.
+* @returns `undefined` on success, the warning on a malformed multicall.
 */
-async function replayInnerOperations(sdk, multicall, state) {
+function replayInnerOperations(sdk, multicall, state) {
 	let inBracket = false;
-	let error;
+	let warning;
 	for (const op of multicall) {
-		let opError;
+		let opWarning;
 		switch (op.operation) {
 			case "AddCollateral":
 				applyAddCollateral(state, op);
@@ -50,29 +47,20 @@ async function replayInnerOperations(sdk, multicall, state) {
 				state.account.updateQuota(op.token, op.change);
 				break;
 			case "StoreExpectedBalances":
-				if (inBracket) opError = {
-					code: ERROR_MALFORMED_BRACKET,
-					message: "nested storeExpectedBalances/compareBalances bracket"
-				};
+				if (inBracket) opWarning = malformedBracketError("nested");
 				inBracket = true;
 				for (const { token, balance } of op.deltas) state.account.balances.inc(token, balance);
 				break;
 			case "CompareBalances":
-				if (!inBracket) opError = {
-					code: ERROR_MALFORMED_BRACKET,
-					message: "compareBalances without a preceding storeExpectedBalances"
-				};
+				if (!inBracket) opWarning = malformedBracketError("unmatchedCompare");
 				inBracket = false;
 				break;
-			case "Execute": opError = await applyExecute(sdk, op, inBracket, state.account.balances);
+			case "Execute": opWarning = applyExecute(sdk, op, inBracket, state.account.balances);
 		}
-		error ??= opError;
+		warning ??= opWarning;
 	}
-	if (inBracket) error ??= {
-		code: ERROR_MALFORMED_BRACKET,
-		message: "storeExpectedBalances without a matching compareBalances"
-	};
-	return error;
+	if (inBracket) warning ??= malformedBracketError("unmatchedStore");
+	return warning;
 }
 function applyAddCollateral(state, op) {
 	state.collateralAdded.inc(op.token, op.amount);
@@ -93,52 +81,27 @@ function applyWithdrawCollateral(state, op) {
 *
 * Inside a bracket, the adapter's balance changes are previewed via
 * {@link AbstractAdapterContract.previewBalanceChanges}. Outside a bracket,
-* only RWA wrap/unwrap calls are allowed (see {@link applyRWAWrapUnwrap});
-* nothing enforces the outcome of any other out-of-bracket adapter call
-* on-chain, so its effect on balances cannot be previewed.
+* only calls that {@link AbstractAdapterContract.replayOutOfBracketCall}
+* accepts are allowed; nothing enforces the outcome of any other out-of-bracket
+* adapter call on-chain, so its effect on balances cannot be previewed.
 */
-async function applyExecute(sdk, op, inBracket, balances) {
+function applyExecute(sdk, op, inBracket, balances) {
 	const adapter = sdk.getContract(op.adapter);
 	if (!inBracket) {
-		if (!isRWAShare(sdk, adapter)) return {
-			code: ERROR_ADAPTER_CALL_OUTSIDE_BRACKET,
-			message: `call to ${op.adapter} outside of a storeExpectedBalances/compareBalances bracket`
-		};
-		try {
-			applyRWAWrapUnwrap(adapter, op.calldata, balances);
-			return;
+		if (adapter instanceof AbstractAdapterContract) try {
+			if (adapter.replayOutOfBracketCall(balances, op.calldata)) return;
 		} catch (e) {
-			return {
-				code: ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP,
-				message: e instanceof Error ? e.message : String(e)
-			};
+			return unsupportedOutOfBracketCallError(op.adapter, e);
 		}
+		return adapterCallOutsideBracketError(op.adapter);
 	}
-	if (!(adapter instanceof AbstractAdapterContract)) return {
-		code: ERROR_NON_ADAPTER_CALL_IN_BRACKET,
-		message: `call to ${op.adapter} between storeExpectedBalances and compareBalances is not an adapter call`
-	};
+	if (!(adapter instanceof AbstractAdapterContract)) return nonAdapterCallInBracketError(op.adapter);
 	try {
-		await adapter.previewBalanceChanges(balances, op.calldata);
+		adapter.previewBalanceChanges(balances, op.calldata);
 		return;
 	} catch (e) {
-		return {
-			code: ERROR_UNPREVIEWABLE_ADAPTER_CALL,
-			message: e instanceof Error ? e.message : String(e)
-		};
-	}
-}
-/**
-* True when the ERC4626 adapter converts an RWA underlying, i.e. it is the
-* wrap/unwrap adapter of an RWA market rather than a regular vault strategy
-* adapter.
-*/
-function isRWAShare(sdk, adapter) {
-	if (adapter instanceof ERC4626AdapterContract) {
-		const meta = sdk.tokensMeta.get(adapter.share);
-		return !!meta && sdk.tokensMeta.isRWAUnderlying(meta);
+		return unpreviewableAdapterCallError(op.adapter, e);
 	}
-	return false;
 }
 //#endregion
 export { makeReplayState, replayInnerOperations };

package/dist/esm/preview/preview/replayMulticall.js

@@ -5,13 +5,13 @@ import { makeReplayState, replayInnerOperations } from "./replayInnerOperations.
 * Replays the operation's multicall over the account's pre-resolved
 * pre-state (`options.creditAccount`) via {@link replayInnerOperations}.
 */
-async function replayMulticall(sdk, operation, options) {
+function replayMulticall(sdk, operation, options) {
 	const before = CreditAccountState.fromCreditAccountData(options.creditAccount);
 	const after = makeReplayState(before.clone());
 	return {
 		before,
 		after,
-		error: await replayInnerOperations(sdk, operation.multicall, after)
+		warning: replayInnerOperations(sdk, operation.multicall, after)
 	};
 }
 //#endregion

package/dist/esm/preview/preview/unwrapNativeCollateral.js

@@ -1,8 +1,7 @@
 import { AssetsMap } from "../../onchain/utils/AssetsMap.js";
 import { NATIVE_ADDRESS } from "../../onchain/constants/addresses.js";
-import { ERROR_INVALID_TRANSACTION_VALUE } from "../../model/previews.js";
-import "../../model/index.js";
 import "../../onchain/index.js";
+import { invalidTransactionValueError } from "./errors.js";
 //#region src/preview/preview/unwrapNativeCollateral.ts
 /**
 * Represents the transaction's attached native value as a `NATIVE_ADDRESS`
@@ -16,14 +15,13 @@ import "../../onchain/index.js";
 *
 * When `nativeAmount` is positive but the WETH collateral is missing or
 * smaller than it, the transaction is malformed: the collateral is returned
-* as-is (no unwrapping) together with an `ERROR_INVALID_TRANSACTION_VALUE`
-* error.
+* as-is (no unwrapping) together with an `invalidTransactionValue` warning.
 *
 * @param collateral - Collateral assets as declared by the multicall.
 * @param nativeAmount - Transaction `msg.value`.
 * @param wethToken - Wrapped native token address.
 * @returns Collateral with the native amount unwrapped from the WETH entry,
-* plus the error on a malformed transaction value.
+* plus the warning on a malformed transaction value.
 */
 function unwrapNativeCollateral(collateral, nativeAmount, wethToken) {
 	if (nativeAmount === 0n) return { assets: collateral };
@@ -31,10 +29,7 @@ function unwrapNativeCollateral(collateral, nativeAmount, wethToken) {
 	const wethBalance = balances.get(wethToken) ?? 0n;
 	if (wethBalance < nativeAmount) return {
 		assets: collateral,
-		error: {
-			code: ERROR_INVALID_TRANSACTION_VALUE,
-			message: `transaction value ${nativeAmount} exceeds WETH collateral ${wethBalance}`
-		}
+		warning: invalidTransactionValueError(nativeAmount, wethBalance)
 	};
 	balances.upsert(wethToken, wethBalance === nativeAmount ? void 0 : wethBalance - nativeAmount);
 	balances.inc(NATIVE_ADDRESS, nativeAmount);

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

@@ -1,34 +1,26 @@
 import { errorAbis } from "../../abi/errors.js";
 import { BaseError, ContractFunctionRevertedError, decodeErrorResult } from "viem";
 //#region src/preview/simulate/errors.ts
-/**
-* Error returned by the pool simulation when it fails. It wraps the flow's
-* decoded revert reason (see {@link failures}).
-*/
-var PreviewSimulationError = class extends BaseError {
-	name = "PreviewSimulationError";
-	/** Per-flow decoded failures behind this error. */
-	failures;
-	constructor(failures) {
-		const shortMessage = failures.length <= 1 ? failures[0]?.detail.reason ?? "simulation failed" : "all simulation flows failed";
-		const cause = failures.find((f) => f.detail.cause instanceof Error)?.detail.cause;
-		super(shortMessage, {
-			metaMessages: failures.map((f) => `[${f.source}] ${f.detail.reason}`),
-			cause
-		});
-		this.failures = failures;
-	}
-};
+function isPreviewSimulationError(value) {
+	return typeof value === "object" && value !== null && !(value instanceof Error) && value.code === "previewSimulationFailed";
+}
 /**
 * Normalises an unknown rejection reason into a {@link PreviewSimulationError}.
 * Pass-through when it already is one; otherwise decodes it under `source`.
 */
 function asPreviewSimulationError(reason, source) {
-	if (reason instanceof PreviewSimulationError) return reason;
-	return new PreviewSimulationError([{
-		source,
-		detail: decodeSimulationError({ error: reason instanceof Error ? reason : new Error(String(reason)) })
-	}]);
+	if (isPreviewSimulationError(reason)) return reason;
+	const error = reason instanceof Error ? reason : new Error(String(reason));
+	const detail = decodeSimulationError({ error });
+	return {
+		code: "previewSimulationFailed",
+		message: detail.reason,
+		failures: [{
+			source,
+			detail
+		}],
+		cause: error
+	};
 }
 /**
 * Decodes a simulated call revert into a {@link SimulationError}.
@@ -76,4 +68,4 @@ function formatDecodedError(errorName, args) {
 	return `${errorName}(${args.map((arg) => String(arg)).join(", ")})`;
 }
 //#endregion
-export { PreviewSimulationError, asPreviewSimulationError, decodeSimulationError };
+export { asPreviewSimulationError, decodeSimulationError };

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

@@ -1,6 +1,6 @@
-import { PreviewSimulationError } from "./errors.js";
-import { simulateFacadeOperation } from "./simulateFacadeOperation.js";
+import { asPreviewSimulationError } from "./errors.js";
 import { simulatePoolOperation } from "./simulatePoolOperation.js";
+import { simulateFacadeOperation } from "./simulateFacadeOperation.js";
 import { simulateRWAOperation } from "./simulateRWAOperation.js";
 import { simulateOperation } from "./simulateOperation.js";
-export { PreviewSimulationError, simulateFacadeOperation, simulateOperation, simulatePoolOperation, simulateRWAOperation };
+export { asPreviewSimulationError, simulateFacadeOperation, simulateOperation, simulatePoolOperation, simulateRWAOperation };

package/dist/esm/preview/simulate/simulateOperation.js

@@ -1,7 +1,9 @@
+import { sdkOk } from "../../model/result.js";
+import "../../model/index.js";
 import { isPoolOperation, isRWAOperation } from "../parse/types.js";
 import "../parse/index.js";
-import { simulateFacadeOperation } from "./simulateFacadeOperation.js";
 import { simulatePoolOperation } from "./simulatePoolOperation.js";
+import { simulateFacadeOperation } from "./simulateFacadeOperation.js";
 import { simulateRWAOperation } from "./simulateRWAOperation.js";
 //#region src/preview/simulate/simulateOperation.ts
 /**
@@ -13,14 +15,14 @@ async function simulateOperation(input, options) {
 		...input,
 		operation
 	}, options);
-	if (isRWAOperation(operation)) return simulateRWAOperation({
+	if (isRWAOperation(operation)) return sdkOk(await simulateRWAOperation({
 		...input,
 		operation
-	}, options);
-	return simulateFacadeOperation({
+	}, options));
+	return sdkOk(await simulateFacadeOperation({
 		...input,
 		operation
-	}, options);
+	}, options));
 }
 //#endregion
 export { simulateOperation };