@gearbox-protocol/sdk 16.4.0-next.1 → 16.4.0-next.10

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,34 @@ 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.
+	*
+	* Reads no account, like {@link leverageBand}: the borrow opens one. The
+	* collateral is valued the way the transaction will be judged, at safe
+	* prices and under the quota the borrow buys, and the answer is then held to
+	* what the market will lend.
+	*
+	* A ceiling, not a verdict: the facade's `minDebt` is a floor and is not
+	* applied here, so collateral too small for this market still answers with
+	* what it carries and {@link borrowIntent} is the one that refuses the loan.
+	*
+	* The default is {@link MIN_HF_LIMITED}, the threshold a form holds an
+	* account to.
+	*
+	* @param props - The manager, the SDK holding its market, the collateral put
+	* up, the token to be paid in, and optionally the health factor to land at
+	* @returns Amount in the payout token's units; `0n` where no loan of this
+	* shape can be funded at any size
+	*/
+	maxBorrow(props) {
+		const { targetHF = 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.
 	*
@@ -183,7 +213,10 @@ var CreditAccountOperationsService = class extends require_onchain_base_SDKConst
 			});
 			return {
 				...result,
-				state: tail.state,
+				state: {
+					...tail.state,
+					executionCost: result.state.executionCost
+				},
 				delayed
 			};
 		} catch (e) {
@@ -275,6 +308,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
@@ -296,6 +349,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,89 @@
+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.
+*
+* The facade's `minDebt` is deliberately not applied. It is a floor, and a
+* ceiling answered as `0n` because the collateral is too small for this market
+* would tell a form nothing about what it is holding — the number a user needs
+* to see is the one they are short of. Collateral that carries something
+* therefore answers with it, whether or not the market would lend that little;
+* a loan under the floor is refused by `borrow` itself, with `debtOutOfRange`
+* naming both ends.
+*
+* Nothing is fetched or simulated — the account does not exist yet and every
+* input is loaded market state, so a form can call this on each keystroke.
+*
+* @param props - {@link MaxBorrowProps}
+* @returns Amount in the payout token's units; `0n` where no loan of this
+* shape exists at any size — a collateral that backs nothing at safe prices, a
+* market with nothing left to lend, and a manager the SDK does not hold yet
+**/
+function maxBorrow(props) {
+	const { sdk, creditManager, collateralAmount, targetHF, quotaReserve } = props;
+	const found = 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);
+	return require_onchain_accounts_intents_utils_common.eq(borrowToken, underlying) ? ceiling : unwrapsPayout ? require_onchain_accounts_intents_utils_common.toTargetDecimals(ceiling, underlying, borrowToken, sdk) : priceOracle.safeConvert(underlying, borrowToken, ceiling).value;
+}
+//#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/realize.js

@@ -1,4 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_onchain_constants_math = require("../../constants/math.js");
 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");
