@gearbox-protocol/sdk 17.0.0-next.4 → 17.0.0

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

@@ -6,6 +6,7 @@ import { checkCreditManagerPaused } from "../../validation/checks/checkCreditMan
 import { checkForbiddenToken } from "../../validation/checks/checkForbiddenToken.js";
 import { checkMarketExpired } from "../../validation/checks/checkMarketExpired.js";
 import { checkQuotaLimit } from "../../validation/checks/checkQuotaLimit.js";
+import { checkReservePriceLimited } from "../../validation/checks/checkReservePriceLimited.js";
 import { raise } from "../../validation/raise.js";
 import "../../validation/index.js";
 import { eq } from "./utils/common.js";
@@ -111,13 +112,24 @@ function assertGrowthAllowed(args) {
 * whose reserve feed the SDK cannot read keeps its main price, so a plan can
 * still be refused on-chain after passing here.
 */
-function assertCollateralised(healthFactorBps, safePrices) {
+function assertCollateralised(healthFactorBps, safePrices, atSafePrices) {
 	const healthFactorThreshold = MIN_HEALTH_FACTOR_FACADE;
-	raise(checkCollateralised({
+	const errors = checkCollateralised({
 		healthFactor: healthFactorBps,
 		healthFactorThreshold,
 		safePrices
-	}), `the account would end at a health factor of ${healthFactorBps}, below ${healthFactorThreshold}`);
+	});
+	if (errors.length === 0) return;
+	if (safePrices && atSafePrices) {
+		const { atMainPrices, withdrawable } = atSafePrices();
+		raise(checkReservePriceLimited({
+			healthFactor: healthFactorBps,
+			atMainPrices,
+			healthFactorThreshold,
+			withdrawable
+		}), `the account covers its debt at ${atMainPrices} on the main feed and only ${healthFactorBps} at the reserve one, below ${healthFactorThreshold}`);
+	}
+	raise(errors, `the account would end at a health factor of ${healthFactorBps}, below ${healthFactorThreshold}`);
 }
 /**
 * A quota can only be raised as far as the market still has room for: past the

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

@@ -7,14 +7,16 @@ import { IntentPreviewError } from "../../validation/raise.js";
 import "../../validation/index.js";
 import { isPhantomToken } from "./utils/pick-token.js";
 import { assertMarketOperable } from "./guards.js";
+import { fetchCreditAccountSlice, toCreditAccountSlice } from "./utils/credit-account-slice.js";
+import { buildBorrowState } from "./borrow.js";
 import { calcLeverageBand } from "./leverage-band.js";
-import { maxProportionalWithdrawal } from "./math.js";
+import { maxBorrow } from "./maxBorrow.js";
 import { maxWithdrawCollateral } from "./maxWithdrawCollateral.js";
-import { fetchCreditAccountSlice, toCreditAccountSlice } from "./utils/credit-account-slice.js";
 import { buildOpenStrategyState } from "./open-strategy.js";
 import { planAddCollateral, planAdjustLeverage, planAdjustLeverageDelayed, planDeposit, planRepay, planWithdraw, planWithdrawAsset, planWithdrawDelayed } from "./plan.js";
-import { realize } from "./realize.js";
 import { accountView } from "./view.js";
+import { withdrawLimits } from "./withdraw-limits.js";
+import { realize } from "./realize.js";
 import { planTail, projectTail } from "./tail.js";
 //#region src/onchain/accounts/intents/index.ts
 /**
@@ -50,26 +52,29 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	}
 	/**
 	* Both ends of what a `WITHDRAW` can take out, in underlying: the largest
-	* partial withdrawal that keeps leverage and stays inside the facade's
-	* `debtLimits`, and the net value an exit hands over. They are reported together
-	* because a withdraw form needs both — the range it may offer, and the one
-	* amount past it that is allowed — and because the distance between them is
-	* the account's own, not a constant a caller could assume.
+	* partial withdrawal that keeps leverage, and the net value an exit hands
+	* over. They are reported together because a withdraw form needs both — the
+	* range it may offer, and the one amount past it that is allowed — and
+	* because the distance between them is the account's own, not a constant a
+	* caller could assume.
 	*
-	* Takes no target health factor, unlike {@link maxWithdrawCollateral}: a
-	* proportional withdrawal leaves the factor where it found it, and the
-	* facade's `minDebt` is what bounds it.
+	* Two rules bound the partial end and both are reported: the facade's
+	* `debtLimits` as `partial`, and the safe-price collateral check on top of
+	* it as `safePartial`. The second is the one to offer — see
+	* {@link WithdrawCeilings}.
 	*
-	* @param props - Account slice and the SDK holding its market
-	* @returns The two ceilings, see {@link WithdrawCeilings} for the gap between
-	* them
+	* Takes no target health factor, unlike {@link maxWithdrawCollateral}. A
+	* proportional withdrawal leaves the factor where it found it, so there is
+	* no room to choose: what these answer to is the facade's own threshold,
+	* which is also what {@link startIntent} refuses against.
+	*
+	* @param props - Account slice, the SDK holding its market, and optionally
+	* the collateral the withdrawal would be funded from
+	* @returns The three limits, see {@link WithdrawCeilings} for the gap
+	* between them
 	*/
 	maxWithdraw(props) {
-		const view = accountView(props.creditAccount, props.sdk);
-		return {
-			partial: maxProportionalWithdrawal(view, view.debtLimits),
-			exit: view.collateral > 0n ? view.collateral : 0n
-		};
+		return withdrawLimits(props);
 	}
 	/**
 	* Debt a `REPAY` would have to cover to settle the account, in underlying
@@ -129,6 +134,34 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 		});
 	}
 	/**
+	* Largest loan a given collateral supports at `targetHF`, in the payout
+	* token's units — the ceiling a borrow form should offer.
+	*
+	* Reads no account, like {@link leverageBand}: the borrow opens one. The
+	* collateral is valued the way the transaction will be judged, at safe
+	* prices and under the quota the borrow buys, and the answer is then held to
+	* what the market will lend.
+	*
+	* A ceiling, not a verdict: the facade's `minDebt` is a floor and is not
+	* applied here, so collateral too small for this market still answers with
+	* what it carries and {@link borrowIntent} is the one that refuses the loan.
+	*
+	* The default is {@link MIN_HF_LIMITED}, the threshold a form holds an
+	* account to.
+	*
+	* @param props - The manager, the SDK holding its market, the collateral put
+	* up, the token to be paid in, and optionally the health factor to land at
+	* @returns Amount in the payout token's units; `0n` where no loan of this
+	* shape can be funded at any size
+	*/
+	maxBorrow(props) {
+		const { targetHF = MIN_HF_LIMITED, ...rest } = props;
+		return maxBorrow({
+			...rest,
+			targetHF: targetHF + 2n
+		});
+	}
+	/**
 	* Previews the same operation when its source only redeems through its
 	* issuer: a Securitize dsToken, a Mellow share.
 	*
@@ -179,7 +212,10 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 			});
 			return {
 				...result,
-				state: tail.state,
+				state: {
+					...tail.state,
+					executionCost: result.state.executionCost
+				},
 				delayed
 			};
 		} catch (e) {
@@ -271,6 +307,26 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 		};
 	}
 	/**
+	* Previews opening an account that holds nothing.
+	*
+	* Nothing is put up, drawn or routed, so there is no state to build and no
+	* guard to run beyond the market's own: a paused or expired facade takes no
+	* multicall, and an opening is a multicall like any other. Answers the same
+	* envelope its two neighbours do so a caller branches on `ok` throughout.
+	*
+	* @param props - The SDK holding the market, and the manager to open in
+	* @returns `{ ok: true }`, or `{ ok: false, error }` when the market takes
+	* no transaction right now
+	*/
+	async openEmptyAccountIntent(props) {
+		try {
+			assertMarketOperable(props.sdk.marketRegister.findCreditManager(props.creditManager));
+			return { ok: true };
+		} catch (e) {
+			return asSDKError(e);
+		}
+	}
+	/**
 	* Previews opening a brand-new leveraged position.
 	*
 	* Sits apart from {@link startIntent} because there is no account yet: nothing
@@ -292,6 +348,37 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 			return asSDKError(e);
 		}
 	}
+	/**
+	* Previews taking a loan against collateral, on an account this same
+	* transaction opens.
+	*
+	* Sits beside {@link openStrategyIntent} rather than under
+	* {@link startIntent} for the same reason: there is no account yet, and the
+	* output feeds `sdk.accounts.openCA`. What sets it apart from an opening is
+	* where the loan goes — out to the wallet rather than into a position — so
+	* the debt is named outright instead of following from a leverage, and the
+	* collateral is the only thing the account is left holding.
+	*
+	* `creditAccount` draws the loan on one the wallet already holds instead of
+	* opening another, as an opening takes one.
+	*
+	* @param props - Credit manager, the collateral the wallet puts up and the
+	* payout it asks for
+	* @returns Debt, the payout's two branches and the projection the account
+	* lands in, or `{ ok: false, error }` when the loan is not viable — a debt
+	* outside the facade's limits, collateral that cannot carry it, a payout the
+	* router has no path to
+	*/
+	async borrowIntent(props) {
+		try {
+			return {
+				ok: true,
+				state: await buildBorrowState(props)
+			};
+		} catch (e) {
+			return asSDKError(e);
+		}
+	}
 	/** Plan → realise → wrap. Unviable requests become `{ ok: false }`. */
 	async #preview(props, plan) {
 		try {

package/dist/esm/onchain/accounts/intents/leverage-band.js

@@ -1,5 +1,6 @@
 import { BigIntMath } from "../../utils/bigint-math.js";
 import { LEVERAGE_DECIMALS } from "../../constants/math.js";
+import { resolveCreditManager } from "./utils/common.js";
 //#region src/onchain/accounts/intents/leverage-band.ts
 /**
 * The leverages this market will actually fund for a position of this size.
@@ -29,7 +30,7 @@ import { LEVERAGE_DECIMALS } from "../../constants/math.js";
 * ```
 **/
 function calcLeverageBand({ sdk, creditManager, collateral, targetHF }) {
-	const found = resolve(sdk, creditManager);
+	const found = resolveCreditManager(sdk, creditManager);
 	if (!found) return;
 	const { suite, market } = found;
 	const target = suite.strategyTargetCollateral;
@@ -54,16 +55,5 @@ function calcLeverageBand({ sdk, creditManager, collateral, targetHF }) {
 		max
 	};
 }
-/** The manager's suite and market, or nothing while they cannot be resolved. */
-function resolve(sdk, creditManager) {
-	try {
-		return {
-			suite: sdk.marketRegister.findCreditManager(creditManager),
-			market: sdk.marketRegister.findByCreditManager(creditManager)
-		};
-	} catch {
-		return;
-	}
-}
 //#endregion
 export { calcLeverageBand };

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

@@ -0,0 +1,87 @@
+import { BigIntMath } from "../../utils/bigint-math.js";
+import "../../constants/math.js";
+import "../../utils/index.js";
+import { eq, resolveCreditManager, toTargetDecimals } from "./utils/common.js";
+import { unopenedAccountSlice } from "./utils/credit-account-slice.js";
+import "./utils/index.js";
+import { borrowCollateralQuota } from "./borrow.js";
+import { collateralValuation } from "./collateral-valuation.js";
+//#region src/onchain/accounts/intents/maxBorrow.ts
+/**
+* Largest loan this collateral supports at `targetHF` — the ceiling a borrow
+* form should offer, in the payout token's units.
+*
+* The inverse of a borrow rather than a search for one: the loan leaves the
+* account entirely, so the collateral is the whole of what backs the debt, and
+* the health factor is one division away from the amount. Solving it the other
+* way round costs a division too, and no iteration.
+*
+* Collateral is valued the way the transaction will be judged — at safe
+* prices, under its liquidation threshold, capped by the quota the borrow
+* buys for it, all of which is {@link collateralValuation}'s business. The ceiling
+* is then held to what the market will actually lend: the pool's free
+* liquidity, the manager's own allowance and the facade's `maxDebt`, whichever
+* binds first.
+*
+* The facade's `minDebt` is deliberately not applied. It is a floor, and a
+* ceiling answered as `0n` because the collateral is too small for this market
+* would tell a form nothing about what it is holding — the number a user needs
+* to see is the one they are short of. Collateral that carries something
+* therefore answers with it, whether or not the market would lend that little;
+* a loan under the floor is refused by `borrow` itself, with `debtOutOfRange`
+* naming both ends.
+*
+* Nothing is fetched or simulated — the account does not exist yet and every
+* input is loaded market state, so a form can call this on each keystroke.
+*
+* @param props - {@link MaxBorrowProps}
+* @returns Amount in the payout token's units; `0n` where no loan of this
+* shape exists at any size — a collateral that backs nothing at safe prices, a
+* market with nothing left to lend, and a manager the SDK does not hold yet
+**/
+function maxBorrow(props) {
+	const { sdk, creditManager, collateralAmount, targetHF, quotaReserve } = props;
+	const found = resolveCreditManager(sdk, creditManager);
+	if (!found) return 0n;
+	const { suite, market } = found;
+	const { priceOracle } = market;
+	const underlying = market.pool.underlying.toLowerCase();
+	const collateralToken = props.collateralToken.toLowerCase();
+	const borrowToken = props.borrowToken.toLowerCase();
+	const rwaAsset = sdk.tokensMeta.rwaUnderlyings.get(underlying)?.asset?.toLowerCase();
+	if (eq(collateralToken, borrowToken)) return 0n;
+	if (rwaAsset && eq(borrowToken, underlying)) return 0n;
+	if (collateralAmount <= 10n || targetHF <= 0n) return 0n;
+	const quotas = borrowCollateralQuota({
+		sdk,
+		creditManager,
+		assets: [{
+			token: collateralToken,
+			balance: collateralAmount
+		}],
+		quotaReserve
+	});
+	const holding = {
+		token: collateralToken,
+		balance: collateralAmount,
+		quota: quotas.find((q) => eq(q.token, collateralToken))?.balance ?? 0n,
+		mask: 0n,
+		success: true
+	};
+	const valuation = collateralValuation({
+		...unopenedAccountSlice({
+			creditManager,
+			creditFacade: suite.creditFacade.address,
+			underlying
+		}),
+		tokens: [holding]
+	}, sdk);
+	const weighted = valuation.checkedUsd(holding) * valuation.lt(collateralToken);
+	const backed = quotas.some((q) => eq(q.token, collateralToken)) ? BigIntMath.min(valuation.quotaValue(holding), weighted) : weighted;
+	if (backed <= 0n) return 0n;
+	const ceiling = BigIntMath.min(priceOracle.safeConvertFromUSD(underlying, backed / targetHF).value, suite.maxBorrowAmount().amount.value);
+	const unwrapsPayout = !!rwaAsset && eq(borrowToken, rwaAsset);
+	return eq(borrowToken, underlying) ? ceiling : unwrapsPayout ? toTargetDecimals(ceiling, underlying, borrowToken, sdk) : priceOracle.safeConvert(underlying, borrowToken, ceiling).value;
+}
+//#endregion
+export { maxBorrow };

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

@@ -1,21 +1,17 @@
 import { BigIntMath } from "../../utils/bigint-math.js";
-import { PERCENTAGE_FACTOR } from "../../constants/math.js";
+import "../../constants/math.js";
 import "../../utils/index.js";
 import { eq } from "./utils/common.js";
+import { collateralValuation } from "./collateral-valuation.js";
 //#region src/onchain/accounts/intents/maxWithdrawCollateral.ts
 /**
 * Largest amount of one collateral the account can withdraw while its health
 * factor stays at or above `targetHF`.
 *
 * This is the collateral check solved for one balance, and it counts what that
-* check counts: a holding backed by a quota contributes the lesser of the
-* quota and its threshold-weighted value, an unquoted one — the underlying —
-* its weighted value alone, and dust or a disabled balance nothing at all.
-* Collateral is valued at the protocol safe price (`min` of the two feeds,
-* 0 when there is no reserve), the way the facade values a call that hands
-* funds over; the underlying is exempt and is valued at the main feed, as
-* `CreditManagerV3._safeConvertToUSD` does. The debt is valued at the main
-* feed, as the check does. Zero debt frees the whole balance.
+* check counts — see {@link collateralValuation} for it, safe prices included.
+* The debt is valued at the main feed, as the check does. Zero debt frees the
+* whole balance.
 *
 * Rounding always favours the account, so the answer clears the check rather
 * than landing a wei short of it.
@@ -26,49 +22,27 @@ import { eq } from "./utils/common.js";
 **/
 function maxWithdrawCollateral(props) {
 	const { creditAccount, sdk, token, targetHF } = props;
-	const { market, creditManager } = sdk.marketRegister.findCreditManager(creditAccount.creditManager);
-	const { priceOracle } = market;
-	const { pqk } = market.pool;
-	const underlying = market.pool.underlying;
 	const target = creditAccount.tokens.find((t) => eq(t.token, token));
 	if (!target || target.balance <= 10n) return 0n;
 	if (creditAccount.totalDebt === 0n) return target.balance;
-	const masked = creditAccount.enabledTokensMask !== 0n;
-	const counts = (t) => t.balance > 10n && (!masked || (t.mask & creditAccount.enabledTokensMask) !== 0n);
-	/** What a holding backs, in the check's units: USD × PERCENTAGE_FACTOR. */
-	const weigh = (t) => {
-		const lt = BigInt(creditManager.liquidationThresholds.get(t.token) ?? 0);
-		const weighted = (eq(t.token, underlying) ? usd(priceOracle, t.token, t.balance) ?? 0n : priceOracle.safeConvertMinUSD(t.token, t.balance).value) * lt;
-		if (t.quota === 0n) return weighted;
-		return BigIntMath.min(quotaUsd(t) * PERCENTAGE_FACTOR, weighted);
-	};
-	/** A quota is underlying-denominated, and a closed market backs nothing. */
-	const quotaUsd = (t) => pqk.hasActiveQuota(t.token) ? usd(priceOracle, underlying, t.quota) ?? 0n : 0n;
-	let otherMoney = 0n;
+	const valuation = collateralValuation(creditAccount, sdk);
+	let otherValue = 0n;
 	for (const t of creditAccount.tokens) {
-		if (eq(t.token, token) || !counts(t)) continue;
-		otherMoney += weigh(t);
+		if (eq(t.token, token) || !valuation.counts(t)) continue;
+		otherValue += valuation.weigh(t);
 	}
-	const borrowed = usd(priceOracle, underlying, creditAccount.totalDebt);
+	const borrowed = valuation.mainUsd(valuation.underlying, creditAccount.totalDebt);
 	if (borrowed === void 0 || borrowed <= 0n) return 0n;
 	const required = borrowed * targetHF;
-	if (required <= otherMoney) return target.balance;
-	const shortfall = required - otherMoney;
-	if (target.quota > 0n && quotaUsd(target) * 10000n < shortfall) return 0n;
-	const targetLt = BigInt(creditManager.liquidationThresholds.get(target.token) ?? 0);
-	const targetUsd = eq(target.token, underlying) ? usd(priceOracle, target.token, target.balance) ?? 0n : priceOracle.safeConvertMinUSD(target.token, target.balance).value;
+	if (required <= otherValue) return target.balance;
+	const shortfall = required - otherValue;
+	if (target.quota > 0n && valuation.quotaValue(target) < shortfall) return 0n;
+	const targetLt = valuation.lt(target.token);
+	const targetUsd = valuation.checkedUsd(target);
 	if (targetLt === 0n || targetUsd === 0n) return 0n;
 	const keptUsd = BigIntMath.ceilDiv(shortfall, targetLt);
 	const kept = BigIntMath.ceilDiv(target.balance * keptUsd, targetUsd);
 	return kept >= target.balance ? 0n : target.balance - kept;
 }
-/** USD value at the main feed, or `undefined` when the token has no price. */
-function usd(oracle, token, amount) {
-	try {
-		return oracle.convertToUSD(token, amount);
-	} catch {
-		return;
-	}
-}
 //#endregion
 export { maxWithdrawCollateral };

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

@@ -3,17 +3,13 @@ import "../../../model/index.js";
 import { IntentPreviewError } from "../../validation/raise.js";
 import { assertCanBorrow, assertCollateralised, assertGrowthAllowed, assertMarketOperable, assertQuotaAvailable } from "./guards.js";
 import { assertDebtLimits, assertLeverageAtLeastOne, debtForLeverage } from "./math.js";
+import { unopenedAccountSlice } from "./utils/credit-account-slice.js";
 import { collectPriceImpact } from "./utils/price-impact.js";
 import { getQuotasForUpdate } from "./utils/quotas-for-update.js";
 import { createRouterPaths } from "./utils/router-path.js";
 import "./utils/index.js";
 //#region src/onchain/accounts/intents/open-strategy.ts
 /**
-* Stand-in account address, used when the opening creates its own account:
-* nothing exists on chain until the tx lands.
-*/
-const NO_ACCOUNT = "0x0000000000000000000000000000000000000000";
-/**
 * Builds the state opening a leveraged position out of wallet collateral would
 * reach.
 *
@@ -26,7 +22,6 @@ const NO_ACCOUNT = "0x0000000000000000000000000000000000000000";
 * `sdk.accounts.openCA`.
 */
 async function buildOpenStrategyState(props) {
-	if (props.empty) return emptyOpenState(props);
 	const { sdk, creditManager, collateral, targetToken, leverage, slippage = 0, quotaReserve, leftoverBalances = [], creditAccount: existing } = props;
 	assertLeverageAtLeastOne(leverage);
 	const suite = sdk.marketRegister.findCreditManager(creditManager);
@@ -37,16 +32,11 @@ async function buildOpenStrategyState(props) {
 	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);
-	const account = existing ?? {
-		creditAccount: NO_ACCOUNT,
-		creditManager: creditManager.toLowerCase(),
-		creditFacade: suite.creditFacade.address.toLowerCase(),
-		underlying,
-		enabledTokensMask: 0n,
-		totalDebtUSD: 0n,
-		totalDebt: 0n,
-		tokens: []
-	};
+	const account = existing ?? unopenedAccountSlice({
+		creditManager,
+		creditFacade: suite.creditFacade.address,
+		underlying
+	});
 	assertDebtLimits(sdk, debt, suite.creditFacade, underlying);
 	assertCanBorrow(sdk, suite, debt);
 	const paths = createRouterPaths({
@@ -96,7 +86,8 @@ async function buildOpenStrategyState(props) {
 	const priceImpact = await collectPriceImpact(leg.probe ? [leg.probe] : [], {
 		totalValue: margin + debt,
 		netValue: margin,
-		toUnderlying: (from, amount) => convert(from, underlying, amount)
+		toUnderlying: (from, amount) => convert(from, underlying, amount),
+		toUnderlyingAmount: market.toUnderlyingAmount
 	});
 	return {
 		...projection,
@@ -110,35 +101,6 @@ async function buildOpenStrategyState(props) {
 		creditAccount: existing?.creditAccount
 	};
 }
-/**
-* The opening that holds an account and nothing else.
-*
-* Taken before the walk rather than threaded through it: the router has no
-* guard for an empty basket and would still make its `eth_call`, and every
-* assertion below reads amounts that are not there.
-*/
-async function emptyOpenState(props) {
-	const { sdk, creditManager } = props;
-	assertMarketOperable(sdk.marketRegister.findCreditManager(creditManager));
-	const snapshot = {
-		creditManager,
-		assets: [],
-		quotas: [],
-		totalDebt: 0n,
-		totalValue: 0n
-	};
-	const { assets: _assets, quotas: _quotas, ...projection } = sdk.positions.projection(snapshot, { availableLiquidityChange: 0n });
-	return {
-		...projection,
-		currentPrice: sdk.positions.currentPrice(snapshot),
-		priceImpact: void 0,
-		averageAssets: [],
-		minAssets: [],
-		averageQuota: [],
-		minQuota: [],
-		calls: []
-	};
-}
 /** Collateral plus the borrowed underlying, folded into one balance per token. */
 function mergeExpectedBalances(collateral, underlying, debt) {
 	const merged = /* @__PURE__ */ new Map();

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

@@ -54,7 +54,6 @@ function buildSwapOperation(input) {
 * underlying comes out.
 */
 function buildCloseSwapOperation(input) {
-	if (input.calls.length === 0) throw new Error("swap: missing router calls");
 	return {
 		type: "swap",
 		from: input.from,

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

@@ -1,3 +1,4 @@
+import { PERCENTAGE_FACTOR_1KK } from "../../constants/math.js";
 import { insufficientBalance } from "../../../model/errors/operation-errors.js";
 import { multipleDelayedWithdrawals, noDelayedRoute, withdrawalInProgress } from "../../../model/errors/prepare-errors.js";
 import "../../../model/index.js";
@@ -11,6 +12,7 @@ import { collectPriceImpact } from "./utils/price-impact.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";
+import { withdrawLimits } from "./withdraw-limits.js";
 //#region src/onchain/accounts/intents/realize.ts
 /**
 * Turns a plan into operations: the one place that talks to the router, knows
@@ -48,6 +50,7 @@ async function realize(steps, props) {
 	* can revert.
 	*/
 	const ledger = new OperationLedger(start);
+	const opening = ledger.snapshot();
 	/**
 	* The same walk with every routed leg counted at the amount the pathfinder
 	* expects to return. Nothing is built from it: it is where the position
@@ -71,6 +74,26 @@ async function realize(steps, props) {
 	let raised = 0n;
 	/** The request, before the walk's end state can be attached to it. */
 	let delayed;
+	/** Oracle value in the underlying of what routed legs and requests spend and return. */
+	const traded = {
+		spentUnd: 0n,
+		returnedUnd: 0n,
+		priced: true
+	};
+	const trade = (spent, returned) => {
+		const underlyingValue = (legs) => {
+			let sum = 0n;
+			for (const { token, amount } of legs) {
+				if (amount === 0n) continue;
+				const value = price(token, underlying, amount);
+				if (value <= 0n) traded.priced = false;
+				sum += value;
+			}
+			return sum;
+		};
+		traded.spentUnd += underlyingValue(spent);
+		traded.returnedUnd += underlyingValue(returned);
+	};
 	/**
 	* 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.
@@ -172,6 +195,13 @@ async function realize(steps, props) {
 				...swap,
 				amountOut: leg.amount
 			});
+			trade([{
+				token: step.from,
+				amount
+			}], [{
+				token: step.to,
+				amount: leg.amount
+			}]);
 			raised = leg.minAmount;
 			break;
 		}
@@ -197,6 +227,13 @@ async function realize(steps, props) {
 						})),
 						amountOut: leg.amount
 					});
+					trade(balances.map((a) => ({
+						token: a.token,
+						amount: a.balance
+					})), [{
+						token: underlying,
+						amount: leg.amount
+					}]);
 				}
 			}
 			raised = ledger.balanceOf(underlying);
@@ -241,6 +278,13 @@ async function realize(steps, props) {
 					amount: toTargetDecimals(queued.amount, queued.token, asset.underlying, sdk)
 				} : void 0
 			};
+			trade([{
+				token: preview.token,
+				amount: preview.amountIn
+			}], [...preview.outputs.filter((o) => !o.isDelayed).map((o) => ({
+				token: o.token,
+				amount: o.amount
+			})), ...delayed.claim ? [delayed.claim] : []]);
 			raised = instantOutput(preview.outputs)?.amount ?? 0n;
 			break;
 		}
@@ -319,19 +363,32 @@ async function realize(steps, props) {
 		totalValue: projected.totalValue
 	};
 	const projection = sdk.positions.projection(snapshot, { availableLiquidityChange: creditAccount.totalDebt - debt });
-	assertCollateralised(sdk.positions.healthFactor({
+	const settled = {
 		...snapshot,
 		assets,
 		totalValue: floor.totalValue
-	}, { safePrices: withdrawsCollateral }), withdrawsCollateral);
+	};
+	assertCollateralised(sdk.positions.healthFactor(settled, { safePrices: withdrawsCollateral }), withdrawsCollateral, () => ({
+		atMainPrices: sdk.positions.healthFactor(settled, { safePrices: false }),
+		withdrawable: toTokenAmount(sdk, underlying, withdrawLimits({
+			creditAccount,
+			sdk
+		}).safePartial)
+	}));
 	const priceImpact = await collectPriceImpact(probes, {
 		totalValue: projected.totalValue,
-		netValue: projected.totalValue - debt,
-		toUnderlying: (from, amount) => price(from, underlying, amount)
+		netValue: opening.totalValue - opening.debt,
+		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)
 	};
 	return {

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

@@ -7,8 +7,8 @@ import { toTargetDecimals } from "./utils/common.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";
+import { realize } from "./realize.js";
 //#region src/onchain/accounts/intents/tail.ts
 /**
 * The second half of a delayed intent: the claim, then whatever the intent

package/dist/esm/onchain/accounts/intents/testing/sdk-mock.js

@@ -203,6 +203,7 @@ function buildMockSdk(args) {
 			liquidationThresholds,
 			collateralTokens,
 			feeInterest: args.feeInterest ?? 0,
+			maxEnabledTokens: args.maxEnabledTokens ?? 4,
 			maxLeverage: (collateral, targetHF) => calcMaxLeverage(liquidationThresholds.get(collateral) ?? 0, targetHF)
 		},
 		creditFacade: {