@gearbox-protocol/sdk 15.1.0-next.21 → 15.1.0-next.23

package/dist/cjs/new-sdk/prepare/PrepareApi.js

@@ -307,12 +307,12 @@ function slice(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.
+* a withdrawal requested without an intent, or one read through a compressor
+* too old to report it. Every intent the engine records can be finished,
+* `CLOSE_ACCOUNT` included.
 **/
 function resumable(intent) {
-	if (!intent || intent.type === "CLOSE_ACCOUNT") return;
-	return intent;
+	return intent ?? void 0;
 }
 /**
 * Picks the route the operation takes out of `tokenIn`, as a value rather than

package/dist/cjs/sdk/accounts/intents/index.js

@@ -5,10 +5,10 @@ const require_sdk_accounts_intents_guards = require("./guards.js");
 const require_sdk_accounts_intents_math = require("./math.js");
 const require_sdk_accounts_intents_utils_credit_account_slice = require("./utils/credit-account-slice.js");
 const require_sdk_accounts_intents_open_strategy = require("./open-strategy.js");
-const require_sdk_accounts_intents_operations = require("./operations.js");
 const require_sdk_accounts_intents_plan = require("./plan.js");
 const require_sdk_accounts_intents_realize = require("./realize.js");
 const require_sdk_accounts_intents_view = require("./view.js");
+const require_sdk_accounts_intents_tail = require("./tail.js");
 //#region src/sdk/accounts/intents/index.ts
 /**
 * Previews of everything a wallet can do to an existing credit account.
@@ -81,10 +81,16 @@ var CreditAccountOperationsService = class extends require_sdk_base_SDKConstruct
 	* {@link intentRoutes}; this is the one to call when the delayed route is the
 	* only one of interest.
 	*
+	* `preview` is where the intent ends — the account once the redemption has
+	* matured, been claimed and the tail has run — because that is what the
+	* caller asked for; the half-way state the request itself lands in is
+	* `delayed.afterRequest`. Both are validated, so a request whose tail could
+	* not be completed is refused instead of started.
+	*
 	* @param props - Intent plus account slice, quota reserve and slippage
-	* @returns The request transaction and what it recorded for the tail, or
-	* `{ ok: false, reason }` — `noDelayedRoute` when this route does not exist
-	* for the account at all
+	* @returns The request transaction, the state it ends in and what it recorded
+	* for the tail, or `{ ok: false, reason }` — `noDelayedRoute` when this route
+	* does not exist for the account at all
 	*/
 	async startDelayedIntent(props) {
 		const { intent } = props;
@@ -97,11 +103,30 @@ var CreditAccountOperationsService = class extends require_sdk_base_SDKConstruct
 			}
 		});
 		if (!result.ok) return result;
