@gearbox-protocol/sdk 17.0.0-next.4 → 17.0.0

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-valuation.d.ts

@@ -0,0 +1,42 @@
+import { OnchainSDK } from "../../OnchainSDK.js";
+import { CreditAccountSlice } from "./types.js";
+import "../../index.js";
+import { Address } from "viem";
+//#region src/onchain/accounts/intents/collateral-valuation.d.ts
+/** One balance on the account, as the slice carries it. */
+type Holding = CreditAccountSlice["tokens"][number];
+/**
+ * The collateral check's own valuation of an account, as a handful of lookups.
+ *
+ * Shared by everything that solves that check for an amount, so the rules it
+ * encodes are written once: a holding backed by a quota counts the lesser of the
+ * quota and its threshold-weighted value, an unquoted one its weighted value
+ * alone, and dust or a disabled balance nothing at all. Collateral is valued at
+ * the protocol safe price — `min` of the two feeds, 0 where there is no reserve
+ * — the way the facade values a call that hands funds over; the underlying is
+ * exempt and stays on the main feed, as `CreditManagerV3._safeConvertToUSD`
+ * does.
+ *
+ * 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 CollateralValuation {
+  /** Market underlying, the one token safe pricing does not touch. */
+  underlying: Address;
+  /** Whether the holding is weighed at all. */
+  counts(holding: Holding): boolean;
+  /** 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. */
+  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. */
+  checkedUsd(holding: Holding): bigint;
+  /** Liquidation threshold in basis points; 0 for a token the manager refuses. */
+  lt(token: Address): bigint;
+}
+/** {@inheritDoc CollateralValuation} */
+declare function collateralValuation(creditAccount: CreditAccountSlice, sdk: OnchainSDK): CollateralValuation;
+//#endregion
+export { CollateralValuation, Holding, collateralValuation };

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

@@ -1,3 +1,5 @@
+import { Bps, TokenAmount } from "../../../model/primitives.js";
+import "../../../model/index.js";
 import { Asset } from "../../base/types.js";
 import { MarketSuite } from "../../market/MarketSuite.js";
 import { CreditSuite } from "../../market/credit/CreditSuite.js";
