@gearbox-protocol/sdk 15.1.0-next.9 → 16.0.0-next.2

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

@@ -0,0 +1,398 @@
+import { MAX_UINT256, PERCENTAGE_FACTOR } from "../../constants/math.js";
+import "../../constants/index.js";
+import { IntentPreviewError } from "./types.js";
+import { eq } from "./utils/common.js";
+import { assertDebtInBand, assertLeverageAtLeastOne, debtForLeverage, proportionalDebt } from "./math.js";
+//#region src/sdk/accounts/intents/plan.ts
+/** Whatever the previous convert produced. */
+const RAISED = { raised: true };
+/** Intent 5: the token lands as is; debt is untouched. */
+function planAddCollateral(intent) {
+	assertPositive(intent.amount, "addCollateral");
+	return [add(intent.token, intent.amount, intent.value)];
+}
+/** Intent 4: one asset out at fixed debt. */
+function planWithdrawAsset(intent, view) {
+	assertPositive(intent.amount, "withdrawAsset");
+	return payout(view, intent.token, intent.amount, intent.to);
+}
+/** Intent 6: collateral fixed, debt retargeted to `C0 · (L1 − 1)`. */
+function planAdjustLeverage(intent, view) {
+	const { U, delta } = leverageShape(intent, view);
+	if (delta === 0n) return [];
+	const T = intent.token ?? positionToken(view, "adjustLeverage");
+	if (delta > 0n) return [borrow(delta), convert(U, T, delta)];
+	const shortfall = -delta - view.balanceOf(U);
+	if (shortfall > 0n && eq(T, U)) throw new IntentPreviewError("insufficientSourceBalance", `adjustLeverage: needs ${-delta} underlying, account holds ${view.balanceOf(U)}`);
+	return [...shortfall > 0n ? [convert(T, U, view.price(U, T, shortfall))] : [], repay(-delta)];
+}
+/** Intents 1.1 / 1.2: collateral grows by `a`, debt grows to match. */
+function planDeposit(intent, view) {
+	assertPositive(intent.amount, "deposit");
+	const U = view.underlying;
+	if (!eq(intent.token, U) && !(view.rwaAsset && eq(intent.token, view.rwaAsset))) throw new IntentPreviewError("unsupportedCollateralToken", `deposit: only ${U}${view.rwaAsset ? ` or ${view.rwaAsset}` : ""} can be deposited, got ${intent.token}`);
+	const aU = view.price(intent.token, U, intent.amount);
+	const debtDelta = intent.targetLeverage === void 0 ? proportionalDebt(view, aU) : debtForLeverage(view.collateral + aU, intent.targetLeverage) - view.debt;
+	if (debtDelta < 0n) throw new IntentPreviewError("leverageOutOfRange", `deposit: target leverage ${intent.targetLeverage} would require repaying debt`);
+	assertDebtInBand(view.debt + debtDelta, view.band);
+	const T = intent.positionToken ?? positionToken(view, "deposit");
+	const depositStays = eq(intent.token, T);
+	return [
+		add(intent.token, intent.amount, intent.value),
+		...depositStays ? [] : [convert(intent.token, U, intent.amount)],
+		...debtDelta > 0n ? [borrow(debtDelta)] : [],
+		convert(U, T, debtDelta + (depositStays ? 0n : aU))
+	].filter((s) => s.kind !== "convert" || s.amount !== 0n);
+}
+/**
+* Intent 3: funding comes in from the wallet and goes straight into the debt.
+* Collateral never moves, so the whole plan is the funding's way to `U`.
+*
+* Funding in `U` needs no way there: it lands and is repaid, which is the whole
+* plan. An RWA market also takes the raw asset behind its underlying, and that
+* one is wrapped on the way in.
+*
+* `MAX_UINT256` settles the loan: the wallet is asked for the debt as it stands
+* plus the headroom {@link SETTLE_MARGIN} allows for the interest of the blocks
+* still to come, since the facade is told to repay everything outstanding
+* rather than the amount quoted here.
+*/
+function planRepay(intent, view) {
+	assertPositive(intent.amount, "repay");
+	const U = view.underlying;
+	const fundsInU = eq(intent.token, U);
+	if (!fundsInU && !(view.rwaAsset && eq(intent.token, view.rwaAsset))) throw new IntentPreviewError("unsupportedCollateralToken", `repay: only ${U}${view.rwaAsset ? ` or ${view.rwaAsset}` : ""} can be repaid with, got ${intent.token}`);
+	if (view.debt <= 0n) throw new IntentPreviewError("debtOutOfRange", "repay: the account owes nothing");
+	const funding = everything(intent.amount) ? view.price(U, intent.token, withMargin(view.debt)) : intent.amount;
+	const repaid = min(view.price(intent.token, U, funding), view.debt);
+	assertDebtInBand(view.debt - repaid, view.band);
+	return [
+		add(intent.token, funding, intent.value),
+		...fundsInU ? [] : [convert(intent.token, U, funding)],
+		...repaid === view.debt ? [clearQuotas()] : [],
+		repay(repaid)
+	];
+}
+/**
+* Intent 2.1: `W` of value leaves, debt shrinks by `D0 · W / C0` so leverage
+* holds. Both are funded by the source `S`.
+*/
+function planWithdraw(intent, view) {
+	const { U, T, S, WU, dD, all } = withdrawShape(intent, view);
+	if (all) return [
+		clearQuotas(),
+		{ kind: "closeAll" },
+		...view.debt > 0n ? [repay(view.debt)] : [],
+		{
+			kind: "sweep",
+			to: intent.to
+		}
+	];
+	if (eq(T, U)) return [
+		convert(S, U, view.price(U, S, WU + dD)),
+		repay(dD, intent.amount),
+		...payout(view, U, intent.amount, intent.to)
+	];
+	return [
+		convert(S, U, view.price(U, S, dD)),
+		repay(dD),
+		convert(S, T, view.price(U, S, WU)),
+		...payout(view, T, RAISED, intent.to)
+	];
+}
+/**
+* Intent 2.1 against a source that cannot be sold on a DEX.
+*
+* Some collateral only converts through its issuer — a Securitize dsToken, a
+* Mellow share — which answers a redemption request now and pays out days
+* later. The trade is unchanged; what changes is that the proceeds do not exist
+* yet, so this half only requests the redemption:
+*
+* ```
+* request(S, W + dD) → [days] → claim → convert → repay → withdraw
+* ```
+*
+* 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. 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) {
+		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 [{
+		kind: "request",
+		token: S,
+		amount: view.price(U, S, payoutIsSource ? dD : WU + dD),
+		reserve: payoutIsSource ? intent.amount : 0n,
+		record: {
+			type: "WITHDRAW_COLLATERAL",
+			to: intent.to,
+			withdrawToken: T,
+			withdrawAmount: intent.amount,
+			sourceToken: S,
+			debtRepaid: dD
+		}
+	}];
+}
+/**
+* Intent 6.2 against a position token that only redeems through its issuer.
+*
+* Only deleveraging can be delayed: raising leverage borrows and buys, both of
+* which settle at once. The request covers whatever idle underlying does not
+* already, and the tail repays from the claim.
+*/
+function planAdjustLeverageDelayed(intent, view) {
+	const { U, delta } = leverageShape(intent, view);
+	if (delta >= 0n) throw new IntentPreviewError("noDelayedRoute", "adjustLeverage: only deleveraging can settle with a delay");
+	const shortfall = -delta - view.balanceOf(U);
+	if (shortfall <= 0n) throw new IntentPreviewError("noDelayedRoute", "adjustLeverage: idle underlying covers the repayment, nothing to redeem");
+	const T = intent.token ?? positionToken(view, "adjustLeverage");
+	return [{
+		kind: "request",
+		token: T,
+		amount: view.price(U, T, shortfall),
+		reserve: 0n,
+		record: { type: "DECREASE_LEVERAGE" }
+	}];
+}
+/** Everything claimed goes into the debt. */
+function planFinishDecreaseLeverage(claimable, claimed, view) {
+	return [
+		claim(claimable),
+		convert(claimed.token, view.underlying, claimed.amount),
+		repay(RAISED)
+	];
+}
+/**
+* The claim is split between the promised payout `W` and the debt the leading
+* half deferred: the payout is served first, the debt gets what is left, so a
+* routing shortfall shows as leverage a touch above target rather than as a
+* payout the wallet was promised and did not get.
+*/
+function planFinishWithdraw(intent, claimable, claimed, view) {
+	const U = view.underlying;
+	const T = intent.withdrawToken;
+	const W = intent.withdrawAmount;
+	if (!eq(T, U) && !(view.rwaAsset && eq(T, view.rwaAsset))) throw new IntentPreviewError("noDelayedRoute", `finishWithdraw: cannot pay out in ${T}`);
+	if (intent.debtRepaid === 0n) return [
+		claim(claimable),
+		convert(claimed.token, T, claimed.amount),
+		...payout(view, T, {
+			raised: true,
+			max: W
+		}, intent.to)
+	];
+	if (eq(intent.sourceToken, T)) return [
+		claim(claimable),
+		convert(claimed.token, U, claimed.amount),
+		repay({
+			raised: true,
+			max: intent.debtRepaid
+		}),
+		...payout(view, T, W, intent.to)
+	];
+	if (eq(T, U)) return [
+		claim(claimable),
+		convert(claimed.token, U, claimed.amount),
+		repay(intent.debtRepaid, W),
+		...payout(view, U, {
+			raised: true,
+			max: W
+		}, intent.to)
+	];
+	const reserved = min(view.price(T, claimed.token, W), claimed.amount);
+	return [
+		claim(claimable),
+		convert(claimed.token, U, claimed.amount - reserved),
+		repay({
+			raised: true,
+			max: intent.debtRepaid
+		}),
+		convert(claimed.token, T, reserved),
+		...payout(view, T, {
+			raised: true,
+			max: W
+		}, 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)];
+}
+/**
+* What a withdrawal comes down to: the payout `W` of `T` priced in the
+* underlying, the debt `dD` that keeps leverage flat, and the source `S` both
+* are funded from. Shared so that the instant and the delayed leading half
+* cannot disagree on the amounts.
+*/
+function withdrawShape(intent, view) {
+	assertPositive(intent.amount, "withdraw");
+	const U = view.underlying;
+	const T = intent.tokenOut ?? U;
+	const S = intent.sourceToken ?? sourceToken(view);
+	if (everything(intent.amount)) {
+		assertHasValue(view);
+		return {
+			U,
+			T,
+			S,
+			WU: view.collateral,
+			dD: view.debt,
+			all: true
+		};
+	}
+	const WU = view.price(T, U, intent.amount);
+	if (WU <= 0n) throw new IntentPreviewError("insufficientSourceBalance", `withdraw: cannot price ${intent.amount} of ${T}`);
+	if (WU >= view.collateral) {
+		assertHasValue(view);
+		return {
+			U,
+			T,
+			S,
+			WU,
+			dD: view.debt,
+			all: true
+		};
+	}
+	const dD = proportionalDebt(view, WU);
+	assertDebtInBand(view.debt - dD, view.band);
+	return {
+		U,
+		T,
+		S,
+		WU,
+		dD,
+		all: false
+	};
+}
+/**
+* The debt move a leverage target implies. Shared by the instant and the
+* delayed leading half; the token that funds it is resolved by the caller,
+* once it knows the move needs one at all.
+*/
+function leverageShape(intent, view) {
+	assertLeverageAtLeastOne(intent.targetLeverage);
+	if (view.collateral <= 0n) throw new IntentPreviewError("insufficientSourceBalance", "adjustLeverage: account has no collateral to lever");
+	const target = debtForLeverage(view.collateral, intent.targetLeverage);
+	assertDebtInBand(target, view.band);
+	return {
+		U: view.underlying,
+		delta: target - view.debt
+	};
+}
+const add = (token, amount, value) => ({
+	kind: "add",
+	token,
+	amount,
+	value
+});
+const borrow = (amount) => ({
+	kind: "borrow",
+	amount
+});
+const repay = (amount, keep) => keep === void 0 ? {
+	kind: "repay",
+	amount
+} : {
+	kind: "repay",
+	amount,
+	keep
+};
+const convert = (from, to, amount) => ({
+	kind: "convert",
+	from,
+	to,
+	amount
+});
+const claim = (claimable) => ({
+	kind: "claim",
+	claimable
+});
+const clearQuotas = () => ({ kind: "clearQuotas" });
+/**
+* Headroom a settlement raises on top of the debt it read, in
+* `PERCENTAGE_FACTOR`: enough interest for the transaction to sit in the
+* mempool for hours at any sane borrow rate, small enough not to matter to the
+* wallet that fronts it.
+*/
+const SETTLE_MARGIN = 10n;
+const withMargin = (debt) => debt + debt * SETTLE_MARGIN / PERCENTAGE_FACTOR;
+/** The amount that asks for all of it, whatever "all" turns out to be. */
+const everything = (amount) => amount >= MAX_UINT256;
+const min = (a, b) => a < b ? a : b;
+/**
+* Hands `amount` of `token` to `to`. The wrapped underlying of an RWA market
+* cannot leave the account, so it is unwrapped into the raw asset on the way.
+*/
+function payout(view, token, amount, to) {
+	if (view.rwaAsset && eq(token, view.underlying)) return [convert(view.underlying, view.rwaAsset, amount), {
+		kind: "withdraw",
+		token: view.rwaAsset,
+		amount: RAISED,
+		to
+	}];
+	return [{
+		kind: "withdraw",
+		token,
+		amount,
+		to
+	}];
+}
+function positionToken(view, flow) {
+	const pick = view.fattest([view.underlying]);
+	if (!pick) throw new IntentPreviewError("insufficientSourceBalance", `${flow}: no position token on the account`);
+	return pick;
+}
+function sourceToken(view) {
+	const pick = view.fattest();
+	if (!pick) throw new IntentPreviewError("insufficientSourceBalance", "withdraw: account has no spendable balance");
+	return pick;
+}
+/** An account whose debt has eaten its collateral has nothing to hand over. */
+function assertHasValue(view) {
+	if (view.collateral <= 0n) throw new IntentPreviewError("insufficientSourceBalance", `withdraw: nothing to withdraw, net value is ${view.collateral}`);
+}
+function assertPositive(amount, flow) {
+	if (amount <= 0n) throw new IntentPreviewError("insufficientSourceBalance", `${flow}: amount must be positive`);
+}
+//#endregion
+export { RAISED, planAddCollateral, planAdjustLeverage, planAdjustLeverageDelayed, planDeposit, planFinishClaimOnly, planFinishCloseAccount, planFinishDecreaseLeverage, planFinishWithdraw, planRepay, planWithdraw, planWithdrawAsset, planWithdrawDelayed };

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