-		if (!result.delayed) throw new Error("startDelayedIntent: plan started no withdrawal");
-		return {
+		const { delayed } = result;
+		if (!delayed) throw new Error("startDelayedIntent: plan started no withdrawal");
+		if (delayed.settlement === "instant") return {
 			...result,
-			delayed: result.delayed
+			delayed
 		};
+		const request = result.operations.find((op) => op.type === "startDelayedWithdrawal");
+		if (!request) throw new Error("startDelayedIntent: no request among the operations");
+		try {
+			const tail = await require_sdk_accounts_intents_tail.projectTail({
+				request,
+				delayed,
+				creditAccount: props.creditAccount,
+				sdk: props.sdk,
+				quotaReserve: props.quotaReserve
+			});
+			return {
+				...result,
+				preview: tail.state,
+				delayed
+			};
+		} catch (e) {
+			return asFailure(e);
+		}
 	}
 	/**
 	* Previews a delayable intent both ways at once: settled by the router now,
@@ -150,9 +175,10 @@ var CreditAccountOperationsService = class extends require_sdk_base_SDKConstruct
 	* Previews the tail of a delayed intent, once the withdrawal it started has
 	* matured: the claim, then whatever the intent still owes.
 	*
-	* Serves the two operations that can genuinely be interrupted by a delay — a
-	* withdrawal and a deleveraging. For the rest, the claim is the whole tail:
-	* the tokens land on the account and only their quota has to catch up.
+	* Serves the three operations that can genuinely be interrupted by a delay —
+	* a withdrawal, a deleveraging and an exit. For the rest, the claim is the
+	* whole tail: the tokens land on the account and only their quota has to
+	* catch up.
 	*
 	* @param props - The recorded intent, the account slice as it stands now, and
 	* the matured claimable
@@ -160,24 +186,11 @@ var CreditAccountOperationsService = class extends require_sdk_base_SDKConstruct
 	* an operation are consumed the same way
 	*/
 	async finishIntent(props) {
-		const { intent, claimable } = props;
-		return plain(await this.#preview(props, () => {
-			const view = require_sdk_accounts_intents_view.accountView(props.creditAccount, props.sdk);
-			const claimed = () => {
-				const output = require_sdk_accounts_intents_operations.instantOutput(claimable.outputs);
-				if (!output) throw new require_sdk_accounts_intents_types.IntentPreviewError("insufficientSourceBalance", "finishIntent: the claim credits nothing to spend");
-				return output;
-			};
-			switch (intent.type) {
-				case "WITHDRAW_COLLATERAL": return require_sdk_accounts_intents_plan.planFinishWithdraw(intent, claimable, claimed(), view);
-				case "DECREASE_LEVERAGE": return require_sdk_accounts_intents_plan.planFinishDecreaseLeverage(claimable, claimed(), view);
-				case "ADD_COLLATERAL":
-				case "INCREASE_LEVERAGE":
-				case "DEPOSIT":
-				case "DEPOSIT_AND_INCREASE_LEVERAGE": return require_sdk_accounts_intents_plan.planFinishClaimOnly(claimable);
-				default: throw new Error(`${intent.type} - not implemented`);
-			}
-		}));
+		return plain(await this.#preview(props, () => require_sdk_accounts_intents_tail.planTail({
+			intent: props.intent,
+			claimable: props.claimable,
+			view: require_sdk_accounts_intents_view.accountView(props.creditAccount, props.sdk)
+		})));
 	}
 	/**
 	* Previews opening a brand-new leveraged position.
@@ -240,8 +253,24 @@ function asFailure(e) {
 		ok: false,
 		reason: e.reason
 	};
+	if (isUnroutable(e)) return {
+		ok: false,
+		reason: "unsupportedTokenPair"
+	};
 	throw e;
 }
+/**
+* How the pathfinder says there is no route: it reverts instead of answering
+* with an empty path, so viem raises a contract error where the rest of the
+* engine raises an {@link IntentPreviewError}. Nothing is wrong — the trade
+* asked for cannot be made, which is a refusal the caller can act on, and one
+* `intentRoutes` in particular must keep as a value so the other route can
+* still be offered.
+*/
+function isUnroutable(e) {
+	for (let cause = e; cause instanceof Error; cause = cause.cause) if (cause.message.includes("no optimal edge found")) return true;
+	return false;
+}
 //#endregion
 exports.CreditAccountOperationsService = CreditAccountOperationsService;
 exports.IntentPreviewError = require_sdk_accounts_intents_types.IntentPreviewError;

package/dist/cjs/sdk/accounts/intents/plan.js

