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

package/dist/cjs/preview/preview/previewAdjustCreditAccount.js

@@ -0,0 +1,78 @@
+"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 previewAdjustCreditAccount_exports = {};
+__export(previewAdjustCreditAccount_exports, {
+  previewAdjustCreditAccount: () => previewAdjustCreditAccount
+});
+module.exports = __toCommonJS(previewAdjustCreditAccount_exports);
+var import_sdk = require("../../sdk/index.js");
+var import_replayMulticall = require("./replayMulticall.js");
+var import_types = require("./types.js");
+var import_unwrapNativeCollateral = require("./unwrapNativeCollateral.js");
+async function previewAdjustCreditAccount(input, operation, options) {
+  const { sdk, value = 0n } = input;
+  const market = sdk.marketRegister.findByCreditManager(
+    operation.creditManager
+  );
+  const {
+    before,
+    after,
+    error: replayError
+  } = await (0, import_replayMulticall.replayMulticall)(sdk, operation, options);
+  const account = after.account;
+  let error = replayError;
+  const { assets: collateralAdded, error: unwrapError } = (0, import_unwrapNativeCollateral.unwrapNativeCollateral)(
+    after.collateralAdded.toAssets(),
+    value,
+    sdk.addressProvider.getAddress(import_sdk.AP_WETH_TOKEN, import_sdk.NO_VERSION)
+  );
+  error ??= unwrapError;
+  const assets = account.balances.toAssets(import_types.PREVIEW_DUST);
+  const assetsChange = account.balances.difference(before.balances).toAssets(import_types.PREVIEW_DUST);
+  const totalValue = assets.reduce((acc, { token, balance }) => {
+    try {
+      return acc + market.priceOracle.convert(token, market.underlying, balance);
+    } catch {
+      error ??= {
+        code: import_types.ERROR_UNPRICEABLE_TOKEN,
+        message: `cannot price token ${token}`
+      };
+      return acc;
+    }
+  }, 0n);
+  return {
+    operation: "AdjustCreditAccount",
+    creditManager: operation.creditManager,
+    creditAccount: operation.creditAccount,
+    collateralAdded,
+    collateralWithdrawn: after.collateralWithdrawn.toAssets(),
+    totalValue,
+    debt: account.debt,
+    debtChange: account.debt - before.debt,
+    quotas: account.quotas.toAssets(0n),
+    quotasChange: account.quotas.difference(before.quotas).toAssets(),
+    assets,
+    assetsChange,
+    error
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  previewAdjustCreditAccount
+});

package/dist/cjs/preview/preview/previewCloseOrRepayCreditAccount.js

