@gearbox-protocol/sdk 15.1.0-next.1 → 15.1.0-next.10

package/dist/esm/new-sdk/simulate/SimulateApi.js

@@ -0,0 +1,360 @@
+import { hexEq } from "../../sdk/utils/hex.js";
+import { MultichainConstruct } from "../../sdk/base/MultichainConstruct.js";
+import { fetchCreditAccountSlice } from "../../sdk/accounts/intents/utils/credit-account-slice.js";
+import { CreditAccountOperationsService } from "../../sdk/accounts/intents/index.js";
+import "../../sdk/index.js";
+//#region src/new-sdk/simulate/SimulateApi.ts
+/**
+* {@inheritDoc OpportunitiesSimulate}
+*
+* Holds no state of its own: it owns the mapping from the public,
+* read-model-shaped request to the engine's intent, and nothing else. All
+* protocol knowledge stays in `CreditAccountOperationsService` and
+* `PoolService`.
+*
+* A simulation names one chain, so it reads through
+* {@link MultichainConstruct.queryChain}: there is no second source to fall back
+* to, hence a chain the SDK does not cover, or one that fails the read, throws
+* rather than answering with empty metadata.
+**/
+var SimulateApi = class extends MultichainConstruct {
+	#ensureFresh;
+	constructor(sdk, ensureFresh) {
+		super(sdk);
+		this.#ensureFresh = ensureFresh;
+	}
+	async queryChain(props) {
+		await this.#ensureFresh?.([this.sdk.chain(props.network).chainId]);
+		return super.queryChain(props);
+	}
+	/**
+	* {@inheritDoc OpportunitiesSimulate.delayed}
+	**/
+	delayed = {
+		withdrawStrategy: (position, params) => this.#startDelayedIntent(position, params, {
+			type: "WITHDRAW",
+			amount: params.amount,
+			to: params.to,
+			tokenOut: params.tokenOut,
+			sourceToken: params.sourceToken
+		}),
+		adjustLeverage: (position, params) => this.#startDelayedIntent(position, params, {
+			type: "ADJUST_LEVERAGE",
+			targetLeverage: params.targetLeverage,
+			token: params.token
+		}),
+		finish: (position, params) => this.queryChain({
+			network: position.chainId,
+			run: async (sdk) => {
+				const intent = resumable(params.intent ?? params.claimable.intent);
+				if (!intent) return {
+					ok: false,
+					reason: "noRecordedIntent"
+				};
+				return service(sdk).finishIntent({
+					intent,
+					claimable: params.claimable,
+					creditAccount: await slice(sdk, position.creditAccount),
+					sdk,
+					slippage: params.slippage,
+					quotaReserve: params.quotaReserve
+				});
+			}
+		})
+	};
+	/**
+	* {@inheritDoc OpportunitiesSimulate.deposit}
+	**/
+	deposit(pool, params) {
+		const { marketRegister, pools } = this.sdk.chain(pool.chainId);
+		const tokenIn = params.tokenIn ?? marketRegister.findByPool(pool.pool).pool.underlying;
+		const tokenOut = lpRoute(params.tokenOut, () => pools.getDepositTokensOut(pool.pool, tokenIn));
+		if (!tokenOut) return {
+			ok: false,
+			reason: "unsupportedTokenPair"
+		};
+		const preview = pools.simulateDeposit({
+			pool: pool.pool,
+			amount: params.amount,
+			tokenIn,
+			tokenOut
+		});
+		const call = pools.addLiquidity({
+			collateral: preview.tokenIn,
+			pool: pool.pool,
+			wallet: params.wallet,
+			meta: pools.getDepositMetadata(pool.pool, tokenIn, tokenOut)
+		});
+		if (!call) return {
+			ok: false,
+			reason: "unsupportedTokenPair"
+		};
+		return {
+			ok: true,
+			operations: [],
+			preview,
+			calls: call.calls
+		};
+	}
+	/**
+	* {@inheritDoc OpportunitiesSimulate.withdraw}
+	**/
+	withdraw(pool, params) {
+		const { pools } = this.sdk.chain(pool.chainId);
+		const tokenIn = params.tokenIn ?? pool.pool;
+		const tokenOut = lpRoute(params.tokenOut, () => pools.getWithdrawalTokensOut(pool.pool, tokenIn));
+		if (!tokenOut) return {
+			ok: false,
+			reason: "unsupportedTokenPair"
+		};
+		const preview = pools.simulateWithdraw({
+			pool: pool.pool,
+			amount: params.amount,
+			tokenIn,
+			tokenOut
+		});
+		const { calls } = pools.removeLiquidity({
+			pool: pool.pool,
+			amount: params.amount,
+			wallet: params.wallet,
+			permit: void 0,
+			meta: pools.getWithdrawalMetadata(pool.pool, tokenIn, tokenOut),
+			mode: "withdraw"
+		});
+		return {
+			ok: true,
+			operations: [],
+			preview,
+			calls
+		};
+	}
+	/**
+	* {@inheritDoc OpportunitiesSimulate.redeem}
+	**/
+	redeem(pool, params) {
+		const { pools } = this.sdk.chain(pool.chainId);
+		const tokenIn = params.tokenIn ?? pool.pool;
+		const tokenOut = lpRoute(params.tokenOut, () => pools.getWithdrawalTokensOut(pool.pool, tokenIn));
+		if (!tokenOut) return {
+			ok: false,
+			reason: "unsupportedTokenPair"
+		};
+		const preview = pools.simulateRedeem({
+			pool: pool.pool,
+			amount: params.amount,
+			tokenIn,
+			tokenOut
+		});
+		const { calls } = pools.removeLiquidity({
+			pool: pool.pool,
+			amount: params.amount,
+			wallet: params.wallet,
+			permit: void 0,
+			meta: pools.getWithdrawalMetadata(pool.pool, tokenIn, tokenOut),
+			mode: "redeem"
+		});
+		return {
+			ok: true,
+			operations: [],
+			preview,
+			calls
+		};
+	}
+	/**
+	* {@inheritDoc OpportunitiesSimulate.openNewStrategy}
+	**/
+	async openNewStrategy(strategy, params) {
+		return this.queryChain({
+			network: strategy.chainId,
+			run: (sdk) => service(sdk).openStrategyIntent({
+				sdk,
+				creditManager: strategy.creditManager,
+				collateral: params.collateral,
+				targetToken: params.targetToken ?? strategy.targetCollateral,
+				leverage: params.leverage,
+				leftoverBalances: params.leftoverBalances,
+				slippage: params.slippage,
+				quotaReserve: params.quotaReserve
+			})
+		});
+	}
+	/**
+	* {@inheritDoc OpportunitiesSimulate.depositStrategy}
+	**/
+	async depositStrategy(position, params) {
+		return this.#startIntent(position, params, {
+			type: "DEPOSIT",
+			token: params.token,
+			amount: params.amount,
+			value: params.value,
+			positionToken: params.positionToken,
+			targetLeverage: params.targetLeverage
+		});
+	}
+	/**
+	* {@inheritDoc OpportunitiesSimulate.withdrawStrategy}
+	**/
+	async withdrawStrategy(position, params) {
+		return this.#startRoutes(position, params, {
+			type: "WITHDRAW",
+			amount: params.amount,
+			to: params.to,
+			tokenOut: params.tokenOut,
+			sourceToken: params.sourceToken
+		});
+	}
+	/**
+	* {@inheritDoc OpportunitiesSimulate.maxWithdraw}
+	**/
+	async maxWithdraw(position) {
+		return this.queryChain({
+			network: position.chainId,
+			run: async (sdk) => service(sdk).maxWithdraw({
+				creditAccount: await slice(sdk, position.creditAccount),
+				sdk
+			})
+		});
+	}
+	/**
+	* {@inheritDoc OpportunitiesSimulate.repayStrategy}
+	**/
+	async repayStrategy(position, params) {
+		return this.#startIntent(position, params, {
+			type: "REPAY",
+			token: params.token,
+			amount: params.amount,
+			value: params.value
+		});
+	}
+	/**
+	* {@inheritDoc OpportunitiesSimulate.maxRepay}
+	**/
+	async maxRepay(position) {
+		return this.queryChain({
+			network: position.chainId,
+			run: async (sdk) => service(sdk).maxRepay({
+				creditAccount: await slice(sdk, position.creditAccount),
+				sdk
+			})
+		});
+	}
+	/**
+	* {@inheritDoc OpportunitiesSimulate.adjustLeverage}
+	**/
+	async adjustLeverage(position, params) {
+		return this.#startRoutes(position, params, {
+			type: "ADJUST_LEVERAGE",
+			targetLeverage: params.targetLeverage,
+			token: params.token
+		});
+	}
+	/**
+	* {@inheritDoc OpportunitiesSimulate.addCollateral}
+	**/
+	async addCollateral(position, params) {
+		return this.#startIntent(position, params, {
+			type: "ADD_COLLATERAL",
+			token: params.token,
+			amount: params.amount,
+			value: params.value
+		});
+	}
+	/**
+	* {@inheritDoc OpportunitiesSimulate.withdrawCollateral}
+	**/
+	async withdrawCollateral(position, params) {
+		return this.#startIntent(position, params, {
+			type: "WITHDRAW_ASSET",
+			token: params.token,
+			amount: params.amount,
+			to: params.to
+		});
+	}
+	/**
+	* Shared path of the two flows that sell a position asset, and therefore have
+	* two routes to offer: one account read, one intent, both routes quoted.
+	**/
+	async #startRoutes(position, options, intent) {
+		return this.queryChain({
+			network: position.chainId,
+			run: async (sdk) => service(sdk).intentRoutes({
+				intent,
+				creditAccount: await slice(sdk, position.creditAccount),
+				sdk,
+				slippage: options.slippage,
+				quotaReserve: options.quotaReserve
+			})
+		});
+	}
+	/**
+	* Shared path of the same two flows when only the delayed route is asked for:
+	* a planner that requests a redemption instead of swapping.
+	**/
+	async #startDelayedIntent(position, options, intent) {
+		return this.queryChain({
+			network: position.chainId,
+			run: async (sdk) => service(sdk).startDelayedIntent({
+				intent,
+				creditAccount: await slice(sdk, position.creditAccount),
+				sdk,
+				slippage: options.slippage,
+				quotaReserve: options.quotaReserve
+			})
+		});
+	}
+	/**
+	* Shared path of the five flows that act on an existing account: read the
+	* account, then run the intent through the engine.
+	**/
+	async #startIntent(position, options, intent) {
+		return this.queryChain({
+			network: position.chainId,
+			run: async (sdk) => {
+				const creditAccount = await slice(sdk, position.creditAccount);
+				return service(sdk).startIntent({
+					intent,
+					creditAccount,
+					sdk,
+					slippage: options.slippage,
+					quotaReserve: options.quotaReserve
+				});
+			}
+		});
+	}
+};
+function service(sdk) {
+	return new CreditAccountOperationsService(sdk);
+}
+function slice(sdk, creditAccount) {
+	return fetchCreditAccountSlice(sdk, creditAccount);
+}
+/**
+* The operation a claim resumes, or `undefined` when there is none to resume:
+* a withdrawal requested without an intent, a compressor too old to report one,
+* or a full close, which the engine no longer previews.
+**/
+function resumable(intent) {
+	if (!intent || intent.type === "CLOSE_ACCOUNT") return;
+	return intent;
+}
+/**
+* Picks the route the operation takes out of `tokenIn`, as a value rather than
+* an exception: an unroutable or ambiguous pair is a request the caller can
+* fix, so it belongs in the `ok: false` half alongside the strategy refusals.
+*
+* A pool with no route out of the input reports it by throwing, hence the
+* catch; a requested output is checked against the list rather than trusted,
+* so that a wrong one fails here instead of deeper in call assembly.
+**/
+function lpRoute(requested, routes) {
+	let options;
+	try {
+		options = routes();
+	} catch {
+		return;
+	}
+	if (requested) return options.some((o) => hexEq(o, requested)) ? requested : void 0;
+	return options.length === 1 ? options[0] : void 0;
+}
+//#endregion
+export { SimulateApi };

