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

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 { 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 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

@@ -62,7 +62,21 @@ 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, as `(out − in) / in`: the oracle value in the
+   * underlying of everything its routed legs and redemption request return,
+   * the expected claim included, against the value of what they spend.
+   * In `PERCENTAGE_FACTOR_1KK` (1_000_000 = 100%), negative for a loss.
+   *
+   * `undefined` where nothing was traded, where a leg cannot be priced, and on
+   * a {@link BorrowState}, which does not measure it: the rate 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: bigint | 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 +443,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

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

package/dist/types/onchain/accounts/intents/utils/credit-account-slice.d.ts

@@ -15,6 +15,19 @@ import { Address } from "viem";
  * behave consistently everywhere downstream.
  */
 declare function toCreditAccountSlice(ca: CreditAccountDataPayload): CreditAccountSlice;
+/**
+ * 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.
+ */
+declare function unopenedAccountSlice(args: {
+  creditManager: Address;
+  creditFacade: Address;
+  underlying: Address;
+}): CreditAccountSlice;
 /**
  * Reads an account by address and narrows it to {@link CreditAccountSlice}.
  *
@@ -26,4 +39,4 @@ declare function toCreditAccountSlice(ca: CreditAccountDataPayload): CreditAccou
  */
 declare function fetchCreditAccountSlice(sdk: OnchainSDK, creditAccount: Address): Promise<CreditAccountSlice>;
 //#endregion
-export { fetchCreditAccountSlice, toCreditAccountSlice };
+export { fetchCreditAccountSlice, toCreditAccountSlice, unopenedAccountSlice };

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

@@ -1,11 +1,11 @@
-import { fetchCreditAccountSlice, toCreditAccountSlice } from "./credit-account-slice.js";
+import { fetchCreditAccountSlice, toCreditAccountSlice, unopenedAccountSlice } from "./credit-account-slice.js";
 import { CandidateToken, isPhantomToken, isRedemptionPhantomToken, pickFattestNonPhantomToken, rankAccountTokens } from "./pick-token.js";
 import { LegProbe, collectPriceImpact, lossRate, startProbe } from "./price-impact.js";
 import { OpenStrategyLeg, RouterPaths, SwapLeg, createOraclePaths, createRouterPaths } from "./router-path.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 { eq, toRouterCaSlice, toTargetDecimals } from "./common.js";
+import { eq, resolveCreditManager, toRouterCaSlice, toTargetDecimals } from "./common.js";
 import { LedgerSnapshot, OperationLedger } from "./ledger.js";
 import { clearedQuotas, getQuotasForUpdate, quotasAfterUpdate } from "./quotas-for-update.js";
-export { CandidateToken, LedgerSnapshot, LegProbe, OpenStrategyLeg, OperationLedger, RouterPaths, SwapLeg, adjustStateToSnapshot, assembleOperationCalls, calcBorrowedAmountPlusInterestAndFees, clearedQuotas, collectPriceImpact, createOraclePaths, createRouterPaths, eq, fetchCreditAccountSlice, getQuotasForUpdate, isPhantomToken, isRedemptionPhantomToken, lossRate, pickFattestNonPhantomToken, quotasAfterUpdate, rankAccountTokens, startProbe, toCreditAccountSlice, toRouterCaSlice, toTargetDecimals };
+export { CandidateToken, LedgerSnapshot, LegProbe, OpenStrategyLeg, OperationLedger, RouterPaths, SwapLeg, adjustStateToSnapshot, assembleOperationCalls, calcBorrowedAmountPlusInterestAndFees, clearedQuotas, collectPriceImpact, createOraclePaths, createRouterPaths, eq, fetchCreditAccountSlice, getQuotasForUpdate, isPhantomToken, isRedemptionPhantomToken, lossRate, pickFattestNonPhantomToken, quotasAfterUpdate, rankAccountTokens, resolveCreditManager, startProbe, toCreditAccountSlice, toRouterCaSlice, toTargetDecimals, unopenedAccountSlice };

package/dist/types/onchain/accounts/intents/withdraw-limits.d.ts

@@ -0,0 +1,80 @@
+import { OnchainSDK } from "../../OnchainSDK.js";
+import { CreditAccountSlice, WithdrawCeilings } from "./types.js";
+import "../../index.js";
+import { Address } from "viem";
+//#region src/onchain/accounts/intents/withdraw-limits.d.ts
+interface WithdrawLimitsProps {
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+  /**
+   * Token the withdrawal liquidates. Defaults to the account's largest
+   * non-phantom balance, which is what the planner reaches for when the intent
+   * names none.
+   */
+  sourceToken?: Address;
+}
+/**
+ * Every limit a `WITHDRAW` answers to, in underlying units.
+ *
+ * The one place they are assembled, so the figure a form is offered and the
+ * figure the collateral guard names when it turns a withdrawal down cannot
+ * drift apart: `CreditAccountOperationsService` reports this, and the guard
+ * quotes it back.
+ *
+ * @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}
+ **/
+declare function withdrawLimits(props: WithdrawLimitsProps): WithdrawCeilings;
+interface MaxSafeWithdrawalProps {
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+  /**
+   * Token the withdrawal liquidates. Defaults to the account's largest
+   * non-phantom balance, which is what the planner reaches for when the intent
+   * names none.
+   */
+  sourceToken?: Address;
+  /**
+   * Health factor the withdrawal has to leave behind, in basis points. The
+   * facade's own threshold answers "would this land"; a form holding the
+   * account to something stricter passes its own.
+   */
+  targetHF: bigint;
+}
+/**
+ * Largest proportional withdrawal the safe-price collateral check still clears,
+ * 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 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`.
+ *
+ * The arithmetic is the check solved for the amount. Taking `W` out at fixed
+ * leverage repays `dD = D·W/C`, so `W·TVL/C` of value is sold out of the source
+ * token; each dollar of that sale costs the check the source's threshold times
+ * its safe-to-main price ratio, while the repayment relieves `targetHF` per
+ * dollar of debt. Both terms are linear in `W`, which is why one division
+ * answers instead of a search — and why the answer is exact rather than a
+ * bound, as long as the plan really does fund itself from `sourceToken`.
+ *
+ * Two consequences worth stating, because they surprise:
+ *
+ * - An account whose collateral is entirely a token the reserve feed marks
+ *   down cannot withdraw at all once it is under the threshold. A proportional
+ *   withdrawal scales collateral and debt together, so it leaves the safe-price
+ *   factor exactly where it found it — no amount climbs back over.
+ * - Leaving entirely is never refused for this reason: the exit settles the
+ *   debt instead of shrinking it, and a check with no debt to divide by has
+ *   nothing to refuse.
+ *
+ * @returns Amount in underlying units. The account's net value when safe prices
+ * do not limit the withdrawal at all, so the caller's `min` is a no-op; `0n`
+ * when the account already sits below `targetHF` at safe prices, and only the
+ * exit is left
+ **/
+declare function maxSafeWithdrawal(props: MaxSafeWithdrawalProps): bigint;
+//#endregion
+export { MaxSafeWithdrawalProps, WithdrawLimitsProps, maxSafeWithdrawal, withdrawLimits };