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

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/dev/midasUtils.d.ts

@@ -22,9 +22,10 @@ interface UnpauseMidasIssuanceVaultProps {
  */
 type RestoreMidasIssuanceVaultPause = () => Promise<void>;
 /**
- * Unpauses a globally paused Midas issuance vault on an anvil fork, so that
- * `depositInstant` stops reverting with `Pausable: paused`, and returns a
- * callback that restores the original pause state.
+ * Unpauses a Midas issuance vault on an anvil fork so that `depositInstant`
+ * stops reverting with `Pausable: paused` (global) or `Pausable: fn paused`
+ * (per-selector), and returns a callback that restores the original pause
+ * state of each layer that was cleared.
  *
  * Impersonates `admin` and grants it `pauseAdminRole()` when missing, same as
  * `greenlistMidasGateway` does with the greenlist roles. The grant is not

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";

package/dist/types/onchain/accounts/index.d.ts

@@ -19,17 +19,18 @@ import { AccountBotsService } from "./bots/AccountBotsService.js";
 import { PeripheryCompressorV310Contract } from "./bots/PeripheryCompressorV310Contract.js";
 import "./bots/index.js";
 import { CreditAccountsServiceV310 } from "./CreditAccountsServiceV310.js";
-import { LeverageBand } from "./intents/leverage-band.js";
 import { CalcDefaultQuotaProps, CalcQuotaUpdateProps, CalcRecommendedQuotaProps, calcDefaultQuota, calcQuotaUpdate, calcRecommendedQuota, roundUpQuota } from "./quota-utils.js";
 import { AccountCalculatorOperation } from "./intents/operations.js";
 import { AddCollateralIntent, AdjustLeverageIntent, ClaimRemainder, CreditAccountSlice, DelayableIntent, DelayedRoute, DelayedStart, DelayedStartResult, DepositStrategyIntent, FinishIntentProps, FinishIntentResult, InstantRoute, IntentPreviewResult, IntentRoutesResult, OperationState, PathLossRate, RepayStrategyIntent, ResumableIntent, RouteErrors, StartIntent, WithdrawAssetIntent, WithdrawCeilings, WithdrawStrategyIntent } from "./intents/types.js";
+import { BorrowProps, BorrowState } from "./intents/borrow.js";
+import { LeverageBand } from "./intents/leverage-band.js";
 import { OpenStrategyProps, OpenStrategyState } from "./intents/open-strategy.js";
 import { fetchCreditAccountSlice, toCreditAccountSlice } from "./intents/utils/credit-account-slice.js";
 import { isPhantomToken } from "./intents/utils/pick-token.js";
-import { CreditAccountOperationsService, OpenStrategyPreviewResult } from "./intents/index.js";
+import { BorrowPreviewResult, CreditAccountOperationsService, EmptyAccountPreviewResult, OpenStrategyPreviewResult } from "./intents/index.js";
 import { LIQUIDATION_APPROVAL_BUFFER, LIQUIDATION_COMPRESSOR_V313_ADDRESS } from "./liquidations/constants.js";
 import { BuildLiquidationTxProps, BuildLiquidationTxPropsBase, GetLiquidatableAccountsProps, GetLiquidationDetailsProps, GetLiquidationDetailsPropsBase, GetLiquidationPositionsProps, GetLiquidationPositionsPropsBase, LoadRWALiquidatorsProps, OnchainLiquidationCall, OnchainLiquidationData, OnchainLiquidationOutput, RWALiquidatorInfo } from "./liquidations/types.js";
 import { LiquidationsService } from "./liquidations/LiquidationsService.js";
 import { MultichainLiquidationsService } from "./liquidations/MultichainLiquidationsService.js";
 import "./liquidations/index.js";
-export { AbstractWithdrawalCompressorContract, AccountBotsService, type AccountCalculatorOperation, AccountToCheck, type AddCollateralIntent, type AdjustLeverageIntent, AssembleCaOperationsProps, AssembleClaimDelayedCallsProps, AssembleCloseCreditAccountCallsProps, AssembleRepayCreditAccountCallsProps, AssembleStartDelayedWithdrawalCallsProps, BotStatusCall, BotsDirectResponse, BuildLiquidationTxProps, BuildLiquidationTxPropsBase, CMSlice, CalcDefaultQuotaProps, CalcQuotaUpdateProps, CalcRecommendedQuotaProps, ClaimFarmRewardsProps, type ClaimRemainder, ClaimableWithdrawal, CloseCreditAccountResult, ConnectedBotsCall, ConnectedBotsPerAccount, CreditAccountCompressor, CreditAccountCompressorV310Contract, CreditAccountDataCall, CreditAccountFilter, CreditAccountOperationResult, CreditAccountOperationsService, CreditAccountReadOptions, type CreditAccountSlice, CreditAccountsCall, CreditAccountsQuery, CreditAccountsReadOptions, CreditAccountsServiceV310, CreditAccountsTarget, CreditManagerFilter, CreditManagerOperationResult, CurrentWithdrawals, DELAYED_INTENT_TYPES, DELAYED_INTENT_VERSION, type DelayableIntent, DelayedIntentExtended, type DelayedRoute, type DelayedStart, type DelayedStartResult, type DepositStrategyIntent, EncodableCreditAccountOperation, type FinishIntentProps, type FinishIntentResult, FullyLiquidateProps, FullyLiquidateResult, GetApprovalAddressProps, GetConnectedBotsResponse, GetConnectedBotsResult, GetConnectedMigrationBotsResult, GetCreditAccountsArgs, GetCreditAccountsOptions, GetExternalAccountCurrentWithdrawalsProps, GetLiquidatableAccountsProps, GetLiquidationDetailsProps, GetLiquidationDetailsPropsBase, GetLiquidationPositionsProps, GetLiquidationPositionsPropsBase, GetWithdrawalRequestResultProps, ICreditAccountsService, IRedemptionLoggerContract, IWithdrawalCompressorContract, type InstantRoute, type IntentPreviewResult, type IntentRoutesResult, LIQUIDATION_APPROVAL_BUFFER, LIQUIDATION_COMPRESSOR_V313_ADDRESS, type LeverageBand, LiquidationsService, LoadRWALiquidatorsProps, MulticallWithFailure, MultichainLiquidationsService, OnchainLiquidationCall, OnchainLiquidationData, OnchainLiquidationOutput, OnchainRequestableWithdrawal, OpenCAProps, OpenStrategyPreviewResult, type OpenStrategyProps, type OpenStrategyState, type OperationState, PartiallyLiquidateProps, type PathLossRate, PendingWithdrawal, PeripheryCompressorV310Contract, PreviewDelayedWithdrawalProps, RWALiquidatorInfo, RedemptionLog, RedemptionLoggerV310Contract, type RepayStrategyIntent, RequestableWithdrawal, type ResumableIntent, Rewards, type RouteErrors, SetBotProps, SetBotResult, type StartIntent, type WithdrawAssetIntent, type WithdrawCeilings, type WithdrawStrategyIntent, WithdrawableAsset, WithdrawalCompressorLocation, WithdrawalCompressorV310Contract, WithdrawalCompressorV311Contract, WithdrawalCompressorV313Contract, WithdrawalCompressorVersion, WithdrawalOutput, WithdrawalStatus, WithdrawalsState, calcDefaultQuota, calcQuotaUpdate, calcRecommendedQuota, createRedemptionLogger, createWithdrawalCompressor, decodeDelayedIntent, encodeDelayedIntent, fetchCreditAccountSlice, getWithdrawalCompressorAddress, iCreditAccountAbi, isPhantomToken, roundUpQuota, toClaimableWithdrawal, toCreditAccountSlice, toPendingWithdrawal, toRequestableWithdrawal, toWithdrawalStatus };
+export { AbstractWithdrawalCompressorContract, AccountBotsService, type AccountCalculatorOperation, AccountToCheck, type AddCollateralIntent, type AdjustLeverageIntent, AssembleCaOperationsProps, AssembleClaimDelayedCallsProps, AssembleCloseCreditAccountCallsProps, AssembleRepayCreditAccountCallsProps, AssembleStartDelayedWithdrawalCallsProps, BorrowPreviewResult, type BorrowProps, type BorrowState, BotStatusCall, BotsDirectResponse, BuildLiquidationTxProps, BuildLiquidationTxPropsBase, CMSlice, CalcDefaultQuotaProps, CalcQuotaUpdateProps, CalcRecommendedQuotaProps, ClaimFarmRewardsProps, type ClaimRemainder, ClaimableWithdrawal, CloseCreditAccountResult, ConnectedBotsCall, ConnectedBotsPerAccount, CreditAccountCompressor, CreditAccountCompressorV310Contract, CreditAccountDataCall, CreditAccountFilter, CreditAccountOperationResult, CreditAccountOperationsService, CreditAccountReadOptions, type CreditAccountSlice, CreditAccountsCall, CreditAccountsQuery, CreditAccountsReadOptions, CreditAccountsServiceV310, CreditAccountsTarget, CreditManagerFilter, CreditManagerOperationResult, CurrentWithdrawals, DELAYED_INTENT_TYPES, DELAYED_INTENT_VERSION, type DelayableIntent, DelayedIntentExtended, type DelayedRoute, type DelayedStart, type DelayedStartResult, type DepositStrategyIntent, EmptyAccountPreviewResult, EncodableCreditAccountOperation, type FinishIntentProps, type FinishIntentResult, FullyLiquidateProps, FullyLiquidateResult, GetApprovalAddressProps, GetConnectedBotsResponse, GetConnectedBotsResult, GetConnectedMigrationBotsResult, GetCreditAccountsArgs, GetCreditAccountsOptions, GetExternalAccountCurrentWithdrawalsProps, GetLiquidatableAccountsProps, GetLiquidationDetailsProps, GetLiquidationDetailsPropsBase, GetLiquidationPositionsProps, GetLiquidationPositionsPropsBase, GetWithdrawalRequestResultProps, ICreditAccountsService, IRedemptionLoggerContract, IWithdrawalCompressorContract, type InstantRoute, type IntentPreviewResult, type IntentRoutesResult, LIQUIDATION_APPROVAL_BUFFER, LIQUIDATION_COMPRESSOR_V313_ADDRESS, type LeverageBand, LiquidationsService, LoadRWALiquidatorsProps, MulticallWithFailure, MultichainLiquidationsService, OnchainLiquidationCall, OnchainLiquidationData, OnchainLiquidationOutput, OnchainRequestableWithdrawal, OpenCAProps, OpenStrategyPreviewResult, type OpenStrategyProps, type OpenStrategyState, type OperationState, PartiallyLiquidateProps, type PathLossRate, PendingWithdrawal, PeripheryCompressorV310Contract, PreviewDelayedWithdrawalProps, RWALiquidatorInfo, RedemptionLog, RedemptionLoggerV310Contract, type RepayStrategyIntent, RequestableWithdrawal, type ResumableIntent, Rewards, type RouteErrors, SetBotProps, SetBotResult, type StartIntent, type WithdrawAssetIntent, type WithdrawCeilings, type WithdrawStrategyIntent, WithdrawableAsset, WithdrawalCompressorLocation, WithdrawalCompressorV310Contract, WithdrawalCompressorV311Contract, WithdrawalCompressorV313Contract, WithdrawalCompressorVersion, WithdrawalOutput, WithdrawalStatus, WithdrawalsState, calcDefaultQuota, calcQuotaUpdate, calcRecommendedQuota, createRedemptionLogger, createWithdrawalCompressor, decodeDelayedIntent, encodeDelayedIntent, fetchCreditAccountSlice, getWithdrawalCompressorAddress, iCreditAccountAbi, isPhantomToken, roundUpQuota, toClaimableWithdrawal, toCreditAccountSlice, toPendingWithdrawal, toRequestableWithdrawal, toWithdrawalStatus };

package/dist/types/onchain/accounts/intents/borrow.d.ts

@@ -0,0 +1,141 @@
+import { TokenAmount } from "../../../model/primitives.js";
+import "../../../model/index.js";
+import { Asset } from "../../base/types.js";
+import { MultiCall } from "../../types/transactions.js";
+import { OnchainSDK } from "../../OnchainSDK.js";
+import { CreditAccountSlice, OperationState } from "./types.js";
+import "../../index.js";
+import { Address } from "viem";
+//#region src/onchain/accounts/intents/borrow.d.ts
+/**
+ * Taking a loan against collateral, in one transaction that opens the account.
+ *
+ * The plainest thing a credit account can do, and the one shape of it the
+ * leveraged flows cannot express: the borrowed funds do not stay on the
+ * account to be traded, they go to the wallet. What is left behind is the
+ * collateral and the debt it backs.
+ */
+interface BorrowProps {
+  sdk: OnchainSDK;
+  /** Credit manager to open the account in. */
+  creditManager: Address;
+  /** Token the wallet puts up, in the manager's collateral list. */
+  collateralToken: Address;
+  /** Amount of {@link collateralToken}, in its own units. */
+  collateralAmount: bigint;
+  /**
+   * Token the loan is paid out in. The market underlying needs no trade;
+   * anything else is bought with the borrowed underlying on the way out.
+   *
+   * On an RWA market the underlying is a compliance wrapper that cannot leave
+   * the account, so the payout there is the asset behind it — USDC rather than
+   * dcUSDC — and the wrapper itself is refused.
+   */
+  borrowToken: Address;
+  /** Amount of {@link borrowToken} the wallet asks for, in its own units. */
+  borrowAmount: bigint;
+  /** Router slippage in PERCENTAGE_FORMAT (100% = 10_000). */
+  slippage: number | undefined;
+  /** Extra quota headroom in PERCENTAGE_FORMAT. */
+  quotaReserve: number | undefined;
+  /**
+   * Existing credit account to draw the loan on, instead of opening one.
+   *
+   * Must carry no debt and no quotas, as a reused opening must. Borrowing on
+   * an account that already owes is what the `ADJUST_LEVERAGE` intent is for.
+   **/
+  creditAccount?: CreditAccountSlice;
+}
+/**
+ * Where a borrow leaves the wallet and the account it opens.
+ *
+ * A whole {@link OperationState}, holdings included: unlike an opening, a
+ * borrow has no second branch of balances to choose between — the collateral
+ * is the only thing left on the account and its amount is known exactly.
+ * Slippage lands on the payout instead, which is why that one is reported
+ * twice.
+ *
+ * Being that state rather than merely resembling it is what lets a borrow
+ * result go straight to `checkSimulation`, which weighs whatever the engine
+ * projected: the market, the debt, the quotas and the two factors, all of
+ * which a borrow reports where an operation on an existing account does.
+ */
+interface BorrowState extends OperationState {
+  /** What the wallet puts up, as it will sit on the account. */
+  collateral: TokenAmount;
+  /**
+   * What the wallet is expected to receive, in the token it asked for. Equal
+   * to the debt when that token is the market underlying, and to the debt
+   * rescaled where an RWA payout unwraps it one for one; in neither case is
+   * anything traded.
+   */
+  borrowed: TokenAmount;
+  /**
+   * The floor under {@link borrowed} once slippage is allowed for — what the
+   * transaction is signed against. Equal to `borrowed` when nothing is traded.
+   */
+  minBorrowed: TokenAmount;
+  /**
+   * Router slippage the payout leg was quoted at, in PERCENTAGE_FORMAT
+   * (100% = 10_000). The SDK's own default where the caller named none.
+   */
+  slippage: number;
+  /**
+   * Quota to buy for the collateral; feeds `openCA.averageQuota` and
+   * `openCA.minQuota` alike, both branches being the same here.
+   *
+   * Transport for the transaction rather than something to display, like
+   * {@link calls} below.
+   */
+  quotaIncrease: Asset[];
+  /**
+   * The leg that turns the borrowed underlying into the payout: a router path
+   * where it is bought, the vault redemption where an RWA market unwraps it,
+   * empty where the payout is the underlying itself. Feeds `openCA.calls`,
+   * which places it before the withdrawal.
+   */
+  calls: MultiCall[];
+  /**
+   * The account this loan was simulated against and must be executed on, when
+   * it reuses one; `undefined` for a borrow that opens its own.
+   *
+   * Carried here rather than asked of the caller again at `buildTx`, so the
+   * transaction cannot be built against an account the numbers were not
+   * computed for.
+   **/
+  creditAccount?: Address;
+}
+/**
+ * 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.
+ */
+declare function buildBorrowState(props: BorrowProps): Promise<BorrowState>;
+/** Inputs of {@link borrowCollateralQuota}. */
+interface BorrowCollateralQuotaProps {
+  sdk: OnchainSDK;
+  creditManager: Address;
+  /** Collateral the fresh account will hold. */
+  assets: Asset[];
+  /** Extra quota headroom in PERCENTAGE_FORMAT. */
+  quotaReserve: number | undefined;
+}
+/**
+ * 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}
+ **/
+declare function borrowCollateralQuota({ sdk, creditManager, assets, quotaReserve }: BorrowCollateralQuotaProps): Asset[];
+//#endregion
+export { BorrowCollateralQuotaProps, BorrowProps, BorrowState, borrowCollateralQuota, buildBorrowState };

package/dist/types/onchain/accounts/intents/{collateral-money.d.ts → collateral-valuation.d.ts}

@@ -2,7 +2,7 @@ import { OnchainSDK } from "../../OnchainSDK.js";
 import { CreditAccountSlice } from "./types.js";
 import "../../index.js";
 import { Address } from "viem";
-//#region src/onchain/accounts/intents/collateral-money.d.ts
+//#region src/onchain/accounts/intents/collateral-valuation.d.ts
 /** One balance on the account, as the slice carries it. */
 type Holding = CreditAccountSlice["tokens"][number];
 /**
@@ -17,10 +17,10 @@ type Holding = CreditAccountSlice["tokens"][number];
  * exempt and stays on the main feed, as `CreditManagerV3._safeConvertToUSD`
  * does.
  *
- * Money is carried in USD × `PERCENTAGE_FACTOR`, the units the check compares
- * in, so a threshold never has to be divided back out.
+ * Every figure is carried in USD × `PERCENTAGE_FACTOR`, the units the check
+ * compares in, so a threshold never has to be divided back out.
  */
-interface CollateralMoney {
+interface CollateralValuation {
   /** Market underlying, the one token safe pricing does not touch. */
   underlying: Address;
   /** Whether the holding is weighed at all. */
@@ -28,7 +28,7 @@ interface CollateralMoney {
   /** What the holding backs, in USD × `PERCENTAGE_FACTOR`. */
   weigh(holding: Holding): bigint;
   /** What the holding's quota backs, in the same units; 0 on a closed market. */
-  quotaMoney(holding: Holding): bigint;
+  quotaValue(holding: Holding): bigint;
   /** USD at the main feed; `undefined` when the token has no price at all. */
   mainUsd(token: Address, amount: bigint): bigint | undefined;
   /** USD the check counts the holding at, before its threshold. */
@@ -36,7 +36,7 @@ interface CollateralMoney {
   /** Liquidation threshold in basis points; 0 for a token the manager refuses. */
   lt(token: Address): bigint;
 }
-/** {@inheritDoc CollateralMoney} */
-declare function collateralMoney(creditAccount: CreditAccountSlice, sdk: OnchainSDK): CollateralMoney;
+/** {@inheritDoc CollateralValuation} */
+declare function collateralValuation(creditAccount: CreditAccountSlice, sdk: OnchainSDK): CollateralValuation;
 //#endregion
-export { CollateralMoney, Holding, collateralMoney };
+export { CollateralValuation, Holding, collateralValuation };

package/dist/types/onchain/accounts/intents/index.d.ts

@@ -2,9 +2,11 @@ import { SDKError } from "../../../model/result.js";
 import "../../../model/index.js";
 import { SDKConstruct } from "../../base/SDKConstruct.js";
 import { IntentValidationError } from "../../validation/raise.js";
-import { LeverageBand, LeverageBandProps } from "./leverage-band.js";
 import { AccountCalculatorOperation } from "./operations.js";
 import { AddCollateralIntent, AdjustLeverageIntent, ClaimRemainder, CreditAccountSlice, DelayableIntent, DelayedRoute, DelayedStart, DelayedStartResult, DepositStrategyIntent, FinishIntentProps, FinishIntentResult, InstantRoute, IntentPreviewResult, IntentRoutesResult, OperationState, PathLossRate, RepayStrategyIntent, ResumableIntent, RouteErrors, StartIntent, StartIntentProps, WithdrawAssetIntent, WithdrawCeilings, WithdrawStrategyIntent } from "./types.js";
+import { BorrowProps, BorrowState } from "./borrow.js";
+import { LeverageBand, LeverageBandProps } from "./leverage-band.js";
+import { MaxBorrowProps } from "./maxBorrow.js";
 import { OpenStrategyProps, OpenStrategyState } from "./open-strategy.js";
 import { fetchCreditAccountSlice, toCreditAccountSlice } from "./utils/credit-account-slice.js";
 import { isPhantomToken } from "./utils/pick-token.js";
@@ -21,6 +23,22 @@ type OpenStrategyPreviewResult = {
   ok: true;
   state: OpenStrategyState;
 } | SDKError<IntentValidationError>;
+/**
+ * Borrow preview outcome, shaped like {@link OpenStrategyPreviewResult}: both
+ * open an account, so neither has an operation chain to report.
+ */
+type BorrowPreviewResult = {
+  ok: true;
+  state: BorrowState;
+} | SDKError<IntentValidationError>;
+/**
+ * Empty-account preview outcome: the thinnest of the three, since an account
+ * that holds nothing has no state to project — only the market's own refusal
+ * to open one at all.
+ */
+type EmptyAccountPreviewResult = {
+  ok: true;
+} | SDKError<IntentValidationError>;
 /** An intent plus everything previewing it needs. */
 type StartProps = StartIntentProps & {
   intent: StartIntent;
@@ -119,6 +137,27 @@ declare class CreditAccountOperationsService extends SDKConstruct {
     token: Address;
     targetHF?: bigint;
   }): bigint;
+  /**
+   * 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: Omit<MaxBorrowProps, "targetHF"> & {
+    targetHF?: bigint;
+  }): bigint;
   /**
    * Previews the same operation when its source only redeems through its
    * issuer: a Securitize dsToken, a Mellow share.
@@ -186,6 +225,21 @@ declare class CreditAccountOperationsService extends SDKConstruct {
    * beside it, so both halves of an operation are consumed the same way
    */
   finishIntent(props: FinishIntentProps): Promise<FinishIntentResult>;
+  /**
+   * 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
+   */
+  openEmptyAccountIntent(props: Pick<StartIntentProps, "sdk"> & {
+    creditManager: Address;
+  }): Promise<EmptyAccountPreviewResult>;
   /**
    * Previews opening a brand-new leveraged position.
    *
@@ -199,6 +253,28 @@ declare class CreditAccountOperationsService extends SDKConstruct {
    * leverage or the resulting debt is not viable
    */
   openStrategyIntent(props: OpenStrategyProps): Promise<OpenStrategyPreviewResult>;
+  /**
+   * 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
+   */
+  borrowIntent(props: BorrowProps): Promise<BorrowPreviewResult>;
 }
 //#endregion
-export { type AccountCalculatorOperation, type AddCollateralIntent, type AdjustLeverageIntent, type ClaimRemainder, CreditAccountOperationsService, type CreditAccountSlice, type DelayableIntent, type DelayedRoute, type DelayedStart, type DelayedStartResult, type DepositStrategyIntent, type FinishIntentProps, type FinishIntentResult, type InstantRoute, type IntentPreviewResult, type IntentRoutesResult, type LeverageBand, OpenStrategyPreviewResult, type OpenStrategyProps, type OpenStrategyState, type OperationState, type PathLossRate, type RepayStrategyIntent, type ResumableIntent, type RouteErrors, type StartIntent, type WithdrawAssetIntent, type WithdrawCeilings, type WithdrawStrategyIntent, fetchCreditAccountSlice, isPhantomToken, toCreditAccountSlice };
+export { type AccountCalculatorOperation, type AddCollateralIntent, type AdjustLeverageIntent, BorrowPreviewResult, type BorrowProps, type BorrowState, type ClaimRemainder, CreditAccountOperationsService, type CreditAccountSlice, type DelayableIntent, type DelayedRoute, type DelayedStart, type DelayedStartResult, type DepositStrategyIntent, EmptyAccountPreviewResult, type FinishIntentProps, type FinishIntentResult, type InstantRoute, type IntentPreviewResult, type IntentRoutesResult, type LeverageBand, OpenStrategyPreviewResult, type OpenStrategyProps, type OpenStrategyState, type OperationState, type PathLossRate, type RepayStrategyIntent, type ResumableIntent, type RouteErrors, type StartIntent, type WithdrawAssetIntent, type WithdrawCeilings, type WithdrawStrategyIntent, fetchCreditAccountSlice, isPhantomToken, toCreditAccountSlice };

package/dist/types/onchain/accounts/intents/maxBorrow.d.ts

@@ -0,0 +1,47 @@
+import { OnchainSDK } from "../../OnchainSDK.js";
+import "../../index.js";
+import { Address } from "viem";
+//#region src/onchain/accounts/intents/maxBorrow.d.ts
+interface MaxBorrowProps {
+  sdk: OnchainSDK;
+  /** Credit manager the loan would be taken in. */
+  creditManager: Address;
+  /** Token the wallet puts up, in the manager's collateral list. */
+  collateralToken: Address;
+  /** Amount of {@link collateralToken}, in its own units. */
+  collateralAmount: bigint;
+  /** Token the loan is paid out in; the answer is in its units. */
+  borrowToken: Address;
+  /** Health factor the loan has to leave the account at, in basis points. */
+  targetHF: bigint;
+  /** Extra quota headroom in PERCENTAGE_FORMAT, as the borrow itself takes. */
+  quotaReserve: number | undefined;
+}
+/**
+ * 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
+ **/
+declare function maxBorrow(props: MaxBorrowProps): bigint;
+//#endregion
+export { MaxBorrowProps, maxBorrow };