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

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

@@ -0,0 +1,87 @@
+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.
+*
+* 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 = 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);
+	return eq(borrowToken, underlying) ? ceiling : unwrapsPayout ? toTargetDecimals(ceiling, underlying, borrowToken, sdk) : priceOracle.safeConvert(underlying, borrowToken, ceiling).value;
+}
+//#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({

package/dist/esm/sdk/execute/ExecuteApi.js

@@ -16,6 +16,8 @@ var ExecuteApi = class {
 		switch (request.kind) {
 			case "pool": return poolTx(sdk, request);
 			case "open": return openTx(sdk, request);
+			case "openEmpty": return openEmptyTx(sdk, request);
+			case "borrow": return borrowTx(sdk, request);
 			case "account": return accountTx(sdk, request);
 		}
 	}
@@ -62,17 +64,75 @@ async function openTx(sdk, request) {
 		reopenCreditAccount: state.creditAccount,
 		permits: {},
 		referralCode: 0n,
-		rwaOptions: await openRwaOptions(sdk, request)
+		rwaOptions: await openRwaOptions(sdk, request, request.targetToken)
+	});
+}
+/**
+* The opening with nothing in it: no debt to draw, no collateral to take, no
+* path to run and no quota to buy, so `openCA` is left with the price updates
+* the market demands and the facade's own `openCreditAccount`.
+*
+* Nothing is read off the preparation because there is nothing on it. The
+* account holds no token, so an RWA market has none to gate on either.
+**/
+function openEmptyTx(sdk, request) {
+	return sdk.accounts.openCA({
+		creditManager: request.creditManager,
+		to: request.wallet,
+		collateral: [],
+		ethAmount: 0n,
+		debt: 0n,
+		calls: [],
+		averageQuota: [],
+		minQuota: [],
+		permits: {},
+		referralCode: 0n
+	});
+}
+/**
+* A loan is an opening whose debt leaves again, so it is the same `openCA`
+* with `withdrawToken` set: the facade draws the debt, takes the collateral,
+* runs whatever path buys the payout, and sweeps that payout to the wallet.
+*
+* Both quota branches are the one the state carries. An opening has two
+* because the balances it lands on are a router quote; here the account is
+* left holding the collateral the caller named, and a named amount has no
+* floor to differ from.
+**/
+async function borrowTx(sdk, request) {
+	const { creditManager, wallet, ethAmount, sim } = request;
+	const { state } = sim.data;
+	const collateral = {
+		token: state.collateral.token.address,
+		balance: state.collateral.value
+	};
+	return sdk.accounts.openCA({
+		creditManager,
+		to: wallet,
+		collateral: [collateral],
+		ethAmount,
+		debt: state.totalDebt.value,
+		calls: state.calls,
+		withdrawToken: state.borrowed.token.address,
+		averageQuota: state.quotaIncrease,
+		minQuota: state.quotaIncrease,
+		reopenCreditAccount: state.creditAccount,
+		permits: {},
+		referralCode: 0n,
+		rwaOptions: await openRwaOptions(sdk, request, collateral.token)
 	});
 }
 /**
 * The documented `openCA` contract: ask the market for its open requirements
 * and hand them back as operation args, with the caller's cached signatures
-* attached. `undefined` on non-RWA markets and when no target token is named.
+* attached. `undefined` on non-RWA markets and when no token is named.
+*
+* `token` is the one the account ends up holding, which is what an RWA market
+* gates on: the opening's target, and the borrow's collateral.
 **/
