@gearbox-protocol/sdk 14.12.0-next.9 → 14.12.0-test.2

package/dist/cjs/preview/preview/CreditAccountState.js

@@ -0,0 +1,154 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var CreditAccountState_exports = {};
+__export(CreditAccountState_exports, {
+  CreditAccountState: () => CreditAccountState
+});
+module.exports = __toCommonJS(CreditAccountState_exports);
+var import_viem = require("viem");
+var import_sdk = require("../../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 import_sdk.AssetsMap();
+    this.quotas = props.quotas ?? new import_sdk.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: import_viem.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 import_sdk.AssetsMap();
+    const quotas = new import_sdk.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 === import_sdk.MIN_INT96) {
+      this.quotas.upsert(token, 0n);
+      return;
+    }
+    const next = this.quotas.getOrZero(token) + change;
+    this.quotas.upsert(token, next > 0n ? next : 0n);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CreditAccountState
+});

package/dist/cjs/preview/preview/applyRWAWrapUnwrap.js

@@ -0,0 +1,74 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var applyRWAWrapUnwrap_exports = {};
+__export(applyRWAWrapUnwrap_exports, {
+  applyRWAWrapUnwrap: () => applyRWAWrapUnwrap
+});
+module.exports = __toCommonJS(applyRWAWrapUnwrap_exports);
+var import_viem = require("viem");
+var import_ierc4626Adapter = require("../../abi/ierc4626Adapter.js");
+function resolveWrapUnwrap(adapter, calldata, balances) {
+  const decoded = (0, import_viem.decodeFunctionData)({
+    abi: import_ierc4626Adapter.ierc4626AdapterAbi,
+    data: calldata
+  });
+  const { asset, share } = adapter;
+  switch (decoded.functionName) {
+    case "deposit":
+      return { tokenIn: asset, tokenOut: share, amountIn: decoded.args[0] };
+    case "depositDiff": {
+      const [leftoverAmount] = decoded.args;
+      const running = balances.getOrZero(asset);
+      return {
+        tokenIn: asset,
+        tokenOut: share,
+        amountIn: running > leftoverAmount ? running - leftoverAmount : 0n
+      };
+    }
+    case "redeem":
+      return { tokenIn: share, tokenOut: asset, amountIn: decoded.args[0] };
+    case "redeemDiff": {
+      const [leftoverAmount] = decoded.args;
+      const running = balances.getOrZero(share);
+      return {
+        tokenIn: share,
+        tokenOut: asset,
+        amountIn: running > leftoverAmount ? running - leftoverAmount : 0n
+      };
+    }
+    default:
+      return void 0;
+  }
+}
+function applyRWAWrapUnwrap(adapter, calldata, balances) {
+  const resolved = resolveWrapUnwrap(adapter, calldata, balances);
+  if (!resolved) {
+    return;
+  }
+  const { tokenIn, tokenOut, amountIn } = resolved;
+  if (amountIn === 0n) {
+    return;
+  }
+  balances.dec(tokenIn, amountIn);
+  balances.inc(tokenOut, amountIn);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  applyRWAWrapUnwrap
+});

package/dist/cjs/preview/preview/buildDelayedPreview.js

