@gearbox-protocol/sdk 16.4.0-next.5 → 16.4.0-next.6

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

@@ -0,0 +1,139 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_model_errors_operation_errors = require("../../../model/errors/operation-errors.js");
+const require_model_errors_prepare_errors = require("../../../model/errors/prepare-errors.js");
+require("../../../model/index.js");
+const require_onchain_validation_helpers_token = require("../../validation/helpers/token.js");
+const require_onchain_validation_raise = require("../../validation/raise.js");
+require("../../validation/index.js");
+const require_onchain_accounts_intents_utils_common = require("./utils/common.js");
+const require_onchain_accounts_intents_guards = require("./guards.js");
+const require_onchain_accounts_intents_math = require("./math.js");
+const require_onchain_accounts_intents_utils_credit_account_slice = require("./utils/credit-account-slice.js");
+const require_onchain_accounts_intents_utils_price_impact = require("./utils/price-impact.js");
+const require_onchain_accounts_intents_utils_quotas_for_update = require("./utils/quotas-for-update.js");
+const require_onchain_accounts_intents_utils_router_path = require("./utils/router-path.js");
+require("./utils/index.js");
+//#region src/onchain/accounts/intents/borrow.ts
+/**
+* Builds the state a borrow would leave behind.
+*
+* The debt is named rather than derived: a borrow asks for an amount, where an
+* opening asks for a leverage and lets the collateral decide. Everything the
+* loan pays out leaves the account, so the collateral alone backs it — which
+* is what makes the health factor here a straight function of the two amounts.
+*
+* Produces no operation list, as opening never does: the caller hands the
+* numbers and the calls to `sdk.accounts.openCA`, with `withdrawToken` set to
+* the payout.
+*/
+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);
+	require_onchain_accounts_intents_guards.assertMarketOperable(suite);
+	const underlying = market.pool.underlying.toLowerCase();
+	const collateralToken = props.collateralToken.toLowerCase();
+	const borrowToken = props.borrowToken.toLowerCase();
+	const convert = (from, to, amount) => market.priceOracle.safeConvert(from, to, amount).value;
+	if (require_onchain_accounts_intents_utils_common.eq(collateralToken, borrowToken)) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_prepare_errors.unsupportedCollateralToken(require_onchain_validation_helpers_token.toToken(sdk, collateralToken)), "borrow: the payout token cannot also be the collateral");
+	const rwaAsset = sdk.tokensMeta.rwaUnderlyings.get(underlying)?.asset?.toLowerCase();
+	const unwrapsPayout = !!rwaAsset && require_onchain_accounts_intents_utils_common.eq(borrowToken, rwaAsset);
+	if (rwaAsset && require_onchain_accounts_intents_utils_common.eq(borrowToken, underlying)) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_prepare_errors.unsupportedCollateralToken(require_onchain_validation_helpers_token.toToken(sdk, borrowToken)), `borrow: ${underlying} cannot leave the account, ask for the payout in ${rwaAsset}`);
+	if (collateralAmount <= 0n) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_operation_errors.insufficientBalance(), "borrow: no collateral supplied");
+	if (borrowAmount <= 0n) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_operation_errors.insufficientBalance(), "borrow: nothing to borrow");
+	const margin = convert(collateralToken, underlying, collateralAmount);
+	if (margin <= 0n) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_operation_errors.insufficientBalance(), "borrow: collateral is worth nothing in underlying");
+	const debt = require_onchain_accounts_intents_utils_common.eq(borrowToken, underlying) ? borrowAmount : unwrapsPayout ? require_onchain_accounts_intents_utils_common.toTargetDecimals(borrowAmount, borrowToken, underlying, sdk) : convert(borrowToken, underlying, borrowAmount);
+	require_onchain_accounts_intents_math.assertDebtLimits(sdk, debt, suite.creditFacade, underlying);
+	require_onchain_accounts_intents_guards.assertCanBorrow(sdk, suite, debt);
+	const account = existing ?? require_onchain_accounts_intents_utils_credit_account_slice.unopenedAccountSlice({
+		creditManager,
+		creditFacade: suite.creditFacade.address,
+		underlying
+	});
+	const leg = require_onchain_accounts_intents_utils_common.eq(borrowToken, underlying) || unwrapsPayout ? void 0 : await require_onchain_accounts_intents_utils_router_path.createRouterPaths({
+		sdk,
+		creditAccount: account,
+		slippage
+	}).swap({
+		tokenIn: underlying,
+		tokenOut: borrowToken,
+		amount: debt,
+		keep: require_onchain_accounts_intents_utils_common.eq(collateralToken, underlying) ? collateralAmount : 0n
+	});
+	const unwrap = unwrapsPayout ? await sdk.accounts.assembleRWAUnwrapCalls(debt, creditManager) : void 0;
+	if (unwrapsPayout && !unwrap) throw new Error(`borrow: no unwrap calls found for ${borrowToken}`);
+	const assets = [{
+		token: collateralToken,
+		balance: collateralAmount
+	}];
+	const quotaIncrease = borrowCollateralQuota({
+		sdk,
+		creditManager,
+		assets,
+		quotaReserve
+	});
+	require_onchain_accounts_intents_guards.assertGrowthAllowed({
+		sdk,
+		suite,
+		market,
+		before: [],
+		after: assets
+	});
+	require_onchain_accounts_intents_guards.assertQuotaAvailable(sdk, market, quotaIncrease);
+	const snapshot = {
+		creditManager,
+		assets,
+		quotas: quotaIncrease,
+		totalDebt: debt,
+		totalValue: margin
+	};
+	const projection = sdk.positions.projection(snapshot, { availableLiquidityChange: -debt });
+	require_onchain_accounts_intents_guards.assertCollateralised(projection.safeHealthFactor, true);
+	const priced = (token, balance) => market.priceOracle.toTokenAmount(token, balance);
+	const payout = unwrapsPayout ? require_onchain_accounts_intents_utils_common.toTargetDecimals(debt, underlying, borrowToken, sdk) : leg ? leg.amount : debt;
+	return {
+		...projection,
+		currentPrice: sdk.positions.currentPrice(snapshot),
+		executionCost: void 0,
+		priceImpact: await require_onchain_accounts_intents_utils_price_impact.collectPriceImpact(leg?.probe ? [leg.probe] : [], {
+			totalValue: margin,
+			netValue: margin - debt,
+			toUnderlying: (from, amount) => convert(from, underlying, amount)
+		}),
+		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
+	};
+}
+/**
+* Quota a borrow buys for its collateral on an account that holds none yet.
+*
+* Shared with `maxBorrow`, because a quota short of the collateral's weighted
+* value is what caps the loan: the two have to read the same number or the
+* ceiling one offers is one the other refuses.
+*
+* @param props - {@link BorrowCollateralQuotaProps}
+**/
+function borrowCollateralQuota({ sdk, creditManager, assets, quotaReserve }) {
+	const suite = sdk.marketRegister.findCreditManager(creditManager);
+	const market = sdk.marketRegister.findByCreditManager(creditManager);
+	return require_onchain_accounts_intents_utils_quotas_for_update.getQuotasForUpdate({
+		assetsBefore: [],
+		assetsAfter: assets,
+		initialQuotas: [],
+		quotaReserve,
+		underlyingToken: market.pool.underlying,
+		liquidationThresholds: suite.creditManager.liquidationThresholds,
+		quotas: market.pool.pqk.quotas,
+		maxDebt: suite.creditFacade.maxDebt,
+		convert: (from, to, amount) => market.priceOracle.safeConvert(from, to, amount).value
+	}).quotaIncrease;
+}
+//#endregion
+exports.borrowCollateralQuota = borrowCollateralQuota;
+exports.buildBorrowState = buildBorrowState;