@@ -115,11 +115,25 @@ function planWithdraw(intent, view) {
 *
 * The tail is planned at claim time by {@link planFinishWithdraw}, from the
 * intent this request records — only then is the claimed amount, and the token
-* it arrived in, known.
+* it arrived in, known. An exit records {@link planFinishCloseAccount}'s intent
+* instead, and rebuilds itself from the account rather than from the request.
 */
 function planWithdrawDelayed(intent, view) {
 	const { U, T, S, WU, dD, all } = withdrawShape(intent, view);
-	if (all) throw new require_sdk_accounts_intents_types.IntentPreviewError("noDelayedRoute", "withdraw: taking the whole net value cannot be started as a redemption");
+	if (all) {
+		const held = view.balanceOf(S);
+		if (held <= 0n) throw new require_sdk_accounts_intents_types.IntentPreviewError("insufficientSourceBalance", `withdraw: account holds no ${S} to redeem`);
+		return [{
+			kind: "request",
+			token: S,
+			amount: held,
+			reserve: 0n,
+			record: {
+				type: "CLOSE_ACCOUNT",
+				to: intent.to
+			}
+		}];
+	}
 	if (!require_sdk_accounts_intents_utils_common.eq(T, U) && !(view.rwaAsset && require_sdk_accounts_intents_utils_common.eq(T, view.rwaAsset))) throw new require_sdk_accounts_intents_types.IntentPreviewError("noDelayedRoute", `withdraw: a delayed route cannot pay out in ${T}`);
 	const payoutIsSource = require_sdk_accounts_intents_utils_common.eq(T, S);
 	return [{
@@ -218,6 +232,29 @@ function planFinishWithdraw(intent, claimable, claimed, view) {
 		}, intent.to)
 	];
 }
+/**
+* The tail of an exit: the claim lands, everything the account holds is sold
+* into the underlying, the loan is settled out of the proceeds and the rest
+* goes to the wallet. The account survives it, empty and owing nothing.
+*
+* Nothing is quoted from the request — the same shape {@link planWithdraw}
+* builds for an instant exit is rebuilt here against the account as it stands
+* now, which is the only state that can name these amounts.
+*/
+function planFinishCloseAccount(intent, claimable, claimed, view) {
+	const wrap = view.rwaAsset && require_sdk_accounts_intents_utils_common.eq(claimed.token, view.rwaAsset) ? [convert(claimed.token, view.underlying, view.balanceOf(claimed.token) + claimed.amount)] : [];
+	return [
+		claim(claimable),
+		...wrap,
+		clearQuotas(),
+		{ kind: "closeAll" },
+		...view.debt > 0n ? [repay(view.debt)] : [],
+		{
+			kind: "sweep",
+			to: intent.to
+		}
+	];
+}
 /** Nothing is owed beyond the claim: the tokens land and quotas catch up. */
 function planFinishClaimOnly(claimable) {
 	return [claim(claimable)];
@@ -365,6 +402,7 @@ exports.planAdjustLeverage = planAdjustLeverage;
 exports.planAdjustLeverageDelayed = planAdjustLeverageDelayed;
 exports.planDeposit = planDeposit;
 exports.planFinishClaimOnly = planFinishClaimOnly;
+exports.planFinishCloseAccount = planFinishCloseAccount;
 exports.planFinishDecreaseLeverage = planFinishDecreaseLeverage;
 exports.planFinishWithdraw = planFinishWithdraw;
 exports.planRepay = planRepay;

package/dist/cjs/sdk/accounts/intents/realize.js

@@ -25,7 +25,7 @@ async function realize(steps, props) {
 	const { underlying } = creditAccount;
 	const rwaAsset = sdk.tokensMeta.rwaUnderlyings.get(underlying)?.asset;
 	const price = require_sdk_accounts_intents_utils_convert_amount.convertAmount(sdk, creditAccount.creditManager);
-	const paths = require_sdk_accounts_intents_utils_router_path.createRouterPaths({
+	const paths = props.paths ?? require_sdk_accounts_intents_utils_router_path.createRouterPaths({
 		sdk,
 		creditAccount,
 		slippage
@@ -45,6 +45,7 @@ async function realize(steps, props) {
 	};
 	/** Output of the last convert or claim, for `RAISED` amounts. */
 	let raised = 0n;
+	/** The request, before the walk's end state can be attached to it. */
 	let delayed;
 	/**
 	* Set by a `clearQuotas` step, which settles the quotas mid-walk instead of
@@ -146,7 +147,7 @@ async function realize(steps, props) {
 			if (pending) throw new require_sdk_accounts_intents_types.IntentPreviewError("withdrawalInProgress", `closeAll: ${pending.token} is a pending withdrawal, claim it first`);
 			if (balances.length > 0) {
 				const leg = await paths.closeAll({ balances });
-				if (leg.calls.length > 0) push(require_sdk_accounts_intents_operations.buildCloseSwapOperation({
+				if (leg.calls.length > 0 || leg.minAmount > 0n) push(require_sdk_accounts_intents_operations.buildCloseSwapOperation({
 					from: balances,
 					tokenOut: underlying,
 					amountOut: leg.minAmount,
@@ -185,10 +186,15 @@ async function realize(steps, props) {
 				creditAccount,
 				sdk
 			}));
+			const queued = preview.outputs.find((o) => o.isDelayed);
 			delayed = {
 				record: step.record,
 				claimableAt: preview.claimableAt,
-				settlement: preview.outputs.some((o) => o.isDelayed) ? "delayed" : "instant"
+				settlement: queued ? "delayed" : "instant",
+				claim: queued ? {
+					token: asset.underlying.toLowerCase(),
+					amount: require_sdk_accounts_intents_utils_common.toTargetDecimals(queued.amount, queued.token, asset.underlying, sdk)
+				} : void 0
 			};
 			raised = require_sdk_accounts_intents_operations.instantOutput(preview.outputs)?.amount ?? 0n;
 			break;
@@ -266,18 +272,22 @@ async function realize(steps, props) {
 		liquidationPrice: sdk.positions.liquidationPrice(snapshot)
 	};
 	require_sdk_accounts_intents_guards.assertCollateralised(paysOut ? sdk.positions.healthFactor(snapshot, { safePrices: true }) : metrics.healthFactor);
+	const state = {
+		totalValue,
+		accountDebt: debt,
+		leverage: require_sdk_market_math.calcPositionLeverage(totalValue, debt),
+		assets,
+		quotas: quotasAfter,
+		...metrics
+	};
 	return {
 		operations,
-		state: {
-			totalValue,
-			accountDebt: debt,
-			leverage: require_sdk_market_math.calcPositionLeverage(totalValue, debt),
-			assets,
-			quotas: quotasAfter,
-			...metrics
-		},
+		state,
 		calls: callsOf(operations),
-		delayed
+		delayed: delayed && {
+			...delayed,
+			afterRequest: state
+		}
 	};
 }
 /**

package/dist/cjs/sdk/accounts/intents/tail.js

@@ -0,0 +1,120 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_accounts_intents_types = require("./types.js");
+const require_sdk_accounts_intents_utils_router_path = require("./utils/router-path.js");
+const require_sdk_accounts_intents_plan = require("./plan.js");
+const require_sdk_accounts_intents_operations = require("./operations.js");
+const require_sdk_accounts_intents_realize = require("./realize.js");
+const require_sdk_accounts_intents_view = require("./view.js");
+//#region src/sdk/accounts/intents/tail.ts
+/**
+* The second half of a delayed intent: the claim, then whatever the intent
+* still owes.
+*
+* Shared by the two callers that need it and must not disagree — the tail as
+* it is previewed days later against the account that really exists, and the
+* tail as it is projected the moment the request is made.
+*/
+function planTail(args) {
+	const { intent, claimable, view } = args;
+	const claimed = () => {
+		const output = require_sdk_accounts_intents_operations.instantOutput(claimable.outputs);
+		if (!output) throw new require_sdk_accounts_intents_types.IntentPreviewError("insufficientSourceBalance", "finishIntent: the claim credits nothing to spend");
+		return output;
+	};
+	switch (intent.type) {
+		case "WITHDRAW_COLLATERAL": return require_sdk_accounts_intents_plan.planFinishWithdraw(intent, claimable, claimed(), view);
+		case "DECREASE_LEVERAGE": return require_sdk_accounts_intents_plan.planFinishDecreaseLeverage(claimable, claimed(), view);
+		case "CLOSE_ACCOUNT": return require_sdk_accounts_intents_plan.planFinishCloseAccount(intent, claimable, claimed(), view);
+		case "ADD_COLLATERAL":
+		case "INCREASE_LEVERAGE":
+		case "DEPOSIT":
+		case "DEPOSIT_AND_INCREASE_LEVERAGE": return require_sdk_accounts_intents_plan.planFinishClaimOnly(claimable);
+		default: throw new Error(`${intent.type} - not implemented`);
+	}
+}
+/**
+* Where a delayed intent ends up, worked out at the moment it is started.
+*
+* A request is only half a withdrawal, so the state it lands in is not the
+* answer to "what does this do to my position": the debt is still there, the
+* payout has not been made, and the position sits in a phantom token. What the
+* caller means is the far side — and that side can be walked now, because the
+* request already fixes the claim it will be finished from.
+*
+* So the same tail {@link planTail} builds at claim time is built here against
+* the account as the request leaves it, with the claim it is expected to bring,
+* and walked by the same realiser — with one substitution: routed legs are
+* priced by the oracle rather than the pathfinder, since the funds they trade
+* do not exist yet and no calldata is being produced. The result is an
+* estimate that the engine's guards are nevertheless applied to, so a request
+* that would strand the account is refused before it is sent rather than
+* discovered days later.
+*/
+async function projectTail(args) {
+	const { request, delayed, creditAccount, sdk, quotaReserve } = args;
+	const { claim } = delayed;
+	const queued = request.outputs.find((o) => o.isDelayed);
+	if (!queued || !claim) throw new Error("projectTail: the request queued nothing to claim");
+	const next = sliceAfter(creditAccount, delayed.afterRequest);
+	const steps = planTail({
+		intent: delayed.record,
+		claimable: projectedClaimable(request, queued.token, queued.amount, claim),
+		view: require_sdk_accounts_intents_view.accountView(next, sdk)
+	});
+	const { state, operations } = await require_sdk_accounts_intents_realize.realize(steps, {
+		creditAccount: next,
+		sdk,
+		slippage: 0,
+		quotaReserve,
+		paths: require_sdk_accounts_intents_utils_router_path.createOraclePaths({
+			sdk,
+			creditAccount: next
+		})
+	});
+	return {
+		state,
+		operations
+	};
+}
+/**
+* The matured withdrawal the tail will be built from, as the request implies
+* it: the phantom it created is burned and the venue's payout takes its place.
+* It carries no claim calls — those are read from the chain when the claim is
+* real, and nothing here is going to be sent.
+*/
+function projectedClaimable(request, phantom, phantomAmount, claim) {
+	return {
+		token: request.token,
+		withdrawalPhantomToken: phantom,
+		withdrawalTokenSpent: phantomAmount,
+		outputs: [{
+			token: claim.token,
+			amount: claim.amount,
+			isDelayed: false
+		}],
+		claimCalls: []
+	};
+}
+/**
+* The account as one walk left it, shaped as the slice the next walk reads.
+* Masks are carried over from the tokens the account already held; one it
+* picked up along the way has none to carry, which only the router slice
+* would have used.
+*/
+function sliceAfter(creditAccount, after) {
+	const masks = new Map(creditAccount.tokens.map((t) => [t.token.toLowerCase(), t.mask]));
+	return {
+		...creditAccount,
+		accountDebt: after.accountDebt,
+		tokens: after.assets.map((a) => ({
+			token: a.token,
+			balance: a.balance,
+			quota: after.quotas[a.token]?.balance ?? 0n,
+			mask: masks.get(a.token) ?? 0n,
+			success: true
+		}))
+	};
+}
+//#endregion
+exports.planTail = planTail;
+exports.projectTail = projectTail;

package/dist/cjs/sdk/accounts/intents/utils/index.js

@@ -15,6 +15,7 @@ exports.assembleOperationCalls = require_sdk_accounts_intents_utils_assemble_ope
 exports.calcBorrowedAmountPlusInterestAndFees = require_sdk_accounts_intents_utils_borrowed_amount_plus_interest_and_fees.calcBorrowedAmountPlusInterestAndFees;
 exports.clearedQuotas = require_sdk_accounts_intents_utils_quotas_for_update.clearedQuotas;
 exports.convertAmount = require_sdk_accounts_intents_utils_convert_amount.convertAmount;
+exports.createOraclePaths = require_sdk_accounts_intents_utils_router_path.createOraclePaths;
 exports.createRouterPaths = require_sdk_accounts_intents_utils_router_path.createRouterPaths;
 exports.eq = require_sdk_accounts_intents_utils_common.eq;
 exports.fetchCreditAccountSlice = require_sdk_accounts_intents_utils_credit_account_slice.fetchCreditAccountSlice;

package/dist/cjs/sdk/accounts/intents/utils/router-path.js

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_sdk_accounts_intents_utils_common = require("./common.js");
+const require_sdk_accounts_intents_utils_convert_amount = require("./convert-amount.js");
 //#region src/sdk/accounts/intents/utils/router-path.ts
 /**
 * The engine's only door to the pathfinder.
@@ -82,5 +83,36 @@ function createRouterPaths(args) {
 		}
 	};
 }
+/**
+* The same door, priced by the oracle and opening onto no calldata.
+*
+* For a leg that cannot be quoted yet: the tail of a redemption trades funds
+* that do not exist, along a route the pathfinder will only be able to build
+* once they do. Asking it now would price a swap of nothing, so the amounts
+* come from the oracle instead — an estimate with no slippage floor, which is
+* all a projection days out can honestly be — and the walk yields a state
+* rather than a transaction.
+*/
+function createOraclePaths(args) {
+	const { sdk, creditAccount } = args;
+	const price = require_sdk_accounts_intents_utils_convert_amount.convertAmount(sdk, creditAccount.creditManager);
+	const estimate = (amount) => ({
+		amount,
+		minAmount: amount,
+		calls: []
+	});
+	return {
+		async swap({ tokenIn, tokenOut, amount }) {
+			return estimate(amount > 0n ? price(tokenIn, tokenOut, amount) : 0n);
+		},
+		async closeAll({ balances }) {
+			return estimate(balances.reduce((sum, b) => sum + price(b.token, creditAccount.underlying, b.balance), 0n));
+		},
+		async openStrategy() {
+			throw new Error("oracle paths: opening a position is never projected");
+		}
+	};
+}
 //#endregion
+exports.createOraclePaths = createOraclePaths;
 exports.createRouterPaths = createRouterPaths;

package/dist/cjs/sdk/market/oracle/PriceOracleBaseContract.js

@@ -138,6 +138,17 @@ var PriceOracleBaseContract = class extends require_sdk_base_BaseContract.BaseCo
 		return amount * 10n ** BigInt(this.tokensMeta.decimals(token)) / price;
 	}
 	/**
+	* {@inheritDoc IPriceOracleContract.safeConvert}
+	**/
+	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;
+		}
+	}
+	/**
 	* {@inheritDoc IPriceOracleContract.safeConvertToUSD}
 	**/
 	safeConvertToUSD(token, amount) {

package/dist/cjs/sdk/positions/PositionsService.js

@@ -154,6 +154,24 @@ var PositionsService = class extends require_sdk_base_SDKConstruct.SDKConstruct
 		const borrowRate = this.borrowRate(snapshot);
 		const timeToLiquidation = this.timeToLiquidation(snapshot);
 		const liquidationPrice = this.liquidationPrice(snapshot);
+		const zeroDebt = ca.debt === 0n;
+		const collaterals = [];
+		let totalValue = zeroDebt ? 0n : ca.totalValue;
+		let totalValueUSD = zeroDebt ? 0n : ca.totalValueUSD;
+		for (const t of ca.tokens) {
+			if (t.balance <= 10n) continue;
+			collaterals.push({
+				collateral: priceOracle.toTokenAmount(t.token, t.balance),
+				quota: priceOracle.toTokenAmount(market.underlying, t.quota),
+				withdrawals: withdrawals.get(t.token) ?? []
+			});
+			if (zeroDebt) {
+				const value = priceOracle.safeConvert(t.token, market.underlying, t.balance) || 0n;
+				totalValue += value;
+				const usd = priceOracle.safeConvertToUSD(t.token, t.balance) || 0n;
+				totalValueUSD += usd;
+			}
+		}
 		return {
 			kind: "strategy",
 			chainId: this.sdk.chainId,
@@ -161,7 +179,7 @@ var PositionsService = class extends require_sdk_base_SDKConstruct.SDKConstruct
 			creditAccount: ca.creditAccount,
 			name: target ? require_sdk_market_strategyName.strategyName(this.sdk.tokensMeta.mustGetToken(target), token, this.sdk.chainId) : token.symbol,
 			targetCollateral: target ? this.sdk.tokensMeta.mustGetToken(target) : null,
-			leverage: require_sdk_market_math.calcPositionLeverage(ca.totalValue, totalDebtValue),
+			leverage: require_sdk_market_math.calcPositionLeverage(totalValue, totalDebtValue),
 			borrowApy: require_sdk_market_math.calcBorrowApy(pool.baseInterestRate, suite.creditManager.feeInterest),
 			totalDebt: {
 				token,
@@ -170,21 +188,14 @@ var PositionsService = class extends require_sdk_base_SDKConstruct.SDKConstruct
 			},
 			totalValue: {
 				token,
-				value: ca.totalValue,
-				valueUsd: require_sdk_market_math.usdToNumber(ca.totalValueUSD)
+				value: totalValue,
+				valueUsd: require_sdk_market_math.usdToNumber(totalValueUSD)
 			},
 			healthFactor: require_sdk_market_math.healthFactorBps(ca.healthFactor),
 			borrowRate,
 			timeToLiquidation,
 			liquidationPrice,
-			collaterals: ca.tokens.flatMap((t) => {
-				if (t.balance <= 10n) return [];
-				return [{
-					collateral: priceOracle.toTokenAmount(t.token, t.balance),
-					quota: priceOracle.toTokenAmount(market.underlying, t.quota),
-					withdrawals: withdrawals.get(t.token) ?? []
-				}];
-			})
+			collaterals
 		};
 	}
 	/**

package/dist/esm/new-sdk/prepare/PrepareApi.js

@@ -306,12 +306,12 @@ function slice(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.
+* a withdrawal requested without an intent, or one read through a compressor
+* too old to report it. Every intent the engine records can be finished,
+* `CLOSE_ACCOUNT` included.
 **/
 function resumable(intent) {
-	if (!intent || intent.type === "CLOSE_ACCOUNT") return;
-	return intent;
+	return intent ?? void 0;
 }
 /**
 * Picks the route the operation takes out of `tokenIn`, as a value rather than