@@ -0,0 +1,173 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var buildDelayedPreview_exports = {};
+__export(buildDelayedPreview_exports, {
+  buildDelayedPreview: () => buildDelayedPreview
+});
+module.exports = __toCommonJS(buildDelayedPreview_exports);
+var import_viem = require("viem");
+var import_common_utils = require("../../common-utils/index.js");
+var import_sdk = require("../../sdk/index.js");
+var import_types = require("./types.js");
+function buildDelayedPreview(afterInstant, before, detected, convert, receivedToken) {
+  const { request, intent } = detected;
+  const post = afterInstant.clone();
+  const converter = makeSafeConverter(convert);
+  const claimed = applyClaim(post, request);
+  const collateralWithdrawn = new import_sdk.AssetsMap();
+  switch (intent?.type) {
+    case "CLOSE_ACCOUNT":
+      return buildClosePreview(post, converter, receivedToken);
+    case "DECREASE_LEVERAGE":
+      repayFromClaim(post, request.claimToken, converter.convert, claimed);
+      break;
+    case "WITHDRAW_COLLATERAL": {
+      applyWithdrawCollateral(
+        post,
+        request,
+        intent,
+        converter,
+        collateralWithdrawn
+      );
+      break;
+    }
+    default:
+      break;
+  }
+  return buildAdjustPreview(post, before, collateralWithdrawn, converter);
+}
+function makeSafeConverter(convert) {
+  let error;
+  return {
+    convert: (token, to, amount) => {
+      try {
+        return convert(token, to, amount);
+      } catch {
+        error ??= {
+          code: import_types.ERROR_UNPRICEABLE_TOKEN,
+          message: `cannot price token ${token}`
+        };
+        return 0n;
+      }
+    },
+    get error() {
+      return error;
+    }
+  };
+}
+function applyClaim(post, request) {
+  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);
+  return claimed;
+}
+function applyWithdrawCollateral(post, request, intent, converter, collateralWithdrawn) {
+  const { withdrawToken, withdrawAmount, debtRepaid } = intent;
+  const { claimToken } = request;
+  const sameToken = (0, import_viem.isAddressEqual)(withdrawToken, claimToken);
+  const fromBalance = import_common_utils.BigIntMath.min(
+    withdrawAmount,
+    post.balances.getOrZero(withdrawToken)
+  );
+  post.balances.dec(withdrawToken, fromBalance);
+  let withdrawn = fromBalance;
+  const missing = withdrawAmount - fromBalance;
+  if (missing > 0n && !sameToken) {
+    const available = post.balances.getOrZero(claimToken);
+    const cost = converter.convert(withdrawToken, claimToken, missing);
+    if (cost > 0n && cost <= available) {
+      post.balances.dec(claimToken, cost);
+      withdrawn += missing;
+    } else if (available > 0n) {
+      post.balances.dec(claimToken, available);
+      withdrawn += converter.convert(claimToken, withdrawToken, available);
+    }
+  }
+  if (withdrawn > 0n) {
+    collateralWithdrawn.upsert(withdrawToken, withdrawn);
+  }
+  const remaining = post.balances.getOrZero(claimToken);
+  if (remaining > 0n) {
+    const proceeds = converter.convert(claimToken, post.underlying, remaining);
+    post.balances.dec(claimToken, remaining);
+    post.balances.inc(post.underlying, proceeds);
+    post.repay(import_common_utils.BigIntMath.min(proceeds, debtRepaid));
+  }
+}
+function repayFromClaim(post, claimToken, convert, amount) {
+  const spent = import_common_utils.BigIntMath.min(amount, post.balances.getOrZero(claimToken));
+  if (spent <= 0n) {
+    return;
+  }
+  const received = convert(claimToken, post.underlying, spent);
+  post.balances.dec(claimToken, spent);
+  post.balances.inc(post.underlying, received);
+  post.repay(received);
+}
+function totalValueInUnderlying(post, convert, dust) {
+  return post.balances.sum(
+    (token, balance) => balance > dust ? convert(token, post.underlying, balance) : 0n
+  );
+}
+function buildClosePreview(post, converter, receivedToken) {
+  const totalValue = totalValueInUnderlying(post, converter.convert, 0n);
+  return {
+    operation: "CloseCreditAccount",
+    permanent: false,
+    creditManager: post.creditManager,
+    creditAccount: post.creditAccount,
+    // Oracle estimate computed in the underlying; RWA underlyings convert
+    // 1:1 with their vault asset, so the amount holds for `receivedToken`
+    receivedAmount: {
+      token: receivedToken,
+      balance: import_common_utils.BigIntMath.max(totalValue - post.totalDebt, 0n)
+    },
+    error: converter.error
+  };
+}
+function buildAdjustPreview(post, before, collateralWithdrawn, converter) {
+  const totalValue = totalValueInUnderlying(
+    post,
+    converter.convert,
+    import_types.PREVIEW_DUST
+  );
+  return {
+    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(import_types.PREVIEW_DUST),
+    assetsChange: post.balances.difference(before.balances).toAssets(import_types.PREVIEW_DUST),
+    error: converter.error
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildDelayedPreview
+});

package/dist/cjs/preview/preview/detectCloseOrRepay.js

@@ -0,0 +1,51 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var detectCloseOrRepay_exports = {};
+__export(detectCloseOrRepay_exports, {
+  classifyCloseOrRepay: () => classifyCloseOrRepay,
+  isCloseOrRepay: () => isCloseOrRepay
+});
+module.exports = __toCommonJS(detectCloseOrRepay_exports);
+var import_viem = require("viem");
+var import_sdk = require("../../sdk/index.js");
+function isCloseOrRepay(multicall) {
+  const repaysFullDebt = multicall.some(
+    (op) => op.operation === "DecreaseBorrowedAmount" && op.amount === import_sdk.MAX_UINT256
+  );
+  const withdrawsEverything = multicall.some(
+    (op) => op.operation === "WithdrawCollateral" && op.amount === import_sdk.MAX_UINT256
+  );
+  return repaysFullDebt && withdrawsEverything;
+}
+function classifyCloseOrRepay(multicall, exitTokens) {
+  for (const op of multicall) {
+    if (op.operation === "AddCollateral") {
+      return "repay";
+    }
+    if (op.operation === "WithdrawCollateral" && !exitTokens.some((token) => (0, import_viem.isAddressEqual)(op.token, token))) {
+      return "repay";
+    }
+  }
+  return "close";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  classifyCloseOrRepay,
+  isCloseOrRepay
+});

package/dist/cjs/preview/preview/detectDelayedClaim.js

