@gearbox-protocol/sdk 17.1.0-next.1 → 17.1.0-next.3

package/dist/esm/onchain/MultichainSDK.js

@@ -1,7 +1,5 @@
 import { getNetworkType } from "./chain/chains.js";
 import { ChainNotConfiguredError, SdkMissingChainStateError, SdkStateVersionMismatchError, SdkSyncFailedError } from "./core/errors.js";
-import { PriceUpdatesCache } from "./market/pricefeeds/updates/PriceUpdatesCache.js";
-import "./market/pricefeeds/updates/index.js";
 import { MultichainLiquidationsService } from "./accounts/liquidations/MultichainLiquidationsService.js";
 import "./accounts/index.js";
 import "./core/index.js";
@@ -18,7 +16,6 @@ import { OnchainSDK } from "./OnchainSDK.js";
 **/
 var MultichainSDK = class {
 	#chains;
-	#redstoneCache;
 	#logger;
 	/**
 	* Namespace for liquidatable credit accounts discovery across all
@@ -60,20 +57,9 @@ var MultichainSDK = class {
 	* @param options - Shared and per-chain attach options.
 	*/
 	async attach(options) {
-		if (options?.redstone) this.#redstoneCache = new PriceUpdatesCache({
-			ttl: options.redstone.cacheTTL ?? 225e3,
-			historical: !!options.redstone.historicTimestamp
-		});
 		await Promise.all([...this.#chains.entries()].map(([network, sdk]) => {
 			const perChainOpts = options?.perChain?.[network] ?? {};
-			return sdk.attach({
-				...perChainOpts,
-				redstone: {
-					...options?.redstone,
-					cache: this.#redstoneCache,
-					...perChainOpts.redstone
-				}
-			});
+			return sdk.attach(perChainOpts);
 		}));
 		this.#logger?.info("Attached all chains");
 	}
@@ -88,10 +74,6 @@ var MultichainSDK = class {
 	*/
 	hydrate(state, options) {
 		if (state.version !== 2) throw new SdkStateVersionMismatchError(2, state.version);
-		if (options?.redstone) this.#redstoneCache = new PriceUpdatesCache({
-			ttl: options.redstone.cacheTTL ?? 225e3,
-			historical: !!options.redstone.historicTimestamp
-		});
 		const stateByNetwork = new Map(state.chains.map((cs) => [cs.network, cs]));
 		for (const [network, sdk] of this.#chains) {
 			const chainState = stateByNetwork.get(network);
@@ -100,14 +82,7 @@ var MultichainSDK = class {
 				throw new SdkMissingChainStateError(network);
 			}
 			const perChainOpts = options?.perChain?.[network] ?? {};
-			sdk.hydrate(chainState, {
-				...perChainOpts,
-				redstone: {
-					...options?.redstone,
-					cache: this.#redstoneCache,
-					...perChainOpts.redstone
-				}
-			});
+			sdk.hydrate(chainState, perChainOpts);
 		}
 		this.#logger?.info("Hydrated all chains");
 	}

package/dist/esm/onchain/OnchainSDK.js