package/dist/esm/new-sdk/simulate/index.js

@@ -0,0 +1,3 @@
+import { SimulateApi } from "./SimulateApi.js";
+import "./types.js";
+export { SimulateApi };

package/dist/esm/new-sdk/utils/index.js

@@ -1,4 +1,3 @@
 import { filterResponse } from "./filterResponse.js";
-import "./history.js";
 import { DEFAULT_MAX_OFFCHAIN_LAG, mergeChainList, mergeChainOne } from "./mergeChains.js";
 export { DEFAULT_MAX_OFFCHAIN_LAG, filterResponse, mergeChainList, mergeChainOne };

package/dist/esm/offchain/AbstractOffchainNamespace.js

@@ -1,4 +1,4 @@
-import { historySeriesSchema } from "../model/history.schema.js";
+import { chartBundleSchemaFor, chartQueryCodec } from "../model/charts.schema.js";
 import { responseSchema } from "../model/response.schema.js";
 import { OffchainInvalidJsonError } from "./errors/OffchainInvalidJsonError.js";
 import { OffchainNotConfiguredError } from "./errors/OffchainNotConfiguredError.js";
@@ -64,14 +64,17 @@ var AbstractOffchainNamespace = class {
 		};
 	}
 	/**
-	* Reads one historical series. A response carrying a metric other than the
-	* requested one fails validation.
+	* Reads the charts of one subject: one series per metric named, onto the one
+	* grid that lets them be compared at an index.
 	**/