@@ -73,6 +74,26 @@ async function realize(steps, props) {
 	let raised = 0n;
 	/** The request, before the walk's end state can be attached to it. */
 	let delayed;
+	/** Oracle value in the underlying of what routed legs and requests spend and return. */
+	const traded = {
+		spentUnd: 0n,
+		returnedUnd: 0n,
+		priced: true
+	};
+	const trade = (spent, returned) => {
+		const underlyingValue = (legs) => {
+			let sum = 0n;
+			for (const { token, amount } of legs) {
+				if (amount === 0n) continue;
+				const value = price(token, underlying, amount);
+				if (value <= 0n) traded.priced = false;
+				sum += value;
+			}
+			return sum;
+		};
+		traded.spentUnd += underlyingValue(spent);
+		traded.returnedUnd += underlyingValue(returned);
+	};
 	/**
 	* Set by a `clearQuotas` step, which settles the quotas mid-walk instead of
 	* at the end — and settles them at none, whatever the balances turn out to be.
@@ -174,6 +195,13 @@ async function realize(steps, props) {
 				...swap,
 				amountOut: leg.amount
 			});
+			trade([{
+				token: step.from,
+				amount
+			}], [{
+				token: step.to,
+				amount: leg.amount
+			}]);
 			raised = leg.minAmount;
 			break;
 		}
@@ -199,6 +227,13 @@ async function realize(steps, props) {
 						})),
 						amountOut: leg.amount
 					});
+					trade(balances.map((a) => ({
+						token: a.token,
+						amount: a.balance
+					})), [{
+						token: underlying,
+						amount: leg.amount
+					}]);
 				}
 			}
 			raised = ledger.balanceOf(underlying);
@@ -243,6 +278,13 @@ async function realize(steps, props) {
 					amount: require_onchain_accounts_intents_utils_common.toTargetDecimals(queued.amount, queued.token, asset.underlying, sdk)
 				} : void 0
 			};
+			trade([{
+				token: preview.token,
+				amount: preview.amountIn
+			}], [...preview.outputs.filter((o) => !o.isDelayed).map((o) => ({
+				token: o.token,
+				amount: o.amount
+			})), ...delayed.claim ? [delayed.claim] : []]);
 			raised = require_onchain_accounts_intents_operations.instantOutput(preview.outputs)?.amount ?? 0n;
 			break;
 		}
@@ -338,9 +380,11 @@ async function realize(steps, props) {
 		netValue: projected.totalValue - debt,
 		toUnderlying: (from, amount) => price(from, underlying, amount)
 	});
+	const executionCost = traded.priced && traded.spentUnd > 0n ? require_onchain_constants_math.PERCENTAGE_FACTOR_1KK * (traded.returnedUnd - traded.spentUnd) / traded.spentUnd : void 0;
 	const state = {
 		...projection,
 		priceImpact,
+		executionCost,
 		currentPrice: sdk.positions.currentPrice(snapshot)
 	};
 	return {

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;

package/dist/cjs/onchain/accounts/intents/utils/price-impact.js

@@ -19,12 +19,12 @@ function probeBasket(balances, oracle) {
 		if (usd > 0n) basketWad += usd * require_onchain_constants_math.WAD / require_onchain_constants_math.PRICE_DECIMALS;
 	}
 	if (basketWad <= 0n) return;
-	const probeWad = PROBE_UNIT_USD_WAD;
 	const scaled = balances.map((asset) => ({
 		token: asset.token,
-		balance: asset.balance * probeWad / basketWad
+		balance: asset.balance * PROBE_UNIT_USD_WAD / basketWad
 	}));
-	if (!scaled.some((a) => a.balance > 0n)) return;
+	const probeWad = scaled.reduce((sum, a) => sum + oracle.safeConvertToUSD(a.token, a.balance).value * require_onchain_constants_math.WAD / require_onchain_constants_math.PRICE_DECIMALS, 0n);
+	if (probeWad <= 0n) return;
 	return {
 		balances: scaled,
 		basketWad,

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

@@ -4,8 +4,8 @@ require("../../utils/index.js");
 const require_onchain_validation_helpers_health_factor_limits = require("../../validation/helpers/health-factor-limits.js");
 require("../../validation/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_math = require("./math.js");
+const require_onchain_accounts_intents_collateral_valuation = require("./collateral-valuation.js");
 const require_onchain_accounts_intents_view = require("./view.js");
 //#region src/onchain/accounts/intents/withdraw-limits.ts
 /**
@@ -39,7 +39,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`.
@@ -72,20 +72,20 @@ function maxSafeWithdrawal(props) {
 	const view = require_onchain_accounts_intents_view.accountView(creditAccount, sdk);
 	if (view.collateral <= 0n) return 0n;
 	if (view.debt === 0n) return view.collateral;
-	const money = require_onchain_accounts_intents_collateral_money.collateralMoney(creditAccount, sdk);
+	const valuation = require_onchain_accounts_intents_collateral_valuation.collateralValuation(creditAccount, sdk);
 	const source = props.sourceToken ?? view.fattest();
 	const holding = source === void 0 ? void 0 : creditAccount.tokens.find((t) => require_onchain_accounts_intents_utils_common.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/cjs/onchain/core/createAddressProvider.js

@@ -1,15 +1,12 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_abi_iVersion = require("../../abi/iVersion.js");
-const require_onchain_constants_address_provider = require("../constants/address-provider.js");
+require("../constants/address-provider.js");
 const require_onchain_constants_versions = require("../constants/versions.js");
 require("../constants/index.js");
 const require_onchain_utils_hex = require("../utils/hex.js");
 const require_onchain_core_AddressProviderV310Contract = require("./AddressProviderV310Contract.js");
 //#region src/onchain/core/createAddressProvider.ts
-const OVERRIDE_ADDRESSES = { Mainnet: {
-	[require_onchain_constants_address_provider.AP_PRICE_FEED_COMPRESSOR]: { 311: "0x1fA2637B9fab0CD14290A7EE908DDc9688a15120" },
-	[require_onchain_constants_address_provider.AP_MARKET_COMPRESSOR]: { 311: "0x0C27F242f6e9F2A9AD3261bE6e439De3B948bcA2" }
-} };
+const OVERRIDE_ADDRESSES = {};
 async function createAddressProvider(sdk, address) {
 	let v;
 	if (require_onchain_utils_hex.hexEq(address, "0xF7f0a609BfAb9a0A98786951ef10e5FE26cC1E38")) v = 310n;