-async function openRwaOptions(sdk, request) {
-	if (!request.targetToken) return;
-	const requirements = await sdk.accounts.getOpenAccountRequirements(request.wallet, request.creditManager, { tokenOutAddress: request.targetToken });
+async function openRwaOptions(sdk, request, token) {
+	if (!token) return;
+	const requirements = await sdk.accounts.getOpenAccountRequirements(request.wallet, request.creditManager, { tokenOutAddress: token });
 	if (requirements?.protocol !== "securitize") return;
 	return {
 		protocol: "securitize",

package/dist/esm/sdk/prepare/PrepareApi.js

@@ -195,26 +195,33 @@ var PrepareApi = class extends MultichainConstruct {
 		}
 	}
 	/**
+	* {@inheritDoc IOpportunitiesPrepare.openEmptyCreditAccount}
+	**/
+	async openEmptyCreditAccount(strategy) {
+		try {
+			const sdk = await this.#chain(strategy.chainId);
+			const at = stateBlock(sdk);
+			const result = await service(sdk).openEmptyAccountIntent({
+				sdk,
+				creditManager: strategy.creditManager
+			});
+			return result.ok ? sdkOk(at) : methodError(result);
+		} catch (e) {
+			return sdkErr(unexpectedFailure(e));
+		}
+	}
+	/**
 	* {@inheritDoc IOpportunitiesPrepare.openNewStrategy}
 	**/
 	async openNewStrategy(strategy, params) {
 		try {
 			const sdk = await this.#chain(strategy.chainId);
 			const at = stateBlock(sdk);
-			if (params.empty) return opened(await service(sdk).openStrategyIntent({
-				sdk,
-				creditManager: strategy.creditManager,
-				empty: true
-			}), at);
 			const targetToken = params.targetToken ?? sdk.marketRegister.findCreditManager(strategy.creditManager).strategyTargetCollateral;
 			if (!targetToken) return sdkErr(noStrategyTargetCollateral(strategy.creditManager));
-			let creditAccount;
-			if (params.creditAccount) {
-				const reused = await slice(sdk, params.creditAccount);
-				if (!reused || !isAddressEqual(reused.creditManager, strategy.creditManager)) return sdkErr(creditAccountNotFound(params.creditAccount));
-				if (reused.totalDebt > 0n || reused.tokens.some((t) => t.quota > 0n)) return sdkErr(creditAccountNotEmpty(params.creditAccount));
-				creditAccount = reused;
-			}
+			const reused = await reusable(sdk, strategy, params.creditAccount);
+			if (reused && "error" in reused) return reused;
+			const creditAccount = reused?.account;
 			return opened(await service(sdk).openStrategyIntent({
 				sdk,
 				creditManager: strategy.creditManager,
@@ -231,6 +238,30 @@ var PrepareApi = class extends MultichainConstruct {
 		}
 	}
 	/**
+	* {@inheritDoc IOpportunitiesPrepare.borrow}
+	**/
+	async borrow(strategy, params) {
+		try {
+			const sdk = await this.#chain(strategy.chainId);
+			const at = stateBlock(sdk);
+			const reused = await reusable(sdk, strategy, params.creditAccount);
+			if (reused && "error" in reused) return reused;
+			return borrowed(await service(sdk).borrowIntent({
+				sdk,
+				creditManager: strategy.creditManager,
+				collateralToken: params.collateralToken,
+				collateralAmount: params.collateralAmount,
+				borrowToken: params.borrowToken,
+				borrowAmount: params.borrowAmount,
+				slippage: params.slippage,
+				quotaReserve: params.quotaReserve,
+				creditAccount: reused?.account
+			}), at);
+		} catch (e) {
+			return sdkErr(unexpectedFailure(e));
+		}
+	}
+	/**
 	* {@inheritDoc IOpportunitiesPrepare.depositStrategy}
 	**/
 	async depositStrategy(position, params) {
@@ -353,6 +384,21 @@ var PrepareApi = class extends MultichainConstruct {
 		});
 	}
 	/**
+	* {@inheritDoc IOpportunitiesPrepare.maxBorrow}
+	**/
+	maxBorrow(strategy, params) {
+		const sdk = this.sdk.chain(strategy.chainId);
+		return service(sdk).maxBorrow({
+			sdk,
+			creditManager: strategy.creditManager,
+			collateralToken: params.collateralToken,
+			collateralAmount: params.collateralAmount,
+			borrowToken: params.borrowToken,
+			targetHF: params.targetHF,
+			quotaReserve: params.quotaReserve
+		});
+	}
+	/**
 	* The account a bare `max*` read weighs. These reads answer a number, not
 	* an envelope, so an account the markets do not hold is thrown rather than
 	* described, see {@link IOpportunitiesPrepare.maxWithdraw}.
@@ -438,6 +484,25 @@ async function slice(sdk, creditAccount) {
 	return data && toCreditAccountSlice(data);
 }
 /**
+* The pre-opened account a request asks to be run on, held to what "pre-opened"
+* means: this manager's, owing nothing and holding no quota.
+*
+* Shared by the two flows that put something on a fresh account — an opening
+* and a borrow — so both hold a reused one to the same terms. Whatever
+* balances sit on it are left to the flow: an opening routes them, a borrow
+* leaves them where they are.
+*
+* @returns Nothing when the request named no account, the refusal to answer
+* with when it named one that does not qualify, and the slice otherwise
+**/
+async function reusable(sdk, strategy, creditAccount) {
+	if (!creditAccount) return;
+	const account = await slice(sdk, creditAccount);
+	if (!account || !isAddressEqual(account.creditManager, strategy.creditManager)) return sdkErr(creditAccountNotFound(creditAccount));
+	if (account.totalDebt > 0n || account.tokens.some((t) => t.quota > 0n)) return sdkErr(creditAccountNotEmpty(creditAccount));
+	return { account };
+}
+/**
 * The operation a claim resumes, or `undefined` when there is none to resume:
 * a withdrawal requested without an intent, or one read through a compressor
 * too old to report it. Every intent the engine records can be finished,
@@ -537,6 +602,15 @@ function opened(result, at) {
 }
 /**
 * {@inheritDoc planned}
+**/
+function borrowed(result, at) {
+	return result.ok ? sdkOk({
+		state: result.state,
+		...at
+	}) : methodError(result);
+}
+/**
+* {@inheritDoc planned}
 *
 * Both routes are payload, error and all: `errors` says why a missing one is
 * missing, and it stays on the error when neither route answered, since that is

package/dist/types/model/previews.d.ts

@@ -369,6 +369,15 @@ interface OpenStrategyPositionProjection extends EstimatedProjection {
    * accordingly (omitted entirely when it reaches zero).
    */
   collateralAdded: TokenAmount[];
+  /**
+   * Tokens the same transaction hands back to the wallet
+   * (`withdrawCollateral` calls, with the MAX_UINT256 sentinel resolved
+   * against replayed balances).
+   *
+   * Empty for an opening that keeps everything it bought; a borrow pays its
+   * loan out here, and the values above are what is left once it has.
+   */
+  collateralWithdrawn: TokenAmount[];
   /**
    * The oracle could not price a token; it contributes nothing to the values.
    */
@@ -376,8 +385,8 @@ interface OpenStrategyPositionProjection extends EstimatedProjection {
 }
 /**
  * What an account-opening transaction that already exists would do — the
- * counterpart of `prepare.openNewStrategy`, read off calldata rather than
- * planned into it.
+ * counterpart of `prepare.openNewStrategy` and `prepare.borrow`, read off
+ * calldata rather than planned into it.
  **/
 interface OpenStrategyPositionPreview extends OpenStrategyPositionProjection {
   operation: "OpenCreditAccount";