package/dist/cjs/onchain/accounts/intents/{collateral-money.js → collateral-valuation.js}

@@ -3,9 +3,9 @@ const require_onchain_utils_bigint_math = require("../../utils/bigint-math.js");
 const require_onchain_constants_math = require("../../constants/math.js");
 require("../../utils/index.js");
 const require_onchain_accounts_intents_utils_common = require("./utils/common.js");
-//#region src/onchain/accounts/intents/collateral-money.ts
-/** {@inheritDoc CollateralMoney} */
-function collateralMoney(creditAccount, sdk) {
+//#region src/onchain/accounts/intents/collateral-valuation.ts
+/** {@inheritDoc CollateralValuation} */
+function collateralValuation(creditAccount, sdk) {
 	const { market, creditManager } = sdk.marketRegister.findCreditManager(creditAccount.creditManager);
 	const { priceOracle } = market;
 	const { pqk } = market.pool;
@@ -21,21 +21,21 @@ function collateralMoney(creditAccount, sdk) {
 	const lt = (token) => BigInt(creditManager.liquidationThresholds.get(token) ?? 0);
 	const checkedUsd = (holding) => require_onchain_accounts_intents_utils_common.eq(holding.token, underlying) ? mainUsd(holding.token, holding.balance) ?? 0n : priceOracle.safeConvertMinUSD(holding.token, holding.balance).value;
 	/** A quota is underlying-denominated, and a closed market backs nothing. */
-	const quotaMoney = (holding) => pqk.hasActiveQuota(holding.token) ? (mainUsd(underlying, holding.quota) ?? 0n) * require_onchain_constants_math.PERCENTAGE_FACTOR : 0n;
+	const quotaValue = (holding) => pqk.hasActiveQuota(holding.token) ? (mainUsd(underlying, holding.quota) ?? 0n) * require_onchain_constants_math.PERCENTAGE_FACTOR : 0n;
 	const weigh = (holding) => {
 		const weighted = checkedUsd(holding) * lt(holding.token);
 		if (holding.quota === 0n) return weighted;
-		return require_onchain_utils_bigint_math.BigIntMath.min(quotaMoney(holding), weighted);
+		return require_onchain_utils_bigint_math.BigIntMath.min(quotaValue(holding), weighted);
 	};
 	return {
 		underlying,
 		counts: (holding) => holding.balance > 10n && (!masked || (holding.mask & creditAccount.enabledTokensMask) !== 0n),
 		weigh,
-		quotaMoney,
+		quotaValue,
 		mainUsd,
 		checkedUsd,
 		lt
 	};
 }
 //#endregion
-exports.collateralMoney = collateralMoney;
+exports.collateralValuation = collateralValuation;

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

@@ -8,9 +8,11 @@ const require_onchain_validation_raise = require("../../validation/raise.js");
 require("../../validation/index.js");
 const require_onchain_accounts_intents_utils_pick_token = require("./utils/pick-token.js");
 const require_onchain_accounts_intents_guards = require("./guards.js");
+const require_onchain_accounts_intents_utils_credit_account_slice = require("./utils/credit-account-slice.js");
+const require_onchain_accounts_intents_borrow = require("./borrow.js");
 const require_onchain_accounts_intents_leverage_band = require("./leverage-band.js");
+const require_onchain_accounts_intents_maxBorrow = require("./maxBorrow.js");
 const require_onchain_accounts_intents_maxWithdrawCollateral = require("./maxWithdrawCollateral.js");
-const require_onchain_accounts_intents_utils_credit_account_slice = require("./utils/credit-account-slice.js");
 const require_onchain_accounts_intents_open_strategy = require("./open-strategy.js");
 const require_onchain_accounts_intents_plan = require("./plan.js");
 const require_onchain_accounts_intents_view = require("./view.js");
@@ -133,6 +135,31 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 		});
 	}
 	/**
+	* Largest loan a given collateral supports at `targetHF`, in the payout
+	* token's units — the ceiling a borrow form should offer, and the amount
+	* {@link borrowIntent} will accept at the top of its range.
+	*
+	* 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.
+	*
+	* 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
+	*/
+	maxBorrow(props) {
+		const { targetHF = require_onchain_validation_helpers_health_factor_limits.MIN_HF_LIMITED, ...rest } = props;
+		return require_onchain_accounts_intents_maxBorrow.maxBorrow({
+			...rest,
+			targetHF: targetHF + 2n
+		});
+	}
+	/**
 	* Previews the same operation when its source only redeems through its
 	* issuer: a Securitize dsToken, a Mellow share.
 	*
@@ -278,6 +305,26 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 		};
 	}
 	/**
+	* 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 {
+			require_onchain_accounts_intents_guards.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
@@ -299,6 +346,37 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 			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 require_onchain_accounts_intents_borrow.buildBorrowState(props)
+			};
+		} catch (e) {
+			return asSDKError(e);
+		}
+	}
 	/** Plan → realise → wrap. Unviable requests become `{ ok: false }`. */
 	async #preview(props, plan) {
 		try {

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

@@ -1,6 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_onchain_utils_bigint_math = require("../../utils/bigint-math.js");
 const require_onchain_constants_math = require("../../constants/math.js");
+const require_onchain_accounts_intents_utils_common = require("./utils/common.js");
 //#region src/onchain/accounts/intents/leverage-band.ts
 /**
 * The leverages this market will actually fund for a position of this size.
@@ -30,7 +31,7 @@ const require_onchain_constants_math = require("../../constants/math.js");
 * ```
 **/
 function calcLeverageBand({ sdk, creditManager, collateral, targetHF }) {
-	const found = resolve(sdk, creditManager);
+	const found = require_onchain_accounts_intents_utils_common.resolveCreditManager(sdk, creditManager);
 	if (!found) return;
 	const { suite, market } = found;
 	const target = suite.strategyTargetCollateral;
@@ -55,16 +56,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
 exports.calcLeverageBand = calcLeverageBand;

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

@@ -0,0 +1,85 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_utils_bigint_math = require("../../utils/bigint-math.js");
+require("../../constants/math.js");
+require("../../utils/index.js");
+const require_onchain_accounts_intents_utils_common = require("./utils/common.js");
+const require_onchain_accounts_intents_utils_credit_account_slice = require("./utils/credit-account-slice.js");
+require("./utils/index.js");
+const require_onchain_accounts_intents_borrow = require("./borrow.js");
+const require_onchain_accounts_intents_collateral_valuation = require("./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.
+*
+* 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` when this market will fund
+* no loan of this shape — including a debt that would land under `minDebt`, a
+* collateral that backs nothing at safe prices, and a manager the SDK does not
+* hold yet
+**/
+function maxBorrow(props) {
+	const { sdk, creditManager, collateralAmount, targetHF, quotaReserve } = props;
+	const found = require_onchain_accounts_intents_utils_common.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 (require_onchain_accounts_intents_utils_common.eq(collateralToken, borrowToken)) return 0n;
+	if (rwaAsset && require_onchain_accounts_intents_utils_common.eq(borrowToken, underlying)) return 0n;
+	if (collateralAmount <= 10n || targetHF <= 0n) return 0n;
+	const assets = [{
+		token: collateralToken,
+		balance: collateralAmount
+	}];
+	const quotas = require_onchain_accounts_intents_borrow.borrowCollateralQuota({
+		sdk,
+		creditManager,
+		assets,
+		quotaReserve
+	});
+	const holding = {
+		token: collateralToken,
+		balance: collateralAmount,
+		quota: quotas.find((q) => require_onchain_accounts_intents_utils_common.eq(q.token, collateralToken))?.balance ?? 0n,
+		mask: 0n,
+		success: true
+	};
+	const valuation = require_onchain_accounts_intents_collateral_valuation.collateralValuation({
+		...require_onchain_accounts_intents_utils_credit_account_slice.unopenedAccountSlice({
+			creditManager,
+			creditFacade: suite.creditFacade.address,
+			underlying
+		}),
+		tokens: [holding]
+	}, sdk);
+	const weighted = valuation.checkedUsd(holding) * valuation.lt(collateralToken);
+	const backed = quotas.some((q) => require_onchain_accounts_intents_utils_common.eq(q.token, collateralToken)) ? require_onchain_utils_bigint_math.BigIntMath.min(valuation.quotaValue(holding), weighted) : weighted;
+	if (backed <= 0n) return 0n;
+	const ceiling = require_onchain_utils_bigint_math.BigIntMath.min(priceOracle.safeConvertFromUSD(underlying, backed / targetHF).value, suite.maxBorrowAmount().amount.value);
+	const unwrapsPayout = !!rwaAsset && require_onchain_accounts_intents_utils_common.eq(borrowToken, rwaAsset);
+	const intoPayout = (value) => unwrapsPayout ? require_onchain_accounts_intents_utils_common.toTargetDecimals(value, underlying, borrowToken, sdk) : priceOracle.safeConvert(underlying, borrowToken, value).value;
+	const intoUnderlying = (value) => unwrapsPayout ? require_onchain_accounts_intents_utils_common.toTargetDecimals(value, borrowToken, underlying, sdk) : priceOracle.safeConvert(borrowToken, underlying, value).value;
+	const amount = require_onchain_accounts_intents_utils_common.eq(borrowToken, underlying) ? ceiling : intoPayout(ceiling);
+	return (require_onchain_accounts_intents_utils_common.eq(borrowToken, underlying) ? amount : intoUnderlying(amount)) < suite.creditFacade.minDebt ? 0n : amount;
+}
+//#endregion
+exports.maxBorrow = maxBorrow;

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

@@ -3,16 +3,16 @@ const require_onchain_utils_bigint_math = require("../../utils/bigint-math.js");
 require("../../constants/math.js");
 require("../../utils/index.js");
 const require_onchain_accounts_intents_utils_common = require("./utils/common.js");
-const require_onchain_accounts_intents_collateral_money = require("./collateral-money.js");
+const require_onchain_accounts_intents_collateral_valuation = require("./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 — see {@link collateralMoney} for the valuation, safe prices
-* included. 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,20 +26,20 @@ function maxWithdrawCollateral(props) {
 	const target = creditAccount.tokens.find((t) => require_onchain_accounts_intents_utils_common.eq(t.token, token));
 	if (!target || target.balance <= 10n) return 0n;
 	if (creditAccount.totalDebt === 0n) return target.balance;
-	const money = require_onchain_accounts_intents_collateral_money.collateralMoney(creditAccount, sdk);
-	let otherMoney = 0n;
+	const valuation = require_onchain_accounts_intents_collateral_valuation.collateralValuation(creditAccount, sdk);
+	let otherValue = 0n;
 	for (const t of creditAccount.tokens) {
-		if (require_onchain_accounts_intents_utils_common.eq(t.token, token) || !money.counts(t)) continue;
-		otherMoney += money.weigh(t);
+		if (require_onchain_accounts_intents_utils_common.eq(t.token, token) || !valuation.counts(t)) continue;
+		otherValue += valuation.weigh(t);
 	}
-	const borrowed = money.mainUsd(money.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 && money.quotaMoney(target) < shortfall) return 0n;
-	const targetLt = money.lt(target.token);
-	const targetUsd = money.checkedUsd(target);
+	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 = require_onchain_utils_bigint_math.BigIntMath.ceilDiv(shortfall, targetLt);
 	const kept = require_onchain_utils_bigint_math.BigIntMath.ceilDiv(target.balance * keptUsd, targetUsd);

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

@@ -4,17 +4,13 @@ require("../../../model/index.js");
 const require_onchain_validation_raise = require("../../validation/raise.js");
 const require_onchain_accounts_intents_guards = require("./guards.js");
 const require_onchain_accounts_intents_math = require("./math.js");
+const require_onchain_accounts_intents_utils_credit_account_slice = require("./utils/credit-account-slice.js");
 const require_onchain_accounts_intents_utils_price_impact = require("./utils/price-impact.js");
 const require_onchain_accounts_intents_utils_quotas_for_update = require("./utils/quotas-for-update.js");
 const require_onchain_accounts_intents_utils_router_path = require("./utils/router-path.js");
 require("./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.
 *
@@ -27,7 +23,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;
 	require_onchain_accounts_intents_math.assertLeverageAtLeastOne(leverage);
 	const suite = sdk.marketRegister.findCreditManager(creditManager);
@@ -38,16 +33,11 @@ async function buildOpenStrategyState(props) {
 	const margin = collateral.reduce((acc, a) => acc + convert(a.token, underlying, a.balance), 0n);
 	if (margin <= 0n) throw new require_onchain_validation_raise.IntentPreviewError(require_model_errors_operation_errors.insufficientBalance(), "openStrategy: collateral is worth nothing in underlying");
 	const debt = require_onchain_accounts_intents_math.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 ?? require_onchain_accounts_intents_utils_credit_account_slice.unopenedAccountSlice({
+		creditManager,
+		creditFacade: suite.creditFacade.address,
+		underlying
+	});
 	require_onchain_accounts_intents_math.assertDebtLimits(sdk, debt, suite.creditFacade, underlying);
 	require_onchain_accounts_intents_guards.assertCanBorrow(sdk, suite, debt);
 	const paths = require_onchain_accounts_intents_utils_router_path.createRouterPaths({
@@ -111,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;
-	require_onchain_accounts_intents_guards.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/cjs/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) => require_onchain_market_math.calcMaxLeverage(liquidationThresholds.get(collateral) ?? 0, targetHF)
 		},
 		creditFacade: {

package/dist/cjs/onchain/accounts/intents/utils/common.js

@@ -3,6 +3,24 @@ const require_onchain_utils_AddressMap = require("../../../utils/AddressMap.js")
 //#region src/onchain/accounts/intents/utils/common.ts
 /** Case-insensitive address equality. */
 const eq = (a, b) => a.toLowerCase() === b.toLowerCase();
+/**
+* The suite and market behind a credit manager, or nothing where the register
+* has no entry for it.
+*
+* For the reads a form calls on every keystroke, including before the SDK has
+* finished attaching: a question the register cannot answer yet is not an
+* error. Everything that prepares a transaction wants the throw instead.
+*/
+function resolveCreditManager(sdk, creditManager) {
+	try {
+		return {
+			suite: sdk.marketRegister.findCreditManager(creditManager),
+			market: sdk.marketRegister.findByCreditManager(creditManager)
+		};
+	} catch {
+		return;
+	}
+}
 function toTargetDecimals(fromAmount, fromToken, toToken, sdk) {
 	const fromDecimals = sdk.tokensMeta.get(fromToken)?.decimals ?? 18;
 	const toDecimals = sdk.tokensMeta.get(toToken)?.decimals ?? 18;
@@ -39,5 +57,6 @@ function toRouterCaSlice(creditAccount, expectedBalances = []) {
 }
 //#endregion
 exports.eq = eq;
+exports.resolveCreditManager = resolveCreditManager;
 exports.toRouterCaSlice = toRouterCaSlice;
 exports.toTargetDecimals = toTargetDecimals;

package/dist/cjs/onchain/accounts/intents/utils/credit-account-slice.js

@@ -27,6 +27,26 @@ function toCreditAccountSlice(ca) {
 	};
 }
 /**
+* The slice a flow that has no account yet quotes against.
+*
+* Nothing of it exists on chain until the transaction lands, and nothing has
+* to: the pathfinder is asked about the credit manager, and every balance the
+* flow reasons about is one the transaction itself puts there. The zero
+* address stands in for the account so the shape is complete.
+*/
+function unopenedAccountSlice(args) {
+	return {
+		creditAccount: "0x0000000000000000000000000000000000000000",
+		creditManager: args.creditManager.toLowerCase(),
+		creditFacade: args.creditFacade.toLowerCase(),
+		underlying: args.underlying.toLowerCase(),
+		enabledTokensMask: 0n,
+		totalDebtUSD: 0n,
+		totalDebt: 0n,
+		tokens: []
+	};
+}
+/**
 * Reads an account by address and narrows it to {@link CreditAccountSlice}.
 *
 * The shared read model's `StrategyPosition` carries neither `tokens` nor
@@ -43,3 +63,4 @@ async function fetchCreditAccountSlice(sdk, creditAccount) {
 //#endregion
 exports.fetchCreditAccountSlice = fetchCreditAccountSlice;
 exports.toCreditAccountSlice = toCreditAccountSlice;
+exports.unopenedAccountSlice = unopenedAccountSlice;

package/dist/cjs/onchain/accounts/intents/utils/index.js

@@ -26,7 +26,9 @@ exports.lossRate = require_onchain_accounts_intents_utils_price_impact.lossRate;
 exports.pickFattestNonPhantomToken = require_onchain_accounts_intents_utils_pick_token.pickFattestNonPhantomToken;
 exports.quotasAfterUpdate = require_onchain_accounts_intents_utils_quotas_for_update.quotasAfterUpdate;
 exports.rankAccountTokens = require_onchain_accounts_intents_utils_pick_token.rankAccountTokens;
+exports.resolveCreditManager = require_onchain_accounts_intents_utils_common.resolveCreditManager;
 exports.startProbe = require_onchain_accounts_intents_utils_price_impact.startProbe;
 exports.toCreditAccountSlice = require_onchain_accounts_intents_utils_credit_account_slice.toCreditAccountSlice;
 exports.toRouterCaSlice = require_onchain_accounts_intents_utils_common.toRouterCaSlice;
 exports.toTargetDecimals = require_onchain_accounts_intents_utils_common.toTargetDecimals;
+exports.unopenedAccountSlice = require_onchain_accounts_intents_utils_credit_account_slice.unopenedAccountSlice;