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

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

@@ -2,9 +2,9 @@ import { BigIntMath } from "../../utils/bigint-math.js";
 import { PERCENTAGE_FACTOR } from "../../constants/math.js";
 import "../../utils/index.js";
 import { eq } from "./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;
@@ -20,21 +20,21 @@ function collateralMoney(creditAccount, sdk) {
 	const lt = (token) => BigInt(creditManager.liquidationThresholds.get(token) ?? 0);
 	const checkedUsd = (holding) => 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) * PERCENTAGE_FACTOR : 0n;
+	const quotaValue = (holding) => pqk.hasActiveQuota(holding.token) ? (mainUsd(underlying, holding.quota) ?? 0n) * PERCENTAGE_FACTOR : 0n;
 	const weigh = (holding) => {
 		const weighted = checkedUsd(holding) * lt(holding.token);
 		if (holding.quota === 0n) return weighted;
-		return BigIntMath.min(quotaMoney(holding), weighted);
+		return 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
-export { collateralMoney };
+export { collateralValuation };

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

@@ -7,9 +7,11 @@ 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 { 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 { accountView } from "./view.js";
@@ -132,6 +134,31 @@ 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, 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 = 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.
 	*
@@ -277,6 +304,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
@@ -298,6 +345,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,83 @@
+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.
+*
+* 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 = 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);
+	const intoPayout = (value) => unwrapsPayout ? toTargetDecimals(value, underlying, borrowToken, sdk) : priceOracle.safeConvert(underlying, borrowToken, value).value;
+	const intoUnderlying = (value) => unwrapsPayout ? toTargetDecimals(value, borrowToken, underlying, sdk) : priceOracle.safeConvert(borrowToken, underlying, value).value;
+	const amount = eq(borrowToken, underlying) ? ceiling : intoPayout(ceiling);
+	return (eq(borrowToken, underlying) ? amount : intoUnderlying(amount)) < suite.creditFacade.minDebt ? 0n : amount;
+}
+//#endregion
+export { maxBorrow };

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

@@ -2,16 +2,16 @@ import { BigIntMath } from "../../utils/bigint-math.js";
 import "../../constants/math.js";
 import "../../utils/index.js";
 import { eq } from "./utils/common.js";