@@ -0,0 +1,53 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var detectDelayedClaim_exports = {};
+__export(detectDelayedClaim_exports, {
+  detectDelayedClaim: () => detectDelayedClaim,
+  resolveDelayedClaimIntent: () => resolveDelayedClaimIntent
+});
+module.exports = __toCommonJS(detectDelayedClaim_exports);
+var import_adapters = require("../../plugins/adapters/index.js");
+function detectDelayedClaim(sdk, multicall) {
+  for (const op of multicall) {
+    if (op.operation !== "Execute") {
+      continue;
+    }
+    const adapter = sdk.getContract(op.adapter);
+    if (!(adapter instanceof import_adapters.AbstractAdapterContract)) {
+      continue;
+    }
+    const claim = adapter.parseDelayedWithdrawalClaim(op.calldata);
+    if (claim) {
+      return { adapter: op.adapter, redeemer: claim.redeemer };
+    }
+  }
+  return void 0;
+}
+async function resolveDelayedClaimIntent(sdk, multicall, blockNumber) {
+  const claim = detectDelayedClaim(sdk, multicall);
+  if (!claim) {
+    return void 0;
+  }
+  return sdk.redemptionLogger?.getDelayedIntent(claim.redeemer, blockNumber);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  detectDelayedClaim,
+  resolveDelayedClaimIntent
+});

package/dist/cjs/preview/preview/detectDelayedOperation.js

@@ -0,0 +1,70 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var detectDelayedOperation_exports = {};
+__export(detectDelayedOperation_exports, {
+  detectDelayedOperation: () => detectDelayedOperation
+});
+module.exports = __toCommonJS(detectDelayedOperation_exports);
+var import_viem = require("viem");
+var import_adapters = require("../../plugins/adapters/index.js");
+var import_sdk = require("../../sdk/index.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 import_adapters.AbstractAdapterContract)) {
+      continue;
+    }
+    const request = adapter.parseDelayedWithdrawalRequest(op.calldata);
+    if (!request) {
+      continue;
+    }
+    const mintsPhantom = bracketDeltas.some(
+      ({ token, balance }) => balance > 0n && (0, import_viem.isAddressEqual)(token, request.phantomToken)
+    );
+    if (!mintsPhantom) {
+      continue;
+    }
+    let intent;
+    if (request.extraData && request.extraData !== "0x") {
+      try {
+        intent = (0, import_sdk.decodeDelayedIntent)(request.extraData);
+      } catch (e) {
+        throw new import_sdk.InvalidDelayedIntentError(request.extraData, e);
+      }
+    }
+    return { request, intent };
+  }
+  return void 0;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  detectDelayedOperation
+});

package/dist/cjs/preview/preview/errors.js

@@ -18,24 +18,9 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var errors_exports = {};
 __export(errors_exports, {
-  InvalidTransactionValueError: () => InvalidTransactionValueError,
   UnsupportedOperationError: () => UnsupportedOperationError
 });
 module.exports = __toCommonJS(errors_exports);
-class InvalidTransactionValueError extends Error {
-  /** Transaction `msg.value`. */
-  value;
-  /** Amount of wrapped native token added as collateral. */
-  wethCollateral;
-  constructor(value, wethCollateral) {
-    super(
-      `transaction value ${value} exceeds WETH collateral ${wethCollateral}`
-    );
-    this.name = "InvalidTransactionValueError";
-    this.value = value;
-    this.wethCollateral = wethCollateral;
-  }
-}
 class UnsupportedOperationError extends Error {
   /** The parsed operation kind (the `operation` discriminant). */
   operation;
@@ -47,6 +32,5 @@ class UnsupportedOperationError extends Error {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  InvalidTransactionValueError,
   UnsupportedOperationError
 });

package/dist/cjs/preview/preview/index.js

@@ -15,12 +15,30 @@ var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "defau
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var preview_exports = {};
 module.exports = __toCommonJS(preview_exports);
+__reExport(preview_exports, require("./buildDelayedPreview.js"), module.exports);
+__reExport(preview_exports, require("./CreditAccountState.js"), module.exports);
+__reExport(preview_exports, require("./detectCloseOrRepay.js"), module.exports);
+__reExport(preview_exports, require("./detectDelayedClaim.js"), module.exports);
+__reExport(preview_exports, require("./detectDelayedOperation.js"), module.exports);
 __reExport(preview_exports, require("./errors.js"), module.exports);
+__reExport(preview_exports, require("./previewAdjustCreditAccount.js"), module.exports);
+__reExport(preview_exports, require("./previewCloseOrRepayCreditAccount.js"), module.exports);
 __reExport(preview_exports, require("./previewOperation.js"), module.exports);
+__reExport(preview_exports, require("./replayInnerOperations.js"), module.exports);
+__reExport(preview_exports, require("./replayMulticall.js"), module.exports);
 __reExport(preview_exports, require("./types.js"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ...require("./buildDelayedPreview.js"),
+  ...require("./CreditAccountState.js"),
+  ...require("./detectCloseOrRepay.js"),
+  ...require("./detectDelayedClaim.js"),
+  ...require("./detectDelayedOperation.js"),
   ...require("./errors.js"),
+  ...require("./previewAdjustCreditAccount.js"),
+  ...require("./previewCloseOrRepayCreditAccount.js"),
   ...require("./previewOperation.js"),
+  ...require("./replayInnerOperations.js"),
+  ...require("./replayMulticall.js"),
   ...require("./types.js")
 });