@@ -0,0 +1,311 @@
+import { calcPositionLeverage } from "../../market/math.js";
+import { IntentPreviewError } from "./types.js";
+import { eq, toTargetDecimals } from "./utils/common.js";
+import { convertAmount } from "./utils/convert-amount.js";
+import { isRedemptionPhantomToken } from "./utils/pick-token.js";
+import { assertCanBorrow, assertCollateralised, assertGrowthAllowed, assertQuotaHeadroom } from "./guards.js";
+import { OperationLedger } from "./utils/ledger.js";
+import { clearedQuotas, getQuotasForUpdate, quotasAfterUpdate } from "./utils/quotas-for-update.js";
+import { createRouterPaths } from "./utils/router-path.js";
+import { buildAddCollateralOperation, buildClaimDelayedWithdrawalOperation, buildCloseSwapOperation, buildDecreaseDebtOperation, buildIncreaseDebtOperation, buildQuotaUpdateOperation, buildStartDelayedWithdrawalOperation, buildSwapOperation, buildUnwrapRwaCollateralOperation, buildWithdrawCollateralOperation, buildWrapRwaCollateralOperation, instantOutput } from "./operations.js";
+//#region src/sdk/accounts/intents/realize.ts
+/**
+* Turns a plan into operations: the one place that talks to the router, knows
+* how an RWA leg differs from a swap, and keeps the running balances.
+*
+* Steps are applied to a ledger as they are built, so every leg sees the
+* balances the previous ones left behind: a swap only spends what the plan
+* says and keeps the rest of its input token in place, a repayment never
+* exceeds the underlying actually raised. Once the walk is done the projected
+* balances yield the quota update and the reported state.
+*/
+async function realize(steps, props) {
+	const { creditAccount, sdk, slippage, quotaReserve } = props;
+	const { underlying } = creditAccount;
+	const rwaAsset = sdk.tokensMeta.rwaUnderlyings.get(underlying)?.asset;
+	const price = convertAmount(sdk, creditAccount.creditManager);
+	const paths = props.paths ?? createRouterPaths({
+		sdk,
+		creditAccount,
+		slippage
+	});
+	const market = sdk.marketRegister.findByCreditManager(creditAccount.creditManager);
+	const suite = sdk.marketRegister.findCreditManager(creditAccount.creditManager);
+	const ledger = new OperationLedger({
+		initialAssets: creditAccount.tokens,
+		underlying,
+		debt: creditAccount.accountDebt,
+		convert: price
+	});
+	const operations = [];
+	const push = (op) => {
+		operations.push(op);
+		ledger.apply(op);
+	};
+	/** 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
+	* at the end — and settles them at none, whatever the balances turn out to be.
+	*/
+	let cleared;
+	/**
+	* Whether anything leaves the account, which is what makes the credit manager
+	* judge the closing collateral check at safe prices.
+	*/
+	let paysOut = false;
+	const amountOf = (a) => typeof a === "bigint" ? a : min(raised, a.max ?? raised);
+	const assertHolds = (token, amount, what) => {
+		const held = ledger.balanceOf(token);
+		if (amount <= 0n || held < amount) throw new IntentPreviewError("insufficientSourceBalance", `${what}: needs ${amount} of ${token}, account holds ${held}`);
+	};
+	for (const step of steps) switch (step.kind) {
+		case "add":
+			push(buildAddCollateralOperation({
+				token: step.token,
+				amount: step.amount,
+				value: step.value,
+				creditAccount,
+				sdk
+			}));
+			break;
+		case "borrow":
+			assertCanBorrow(suite, step.amount);
+			push(buildIncreaseDebtOperation({
+				amount: step.amount,
+				creditAccount,
+				sdk
+			}));
+			break;
+		case "repay": {
+			const amount = min(amountOf(step.amount), ledger.balanceOf(underlying) - (step.keep ?? 0n));
+			if (amount > 0n) push(buildDecreaseDebtOperation({
+				amount,
+				full: amount >= ledger.debt,
+				creditAccount,
+				sdk
+			}));
+			break;
+		}
+		case "clearQuotas":
+			cleared = clearedQuotas(creditAccount.tokens);
+			if (cleared.quotaDecrease.length > 0) push(buildQuotaUpdateOperation({
+				update: cleared,
+				creditAccount,
+				sdk
+			}));
+			break;
+		case "convert": {
+			const amount = amountOf(step.amount);
+			if (amount <= 0n) {
+				raised = 0n;
+				break;
+			}
+			assertHolds(step.from, amount, "convert");
+			if (eq(step.from, step.to)) {
+				raised = amount;
+				break;
+			}
+			const wrap = rwaAsset && eq(step.from, rwaAsset) && eq(step.to, underlying);
+			const unwrap = rwaAsset && eq(step.from, underlying) && eq(step.to, rwaAsset);
+			if (wrap || unwrap) {
+				const amountOut = toTargetDecimals(amount, step.from, step.to, sdk);
+				push(await (wrap ? buildWrapRwaCollateralOperation : buildUnwrapRwaCollateralOperation)({
+					tokenIn: step.from,
+					amountIn: amount,
+					tokenOut: step.to,
+					amountOut,
+					creditAccount,
+					sdk
+				}));
+				raised = amountOut;
+				break;
+			}
+			const held = ledger.balanceOf(step.from);
+			const leg = await paths.swap({
+				tokenIn: step.from,
+				tokenOut: step.to,
+				amount,
+				keep: held - amount
+			});
+			push(buildSwapOperation({
+				tokenIn: step.from,
+				amountIn: amount,
+				tokenOut: step.to,
+				amountOut: leg.minAmount,
+				calls: leg.calls
+			}));
+			raised = leg.minAmount;
+			break;
+		}
+		case "closeAll": {
+			const balances = ledger.snapshot().assets.filter((a) => !eq(a.token, underlying) && a.balance > DUST);
+			const pending = balances.find((a) => isRedemptionPhantomToken(sdk, a.token));
+			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 || leg.minAmount > 0n) push(buildCloseSwapOperation({
+					from: balances,
+					tokenOut: underlying,
+					amountOut: leg.minAmount,
+					calls: leg.calls
+				}));
+			}
+			raised = ledger.balanceOf(underlying);
+			break;
+		}
+		case "withdraw": {
+			const amount = amountOf(step.amount);
+			assertHolds(step.token, amount, "withdraw");
+			paysOut = true;
+			push(buildWithdrawCollateralOperation({
+				token: step.token,
+				amount,
+				to: step.to,
+				creditAccount,
+				sdk
+			}));
+			break;
+		}
+		case "request": {
+			const asset = await delayedConfig(sdk, creditAccount, step.token);
+			if (ledger.balanceOf(asset.withdrawalPhantomToken) > 0n) throw new IntentPreviewError("withdrawalInProgress", `request: ${asset.withdrawalPhantomToken} already holds a pending withdrawal`);
+			assertHolds(step.token, step.amount + step.reserve, "request");
+			const preview = await sdk.accounts.previewDelayedWithdrawal({
+				creditAccount: creditAccount.creditAccount,
+				token: step.token,
+				amount: step.amount,
+				withdrawalPhantomToken: asset.withdrawalPhantomToken,
+				intent: step.record
+			});
+			push(buildStartDelayedWithdrawalOperation({
+				preview,
+				creditAccount,
+				sdk
+			}));
+			const queued = preview.outputs.find((o) => o.isDelayed);
+			delayed = {
+				record: step.record,
+				claimableAt: preview.claimableAt,
+				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;
+		}
+		case "claim":
+			push(buildClaimDelayedWithdrawalOperation({
+				claimable: step.claimable,
+				creditAccount,
+				sdk
+			}));
+			raised = instantOutput(step.claimable.outputs)?.amount ?? 0n;
+			break;
+		case "sweep": {
+			paysOut = true;
+			const wrapped = ledger.balanceOf(underlying);
+			if (rwaAsset && wrapped > 0n) push(await buildUnwrapRwaCollateralOperation({
+				tokenIn: underlying,
+				amountIn: wrapped,
+				tokenOut: rwaAsset,
+				amountOut: toTargetDecimals(wrapped, underlying, rwaAsset, sdk),
+				creditAccount,
+				sdk
+			}));
+			for (const { token, balance } of ledger.snapshot().assets) push(buildWithdrawCollateralOperation({
+				token,
+				amount: balance,
+				to: step.to,
+				all: true,
+				creditAccount,
+				sdk
+			}));
+			break;
+		}
+	}
+	const { assets, totalValue, debt } = ledger.snapshot();
+	assertGrowthAllowed({
+		sdk,
+		suite,
+		market,
+		before: creditAccount.tokens,
+		after: assets
+	});
+	const quotas = cleared ?? getQuotasForUpdate({
+		assetsBefore: creditAccount.tokens,
+		assetsAfter: assets,
+		initialQuotas: creditAccount.tokens,
+		quotaReserve,
+		underlyingToken: underlying,
+		liquidationThresholds: suite.creditManager.liquidationThresholds,
+		quotas: market.pool.pqk.quotas,
+		maxDebt: suite.creditFacade.maxDebt,
+		convert: price
+	});
+	if (!cleared && quotas.quotaIncrease.length + quotas.quotaDecrease.length > 0) {
+		assertQuotaHeadroom(market, quotas.quotaIncrease);
+		push(buildQuotaUpdateOperation({
+			update: quotas,
+			creditAccount,
+			sdk
+		}));
+	}
+	const quotasAfter = quotasAfterUpdate(creditAccount.tokens, quotas.desiredQuota);
+	const snapshot = {
+		creditManager: creditAccount.creditManager,
+		assets,
+		quotas: Object.values(quotasAfter),
+		totalDebt: debt,
+		totalValue
+	};
+	const projectedPool = { availableLiquidityChange: creditAccount.accountDebt - debt };
+	const metrics = {
+		healthFactor: sdk.positions.healthFactor(snapshot),
+		borrowRate: sdk.positions.borrowRate(snapshot, projectedPool),
+		timeToLiquidation: sdk.positions.timeToLiquidation(snapshot, projectedPool),
+		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: assets.map((a) => market.priceOracle.toTokenAmount(a.token, a.balance)),
+		quotas: quotasAfter,
+		...metrics
+	};
+	return {
+		operations,
+		state,
+		calls: callsOf(operations),
+		delayed: delayed && {
+			...delayed,
+			afterRequest: state
+		}
+	};
+}
+/**
+* The redemption config for `token`, when the credit manager offers exactly one.
+*
+* Several configs mean several venues with different delays and outputs, and
+* nothing in the intent says which one was meant.
+*/
+async function delayedConfig(sdk, creditAccount, token) {
+	const compressor = sdk.withdrawalCompressor;
+	if (!compressor) throw new IntentPreviewError("noDelayedRoute", "request: chain has no withdrawal compressor");
+	const assets = await compressor.findWithdrawableAssets(creditAccount.creditManager, token);
+	if (assets.length === 0) throw new IntentPreviewError("noDelayedRoute", `request: ${token} has no delayed withdrawal config`);
+	if (assets.length > 1) throw new IntentPreviewError("multipleDelayedWithdrawals", `request: ${token} has ${assets.length} delayed withdrawal configs`);
+	return assets[0];
+}
+const callsOf = (operations) => operations.flatMap((op) => op.calls);
+const min = (a, b) => a < b ? a : b;
+/** Balance the router's close path refuses to route, and leaves in place. */
+const DUST = 10n;
+//#endregion
+export { realize };