-	async readHistory(request) {
+	async readCharts(path, metrics, range) {
 		return this.get({
-			path: request.path,
-			query: { range: request.range },
-			schema: historySeriesSchema.extend({ metric: z.literal(request.metric) })
+			path,
+			query: z.encode(chartQueryCodec, {
+				metrics,
+				range
+			}),
+			schema: chartBundleSchemaFor(metrics, range)
 		});
 	}
 	/**

package/dist/esm/offchain/GearboxAPI.js

@@ -1,3 +1,5 @@
+import { OffchainNotices } from "./notices/OffchainNotices.js";
+import "./notices/index.js";
 import { OffchainOpportunities } from "./opportunities/OffchainOpportunities.js";
 import "./opportunities/index.js";
 import { OffchainPositions } from "./positions/OffchainPositions.js";
@@ -33,10 +35,15 @@ var GearboxAPI = class {
 	* Namespace for the positions a wallet holds.
 	**/
 	positions;
+	/**
+	* Namespace for the notices the backend attaches to entities.
+	**/
+	notices;
 	constructor(options) {
 		this.chainIds = [...options.chainIds];
 		this.opportunities = new OffchainOpportunities(options);
 		this.positions = new OffchainPositions(options);
+		this.notices = new OffchainNotices(options);
 	}
 };
 //#endregion

