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

package/dist/esm/preview/preview/previewCloseOrRepayCreditAccount.js

@@ -1,27 +1,24 @@
-import {
-  AP_WETH_TOKEN,
-  NO_VERSION
-} from "../../sdk/index.js";
-import {
-  applyInnerOperations,
-  makeInnerOperationsState
-} from "./applyInnerOperations.js";
+import { AP_WETH_TOKEN, NO_VERSION } from "../../sdk/index.js";
 import { classifyCloseOrRepay } from "./detectCloseOrRepay.js";
+import {
+  replayMulticall
+} from "./replayMulticall.js";
 import { unwrapNativeCollateral } from "./unwrapNativeCollateral.js";
 async function previewCloseOrRepayCreditAccount(input, operation, permanent, options) {
   const { sdk } = input;
   const market = sdk.marketRegister.findByCreditManager(
     operation.creditManager
   );
+  const replay = await replayMulticall(sdk, operation, options);
   const kind = classifyCloseOrRepay(operation.multicall, market.underlying);
-  return kind === "close" ? previewCloseCreditAccount(input, operation, permanent, options) : previewRepayCreditAccount(input, operation, permanent, options);
+  return kind === "close" ? previewCloseCreditAccount(input, operation, permanent, replay) : previewRepayCreditAccount(input, operation, permanent, replay);
 }
