@gearbox-protocol/sdk 15.1.0-next.9 → 16.0.0-next.1

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

@@ -1,22 +1,159 @@
-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";
+import { Address } from "viem";
 //#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;
+  /**
+   * Largest `WITHDRAW_ASSET` amount of one token the account can take out
+   * while its health factor stays at {@link MIN_HF_LIMITED} plus a basis
+   * point — the ceiling a withdraw-collateral form should offer. Thresholds,
+   * prices and quota activity come from the account's market, valued the way
+   * the facade values a call that pays out; zero debt frees the whole balance.
+   *
+   * @param props - Account slice, the SDK holding its market, and the
+   * collateral to withdraw
+   * @returns Amount in the token's units; `0n` when nothing can leave
+   */
+  maxWithdrawCollateral(props: Pick<StartIntentProps, "creditAccount" | "sdk"> & {
+    token: Address;
+  }): 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.
+   *
+   * `preview` is where the intent ends — the account once the redemption has
+   * matured, been claimed and the tail has run — because that is what the
+   * caller asked for; the half-way state the request itself lands in is
+   * `delayed.afterRequest`. Both are validated, so a request whose tail could
+   * not be completed is refused instead of started.
+   *
+   * @param props - Intent plus account slice, quota reserve and slippage
+   * @returns The request transaction, the state it ends in 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 three operations that can genuinely be interrupted by a delay —
+   * a withdrawal, a deleveraging and an exit. 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/maxWithdrawCollateral.d.ts

@@ -0,0 +1,35 @@
+import { OnchainSDK } from "../../OnchainSDK.js";
+import { CreditAccountSlice } from "./types.js";
+import "../../index.js";
+import { Address } from "viem";
+//#region src/sdk/accounts/intents/maxWithdrawCollateral.d.ts
+interface MaxWithdrawCollateralProps {
+  creditAccount: CreditAccountSlice;
+  sdk: OnchainSDK;
+  /** Collateral to withdraw. */
+  token: Address;
+  /** Health factor the withdrawal has to leave behind, in basis points. */
+  targetHF: bigint;
+}
+/**
+ * Largest amount of one collateral the account can withdraw while its health
+ * 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 lower of its two feeds, the way the facade
+ * values a call that hands funds over; 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.
+ *
+ * @returns Amount in the token's units; `0n` when nothing can leave —
+ * including when the account is already below `targetHF`, or the target or the
+ * underlying has no price
+ **/
+declare function maxWithdrawCollateral(props: MaxWithdrawCollateralProps): bigint;
+//#endregion
+export { MaxWithdrawCollateralProps, maxWithdrawCollateral };

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

@@ -0,0 +1,87 @@
+import { Bps, TokenAmount } from "../../../model/primitives.js";
+import { BorrowRateBreakdown } from "../../../model/positions.js";
+import "../../../model/index.js";
+import { Asset } from "../../base/types.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 {
+  /**
+   * Health factor in basis points: below `10000` the account is liquidatable.
+   *
+   * @example `12500` for a health factor of 1.25
+   **/
+  healthFactor: Bps;
+  /**
+   * Cost of the debt, broken down by source.
+   **/
+  borrowRate: BorrowRateBreakdown;
+  /**
+   * Estimated milliseconds until the health factor decays to `10000` under
+   * the current borrow rate, or `null` when the debt carries no rate (or the
+   * account is already liquidatable).
+   **/
+  timeToLiquidation: bigint | null;
+  /**
+   * Price of the single non-underlying collateral at which the account
+   * becomes liquidatable, in the oracle's 8-decimal fixed point, or `null`
+   * when the account holds zero or several non-underlying assets.
+   **/
+  liquidationPrice: bigint | null;
+  /** 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: TokenAmount[];
+  /** Floor post-open balances after slippage. */
+  minAssets: TokenAmount[];
+  /** 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 };