-import { collateralMoney } from "./collateral-money.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 — 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.
@@ -25,20 +25,20 @@ function maxWithdrawCollateral(props) {
 	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 money = collateralMoney(creditAccount, sdk);
-	let otherMoney = 0n;
+	const valuation = collateralValuation(creditAccount, sdk);
+	let otherValue = 0n;
 	for (const t of creditAccount.tokens) {
-		if (eq(t.token, token) || !money.counts(t)) continue;
-		otherMoney += money.weigh(t);
+		if (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 = BigIntMath.ceilDiv(shortfall, targetLt);
 	const kept = BigIntMath.ceilDiv(target.balance * keptUsd, targetUsd);

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({
@@ -110,35 +100,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/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: {

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

@@ -2,6 +2,24 @@ import { AddressMap } from "../../../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;
@@ -37,4 +55,4 @@ function toRouterCaSlice(creditAccount, expectedBalances = []) {
 	};
 }
 //#endregion
-export { eq, toRouterCaSlice, toTargetDecimals };
+export { eq, resolveCreditManager, toRouterCaSlice, toTargetDecimals };

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

@@ -26,6 +26,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
@@ -40,4 +60,4 @@ async function fetchCreditAccountSlice(sdk, creditAccount) {
 	return toCreditAccountSlice(data);
 }
 //#endregion
-export { fetchCreditAccountSlice, toCreditAccountSlice };
+export { fetchCreditAccountSlice, toCreditAccountSlice, unopenedAccountSlice };

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

@@ -1,11 +1,11 @@
-import { eq, toRouterCaSlice, toTargetDecimals } from "./common.js";
+import { eq, resolveCreditManager, toRouterCaSlice, toTargetDecimals } from "./common.js";
 import { isPhantomToken, isRedemptionPhantomToken, pickFattestNonPhantomToken, rankAccountTokens } from "./pick-token.js";
 import { adjustStateToSnapshot } from "./adjust-state-to-snapshot.js";
 import { assembleOperationCalls } from "./assemble-operation-calls.js";
 import { calcBorrowedAmountPlusInterestAndFees } from "./borrowed-amount-plus-interest-and-fees.js";
-import { fetchCreditAccountSlice, toCreditAccountSlice } from "./credit-account-slice.js";
+import { fetchCreditAccountSlice, toCreditAccountSlice, unopenedAccountSlice } from "./credit-account-slice.js";
 import { OperationLedger } from "./ledger.js";
 import { collectPriceImpact, lossRate, startProbe } from "./price-impact.js";
 import { clearedQuotas, getQuotasForUpdate, quotasAfterUpdate } from "./quotas-for-update.js";
 import { createOraclePaths, createRouterPaths } from "./router-path.js";
-export { OperationLedger, adjustStateToSnapshot, assembleOperationCalls, calcBorrowedAmountPlusInterestAndFees, clearedQuotas, collectPriceImpact, createOraclePaths, createRouterPaths, eq, fetchCreditAccountSlice, getQuotasForUpdate, isPhantomToken, isRedemptionPhantomToken, lossRate, pickFattestNonPhantomToken, quotasAfterUpdate, rankAccountTokens, startProbe, toCreditAccountSlice, toRouterCaSlice, toTargetDecimals };
+export { OperationLedger, adjustStateToSnapshot, assembleOperationCalls, calcBorrowedAmountPlusInterestAndFees, clearedQuotas, collectPriceImpact, createOraclePaths, createRouterPaths, eq, fetchCreditAccountSlice, getQuotasForUpdate, isPhantomToken, isRedemptionPhantomToken, lossRate, pickFattestNonPhantomToken, quotasAfterUpdate, rankAccountTokens, resolveCreditManager, startProbe, toCreditAccountSlice, toRouterCaSlice, toTargetDecimals, unopenedAccountSlice };

package/dist/esm/onchain/accounts/intents/withdraw-limits.js

@@ -3,8 +3,8 @@ import "../../utils/index.js";
 import { MIN_HEALTH_FACTOR_FACADE } from "../../validation/helpers/health-factor-limits.js";
 import "../../validation/index.js";
 import { eq } from "./utils/common.js";
-import { collateralMoney } from "./collateral-money.js";
 import { maxProportionalWithdrawal } from "./math.js";
+import { collateralValuation } from "./collateral-valuation.js";
 import { accountView } from "./view.js";
 //#region src/onchain/accounts/intents/withdraw-limits.ts
 /**
@@ -38,7 +38,7 @@ function withdrawLimits(props) {
 * in underlying units.
 *
 * A withdrawal hands funds over, so the facade weighs the account it leaves
-* behind at safe prices rather than main ones — see {@link collateralMoney}.
+* behind at safe prices rather than main ones — see {@link collateralValuation}.
 * That is a second limit on top of the facade's `debtLimits`, and the two are
 * independent: a caller wanting the amount a form may actually offer takes the
 * lesser of this and `maxProportionalWithdrawal`.
@@ -71,20 +71,20 @@ function maxSafeWithdrawal(props) {
 	const view = accountView(creditAccount, sdk);
 	if (view.collateral <= 0n) return 0n;
 	if (view.debt === 0n) return view.collateral;
-	const money = collateralMoney(creditAccount, sdk);
+	const valuation = collateralValuation(creditAccount, sdk);
 	const source = props.sourceToken ?? view.fattest();
 	const holding = source === void 0 ? void 0 : creditAccount.tokens.find((t) => eq(t.token, source));
 	if (!holding) return view.collateral;
 	let total = 0n;
-	for (const t of creditAccount.tokens) if (money.counts(t)) total += money.weigh(t);
-	const debtUsd = money.mainUsd(money.underlying, view.debt);
+	for (const t of creditAccount.tokens) if (valuation.counts(t)) total += valuation.weigh(t);
+	const debtUsd = valuation.mainUsd(valuation.underlying, view.debt);
 	if (debtUsd === void 0 || debtUsd <= 0n) return view.collateral;
 	const slack = total - debtUsd * targetHF;
 	if (slack < 0n) return 0n;
-	const sourceMainUsd = money.mainUsd(holding.token, holding.balance);
+	const sourceMainUsd = valuation.mainUsd(holding.token, holding.balance);
 	if (sourceMainUsd === void 0 || sourceMainUsd <= 0n) return view.collateral;
-	const sourceRate = money.lt(holding.token) * money.checkedUsd(holding);
-	const tvlUsd = money.mainUsd(money.underlying, view.collateral + view.debt);
+	const sourceRate = valuation.lt(holding.token) * valuation.checkedUsd(holding);
+	const tvlUsd = valuation.mainUsd(valuation.underlying, view.collateral + view.debt);
 	if (tvlUsd === void 0) return view.collateral;
 	const drain = sourceRate * tvlUsd - targetHF * debtUsd * sourceMainUsd;
 	if (drain <= 0n) return view.collateral;

package/dist/esm/onchain/positions/calcHealthFactor.js

@@ -35,7 +35,7 @@ function calcHealthFactor(props) {
 		const scale = 10n ** BigInt(decimalsByToken.get(token) ?? 18);
 		return amount * price / scale;
 	};
-	const assetMoney = snapshot.assets.reduce((acc, { token, balance }) => {
+	const assetValue = snapshot.assets.reduce((acc, { token, balance }) => {
 		if (balance <= 10n) return acc;
 		const lt = BigInt(lts.get(token) ?? 0);
 		const tokenLtWeighted = (convertToUSD(token, balance, true) ?? 0n) * lt;
@@ -44,8 +44,8 @@ function calcHealthFactor(props) {
 		const quotaWeighted = (convertToUSD(underlying, quotaBalance) ?? 0n) * PERCENTAGE_FACTOR;
 		return acc + (quota ? BigIntMath.min(quotaWeighted, tokenLtWeighted) : tokenLtWeighted);
 	}, 0n);
-	const borrowedMoney = convertToUSD(underlying, snapshot.totalDebt) ?? 0n;
-	const hf = borrowedMoney > 0n ? assetMoney / borrowedMoney : 0n;
+	const borrowedValue = convertToUSD(underlying, snapshot.totalDebt) ?? 0n;
+	const hf = borrowedValue > 0n ? assetValue / borrowedValue : 0n;
 	return Number(hf);
 }
 //#endregion

package/dist/esm/onchain/preview/preview/previewOpenStrategyPosition.js

@@ -17,7 +17,7 @@ function previewOpenStrategyPosition(sdk, input, operation, replay) {
 		warning ??= priced.error;
 		return priced.value;
 	};
-	const netValue = before.balances.sum(price) + after.collateralAdded.sum(price);
+	const netValue = before.balances.sum(price) + after.collateralAdded.sum(price) - after.collateralWithdrawn.sum(price);
 	const unwrapped = unwrapNativeCollateral(after.collateralAdded.toAssets(), value, sdk.addressProvider.getAddress(AP_WETH_TOKEN, 0));
 	if (!unwrapped.ok) return unwrapped;
 	const collateral = unwrapped.data;
@@ -27,6 +27,7 @@ function previewOpenStrategyPosition(sdk, input, operation, replay) {
 		...asEstimated(sdk.positions.projection(snap, { availableLiquidityChange: -account.totalDebt })),
 		targetCollateral: targetAsset ? oracle.toTokenAmount(targetAsset.token, targetAsset.balance) : void 0,
 		collateralAdded: collateral.map((a) => oracle.toTokenAmount(a.token, a.balance)),
+		collateralWithdrawn: after.collateralWithdrawn.toAssets().map((a) => oracle.toTokenAmount(a.token, a.balance)),
 		warning
 	};
 	return sdkOk({