-async function previewCloseCreditAccount(input, operation, permanent, options) {
+function previewCloseCreditAccount(input, operation, permanent, replay) {
   const { sdk } = input;
   const market = sdk.marketRegister.findByCreditManager(
     operation.creditManager
   );
-  const { state, error } = await replayMulticall(sdk, operation, options);
+  const { after, error } = replay;
   return {
     operation: "CloseCreditAccount",
     permanent,
@@ -29,59 +26,32 @@ async function previewCloseCreditAccount(input, operation, permanent, options) {
     creditAccount: operation.creditAccount,
     // On a malformed multicall the withdrawn amount depends on best-effort
     // replayed balances and may be unreliable
-    receivedAmount: state.collateralWithdrawn.getOrZero(market.underlying),
+    receivedAmount: after.collateralWithdrawn.getOrZero(market.underlying),
     error
   };
 }
-async function previewRepayCreditAccount(input, operation, permanent, options) {
+function previewRepayCreditAccount(input, operation, permanent, replay) {
   const { sdk, value = 0n } = input;
-  const {
-    ca,
-    state,
-    error: replayError
-  } = await replayMulticall(sdk, operation, options);
+  const { before, after, error: replayError } = replay;
   const { assets: collateralAdded, error: unwrapError } = unwrapNativeCollateral(
-    state.collateralAdded.toAssets(),
+    after.collateralAdded.toAssets(),
     value,
     sdk.addressProvider.getAddress(AP_WETH_TOKEN, NO_VERSION)
   );
   const error = replayError ?? unwrapError;
-  const initialTotalDebt = ca.debt + ca.accruedInterest + ca.accruedFees;
   return {
     operation: "RepayCreditAccount",
     permanent,
     creditManager: operation.creditManager,
     creditAccount: operation.creditAccount,
     collateralAdded,
-    debtRepaid: initialTotalDebt - state.totalDebt,
+    debtRepaid: before.totalDebt - after.account.totalDebt,
     // On a malformed multicall the MAX_UINT256 withdrawal sentinel resolves
     // against best-effort replayed balances and may be unreliable
-    collateralWithdrawn: state.collateralWithdrawn.toAssets(),
+    collateralWithdrawn: after.collateralWithdrawn.toAssets(),
     error
   };
 }
-async function replayMulticall(sdk, operation, options) {
-  let ca = options?.creditAccount;
-  if (!ca) {
-    ca = await sdk.accounts.getCreditAccountData(
-      operation.creditAccount,
-      options?.blockNumber
-    );
-  }
-  if (!ca) {
-    throw new Error(`credit account ${operation.creditAccount} not found`);
-  }
-  const state = makeInnerOperationsState();
-  for (const t of ca.tokens) {
-    if (t.balance > 1n) {
-      state.balances.upsert(t.token, t.balance);
-    }
-  }
-  state.debt = ca.debt;
-  state.totalDebt = ca.debt + ca.accruedInterest + ca.accruedFees;
-  const error = await applyInnerOperations(sdk, operation.multicall, state);
-  return { ca, state, error };
-}
 export {
   previewCloseOrRepayCreditAccount
 };

package/dist/esm/preview/preview/previewOpenCreditAccount.js

@@ -2,10 +2,11 @@ import {
   AP_WETH_TOKEN,
   NO_VERSION
 } from "../../sdk/index.js";
+import { CreditAccountState } from "./CreditAccountState.js";
 import {
-  applyInnerOperations,
-  makeInnerOperationsState
-} from "./applyInnerOperations.js";
+  makeReplayState,
+  replayInnerOperations
+} from "./replayInnerOperations.js";
 import {
   ERROR_UNPRICEABLE_TOKEN
 } from "./types.js";
@@ -15,8 +16,11 @@ async function previewOpenCreditAccount(input, operation) {
   const market = sdk.marketRegister.findByCreditManager(
     operation.creditManager
   );
-  const state = makeInnerOperationsState();
-  let error = await applyInnerOperations(sdk, operation.multicall, state);
+  const state = makeReplayState(
+    CreditAccountState.beforeOpen(operation.creditManager, market.underlying)
+  );
+  let error = await replayInnerOperations(sdk, operation.multicall, state);
+  const account = state.account;
   let priceError;
   const collateralValue = state.collateralAdded.sum((token, balance) => {
     try {
@@ -35,16 +39,17 @@ async function previewOpenCreditAccount(input, operation) {
     sdk.addressProvider.getAddress(AP_WETH_TOKEN, NO_VERSION)
   );
   error ??= unwrapError ?? priceError;
-  const assets = state.balances.toAssets(1n);
+  const assets = account.balances.toAssets(1n);
   return {
     operation: operation.operation,
     creditManager: operation.creditManager,
-    target: inferTargetAsset(operation.multicall, state.balances),
+    target: inferTargetAsset(operation.multicall, account.balances),
     collateral,
     collateralValue,
-    debt: state.debt,
-    // On opening, initial quotas are zero, so the raw changes are the quotas.
-    quotas: state.quotaChanges,
+    debt: account.debt,
+    // On opening, initial quotas are zero, so the folded quotas are the
+    // applied changes.
+    quotas: account.quotas.toAssets(0n),
     assets,
     error
   };

package/dist/esm/preview/preview/previewOperation.js

@@ -1,10 +1,18 @@
-import { isPoolOperation, parseOperationCalldata } from "../parse/index.js";
+import {
+  isPoolOperation,
+  parseOperationCalldata
+} from "../parse/index.js";
+import { buildDelayedPreview } from "./buildDelayedPreview.js";
 import { isCloseOrRepay } from "./detectCloseOrRepay.js";
+import { detectDelayedOperation } from "./detectDelayedOperation.js";
 import { UnsupportedOperationError } from "./errors.js";
 import { previewAdjustCreditAccount } from "./previewAdjustCreditAccount.js";
 import { previewCloseOrRepayCreditAccount } from "./previewCloseOrRepayCreditAccount.js";
 import { previewOpenCreditAccount } from "./previewOpenCreditAccount.js";
 import { previewPoolOperation } from "./previewPoolOperation.js";
+import {
+  replayMulticall
+} from "./replayMulticall.js";
 async function previewOperation(input, options) {
   const operation = parseOperationCalldata(input);
   if (isPoolOperation(operation)) {
@@ -14,16 +22,54 @@ async function previewOperation(input, options) {
     return previewOpenCreditAccount(input, operation);
   }
   if (operation.operation === "CloseCreditAccount") {
-    return previewCloseOrRepayCreditAccount(input, operation, true, options);
+    const resolved = await resolveCreditAccount(input, operation, options);
+    return previewCloseOrRepayCreditAccount(input, operation, true, resolved);
   }
   if (operation.operation === "MultiCall" || operation.operation === "BotMulticall" || operation.operation === "RWAMulticall") {
-    if (isCloseOrRepay(operation.multicall)) {
-      return previewCloseOrRepayCreditAccount(input, operation, false, options);
-    }
-    return previewAdjustCreditAccount(input, operation, options);
+    const resolved = await resolveCreditAccount(input, operation, options);
+    return previewMulticallOperation(input, operation, resolved);
   }
   throw new UnsupportedOperationError(operation.operation);
 }
+async function resolveCreditAccount(input, operation, options) {
+  let creditAccount = options?.creditAccount;
+  if (!creditAccount) {
+    creditAccount = await input.sdk.accounts.getCreditAccountData(
+      operation.creditAccount,
+      options?.blockNumber
+    );
+  }
+  if (!creditAccount) {
+    throw new Error(`credit account ${operation.creditAccount} not found`);
+  }
+  return { ...options, creditAccount };
+}
+async function previewMulticallOperation(input, operation, options) {
+  const { sdk } = input;
+  const instantPreview = isCloseOrRepay(operation.multicall) ? await previewCloseOrRepayCreditAccount(input, operation, false, options) : await previewAdjustCreditAccount(input, operation, options);
+  const delayed = detectDelayedOperation(sdk, operation.multicall);
+  if (!delayed) {
+    return instantPreview;
+  }
+  const { before, after } = await replayMulticall(sdk, operation, options);
+  const market = sdk.marketRegister.findByCreditManager(
+    operation.creditManager
+  );
+  const convert = (token, to, amount) => market.priceOracle.convert(token, to, amount);
+  return {
+    operation: "DelayedCreditAccountOperation",
+    creditAccount: operation.creditAccount,
+    creditManager: operation.creditManager,
+    intent: delayed.intent,
+    instantPreview,
+    delayedPreview: buildDelayedPreview(
+      after.account,
+      before,
+      delayed,
+      convert
+    )
+  };
+}
 export {
   previewOperation
 };

package/dist/esm/preview/preview/{applyInnerOperations.js → replayInnerOperations.js}

@@ -2,10 +2,7 @@ import {
   AbstractAdapterContract,
   ERC4626AdapterContract
 } from "../../plugins/adapters/index.js";
-import {
-  AssetsMap,
-  MAX_UINT256
-} from "../../sdk/index.js";
+import { AssetsMap, MAX_UINT256 } from "../../sdk/index.js";
 import { applyRWAWrapUnwrap } from "./applyRWAWrapUnwrap.js";
 import {
   ERROR_ADAPTER_CALL_OUTSIDE_BRACKET,
@@ -14,17 +11,14 @@ import {
   ERROR_UNPREVIEWABLE_ADAPTER_CALL,
   ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP
 } from "./types.js";
-function makeInnerOperationsState() {
+function makeReplayState(account) {
   return {
-    balances: new AssetsMap(),
-    debt: 0n,
-    totalDebt: 0n,
+    account,
     collateralAdded: new AssetsMap(),
-    collateralWithdrawn: new AssetsMap(),
-    quotaChanges: []
+    collateralWithdrawn: new AssetsMap()
   };
 }
-async function applyInnerOperations(sdk, multicall, state) {
+async function replayInnerOperations(sdk, multicall, state) {
   let inBracket = false;
   let error;
   for (const op of multicall) {
@@ -37,13 +31,13 @@ async function applyInnerOperations(sdk, multicall, state) {
         applyWithdrawCollateral(state, op);
         break;
       case "IncreaseBorrowedAmount":
-        applyIncreaseDebt(state, op);
+        state.account.increaseDebt(op.amount);
         break;
       case "DecreaseBorrowedAmount":
-        applyDecreaseDebt(state, op);
+        state.account.repay(op.amount);
         break;
       case "UpdateQuota":
-        state.quotaChanges.push({ token: op.token, balance: op.change });
+        state.account.updateQuota(op.token, op.change);
         break;
       case "StoreExpectedBalances":
         if (inBracket) {
@@ -54,7 +48,7 @@ async function applyInnerOperations(sdk, multicall, state) {
         }
         inBracket = true;
         for (const { token, balance } of op.deltas) {
-          state.balances.inc(token, balance);
+          state.account.balances.inc(token, balance);
         }
         break;
       case "CompareBalances":
@@ -67,7 +61,12 @@ async function applyInnerOperations(sdk, multicall, state) {
         inBracket = false;
         break;
       case "Execute":
-        opError = await applyExecute(sdk, op, inBracket, state.balances);
+        opError = await applyExecute(
+          sdk,
+          op,
+          inBracket,
+          state.account.balances
+        );
         break;
     }
     error ??= opError;
@@ -82,27 +81,14 @@ async function applyInnerOperations(sdk, multicall, state) {
 }
 function applyAddCollateral(state, op) {
   state.collateralAdded.inc(op.token, op.amount);
-  state.balances.inc(op.token, op.amount);
+  state.account.balances.inc(op.token, op.amount);
 }
 function applyWithdrawCollateral(state, op) {
-  const running = state.balances.getOrZero(op.token);
+  const running = state.account.balances.getOrZero(op.token);
   const amount = op.amount === MAX_UINT256 ? running > 0n ? running : 0n : op.amount;
-  state.balances.dec(op.token, amount);
+  state.account.balances.dec(op.token, amount);
   state.collateralWithdrawn.inc(op.token, amount);
 }
-function applyIncreaseDebt(state, op) {
-  state.debt += op.amount;
-  state.totalDebt += op.amount;
-  state.balances.inc(op.token, op.amount);
-}
-function applyDecreaseDebt(state, op) {
-  const repaid = op.amount > state.totalDebt ? state.totalDebt : op.amount;
-  state.balances.dec(op.token, repaid);
-  state.totalDebt -= repaid;
-  if (state.debt > state.totalDebt) {
-    state.debt = state.totalDebt;
-  }
-}
 async function applyExecute(sdk, op, inBracket, balances) {
   const adapter = sdk.getContract(op.adapter);
   if (!inBracket) {
@@ -146,6 +132,6 @@ function isRWAShare(sdk, adapter) {
   return false;
 }
 export {
-  applyInnerOperations,
-  makeInnerOperationsState
+  makeReplayState,
+  replayInnerOperations
 };

package/dist/esm/preview/preview/replayMulticall.js

@@ -0,0 +1,16 @@
+import { CreditAccountState } from "./CreditAccountState.js";
+import {
+  makeReplayState,
+  replayInnerOperations
+} from "./replayInnerOperations.js";
+async function replayMulticall(sdk, operation, options) {
+  const before = CreditAccountState.fromCreditAccountData(
+    options.creditAccount
+  );
+  const after = makeReplayState(before.clone());
+  const error = await replayInnerOperations(sdk, operation.multicall, after);
+  return { before, after, error };
+}
+export {
+  replayMulticall
+};

package/dist/esm/preview/preview/types.js

@@ -5,6 +5,7 @@ const ERROR_UNPREVIEWABLE_ADAPTER_CALL = 1004;
 const ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP = 1005;
 const ERROR_INVALID_TRANSACTION_VALUE = 1006;
 const ERROR_UNPRICEABLE_TOKEN = 2001;
+const PREVIEW_DUST = 10n;
 export {
   ERROR_ADAPTER_CALL_OUTSIDE_BRACKET,
   ERROR_INVALID_TRANSACTION_VALUE,
@@ -12,5 +13,6 @@ export {
   ERROR_NON_ADAPTER_CALL_IN_BRACKET,
   ERROR_UNPREVIEWABLE_ADAPTER_CALL,
   ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP,
-  ERROR_UNPRICEABLE_TOKEN
+  ERROR_UNPRICEABLE_TOKEN,
+  PREVIEW_DUST
 };

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

@@ -1,3 +1,4 @@
+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.
@@ -7,3 +8,17 @@ export declare class UnsupportedOperationError extends Error {
     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

@@ -1,8 +1,11 @@
-export * from "./applyInnerOperations.js";
-export * from "./applyQuotaChanges.js";
+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

@@ -4,9 +4,9 @@ import type { PreviewOperationInput, PreviewOperationOptions } from "../types.js
 import { type AdjustCreditAccountPreview } from "./types.js";
 /**
  * Previews a `multicall`/`botMulticall` operation on an existing credit
- * account: fetches the account's pre-state (unless provided via options),
- * threads the multicall through {@link applyInnerOperations} and reports the
+ * 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): Promise<AdjustCreditAccountPreview>;
+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

@@ -1,11 +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 { OperationPreview } 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): Promise<OperationPreview>;
+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/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>;