package/dist/esm/offchain/index.js

@@ -10,10 +10,12 @@ import { OffchainValidationError } from "./errors/OffchainValidationError.js";
 import { readResponseBody } from "./errors/readResponseBody.js";
 import "./errors/index.js";
 import { AbstractOffchainNamespace } from "./AbstractOffchainNamespace.js";
+import { OffchainNotices } from "./notices/OffchainNotices.js";
+import "./notices/index.js";
 import { OffchainOpportunities } from "./opportunities/OffchainOpportunities.js";
 import "./opportunities/index.js";
 import { OffchainPositions } from "./positions/OffchainPositions.js";
 import "./positions/index.js";
 import { GearboxAPI } from "./GearboxAPI.js";
 import "./types.js";
-export { AbstractOffchainNamespace, GearboxAPI, OffchainInvalidJsonError, OffchainNotConfiguredError, OffchainNotImplementedError, OffchainOpportunities, OffchainPositions, OffchainRequestFailedError, OffchainStatusError, OffchainTransportError, OffchainValidationError, backendMessage, errorCause, readResponseBody };
+export { AbstractOffchainNamespace, GearboxAPI, OffchainInvalidJsonError, OffchainNotConfiguredError, OffchainNotImplementedError, OffchainNotices, OffchainOpportunities, OffchainPositions, OffchainRequestFailedError, OffchainStatusError, OffchainTransportError, OffchainValidationError, backendMessage, errorCause, readResponseBody };