@@ -74,11 +76,25 @@ declare function assertGrowthAllowed(args: {
  * whose reserve feed the SDK cannot read keeps its main price, so a plan can
  * still be refused on-chain after passing here.
  */
-declare function assertCollateralised(healthFactorBps: number, safePrices: boolean): void;
+declare function assertCollateralised(healthFactorBps: number, safePrices: boolean, atSafePrices?: SafePriceEvidence): void;
+/**
+ * What tells a reserve feed marking collateral down apart from a position that
+ * is simply too small, read only when the collateral check has already failed.
+ *
+ * A thunk because both halves are expensive: the account has to be valued a
+ * second time at the main feed, and the check solved for the amount that would
+ * still clear it.
+ */
+type SafePriceEvidence = () => {
+  /** The plan's end state weighed at the main feed. */
+  atMainPrices: Bps;
+  /** What the account can still take out, in the market's underlying. */
+  withdrawable: TokenAmount;
+};
 /**
  * A quota can only be raised as far as the market still has room for: past the
  * token's limit the keeper takes nothing more, whoever is asking.
  */
 declare function assertQuotaAvailable(sdk: OnchainSDK, market: MarketSuite, increases: readonly Asset[]): void;
 //#endregion
-export { assertCanBorrow, assertCollateralised, assertGrowthAllowed, assertMarketOperable, assertQuotaAvailable };
+export { SafePriceEvidence, assertCanBorrow, assertCollateralised, assertGrowthAllowed, assertMarketOperable, assertQuotaAvailable };

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 { AddCollateralIntent, AdjustLeverageIntent, ClaimRemainder, CreditAccountSlice, DelayableIntent, DelayedRoute, DelayedStart, DelayedStartResult, DepositStrategyIntent, ExecutionCost, 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;
@@ -45,21 +63,30 @@ declare class CreditAccountOperationsService extends SDKConstruct {
   startIntent(props: StartProps): Promise<IntentPreviewResult>;
   /**
    * Both ends of what a `WITHDRAW` can take out, in underlying: the largest
-   * partial withdrawal that keeps leverage and stays inside the facade's
-   * `debtLimits`, and the net value an exit hands over. They are reported together
-   * because a withdraw form needs both — the range it may offer, and the one
-   * amount past it that is allowed — and because the distance between them is
-   * the account's own, not a constant a caller could assume.
+   * partial withdrawal that keeps leverage, and the net value an exit hands
+   * over. They are reported together because a withdraw form needs both — the
+   * range it may offer, and the one amount past it that is allowed — and
+   * because the distance between them is the account's own, not a constant a
+   * caller could assume.
    *
-   * Takes no target health factor, unlike {@link maxWithdrawCollateral}: a
-   * proportional withdrawal leaves the factor where it found it, and the
-   * facade's `minDebt` is what bounds it.
+   * Two rules bound the partial end and both are reported: the facade's
+   * `debtLimits` as `partial`, and the safe-price collateral check on top of
+   * it as `safePartial`. The second is the one to offer — see
+   * {@link WithdrawCeilings}.
    *
-   * @param props - Account slice and the SDK holding its market
-   * @returns The two ceilings, see {@link WithdrawCeilings} for the gap between
-   * them
+   * Takes no target health factor, unlike {@link maxWithdrawCollateral}. A
+   * proportional withdrawal leaves the factor where it found it, so there is
+   * no room to choose: what these answer to is the facade's own threshold,
+   * which is also what {@link startIntent} refuses against.
+   *
+   * @param props - Account slice, the SDK holding its market, and optionally
+   * the collateral the withdrawal would be funded from
+   * @returns The three limits, see {@link WithdrawCeilings} for the gap
+   * between them
    */
-  maxWithdraw(props: Pick<StartIntentProps, "creditAccount" | "sdk">): WithdrawCeilings;
+  maxWithdraw(props: Pick<StartIntentProps, "creditAccount" | "sdk"> & {
+    sourceToken?: Address;
+  }): WithdrawCeilings;
   /**
    * Debt a `REPAY` would have to cover to settle the account, in underlying
    * units: principal plus the interest and fees accrued as of the read.
@@ -110,6 +137,30 @@ 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.
+   *
+   * 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: Omit<MaxBorrowProps, "targetHF"> & {
+    targetHF?: bigint;
+  }): bigint;
   /**
    * Previews the same operation when its source only redeems through its
    * issuer: a Securitize dsToken, a Mellow share.
@@ -177,6 +228,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.
    *
@@ -190,6 +256,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 ExecutionCost, 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,54 @@
+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.
+ *
+ * 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
+ **/
+declare function maxBorrow(props: MaxBorrowProps): bigint;
+//#endregion
+export { MaxBorrowProps, maxBorrow };

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

@@ -16,14 +16,9 @@ interface MaxWithdrawCollateralProps {
  * factor stays at or above `targetHF`.
  *
  * This is the collateral check solved for one balance, and it counts what that
- * check counts: a holding backed by a quota contributes the lesser of the
- * quota and its threshold-weighted value, an unquoted one — the underlying —
- * its weighted value alone, and dust or a disabled balance nothing at all.
- * Collateral is valued at the protocol safe price (`min` of the two feeds,
- * 0 when there is no reserve), the way the facade values a call that hands
- * funds over; the underlying is exempt and is valued at the main feed, as
- * `CreditManagerV3._safeConvertToUSD` does. 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.

package/dist/types/onchain/accounts/intents/open-strategy.d.ts

@@ -8,15 +8,8 @@ import { CreditAccountSlice, SimulationPrices } from "./types.js";
 import "../../index.js";
 import { Address } from "viem";
 //#region src/onchain/accounts/intents/open-strategy.d.ts
-/**
- * Opening an account and putting a position on it in one transaction.
- *
- * The union says which of the two openings this is: {@link OpenStrategyEmpty}
- * takes only the market, because an account holding nothing has nothing to
- * route, no leverage to reach and no target to reach it in.
- */
-type OpenStrategyProps = OpenStrategyFunded | OpenStrategyEmpty;
-interface OpenStrategyFunded {
+/** Opening an account and putting a position on it in one transaction. */
+interface OpenStrategyProps {
   sdk: OnchainSDK;
   /** Credit manager to open the account in. */
   creditManager: Address;
@@ -39,13 +32,6 @@ interface OpenStrategyFunded {
    * is what the `DEPOSIT` intent is for.
    **/
   creditAccount?: CreditAccountSlice;
-  empty?: false;
-}
-/** Opening an account that holds nothing, for a position to land on later. */
-interface OpenStrategyEmpty {
-  sdk: OnchainSDK;
-  creditManager: Address;
-  empty: true;
 }
 /**
  * Projected result of opening a brand-new leveraged position.
@@ -95,4 +81,4 @@ interface OpenStrategyState extends Omit<AccountProjection, "assets" | "quotas">
  */
 declare function buildOpenStrategyState(props: OpenStrategyProps): Promise<OpenStrategyState>;
 //#endregion
-export { OpenStrategyEmpty, OpenStrategyFunded, OpenStrategyProps, OpenStrategyState, buildOpenStrategyState };
+export { OpenStrategyProps, OpenStrategyState, buildOpenStrategyState };

package/dist/types/onchain/accounts/intents/testing/sdk-mock.d.ts

@@ -90,6 +90,8 @@ interface BuildMockSdkArgs {
   baseInterestRate?: bigint;
   /** Credit manager interest fee in Bps; feeds position metrics. */
   feeInterest?: number;
+  /** Quoted tokens the facade enables at once; feeds `checkQuotaCount`. */
+  maxEnabledTokens?: number;
   creditManager: Address;
   creditFacade: Address;
   /** Market underlying token (`market.pool.underlying`). */

package/dist/types/onchain/accounts/intents/tests/open-strategy.fixtures.d.ts

@@ -1,6 +1,6 @@
 import { Asset } from "../../../base/types.js";
 import { OnchainSDK } from "../../../OnchainSDK.js";
-import { OpenStrategyFunded } from "../open-strategy.js";
+import { OpenStrategyProps } from "../open-strategy.js";
 import "../../../index.js";
 import { MarketSdkExtras } from "../testing/market.js";
 import { Address } from "viem";
@@ -51,6 +51,6 @@ declare const case_underlying_1x: OpenStrategyCase;
  */
 declare const case_mixed_with_leftover: OpenStrategyCase;
 declare function buildOpenStrategySdk(extras?: MarketSdkExtras): OnchainSDK;
-declare function buildOpenStrategyProps(c: OpenStrategyCase, sdk: OnchainSDK): OpenStrategyFunded;
+declare function buildOpenStrategyProps(c: OpenStrategyCase, sdk: OnchainSDK): OpenStrategyProps;
 //#endregion
 export { COLLATERAL_ANY, HALF_UND, KEEP_ANY, LEVERAGE_1X, LEVERAGE_2X, LEVERAGE_3X, LT, MARGIN_UND, OpenStrategyCase, buildOpenStrategyProps, buildOpenStrategySdk, case_mixed_with_leftover, case_underlying_1x, case_underlying_3x, quotaFor };

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

@@ -31,6 +31,18 @@ interface PathLossRate {
   pathPriceImpact: bigint;
   netValuePriceImpact: bigint;
   totalValuePriceImpact: bigint;
+  absolutePriceImpact: TokenAmount;
+}
+/**
+ * What an operation gives up against the oracle: the value of everything its
+ * routed legs and redemption request return, the expected claim included, less
+ * the value of what they spend. Negative for a loss.
+ */
+interface ExecutionCost {
+  /** `out − in` in the market underlying. */
+  amount: TokenAmount;
+  /** `(out − in) / in`, in `PERCENTAGE_FACTOR_1KK` (1_000_000 = 100%). */
+  rate: bigint;
 }
 /**
  * The two prices only a planned walk can quote, carried by every simulation
@@ -62,7 +74,18 @@ interface SimulationPrices {
  * {@link AccountProjection} vocabulary, plus the prices only a routed walk can
  * report.
  */
-interface OperationState extends AccountProjection, SimulationPrices {}
+interface OperationState extends AccountProjection, SimulationPrices {
+  /**
+   * What the operation gives up against the oracle.
+   *
+   * `undefined` where nothing was traded, where a leg cannot be priced, and on
+   * a {@link BorrowState}, which does not measure it: the cost compares an
+   * account against itself before and after, and a borrow's payout goes to the
+   * wallet rather than staying to be compared. What its route cost is on that
+   * state as `borrowed` against `totalDebt`.
+   */
+  executionCost: ExecutionCost | undefined;
+}
 /**
  * What planning an intent yields: the operation chain, the state it projects,
  * and the calldata that realises it — or the error that stopped the plan.
@@ -429,12 +452,34 @@ interface WithdrawStrategyIntent {
  */
 interface WithdrawCeilings {
   /**
-   * Largest partial withdrawal {@link WithdrawStrategyIntent} accepts: the one
-   * whose proportional repayment leaves the debt at `minDebt`. `0n` when the
-   * debt already sits below the floor, and always at least one unit under
-   * `exit` — the last unit closes the account rather than shrinking it.
+   * Largest partial withdrawal the facade's `debtLimits` accept: the one whose
+   * proportional repayment leaves the debt at `minDebt`. `0n` when the debt
+   * already sits below the floor, and always at least one unit under `exit` —
+   * the last unit closes the account rather than shrinking it.
+   *
+   * `debtLimits` are not the only rule a withdrawal answers to, so this is a
+   * limit rather than the limit: {@link safePartial} is the one to offer.
    */
   partial: bigint;
+  /**
+   * Largest partial withdrawal {@link WithdrawStrategyIntent} actually accepts
+   * — {@link partial} once the safe-price collateral check has had its say,
+   * and never above it.
+   *
+   * A withdrawal hands funds over, and the facade weighs what it leaves behind
+   * at safe prices: `min` of a token's two feeds, or nothing at all where
+   * governance registered no reserve feed. Collateral the reserve feed marks
+   * down therefore backs less than a projection at main prices suggests, and
+   * the withdrawal stops earlier than `debtLimits` alone would say. This is
+   * the figure a slider and a Max button belong on.
+   *
+   * `0n` on an account already under the threshold at safe prices. That is not
+   * a rounding artefact and a smaller request does not help: a proportional
+   * withdrawal leaves the safe-price factor exactly where it found it, so no
+   * amount clears a threshold the account is already under. Such a position
+   * can still leave — see {@link exit}, which the check never refuses.
+   */
+  safePartial: bigint;
   /**
    * What leaving hands over: the account's net value, which is also the amount
    * at which a withdrawal turns into an exit. `0n` on an account whose debt
@@ -470,4 +515,4 @@ type FinishIntentProps = StartIntentProps & {
   claimable: ClaimableWithdrawal;
 };
 //#endregion
-export { AddCollateralIntent, AdjustLeverageIntent, ClaimRemainder, CreditAccountSlice, DelayableIntent, DelayedRoute, DelayedStart, DelayedStartResult, DepositStrategyIntent, FinishIntentProps, FinishIntentResult, InstantRoute, IntentPreviewResult, IntentRoutesResult, OperationState, PathLossRate, RepayStrategyIntent, ResumableIntent, RouteErrors, SimulationPrices, StartIntent, StartIntentProps, WithdrawAssetIntent, WithdrawCeilings, WithdrawStrategyIntent };
+export { AddCollateralIntent, AdjustLeverageIntent, ClaimRemainder, CreditAccountSlice, DelayableIntent, DelayedRoute, DelayedStart, DelayedStartResult, DepositStrategyIntent, ExecutionCost, FinishIntentProps, FinishIntentResult, InstantRoute, IntentPreviewResult, IntentRoutesResult, OperationState, PathLossRate, RepayStrategyIntent, ResumableIntent, RouteErrors, SimulationPrices, StartIntent, StartIntentProps, WithdrawAssetIntent, WithdrawCeilings, WithdrawStrategyIntent };

package/dist/types/onchain/accounts/intents/utils/common.d.ts

@@ -1,5 +1,7 @@
 import { Asset } from "../../../base/types.js";
 import { RouterCASlice } from "../../../router/types.js";
+import { MarketSuite } from "../../../market/MarketSuite.js";
+import { CreditSuite } from "../../../market/credit/CreditSuite.js";
 import { OnchainSDK } from "../../../OnchainSDK.js";
 import { CreditAccountSlice } from "../types.js";
 import "../../../index.js";
@@ -7,6 +9,18 @@ import { Address } from "viem";
 //#region src/onchain/accounts/intents/utils/common.d.ts
 /** Case-insensitive address equality. */
 declare const eq: (a: Address, b: Address) => boolean;
+/**
+ * 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.
+ */
+declare function resolveCreditManager(sdk: OnchainSDK, creditManager: Address): {
+  suite: CreditSuite;
+  market: MarketSuite;
+} | undefined;
 declare function toTargetDecimals(fromAmount: bigint, fromToken: Address, toToken: Address, sdk: OnchainSDK): bigint;
 /**
  * Router CA slice from the account slice. RouterV310 reads `ca.tokens` for
@@ -16,4 +30,4 @@ declare function toTargetDecimals(fromAmount: bigint, fromToken: Address, toToke
  */
 declare function toRouterCaSlice(creditAccount: CreditAccountSlice, expectedBalances?: Asset[]): RouterCASlice;
 //#endregion
-export { eq, toRouterCaSlice, toTargetDecimals };
+export { eq, resolveCreditManager, toRouterCaSlice, toTargetDecimals };