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

package/dist/cjs/preview/preview/previewOperation.js

@@ -22,12 +22,15 @@ __export(previewOperation_exports, {
 });
 module.exports = __toCommonJS(previewOperation_exports);
 var import_parse = require("../parse/index.js");
+var import_buildDelayedPreview = require("./buildDelayedPreview.js");
 var import_detectCloseOrRepay = require("./detectCloseOrRepay.js");
+var import_detectDelayedOperation = require("./detectDelayedOperation.js");
 var import_errors = require("./errors.js");
 var import_previewAdjustCreditAccount = require("./previewAdjustCreditAccount.js");
 var import_previewCloseOrRepayCreditAccount = require("./previewCloseOrRepayCreditAccount.js");
 var import_previewOpenCreditAccount = require("./previewOpenCreditAccount.js");
 var import_previewPoolOperation = require("./previewPoolOperation.js");
+var import_replayMulticall = require("./replayMulticall.js");
 async function previewOperation(input, options) {
   const operation = (0, import_parse.parseOperationCalldata)(input);
   if ((0, import_parse.isPoolOperation)(operation)) {
@@ -37,16 +40,54 @@ async function previewOperation(input, options) {
     return (0, import_previewOpenCreditAccount.previewOpenCreditAccount)(input, operation);
   }
   if (operation.operation === "CloseCreditAccount") {
-    return (0, import_previewCloseOrRepayCreditAccount.previewCloseOrRepayCreditAccount)(input, operation, true, options);
+    const resolved = await resolveCreditAccount(input, operation, options);
+    return (0, import_previewCloseOrRepayCreditAccount.previewCloseOrRepayCreditAccount)(input, operation, true, resolved);
   }
   if (operation.operation === "MultiCall" || operation.operation === "BotMulticall" || operation.operation === "RWAMulticall") {
-    if ((0, import_detectCloseOrRepay.isCloseOrRepay)(operation.multicall)) {
-      return (0, import_previewCloseOrRepayCreditAccount.previewCloseOrRepayCreditAccount)(input, operation, false, options);
-    }
-    return (0, import_previewAdjustCreditAccount.previewAdjustCreditAccount)(input, operation, options);
+    const resolved = await resolveCreditAccount(input, operation, options);
+    return previewMulticallOperation(input, operation, resolved);
   }
   throw new import_errors.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 = (0, import_detectCloseOrRepay.isCloseOrRepay)(operation.multicall) ? await (0, import_previewCloseOrRepayCreditAccount.previewCloseOrRepayCreditAccount)(input, operation, false, options) : await (0, import_previewAdjustCreditAccount.previewAdjustCreditAccount)(input, operation, options);
+  const delayed = (0, import_detectDelayedOperation.detectDelayedOperation)(sdk, operation.multicall);
+  if (!delayed) {
+    return instantPreview;
+  }
+  const { before, after } = await (0, import_replayMulticall.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: (0, import_buildDelayedPreview.buildDelayedPreview)(
+      after.account,
+      before,
+      delayed,
+      convert
+    )
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   previewOperation

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

@@ -16,27 +16,24 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var applyInnerOperations_exports = {};
-__export(applyInnerOperations_exports, {
-  applyInnerOperations: () => applyInnerOperations,
-  makeInnerOperationsState: () => makeInnerOperationsState
+var replayInnerOperations_exports = {};
+__export(replayInnerOperations_exports, {
+  makeReplayState: () => makeReplayState,
+  replayInnerOperations: () => replayInnerOperations
 });
-module.exports = __toCommonJS(applyInnerOperations_exports);
+module.exports = __toCommonJS(replayInnerOperations_exports);
 var import_adapters = require("../../plugins/adapters/index.js");
 var import_sdk = require("../../sdk/index.js");
 var import_applyRWAWrapUnwrap = require("./applyRWAWrapUnwrap.js");
 var import_types = require("./types.js");
-function makeInnerOperationsState() {
+function makeReplayState(account) {
   return {
-    balances: new import_sdk.AssetsMap(),
-    debt: 0n,
-    totalDebt: 0n,
+    account,
     collateralAdded: new import_sdk.AssetsMap(),
-    collateralWithdrawn: new import_sdk.AssetsMap(),
-    quotaChanges: []
+    collateralWithdrawn: new import_sdk.AssetsMap()
   };
 }
-async function applyInnerOperations(sdk, multicall, state) {
+async function replayInnerOperations(sdk, multicall, state) {
   let inBracket = false;
   let error;
   for (const op of multicall) {
@@ -49,13 +46,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) {
@@ -66,7 +63,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":
@@ -79,7 +76,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;
@@ -94,27 +96,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 === import_sdk.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) {
@@ -159,6 +148,6 @@ function isRWAShare(sdk, adapter) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  applyInnerOperations,
-  makeInnerOperationsState
+  makeReplayState,
+  replayInnerOperations
 });

package/dist/cjs/preview/preview/{applyQuotaChanges.js → replayMulticall.js}

@@ -16,28 +16,22 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var applyQuotaChanges_exports = {};
-__export(applyQuotaChanges_exports, {
-  applyQuotaChanges: () => applyQuotaChanges
+var replayMulticall_exports = {};
+__export(replayMulticall_exports, {
+  replayMulticall: () => replayMulticall
 });
-module.exports = __toCommonJS(applyQuotaChanges_exports);
-var import_sdk = require("../../sdk/index.js");
-function applyQuotaChanges(initialQuotas, changes) {
-  const final = initialQuotas.clone();
-  for (const { token, balance: change } of changes) {
-    if (change === import_sdk.MIN_INT96) {
-      final.upsert(token, 0n);
-    } else {
-      const next = final.getOrZero(token) + change;
-      final.upsert(token, next > 0n ? next : 0n);
-    }
-  }
-  return {
-    quotas: final.toAssets(0n),
-    quotasChange: final.difference(initialQuotas).toAssets()
-  };
+module.exports = __toCommonJS(replayMulticall_exports);
+var import_CreditAccountState = require("./CreditAccountState.js");
+var import_replayInnerOperations = require("./replayInnerOperations.js");
+async function replayMulticall(sdk, operation, options) {
+  const before = import_CreditAccountState.CreditAccountState.fromCreditAccountData(
+    options.creditAccount
+  );
+  const after = (0, import_replayInnerOperations.makeReplayState)(before.clone());
+  const error = await (0, import_replayInnerOperations.replayInnerOperations)(sdk, operation.multicall, after);
+  return { before, after, error };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  applyQuotaChanges
+  replayMulticall
 });

package/dist/cjs/preview/preview/types.js

@@ -24,7 +24,8 @@ __export(types_exports, {
   ERROR_NON_ADAPTER_CALL_IN_BRACKET: () => ERROR_NON_ADAPTER_CALL_IN_BRACKET,
   ERROR_UNPREVIEWABLE_ADAPTER_CALL: () => ERROR_UNPREVIEWABLE_ADAPTER_CALL,
   ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP: () => ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP,
-  ERROR_UNPRICEABLE_TOKEN: () => ERROR_UNPRICEABLE_TOKEN
+  ERROR_UNPRICEABLE_TOKEN: () => ERROR_UNPRICEABLE_TOKEN,
+  PREVIEW_DUST: () => PREVIEW_DUST
 });
 module.exports = __toCommonJS(types_exports);
 const ERROR_MALFORMED_BRACKET = 1001;
@@ -34,6 +35,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;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ERROR_ADAPTER_CALL_OUTSIDE_BRACKET,
@@ -42,5 +44,6 @@ const ERROR_UNPRICEABLE_TOKEN = 2001;
   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/esm/preview/preview/CreditAccountState.js

@@ -0,0 +1,133 @@
+import { zeroAddress } from "viem";
+import {
+  AssetsMap,
+  MIN_INT96
+} from "../../sdk/index.js";
+class CreditAccountState {
+  creditAccount;
+  creditManager;
+  /**
+   * Credit manager underlying
+   */
+  underlying;
+  /**
+   * Per-token balances
+   */
+  balances;
+  /**
+   * Per-token quotas
+   */
+  quotas;
+  /**
+   * Debt principal
+   */
+  debt;
+  /**
+   * 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;
+  constructor(props) {
+    this.creditAccount = props.creditAccount;
+    this.creditManager = props.creditManager;
+    this.underlying = props.underlying;
+    this.balances = props.balances ?? new AssetsMap();
+    this.quotas = props.quotas ?? new AssetsMap();
+    this.debt = props.debt ?? 0n;
+    this.totalDebt = props.totalDebt ?? 0n;
+  }
+  /**
+   * 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, underlying) {
+    return new CreditAccountState({
+      creditAccount: zeroAddress,
+      creditManager,
+      underlying
+    });
+  }
+  /**
+   * Pre-state of an existing account from its on-chain data, with dust
+   * balances and quotas (≤ 1 wei) filtered out.
+   */
+  static fromCreditAccountData(ca) {
+    const balances = new AssetsMap();
+    const quotas = new AssetsMap();
+    for (const t of ca.tokens) {
+      if (t.balance > 1n) {
+        balances.upsert(t.token, t.balance);
+      }
+      if (t.quota > 1n) {
+        quotas.upsert(t.token, t.quota);
+      }
+    }
+    return new CreditAccountState({
+      creditAccount: ca.creditAccount,
+      creditManager: ca.creditManager,
+      underlying: ca.underlying,
+      balances,
+      quotas,
+      debt: ca.debt,
+      totalDebt: ca.debt + ca.accruedInterest + ca.accruedFees
+    });
+  }
+  clone() {
+    return new CreditAccountState({
+      creditAccount: this.creditAccount,
+      creditManager: this.creditManager,
+      underlying: this.underlying,
+      balances: this.balances.clone(),
+      quotas: this.quotas.clone(),
+      debt: this.debt,
+      totalDebt: this.totalDebt
+    });
+  }
+  /**
+   * Borrows `amount` of underlying: debt, total debt and the underlying
+   * balance all increase by it.
+   */
+  increaseDebt(amount) {
+    this.debt += amount;
+    this.totalDebt += amount;
+    this.balances.inc(this.underlying, amount);
+  }
+  /**
+   * 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) {
+    const repaid = amount > this.totalDebt ? this.totalDebt : amount;
+    this.balances.dec(this.underlying, repaid);
+    this.totalDebt -= repaid;
+    if (this.debt > this.totalDebt) {
+      this.debt = this.totalDebt;
+    }
+    return repaid;
+  }
+  /**
+   * 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, change) {
+    if (change === MIN_INT96) {
+      this.quotas.upsert(token, 0n);
+      return;
+    }
+    const next = this.quotas.getOrZero(token) + change;
+    this.quotas.upsert(token, next > 0n ? next : 0n);
+  }
+}
+export {
+  CreditAccountState
+};

package/dist/esm/preview/preview/buildDelayedPreview.js

@@ -0,0 +1,90 @@
+import { isAddressEqual } from "viem";
+import { AssetsMap } from "../../sdk/index.js";
+import {
+  ERROR_UNPRICEABLE_TOKEN,
+  PREVIEW_DUST
+} from "./types.js";
+function buildDelayedPreview(state, before, detected, convert) {
+  const { request, intent } = detected;
+  const post = state.clone();
+  let error;
+  const safeConvert = (token, to, amount) => {
+    try {
+      return convert(token, to, amount);
+    } catch {
+      error ??= {
+        code: ERROR_UNPRICEABLE_TOKEN,
+        message: `cannot price token ${token}`
+      };
+      return 0n;
+    }
+  };
+  const claimed = post.balances.getOrZero(request.phantomToken);
+  post.balances.upsert(request.phantomToken, 0n);
+  post.quotas.upsert(request.phantomToken, 0n);
+  post.balances.inc(request.claimToken, claimed);
+  if (intent?.type === "CLOSE_ACCOUNT") {
+    const totalValue2 = post.balances.sum(
+      (token, balance) => balance > 0n ? safeConvert(token, post.underlying, balance) : 0n
+    );
+    const receivedAmount = totalValue2 > post.totalDebt ? totalValue2 - post.totalDebt : 0n;
+    const preview2 = {
+      operation: "CloseCreditAccount",
+      permanent: true,
+      creditManager: post.creditManager,
+      creditAccount: post.creditAccount,
+      receivedAmount,
+      error
+    };
+    return preview2;
+  }
+  const collateralWithdrawn = new AssetsMap();
+  const repayFromClaim = (amount) => {
+    const available = post.balances.getOrZero(request.claimToken);
+    const spent = amount > available ? available : amount;
+    if (spent <= 0n) {
+      return;
+    }
+    const received = safeConvert(request.claimToken, post.underlying, spent);
+    post.balances.dec(request.claimToken, spent);
+    post.balances.inc(post.underlying, received);
+    post.repay(received);
+  };
+  if (intent?.type === "DECREASE_LEVERAGE") {
+    repayFromClaim(claimed);
+  } else if (intent?.type === "WITHDRAW_COLLATERAL") {
+    const running = post.balances.getOrZero(intent.withdrawToken);
+    const withdrawn = intent.withdrawAmount > running ? running : intent.withdrawAmount;
+    if (withdrawn > 0n) {
+      post.balances.dec(intent.withdrawToken, withdrawn);
+      collateralWithdrawn.upsert(intent.withdrawToken, withdrawn);
+    }
+    const remainingClaim = isAddressEqual(intent.withdrawToken, request.claimToken) && claimed > withdrawn ? claimed - withdrawn : claimed;
+    repayFromClaim(remainingClaim);
+  }
+  const totalValue = post.balances.sum(
+    (token, balance) => balance > PREVIEW_DUST ? safeConvert(token, post.underlying, balance) : 0n
+  );
+  const preview = {
+    operation: "AdjustCreditAccount",
+    creditManager: post.creditManager,
+    creditAccount: post.creditAccount,
+    // the resume flow adds nothing from the wallet
+    collateralAdded: [],
+    collateralWithdrawn: collateralWithdrawn.toAssets(),
+    totalValue,
+    debt: post.debt,
+    // relative to the pre-transaction state: where the account will end up
+    // compared to now, once the withdrawal is claimed and the intent resumed
+    debtChange: post.debt - before.debt,
+    quotas: post.quotas.toAssets(0n),
+    quotasChange: post.quotas.difference(before.quotas).toAssets(),
+    assets: post.balances.toAssets(PREVIEW_DUST),
+    assetsChange: post.balances.difference(before.balances).toAssets(PREVIEW_DUST),
+    error
+  };
+  return preview;
+}
+export {
+  buildDelayedPreview
+};

package/dist/esm/preview/preview/detectDelayedOperation.js

@@ -0,0 +1,51 @@
+import { isAddressEqual } from "viem";
+import {
+  AbstractAdapterContract
+} from "../../plugins/adapters/index.js";
+import {
+  decodeDelayedIntent
+} from "../../sdk/index.js";
+import { InvalidDelayedIntentError } from "./errors.js";
+function detectDelayedOperation(sdk, multicall) {
+  let bracketDeltas = [];
+  for (const op of multicall) {
+    if (op.operation === "StoreExpectedBalances") {
+      bracketDeltas = op.deltas;
+      continue;
+    }
+    if (op.operation === "CompareBalances") {
+      bracketDeltas = [];
+      continue;
+    }
+    if (op.operation !== "Execute") {
+      continue;
+    }
+    const adapter = sdk.getContract(op.adapter);
+    if (!(adapter instanceof AbstractAdapterContract)) {
+      continue;
+    }
+    const request = adapter.parseDelayedWithdrawalRequest(op.calldata);
+    if (!request) {
+      continue;
+    }
+    const mintsPhantom = bracketDeltas.some(
+      ({ token, balance }) => balance > 0n && isAddressEqual(token, request.phantomToken)
+    );
+    if (!mintsPhantom) {
+      continue;
+    }
+    let intent;
+    if (request.extraData && request.extraData !== "0x") {
+      try {
+        intent = decodeDelayedIntent(request.extraData);
+      } catch (e) {
+        throw new InvalidDelayedIntentError(op.adapter, request.extraData, e);
+      }
+    }
+    return { request, intent };
+  }
+  return void 0;
+}
+export {
+  detectDelayedOperation
+};

package/dist/esm/preview/preview/errors.js

@@ -7,6 +7,22 @@ class UnsupportedOperationError extends Error {
     this.operation = operation;
   }
 }
+class InvalidDelayedIntentError extends Error {
+  /** Adapter the withdrawal request was addressed to. */
+  adapter;
+  /** Raw `extraData` that failed to decode. */
+  extraData;
+  constructor(adapter, extraData, cause) {
+    super(
+      `cannot decode delayed intent from extraData ${extraData} of withdrawal request to adapter ${adapter}`,
+      { cause }
+    );
+    this.name = "InvalidDelayedIntentError";
+    this.adapter = adapter;
+    this.extraData = extraData;
+  }
+}
 export {
+  InvalidDelayedIntentError,
   UnsupportedOperationError
 };

package/dist/esm/preview/preview/index.js

@@ -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/esm/preview/preview/previewAdjustCreditAccount.js

@@ -1,15 +1,8 @@
+import { AP_WETH_TOKEN, NO_VERSION } from "../../sdk/index.js";
+import { replayMulticall } from "./replayMulticall.js";
 import {
-  AP_WETH_TOKEN,
-  AssetsMap,
-  NO_VERSION
-} from "../../sdk/index.js";
-import {
-  applyInnerOperations,
-  makeInnerOperationsState
-} from "./applyInnerOperations.js";
-import { applyQuotaChanges } from "./applyQuotaChanges.js";
-import {
-  ERROR_UNPRICEABLE_TOKEN
+  ERROR_UNPRICEABLE_TOKEN,
+  PREVIEW_DUST
 } from "./types.js";
 import { unwrapNativeCollateral } from "./unwrapNativeCollateral.js";
 async function previewAdjustCreditAccount(input, operation, options) {
@@ -17,43 +10,21 @@ async function previewAdjustCreditAccount(input, operation, options) {
   const market = sdk.marketRegister.findByCreditManager(
     operation.creditManager
   );
-  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 initialBalances = new AssetsMap();
-  const initialQuotas = new AssetsMap();
-  for (const t of ca.tokens) {
-    if (t.balance > 1n) {
-      initialBalances.upsert(t.token, t.balance);
-    }
-    if (t.quota > 1n) {
-      initialQuotas.upsert(t.token, t.quota);
-    }
-  }
-  const state = makeInnerOperationsState();
-  state.balances = initialBalances.clone();
-  state.debt = ca.debt;
-  state.totalDebt = ca.debt + ca.accruedInterest + ca.accruedFees;
-  let error = await applyInnerOperations(sdk, operation.multicall, state);
+  const {
+    before,
+    after,
+    error: replayError
+  } = await replayMulticall(sdk, operation, options);
+  const account = after.account;
+  let error = replayError;
   const { assets: collateralAdded, error: unwrapError } = unwrapNativeCollateral(
-    state.collateralAdded.toAssets(),
+    after.collateralAdded.toAssets(),
     value,
     sdk.addressProvider.getAddress(AP_WETH_TOKEN, NO_VERSION)
   );
   error ??= unwrapError;
-  const { quotas, quotasChange } = applyQuotaChanges(
-    initialQuotas,
-    state.quotaChanges
-  );
-  const assets = state.balances.toAssets(1n);
-  const assetsChange = state.balances.difference(initialBalances).toAssets(1n);
+  const assets = account.balances.toAssets(PREVIEW_DUST);
+  const assetsChange = account.balances.difference(before.balances).toAssets(PREVIEW_DUST);
   const totalValue = assets.reduce((acc, { token, balance }) => {
     try {
       return acc + market.priceOracle.convert(token, market.underlying, balance);
@@ -70,12 +41,12 @@ async function previewAdjustCreditAccount(input, operation, options) {
     creditManager: operation.creditManager,
     creditAccount: operation.creditAccount,
     collateralAdded,
-    collateralWithdrawn: state.collateralWithdrawn.toAssets(),
+    collateralWithdrawn: after.collateralWithdrawn.toAssets(),
     totalValue,
-    debt: state.debt,
-    debtChange: state.debt - ca.debt,
-    quotas,
-    quotasChange,
+    debt: account.debt,
+    debtChange: account.debt - before.debt,
+    quotas: account.quotas.toAssets(0n),
+    quotasChange: account.quotas.difference(before.quotas).toAssets(),
     assets,
     assetsChange,
     error