package/dist/esm/offchain/notices/OffchainNotices.js

@@ -0,0 +1,26 @@
+import { noticeSchema } from "../../model/notices.schema.js";
+import { AbstractOffchainNamespace } from "../AbstractOffchainNamespace.js";
+import { z } from "zod/v4";
+//#region src/offchain/notices/OffchainNotices.ts
+/**
+* Backend counterpart of `sdk.notices`: banners the backend asks a consumer to
+* show for one entity, see {@link Notice}.
+**/
+var OffchainNotices = class extends AbstractOffchainNamespace {
+	#root = "/v2/notices";
+	constructor(options) {
+		super("OffchainNotices", options);
+	}
+	/**
+	* The notices of one pool opportunity or one strategy position.
+	**/
+	async list(subject) {
+		const [kind, address] = subject.kind === "pool" ? ["pool", subject.pool] : ["strategy", subject.creditAccount];
+		return this.get({
+			path: `${this.#root}/${kind}/${subject.chainId}/${address}`,
+			schema: z.array(noticeSchema)
+		});
+	}
+};
+//#endregion
+export { OffchainNotices };

package/dist/esm/offchain/notices/index.js

@@ -0,0 +1,2 @@
+import { OffchainNotices } from "./OffchainNotices.js";
+export { OffchainNotices };

package/dist/esm/offchain/opportunities/OffchainOpportunities.js

@@ -43,14 +43,10 @@ var OffchainOpportunities = class extends AbstractOffchainNamespace {
 		});
 	}
 	/**
-	* One historical series of one opportunity
+	* Charts of one opportunity: one series per metric, on a shared grid.
 	**/
-	async getHistory(query) {
-		return this.readHistory({
-			path: `${this.#historyRoot(query.opportunity)}/history/${query.metric}`,
-			metric: query.metric,
-			range: query.range
-		});
+	async getCharts(key, metrics, range) {
+		return this.readCharts(`${this.#chartRoot(key)}/charts`, metrics, range);
 	}
 	#poolPath(key) {
 		return `${this.#root}/pools/${key.chainId}/${key.pool}`;
@@ -58,7 +54,7 @@ var OffchainOpportunities = class extends AbstractOffchainNamespace {
 	#strategyPath(key) {
 		return `${this.#root}/strategies/${key.chainId}/${key.creditManager}/${key.targetCollateral}`;
 	}
-	#historyRoot(key) {
+	#chartRoot(key) {
 		return key.kind === "pool" ? this.#poolPath(key) : this.#strategyPath(key);
 	}
 };

package/dist/esm/offchain/positions/OffchainPositions.js

@@ -24,19 +24,19 @@ var OffchainPositions = class extends AbstractOffchainNamespace {
 		});
 	}
 	/**
-	* One historical series of one position.
-	*
-	* @returns An empty series until the backend client is implemented.
+	* Charts of one position: one series per metric, on a shared grid.
 	**/
-	async getHistory(query) {
-		return {
-			data: {
-				metric: query.metric,
-				points: [],
-				metadata: {}
-			},
-			meta: { chains: [] }
-		};
+	async getCharts(key, metrics, range) {
+		return this.readCharts(`${this.#chartRoot(key)}/charts`, metrics, range);
+	}
+	#poolPath(key) {
+		return `${this.#root}/pool/${key.chainId}/${key.pool}/${key.wallet}`;
+	}
+	#strategyPath(key) {
+		return `${this.#root}/strategy/${key.chainId}/${key.creditAccount}`;
+	}
+	#chartRoot(key) {
+		return key.kind === "pool" ? this.#poolPath(key) : this.#strategyPath(key);
 	}
 };
 //#endregion

