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

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

@@ -4,10 +4,10 @@ import { assertMarketOperable } from "./guards.js";
 import { maxProportionalWithdrawal } from "./math.js";
 import { fetchCreditAccountSlice, toCreditAccountSlice } from "./utils/credit-account-slice.js";
 import { previewOpenStrategy } from "./open-strategy.js";
-import { instantOutput } from "./operations.js";
-import { planAddCollateral, planAdjustLeverage, planAdjustLeverageDelayed, planDeposit, planFinishClaimOnly, planFinishDecreaseLeverage, planFinishWithdraw, planRepay, planWithdraw, planWithdrawAsset, planWithdrawDelayed } from "./plan.js";
+import { planAddCollateral, planAdjustLeverage, planAdjustLeverageDelayed, planDeposit, planRepay, planWithdraw, planWithdrawAsset, planWithdrawDelayed } from "./plan.js";
 import { realize } from "./realize.js";
 import { accountView } from "./view.js";
+import { planTail, projectTail } from "./tail.js";
 //#region src/sdk/accounts/intents/index.ts
 /**
 * Previews of everything a wallet can do to an existing credit account.
@@ -80,10 +80,16 @@ var CreditAccountOperationsService = class extends 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;
@@ -96,11 +102,30 @@ var CreditAccountOperationsService = class extends 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 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,
@@ -149,9 +174,10 @@ var CreditAccountOperationsService = class extends 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
@@ -159,24 +185,11 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	* an operation are consumed the same way
 	*/
 	async finishIntent(props) {
-		const { intent, claimable } = props;
-		return plain(await this.#preview(props, () => {
-			const view = accountView(props.creditAccount, props.sdk);
-			const claimed = () => {
-				const output = instantOutput(claimable.outputs);
-				if (!output) throw new IntentPreviewError("insufficientSourceBalance", "finishIntent: the claim credits nothing to spend");
-				return output;
-			};
-			switch (intent.type) {
-				case "WITHDRAW_COLLATERAL": return planFinishWithdraw(intent, claimable, claimed(), view);
-				case "DECREASE_LEVERAGE": return planFinishDecreaseLeverage(claimable, claimed(), view);
-				case "ADD_COLLATERAL":
-				case "INCREASE_LEVERAGE":
-				case "DEPOSIT":
-				case "DEPOSIT_AND_INCREASE_LEVERAGE": return planFinishClaimOnly(claimable);
-				default: throw new Error(`${intent.type} - not implemented`);
-			}
-		}));
+		return plain(await this.#preview(props, () => planTail({
+			intent: props.intent,
+			claimable: props.claimable,
+			view: accountView(props.creditAccount, props.sdk)
+		})));
 	}
 	/**
 	* Previews opening a brand-new leveraged position.
@@ -239,7 +252,23 @@ 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
 export { CreditAccountOperationsService, IntentPreviewError, fetchCreditAccountSlice, toCreditAccountSlice };

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

@@ -114,11 +114,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 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 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 (!eq(T, U) && !(view.rwaAsset && eq(T, view.rwaAsset))) throw new IntentPreviewError("noDelayedRoute", `withdraw: a delayed route cannot pay out in ${T}`);
 	const payoutIsSource = eq(T, S);
 	return [{
@@ -217,6 +231,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 && 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)];
@@ -358,4 +395,4 @@ function assertPositive(amount, flow) {
 	if (amount <= 0n) throw new IntentPreviewError("insufficientSourceBalance", `${flow}: amount must be positive`);
 }
 //#endregion
-export { RAISED, planAddCollateral, planAdjustLeverage, planAdjustLeverageDelayed, planDeposit, planFinishClaimOnly, planFinishDecreaseLeverage, planFinishWithdraw, planRepay, planWithdraw, planWithdrawAsset, planWithdrawDelayed };
+export { RAISED, planAddCollateral, planAdjustLeverage, planAdjustLeverageDelayed, planDeposit, planFinishClaimOnly, planFinishCloseAccount, planFinishDecreaseLeverage, planFinishWithdraw, planRepay, planWithdraw, planWithdrawAsset, planWithdrawDelayed };

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

@@ -24,7 +24,7 @@ async function realize(steps, props) {
 	const { underlying } = creditAccount;
 	const rwaAsset = sdk.tokensMeta.rwaUnderlyings.get(underlying)?.asset;
 	const price = convertAmount(sdk, creditAccount.creditManager);
-	const paths = createRouterPaths({
+	const paths = props.paths ?? createRouterPaths({
 		sdk,
 		creditAccount,
 		slippage
@@ -44,6 +44,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
@@ -145,7 +146,7 @@ async function realize(steps, props) {
 			if (pending) throw new 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(buildCloseSwapOperation({
+				if (leg.calls.length > 0 || leg.minAmount > 0n) push(buildCloseSwapOperation({
 					from: balances,
 					tokenOut: underlying,
 					amountOut: leg.minAmount,
@@ -184,10 +185,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: toTargetDecimals(queued.amount, queued.token, asset.underlying, sdk)
+				} : void 0
 			};
 			raised = instantOutput(preview.outputs)?.amount ?? 0n;
 			break;
@@ -265,18 +271,22 @@ async function realize(steps, props) {
 		liquidationPrice: sdk.positions.liquidationPrice(snapshot)
 	};
 	assertCollateralised(paysOut ? sdk.positions.healthFactor(snapshot, { safePrices: true }) : metrics.healthFactor);
+	const state = {
+		totalValue,
+		accountDebt: debt,
+		leverage: calcPositionLeverage(totalValue, debt),
+		assets,
+		quotas: quotasAfter,
+		...metrics
+	};
 	return {
 		operations,
-		state: {
-			totalValue,
-			accountDebt: debt,
-			leverage: calcPositionLeverage(totalValue, debt),
-			assets,
-			quotas: quotasAfter,
-			...metrics
-		},
+		state,
 		calls: callsOf(operations),
-		delayed
+		delayed: delayed && {
+			...delayed,
+			afterRequest: state
+		}
 	};
 }
 /**

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

@@ -0,0 +1,118 @@
+import { IntentPreviewError } from "./types.js";
+import { createOraclePaths } from "./utils/router-path.js";
+import { planFinishClaimOnly, planFinishCloseAccount, planFinishDecreaseLeverage, planFinishWithdraw } from "./plan.js";
+import { instantOutput } from "./operations.js";
+import { realize } from "./realize.js";
+import { accountView } from "./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 = instantOutput(claimable.outputs);
+		if (!output) throw new IntentPreviewError("insufficientSourceBalance", "finishIntent: the claim credits nothing to spend");
+		return output;
+	};
+	switch (intent.type) {
+		case "WITHDRAW_COLLATERAL": return planFinishWithdraw(intent, claimable, claimed(), view);
+		case "DECREASE_LEVERAGE": return planFinishDecreaseLeverage(claimable, claimed(), view);
+		case "CLOSE_ACCOUNT": return planFinishCloseAccount(intent, claimable, claimed(), view);
+		case "ADD_COLLATERAL":
+		case "INCREASE_LEVERAGE":
+		case "DEPOSIT":
+		case "DEPOSIT_AND_INCREASE_LEVERAGE": return 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: accountView(next, sdk)
+	});
+	const { state, operations } = await realize(steps, {
+		creditAccount: next,
+		sdk,
+		slippage: 0,
+		quotaReserve,
+		paths: 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
+export { planTail, projectTail };

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

@@ -7,5 +7,5 @@ import { calcBorrowedAmountPlusInterestAndFees } from "./borrowed-amount-plus-in
 import { fetchCreditAccountSlice, toCreditAccountSlice } from "./credit-account-slice.js";
 import { OperationLedger } from "./ledger.js";
 import { clearedQuotas, getQuotasForUpdate, quotasAfterUpdate } from "./quotas-for-update.js";
-import { createRouterPaths } from "./router-path.js";
-export { OperationLedger, adjustStateToSnapshot, assembleOperationCalls, calcBorrowedAmountPlusInterestAndFees, clearedQuotas, convertAmount, createRouterPaths, eq, fetchCreditAccountSlice, getQuotasForUpdate, isPhantomToken, isRedemptionPhantomToken, pickFattestNonPhantomToken, quotasAfterUpdate, rankAccountTokens, toCreditAccountSlice, toRouterCaSlice, toTargetDecimals };
+import { createOraclePaths, createRouterPaths } from "./router-path.js";
+export { OperationLedger, adjustStateToSnapshot, assembleOperationCalls, calcBorrowedAmountPlusInterestAndFees, clearedQuotas, convertAmount, createOraclePaths, createRouterPaths, eq, fetchCreditAccountSlice, getQuotasForUpdate, isPhantomToken, isRedemptionPhantomToken, pickFattestNonPhantomToken, quotasAfterUpdate, rankAccountTokens, toCreditAccountSlice, toRouterCaSlice, toTargetDecimals };

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

@@ -1,4 +1,5 @@
 import { toRouterCaSlice } from "./common.js";
+import { convertAmount } from "./convert-amount.js";
 //#region src/sdk/accounts/intents/utils/router-path.ts
 /**
 * The engine's only door to the pathfinder.
@@ -81,5 +82,35 @@ 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 = 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
-export { createRouterPaths };
+export { createOraclePaths, createRouterPaths };

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

@@ -137,6 +137,17 @@ var PriceOracleBaseContract = class extends BaseContract {
 		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/esm/sdk/positions/PositionsService.js

@@ -153,6 +153,24 @@ var PositionsService = class extends 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,
@@ -160,7 +178,7 @@ var PositionsService = class extends SDKConstruct {
 			creditAccount: ca.creditAccount,
 			name: target ? strategyName(this.sdk.tokensMeta.mustGetToken(target), token, this.sdk.chainId) : token.symbol,
 			targetCollateral: target ? this.sdk.tokensMeta.mustGetToken(target) : null,
-			leverage: calcPositionLeverage(ca.totalValue, totalDebtValue),
+			leverage: calcPositionLeverage(totalValue, totalDebtValue),
 			borrowApy: calcBorrowApy(pool.baseInterestRate, suite.creditManager.feeInterest),
 			totalDebt: {
 				token,
@@ -169,21 +187,14 @@ var PositionsService = class extends SDKConstruct {
 			},
 			totalValue: {
 				token,
-				value: ca.totalValue,
-				valueUsd: usdToNumber(ca.totalValueUSD)
+				value: totalValue,
+				valueUsd: usdToNumber(totalValueUSD)
 			},
 			healthFactor: 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/types/new-sdk/prepare/types.d.ts

@@ -73,10 +73,12 @@ type StrategySimulate = {
 };
 /**
  * What the leading half of a delayed operation would yield: the request
- * transaction, plus what it recorded for the tail.
+ * transaction, plus what it recorded for the tail and where that tail leads.
  *
  * Shaped like {@link StrategySimulate} with one field more, so the instant and
- * the delayed route of the same request are compared side by side.
+ * the delayed route of the same request are compared side by side — and they
+ * are meant to be compared on the same footing, so `preview` is the end of the
+ * operation in both, not the end of the transaction.
  **/
 type DelayedStrategySimulate = {
   ok: true;
@@ -85,9 +87,14 @@ type DelayedStrategySimulate = {
    **/
   operations: AccountCalculatorOperation[];
   /**
-   * State once the request executes: the source token is gone and the
-   * withdrawal position stands in its place, with debt untouched — the
-   * repayment belongs to the tail.
+   * Where the operation ends: the account once the redemption has matured,
+   * been claimed and the tail has run — the same place the instant route
+   * reaches in one transaction, which is what makes the two comparable.
+   *
+   * The tail's half of it is an estimate priced by the oracle: the funds it
+   * trades do not exist yet, so no route can be quoted for them. The state
+   * the request alone lands in — source spent, withdrawal position in its
+   * place, debt untouched — is `delayed.afterRequest`.
    **/
   preview: OperationState;
   /**
@@ -398,7 +405,13 @@ interface OpportunitiesPrepare {
    * many-to-one route, the debt is settled in full and every balance left goes
    * to `to`. `tokenOut` is ignored, since the proceeds are already the
    * underlying (unwrapped on an RWA market). The account stays open with
-   * nothing on it. An exit has no delayed route.
+   * nothing on it.
+   *
+   * An exit has both routes as well, which is what lets an account whose
+   * position only redeems through its issuer leave at all: the delayed route
+   * redeems `sourceToken` whole and records the exit, and {@link finalize}
+   * rebuilds it against the account the claim finds — the debt as it stands by
+   * then, whatever else is on the account, everything sold in one route.
    *
    * @see withdrawCollateral to move an asset out without touching debt, which
    * raises leverage instead.
@@ -463,8 +476,9 @@ interface OpportunitiesPrepare {
   /**
    * The tail of a delayed route: claim the matured withdrawal, then whatever the
    * operation that requested it still owes — repaying debt and paying the wallet
-   * out for a withdrawal, repaying alone for a deleveraging, nothing beyond the
-   * claim for the rest.
+   * out for a withdrawal, repaying alone for a deleveraging, selling the rest of
+   * the account and settling the loan for an exit, nothing beyond the claim for
+   * the rest.
    *
    * The route is requested by {@link withdrawStrategy} or
    * {@link adjustLeverage}, whose `delayed` branch is the transaction that

package/dist/types/sdk/accounts/intents/index.d.ts

@@ -75,10 +75,16 @@ declare class CreditAccountOperationsService extends 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
    */
   startDelayedIntent(props: StartIntentProps & {
     intent: DelayableIntent;
@@ -109,9 +115,10 @@ declare class CreditAccountOperationsService extends 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

package/dist/types/sdk/accounts/intents/plan.d.ts

@@ -153,7 +153,8 @@ declare function planWithdraw(intent: Omit<WithdrawStrategyIntent, "type">, 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.
  */
 declare function planWithdrawDelayed(intent: Omit<WithdrawStrategyIntent, "type">, view: AccountView): Step[];
 /**
@@ -185,7 +186,22 @@ declare function planFinishWithdraw(intent: {
   token: Address;
   amount: bigint;
 }, view: AccountView): Step[];
+/**
+ * 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.
+ */
+declare function planFinishCloseAccount(intent: {
+  to: Address;
+}, claimable: ClaimableWithdrawal, claimed: {
+  token: Address;
+  amount: bigint;
+}, view: AccountView): Step[];
 /** Nothing is owed beyond the claim: the tokens land and quotas catch up. */
 declare function planFinishClaimOnly(claimable: ClaimableWithdrawal): Step[];
 //#endregion
-export { AccountView, Amount, RAISED, Step, planAddCollateral, planAdjustLeverage, planAdjustLeverageDelayed, planDeposit, planFinishClaimOnly, planFinishDecreaseLeverage, planFinishWithdraw, planRepay, planWithdraw, planWithdrawAsset, planWithdrawDelayed };
+export { AccountView, Amount, RAISED, Step, planAddCollateral, planAdjustLeverage, planAdjustLeverageDelayed, planDeposit, planFinishClaimOnly, planFinishCloseAccount, planFinishDecreaseLeverage, planFinishWithdraw, planRepay, planWithdraw, planWithdrawAsset, planWithdrawDelayed };

package/dist/types/sdk/accounts/intents/realize.d.ts

@@ -4,6 +4,7 @@ import { CreditAccountSlice, DelayedStart, OperationState } from "./types.js";
 import { AccountCalculatorOperation } from "./operations.js";
 import "../../index.js";
 import { Step } from "./plan.js";
+import { RouterPaths } from "./utils/router-path.js";
 //#region src/sdk/accounts/intents/realize.d.ts
 interface RealizeProps {
   creditAccount: CreditAccountSlice;
@@ -12,6 +13,12 @@ interface RealizeProps {
   slippage: number;
   /** Extra quota headroom in PERCENTAGE_FORMAT. */
   quotaReserve: number | undefined;
+  /**
+   * Where routed legs are quoted. Defaults to the pathfinder, which is what
+   * anything that will be sent needs; a walk that only projects a state passes
+   * `createOraclePaths` instead.
+   */
+  paths?: RouterPaths;
 }
 interface Realized {
   operations: AccountCalculatorOperation[];