@gearbox-protocol/sdk 14.12.0-next.3 → 14.12.0-next.30

package/dist/types/preview/prerequisites/Prerequisite.d.ts

@@ -1,60 +1,23 @@
-import { type ContractFunctionParameters } from "viem";
-import type { PrerequisiteContext, PrerequisiteDetail, PrerequisiteError, PrerequisiteKind, PrerequisiteResult } from "./types.js";
+import type { PrerequisiteContext, PrerequisiteError, PrerequisiteResult } from "./types.js";
 /**
- * One entry of a viem `multicall({ allowFailure: true })` response: either a
- * decoded `result` or the `error` that the call reverted with.
+ * A single verifiable prerequisite for a transaction. Subclasses implement
+ * {@link check} to perform whatever async reads they need (an ERC-20
+ * `readContract`, a compressor call, ...) and map the outcome into a
+ * {@link PrerequisiteResult}.
  */
-export type MulticallCallResult = {
-    status: "success";
-    result: unknown;
-    error?: undefined;
-} | {
-    status: "failure";
-    result?: undefined;
-    error: Error;
-};
-/**
- * Decodes an unknown error into a {@link PrerequisiteError} with a
- * human-readable revert reason. Mirrors the SDK's `extractCallError`: walk the
- * viem error chain for a {@link ContractFunctionRevertedError} and use its
- * `errorName`, otherwise fall back to the error's short message / name.
- */
-export declare function toPrerequisiteError(cause: unknown): PrerequisiteError;
-/**
- * A single verifiable prerequisite for a transaction. Subclasses describe the
- * on-chain reads they need ({@link calls}) and how to turn the multicall slice
- * into a {@link PrerequisiteResult} ({@link resolve}).
- *
- * Identity (`id`, `kind`, `title`) and build-time `detail` are exposed as
- * read-only accessors; subclasses back them with private fields. The shared
- * {@link satisfiedResult}/{@link errorResult} helpers are `protected` so each
- * subclass builds results consistently.
- *
- * The same instance can be verified standalone via {@link verify} or batched
- * together with others by `verifyPrerequisites`.
- */
-export declare abstract class Prerequisite<K extends PrerequisiteKind> {
-    /** Stable identifier, used as a React key and for deduplication. */
-    abstract get id(): string;
-    /** Discriminant tying this check to its detail payload. */
-    abstract get kind(): K;
-    /** Human-readable label shown in the UI. */
-    abstract get title(): string;
-    /** Inputs known before reading the chain (no `actual` yet). */
-    abstract get detail(): PrerequisiteDetail<K>;
-    /** Contract reads this check needs (usually one). */
-    abstract calls(ctx: PrerequisiteContext): ContractFunctionParameters[];
-    /** Maps this check's slice of the multicall response into a result. */
-    abstract resolve(slice: MulticallCallResult[]): PrerequisiteResult<K>;
+export declare abstract class Prerequisite {
+    /**
+     * Verifies this prerequisite. Never rejects: any error thrown by
+     * {@link check} (revert, RPC/network failure, compressor error) is
+     * normalized into an `error` result.
+     */
+    verify(ctx: PrerequisiteContext): Promise<PrerequisiteResult>;
     /**
-     * Verifies this prerequisite on its own using an `allowFailure` multicall.
-     * Prefer `verifyPrerequisites` to batch several checks into one round-trip.
+     * Performs the reads this prerequisite needs and maps them into a result.
+     * May throw on read failure; {@link verify} converts throws into `error`
+     * results.
      */
-    verify(ctx: PrerequisiteContext): Promise<PrerequisiteResult<K>>;
-    /** Builds a successful result; `detail` carries the on-chain `actual`. */
-    protected satisfiedResult(satisfied: boolean, detail: PrerequisiteDetail<K>): PrerequisiteResult<K>;
-    /** Builds a failed result from a decoded read error. */
-    protected errorResult(error: PrerequisiteError): PrerequisiteResult<K>;
+    protected abstract check(ctx: PrerequisiteContext): Promise<PrerequisiteResult>;
+    /** Builds this prerequisite's failed result from a normalized read error. */
+    protected abstract errorResult(error: PrerequisiteError): PrerequisiteResult;
 }
-/** Any prerequisite regardless of its kind, used for heterogeneous lists. */
-export type AnyPrerequisite = Prerequisite<PrerequisiteKind>;

package/dist/types/preview/prerequisites/RWAOpenRequirementsPrerequisite.d.ts

@@ -0,0 +1,51 @@
+import type { Address } from "viem";
+import type { RWAMissingOpenAccountRequirements, RWAOpenAccountRequirements, RWAOperationArgs } from "../../sdk/index.js";
+import { Prerequisite } from "./Prerequisite.js";
+import type { PrerequisiteContext, PrerequisiteError, PrerequisiteOutcome } from "./types.js";
+/**
+ * RWA (e.g. Securitize) open-account requirements: off-chain token
+ * registration and/or EIP-712 signatures the borrower must provide before
+ * opening a credit account in an RWA market.
+ */
+export interface RWAOpenRequirementsDetail {
+    /** RWA token (e.g. Securitize DSToken) the requirements are checked for. */
+    token: Address;
+    /** Credit manager of the RWA market. */
+    creditManager: Address;
+    /** RWA factory that gates the token. */
+    factory: Address;
+    /**
+     * Full requirements fetched at verify time via
+     * `sdk.accounts.getOpenAccountRequirements`; only present when the read
+     * succeeded and the factory gates the token.
+     */
+    requirements?: RWAOpenAccountRequirements;
+    /**
+     * Subset of `requirements` still unfulfilled, computed by the RWA
+     * factory at verify time (`IRWAFactory.getMissingRequirements`);
+     * `undefined` when everything is satisfied.
+     */
+    missing?: RWAMissingOpenAccountRequirements;
+}
+export type RWAOpenRequirementsResult = PrerequisiteOutcome & {
+    kind: "rwaOpenRequirements";
+    detail: RWAOpenRequirementsDetail;
+};
+/**
+ * Checks that the borrower has fulfilled the RWA factory's open-account
+ * requirements (issuer-side token registration, EIP-712 signatures).
+ *
+ * The requirements are fetched at verify time via
+ * `sdk.accounts.getOpenAccountRequirements`, so re-running verification picks
+ * up off-chain progress (the borrower registering on the issuer's website or
+ * signing the factory's message) without rebuilding the prerequisites. The
+ * unfulfilled subset is computed by the factory itself
+ * (`IRWAFactory.getMissingRequirements`) and exposed on the result's
+ * `detail.missing`; the full requirements are kept on `detail.requirements`.
+ */
+export declare class RWAOpenRequirementsPrerequisite extends Prerequisite {
+    #private;
+    constructor(detail: Omit<RWAOpenRequirementsDetail, "requirements" | "missing">, providedArgs?: RWAOperationArgs);
+    protected check(ctx: PrerequisiteContext): Promise<RWAOpenRequirementsResult>;
+    protected errorResult(error: PrerequisiteError): RWAOpenRequirementsResult;
+}

package/dist/types/preview/prerequisites/buildCollateralPrerequisites.d.ts

@@ -0,0 +1,14 @@
+import { type GetApprovalAddressProps } from "../../sdk/index.js";
+import type { InnerOperation } from "../parse/index.js";
+import type { Prerequisite } from "./Prerequisite.js";
+import type { PrerequisiteContext } from "./types.js";
+/**
+ * For every `addCollateral` inside a multicall, requires the wallet to approve
+ * and hold the collateral token for the collateral spender.
+ *
+ * The approval spender is resolved via {@link OnchainSDK.accounts.getApprovalAddress}:
+ * the credit manager for classic markets, but a per-investor "special wallet"
+ * for RWA markets. The resolution happens at build time because the spender is
+ * part of the prerequisite's identity and UI detail.
+ */
+export declare function buildCollateralPrerequisites(spenderOptions: GetApprovalAddressProps, multicall: InnerOperation[], ctx: PrerequisiteContext): Promise<Prerequisite[]>;

package/dist/types/preview/prerequisites/buildPartialLiquidationPrerequisites.d.ts

@@ -0,0 +1,8 @@
+import type { PartialLiquidationOperation } from "../parse/index.js";
+import type { Prerequisite } from "./Prerequisite.js";
+import type { PrerequisiteContext } from "./types.js";
+/**
+ * Partial liquidation pulls the repaid underlying from the liquidator: they
+ * must have approved it to the credit manager and hold enough of it.
+ */
+export declare function buildPartialLiquidationPrerequisites(tx: PartialLiquidationOperation, ctx: PrerequisiteContext): Prerequisite[];

package/dist/types/preview/prerequisites/buildPoolPrerequisites.d.ts

@@ -0,0 +1,8 @@
+import { type Address } from "viem";
+import type { PoolOperation } from "../parse/index.js";
+import type { Prerequisite } from "./Prerequisite.js";
+/**
+ * Prerequisites for ERC4626 pool operations (deposit, mint, withdraw, redeem),
+ * either direct or zapper-routed.
+ */
+export declare function buildPoolPrerequisites(tx: PoolOperation, wallet: Address): Prerequisite[];

package/dist/types/preview/prerequisites/buildRWAPrerequisites.d.ts

@@ -0,0 +1,21 @@
+import type { Address } from "viem";
+import { type RWAOperationArgs } from "../../sdk/index.js";
+import type { InnerOperation } from "../parse/index.js";
+import type { Prerequisite } from "./Prerequisite.js";
+import type { PrerequisiteContext } from "./types.js";
+/**
+ * For RWA-factory open-account operations (e.g. `RWAOpenCreditAccount`),
+ * builds a prerequisite per RWA token the multicall touches; each one checks
+ * the factory's open-account requirements (issuer-side token registration,
+ * EIP-712 signatures) at verify time.
+ *
+ * The `providedArgs` params are the registration values decoded from the
+ * transaction calldata itself: signatures already included there satisfy the
+ * signature requirement, so a fully built transaction is not reported as
+ * missing signatures. In the template flow they are empty and the verified
+ * result's `detail.missing` describes what is still unfulfilled; acting on it
+ * (signing, rebuilding calldata) is up to the consumer.
+ *
+ * Returns nothing for non-RWA markets.
+ */
+export declare function buildRWAPrerequisites(multicall: InnerOperation[], creditManager: Address, providedArgs: RWAOperationArgs, ctx: PrerequisiteContext): Prerequisite[];

package/dist/types/preview/prerequisites/checkPrerequisites.d.ts

@@ -0,0 +1,19 @@
+import type { PluginsMap } from "../../sdk/index.js";
+import type { PreviewOperationInput, PreviewOperationOptions } from "../types.js";
+import type { PrerequisiteResult } from "./types.js";
+/**
+ * Derives and verifies the on-chain prerequisites for an operation given its
+ * raw calldata: the conditions that must hold for the call not to revert and
+ * that we can verify with the SDK (token approvals, wallet balances, RWA
+ * open-account requirements).
+ *
+ * Each prerequisite performs its own reads and resolves into a
+ * {@link PrerequisiteResult} (`satisfied` or `error`).
+ *
+ * Only *sender-actionable* prerequisites belong here: conditions the LP
+ * provider or borrower can fix themselves before retrying (e.g. approve a
+ * token, sign the RWA factory's messages). Non-actionable protocol/admin state
+ * (e.g. pool is paused) is intentionally out of scope, since the user cannot
+ * resolve it.
+ */
+export declare function checkPrerequisites<P extends PluginsMap>(input: PreviewOperationInput<P>, options?: PreviewOperationOptions): Promise<PrerequisiteResult[]>;

package/dist/types/preview/prerequisites/helpers.d.ts

@@ -0,0 +1,7 @@
+import { type AllowanceDetail } from "./AllowancePrerequisite.js";
+import type { Prerequisite } from "./Prerequisite.js";
+/**
+ * The most common prerequisite pair: `owner` must have approved `spender` for
+ * `required` of `token` and must hold at least that much of it.
+ */
+export declare function allowanceAndBalance(props: Omit<AllowanceDetail, "actual">): Prerequisite[];

package/dist/types/preview/prerequisites/index.d.ts

@@ -1,7 +1,6 @@
 export * from "./AllowancePrerequisite.js";
 export * from "./BalancePrerequisite.js";
-export * from "./buildPrerequisites.js";
+export * from "./checkPrerequisites.js";
 export * from "./Prerequisite.js";
-export * from "./prepareAction.js";
-export * from "./runPrerequisites.js";
+export * from "./RWAOpenRequirementsPrerequisite.js";
 export * from "./types.js";

package/dist/types/preview/prerequisites/types.d.ts

@@ -1,40 +1,8 @@
 import type { Address } from "viem";
 import type { OnchainSDK } from "../../sdk/index.js";
-/**
- * Extension point that ties each prerequisite kind to its detail payload.
- *
- * Adding a new prerequisite kind only requires a new entry here: the generic
- * machinery below and the UI renderer registry both key off this map, so TS
- * forces every consumer to handle the new kind.
- *
- * IMPORTANT: only add prerequisites that are *actionable by the transaction
- * sender* (the LP provider or borrower). A valid prerequisite is one the user
- * can resolve themselves before retrying, e.g. approve a token (`allowance`)
- * or acquire/free up funds (`balance`). Do NOT add protocol- or admin-level
- * state the user cannot change, such as pool pause status or available pool
- * liquidity; those are not actionable and must not be listed as prerequisites.
- */
-export interface PrerequisiteDetailMap {
-    /** ERC-20 allowance from `owner` to `spender` must cover `required`. */
-    allowance: {
-        token: Address;
-        owner: Address;
-        spender: Address;
-        required: bigint;
-        /** On-chain allowance read; only present when the read succeeded. */
-        actual?: bigint;
-    };
-    /** ERC-20 balance of `owner` must cover `required`. */
-    balance: {
-        token: Address;
-        owner: Address;
-        required: bigint;
-        /** On-chain balance read; only present when the read succeeded. */
-        actual?: bigint;
-    };
-}
-export type PrerequisiteKind = keyof PrerequisiteDetailMap;
-export type PrerequisiteDetail<K extends PrerequisiteKind = PrerequisiteKind> = PrerequisiteDetailMap[K];
+import type { AllowanceResult } from "./AllowancePrerequisite.js";
+import type { BalanceResult } from "./BalancePrerequisite.js";
+import type { RWAOpenRequirementsResult } from "./RWAOpenRequirementsPrerequisite.js";
 /** Failure of the underlying on-chain read (revert, decode error, RPC error). */
 export interface PrerequisiteError {
     /** Decoded revert reason / error name, human-readable. */
@@ -42,32 +10,27 @@ export interface PrerequisiteError {
     /** Original error, kept for debugging. */
     cause?: unknown;
 }
-export interface PrerequisiteBase<K extends PrerequisiteKind> {
-    id: string;
-    kind: K;
-    title: string;
-    detail: PrerequisiteDetail<K>;
-}
 /**
  * Outcome of verifying a single prerequisite: either the read succeeded (a
  * `satisfied` boolean) or it reverted/failed (an `error` with the revert
- * reason). The two variants are mutually exclusive.
+ * reason).
  */
-export type PrerequisiteResult<K extends PrerequisiteKind = PrerequisiteKind> = PrerequisiteBase<K> & ({
+export type PrerequisiteOutcome = {
     satisfied: boolean;
     error?: undefined;
 } | {
     satisfied?: undefined;
     error: PrerequisiteError;
-});
+};
 /**
- * Discriminated union over every prerequisite kind. Switching on `kind`
- * narrows `detail` to the matching payload, so React components can render
- * kind-specific details with full type safety.
+ * Discriminated union over every prerequisite kind
+ *
+ * Only add prerequisites that are actionable by tx sender.
+ * A valid prerequisite is one the user can resolve themselves before retrying,
+ * e.g. approve a token (`allowance`) or perform offchain KYC verification.
  */
-export type AnyPrerequisiteResult = {
-    [K in PrerequisiteKind]: PrerequisiteResult<K>;
-}[PrerequisiteKind];
+export type PrerequisiteResult = AllowanceResult | BalanceResult | RWAOpenRequirementsResult;
+export type PrerequisiteKind = PrerequisiteResult["kind"];
 /** Shared inputs for building and verifying prerequisites. */
 export interface PrerequisiteContext {
     sdk: OnchainSDK;

package/dist/types/preview/preview/CreditAccountState.d.ts

@@ -0,0 +1,83 @@
+import type { Address } from "viem";
+import { AssetsMap, type CreditAccountData } from "../../sdk/index.js";
+/**
+ * Constructor properties of {@link CreditAccountState}.
+ */
+export interface CreditAccountStateProps {
+    creditAccount: Address;
+    creditManager: Address;
+    underlying: Address;
+    balances?: AssetsMap;
+    quotas?: AssetsMap;
+    debt?: bigint;
+    totalDebt?: bigint;
+}
+/**
+ * A snapshot of a credit account's economic state (balances, quotas, debt)
+ * as used by operation previews, together with the account's identity.
+ *
+ * Used both as the pre-state seed of a multicall replay and as the running
+ * post-state mutated by it; changes are derived by diffing two snapshots.
+ */
+export declare class CreditAccountState {
+    creditAccount: Address;
+    creditManager: Address;
+    /**
+     * Credit manager underlying
+     */
+    underlying: Address;
+    /**
+     * Per-token balances
+     */
+    balances: AssetsMap;
+    /**
+     * Per-token quotas
+     */
+    quotas: AssetsMap;
+    /**
+     * Debt principal
+     */
+    debt: bigint;
+    /**
+     * Total debt: principal + accrued interest + accrued fees.
+     * `decreaseDebt` amounts operate on total debt (interest and fees are
+     * repaid before principal), so principal alone is not enough to resolve
+     * either the underlying balance decrement or the final principal.
+     */
+    totalDebt: bigint;
+    constructor(props: CreditAccountStateProps);
+    /**
+     * The account-opening seed: everything zero/empty. The account doesn't
+     * exist yet at preview time, so `creditAccount` is the zero address;
+     * opening previews take identity from the parsed operation instead.
+     */
+    static beforeOpen(creditManager: Address, underlying: Address): CreditAccountState;
+    /**
+     * Pre-state of an existing account from its on-chain data, with dust
+     * balances and quotas (≤ 1 wei) filtered out.
+     */
+    static fromCreditAccountData(ca: CreditAccountData): CreditAccountState;
+    clone(): CreditAccountState;
+    /**
+     * Borrows `amount` of underlying: debt, total debt and the underlying
+     * balance all increase by it.
+     */
+    increaseDebt(amount: bigint): void;
+    /**
+     * Repays up to `amount` of underlying against the debt, clamped to the
+     * total debt (the facade never repays more than is owed). Interest and
+     * fees are repaid before principal (CreditLogic.calcDecrease), so
+     * principal only decreases once total debt drops below it. The underlying
+     * balance decreases by the repaid amount.
+     *
+     * @returns The actually repaid (post-clamp) amount.
+     */
+    repay(amount: bigint): bigint;
+    /**
+     * Applies a relative `updateQuota` change to the token's quota:
+     * `MIN_INT96` is the facade "disable quota" sentinel and zeroes it, other
+     * changes are added with the result clamped at zero (quotas cannot go
+     * negative on-chain).
+     */
+    updateQuota(token: Address, change: bigint): void;
+}

package/dist/types/preview/preview/applyRWAWrapUnwrap.d.ts

@@ -0,0 +1,13 @@
+import { type Hex } from "viem";
+import type { ERC4626AdapterContract } from "../../plugins/adapters/index.js";
+import type { AssetsMap } from "../../sdk/index.js";
+/**
+ * Applies an RWA wrap/unwrap adapter call (ERC4626 `deposit`/`redeem` and
+ * their diff variants, as emitted by `CreditAccountsServiceV310`) to the
+ * running credit-account balances.
+ *
+ * RWA underlyings always convert 1-to-1 with their vault asset, so the
+ * counterpart amount equals the input amount and no on-chain preview read is
+ * needed.
+ */
+export declare function applyRWAWrapUnwrap(adapter: ERC4626AdapterContract, calldata: Hex, balances: AssetsMap): void;

package/dist/types/preview/preview/buildDelayedPreview.d.ts

@@ -0,0 +1,41 @@
+import { type Address } from "viem";
+import type { CreditAccountState } from "./CreditAccountState.js";
+import type { DetectedDelayedOperation } from "./detectDelayedOperation.js";
+import { type InstantOperationPreview } from "./types.js";
+/**
+ * Oracle conversion, injected so unit tests don't need a market
+ */
+export type ConvertFn = (token: Address, to: Address, amount: bigint) => bigint;
+/**
+ * Builds the best-effort preview of the account state after the detected
+ * delayed withdrawal is claimed and its intent (if any) is resumed.
+ *
+ * Pure function: reads the post-instant account state, never mutates it and
+ * performs no network access. Swaps that the resume flow would route through
+ * the router are estimated with the injected oracle conversion; tokens the
+ * oracle cannot price contribute nothing and set a non-fatal
+ * `ERROR_UNPRICEABLE_TOKEN` error on the preview.
+ *
+ * Common claim step (all intents): the phantom token is burned (balance and
+ * quota zeroed) and the claim token is credited with the same amount 1:1.
+ *
+ * Intent-specific resume:
+ * - `CLOSE_ACCOUNT`: everything is swapped into the underlying, the debt is
+ *   fully repaid and the rest is withdrawn to the user.
+ * - `DECREASE_LEVERAGE`: the claimed amount is swapped into the underlying
+ *   and used to decrease the debt.
+ * - `WITHDRAW_COLLATERAL`: the recorded amount of the recorded token is
+ *   withdrawn to the user, the rest of the claimed amount decreases the debt.
+ * - other intents and `intent: undefined`: claim-only, the post-claim swap
+ *   target is not recoverable from the intent.
+ *
+ * The changes (`debtChange`, `quotasChange`, `assetsChange`) are reported
+ * relative to the account state before the whole transaction, not the
+ * post-instant state: to the user the delayed preview answers "where will
+ * the account end up compared to now", so the transient phantom token
+ * (minted by the instant part, burned by the claim) nets out to nothing.
+ *
+ * @param state - Account state after the instant part of the transaction.
+ * @param before - Account state before the transaction (the diff base).
+ */
+export declare function buildDelayedPreview(state: CreditAccountState, before: CreditAccountState, detected: DetectedDelayedOperation, convert: ConvertFn): InstantOperationPreview;

package/dist/types/preview/preview/detectCloseOrRepay.d.ts

@@ -0,0 +1,18 @@
+import type { Address } from "viem";
+import type { InnerOperation } from "../parse/index.js";
+/**
+ * Detects whether a credit-facade multicall fully closes or repays the
+ * account.
+ *
+ * Note that closing/repaying an account whose debt is already zero emits no
+ * `decreaseDebt` call at all and is not detected (previews as an adjustment).
+ */
+export declare function isCloseOrRepay(multicall: InnerOperation[]): boolean;
+/**
+ * Distinguishes a closure from a repayment by how collateral leaves the
+ * account:
+ * - close swaps all assets into underlying and withdraws only the underlying
+ * - repay returns collateral in-kind: it adds collateral from the wallet to
+ *   cover the debt and/or withdraws non-underlying tokens.
+ */
+export declare function classifyCloseOrRepay(multicall: InnerOperation[], underlying: Address): "close" | "repay";

package/dist/types/preview/preview/detectDelayedOperation.d.ts

@@ -0,0 +1,29 @@
+import { type DelayedWithdrawalRequest, type SdkWithAdapters } from "../../plugins/adapters/index.js";
+import { type DelayedIntent, type PluginsMap } from "../../sdk/index.js";
+import type { InnerOperation } from "../parse/index.js";
+/**
+ * A delayed-withdrawal request detected in a credit-facade multicall,
+ * produced by `detectDelayedOperation`.
+ */
+export interface DetectedDelayedOperation {
+    /**
+     * Phantom/claim tokens from the adapter's `parseDelayedWithdrawalRequest`
+     */
+    request: DelayedWithdrawalRequest;
+    /**
+     * Decoded delayed intent; undefined when the request carries none, in
+     * which case the delayed preview is claim-only
+     */
+    intent?: DelayedIntent;
+}
+/**
+ * Scans a credit-facade multicall for a delayed-withdrawal request.
+ *
+ * @param sdk - SDK with the adapters plugin attached.
+ * @param multicall - Parsed inner operations of the multicall.
+ * @returns The detected request, or `undefined` when
+ * the multicall contains no delayed-withdrawal request.
+ * @throws InvalidDelayedIntentError when a request carries non-empty
+ * `extraData` that cannot be decoded as a `DelayedIntent`.
+ */
+export declare function detectDelayedOperation<P extends PluginsMap>(sdk: SdkWithAdapters<P>, multicall: InnerOperation[]): DetectedDelayedOperation | undefined;

package/dist/types/preview/preview/errors.d.ts

@@ -0,0 +1,24 @@
+import type { Address, Hex } from "viem";
+/**
+ * Thrown by `previewOperation` for parsed operations it cannot preview yet.
+ * Currently only pool operations and credit account opening are supported.
+ */
+export declare class UnsupportedOperationError extends Error {
+    /** The parsed operation kind (the `operation` discriminant). */
+    readonly operation: string;
+    constructor(operation: string);
+}
+/**
+ * Thrown when a delayed-withdrawal request carries non-empty `extraData`
+ * that cannot be decoded as a `DelayedIntent`. Requests produced by our
+ * stack always encode a valid intent, so garbage here means a
+ * malformed/foreign transaction that must not be previewed as if it were
+ * fine.
+ */
+export declare class InvalidDelayedIntentError extends Error {
+    /** Adapter the withdrawal request was addressed to. */
+    readonly adapter: Address;
+    /** Raw `extraData` that failed to decode. */
+    readonly extraData: Hex;
+    constructor(adapter: Address, extraData: Hex, cause?: unknown);
+}

package/dist/types/preview/preview/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./buildDelayedPreview.js";
+export * from "./CreditAccountState.js";
+export * from "./detectCloseOrRepay.js";
+export * from "./detectDelayedOperation.js";
+export * from "./errors.js";
+export * from "./previewAdjustCreditAccount.js";
+export * from "./previewCloseOrRepayCreditAccount.js";
+export * from "./previewOperation.js";
+export * from "./replayInnerOperations.js";
+export * from "./replayMulticall.js";
+export * from "./types.js";

package/dist/types/preview/preview/previewAdjustCreditAccount.d.ts

@@ -0,0 +1,12 @@
+import { type PluginsMap } from "../../sdk/index.js";
+import type { MulticallOperation, RWAMulticallOperation } from "../parse/index.js";
+import type { PreviewOperationInput, PreviewOperationOptions } from "../types.js";
+import { type AdjustCreditAccountPreview } from "./types.js";
+/**
+ * Previews a `multicall`/`botMulticall` operation on an existing credit
+ * account: threads the multicall through {@link replayMulticall} over the
+ * pre-resolved account state (`options.creditAccount`) and reports the
+ * minimal guaranteed post-state alongside the changes relative to the
+ * pre-state.
+ */
+export declare function previewAdjustCreditAccount<P extends PluginsMap>(input: PreviewOperationInput<P>, operation: MulticallOperation | RWAMulticallOperation, options: PreviewOperationOptions<true>): Promise<AdjustCreditAccountPreview>;

package/dist/types/preview/preview/previewCloseOrRepayCreditAccount.d.ts

@@ -0,0 +1,11 @@
+import { type PluginsMap } from "../../sdk/index.js";
+import type { CloseCreditAccountOperation, MulticallOperation, RWAMulticallOperation } from "../parse/index.js";
+import type { PreviewOperationInput, PreviewOperationOptions } from "../types.js";
+import type { CloseCreditAccountPreview, RepayCreditAccountPreview } from "./types.js";
+/**
+ * Any parsed operation that fully closes or repays a credit account: the
+ * facade `closeCreditAccount` entry point (permanent closure) or a plain
+ * multicall detected by `isCloseOrRepay` (zero-debt closure/repay).
+ */
+export type CloseOrRepayOperation = CloseCreditAccountOperation | MulticallOperation | RWAMulticallOperation;
+export declare function previewCloseOrRepayCreditAccount<P extends PluginsMap>(input: PreviewOperationInput<P>, operation: CloseOrRepayOperation, permanent: boolean, options: PreviewOperationOptions<true>): Promise<CloseCreditAccountPreview | RepayCreditAccountPreview>;

package/dist/types/preview/preview/previewOpenCreditAccount.d.ts

@@ -0,0 +1,5 @@
+import { type PluginsMap } from "../../sdk/index.js";
+import type { OpenCreditAccountOperation, RWAOpenCreditAccountOperation } from "../parse/index.js";
+import type { PreviewOperationInput } from "../types.js";
+import { type OpenCreditAccountPreview } from "./types.js";
+export declare function previewOpenCreditAccount<P extends PluginsMap>(input: PreviewOperationInput<P>, operation: OpenCreditAccountOperation | RWAOpenCreditAccountOperation): Promise<OpenCreditAccountPreview>;

package/dist/types/preview/preview/previewOperation.d.ts

@@ -0,0 +1,8 @@
+import type { PluginsMap } from "../../sdk/index.js";
+import type { PreviewOperationInput, PreviewOperationOptions } from "../types.js";
+import type { OperationPreview } from "./types.js";
+/**
+ * Previews a raw operation calldata: decodes it into a typed operation and
+ * assembles an operation-specific, human-displayable preview.
+ */
+export declare function previewOperation<P extends PluginsMap = PluginsMap>(input: PreviewOperationInput<P>, options?: PreviewOperationOptions): Promise<OperationPreview>;

package/dist/types/preview/preview/previewPoolOperation.d.ts

@@ -0,0 +1,5 @@
+import type { PluginsMap } from "../../sdk/index.js";
+import type { PoolOperation } from "../parse/index.js";
+import type { PreviewOperationInput, PreviewOperationOptions } from "../types.js";
+import type { PoolOperationPreview } from "./types.js";
+export declare function previewPoolOperation<P extends PluginsMap>(input: PreviewOperationInput<P>, operation: PoolOperation, options?: PreviewOperationOptions): Promise<PoolOperationPreview>;

package/dist/types/preview/preview/replayInnerOperations.d.ts

@@ -0,0 +1,44 @@
+import { type SdkWithAdapters } from "../../plugins/adapters/index.js";
+import { AssetsMap, type PluginsMap } from "../../sdk/index.js";
+import type { InnerOperation } from "../parse/index.js";
+import type { CreditAccountState } from "./CreditAccountState.js";
+import { type OperationPreviewError } from "./types.js";
+/**
+ * Running state threaded through a credit-facade multicall by
+ * {@link replayInnerOperations}: the account's post-state being mutated in
+ * facade execution order, plus per-multicall bookkeeping that is not account
+ * state (what was added from / withdrawn to the wallet).
+ */
+export interface ReplayState {
+    /**
+     * Running account state, mutated in facade execution order. Seeded by the
+     * caller: `CreditAccountState.beforeOpen` for account opening, a clone of
+     * `CreditAccountState.fromCreditAccountData` for an existing account.
+     */
+    account: CreditAccountState;
+    /**
+     * Cumulative amounts added via `addCollateral`.
+     */
+    collateralAdded: AssetsMap;
+    /**
+     * Cumulative amounts withdrawn via `withdrawCollateral`, with `MAX_UINT256`
+     * resolved against the running balance at the point of the call.
+     */
+    collateralWithdrawn: AssetsMap;
+}
+/**
+ * Creates a {@link ReplayState} around the given account seed, with empty
+ * bookkeeping.
+ */
+export declare function makeReplayState(account: CreditAccountState): ReplayState;
+/**
+ * Replays a credit-facade multicall over `state`, mutating it in place in
+ * facade execution order. The result is the *minimal guaranteed* post-state.
+ *
+ * The function assumes that the call was generated by our frontend using
+ * router/withdrawal compressor, otherwise it returns an error, but still
+ * proceeds best-effort.
+ *
+ * @returns `undefined` on success, the error on a malformed multicall.
+ */
+export declare function replayInnerOperations<P extends PluginsMap>(sdk: SdkWithAdapters<P>, multicall: InnerOperation[], state: ReplayState): Promise<OperationPreviewError | undefined>;