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

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

@@ -1,14 +1,17 @@
-import { DelayedIntent, RequestableWithdrawal } from "../withdrawal-compressor/types.js";
+import { Leverage } from "../../../model/primitives.js";
+import { ClaimableWithdrawal, DelayedIntent } from "../withdrawal-compressor/types.js";
 import { Asset } from "../../base/types.js";
+import { PositionMetrics } from "../../../model/positions.js";
+import "../../../model/index.js";
 import { RouterCASlice } from "../../router/types.js";
 import { MultiCall } from "../../types/transactions.js";
-import { AccountCalculatorOperation } from "./operations/types.js";
-import "./operations/index.js";
+import { OnchainSDK } from "../../OnchainSDK.js";
+import { AccountCalculatorOperation } from "./operations.js";
 import "../../index.js";
 import { Address } from "viem";
 //#region src/sdk/accounts/intents/types.d.ts
 /**
- * Minimal credit-account data needed by resume previews:
+ * Minimal credit-account data an intent is previewed against:
  * account address, CM lookup, underlying for conversion, debt, token balances
  * and initial quotas.
  */
@@ -16,60 +19,383 @@ type CreditAccountSlice = Omit<RouterCASlice, "debt"> & {
   /** either base debt or debt plus interest and fees */
   accountDebt: bigint;
 };