package/dist/esm/plugins/adapters/contracts/ERC4626AdapterContract.js

@@ -1,5 +1,5 @@
-import { MissingSerializedParamsError } from "../../../sdk/base/errors.js";
 import { ierc4626AdapterAbi } from "../../../abi/ierc4626Adapter.js";
+import { MissingSerializedParamsError } from "../../../sdk/base/errors.js";
 import "../../../sdk/index.js";
 import { fnSigToName, swapFromTransfers } from "../transferHelpers.js";
 import { AbstractAdapterContract } from "./AbstractAdapter.js";

package/dist/esm/preview/preview/CreditAccountState.js

@@ -1,5 +1,5 @@
 import { AssetsMap } from "../../sdk/utils/AssetsMap.js";
-import "../../sdk/constants/math.js";
+import { DUST_THRESHOLD } from "../../sdk/constants/math.js";
 import "../../sdk/index.js";
 import { zeroAddress } from "viem";
 //#region src/preview/preview/CreditAccountState.ts
@@ -78,6 +78,19 @@ var CreditAccountState = class CreditAccountState {
 			totalDebt: ca.debt + ca.accruedInterest + ca.accruedFees
 		});
 	}
+	/**
+	* Immutable snapshot of this projected state for `sdk.positions` metric
+	* methods: dust-filtered balances, all quotas, and {@link totalDebt}.
+	**/
+	toSnapshot(totalValue) {
+		return {
+			creditManager: this.creditManager,
+			assets: this.balances.toAssets(DUST_THRESHOLD),
+			quotas: this.quotas.toAssets(0n),
+			totalDebt: this.totalDebt,
+			totalValue
+		};
+	}
 	clone() {
 		return new CreditAccountState({
 			creditAccount: this.creditAccount,

package/dist/esm/preview/preview/buildDelayedPreview.js

@@ -25,8 +25,10 @@ import { isAddressEqual } from "viem";
 * @param receivedToken - Token the `CLOSE_ACCOUNT` resume withdraws to the
 * user: the unwrapped underlying (vault asset) for RWA markets, the
 * underlying itself otherwise.
+* @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) {
+function buildDelayedPreview(afterInstant, before, detected, convert, receivedToken, sdk) {
 	const { request, intent } = detected;
 	const post = afterInstant.clone();
 	const converter = makeSafeConverter(convert);
@@ -39,7 +41,7 @@ function buildDelayedPreview(afterInstant, before, detected, convert, receivedTo
 			break;
 		case "WITHDRAW_COLLATERAL": applyWithdrawCollateral(post, request, intent, converter, collateralWithdrawn);
 	}
-	return buildAdjustPreview(post, before, collateralWithdrawn, converter);
+	return buildAdjustPreview(post, before, collateralWithdrawn, converter, sdk);
 }
 function makeSafeConverter(convert) {
 	let error;
@@ -171,8 +173,11 @@ function buildClosePreview(post, converter, receivedToken) {
 		error: converter.error
 	};
 }
-function buildAdjustPreview(post, before, collateralWithdrawn, converter) {
+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);
 	return {
 		operation: "AdjustCreditAccount",
 		creditManager: post.creditManager,
@@ -182,11 +187,16 @@ function buildAdjustPreview(post, before, collateralWithdrawn, converter) {
 		totalValue,
 		debt: post.debt,
 		debtChange: post.debt - before.debt,
-		quotas: post.quotas.toAssets(0n),
+		quotas,
 		quotasChange: post.quotas.difference(before.quotas).toAssets(),
-		assets: post.balances.toAssets(DUST_THRESHOLD),
+		assets,
 		assetsChange: post.balances.difference(before.balances).toAssets(DUST_THRESHOLD),
-		error: converter.error
+		error: converter.error,
+		healthFactor: sdk.positions.healthFactor(snap),
+		overallApy: 0,
+		borrowRate: sdk.positions.borrowRate(snap),
+		timeToLiquidation: sdk.positions.timeToLiquidation(snap),
+		liquidationPrice: sdk.positions.liquidationPrice(snap)
 	};
 }
 //#endregion

package/dist/esm/preview/preview/previewAdjustCreditAccount.js

@@ -21,6 +21,7 @@ async function previewAdjustCreditAccount(input, operation, options) {
 	const { assets: collateralAdded, error: unwrapError } = unwrapNativeCollateral(after.collateralAdded.toAssets(), value, sdk.addressProvider.getAddress(AP_WETH_TOKEN, 0));
 	error ??= unwrapError;
 	const assets = account.balances.toAssets(DUST_THRESHOLD);
+	const quotas = account.quotas.toAssets(0n);
 	const assetsChange = account.balances.difference(before.balances).toAssets(DUST_THRESHOLD);
 	const totalValue = assets.reduce((acc, { token, balance }) => {
 		try {
@@ -33,6 +34,7 @@ async function previewAdjustCreditAccount(input, operation, options) {
 			return acc;
 		}
 	}, 0n);
+	const snap = account.toSnapshot(totalValue);
 	return {
 		operation: "AdjustCreditAccount",
 		creditManager: operation.creditManager,
@@ -42,11 +44,16 @@ async function previewAdjustCreditAccount(input, operation, options) {
 		totalValue,
 		debt: account.debt,
 		debtChange: account.debt - before.debt,
-		quotas: account.quotas.toAssets(0n),
+		quotas,
 		quotasChange: account.quotas.difference(before.quotas).toAssets(),
 		assets,
 		assetsChange,
-		error
+		error,
+		healthFactor: sdk.positions.healthFactor(snap),
+		overallApy: 0,
+		borrowRate: sdk.positions.borrowRate(snap),
+		timeToLiquidation: sdk.positions.timeToLiquidation(snap),
+		liquidationPrice: sdk.positions.liquidationPrice(snap)
 	};
 }
 //#endregion

package/dist/esm/preview/preview/previewOpenCreditAccount.js

@@ -1,4 +1,5 @@
 import { AP_WETH_TOKEN } from "../../sdk/constants/address-provider.js";
+import { DUST_THRESHOLD } from "../../sdk/constants/math.js";
 import "../../sdk/index.js";
 import { ERROR_UNPRICEABLE_TOKEN } from "./types.js";
 import { CreditAccountState } from "./CreditAccountState.js";
@@ -25,7 +26,9 @@ async function previewOpenCreditAccount(input, operation) {
 	});
 	const { assets: collateral, error: unwrapError } = unwrapNativeCollateral(state.collateralAdded.toAssets(), value, sdk.addressProvider.getAddress(AP_WETH_TOKEN, 0));
 	error ??= unwrapError ?? priceError;
-	const assets = account.balances.toAssets(1n);
+	const assets = account.balances.toAssets(DUST_THRESHOLD);
+	const quotas = account.quotas.toAssets(0n);
+	const snap = account.toSnapshot(collateralValue + account.totalDebt);
 	return {
 		operation: operation.operation,
 		creditManager: operation.creditManager,
@@ -33,9 +36,14 @@ async function previewOpenCreditAccount(input, operation) {
 		collateral,
 		collateralValue,
 		debt: account.debt,
-		quotas: account.quotas.toAssets(0n),
+		quotas,
 		assets,
-		error
+		error,
+		healthFactor: sdk.positions.healthFactor(snap),
+		overallApy: 0,
+		borrowRate: sdk.positions.borrowRate(snap),
+		timeToLiquidation: sdk.positions.timeToLiquidation(snap),
+		liquidationPrice: sdk.positions.liquidationPrice(snap)
 	};
 }
 /**