@@ -0,0 +1,94 @@
+"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 previewCloseOrRepayCreditAccount_exports = {};
+__export(previewCloseOrRepayCreditAccount_exports, {
+  previewCloseOrRepayCreditAccount: () => previewCloseOrRepayCreditAccount
+});
+module.exports = __toCommonJS(previewCloseOrRepayCreditAccount_exports);
+var import_sdk = require("../../sdk/index.js");
+var import_detectCloseOrRepay = require("./detectCloseOrRepay.js");
+var import_replayMulticall = require("./replayMulticall.js");
+var import_unwrapNativeCollateral = require("./unwrapNativeCollateral.js");
+async function previewCloseOrRepayCreditAccount(input, operation, permanent, options) {
+  const { sdk } = input;
+  const market = sdk.marketRegister.findByCreditManager(
+    operation.creditManager
+  );
+  const exitTokens = [market.underlying];
+  const meta = sdk.tokensMeta.get(market.underlying);
+  if (meta && sdk.tokensMeta.isRWAUnderlying(meta)) {
+    exitTokens.push(meta.asset);
+  }
+  const replay = await (0, import_replayMulticall.replayMulticall)(sdk, operation, options);
+  const kind = (0, import_detectCloseOrRepay.classifyCloseOrRepay)(operation.multicall, exitTokens);
+  return kind === "close" ? previewCloseCreditAccount(input, operation, permanent, replay) : previewRepayCreditAccount(input, operation, permanent, replay);
+}
+function previewCloseCreditAccount(input, operation, permanent, replay) {
+  const { sdk } = input;
+  const market = sdk.marketRegister.findByCreditManager(
+    operation.creditManager
+  );
+  const { after, error } = replay;
+  let receivedToken = market.underlying;
+  for (const m of operation.multicall) {
+    if (m.operation === "WithdrawCollateral" && m.amount === import_sdk.MAX_UINT256) {
+      receivedToken = m.token;
+      break;
+    }
+  }
+  return {
+    operation: "CloseCreditAccount",
+    permanent,
+    creditManager: operation.creditManager,
+    creditAccount: operation.creditAccount,
+    // On a malformed multicall the withdrawn amount depends on best-effort
+    // replayed balances and may be unreliable
+    receivedAmount: {
+      token: receivedToken,
+      balance: after.collateralWithdrawn.getOrZero(receivedToken)
+    },
+    error
+  };
+}
+function previewRepayCreditAccount(input, operation, permanent, replay) {
+  const { sdk, value = 0n } = input;
+  const { before, after, error: replayError } = replay;
+  const { assets: collateralAdded, error: unwrapError } = (0, import_unwrapNativeCollateral.unwrapNativeCollateral)(
+    after.collateralAdded.toAssets(),
+    value,
+    sdk.addressProvider.getAddress(import_sdk.AP_WETH_TOKEN, import_sdk.NO_VERSION)
+  );
+  const error = replayError ?? unwrapError;
+  return {
+    operation: "RepayCreditAccount",
+    permanent,
+    creditManager: operation.creditManager,
+    creditAccount: operation.creditAccount,
+    collateralAdded,
+    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: after.collateralWithdrawn.toAssets(),
+    error
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  previewCloseOrRepayCreditAccount
+});

package/dist/cjs/preview/preview/previewOpenCreditAccount.js

@@ -21,98 +21,52 @@ __export(previewOpenCreditAccount_exports, {
   previewOpenCreditAccount: () => previewOpenCreditAccount
 });
 module.exports = __toCommonJS(previewOpenCreditAccount_exports);
-var import_adapters = require("../../plugins/adapters/index.js");
 var import_sdk = require("../../sdk/index.js");
+var import_CreditAccountState = require("./CreditAccountState.js");
+var import_replayInnerOperations = require("./replayInnerOperations.js");
+var import_types = require("./types.js");
 var import_unwrapNativeCollateral = require("./unwrapNativeCollateral.js");