-/** Post-adjust CA metrics. */
-type AdjustState = {
-  kind: "adjust";
+/** Projected account metrics once the operations execute. */
+interface OperationState extends PositionMetrics {
   /** Account TVL after operation */
   totalValue: bigint;
   /** Account debt after operation */
   accountDebt: bigint;
+  /**
+   * Leverage after operation in the read model's convention — `debt / equity`,
+   * as `Position.leverage` reports it — not the calculator's `TVL / collateral`.
+   */
+  leverage: Leverage;
   /** Account assets after operation */
   assets: Asset[];
   /** Account quotas after operation */
   quotas: Record<Address, Asset>;
-};
-/** Close state result. */
-type CloseState = {
-  kind: "close";
-  /** Received amount */
-  amount: bigint;
-  /** Conservative receive (min branch / pathfinder floor). */
-  minAmount: bigint;
-  /** Pathfinder underlying on CA after close path; 0n when unknown (instant). */
-  underlyingBalance: bigint;
-};
-type OperationState = AdjustState | CloseState;
-type DelayedBranchKind = "instantSettle" | "partialSettle" | "delayedSettle";
-type DelayedBranchResult = {
-  kind: DelayedBranchKind;
+}
+/**
+ * Why a preview could not be produced.
+ *
+ * Every member is thrown by the engine as an {@link IntentPreviewError}, with
+ * the exception of `unsupportedTokenPair` and `noRecordedIntent`, which the
+ * simulate namespace reports for a request it can refuse before planning: a
+ * route the market does not offer, a claim naming no operation.
+ */
+type PreviewErrorReason = "debtOutOfRange" | "leverageOutOfRange" | "insufficientSourceBalance" |
+/** Input token is not accepted by the flow (e.g. deposit of a non-underlying). */
+"unsupportedCollateralToken" |
+/** No pool route between the requested pair, or several and none was picked. */
+"unsupportedTokenPair" |
+/**
+ * The intent cannot settle with a delay: the source has no redemption config,
+ * the chain has no compressor, or the payout is one the tail cannot serve.
+ */
+"noDelayedRoute" |
+/** Several redemption venues for the source, and nothing says which. */
+"multipleDelayedWithdrawals" |
+/** A redemption of the same asset is already in flight. */
+"withdrawalInProgress" |
+/**
+ * The claim names no operation to resume: requested without an intent, read
+ * through a compressor too old to report one, or a full close, which the
+ * engine no longer previews.
+ */
+"noRecordedIntent" |
+/** The facade or the pool behind it is paused: nothing can be done at all. */
+"marketPaused" |
+/** The facade is past its expiration date and takes no more multicalls. */
+"marketExpired" |
+/**
+ * The pool cannot lend what the plan draws right now — its free liquidity,
+ * the manager's debt limit or the per-block cap stands in the way.
+ */
+"insufficientPoolLiquidity" |
+/** The market takes no more quota for a token the plan wants to hold. */
+"quotaLimitReached" |
+/** The plan would increase the balance of a token the market forbids. */
+"forbiddenToken" |
+/**
+ * The account would end the transaction owing more than its collateral is
+ * worth under liquidation thresholds, which the facade refuses to allow.
+ */
+"insufficientCollateral";
+/**
+ * What a preview yields: the operation chain, the state it projects, and the
+ * calldata that realises it — or the reason the request is not viable.
+ */
+type IntentPreviewResult = {
+  ok: true;
   operations: AccountCalculatorOperation[];
-  preview: {
-    min: OperationState;
-  };
+  preview: OperationState;
   calls: MultiCall[];
-  intent: DelayedIntent;
-  request?: RequestableWithdrawal;
+} | {
+  ok: false;
+  reason: PreviewErrorReason;
 };
-type DelayedErrorReason = "multipleDelayedWithdrawals" | "withdrawalInProgress";
-type InstantBranchResult = {
+/** What the request recorded, and when the tail can be run. */
+interface DelayedStart {
+  /**
+   * The intent written into the request, and decoded back from the claimable
+   * withdrawal at claim time. Feed it to
+   * `CreditAccountOperationsService.finishIntent`.
+   */
+  record: DelayedIntent;
+  /** Unix seconds after which the delayed outputs can be claimed. */
+  claimableAt: bigint;
+  /**
+   * `instant` when the venue served the whole request on the spot, so no claim
+   * will ever arrive to carry the tail. The intent is then left half-done —
+   * nothing repaid, nothing paid out — and the caller wants `startIntent`
+   * instead, which settles all of it in one transaction.
+   */
+  settlement: "instant" | "delayed";
+}
+/**
+ * What the leading half of a delayed intent yields: the request transaction,
+ * plus what it recorded for the tail.
+ */
+type DelayedStartResult = {
+  ok: true;
   operations: AccountCalculatorOperation[];
-  preview: {
-    min: OperationState;
-  };
+  preview: OperationState;
   calls: MultiCall[];
-};
-type InstantErrorReason = "pathNotFound";
-type PreviewErrorResult = {
+  delayed: DelayedStart;
+} | {
   ok: false;
-  reason: "unsupportedFieldPair" | "debtOutOfRange" | "leverageOutOfRange" | "multipleDelayedWithdrawals" | "unsupportedMixedDelayedWithdrawal" | "unsupportedCloseClaimOutput" | "insufficientSourceBalance";
+  reason: PreviewErrorReason;
 };
-interface IntentPreviewSuccessResult {
+/** An intent previewed through the router: one transaction, settled now. */
+type InstantRoute = Extract<IntentPreviewResult, {
+  ok: true;
+}>;
+/** An intent previewed as a redemption: the request now, the tail later. */
+type DelayedRoute = Extract<DelayedStartResult, {
+  ok: true;
+}>;
+/**
+ * Why a route is missing from an {@link IntentRoutesResult}.
+ *
+ * A reason is the engine's refusal — `noDelayedRoute` for a source with no
+ * redemption venue or for a leverage move that settles at once,
+ * `insufficientSourceBalance` for a payout the account cannot fund. `undefined`
+ * next to a missing route means the route could not be quoted at all: the
+ * pathfinder found no way out of the source, or the read behind it failed.
+ */
+interface RouteRefusals {
+  instant: PreviewErrorReason | undefined;
+  delayed: PreviewErrorReason | undefined;
+}
+/**
+ * Both ways one intent can be served, previewed side by side: traded through
+ * the router, which settles in a single transaction, or redeemed through the
+ * source's issuer, which answers now and pays out days later.
+ *
+ * Which of them an account can take depends on the intent and the token it
+ * sells, so both are quoted and a route it cannot take comes back `undefined`
+ * with its refusal in `refused`. Only when neither answers is the request itself
+ * unviable, and then `reason` is the instant route's refusal — the route every
+ * account is expected to have — falling back to the delayed one's.
+ */
+type IntentRoutesResult = {
   ok: true;
-  instant: InstantBranchResult | undefined;
-  instantError: InstantErrorReason | undefined;
-  delayedBranch: DelayedBranchResult | undefined;
-  delayedError: DelayedErrorReason | undefined;
+  instant: InstantRoute | undefined;
+  delayed: DelayedRoute | undefined;
+  refused: RouteRefusals;
+} | {
+  ok: false;
+  reason: PreviewErrorReason;
+  refused: RouteRefusals;
+};
+/**
+ * The intents the engine previews.
+ *
+ * Naming avoids the `withdrawCollateral` collision that exists elsewhere in the
+ * repo. Mapping to the public simulate API:
+ *
+ * | Intent type        | Public name                | Debt    |
+ * | ------------------ | -------------------------- | ------- |
+ * | `ADD_COLLATERAL`   | `simulate.addCollateral`    | fixed   |
+ * | `WITHDRAW_ASSET`   | `simulate.withdrawCollateral` | fixed |
+ * | `ADJUST_LEVERAGE`  | `simulate.adjustLeverage`   | changes |
+ * | `DEPOSIT`          | `simulate.depositStrategy`  | grows   |
+ * | `WITHDRAW`         | `simulate.withdrawStrategy` | shrinks |
+ * | `REPAY`            | `simulate.repayStrategy`    | shrinks |
+ */
+/** Shared inputs for every start intent. */
+type StartIntentProps = {
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+  /**
+   * Extra quota headroom in PERCENTAGE_FORMAT, to survive price drift between
+   * preview and execution.
+   */
+  quotaReserve: number | undefined;
+  /** Router slippage in PERCENTAGE_FORMAT (100% = 10_000). */
+  slippage: number | undefined;
+};
+/**
+ * Intent 5 — put the position token straight onto the account.
+ *
+ * Only the position token is accepted (e.g. ACRED): there is no swap and no
+ * RWA wrap leg, so whatever is sent lands as-is. Debt is untouched, therefore
+ * leverage drops and the health factor improves.
+ */
+interface AddCollateralIntent {
+  type: "ADD_COLLATERAL";
+  /** Position token to deposit. */
+  token: Address;
+  amount: bigint;
+  /**
+   * Native value to attach when the deposited token is the market's wrapped
+   * native token and the caller is paying in the native coin.
+   */
+  value?: bigint;
+}
+/**
+ * Intent 4 — move one asset that already sits on the account to the wallet.
+ *
+ * Atomic: no swaps, no debt change, so leverage rises. The only special case is
+ * withdrawing the wrapped underlying of an RWA market, which is force-unwrapped
+ * to `rwa.asset` first because the wrapper itself cannot leave the account.
+ *
+ * @see AdjustLeverageIntent and the `WITHDRAW` intent for the deleveraging
+ * withdrawals, which do change debt.
+ */
+interface WithdrawAssetIntent {
+  type: "WITHDRAW_ASSET";
+  /** Token to withdraw; must already be on the account. */
+  token: Address;
+  amount: bigint;
+  /** Wallet receiving the tokens. */
+  to: Address;
+}
+/**
+ * Intent 6 — retarget leverage while collateral (own funds) stays fixed.
+ *
+ * Because collateral is the invariant, the target leverage pins the new debt:
+ * raising it borrows more and buys the position token, lowering it sells the
+ * position token and repays. TVL moves with the debt; net value does not.
+ */
+interface AdjustLeverageIntent {
+  type: "ADJUST_LEVERAGE";
+  /**
+   * Target total leverage scaled by `LEVERAGE_DECIMALS` (300n = 3x). 100n (1x)
+   * means "no debt".
+   */
+  targetLeverage: bigint;
+  /**
+   * Position token to buy into or sell out of. Defaults to the most valuable
+   * non-phantom, non-underlying balance on the account.
+   */
+  token?: Address;
+}
+/**
+ * Intents 1.1 / 1.2 — deposit into a strategy, growing the position.
+ *
+ * Fresh collateral arrives, debt is drawn on top of it, and the combined
+ * underlying is converted into the position token. The two spec variants differ
+ * only in how much debt is drawn:
+ *
+ * - 1.1, `targetLeverage` omitted: debt grows in proportion, leverage unchanged
+ * - 1.2, `targetLeverage` set: debt grows to hit the new, higher leverage
+ *
+ * Only the market underlying may be deposited. Two exceptions: a wrapped-native
+ * market also accepts the native coin (pass the wrapped token plus `value`), and
+ * an RWA market takes the unwrapped asset (USDC rather than dcUSDC), which this
+ * flow wraps for you.
+ */
+interface DepositStrategyIntent {
+  type: "DEPOSIT";
+  /** Collateral token: the market underlying, or `rwa.asset` on an RWA market. */
+  token: Address;
+  amount: bigint;
+  /** Native value to attach when paying with the native coin. */
+  value?: bigint;
+  /**
+   * Token the position ends up in. Defaults to the most valuable non-phantom,
+   * non-underlying balance already on the account.
+   */
+  positionToken?: Address;
+  /**
+   * Target total leverage scaled by `LEVERAGE_DECIMALS`. Omit to preserve the
+   * account's current leverage.
+   */
+  targetLeverage?: bigint;
+}
+/**
+ * Intent 3 — repay debt with funds from the wallet.
+ *
+ * The mirror of {@link DepositStrategyIntent}: money arrives from outside and
+ * nothing on the account is sold, so collateral value stands still while debt
+ * shrinks. Net value grows by what was repaid, leverage falls, and the health
+ * factor improves — this is the flow that rescues an account, and the only one
+ * that lowers debt without touching the position.
+ *
+ * The market underlying is what a loan is denominated in, so sending it needs
+ * no conversion: it lands and is repaid. Two more forms are accepted, as for a
+ * deposit: a wrapped-native market also takes the native coin (pass the wrapped
+ * token plus `value`), and an RWA market takes the unwrapped asset behind its
+ * underlying, which this flow wraps for you.
+ */
+interface RepayStrategyIntent {
+  type: "REPAY";
+  /** Funding token: the market underlying, or `rwa.asset` on an RWA market. */
+  token: Address;
+  /**
+   * Amount of `token` taken from the wallet. More than the outstanding debt is
+   * allowed — the debt is settled in full and the excess stays on the account
+   * as collateral — which is what lets a caller cover the interest that accrues
+   * between this preview and the transaction.
+   *
+   * `MAX_UINT256` asks for exactly that settlement without naming a figure: the
+   * wallet is charged the debt plus a small margin for the interest still to
+   * come, the facade is told to repay everything outstanding, and the quotas go
+   * with the loan.
+   */
+  amount: bigint;
+  /** Native value to attach when paying with the native coin. */
+  value?: bigint;
+}
+/**
+ * Intent 2.1 — withdraw part of the position's net value at fixed leverage.
+ *
+ * The requested amount leaves the account, and debt is repaid in the same
+ * proportion so leverage is unchanged: `dD = D0 * W / C0`. Both the payout and
+ * the repayment are funded by liquidating the source token, which means the
+ * account must give up `W + dD` of value in total.
+ *
+ * The payout leg and the repayment leg are quoted separately and do not share a
+ * pool, so a shortfall on the payout leg does not eat into the repayment.
+ *
+ * Asking for the whole net value is the exit instead — there is no leverage
+ * left to hold — and the shape changes with it: the quotas are dropped, the
+ * position is sold whole in one many-to-one route, the loan is settled in full
+ * and every remaining balance goes to the wallet. The account survives it,
+ * empty and owing nothing.
+ *
+ * @see WithdrawAssetIntent for moving a single asset out at fixed debt, and
+ * AdjustLeverageIntent for changing leverage without withdrawing.
+ */
+interface WithdrawStrategyIntent {
+  type: "WITHDRAW";
+  /**
+   * Amount the wallet receives, denominated in `tokenOut`. At or above the
+   * account's net value this is an exit, which pays out the underlying the
+   * position was sold into rather than in `tokenOut`.
+   *
+   * `MAX_UINT256` is that exit stated outright, and the amount a "close
+   * position" form sends: no net value has to be read to name it, and no
+   * rounding can turn it back into a withdrawal that leaves dust behind.
+   */
+  amount: bigint;
+  /** Wallet receiving the payout. */
+  to: Address;
+  /**
+   * Token the wallet receives. Defaults to the market underlying — which, on an
+   * RWA market, is force-unwrapped to `rwa.asset` on the way out.
+   */
+  tokenOut?: Address;
+  /**
+   * Token liquidated to fund the withdrawal. Defaults to the most valuable
+   * non-phantom balance on the account, and is ignored by an exit — that sells
+   * every balance there is.
+   */
+  sourceToken?: Address;
+}
+type StartIntent = AddCollateralIntent | WithdrawAssetIntent | AdjustLeverageIntent | DepositStrategyIntent | RepayStrategyIntent | WithdrawStrategyIntent;
+/**
+ * The intents that can be started as a redemption rather than a swap: the two
+ * that sell a position asset. The others buy one, and buying settles at once.
+ */
+type DelayableIntent = AdjustLeverageIntent | WithdrawStrategyIntent;
+/**
+ * A delayed intent this engine knows how to finish.
+ *
+ * `CLOSE_ACCOUNT` is absent on purpose: closing goes through the facade's own
+ * entry point, which this engine no longer builds.
+ */
+type ResumableIntent = Exclude<DelayedIntent, {
+  type: "CLOSE_ACCOUNT";
+}>;
+/** Shared inputs plus the matured withdrawal the tail is built around. */
+type FinishIntentProps = StartIntentProps & {
+  intent: ResumableIntent;
+  /**
+   * The matured withdrawal, as reported by
+   * `sdk.accounts.getPendingWithdrawals`.
+   */
+  claimable: ClaimableWithdrawal;
+};
+/**
+ * Validation failure that maps onto {@link PreviewErrorReason} rather than
+ * crashing the caller: thrown by builders, converted to `{ ok: false }` by
+ * `CreditAccountOperationsService.startIntent`.
+ */
+declare class IntentPreviewError extends Error {
+  readonly reason: PreviewErrorReason;
+  constructor(reason: PreviewErrorReason, message?: string);
 }
-type IntentPreviewResult = IntentPreviewSuccessResult | PreviewErrorResult;
 //#endregion
-export { AdjustState, CloseState, CreditAccountSlice, IntentPreviewResult, OperationState };
+export { AddCollateralIntent, AdjustLeverageIntent, CreditAccountSlice, DelayableIntent, DelayedRoute, DelayedStart, DelayedStartResult, DepositStrategyIntent, FinishIntentProps, InstantRoute, IntentPreviewError, IntentPreviewResult, IntentRoutesResult, OperationState, PreviewErrorReason, RepayStrategyIntent, ResumableIntent, RouteRefusals, StartIntent, StartIntentProps, WithdrawAssetIntent, WithdrawStrategyIntent };

package/dist/types/sdk/accounts/intents/utils/adjust-state-to-snapshot.d.ts

@@ -0,0 +1,13 @@
+import { AccountSnapshot } from "../../../positions/types.js";
+import "../../../positions/index.js";
+import { OperationState } from "../types.js";
+import { Address } from "viem";
+//#region src/sdk/accounts/intents/utils/adjust-state-to-snapshot.d.ts
+/**
+ * Maps an intents {@link OperationState} onto the {@link AccountSnapshot} that
+ * position-metric functions take. `accountDebt` is treated as total debt
+ * (principal plus accrued interest and fees).
+ **/
+declare function adjustStateToSnapshot(creditManager: Address, state: OperationState): AccountSnapshot;
+//#endregion
+export { adjustStateToSnapshot };

package/dist/types/sdk/accounts/intents/utils/assemble-operation-calls.d.ts

@@ -1,5 +1,5 @@
 import { MultiCall } from "../../../types/transactions.js";
-import { AccountCalculatorOperation } from "../operations/types.js";
+import { AccountCalculatorOperation } from "../operations.js";
 import "../../../index.js";
 //#region src/sdk/accounts/intents/utils/assemble-operation-calls.d.ts
 interface Props {

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

@@ -0,0 +1,29 @@
+import { CreditAccountDataPayload } from "../../../base/types.js";
+import { OnchainSDK } from "../../../OnchainSDK.js";
+import { CreditAccountSlice } from "../types.js";
+import "../../../index.js";
+import { Address } from "viem";
+//#region src/sdk/accounts/intents/utils/credit-account-slice.d.ts
+/**
+ * Narrows full account data down to the slice the intent engine operates on.
+ *
+ * `accountDebt` is the total repayable debt (principal + accrued interest +
+ * accrued fees) rather than the principal, because every debt-touching intent
+ * settles the full outstanding amount.
+ *
+ * Addresses are lowercased so that `eq` comparisons and `AddressMap` lookups
+ * behave consistently everywhere downstream.
+ */
+declare function toCreditAccountSlice(ca: CreditAccountDataPayload): CreditAccountSlice;
+/**
+ * Reads an account by address and narrows it to {@link CreditAccountSlice}.
+ *
+ * The shared read model's `StrategyPosition` carries neither `tokens` nor
+ * `enabledTokensMask` / `creditFacade` / `totalDebtUSD`, so simulating against
+ * an existing position costs one account read.
+ *
+ * @throws When the account is not found in the connected markets.
+ */
+declare function fetchCreditAccountSlice(sdk: OnchainSDK, creditAccount: Address): Promise<CreditAccountSlice>;
+//#endregion
+export { fetchCreditAccountSlice, toCreditAccountSlice };

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

@@ -1,9 +1,11 @@
+import { fetchCreditAccountSlice, toCreditAccountSlice } from "./credit-account-slice.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 { convertAmount } from "./convert-amount.js";
-import { ConvertFn, simulateOperationAssets } from "./simulate-assets.js";
-import { getQuotasForUpdate } from "./quotas-for-update.js";
-import { SimulateStateReturn, simulateState } from "./simulate-adjust-state.js";
-import { getOperationsWithQuotaUpdate } from "./with-quota-update.js";
-export { ConvertFn, SimulateStateReturn, assembleOperationCalls, calcBorrowedAmountPlusInterestAndFees, convertAmount, eq, getOperationsWithQuotaUpdate, getQuotasForUpdate, simulateOperationAssets, simulateState, toRouterCaSlice, toTargetDecimals };
+import { ConvertFn, LedgerSnapshot, OperationLedger } from "./ledger.js";
+import { CandidateToken, isPhantomToken, isRedemptionPhantomToken, pickFattestNonPhantomToken, rankAccountTokens } from "./pick-token.js";
+import { clearedQuotas, getQuotasForUpdate } from "./quotas-for-update.js";
+import { OpenStrategyLeg, RouterPaths, SwapLeg, createRouterPaths } from "./router-path.js";
+export { CandidateToken, ConvertFn, LedgerSnapshot, OpenStrategyLeg, OperationLedger, RouterPaths, SwapLeg, adjustStateToSnapshot, assembleOperationCalls, calcBorrowedAmountPlusInterestAndFees, clearedQuotas, convertAmount, createRouterPaths, eq, fetchCreditAccountSlice, getQuotasForUpdate, isPhantomToken, isRedemptionPhantomToken, pickFattestNonPhantomToken, rankAccountTokens, toCreditAccountSlice, toRouterCaSlice, toTargetDecimals };

package/dist/types/sdk/accounts/intents/utils/ledger.d.ts

@@ -0,0 +1,41 @@
+import { Asset } from "../../../base/types.js";
+import { AccountCalculatorOperation } from "../operations.js";
+import "../../../index.js";
+import { Address } from "viem";
+//#region src/sdk/accounts/intents/utils/ledger.d.ts
+type ConvertFn = (token: Address, to: Address, amount: bigint) => bigint;
+/** Account state at one point in an operation chain. */
+interface LedgerSnapshot {
+  /** Non-zero balances only, lowercased, in insertion order. */
+  assets: Asset[];
+  /** Sum of `assets` priced in the underlying. */
+  totalValue: bigint;
+  debt: bigint;
+}
+/**
+ * Running account state, advanced one operation at a time.
+ *
+ * Exists because the amounts an operation is built from depend on the balances
+ * the previous ones left behind: a swap has to know how much of its input token
+ * is genuinely swap input, so the router does not sweep collateral that must
+ * stay put. Applying each op as it is built keeps that a single forward pass —
+ * a builder that re-simulated the chain from the start for every leg would be
+ * quadratic in the number of legs and easy to desynchronise.
+ */
+declare class OperationLedger {
+  #private;
+  constructor(args: {
+    initialAssets: readonly Asset[] | Asset[];
+    underlying: Address;
+    debt: bigint;
+    convert: ConvertFn;
+  });
+  get debt(): bigint;
+  balanceOf(token: Address): bigint;
+  applyAll(operations: readonly AccountCalculatorOperation[]): this;
+  snapshot(): LedgerSnapshot;
+  /** Advances the state by one operation; quota changes move no balance. */
+  apply(op: AccountCalculatorOperation): this;
+}
+//#endregion
+export { ConvertFn, LedgerSnapshot, OperationLedger };

package/dist/types/sdk/accounts/intents/utils/pick-token.d.ts

@@ -0,0 +1,55 @@
+import { OnchainSDK } from "../../../OnchainSDK.js";
+import { CreditAccountSlice } from "../types.js";
+import "../../../index.js";
+import { Address } from "viem";
+//#region src/sdk/accounts/intents/utils/pick-token.d.ts
+/**
+ * Whether `token` is a phantom (a non-transferable position marker such as a
+ * pending delayed withdrawal).
+ *
+ * Reads `contractType` directly instead of going through
+ * `TokensMeta.isPhantomToken`, which throws when extended token data has not
+ * been loaded. Here an unknown token is simply treated as non-phantom.
+ */
+declare function isPhantomToken(sdk: OnchainSDK, token: Address): boolean;
+/**
+ * Whether `token` is the phantom of a redemption in flight, rather than one of
+ * the phantoms a position is simply held in (Convex, Infrared, staking
+ * rewards), which the router sells like any other balance.
+ *
+ * Only the former stands between an account and being emptied: it cannot be
+ * sold and it cannot leave until its claim has landed.
+ */
+declare function isRedemptionPhantomToken(sdk: OnchainSDK, token: Address): boolean;
+interface CandidateToken {
+  token: Address;
+  balance: bigint;
+  /** Balance priced in the market underlying, used for the ranking. */
+  valueInUnderlying: bigint;
+}
+/**
+ * Account balances that can actually back an operation, richest first.
+ *
+ * Phantoms are dropped because a pending delayed withdrawal cannot be spent:
+ * it has to be claimed first, in a transaction of its own.
+ */
+declare function rankAccountTokens(args: {
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+  /** Tokens to skip, e.g. the operation's own target. */
+  exclude?: Address[];
+}): CandidateToken[];
+/**
+ * Default working token for flows that do not get one from the caller: the
+ * most valuable non-phantom balance on the account.
+ *
+ * Used for the source of a partial withdraw and the position leg of a leverage
+ * adjustment, both of which the caller may override explicitly.
+ */
+declare function pickFattestNonPhantomToken(args: {
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+  exclude?: Address[];
+}): CandidateToken | undefined;
+//#endregion
+export { CandidateToken, isPhantomToken, isRedemptionPhantomToken, pickFattestNonPhantomToken, rankAccountTokens };

package/dist/types/sdk/accounts/intents/utils/quotas-for-update.d.ts

@@ -1,9 +1,8 @@
 import { AddressMap } from "../../../utils/AddressMap.js";
 import { Asset } from "../../../base/types.js";
-import { QuotaUpdateState } from "../operations/quota-update/index.js";
-import "../operations/index.js";
+import { QuotaUpdateState } from "../operations.js";
 import "../../../index.js";
-import { ConvertFn } from "./simulate-assets.js";
+import { ConvertFn } from "./ledger.js";
 import { Address } from "viem";
 //#region src/sdk/accounts/intents/utils/quotas-for-update.d.ts
 interface InitialQuota {
@@ -31,5 +30,17 @@ interface GetQuotasForUpdateProps {
   convert: ConvertFn;
 }
 declare function getQuotasForUpdate({ assetsBefore, assetsAfter, initialQuotas, quotaReserve, liquidationThresholds: liquidationThresholdsMap, quotas: quotasMap, maxDebt, underlyingToken, convert }: GetQuotasForUpdateProps): QuotaUpdateState;
+/**
+ * The update that leaves the account holding no quota at all.
+ *
+ * Sits beside {@link getQuotasForUpdate} rather than inside it because the two
+ * answer different questions: that one sizes quotas to the balances an
+ * operation leaves behind, this one is asked for by a plan that ends the loan,
+ * where the right size is none whatever the balances are.
+ *
+ * `MIN_INT96` is the protocol's "reset" sentinel, which is how a decrease says
+ * "all of it" instead of naming an amount that interest may have moved.
+ */
+declare function clearedQuotas(initialQuotas: Array<InitialQuota> | readonly InitialQuota[]): QuotaUpdateState;
 //#endregion
-export { getQuotasForUpdate };
+export { clearedQuotas, getQuotasForUpdate };