@gearbox-protocol/sdk 15.1.0-next.22 → 15.1.0-next.24

package/dist/cjs/sdk/market/math.js

@@ -75,6 +75,70 @@ function calcBorrowApy(baseInterestRate, feeInterest) {
 	return rayToBps(baseInterestRate * (require_sdk_constants_math.PERCENTAGE_FACTOR + BigInt(feeInterest)) / require_sdk_constants_math.PERCENTAGE_FACTOR);
 }
 /**
+* Annual quota cost of a collateral, in basis points:
+* `quotaRate × (1 + feeInterest)` — the quoted rate plus the protocol's cut of
+* the accrued quota interest, matching {@link calcBorrowApy}.
+*
+* @param quotaRate - Pool quota keeper rate in basis points, without the fee.
+* @param feeInterest - Credit manager interest fee in basis points.
+*
+* @example
+* ```ts
+* // quotaRate: 200 bps = 2%, feeInterest: 2500 bps = 25%
+* calcQuotaRate(200, 2500) // 2% × 1.25 = 250 bps = 2.5%
+* ```
+**/
+function calcQuotaRate(quotaRate, feeInterest) {
+	return Math.round(quotaRate * (FULL + feeInterest) / FULL);
+}
+/**
+* Extra quota, as a fraction of equity, that an aggressive position quotes
+* above the debt it actually owes. Matches {@link MAX_LEVERAGE_BUFFER_BPS}.
+**/
+const DEFAULT_QUOTA_BUFFER_BPS = 500;
+/**
+* Quoted amount per unit of equity at the given leverage and quota mode.
+* Dimensionless: `1` means the quota equals the user's equity.
+**/
+function calcQuotaMultiplier(leverage, lt, quotaMode = "safe") {
+	switch (quotaMode) {
+		case "min": return leverage - 1;
+		case "safe": return leverage * lt / FULL;
+		case "aggressive": return (1 + 500 / FULL) * (leverage - 1);
+	}
+}
+/**
+* Annual cost of credit on the user's equity, in basis points, at a given
+* leverage and quota mode: base interest on the borrowed part plus quota
+* interest on the quoted amount. Both rates already include the protocol's
+* interest fee.
+*
+* @param opportunity - Borrow APY, quota rate, and liquidation threshold.
+* @param leverage - Total-value leverage, same scale as {@link Leverage}.
+* @param mode - How much quota the position quotes, see {@link QuotaMode}.
+**/
+function calcEffectiveBorrowApy(opportunity, leverage, mode = "safe") {
+	const { borrowApy, quotaRate, liquidationThreshold } = opportunity;
+	return Math.round(borrowApy * (leverage - 1) + quotaRate * calcQuotaMultiplier(leverage, liquidationThreshold, mode));
+}
+/**
+* Net yield of a strategy on the user's equity, in basis points, at a given
+* leverage and quota mode:
+* `leverage × totalCollateralApy − effectiveBorrowApy`. Collateral yield is
+* on the whole position; borrow and quota interest are those of
+* {@link calcEffectiveBorrowApy}.
+*
+* @param opportunity - Borrow APY, quota rate, and liquidation threshold.
+* @param totalCollateralApy - Collateral yield the caller chose, typically
+* `totalApy` of {@link StrategyOpportunity.collateralApy} or
+* {@link StrategyOpportunity.collateralApyAvg7D}.
+* @param leverage - Total-value leverage, same scale as {@link Leverage}.
+* @param mode - How much quota the position quotes, see {@link QuotaMode}.
+**/
+function calcNetStrategyApy(opportunity, totalCollateralApy, leverage, mode = "safe") {
+	return Math.round(leverage * totalCollateralApy - calcEffectiveBorrowApy(opportunity, leverage, mode));
+}
+/**
 * 5% safety margin subtracted from 100% in {@link calcMaxLeverage}, so a
 * maxed position opens with HF slightly above 1.
 **/