-function previewOpenCreditAccount(input, operation) {
+async function previewOpenCreditAccount(input, operation) {
   const { sdk, value = 0n } = input;
   const market = sdk.marketRegister.findByCreditManager(
     operation.creditManager
   );
-  const collateralBalances = new import_sdk.AssetsMap();
-  const balances = new import_sdk.AssetsMap();
-  let debt = 0n;
-  const quotas = [];
-  let inBracket = false;
-  let storeSeen = false;
-  for (const op of operation.multicall) {
-    switch (op.operation) {
-      case "AddCollateral":
-        collateralBalances.inc(op.token, op.amount);
-        balances.inc(op.token, op.amount);
-        break;
-      case "WithdrawCollateral":
-        balances.dec(op.token, op.amount);
-        break;
-      case "IncreaseBorrowedAmount":
-        debt += op.amount;
-        balances.inc(op.token, op.amount);
-        break;
-      case "DecreaseBorrowedAmount":
-        debt -= op.amount;
-        balances.dec(op.token, op.amount);
-        break;
-      case "UpdateQuota":
-        quotas.push({ token: op.token, balance: op.change });
-        break;
-      case "StoreExpectedBalances":
-        if (storeSeen) {
-          throw new Error(
-            "malformed multicall: duplicate storeExpectedBalances call"
-          );
-        }
-        storeSeen = true;
-        inBracket = true;
-        for (const { token, balance } of op.deltas) {
-          balances.inc(token, balance);
-        }
-        break;
-      case "CompareBalances":
-        if (!inBracket) {
-          throw new Error(
-            "malformed multicall: compareBalances without a preceding storeExpectedBalances"
-          );
-        }
-        inBracket = false;
-        break;
-      case "Execute":
-        if (inBracket) {
-          const adapter = sdk.getContract(op.adapter);
-          if (!(adapter instanceof import_adapters.AbstractAdapterContract)) {
-            throw new Error(
-              `call to ${op.adapter} between storeExpectedBalances and compareBalances is not an adapter call`
-            );
-          }
-          adapter.previewBalanceChanges(balances, op.calldata);
-        }
-        break;
-    }
-  }
-  if (inBracket) {
-    throw new Error(
-      "malformed multicall: storeExpectedBalances without a matching compareBalances"
-    );
-  }
-  let collateral = collateralBalances.toAssets();
-  const collateralValue = collateral.reduce(
-    (acc, { token, balance }) => acc + market.priceOracle.convert(token, market.underlying, balance),
-    0n
+  const state = (0, import_replayInnerOperations.makeReplayState)(
+    import_CreditAccountState.CreditAccountState.beforeOpen(operation.creditManager, market.underlying)
   );
-  collateral = (0, import_unwrapNativeCollateral.unwrapNativeCollateral)(
-    collateral,
+  let error = await (0, import_replayInnerOperations.replayInnerOperations)(sdk, operation.multicall, state);
+  const account = state.account;
+  let priceError;
+  const collateralValue = state.collateralAdded.sum((token, balance) => {
+    try {
+      return market.priceOracle.convert(token, market.underlying, balance);
+    } catch {
+      priceError ??= {
+        code: import_types.ERROR_UNPRICEABLE_TOKEN,
+        message: `cannot price token ${token}`
+      };
+      return 0n;
+    }
+  });
+  const { assets: collateral, error: unwrapError } = (0, import_unwrapNativeCollateral.unwrapNativeCollateral)(
+    state.collateralAdded.toAssets(),
     value,
     sdk.addressProvider.getAddress(import_sdk.AP_WETH_TOKEN, import_sdk.NO_VERSION)
   );
-  const assets = balances.entries().filter(([, balance]) => balance > 1n).map(([token, balance]) => ({ token, balance }));
+  error ??= unwrapError ?? priceError;
+  const assets = account.balances.toAssets(1n);
   return {
     operation: operation.operation,
     creditManager: operation.creditManager,
-    target: inferTargetAsset(operation.multicall, balances),
+    target: inferTargetAsset(operation.multicall, account.balances),
     collateral,
     collateralValue,
-    debt,
-    quotas,
-    assets
+    debt: account.debt,
+    // On opening, initial quotas are zero, so the folded quotas are the
+    // applied changes.
+    quotas: account.quotas.toAssets(0n),
+    assets,
+    error
   };
 }
 function inferTargetAsset(multicall, balances) {

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

@@ -22,19 +22,92 @@ __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_detectDelayedClaim = require("./detectDelayedClaim.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)) {
     return (0, import_previewPoolOperation.previewPoolOperation)(input, operation, options);
   }
-  if (operation.operation === "OpenCreditAccount" || operation.operation === "SecuritizeOpenCreditAccount") {
+  if (operation.operation === "OpenCreditAccount" || operation.operation === "RWAOpenCreditAccount") {
     return (0, import_previewOpenCreditAccount.previewOpenCreditAccount)(input, operation);
   }
+  if (operation.operation === "CloseCreditAccount") {
+    const resolved = await resolveCreditAccount(input, operation, options);
+    const preview = await (0, import_previewCloseOrRepayCreditAccount.previewCloseOrRepayCreditAccount)(
+      input,
+      operation,
+      true,
+      resolved
+    );
+    preview.intent = await (0, import_detectDelayedClaim.resolveDelayedClaimIntent)(
+      input.sdk,
+      operation.multicall,
+      options?.blockNumber
+    );
+    return preview;
+  }
+  if (operation.operation === "MultiCall" || operation.operation === "BotMulticall" || operation.operation === "RWAMulticall") {
+    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) {
+    instantPreview.intent = await (0, import_detectDelayedClaim.resolveDelayedClaimIntent)(
+      sdk,
+      operation.multicall,
+      options?.blockNumber
+    );
+    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);
+  const meta = sdk.tokensMeta.get(market.underlying);
+  const receivedToken = meta && sdk.tokensMeta.isRWAUnderlying(meta) ? meta.asset : market.underlying;
+  return {
+    operation: "DelayedCreditAccountOperation",
+    creditAccount: operation.creditAccount,
+    creditManager: operation.creditManager,
+    intent: delayed.intent,
+    instantPreview,
+    delayedPreview: (0, import_buildDelayedPreview.buildDelayedPreview)(
+      after.account,
+      before,
+      delayed,
+      convert,
+      receivedToken
+    )
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   previewOperation

package/dist/cjs/preview/preview/previewPoolOperation.js

@@ -29,45 +29,12 @@ async function previewPoolOperation(input, operation, options) {
     { sdk, operation, to, calldata },
     options
   );
-  if (sim.status === "success") {
-    return {
-      operation: operation.operation,
-      pool: operation.pool,
-      tokenIn: { token: tokenIn, balance: sim.amountIn },
-      tokenOut: { token: tokenOut, balance: sim.amountOut }
-    };
-  }
-  const { error } = sim;
-  switch (operation.operation) {
-    case "Deposit":
-      return {
-        operation: "Deposit",
-        pool: operation.pool,
-        tokenIn: { token: tokenIn, balance: operation.assets },
-        tokenOut: { token: tokenOut, error }
-      };
-    case "Mint":
-      return {
-        operation: "Mint",
-        pool: operation.pool,
-        tokenIn: { token: tokenIn, error },
-        tokenOut: { token: tokenOut, balance: operation.shares }
-      };
-    case "Withdraw":
-      return {
-        operation: "Withdraw",
-        pool: operation.pool,
-        tokenIn: { token: tokenIn, error },
-        tokenOut: { token: tokenOut, balance: operation.assets }
-      };
-    case "Redeem":
-      return {
-        operation: "Redeem",
-        pool: operation.pool,
-        tokenIn: { token: tokenIn, balance: operation.shares },
-        tokenOut: { token: tokenOut, error }
-      };
-  }
+  return {
+    operation: operation.operation,
+    pool: operation.pool,
+    tokenIn: { token: tokenIn, balance: sim.amountIn },
+    tokenOut: { token: tokenOut, balance: sim.amountOut }
+  };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/dist/cjs/preview/preview/replayInnerOperations.js

@@ -0,0 +1,153 @@
+"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 replayInnerOperations_exports = {};
+__export(replayInnerOperations_exports, {
+  makeReplayState: () => makeReplayState,
+  replayInnerOperations: () => replayInnerOperations
+});
+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 makeReplayState(account) {
+  return {
+    account,
+    collateralAdded: new import_sdk.AssetsMap(),
+    collateralWithdrawn: new import_sdk.AssetsMap()
+  };
+}
+async function replayInnerOperations(sdk, multicall, state) {
+  let inBracket = false;
+  let error;
+  for (const op of multicall) {
+    let opError;
+    switch (op.operation) {
+      case "AddCollateral":
+        applyAddCollateral(state, op);
+        break;
+      case "WithdrawCollateral":
+        applyWithdrawCollateral(state, op);
+        break;
+      case "IncreaseBorrowedAmount":
+        state.account.increaseDebt(op.amount);
+        break;
+      case "DecreaseBorrowedAmount":
+        state.account.repay(op.amount);
+        break;
+      case "UpdateQuota":
+        state.account.updateQuota(op.token, op.change);
+        break;
+      case "StoreExpectedBalances":
+        if (inBracket) {
+          opError = {
+            code: import_types.ERROR_MALFORMED_BRACKET,
+            message: "nested storeExpectedBalances/compareBalances bracket"
+          };
+        }
+        inBracket = true;
+        for (const { token, balance } of op.deltas) {
+          state.account.balances.inc(token, balance);
+        }
+        break;
+      case "CompareBalances":
+        if (!inBracket) {
+          opError = {
+            code: import_types.ERROR_MALFORMED_BRACKET,
+            message: "compareBalances without a preceding storeExpectedBalances"
+          };
+        }
+        inBracket = false;
+        break;
+      case "Execute":
+        opError = await applyExecute(
+          sdk,
+          op,
+          inBracket,
+          state.account.balances
+        );
+        break;
+    }
+    error ??= opError;
+  }
+  if (inBracket) {
+    error ??= {
+      code: import_types.ERROR_MALFORMED_BRACKET,
+      message: "storeExpectedBalances without a matching compareBalances"
+    };
+  }
+  return error;
+}
+function applyAddCollateral(state, op) {
+  state.collateralAdded.inc(op.token, op.amount);
+  state.account.balances.inc(op.token, op.amount);
+}
+function applyWithdrawCollateral(state, op) {
+  const running = state.account.balances.getOrZero(op.token);
+  const amount = op.amount === import_sdk.MAX_UINT256 ? running > 0n ? running : 0n : op.amount;
+  state.account.balances.dec(op.token, amount);
+  state.collateralWithdrawn.inc(op.token, amount);
+}
+async function applyExecute(sdk, op, inBracket, balances) {
+  const adapter = sdk.getContract(op.adapter);
+  if (!inBracket) {
+    if (!isRWAShare(sdk, adapter)) {
+      return {
+        code: import_types.ERROR_ADAPTER_CALL_OUTSIDE_BRACKET,
+        message: `call to ${op.adapter} outside of a storeExpectedBalances/compareBalances bracket`
+      };
+    }
+    try {
+      (0, import_applyRWAWrapUnwrap.applyRWAWrapUnwrap)(adapter, op.calldata, balances);
+      return void 0;
+    } catch (e) {
+      return {
+        code: import_types.ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP,
+        message: e instanceof Error ? e.message : String(e)
+      };
+    }
+  }
+  if (!(adapter instanceof import_adapters.AbstractAdapterContract)) {
+    return {
+      code: import_types.ERROR_NON_ADAPTER_CALL_IN_BRACKET,
+      message: `call to ${op.adapter} between storeExpectedBalances and compareBalances is not an adapter call`
+    };
+  }
+  try {
+    await adapter.previewBalanceChanges(balances, op.calldata);
+    return void 0;
+  } catch (e) {
+    return {
+      code: import_types.ERROR_UNPREVIEWABLE_ADAPTER_CALL,
+      message: e instanceof Error ? e.message : String(e)
+    };
+  }
+}
+function isRWAShare(sdk, adapter) {
+  if (adapter instanceof import_adapters.ERC4626AdapterContract) {
+    const meta = sdk.tokensMeta.get(adapter.share);
+    return !!meta && sdk.tokensMeta.isRWAUnderlying(meta);
+  }
+  return false;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  makeReplayState,
+  replayInnerOperations
+});

package/dist/cjs/preview/preview/replayMulticall.js

@@ -0,0 +1,37 @@
+"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 replayMulticall_exports = {};
+__export(replayMulticall_exports, {
+  replayMulticall: () => replayMulticall
+});
+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 = {
+  replayMulticall
+});

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

@@ -3,6 +3,10 @@ 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))
@@ -13,4 +17,33 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var types_exports = {};
+__export(types_exports, {
+  ERROR_ADAPTER_CALL_OUTSIDE_BRACKET: () => ERROR_ADAPTER_CALL_OUTSIDE_BRACKET,
+  ERROR_INVALID_TRANSACTION_VALUE: () => ERROR_INVALID_TRANSACTION_VALUE,
+  ERROR_MALFORMED_BRACKET: () => ERROR_MALFORMED_BRACKET,
+  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,
+  PREVIEW_DUST: () => PREVIEW_DUST
+});
 module.exports = __toCommonJS(types_exports);
+const ERROR_MALFORMED_BRACKET = 1001;
+const ERROR_ADAPTER_CALL_OUTSIDE_BRACKET = 1002;
+const ERROR_NON_ADAPTER_CALL_IN_BRACKET = 1003;
+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,
+  ERROR_INVALID_TRANSACTION_VALUE,
+  ERROR_MALFORMED_BRACKET,
+  ERROR_NON_ADAPTER_CALL_IN_BRACKET,
+  ERROR_UNPREVIEWABLE_ADAPTER_CALL,
+  ERROR_UNPREVIEWABLE_RWA_WRAP_UNWRAP,
+  ERROR_UNPRICEABLE_TOKEN,
+  PREVIEW_DUST
+});