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

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

@@ -0,0 +1,132 @@
+import "../../constants/math.js";
+import { IntentPreviewError } from "./types.js";
+import { convertAmount } from "./utils/convert-amount.js";
+import { assertCanBorrow, assertCollateralised, assertGrowthAllowed, assertMarketOperable, assertQuotaHeadroom } from "./guards.js";
+import { assertDebtInBand, debtForLeverage } from "./math.js";
+import { getQuotasForUpdate } from "./utils/quotas-for-update.js";
+import { createRouterPaths } from "./utils/router-path.js";
+import "./utils/index.js";
+//#region src/sdk/accounts/intents/open-strategy.ts
+/** Stand-in account address: nothing exists on chain until the tx lands. */
+const NO_ACCOUNT = "0x0000000000000000000000000000000000000000";
+/**
+* Previews opening a leveraged position out of wallet collateral.
+*
+* Debt follows from the target leverage against the supplied margin
+* (`debt = margin * (L - 1)`, `totalValue = margin * L`); the collateral and the
+* borrowed underlying are then routed into the target token in one pathfinder call.
+*
+* There is no account yet, so this does not go through `startIntent` and produces
+* no operation list — the caller passes the numbers and calls straight to
+* `sdk.accounts.openCA`.
+*/
+async function previewOpenStrategy(props) {
+	const { sdk, creditManager, collateral, targetToken, leverage, slippage = 0, quotaReserve, leftoverBalances = [] } = props;
+	if (leverage < 100n) throw new IntentPreviewError("leverageOutOfRange", `openStrategy: leverage ${leverage} is below 1x`);
+	const suite = sdk.marketRegister.findCreditManager(creditManager);
+	const market = sdk.marketRegister.findByCreditManager(creditManager);
+	assertMarketOperable(suite);
+	const underlying = market.pool.underlying.toLowerCase();
+	const convert = convertAmount(sdk, creditManager);
+	const margin = collateral.reduce((acc, a) => acc + convert(a.token, underlying, a.balance), 0n);
+	if (margin <= 0n) throw new IntentPreviewError("insufficientSourceBalance", "openStrategy: collateral is worth nothing in underlying");
+	const debt = debtForLeverage(margin, leverage);
+	const account = {
+		creditAccount: NO_ACCOUNT,
+		creditManager: creditManager.toLowerCase(),
+		creditFacade: suite.creditFacade.address.toLowerCase(),
+		underlying,
+		enabledTokensMask: 0n,
+		totalDebtUSD: 0n,
+		accountDebt: 0n,
+		tokens: []
+	};
+	assertDebtInBand(debt, suite.creditFacade);
+	assertCanBorrow(suite, debt);
+	const leg = await createRouterPaths({
+		sdk,
+		creditAccount: account,
+		slippage
+	}).openStrategy({
+		expectedBalances: mergeExpectedBalances(collateral, underlying, debt),
+		leftoverBalances,
+		target: targetToken
+	});
+	const averageAssets = toAssets(leg.balances);
+	const minAssets = toAssets(leg.minBalances);
+	const quotasFor = (assets) => getQuotasForUpdate({
+		assetsBefore: [],
+		assetsAfter: assets,
+		initialQuotas: [],
+		quotaReserve,
+		underlyingToken: underlying,
+		liquidationThresholds: suite.creditManager.liquidationThresholds,
+		quotas: market.pool.pqk.quotas,
+		maxDebt: suite.creditFacade.maxDebt,
+		convert
+	}).quotaIncrease;
+	const averageQuota = quotasFor(averageAssets);
+	const minQuota = quotasFor(minAssets);
+	assertGrowthAllowed({
+		sdk,
+		suite,
+		market,
+		before: [],
+		after: averageAssets
+	});
+	assertQuotaHeadroom(market, averageQuota);
+	const snapshot = {
+		creditManager,
+		assets: averageAssets,
+		quotas: averageQuota,
+		totalDebt: debt,
+		totalValue: margin + debt
+	};
+	const metrics = {
+		healthFactor: sdk.positions.healthFactor(snapshot),
+		overallApy: 0,
+		borrowRate: sdk.positions.borrowRate(snapshot),
+		timeToLiquidation: sdk.positions.timeToLiquidation(snapshot),
+		liquidationPrice: sdk.positions.liquidationPrice(snapshot)
+	};
+	assertCollateralised(metrics.healthFactor);
+	return {
+		debt,
+		collateral: margin,
+		totalValue: margin + debt,
+		averageAssets,
+		minAssets,
+		averageQuota,
+		minQuota,
+		calls: [...leg.calls],
+		...metrics
+	};
+}
+/** Collateral plus the borrowed underlying, folded into one balance per token. */
+function mergeExpectedBalances(collateral, underlying, debt) {
+	const merged = /* @__PURE__ */ new Map();
+	for (const a of collateral) {
+		const token = a.token.toLowerCase();
+		merged.set(token, (merged.get(token) ?? 0n) + a.balance);
+	}
+	if (debt > 0n) merged.set(underlying, (merged.get(underlying) ?? 0n) + debt);
+	return [...merged.entries()].map(([token, balance]) => ({
+		token,
+		balance
+	}));
+}
+/** Router balance records carry mixed-case keys; normalise and drop empties. */
+function toAssets(balances) {
+	const merged = /* @__PURE__ */ new Map();
+	for (const [token, balance] of Object.entries(balances)) {
+		if (balance <= 0n) continue;
+		const key = token.toLowerCase();
+		merged.set(key, (merged.get(key) ?? 0n) + balance);
+	}
+	return [...merged.entries()].map(([token, balance]) => ({
+		token,
+		balance
+	}));
+}
+//#endregion
+export { previewOpenStrategy };

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

