@gearbox-protocol/sdk 16.0.0-next.5 → 16.0.0-next.50

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

@@ -1,11 +1,13 @@
 import { SDKConstruct } from "../../base/SDKConstruct.js";
-import { MIN_HF_LIMITED } from "../../../common-utils/utils/validation/validate-hf.js";
-import { IntentPreviewError } from "./types.js";
-import { assertMarketOperable } from "./guards.js";
+import { MIN_HF_LIMITED } from "../../validation/checks.js";
+import { IntentPreviewError, refuse } from "../../validation/refusal.js";
+import { isPhantomToken } from "./utils/pick-token.js";
+import { assertMarketOperable, borrowable } from "./guards.js";
+import { calcLeverageBand } from "./leverage-band.js";
 import { maxProportionalWithdrawal } from "./math.js";
 import { maxWithdrawCollateral } from "./maxWithdrawCollateral.js";
 import { fetchCreditAccountSlice, toCreditAccountSlice } from "./utils/credit-account-slice.js";
-import { previewOpenStrategy } from "./open-strategy.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";
@@ -43,17 +45,27 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 		}));
 	}
 	/**
-	* Largest `WITHDRAW` amount (in underlying) the account can take out while
-	* keeping leverage and staying inside the facade's debt band — the ceiling a
-	* withdraw form should offer. Taking everything out is the same intent with
-	* `MAX_UINT256` for an amount, and needs none of this arithmetic.
+	* Both ends of what a `WITHDRAW` can take out, in underlying: the largest
+	* partial withdrawal that keeps leverage and stays inside the facade's debt
+	* band, 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.
 	*
 	* @param props - Account slice and the SDK holding its market
-	* @returns Amount in underlying units; `0n` when nothing can leave
+	* @returns The two ceilings, see {@link WithdrawCeilings} for the gap between
+	* them
 	*/
 	maxWithdraw(props) {
 		const view = accountView(props.creditAccount, props.sdk);
-		return maxProportionalWithdrawal(view, view.band);
+		return {
+			partial: maxProportionalWithdrawal(view, view.band),
+			exit: view.collateral > 0n ? view.collateral : 0n
+		};
 	}
 	/**
 	* Debt a `REPAY` would have to cover to settle the account, in underlying
@@ -72,20 +84,44 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 		return accountView(props.creditAccount, props.sdk).debt;
 	}
 	/**
+	* The leverages a position of a given size can be opened at, or moved to.
+	*
+	* A credit manager's `maxLeverage` follows from the liquidation threshold
+	* alone, so it is the same for a hundred dollars and for a million. What a
+	* given deposit reaches is decided by the debt it implies and by the band
+	* the market puts that debt in — the range a leverage slider should offer.
+	*
+	* Unlike the other ceilings here this one reads no account: opening has none
+	* yet, and adjusting measures against the net value the caller already
+	* holds. Nothing is fetched, so a form can ask on every keystroke.
+	*
+	* @param props - The manager, the SDK holding its market, what stands
+	* behind the position, and optionally the health factor the ceiling should
+	* leave
+	* @returns The band, or nothing when the market has none to offer
+	*/
+	leverageBand(props) {
+		return calcLeverageBand(props);
+	}
+	/**
 	* Largest `WITHDRAW_ASSET` amount of one token the account can take out
-	* while its health factor stays at {@link MIN_HF_LIMITED} plus a basis
-	* point — the ceiling a withdraw-collateral form should offer. Thresholds,
-	* prices and quota activity come from the account's market, valued the way
-	* the facade values a call that pays out; zero debt frees the whole balance.
+	* while its health factor stays at `targetHF` — the ceiling a
+	* withdraw-collateral form should offer. Thresholds, prices and quota
+	* activity come from the account's market, valued the way the facade values
+	* a call that pays out; zero debt frees the whole balance.
+	*
+	* The default is {@link MIN_HF_LIMITED}, the bar a form holds an
+	* account to.
 	*
-	* @param props - Account slice, the SDK holding its market, and the
-	* collateral to withdraw
+	* @param props - Account slice, the SDK holding its market, the collateral
+	* to withdraw, and optionally the health factor to leave behind
 	* @returns Amount in the token's units; `0n` when nothing can leave
 	*/
 	maxWithdrawCollateral(props) {
+		const { targetHF = MIN_HF_LIMITED, ...rest } = props;
 		return maxWithdrawCollateral({
-			...props,
-			targetHF: MIN_HF_LIMITED + 2n
+			...rest,
+			targetHF: targetHF + 2n
 		});
 	}
 	/**
@@ -139,7 +175,7 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 			});
 			return {
 				...result,
-				preview: tail.state,
+				state: tail.state,
 				delayed
 			};
 		} catch (e) {
@@ -169,9 +205,11 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 		const [instant, delayed] = await Promise.allSettled([this.startIntent(props), this.startDelayedIntent(props)]);
 		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 instantRefusal = instant.status === "fulfilled" && !instant.value.ok ? instant.value : void 0;
+		const delayedRefusal = delayed.status === "fulfilled" && !delayed.value.ok ? delayed.value : void 0;
 		const refused = {
-			instant: instant.status === "fulfilled" && !instant.value.ok ? instant.value.reason : void 0,
-			delayed: delayed.status === "fulfilled" && !delayed.value.ok ? delayed.value.reason : void 0
+			instant: instantRefusal?.reason,
+			delayed: delayedRefusal?.reason
 		};
 		if (instantRoute || delayedRoute) return {
 			ok: true,
@@ -181,11 +219,10 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 		};
 		const failed = [instant, delayed].find((s) => s.status === "rejected");
 		if (failed?.status === "rejected") throw failed.reason;
-		const reason = refused.instant ?? refused.delayed;
-		if (reason === void 0) throw new Error("intentRoutes: a route neither answered nor refused");
+		const chosen = instantRefusal ?? delayedRefusal;
+		if (chosen === void 0) throw new Error("intentRoutes: a route neither answered nor refused");
 		return {
-			ok: false,
-			reason,
+			...chosen,
 			refused
 		};
 	}
@@ -198,17 +235,36 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 	* whole tail: the tokens land on the account and only their quota has to
 	* catch up.
 	*
+	* A claim that brought only part of what the request queued — a legacy Mellow
+	* multivault, which pays out what it holds liquid and re-queues the rest — is
+	* served in proportion, and what it did not settle comes back as `remainder`:
+	* the withdrawal still in flight and the intent to finish it with.
+	*
 	* @param props - The recorded intent, the account slice as it stands now, and
 	* the matured claimable
-	* @returns Shaped exactly like {@link startIntent}'s result, so both halves of
-	* an operation are consumed the same way
+	* @returns Shaped exactly like {@link startIntent}'s result with the remainder
+	* beside it, so both halves of an operation are consumed the same way
 	*/
 	async finishIntent(props) {
-		return plain(await this.#preview(props, () => planTail({
-			intent: props.intent,
-			claimable: props.claimable,
-			view: accountView(props.creditAccount, props.sdk)
-		})));
+		let remainder;
+		const result = await this.#preview(props, () => {
+			const tail = planTail({
+				intent: props.intent,
+				claimable: props.claimable,
+				view: accountView(props.creditAccount, props.sdk)
+			});
+			remainder = tail.remainder;
+			return tail.steps;
+		});
+		if (!result.ok) return result;
+		const { operations, state, calls } = result;
+		return {
+			ok: true,
+			operations,
+			state,
+			calls,
+			remainder
+		};
 	}
 	/**
 	* Previews opening a brand-new leveraged position.
@@ -226,7 +282,7 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 		try {
 			return {
 				ok: true,
-				preview: await previewOpenStrategy(props)
+				state: await buildOpenStrategyState(props)
 			};
 		} catch (e) {
 			return asFailure(e);
@@ -245,7 +301,7 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 			return {
 				ok: true,
 				operations,
-				preview: state,
+				state,
 				calls,
 				delayed
 			};
@@ -257,24 +313,18 @@ var CreditAccountOperationsService = class extends SDKConstruct {
 /** Drops the delayed half for the flows that cannot produce one. */
 function plain(result) {
 	if (!result.ok) return result;
-	const { operations, preview, calls } = result;
+	const { operations, state, calls } = result;
 	return {
 		ok: true,
 		operations,
-		preview,
+		state,
 		calls
 	};
 }
 /** Unviable requests are values; anything else is a genuine failure. */
 function asFailure(e) {
-	if (e instanceof IntentPreviewError) return {
-		ok: false,
-		reason: e.reason
-	};
-	if (isUnroutable(e)) return {
-		ok: false,
-		reason: "unsupportedTokenPair"
-	};
+	if (e instanceof IntentPreviewError) return refuse(e.reason, e.detail);
+	if (isUnroutable(e)) return refuse("unsupportedTokenPair", void 0);
 	throw e;
 }
 /**
@@ -290,4 +340,4 @@ function isUnroutable(e) {
 	return false;
 }
 //#endregion
-export { CreditAccountOperationsService, IntentPreviewError, fetchCreditAccountSlice, toCreditAccountSlice };
+export { CreditAccountOperationsService, borrowable, fetchCreditAccountSlice, isPhantomToken, toCreditAccountSlice };

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

@@ -0,0 +1,69 @@
+import { BigIntMath } from "../../utils/bigint-math.js";
+import { LEVERAGE_DECIMALS } from "../../constants/math.js";
+//#region src/onchain/accounts/intents/leverage-band.ts
+/**
+* The leverages this market will actually fund for a position of this size.
+*
+* A credit manager's `maxLeverage` follows from the liquidation threshold
+* alone, so it is the same for a hundred dollars and for a million. What a
+* given deposit reaches is decided by the debt it implies —
+* `debt = netValue × (leverage − 1)` — and by the band the market puts that
+* debt in. This inverts that relation.
+*
+* Rounding is asymmetric because the forward direction truncates: the floor
+* rounds **up** so the leverage it names really does clear `minDebt`, and the
+* ceiling rounds **down** so it really does stay under the borrow limit.
+*
+* Nothing here is fetched or simulated — every input is loaded market state,
+* so a form can call this on each keystroke.
+*
+* @param props - {@link LeverageBandProps}
+* @returns The band, or `undefined` when there is nothing to offer: an
+* unknown manager, a market with no strategy, or a deposit too small to reach
+* `minDebt` at any leverage the threshold allows.
+*
+* @example
+* ```ts
+* // minDebt 1k, borrow limit 100k, threshold ceiling 9x, deposit worth 10k
+* calcLeverageBand({ sdk, creditManager, collateral }) // { min: 1.1, max: 9 }
+* ```
+**/
+function calcLeverageBand({ sdk, creditManager, collateral, targetHF }) {
+	const found = resolve(sdk, creditManager);
+	if (!found) return;
+	const { suite, market } = found;
+	const target = suite.strategyTargetCollateral;
+	if (!target) return;
+	const ceiling = suite.creditManager.maxLeverage(target, targetHF);
+	const underlying = market.pool.underlying;
+	const convert = (from, to, amount) => market.priceOracle.safeConvert(from, to, amount) ?? 0n;
+	const netValue = collateral.reduce((acc, a) => acc + convert(a.token, underlying, a.balance), 0n);
+	if (netValue <= 0n) return {
+		min: 1,
+		max: ceiling
+	};
+	const { minDebt, maxDebt } = suite.creditFacade;
+	const available = market.pool.pool.creditManagerDebtParams.get(suite.creditManager.address)?.available;
+	const borrowLimit = available === void 0 ? maxDebt : BigIntMath.min(maxDebt, available);
+	const floor = BigIntMath.ceilDiv(LEVERAGE_DECIMALS * minDebt, netValue);
+	const roof = LEVERAGE_DECIMALS * borrowLimit / netValue;
+	const min = 1 + Number(floor) / Number(LEVERAGE_DECIMALS);
+	const max = Math.min(ceiling, 1 + Number(roof) / Number(LEVERAGE_DECIMALS));
+	return min > max ? void 0 : {
+		min,
+		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/math.js

@@ -1,5 +1,8 @@
+import { BigIntMath } from "../../utils/bigint-math.js";
 import { LEVERAGE_DECIMALS } from "../../constants/math.js";
-import { IntentPreviewError } from "./types.js";
+import { checkDebtInBand, checkLeverageAtLeastOne } from "../../validation/checks.js";
+import { IntentPreviewError, raise } from "../../validation/refusal.js";
+import { toToken } from "../../validation/token.js";
 //#region src/onchain/accounts/intents/math.ts
 /** Debt that realises `leverage` on `collateral`: `D = C · (L − 1)`. */
 function debtForLeverage(collateral, leverage) {
@@ -13,7 +16,7 @@ function debtForLeverage(collateral, leverage) {
 * it, so no rounding is introduced on the way.
 */
 function proportionalDebt(position, collateralDelta) {
-	if (position.collateral <= 0n) throw new IntentPreviewError("insufficientSourceBalance", "cannot preserve leverage on an account with no collateral");
+	if (position.collateral <= 0n) throw new IntentPreviewError("insufficientSourceBalance", void 0, "cannot preserve leverage on an account with no collateral");
 	return position.debt * collateralDelta / position.collateral;
 }
 /**
@@ -31,21 +34,28 @@ function maxProportionalWithdrawal(position, band) {
 	if (debt === 0n) return allButLast;
 	const repayable = debt - band.minDebt;
 	if (repayable < 0n) return 0n;
-	const bound = ceilDiv(collateral * (repayable + 1n), debt) - 1n;
+	const bound = BigIntMath.ceilDiv(collateral * (repayable + 1n), debt) - 1n;
 	return bound < allButLast ? bound : allButLast;
 }
-const ceilDiv = (a, b) => (a + b - 1n) / b;
 /** Total leverage cannot drop below 1x — that would be negative debt. */
 function assertLeverageAtLeastOne(leverage) {
-	if (leverage < 100n) throw new IntentPreviewError("leverageOutOfRange", `target leverage ${leverage} is below 1x`);
+	raise(checkLeverageAtLeastOne({
+		leverage,
+		min: LEVERAGE_DECIMALS
+	}), `target leverage ${leverage} is below 1x`);
 }
 /**
 * Rejects a debt the facade would revert on: zero is always fine (no loan at
 * all), anything else has to sit inside `[minDebt, maxDebt]`.
 */
-function assertDebtInBand(debt, band) {
-	if (debt > band.maxDebt) throw new IntentPreviewError("debtOutOfRange", `debt ${debt} exceeds maxDebt ${band.maxDebt}`);
-	if (debt > 0n && debt < band.minDebt) throw new IntentPreviewError("debtOutOfRange", `debt ${debt} is below minDebt ${band.minDebt}`);
+function assertDebtInBand(sdk, debt, band, underlying) {
+	raise(checkDebtInBand({
+		debt,
+		minDebt: band.minDebt,
+		maxDebt: band.maxDebt,
+		underlying: toToken(sdk, underlying),
+		allowZero: true
+	}), debt > band.maxDebt ? `debt ${debt} exceeds maxDebt ${band.maxDebt}` : `debt ${debt} is below minDebt ${band.minDebt}`);
 }
 //#endregion
 export { assertDebtInBand, assertLeverageAtLeastOne, debtForLeverage, maxProportionalWithdrawal, proportionalDebt };

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

@@ -30,7 +30,7 @@ function maxWithdrawCollateral(props) {
 	const underlying = market.pool.underlying;
 	const target = creditAccount.tokens.find((t) => eq(t.token, token));
 	if (!target || target.balance <= 10n) return 0n;
-	if (creditAccount.accountDebt === 0n) return target.balance;
+	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. */
@@ -47,7 +47,7 @@ function maxWithdrawCollateral(props) {
 		if (eq(t.token, token) || !counts(t)) continue;
 		otherMoney += weigh(t);
 	}
-	const borrowed = usd(priceOracle, underlying, creditAccount.accountDebt);
+	const borrowed = usd(priceOracle, underlying, creditAccount.totalDebt);
 	if (borrowed === void 0 || borrowed <= 0n) return 0n;
 	const required = borrowed * targetHF;
 	if (required <= otherMoney) return target.balance;
@@ -56,8 +56,8 @@ function maxWithdrawCollateral(props) {
 	const targetLt = BigInt(creditManager.liquidationThresholds.get(target.token) ?? 0);
 	const targetUsd = safeUsd(priceOracle, target.token, target.balance);
 	if (targetLt === 0n || !targetUsd) return 0n;
-	const keptUsd = ceilDiv(shortfall, targetLt);
-	const kept = ceilDiv(target.balance * keptUsd, targetUsd);
+	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. */
@@ -81,8 +81,5 @@ function safeUsd(oracle, token, amount) {
 		return main;
 	}
 }
-function ceilDiv(a, b) {
-	return (a + b - 1n) / b;
-}
 //#endregion
 export { maxWithdrawCollateral };

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

@@ -1,8 +1,7 @@
-import "../../constants/math.js";
-import { IntentPreviewError } from "./types.js";
-import { convertAmount } from "./utils/convert-amount.js";
+import { IntentPreviewError } from "../../validation/refusal.js";
 import { assertCanBorrow, assertCollateralised, assertGrowthAllowed, assertMarketOperable, assertQuotaHeadroom } from "./guards.js";
-import { assertDebtInBand, debtForLeverage } from "./math.js";
+import { assertDebtInBand, assertLeverageAtLeastOne, debtForLeverage } from "./math.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";
@@ -10,7 +9,8 @@ import "./utils/index.js";
 /** 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.
+* Builds the state opening a leveraged position out of wallet collateral would
+* reach.
 *
 * Debt follows from the target leverage against the supplied margin
 * (`debt = margin * (L - 1)`, `totalValue = margin * L`); the collateral and the
@@ -20,16 +20,16 @@ const NO_ACCOUNT = "0x0000000000000000000000000000000000000000";
 * no operation list — the caller passes the numbers and calls straight to
 * `sdk.accounts.openCA`.
 */
-async function previewOpenStrategy(props) {
+async function buildOpenStrategyState(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`);
+	assertLeverageAtLeastOne(leverage);
 	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 convert = (from, to, amount) => market.priceOracle.safeConvert(from, to, amount) ?? 0n;
 	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");
+	if (margin <= 0n) throw new IntentPreviewError("insufficientSourceBalance", void 0, "openStrategy: collateral is worth nothing in underlying");
 	const debt = debtForLeverage(margin, leverage);
 	const account = {
 		creditAccount: NO_ACCOUNT,
@@ -38,17 +38,19 @@ async function previewOpenStrategy(props) {
 		underlying,
 		enabledTokensMask: 0n,
 		totalDebtUSD: 0n,
-		accountDebt: 0n,
+		totalDebt: 0n,
 		tokens: []
 	};
-	assertDebtInBand(debt, suite.creditFacade);
-	assertCanBorrow(suite, debt);
-	const leg = await createRouterPaths({
+	assertDebtInBand(sdk, debt, suite.creditFacade, underlying);
+	assertCanBorrow(sdk, suite, debt);
+	const paths = createRouterPaths({
 		sdk,
 		creditAccount: account,
 		slippage
-	}).openStrategy({
-		expectedBalances: mergeExpectedBalances(collateral, underlying, debt),
+	});
+	const expectedBalances = mergeExpectedBalances(collateral, underlying, debt);
+	const leg = await paths.openStrategy({
+		expectedBalances,
 		leftoverBalances,
 		target: targetToken
 	});
@@ -75,7 +77,7 @@ async function previewOpenStrategy(props) {
 		before: [],
 		after: averageAssets
 	});
-	assertQuotaHeadroom(market, averageQuota);
+	assertQuotaHeadroom(sdk, market, averageQuota);
 	const snapshot = {
 		creditManager,
 		assets: averageAssets,
@@ -83,24 +85,22 @@ async function previewOpenStrategy(props) {
 		totalDebt: debt,
 		totalValue: margin + debt
 	};
-	const projectedPool = { availableLiquidityChange: -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(metrics.healthFactor);
-	return {
-		debt,
-		collateral: margin,
+	const { assets: _assets, quotas: _quotas, ...projection } = sdk.positions.projection(snapshot, { availableLiquidityChange: -debt });
+	assertCollateralised(projection.healthFactor, false);
+	const priceImpact = await collectPriceImpact(leg.probe ? [leg.probe] : [], {
 		totalValue: margin + debt,
+		netValue: margin,
+		toUnderlying: (from, amount) => convert(from, underlying, amount)
+	});
+	return {
+		...projection,
+		currentPrice: sdk.positions.currentPrice(snapshot),
+		priceImpact,
 		averageAssets: averageAssets.map(priced),
 		minAssets: minAssets.map(priced),
 		averageQuota,
 		minQuota,
-		calls: [...leg.calls],
-		...metrics
+		calls: [...leg.calls]
 	};
 }
 /** Collateral plus the borrowed underlying, folded into one balance per token. */
@@ -130,4 +130,4 @@ function toAssets(balances) {
 	}));
 }
 //#endregion
-export { previewOpenStrategy };
+export { buildOpenStrategyState };