@@ -91,9 +155,11 @@ const MAX_LEVERAGE_BUFFER_BPS = 500;
 * // liquidationThreshold: 9000 bps = 90%
 * calcMaxLeverage(9000) // (1 − 0.05) / (1 − 0.9) = 9.5x total exposure
 * ```
+* @throws If `liquidationThreshold` is 100% or more, which would make
+* leverage unbounded.
 **/
 function calcMaxLeverage(liquidationThreshold) {
-	if (liquidationThreshold >= FULL) return 0;
+	if (liquidationThreshold >= FULL) throw new Error("cannot compute max leverage: liquidation threshold is 100% or more");
 	const leverage = (FULL - 500) / (FULL - liquidationThreshold);
 	return Math.max(leverage, 1);
 }
@@ -135,21 +201,6 @@ function calcPositionLeverage(totalValue, totalDebt) {
 	return Number(totalValue) / Number(equity);
 }
 /**
-* Annual quota cost on equity, in basis points:
-* `quotaRate × (1 + feeInterest) × leverage`. Quota accrues on the whole
-* quoted position, and the DAO takes `feeInterest` of it as with base interest.
-*
-* @example
-* ```ts
-* // quotaRate: 200 bps = 2%, feeInterest: 2500 bps = 25%, leverage: 9.5x
-* calcAdditionalBorrowApy(200, 2500, 9.5) // 2% × 1.25 × 9.5 = 2375 bps = 23.75%
-* ```
-**/
-function calcAdditionalBorrowApy(quotaRate, feeInterest, leverage) {
-	if (!Number.isFinite(leverage) || leverage <= 0) return 0;
-	return Math.round(quotaRate * (1 + feeInterest / FULL) * leverage);
-}
-/**
 * {@link PERCENTAGE_FACTOR} less a 0.1% safety buffer.
 *
 * Partial liquidation amounts are computed off prices that can drift between
@@ -205,12 +256,15 @@ function optimalHFForPartialLiquidation(borrowRate) {
 	return require_sdk_constants_math.PERCENTAGE_FACTOR + (borrowRate < 100n ? borrowRate : 100n);
 }
 //#endregion
+exports.DEFAULT_QUOTA_BUFFER_BPS = DEFAULT_QUOTA_BUFFER_BPS;
 exports.MAX_LEVERAGE_BUFFER_BPS = MAX_LEVERAGE_BUFFER_BPS;
 exports.PARTIAL_LIQUIDATION_BUFFER_BPS = PARTIAL_LIQUIDATION_BUFFER_BPS;
-exports.calcAdditionalBorrowApy = calcAdditionalBorrowApy;
 exports.calcBorrowApy = calcBorrowApy;
+exports.calcEffectiveBorrowApy = calcEffectiveBorrowApy;
 exports.calcMaxLeverage = calcMaxLeverage;
+exports.calcNetStrategyApy = calcNetStrategyApy;
 exports.calcPositionLeverage = calcPositionLeverage;
+exports.calcQuotaRate = calcQuotaRate;
 exports.calcUtilization = calcUtilization;
 exports.healthFactorBps = healthFactorBps;
 exports.minSeizedAmount = minSeizedAmount;

package/dist/esm/dev/AccountOpener.js

@@ -1,9 +1,9 @@
+import { ierc20Abi } from "../abi/iERC20.js";
 import { iCreditFacadeV310Abi } from "../abi/310/generated.js";
 import { AddressMap } from "../sdk/utils/AddressMap.js";
 import { AddressSet } from "../sdk/utils/AddressSet.js";
 import { AssetsMap } from "../sdk/utils/AssetsMap.js";
 import { childLogger } from "../sdk/utils/childLogger.js";
-import { ierc20Abi } from "../abi/iERC20.js";
 import "../sdk/constants/addresses.js";
 import { MAX_UINT256, PERCENTAGE_FACTOR } from "../sdk/constants/math.js";
 import { SDKConstruct } from "../sdk/base/SDKConstruct.js";

package/dist/esm/dev/withdrawalUtils.js

@@ -1,6 +1,6 @@
+import { iWithdrawalCompressorV313Abi } from "../abi/IWithdrawalCompressorV313.js";
 import { getNetworkType } from "../sdk/chain/chains.js";
 import { getWithdrawalCompressorAddress } from "../sdk/accounts/withdrawal-compressor/addresses.js";
-import { iWithdrawalCompressorV313Abi } from "../abi/IWithdrawalCompressorV313.js";
 import "../sdk/index.js";
 import { iMidasDataFeedAbi, iMidasRedemptionVaultAbi, midasGatewayAbi, midasRedeemerAbi, midasRedemptionVaultPhantomTokenAbi, securitizeRedeemerAbi, securitizeRedemptionGatewayAbi, securitizeRedemptionPhantomTokenAbi } from "./withdrawalAbi.js";
 import { erc20Abi, hexToString, parseAbi, parseEther } from "viem";

package/dist/esm/model/opportunities.schema.js

@@ -91,12 +91,10 @@ const strategyOpportunitySchema = z.object({
 	expirationDate: timestampSchema.nullable(),
 	collateralApy: offchainOnly(apyBreakdownSchema).optional(),
 	collateralApyAvg7D: offchainOnly(apyBreakdownSchema).optional(),
-	maxLeverageApy: offchainOnly(apyBreakdownSchema).optional(),
-	maxLeverageApyAvg7D: offchainOnly(apyBreakdownSchema).optional(),
-	borrowApy: tolerance(bpsSchema, "bps").optional(),
+	borrowApy: tolerance(bpsSchema, "bps"),
 	borrowApyAvg7D: offchainOnly(bpsSchema).optional(),
-	additionalBorrowApy: tolerance(bpsSchema, "bps").optional(),
-	additionalBorrowApyAvg7D: offchainOnly(bpsSchema).optional(),
+	quotaRate: tolerance(bpsSchema, "bps"),
+	quotaRateAvg7D: offchainOnly(bpsSchema).optional(),
 	totalValue: offchainOnly(amountSchema).optional(),
 	utilization: offchainOnly(bpsSchema).optional(),
 	availableLiquidity: tolerance(amountSchema, "amount"),

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

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

@@ -1,5 +1,5 @@
-import { iPoolV310Abi } from "../../abi/310/generated.js";
 import { iZapperAbi } from "../../abi/iZapper.js";
+import { iPoolV310Abi } from "../../abi/310/generated.js";
 import { asPreviewSimulationError } from "./errors.js";
 //#region src/preview/simulate/simulatePoolOperation.ts
 function previewRead(operation) {

package/dist/esm/preview/trace/extractTransfers.js

@@ -1,6 +1,6 @@
+import { ierc20Abi } from "../../abi/iERC20.js";
 import { iCreditFacadeV310Abi } from "../../abi/310/generated.js";
 import { AddressMap } from "../../sdk/utils/AddressMap.js";
-import { ierc20Abi } from "../../abi/iERC20.js";
 import "../../sdk/index.js";
 import { UnexpectedFacadeEventOrderError } from "./errors.js";
 import { getAddress, isAddressEqual, parseEventLogs } from "viem";

package/dist/esm/sdk/accounts/CreditAccountsServiceV310.js

@@ -1,3 +1,5 @@
+import { iBaseRewardPoolAbi } from "../../abi/iBaseRewardPool.js";
+import { ierc4626AdapterAbi } from "../../abi/ierc4626Adapter.js";
 import { AP_REWARDS_COMPRESSOR } from "../constants/address-provider.js";
 import { ADDRESS_0X0 } from "../constants/addresses.js";
 import { MAX_UINT256 } from "../constants/math.js";
@@ -8,8 +10,6 @@ import "../base/index.js";
 import { AccountBotsService } from "./bots/AccountBotsService.js";
 import "./bots/index.js";
 import { rewardsCompressorAbi } from "../../abi/compressors/rewardsCompressor.js";
-import { iBaseRewardPoolAbi } from "../../abi/iBaseRewardPool.js";
-import { ierc4626AdapterAbi } from "../../abi/ierc4626Adapter.js";
 import { expectedBalanceDeltas } from "../market/credit/expectedBalanceDeltas.js";
 import "../market/index.js";
 import { CreditAccountCompressor } from "./credit-account-compressor/CreditAccountCompressor.js";

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