@@ -0,0 +1,153 @@
+import { MAX_UINT256 } from "../../constants/math.js";
+//#region src/sdk/accounts/intents/operations.ts
+function buildAddCollateralOperation(input) {
+	return {
+		type: "addCollateral",
+		token: input.token,
+		amount: input.amount,
+		value: input.value,
+		calls: input.sdk.accounts.prepareAddCollateral(input.creditAccount.creditFacade, [{
+			token: input.token,
+			balance: input.amount
+		}], {})
+	};
+}
+function buildIncreaseDebtOperation(input) {
+	return {
+		type: "increaseDebt",
+		amount: input.amount,
+		calls: [input.sdk.accounts.prepareIncreaseDebt(input.creditAccount.creditFacade, input.amount)]
+	};
+}
+function buildDecreaseDebtOperation(input) {
+	return {
+		type: "decreaseDebt",
+		amount: input.amount,
+		...input.full ? { full: true } : {},
+		calls: [input.sdk.accounts.prepareChangeDebt(input.creditAccount.creditFacade, input.full ? MAX_UINT256 : input.amount, true)]
+	};
+}
+function buildWithdrawCollateralOperation(input) {
+	return {
+		type: "withdrawCollateral",
+		token: input.token,
+		amount: input.amount,
+		to: input.to,
+		...input.all ? { all: true } : {},
+		calls: [input.sdk.accounts.prepareWithdrawToken(input.creditAccount.creditFacade, input.token, input.all ? MAX_UINT256 : input.amount, input.to)]
+	};
+}
+/** One routed leg, with the amounts it was quoted at. */
+function buildSwapOperation(input) {
+	return buildCloseSwapOperation({
+		from: [{
+			token: input.tokenIn,
+			balance: input.amountIn
+		}],
+		tokenOut: input.tokenOut,
+		amountOut: input.amountOut,
+		calls: input.calls
+	});
+}
+/**
+* The many-to-one leg an exit routes: every balance listed goes in, and the
+* underlying comes out.
+*/
+function buildCloseSwapOperation(input) {
+	if (input.calls.length === 0) throw new Error("swap: missing router calls");
+	return {
+		type: "swap",
+		from: input.from,
+		tokenOut: input.tokenOut,
+		amountOut: input.amountOut,
+		calls: input.calls
+	};
+}
+function buildQuotaUpdateOperation(input) {
+	const { update, creditAccount, sdk } = input;
+	const quotaAssets = [...update.quotaIncrease, ...update.quotaDecrease];
+	const calls = quotaAssets.length === 0 ? [] : sdk.accounts.prepareUpdateQuotas(creditAccount.creditFacade, {
+		averageQuota: quotaAssets,
+		minQuota: quotaAssets
+	});
+	return {
+		type: "changeQuota",
+		desiredQuota: update.desiredQuota,
+		quotaIncrease: update.quotaIncrease,
+		quotaDecrease: update.quotaDecrease,
+		calls
+	};
+}
+/** Wraps an RWA asset into the market underlying. */
+async function buildWrapRwaCollateralOperation(input) {
+	const calls = await input.sdk.accounts.assembleRWAWrapCalls(input.amountIn, input.creditAccount.creditManager);
+	if (!calls) throw new Error("wrapRwaCollateral: no wrap calls found");
+	return {
+		type: "wrapRwaCollateral",
+		tokenIn: input.tokenIn,
+		amount: input.amountIn,
+		tokenOut: input.tokenOut,
+		amountOut: input.amountOut,
+		calls
+	};
+}
+/** Unwraps the market underlying back into its RWA asset. */
+async function buildUnwrapRwaCollateralOperation(input) {
+	const calls = await input.sdk.accounts.assembleRWAUnwrapCalls(input.amountIn, input.creditAccount.creditManager);
+	if (!calls) throw new Error("unwrapRwaCollateral: no unwrap calls found");
+	return {
+		type: "unwrapRwaCollateral",
+		tokenIn: input.tokenIn,
+		amount: input.amountIn,
+		tokenOut: input.tokenOut,
+		amountOut: input.amountOut,
+		calls
+	};
+}
+function buildStartDelayedWithdrawalOperation(input) {
+	const { preview } = input;
+	return {
+		type: "startDelayedWithdrawal",
+		token: preview.token,
+		amountIn: preview.amountIn,
+		outputs: [...preview.outputs],
+		settlement: preview.outputs.some((o) => o.isDelayed) ? "delayed" : "instant",
+		calls: input.sdk.accounts.assembleStartDelayedWithdrawalCalls({
+			creditFacade: input.creditAccount.creditFacade,
+			preview
+		})
+	};
+}
+function buildClaimDelayedWithdrawalOperation(input) {
+	const { claimable } = input;
+	return {
+		type: "claimDelayedWithdrawal",
+		token: claimable.token.toLowerCase(),
+		withdrawalPhantomToken: claimable.withdrawalPhantomToken.toLowerCase(),
+		withdrawalTokenSpent: claimable.withdrawalTokenSpent,
+		outputs: claimable.outputs.map((o) => ({
+			...o,
+			token: o.token.toLowerCase()
+		})),
+		calls: input.sdk.accounts.assembleClaimDelayedCalls({
+			creditFacade: input.creditAccount.creditFacade,
+			claimableNow: claimable
+		})
+	};
+}
+/**
+* What a request or a claim puts on the account right away, as opposed to what
+* only the phantom token represents.
+*/
+function instantOutput(outputs, token) {
+	for (const out of outputs) {
+		if (out.isDelayed || out.amount <= 0n) continue;
+		if (token != null && out.token.toLowerCase() !== token.toLowerCase()) continue;
+		return {
+			token: out.token,
+			amount: out.amount
+		};
+	}
+}
+//#endregion
+export { buildAddCollateralOperation, buildClaimDelayedWithdrawalOperation, buildCloseSwapOperation, buildDecreaseDebtOperation, buildIncreaseDebtOperation, buildQuotaUpdateOperation, buildStartDelayedWithdrawalOperation, buildSwapOperation, buildUnwrapRwaCollateralOperation, buildWithdrawCollateralOperation, buildWrapRwaCollateralOperation, instantOutput };

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

@@ -0,0 +1,361 @@
+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.
+*/
+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 (!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)
+	];
+}
+/** 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, planFinishDecreaseLeverage, planFinishWithdraw, planRepay, planWithdraw, planWithdrawAsset, planWithdrawDelayed };