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

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

@@ -1,22 +1,137 @@
-import { DelayedIntent } from "../withdrawal-compressor/types.js";
-import { OnchainSDK } from "../../OnchainSDK.js";
 import { SDKConstruct } from "../../base/SDKConstruct.js";
-import { CreditAccountSlice, IntentPreviewResult } from "./types.js";
-import { ClaimDelayedOption, primaryInstantOutput } from "./operations/claim-delayed/index.js";
-import "./operations/index.js";
+import { OpenStrategyPreview, OpenStrategyProps } from "./open-strategy.js";
+import { AddCollateralIntent, AdjustLeverageIntent, CreditAccountSlice, DelayableIntent, DelayedRoute, DelayedStart, DelayedStartResult, DepositStrategyIntent, FinishIntentProps, InstantRoute, IntentPreviewError, IntentPreviewResult, IntentRoutesResult, OperationState, PreviewErrorReason, RepayStrategyIntent, ResumableIntent, RouteRefusals, StartIntent, StartIntentProps, WithdrawAssetIntent, WithdrawStrategyIntent } from "./types.js";
+import { AccountCalculatorOperation } from "./operations.js";
+import { fetchCreditAccountSlice, toCreditAccountSlice } from "./utils/credit-account-slice.js";
 //#region src/sdk/accounts/intents/index.d.ts