@@ -151,7 +151,7 @@ var OnchainSDK = class extends ChainContractsRegister {
 	*/
 	async attach(options) {
 		if (this.#attached) throw new SdkAlreadyAttachedError();
-		const { addressProvider = ADDRESS_PROVIDER_V310, blockNumber, ignoreUpdateablePrices, ignoreMarkets, marketConfigurators: mcs, redstone } = options ?? {};
+		const { addressProvider = ADDRESS_PROVIDER_V310, blockNumber, ignoreUpdateablePrices, ignoreMarkets, marketConfigurators: mcs } = options ?? {};
 		const marketConfigurators = mcs ?? this.client.chain.defaultMarketConfigurators.keys();
 		const rwaFactories = options?.rwaFactories ?? this.client.chain.rwaFactories;
 		this.logger?.info({
@@ -166,8 +166,7 @@ var OnchainSDK = class extends ChainContractsRegister {
 		const block = await this.client.getBlock(blockNumber ? { blockNumber: BigInt(blockNumber) } : { blockTag: "latest" });
 		this.#currentBlock = block.number;
 		this.#timestamp = block.timestamp;
-		if (blockNumber && !redstone?.historicTimestamp && time - Number(block.timestamp) * 1e3 > 6e4) this.logger?.warn("attaching to fixed block number, but redstone historicTimestamp is not set. price updates might fail");
-		this.#priceFeeds = new UpdatablePriceFeedRegistry(this, { redstone });
+		this.#priceFeeds = new UpdatablePriceFeedRegistry(this);
 		this.logger?.debug(`attach block number ${this.currentBlock} timestamp ${this.timestamp}`);
 		this.#addressProvider = await createAddressProvider(this, addressProvider);
 		this.logger?.debug(`address provider version: ${this.#addressProvider.version}`);
@@ -258,11 +257,11 @@ var OnchainSDK = class extends ChainContractsRegister {
 		if (this.#attached) throw new SdkAlreadyAttachedError();
 		if (state.version !== 2) throw new SdkStateVersionMismatchError(2, state.version);
 		if (state.network !== this.networkType) throw new SdkChainMismatchError(this.networkType, state.network);
-		const { ignoreMarkets, redstone } = options ?? {};
+		const { ignoreMarkets } = options ?? {};
 		this.logger?.info({ networkType: this.networkType }, "hydrating sdk state");
 		this.#currentBlock = state.currentBlock;
 		this.#timestamp = state.timestamp;
-		this.#priceFeeds = new UpdatablePriceFeedRegistry(this, { redstone });
+		this.#priceFeeds = new UpdatablePriceFeedRegistry(this);
 		this.#addressProvider = hydrateAddressProvider(this, state.addressProvider);
 		this.logger?.debug(`address provider version: ${this.#addressProvider.version}`);
 		this.#marketRegister = new MarketRegister(this, ignoreMarkets);
@@ -345,7 +344,7 @@ var OnchainSDK = class extends ChainContractsRegister {
 	*/
 	async syncState(opts) {
 		let { blockNumber, timestamp, ignoreUpdateablePrices } = opts ?? {};
-		if (this.priceFeeds.historical && !ignoreUpdateablePrices) this.logger?.warn("syncState is not supported with redstone historicTimestamp");
+		if (this.priceFeeds.historical && !ignoreUpdateablePrices) this.logger?.warn("syncState is not supported with historical price updates");
 		if (!blockNumber || !timestamp) {
 			const block = await this.client.getBlock({ blockTag: "latest" });
 			blockNumber = block.number;

package/dist/esm/onchain/accounts/intents/borrow.js

@@ -29,7 +29,10 @@ async function buildBorrowState(props) {
 	const { sdk, creditManager, collateralAmount, borrowAmount, slippage = 0, quotaReserve, creditAccount: existing } = props;
 	const suite = sdk.marketRegister.findCreditManager(creditManager);
 	const market = sdk.marketRegister.findByCreditManager(creditManager);
+	const draft = props.draft ?? {};
+	Object.assign(draft, suite.creditOperationMarket(), { slippage });
 	assertMarketOperable(suite);
+	const priced = (token, balance) => market.priceOracle.toTokenAmount(token, balance);
 	const underlying = market.pool.underlying.toLowerCase();
 	const collateralToken = props.collateralToken.toLowerCase();
 	const borrowToken = props.borrowToken.toLowerCase();
@@ -41,8 +44,16 @@ async function buildBorrowState(props) {
 	if (collateralAmount <= 0n) throw new IntentPreviewError(insufficientBalance(), "borrow: no collateral supplied");
 	if (borrowAmount <= 0n) throw new IntentPreviewError(insufficientBalance(), "borrow: nothing to borrow");
 	const margin = convert(collateralToken, underlying, collateralAmount);
+	Object.assign(draft, {
+		collateral: priced(collateralToken, collateralAmount),
+		totalValue: market.toUnderlyingAmount(margin)
+	});
 	if (margin <= 0n) throw new IntentPreviewError(insufficientBalance(), "borrow: collateral is worth nothing in underlying");
 	const debt = eq(borrowToken, underlying) ? borrowAmount : unwrapsPayout ? toTargetDecimals(borrowAmount, borrowToken, underlying, sdk) : convert(borrowToken, underlying, borrowAmount);
+	Object.assign(draft, {
+		totalDebt: market.toUnderlyingAmount(debt),
+		netValue: market.toUnderlyingAmount(margin - debt)
+	});
 	assertDebtLimits(sdk, debt, suite.creditFacade, underlying);
 	assertCanBorrow(sdk, suite, debt);
 	const account = existing ?? unopenedAccountSlice({
@@ -72,6 +83,37 @@ async function buildBorrowState(props) {
 		assets,
 		quotaReserve
 	});
+	const payout = unwrapsPayout ? toTargetDecimals(debt, underlying, borrowToken, sdk) : leg ? leg.amount : debt;
+	/** The two sides of the loan, which the guards below weigh but do not move. */
+	const loan = {
+		collateral: priced(collateralToken, collateralAmount),
+		borrowed: priced(borrowToken, payout),
+		minBorrowed: priced(borrowToken, leg ? leg.minAmount : payout),
+		slippage,
+		quotaIncrease,
+		calls: leg ? [...leg.calls] : unwrap ?? [],
+		creditAccount: existing?.creditAccount
+	};
+	Object.assign(draft, loan);
+	const snapshot = {
+		creditManager,
+		assets,
+		quotas: quotaIncrease,
+		totalDebt: debt,
+		totalValue: margin
+	};
+	const settle = () => ({
+		...sdk.positions.projection(snapshot, { availableLiquidityChange: -debt }),
+		currentPrice: sdk.positions.currentPrice(snapshot),
+		executionCost: void 0
+	});
+	let reached;
+	try {
+		reached = settle();
+		Object.assign(draft, reached);
+	} catch {
+		reached = void 0;
+	}
 	assertGrowthAllowed({
 		sdk,
 		suite,
@@ -80,35 +122,20 @@ async function buildBorrowState(props) {
 		after: assets
 	});
 	assertQuotaAvailable(sdk, market, quotaIncrease);
-	const snapshot = {
-		creditManager,
-		assets,
-		quotas: quotaIncrease,
-		totalDebt: debt,
-		totalValue: margin
-	};
-	const projection = sdk.positions.projection(snapshot, { availableLiquidityChange: -debt });
+	const projection = reached ?? settle();
 	assertCollateralised(projection.safeHealthFactor, true);
-	const priced = (token, balance) => market.priceOracle.toTokenAmount(token, balance);
-	const payout = unwrapsPayout ? toTargetDecimals(debt, underlying, borrowToken, sdk) : leg ? leg.amount : debt;
-	return {
+	const state = {
 		...projection,
-		currentPrice: sdk.positions.currentPrice(snapshot),
-		executionCost: void 0,
 		priceImpact: await collectPriceImpact(leg?.probe ? [leg.probe] : [], {
 			totalValue: margin,
 			netValue: margin - debt,
 			toUnderlying: (from, amount) => convert(from, underlying, amount),
 			toUnderlyingAmount: market.toUnderlyingAmount
 		}),
-		collateral: priced(collateralToken, collateralAmount),
-		borrowed: priced(borrowToken, payout),
-		minBorrowed: priced(borrowToken, leg ? leg.minAmount : payout),
-		slippage,
-		quotaIncrease,
-		calls: leg ? [...leg.calls] : unwrap ?? [],
-		creditAccount: existing?.creditAccount
+		...loan
 	};
+	Object.assign(draft, state);
+	return state;
 }
 /**
 * Quota a borrow buys for its collateral on an account that holds none yet.

package/dist/esm/onchain/accounts/intents/guards.js

@@ -13,7 +13,8 @@ import { eq } from "./utils/common.js";
 import { isPhantomToken } from "./utils/pick-token.js";
 //#region src/onchain/accounts/intents/guards.ts
 /**
-* What the market itself refuses, checked before anything is quoted.
+* What the market itself refuses, read from its loaded state rather than
+* learned from a revert.
 *
 * The planners answer for the arithmetic of an intent and the ledger for the
 * balances it moves, but neither can see that the facade is paused or that the
@@ -22,9 +23,10 @@ import { isPhantomToken } from "./utils/pick-token.js";
 * loaded market and reported as refusals instead.
 *
 * Every guard here refuses something the market decides rather than something
-* the arithmetic cannot do, which is why all six of their reasons are
-* `blocking`: the walk that hit one still reached an end state, and a caller
-* gets that state alongside the refusal.
+* the arithmetic cannot do, so where the account would have landed stays a
+* question the walk can answer. The three that judge that end state — growth,
+* quota limits, collateral — therefore run only once the projection exists,
+* which is what lets them hand it back as `state` when they refuse.
 */
 /**
 * The facade takes no multicall while it is paused or past its expiration, so

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

@@ -219,7 +219,7 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 				delayed
 			};
 		} catch (e) {
-			return asSDKError(e);
+			return asRefused(e, result.state);
 		}
 	}
 	/**
@@ -242,7 +242,13 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	* @returns Whichever routes are viable, or `{ ok: false, error }` when none is
 	*/
 	async intentRoutes(props) {
-		const [instant, delayed] = await Promise.allSettled([this.startIntent(props), this.startDelayedIntent(props)]);
+		const [instant, delayed] = await Promise.allSettled([this.startIntent({
+			...props,
+			draft: props.draft ?? {}
+		}), this.startDelayedIntent({
+			...props,
+			draft: {}
+		})]);
 		const instantRoute = instant.status === "fulfilled" && instant.value.ok ? instant.value : void 0;
 		const delayedRoute = delayed.status === "fulfilled" && delayed.value.ok ? delayed.value : void 0;
 		const instantError = instant.status === "fulfilled" && !instant.value.ok ? instant.value.error : void 0;
@@ -339,13 +345,17 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	* leverage or the resulting debt is not viable
 	*/
 	async openStrategyIntent(props) {
+		const draft = props.draft ?? {};
 		try {
 			return {
 				ok: true,
-				state: await buildOpenStrategyState(props)
+				state: await buildOpenStrategyState({
+					...props,
+					draft
+				})
 			};
 		} catch (e) {
-			return asSDKError(e);
+			return asRefused(e, draft);
 		}
 	}
 	/**
@@ -370,24 +380,32 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	* router has no path to
 	*/
 	async borrowIntent(props) {
+		const draft = props.draft ?? {};
 		try {
 			return {
 				ok: true,
-				state: await buildBorrowState(props)
+				state: await buildBorrowState({
+					...props,
+					draft
+				})
 			};
 		} catch (e) {
-			return asSDKError(e);
+			return asRefused(e, draft);
 		}
 	}
 	/** Plan → realise → wrap. Unviable requests become `{ ok: false }`. */
 	async #preview(props, plan) {
+		const draft = props.draft ?? {};
 		try {
-			assertMarketOperable(props.sdk.marketRegister.findCreditManager(props.creditAccount.creditManager));
+			const suite = props.sdk.marketRegister.findCreditManager(props.creditAccount.creditManager);
+			Object.assign(draft, suite.creditOperationMarket());
+			assertMarketOperable(suite);
 			const { operations, state, calls, delayed } = await realize(plan(), {
 				creditAccount: props.creditAccount,
 				sdk: props.sdk,
 				slippage: props.slippage ?? 0,
-				quotaReserve: props.quotaReserve
+				quotaReserve: props.quotaReserve,
+				draft
 			});
 			return {
 				ok: true,
@@ -397,7 +415,7 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 				delayed
 			};
 		} catch (e) {
-			return asSDKError(e);
+			return asRefused(e, draft);
 		}
 	}
 };
@@ -419,6 +437,19 @@ function asSDKError(e) {
 	throw e;
 }
 /**
+* {@inheritDoc asSDKError}
+*
+* The same verdict with the walk's draft attached, which is what every flow
+* that projects a state answers with — see {@link WithPartialState} for what
+* a caller can expect to find on it.
+*/
+function asRefused(e, state) {
+	return sdkErr({
+		...asSDKError(e).error,
+		state
+	});
+}
+/**
 * 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

package/dist/esm/onchain/accounts/intents/math.js

@@ -23,17 +23,12 @@ function proportionalDebt(position, collateralDelta) {
 	if (position.collateral <= 0n) throw new IntentPreviewError(insufficientBalance(), "cannot preserve leverage on an account with no collateral");
 	return position.debt * collateralDelta / position.collateral;
 }
-/**
-* Headroom on top of the debt 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;
+/** Share of the debt kept above `minDebt` for interest accrued before sending. */
+const WITHDRAW_DEBT_MARGIN = 1n;
 /**
 * Largest withdrawal (in underlying) that {@link proportionalDebt} can still
 * pay for: the repayment it implies leaves debt at or above `minDebt` plus
-* {@link SETTLE_MARGIN} of the debt, so the figure survives the interest of the
-* blocks before it is sent, and
+* {@link WITHDRAW_DEBT_MARGIN} of the debt, and
 * strictly less than the collateral goes — the last unit closes the account
 * rather than shrinks it. `0n` when the debt already sits below `minDebt`.
 *
@@ -44,7 +39,7 @@ function maxProportionalWithdrawal(position, debtLimits) {
 	if (collateral <= 0n) return 0n;
 	const allButLast = collateral - 1n;
 	if (debt === 0n) return allButLast;
-	const repayable = debt - debtLimits.minDebt - debt * SETTLE_MARGIN / PERCENTAGE_FACTOR;
+	const repayable = debt - debtLimits.minDebt - debt * WITHDRAW_DEBT_MARGIN / PERCENTAGE_FACTOR;
 	if (repayable < 0n) return 0n;
 	const bound = BigIntMath.ceilDiv(collateral * (repayable + 1n), debt) - 1n;
 	return bound < allButLast ? bound : allButLast;
@@ -70,4 +65,4 @@ function assertDebtLimits(sdk, debt, debtLimits, underlying) {
 	}), debt > debtLimits.maxDebt ? `debt ${debt} exceeds maxDebt ${debtLimits.maxDebt}` : `debt ${debt} is below minDebt ${debtLimits.minDebt}`);
 }
 //#endregion
-export { SETTLE_MARGIN, assertDebtLimits, assertLeverageAtLeastOne, debtForLeverage, maxProportionalWithdrawal, proportionalDebt };
+export { assertDebtLimits, assertLeverageAtLeastOne, debtForLeverage, maxProportionalWithdrawal, proportionalDebt };

package/dist/esm/onchain/accounts/intents/open-strategy.js

@@ -26,12 +26,19 @@ async function buildOpenStrategyState(props) {
 	assertLeverageAtLeastOne(leverage);
 	const suite = sdk.marketRegister.findCreditManager(creditManager);
 	const market = sdk.marketRegister.findByCreditManager(creditManager);
+	const draft = props.draft ?? {};
+	Object.assign(draft, suite.creditOperationMarket());
 	assertMarketOperable(suite);
 	const underlying = market.pool.underlying.toLowerCase();
 	const convert = (from, to, amount) => market.priceOracle.safeConvert(from, to, amount).value;
 	const margin = collateral.reduce((acc, a) => acc + convert(a.token, underlying, a.balance), 0n);
-	if (margin <= 0n) throw new IntentPreviewError(insufficientBalance(), "openStrategy: collateral is worth nothing in underlying");
 	const debt = debtForLeverage(margin, leverage);
+	Object.assign(draft, {
+		totalValue: market.toUnderlyingAmount(margin + debt),
+		totalDebt: market.toUnderlyingAmount(debt),
+		netValue: market.toUnderlyingAmount(margin)
+	});
+	if (margin <= 0n) throw new IntentPreviewError(insufficientBalance(), "openStrategy: collateral is worth nothing in underlying");
 	const account = existing ?? unopenedAccountSlice({
 		creditManager,
 		creditFacade: suite.creditFacade.address,
@@ -66,6 +73,42 @@ async function buildOpenStrategyState(props) {
 	}).quotaIncrease;
 	const averageQuota = quotasFor(averageAssets);
 	const minQuota = quotasFor(minAssets);
+	/** What the route came back with, which the guards below weigh but do not move. */
+	const routed = {
+		averageAssets: averageAssets.map(priced),
+		minAssets: minAssets.map(priced),
+		averageQuota,
+		minQuota,
+		calls: [...leg.calls],
+		creditAccount: existing?.creditAccount
+	};
+	Object.assign(draft, routed);
+	const snapshot = {
+		creditManager,
+		assets: averageAssets,
+		quotas: averageQuota,
+		totalDebt: debt,
+		totalValue: margin + debt
+	};
+	/**
+	* The shared builder, as everywhere else — the two branches are what this
+	* flow reports instead of `assets` and `quotas`, so those are dropped.
+	* Opening borrows the whole debt from the pool.
+	*/
+	const settle = () => {
+		const { assets: _assets, quotas: _quotas, ...projection } = sdk.positions.projection(snapshot, { availableLiquidityChange: -debt });
+		return {
+			...projection,
+			currentPrice: sdk.positions.currentPrice(snapshot)
+		};
+	};
+	let reached;
+	try {
+		reached = settle();
+		Object.assign(draft, reached);
+	} catch {
+		reached = void 0;
+	}
 	assertGrowthAllowed({
 		sdk,
 		suite,
@@ -74,14 +117,7 @@ async function buildOpenStrategyState(props) {
 		after: averageAssets
 	});
 	assertQuotaAvailable(sdk, market, averageQuota);
-	const snapshot = {
-		creditManager,
-		assets: averageAssets,
-		quotas: averageQuota,
-		totalDebt: debt,
-		totalValue: margin + debt
-	};
-	const { assets: _assets, quotas: _quotas, ...projection } = sdk.positions.projection(snapshot, { availableLiquidityChange: -debt });
+	const projection = reached ?? settle();
 	assertCollateralised(projection.healthFactor, false);
 	const priceImpact = await collectPriceImpact(leg.probe ? [leg.probe] : [], {
 		totalValue: margin + debt,
@@ -89,17 +125,13 @@ async function buildOpenStrategyState(props) {
 		toUnderlying: (from, amount) => convert(from, underlying, amount),
 		toUnderlyingAmount: market.toUnderlyingAmount
 	});
-	return {
+	const state = {
 		...projection,
-		currentPrice: sdk.positions.currentPrice(snapshot),
 		priceImpact,
-		averageAssets: averageAssets.map(priced),
-		minAssets: minAssets.map(priced),
-		averageQuota,
-		minQuota,
-		calls: [...leg.calls],
-		creditAccount: existing?.creditAccount
+		...routed
 	};
+	Object.assign(draft, state);
+	return state;
 }
 /** Collateral plus the borrowed underlying, folded into one balance per token. */
 function mergeExpectedBalances(collateral, underlying, debt) {

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

@@ -6,7 +6,7 @@ import "../../../model/index.js";
 import { toToken, toTokenAmount } from "../../validation/helpers/token.js";
 import { IntentPreviewError } from "../../validation/raise.js";
 import { eq } from "./utils/common.js";
-import { SETTLE_MARGIN, assertDebtLimits, assertLeverageAtLeastOne, debtForLeverage, proportionalDebt } from "./math.js";
+import { assertDebtLimits, assertLeverageAtLeastOne, debtForLeverage, proportionalDebt } from "./math.js";
 //#region src/onchain/accounts/intents/plan.ts
 /** Whatever the previous convert produced. */
 const RAISED = { raised: true };
@@ -360,6 +360,13 @@ const claim = (claimable) => ({
 	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;

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

@@ -36,6 +36,8 @@ async function realize(steps, props) {
 	const market = sdk.marketRegister.findByCreditManager(creditAccount.creditManager);
 	const price = (from, to, amount) => market.priceOracle.safeConvert(from, to, amount).value;
 	const suite = sdk.marketRegister.findCreditManager(creditAccount.creditManager);
+	const draft = props.draft ?? {};
+	Object.assign(draft, suite.creditOperationMarket());
 	const start = {
 		initialAssets: creditAccount.tokens,
 		underlying,
@@ -327,13 +329,6 @@ async function realize(steps, props) {
 	const floor = ledger.snapshot();
 	const { assets, debt } = floor;
 	const projected = expected.snapshot();
-	assertGrowthAllowed({
-		sdk,
-		suite,
-		market,
-		before: creditAccount.tokens,
-		after: projected.assets
-	});
 	const quotas = cleared ?? getQuotasForUpdate({
 		assetsBefore: creditAccount.tokens,
 		assetsAfter: assets,
@@ -345,14 +340,6 @@ async function realize(steps, props) {
 		maxDebt: suite.creditFacade.maxDebt,
 		convert: price
 	});
-	if (!cleared && quotas.quotaIncrease.length + quotas.quotaDecrease.length > 0) {
-		assertQuotaAvailable(sdk, market, quotas.quotaIncrease);
-		push(buildQuotaUpdateOperation({
-			update: quotas,
-			creditAccount,
-			sdk
-		}));
-	}
 	const quotasAfter = quotasAfterUpdate(creditAccount.tokens, quotas.desiredQuota);
 	const quoted = Object.values(quotasAfter);
 	const snapshot = {
@@ -362,7 +349,56 @@ async function realize(steps, props) {
 		totalDebt: debt,
 		totalValue: projected.totalValue
 	};
-	const projection = sdk.positions.projection(snapshot, { availableLiquidityChange: creditAccount.totalDebt - debt });
+	const executionCost = traded.priced && traded.spentUnd > 0n ? {
+		amount: market.toUnderlyingAmount(traded.returnedUnd - traded.spentUnd),
+		rate: PERCENTAGE_FACTOR_1KK * (traded.returnedUnd - traded.spentUnd) / traded.spentUnd
+	} : void 0;
+	/**
+	* Everything about where the account lands except how much depth the routes
+	* cost, which is a quote of its own and waits until the guards have spoken.
+	*
+	* The same builder the preview module fills its answers from, so a state
+	* this walk plans and the state read back out of the calls it produced are
+	* described by one piece of code. Debt taken on leaves the pool, debt repaid
+	* returns to it.
+	*/
+	const settle = () => ({
+		...sdk.positions.projection(snapshot, { availableLiquidityChange: creditAccount.totalDebt - debt }),
+		executionCost,
+		currentPrice: sdk.positions.currentPrice(snapshot)
+	});
+	/**
+	* Read before the guards below rather than after them, so a plan they turn
+	* down is still described by the state they turned it down on — which is the
+	* question a form asks next, and the reason a guard's verdict is worth more
+	* than its code alone.
+	*
+	* A snapshot the oracle cannot value goes unanswered here and is raised by
+	* the success path instead: a guard's verdict is the better answer when
+	* there is one.
+	*/
+	let reached;
+	try {
+		reached = settle();
+		Object.assign(draft, reached);
+	} catch {
+		reached = void 0;
+	}
+	assertGrowthAllowed({
+		sdk,
+		suite,
+		market,
+		before: creditAccount.tokens,
+		after: projected.assets
+	});
+	if (!cleared && quotas.quotaIncrease.length + quotas.quotaDecrease.length > 0) {
+		assertQuotaAvailable(sdk, market, quotas.quotaIncrease);
+		push(buildQuotaUpdateOperation({
+			update: quotas,
+			creditAccount,
+			sdk
+		}));
+	}
 	const settled = {
 		...snapshot,
 		assets,
@@ -381,16 +417,11 @@ async function realize(steps, props) {
 		toUnderlying: (from, amount) => price(from, underlying, amount),
 		toUnderlyingAmount: market.toUnderlyingAmount
 	});
-	const executionCost = traded.priced && traded.spentUnd > 0n ? {
-		amount: market.toUnderlyingAmount(traded.returnedUnd - traded.spentUnd),
-		rate: PERCENTAGE_FACTOR_1KK * (traded.returnedUnd - traded.spentUnd) / traded.spentUnd
-	} : void 0;
 	const state = {
-		...projection,
-		priceImpact,
-		executionCost,
-		currentPrice: sdk.positions.currentPrice(snapshot)
+		...reached ?? settle(),
+		priceImpact
 	};
+	Object.assign(draft, state);
 	return {
 		operations,
 		state,