-type ResumeGenericProps<T extends DelayedIntent> = {
-  intent: T;
-  creditAccount: CreditAccountSlice;
-  sdk: OnchainSDK;
-  quotaReserve: number | undefined;
-  options: ClaimDelayedOption;
-  slippage: number | undefined;
+/**
+ * Open-strategy preview outcome.
+ *
+ * Shaped like {@link IntentPreviewResult} in its error half so all previews fail
+ * the same way, but the payload is its own: opening has no existing account, so
+ * there is no operation chain to report.
+ */
+type OpenStrategyPreviewResult = {
+  ok: true;
+  preview: OpenStrategyPreview;
+} | {
+  ok: false;
+  reason: PreviewErrorReason;
 };
-type ResumeProps = ResumeGenericProps<DelayedIntent>;
+/** An intent plus everything previewing it needs. */
+type StartProps = StartIntentProps & {
+  intent: StartIntent;
+};
+/**
+ * Previews of everything a wallet can do to an existing credit account.
+ *
+ * Two halves, deliberately kept apart: `plan.ts` turns an intent into a few
+ * steps with pure arithmetic, `realize.ts` turns the steps into router-backed
+ * operations. This class only picks the planner and wraps the outcome.
+ */
 declare class CreditAccountOperationsService extends SDKConstruct {
   #private;
-  finishIntent(props: ResumeProps): Promise<IntentPreviewResult>;
+  /**
+   * Previews an operation on an existing account.
+   *
+   * @param props - Intent plus account slice, quota reserve and slippage
+   * @returns Operations, projected state and calldata, or `{ ok: false, reason }`
+   * when the intent cannot be satisfied (e.g. the account lacks the source
+   * balance)
+   */
+  startIntent(props: StartProps): Promise<IntentPreviewResult>;
+  /**
+   * Largest `WITHDRAW` amount (in underlying) the account can take out while
+   * keeping leverage and staying inside the facade's debt band — the ceiling a
+   * withdraw form should offer. Taking everything out is the same intent with
+   * `MAX_UINT256` for an amount, and needs none of this arithmetic.
+   *
+   * @param props - Account slice and the SDK holding its market
+   * @returns Amount in underlying units; `0n` when nothing can leave
+   */
+  maxWithdraw(props: Pick<StartIntentProps, "creditAccount" | "sdk">): bigint;
+  /**
+   * 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.
+   *
+   * A repayment of exactly this leaves nothing behind at the block it was read
+   * at, and a little behind at any later one, since interest does not stop —
+   * so a wallet meaning to clear the account sends this with a buffer on top,
+   * which the intent caps at the debt rather than spending. `REPAY` with
+   * `MAX_UINT256` sizes that buffer itself.
+   *
+   * @param props - Account slice and the SDK holding its market
+   * @returns Amount in underlying units; `0n` on an account that owes nothing
+   */
+  maxRepay(props: Pick<StartIntentProps, "creditAccount" | "sdk">): bigint;
+  /**
+   * Previews the same operation when its source only redeems through its
+   * issuer: a Securitize dsToken, a Mellow share.
+   *
+   * Sits apart from {@link startIntent} because it is a different trade route,
+   * not a different intent: the request goes to the issuer instead of the
+   * router, and the proceeds — hence the repayment and the payout — arrive days
+   * later. Both routes of one intent are quoted together by
+   * {@link intentRoutes}; this is the one to call when the delayed route is the
+   * only one of interest.
+   *
+   * @param props - Intent plus account slice, quota reserve and slippage
+   * @returns The request transaction and what it recorded for the tail, or
+   * `{ ok: false, reason }` — `noDelayedRoute` when this route does not exist
+   * for the account at all
+   */
+  startDelayedIntent(props: StartIntentProps & {
+    intent: DelayableIntent;
+  }): Promise<DelayedStartResult>;
+  /**
+   * Previews a delayable intent both ways at once: settled by the router now,
+   * and started as a redemption that finishes days later.
+   *
+   * Which routes an account has depends on the intent and the token it sells,
+   * and a form has to know before it can offer a choice — so both are quoted
+   * from the same request and each is reported on its own. A route the account
+   * cannot take comes back `undefined` with its refusal in `refused`; only when
+   * neither answers is the whole result `{ ok: false }`.
+   *
+   * A route that could not be quoted at all — a pathfinder with no path out of
+   * the source, a read that failed — counts as missing rather than fatal, since
+   * the other route may be the one the caller wanted. With nothing left to
+   * report the failure is rethrown, as {@link startIntent} would have.
+   *
+   * @param props - A withdraw or adjust-leverage intent plus account slice,
+   * quota reserve and slippage
+   * @returns Whichever routes are viable, or `{ ok: false, reason }` when none is
+   */
+  intentRoutes(props: StartIntentProps & {
+    intent: DelayableIntent;
+  }): Promise<IntentRoutesResult>;
+  /**
+   * Previews the tail of a delayed intent, once the withdrawal it started has
+   * matured: the claim, then whatever the intent still owes.
+   *
+   * Serves the two operations that can genuinely be interrupted by a delay — a
+   * withdrawal and a deleveraging. For the rest, the claim is the whole tail:
+   * the tokens land on the account and only their quota has to catch up.
+   *
+   * @param props - The recorded intent, the account slice as it stands now, and
+   * the matured claimable
+   * @returns Shaped exactly like {@link startIntent}'s result, so both halves of
+   * an operation are consumed the same way
+   */
+  finishIntent(props: FinishIntentProps): Promise<IntentPreviewResult>;
+  /**
+   * Previews opening a brand-new leveraged position.
+   *
+   * Sits apart from {@link startIntent} because there is no account yet: nothing
+   * can be projected from existing balances, and the output feeds
+   * `sdk.accounts.openCA` rather than a facade multicall assembled here.
+   *
+   * @param props - Credit manager, wallet collateral, target token and leverage
+   * @returns Debt, position size, projected balances and quotas for both the
+   * expected and the floor branch, or `{ ok: false, reason }` when the requested
+   * leverage or the resulting debt is not viable
+   */
+  openStrategyIntent(props: OpenStrategyProps): Promise<OpenStrategyPreviewResult>;
 }
 //#endregion
-export { CreditAccountOperationsService, type CreditAccountSlice, type IntentPreviewResult, primaryInstantOutput };
+export { type AccountCalculatorOperation, type AddCollateralIntent, type AdjustLeverageIntent, CreditAccountOperationsService, type CreditAccountSlice, type DelayableIntent, type DelayedRoute, type DelayedStart, type DelayedStartResult, type DepositStrategyIntent, type FinishIntentProps, type InstantRoute, IntentPreviewError, type IntentPreviewResult, type IntentRoutesResult, type OpenStrategyPreview, OpenStrategyPreviewResult, type OpenStrategyProps, type OperationState, type PreviewErrorReason, type RepayStrategyIntent, type ResumableIntent, type RouteRefusals, type StartIntent, type WithdrawAssetIntent, type WithdrawStrategyIntent, fetchCreditAccountSlice, toCreditAccountSlice };

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

@@ -0,0 +1,46 @@
+//#region src/sdk/accounts/intents/math.d.ts
+/**
+ * The whole arithmetic behind every intent, in underlying units.
+ *
+ * Notation: `C` collateral (own funds = TVL − debt), `D` debt, `L` total
+ * leverage scaled by {@link LEVERAGE_DECIMALS} (300n = 3x), so `TVL = C · L`
+ * and `D = C · (L − 1)`.
+ */
+/** Debt and collateral of an account, both priced in the underlying. */
+interface Position {
+  debt: bigint;
+  collateral: bigint;
+}
+/** Facade limits a non-zero debt must respect. */
+interface DebtBand {
+  minDebt: bigint;
+  maxDebt: bigint;
+}
+/** Debt that realises `leverage` on `collateral`: `D = C · (L − 1)`. */
+declare function debtForLeverage(collateral: bigint, leverage: bigint): bigint;
+/**
+ * Debt change that keeps leverage fixed while collateral moves by
+ * `collateralDelta`: `dD = D0 · dC / C0`.
+ *
+ * Computed on the ratio directly rather than by recovering `L` and reapplying
+ * it, so no rounding is introduced on the way.
+ */
+declare function proportionalDebt(position: Position, collateralDelta: bigint): bigint;
+/**
+ * Largest withdrawal (in underlying) that {@link proportionalDebt} can still
+ * pay for: the repayment it implies leaves debt at or above `minDebt`, and
+ * strictly less than the collateral goes — the last unit closes the account
+ * rather than shrinks it. `0n` when the debt already sits below the band.
+ *
+ * Solves `floor(D0 · W / C0) ≤ D0 − minDebt` for `W`.
+ */
+declare function maxProportionalWithdrawal(position: Position, band: DebtBand): bigint;
+/** Total leverage cannot drop below 1x — that would be negative debt. */
+declare function assertLeverageAtLeastOne(leverage: bigint): void;
+/**
+ * Rejects a debt the facade would revert on: zero is always fine (no loan at
+ * all), anything else has to sit inside `[minDebt, maxDebt]`.
+ */
+declare function assertDebtInBand(debt: bigint, band: DebtBand): void;
+//#endregion
+export { DebtBand, Position, assertDebtInBand, assertLeverageAtLeastOne, debtForLeverage, maxProportionalWithdrawal, proportionalDebt };

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

@@ -0,0 +1,64 @@
+import { Asset } from "../../base/types.js";
+import { PositionMetrics } from "../../../model/positions.js";
+import "../../../model/index.js";
+import { MultiCall } from "../../types/transactions.js";
+import { OnchainSDK } from "../../OnchainSDK.js";
+import "../../index.js";
+import { Address } from "viem";
+//#region src/sdk/accounts/intents/open-strategy.d.ts
+interface OpenStrategyProps {
+  sdk: OnchainSDK;
+  /** Credit manager to open the account in. */
+  creditManager: Address;
+  /** Collateral coming from the wallet, in their own tokens. */
+  collateral: Asset[];
+  /** Token the position ends up in. */
+  targetToken: Address;
+  /** Target total leverage scaled by `LEVERAGE_DECIMALS` (300n = 3x). */
+  leverage: bigint;
+  /** Router slippage in PERCENTAGE_FORMAT (100% = 10_000). */
+  slippage: number | undefined;
+  /** Extra quota headroom in PERCENTAGE_FORMAT. */
+  quotaReserve: number | undefined;
+  /** Balances to leave unswapped; everything else is routed into the target. */
+  leftoverBalances?: Asset[];
+}
+/**
+ * Projected result of opening a brand-new leveraged position.
+ *
+ * Unlike every other flow this one reports **both** branches: the pathfinder
+ * hands back expected and floor balances from a single call, and `openCA` wants
+ * both `minQuota` and `averageQuota`, so there is nothing to gain by dropping one.
+ */
+interface OpenStrategyPreview extends PositionMetrics {
+  /** Debt drawn, in underlying. */
+  debt: bigint;
+  /** Collateral supplied, valued in underlying. */
+  collateral: bigint;
+  /** Position size — collateral plus debt, in underlying. */
+  totalValue: bigint;
+  /** Expected post-open balances. */
+  averageAssets: Asset[];
+  /** Floor post-open balances after slippage. */
+  minAssets: Asset[];
+  /** Quotas to buy against `averageAssets`; feeds `openCA.averageQuota`. */
+  averageQuota: Asset[];
+  /** Quotas to buy against `minAssets`; feeds `openCA.minQuota`. */
+  minQuota: Asset[];
+  /** Router path; feeds `openCA.calls`. */
+  calls: MultiCall[];
+}
+/**
+ * Previews opening a leveraged position out of wallet collateral.
+ *
+ * Debt follows from the target leverage against the supplied margin
+ * (`debt = margin * (L - 1)`, `totalValue = margin * L`); the collateral and the
+ * borrowed underlying are then routed into the target token in one pathfinder call.
+ *
+ * There is no account yet, so this does not go through `startIntent` and produces
+ * no operation list — the caller passes the numbers and calls straight to
+ * `sdk.accounts.openCA`.
+ */
+declare function previewOpenStrategy(props: OpenStrategyProps): Promise<OpenStrategyPreview>;
+//#endregion
+export { OpenStrategyPreview, OpenStrategyProps, previewOpenStrategy };

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

@@ -0,0 +1,215 @@
+import { ClaimableWithdrawal, RequestableWithdrawal, WithdrawalOutput } from "../withdrawal-compressor/types.js";
+import { Asset } from "../../base/types.js";
+import { MultiCall } from "../../types/transactions.js";
+import { OnchainSDK } from "../../OnchainSDK.js";
+import { EncodableCreditAccountOperation } from "../types.js";
+import { calcQuotaUpdate } from "../../../common-utils/utils/creditAccount/quota-utils.js";
+import { CreditAccountSlice } from "./types.js";
+import "../../index.js";
+import { Address } from "viem";
+//#region src/sdk/accounts/intents/operations.d.ts
+/**
+ * The operation vocabulary: one logical step of an intent, carrying both the
+ * calldata that realises it and the amounts it was computed from.
+ *
+ * A superset of {@link EncodableCreditAccountOperation}: same discriminants,
+ * plus the quoted amounts the preview and the tests read, plus the RWA legs
+ * that come from their own assemblers rather than from `assembleCaOperations`.
+ */
+type AccountCalculatorOperation = AddCollateralOperation | IncreaseDebtOperation | DecreaseDebtOperation | SwapOperation | WithdrawCollateralOperation | QuotaUpdateOperation | WrapRwaCollateralOperation | UnwrapRwaCollateralOperation | StartDelayedWithdrawalOperation | ClaimDelayedWithdrawalOperation;
+/**
+ * Compile-time proof that the engine's operations really are the SDK's own
+ * encodable ones with the quoted amounts attached, so the two cannot drift into
+ * parallel vocabularies for the same facade calls.
+ */
+type Extends<A extends B, B> = A;
+type _EngineOpsAreEncodable = Extends<Extract<AccountCalculatorOperation, {
+  type: EncodableCreditAccountOperation["type"];
+}>, EncodableCreditAccountOperation>;
+interface AddCollateralOperation {
+  type: "addCollateral";
+  token: Address;
+  amount: bigint;
+  value?: bigint;
+  calls: MultiCall[];
+}
+declare function buildAddCollateralOperation(input: {
+  token: Address;
+  amount: bigint;
+  value?: bigint;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+}): AddCollateralOperation;
+interface IncreaseDebtOperation {
+  type: "increaseDebt";
+  amount: bigint;
+  calls: MultiCall[];
+}
+declare function buildIncreaseDebtOperation(input: {
+  amount: bigint;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+}): IncreaseDebtOperation;
+interface DecreaseDebtOperation {
+  type: "decreaseDebt";
+  amount: bigint;
+  /**
+   * The repayment settles the loan rather than shrinking it, so the call names
+   * no amount and the facade takes everything outstanding. `amount` is still
+   * the debt as it was read, which is what the projection is built on; the
+   * difference is the interest that accrues before the transaction lands.
+   */
+  full?: boolean;
+  calls: MultiCall[];
+}
+declare function buildDecreaseDebtOperation(input: {
+  amount: bigint;
+  full?: boolean;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+}): DecreaseDebtOperation;
+interface WithdrawCollateralOperation {
+  type: "withdrawCollateral";
+  token: Address;
+  amount: bigint;
+  /** Wallet recipient for withdrawn tokens — never a token address. */
+  to: Address;
+  /**
+   * The call names no amount and the facade hands over the whole balance, so a
+   * swap that beat its floor does not strand the surplus on the account.
+   * `amount` remains the figure the projection was built on.
+   */
+  all?: boolean;
+  calls: MultiCall[];
+}
+declare function buildWithdrawCollateralOperation(input: {
+  token: Address;
+  amount: bigint;
+  to: Address;
+  all?: boolean;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+}): WithdrawCollateralOperation;
+/** Routed conversion: one or more tokens in, one token out. */
+interface SwapOperation {
+  type: "swap";
+  from: Asset[];
+  tokenOut: Address;
+  amountOut: bigint;
+  calls: MultiCall[];
+}
+/** One routed leg, with the amounts it was quoted at. */
+declare function buildSwapOperation(input: {
+  tokenIn: Address;
+  amountIn: bigint;
+  tokenOut: Address;
+  amountOut: bigint;
+  calls: MultiCall[];
+}): SwapOperation;
+/**
+ * The many-to-one leg an exit routes: every balance listed goes in, and the
+ * underlying comes out.
+ */
+declare function buildCloseSwapOperation(input: {
+  from: Asset[];
+  tokenOut: Address;
+  amountOut: bigint;
+  calls: MultiCall[];
+}): SwapOperation;
+interface QuotaUpdateOperation {
+  type: "changeQuota";
+  desiredQuota: Record<Address, Asset>;
+  quotaIncrease: Asset[];
+  quotaDecrease: Asset[];
+  calls: MultiCall[];
+}
+type QuotaUpdateState = ReturnType<typeof calcQuotaUpdate>;
+declare function buildQuotaUpdateOperation(input: {
+  update: QuotaUpdateState;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+}): QuotaUpdateOperation;
+interface WrapRwaCollateralOperation {
+  type: "wrapRwaCollateral";
+  /** Amount of RWA asset wrapped. */
+  amount: bigint;
+  /** RWA asset token (wrap source). */
+  tokenIn: Address;
+  /** Underlying received after wrap. */
+  tokenOut: Address;
+  amountOut: bigint;
+  calls: MultiCall[];
+}
+interface UnwrapRwaCollateralOperation {
+  type: "unwrapRwaCollateral";
+  /** Amount of wrapped underlying unwrapped. */
+  amount: bigint;
+  /** Wrapped underlying token (unwrap source). */
+  tokenIn: Address;
+  /** RWA asset received after unwrap. */
+  tokenOut: Address;
+  amountOut: bigint;
+  calls: MultiCall[];
+}
+interface RwaLegInput {
+  tokenIn: Address;
+  amountIn: bigint;
+  tokenOut: Address;
+  amountOut: bigint;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+}
+/** Wraps an RWA asset into the market underlying. */
+declare function buildWrapRwaCollateralOperation(input: RwaLegInput): Promise<WrapRwaCollateralOperation>;
+/** Unwraps the market underlying back into its RWA asset. */
+declare function buildUnwrapRwaCollateralOperation(input: RwaLegInput): Promise<UnwrapRwaCollateralOperation>;
+/**
+ * The request that starts a redemption: spends the source token and receives
+ * the phantom token standing in for the payout until it matures.
+ */
+interface StartDelayedWithdrawalOperation {
+  type: "startDelayedWithdrawal";
+  /** Source token the redemption is requested from. */
+  token: Address;
+  /** Amount of `token` the issuer burns; capped at the account balance. */
+  amountIn: bigint;
+  /** Request outputs; a delayed one is the phantom token, not the payout. */
+  outputs: WithdrawalOutput[];
+  /** Whether anything at all has to be waited for. */
+  settlement: "instant" | "delayed";
+  calls: MultiCall[];
+}
+declare function buildStartDelayedWithdrawalOperation(input: {
+  preview: RequestableWithdrawal;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+}): StartDelayedWithdrawalOperation;
+/**
+ * The claim of a matured delayed withdrawal: burns the phantom and credits the
+ * outputs the compressor reports.
+ */
+interface ClaimDelayedWithdrawalOperation {
+  type: "claimDelayedWithdrawal";
+  /** Source token the delayed withdrawal was requested from. */
+  token: Address;
+  withdrawalPhantomToken: Address;
+  withdrawalTokenSpent: bigint;
+  /** Claim outputs as returned by the compressor (incl. `isDelayed`). */
+  outputs: WithdrawalOutput[];
+  calls: MultiCall[];
+}
+declare function buildClaimDelayedWithdrawalOperation(input: {
+  claimable: ClaimableWithdrawal;
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+}): ClaimDelayedWithdrawalOperation;
+/**
+ * What a request or a claim puts on the account right away, as opposed to what
+ * only the phantom token represents.
+ */
+declare function instantOutput(outputs: WithdrawalOutput[], token?: Address): {
+  token: Address;
+  amount: bigint;
+} | undefined;
+//#endregion
+export { AccountCalculatorOperation, AddCollateralOperation, ClaimDelayedWithdrawalOperation, DecreaseDebtOperation, IncreaseDebtOperation, QuotaUpdateOperation, QuotaUpdateState, RwaLegInput, StartDelayedWithdrawalOperation, SwapOperation, UnwrapRwaCollateralOperation, WithdrawCollateralOperation, WrapRwaCollateralOperation, _EngineOpsAreEncodable, buildAddCollateralOperation, buildClaimDelayedWithdrawalOperation, buildCloseSwapOperation, buildDecreaseDebtOperation, buildIncreaseDebtOperation, buildQuotaUpdateOperation, buildStartDelayedWithdrawalOperation, buildSwapOperation, buildUnwrapRwaCollateralOperation, buildWithdrawCollateralOperation, buildWrapRwaCollateralOperation, instantOutput };

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

@@ -0,0 +1,189 @@
+import { ClaimableWithdrawal, DelayedIntent } from "../withdrawal-compressor/types.js";
+import { AddCollateralIntent, AdjustLeverageIntent, DepositStrategyIntent, RepayStrategyIntent, WithdrawAssetIntent, WithdrawStrategyIntent } from "./types.js";
+import { DebtBand } from "./math.js";
+import { Address } from "viem";
+//#region src/sdk/accounts/intents/plan.d.ts
+/**
+ * Planning: an intent becomes a short list of {@link Step}s.
+ *
+ * Every intent is a walk along the same chain —
+ *
+ * ```
+ * wallet ─add─▶ account ─convert(in→U)─▶ borrow | repay ─convert(U→out)─▶ ─withdraw─▶ wallet
+ * ```
+ *
+ * — so a plan is just which slots are filled and by how much. Planners are
+ * pure: they read an {@link AccountView} and return steps; nothing here touches
+ * the router or the chain. Identity converts (`from === to`) are legitimate
+ * plan entries — the realiser drops them after checking the balance — which is
+ * what lets one planner cover every "S is / is not the underlying" shape.
+ */
+/** Amount of a step: fixed, or whatever the previous step produced. */
+type Amount = bigint | {
+  raised: true;
+  max?: bigint;
+};
+/** Whatever the previous convert produced. */
+declare const RAISED: Amount;
+type Step = {
+  kind: "add";
+  token: Address;
+  amount: bigint;
+  value: bigint | undefined;
+} | {
+  kind: "borrow";
+  amount: bigint;
+} |
+/**
+ * Repays up to `amount`, never more than the underlying on the account minus
+ * `keep` — a routing shortfall shows up as slightly less debt repaid.
+ */
+{
+  kind: "repay";
+  amount: Amount;
+  keep?: bigint;
+} | {
+  kind: "convert";
+  from: Address;
+  to: Address;
+  amount: Amount;
+} | {
+  kind: "withdraw";
+  token: Address;
+  amount: Amount;
+  to: Address;
+} |
+/**
+ * Sells every balance the account holds into the underlying in one
+ * many-to-one route. Only an exit asks for this: the whole position is
+ * leaving, so the router is given all of it at once rather than one leg per
+ * token, and there is nothing left to price a fixed input against.
+ */
+{
+  kind: "closeAll";
+} |
+/**
+ * Redeems `amount` of `token` through its issuer instead of a DEX, keeping
+ * `reserve` of it on the account. `record` is written into the request and
+ * read back at claim time, which is what lets the tail be planned then.
+ */
+{
+  kind: "request";
+  token: Address;
+  amount: bigint;
+  reserve: bigint;
+  record: DelayedIntent;
+} | {
+  kind: "claim";
+  claimable: ClaimableWithdrawal;
+} |
+/**
+ * Hands whatever is left on the account to `to`, each balance in the token it
+ * stands in. Only an exit asks for this: the amounts are whatever the legs
+ * before it happen to leave, which no planner can name in advance.
+ */
+{
+  kind: "sweep";
+  to: Address;
+} |
+/**
+ * Drops every quota the account holds, in the same transaction and before
+ * whatever follows. Only a plan that leaves no debt behind asks for this:
+ * quota fees accrue on the quota, not on the loan, so a quota outliving the
+ * debt it backed would keep charging an account that owes nothing.
+ */
+{
+  kind: "clearQuotas";
+};
+/** What a planner is allowed to know about the account. */
+interface AccountView {
+  underlying: Address;
+  /** Raw asset of an RWA market (e.g. USDC behind dcUSDC); undefined otherwise. */
+  rwaAsset: Address | undefined;
+  debt: bigint;
+  /** TVL − debt, in underlying. */
+  collateral: bigint;
+  band: DebtBand;
+  balanceOf(token: Address): bigint;
+  /** Oracle conversion, RWA-aware. */
+  price(from: Address, to: Address, amount: bigint): bigint;
+  /** Most valuable non-phantom balance, or undefined when there is none. */
+  fattest(exclude?: Address[]): Address | undefined;
+}
+/** Intent 5: the token lands as is; debt is untouched. */
+declare function planAddCollateral(intent: Omit<AddCollateralIntent, "type">): Step[];
+/** Intent 4: one asset out at fixed debt. */
+declare function planWithdrawAsset(intent: Omit<WithdrawAssetIntent, "type">, view: AccountView): Step[];
+/** Intent 6: collateral fixed, debt retargeted to `C0 · (L1 − 1)`. */
+declare function planAdjustLeverage(intent: Omit<AdjustLeverageIntent, "type">, view: AccountView): Step[];
+/** Intents 1.1 / 1.2: collateral grows by `a`, debt grows to match. */
+declare function planDeposit(intent: Omit<DepositStrategyIntent, "type">, view: AccountView): Step[];
+/**
+ * Intent 3: funding comes in from the wallet and goes straight into the debt.
+ * Collateral never moves, so the whole plan is the funding's way to `U`.
+ *
+ * Funding in `U` needs no way there: it lands and is repaid, which is the whole
+ * plan. An RWA market also takes the raw asset behind its underlying, and that
+ * one is wrapped on the way in.
+ *
+ * `MAX_UINT256` settles the loan: the wallet is asked for the debt as it stands
+ * plus the headroom {@link SETTLE_MARGIN} allows for the interest of the blocks
+ * still to come, since the facade is told to repay everything outstanding
+ * rather than the amount quoted here.
+ */
+declare function planRepay(intent: Omit<RepayStrategyIntent, "type">, view: AccountView): Step[];
+/**
+ * Intent 2.1: `W` of value leaves, debt shrinks by `D0 · W / C0` so leverage
+ * holds. Both are funded by the source `S`.
+ */
+declare function planWithdraw(intent: Omit<WithdrawStrategyIntent, "type">, view: AccountView): Step[];
+/**
+ * Intent 2.1 against a source that cannot be sold on a DEX.
+ *
+ * Some collateral only converts through its issuer — a Securitize dsToken, a
+ * Mellow share — which answers a redemption request now and pays out days
+ * later. The trade is unchanged; what changes is that the proceeds do not exist
+ * yet, so this half only requests the redemption:
+ *
+ * ```
+ * request(S, W + dD) → [days] → claim → convert → repay → withdraw
+ * ```
+ *
+ * The tail is planned at claim time by {@link planFinishWithdraw}, from the
+ * intent this request records — only then is the claimed amount, and the token
+ * it arrived in, known.
+ */
+declare function planWithdrawDelayed(intent: Omit<WithdrawStrategyIntent, "type">, view: AccountView): Step[];
+/**
+ * Intent 6.2 against a position token that only redeems through its issuer.
+ *
+ * Only deleveraging can be delayed: raising leverage borrows and buys, both of
+ * which settle at once. The request covers whatever idle underlying does not
+ * already, and the tail repays from the claim.
+ */
+declare function planAdjustLeverageDelayed(intent: Omit<AdjustLeverageIntent, "type">, view: AccountView): Step[];
+/** Everything claimed goes into the debt. */
+declare function planFinishDecreaseLeverage(claimable: ClaimableWithdrawal, claimed: {
+  token: Address;
+  amount: bigint;
+}, view: AccountView): Step[];
+/**
+ * The claim is split between the promised payout `W` and the debt the leading
+ * half deferred: the payout is served first, the debt gets what is left, so a
+ * routing shortfall shows as leverage a touch above target rather than as a
+ * payout the wallet was promised and did not get.
+ */
+declare function planFinishWithdraw(intent: {
+  withdrawToken: Address;
+  withdrawAmount: bigint;
+  debtRepaid: bigint;
+  sourceToken: Address;
+  to: Address;
+}, claimable: ClaimableWithdrawal, claimed: {
+  token: Address;
+  amount: bigint;
+}, view: AccountView): Step[];
+/** Nothing is owed beyond the claim: the tokens land and quotas catch up. */
+declare function planFinishClaimOnly(claimable: ClaimableWithdrawal): Step[];
+//#endregion
+export { AccountView, Amount, RAISED, Step, planAddCollateral, planAdjustLeverage, planAdjustLeverageDelayed, planDeposit, planFinishClaimOnly, planFinishDecreaseLeverage, planFinishWithdraw, planRepay, planWithdraw, planWithdrawAsset, planWithdrawDelayed };