@gearbox-protocol/sdk 14.11.3 → 14.12.0-next.2

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

@@ -0,0 +1,91 @@
+"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 errors_exports = {};
+__export(errors_exports, {
+  PreviewSimulationError: () => PreviewSimulationError,
+  asPreviewSimulationError: () => asPreviewSimulationError,
+  decodeSimulationError: () => decodeSimulationError
+});
+module.exports = __toCommonJS(errors_exports);
+var import_viem = require("viem");
+var import_errors = require("../../abi/errors.js");
+class PreviewSimulationError extends import_viem.BaseError {
+  name = "PreviewSimulationError";
+  /** Per-flow decoded failures behind this error. */
+  failures;
+  constructor(failures) {
+    const shortMessage = failures.length <= 1 ? failures[0]?.detail.reason ?? "simulation failed" : "all simulation flows failed";
+    const cause = failures.find((f) => f.detail.cause instanceof Error)?.detail.cause;
+    super(shortMessage, {
+      metaMessages: failures.map((f) => `[${f.source}] ${f.detail.reason}`),
+      cause
+    });
+    this.failures = failures;
+  }
+}
+function asPreviewSimulationError(reason, source) {
+  if (reason instanceof PreviewSimulationError) {
+    return reason;
+  }
+  const error = reason instanceof Error ? reason : new Error(String(reason));
+  return new PreviewSimulationError([
+    { source, detail: decodeSimulationError({ error }) }
+  ]);
+}
+function decodeSimulationError(revert) {
+  const { error, data } = revert;
+  if (data && data !== "0x") {
+    try {
+      const decoded = (0, import_viem.decodeErrorResult)({ abi: import_errors.errorAbis, data });
+      return {
+        reason: formatDecodedError(decoded.errorName, decoded.args),
+        cause: error
+      };
+    } catch {
+    }
+  }
+  if (error instanceof import_viem.BaseError) {
+    const reverted = error.walk(
+      (e) => e instanceof import_viem.ContractFunctionRevertedError
+    );
+    if (reverted instanceof import_viem.ContractFunctionRevertedError) {
+      return {
+        reason: reverted.data?.errorName ?? reverted.reason ?? reverted.shortMessage ?? "reverted",
+        cause: error
+      };
+    }
+    return { reason: error.shortMessage ?? error.name, cause: error };
+  }
+  if (error instanceof Error) {
+    return { reason: error.message, cause: error };
+  }
+  return { reason: "reverted", cause: error };
+}
+function formatDecodedError(errorName, args) {
+  if (!args || args.length === 0) {
+    return errorName;
+  }
+  return `${errorName}(${args.map((arg) => String(arg)).join(", ")})`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PreviewSimulationError,
+  asPreviewSimulationError,
+  decodeSimulationError
+});

package/dist/cjs/{sdk/market/zapper/Zapper.js → preview/simulate/holders.js}

@@ -16,32 +16,30 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var Zapper_exports = {};
-__export(Zapper_exports, {
-  Zapper: () => Zapper
+var holders_exports = {};
+__export(holders_exports, {
+  watchedHolders: () => watchedHolders
 });
-module.exports = __toCommonJS(Zapper_exports);
-var import_utils = require("../../utils/index.js");
-class Zapper {
-  pool;
-  type;
-  baseParams;
-  tokenIn;
-  tokenOut;
-  contractType;
-  constructor(data) {
-    this.pool = data.pool;
-    this.type = data.type;
-    this.baseParams = data.baseParams;
-    this.tokenIn = data.tokenIn;
-    this.tokenOut = data.tokenOut;
-    this.contractType = Zapper.contractType(data.baseParams);
-  }
-  static contractType(baseParams) {
-    return (0, import_utils.bytes32ToString)(baseParams.contractType);
+module.exports = __toCommonJS(holders_exports);
+var import_sdk = require("../../sdk/index.js");
+function sourceHolder(operation, wallet) {
+  switch (operation.operation) {
+    case "Deposit":
+    case "Mint":
+      return wallet;
+    case "Withdraw":
+    case "Redeem":
+      return operation.owner;
   }
 }
+function watchedHolders(operation, wallet) {
+  const holders = new import_sdk.AddressSet([
+    sourceHolder(operation, wallet),
+    operation.receiver
+  ]);
+  return holders.asArray();
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Zapper
+  watchedHolders
 });

package/dist/cjs/preview/simulate/index.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 simulate_exports = {};
+__export(simulate_exports, {
+  PreviewSimulationError: () => import_errors.PreviewSimulationError,
+  simulateFacadeOperation: () => import_simulateFacadeOperation.simulateFacadeOperation,
+  simulateOperation: () => import_simulateOperation.simulateOperation,
+  simulatePoolOperation: () => import_simulatePoolOperation.simulatePoolOperation
+});
+module.exports = __toCommonJS(simulate_exports);
+var import_errors = require("./errors.js");
+var import_simulateFacadeOperation = require("./simulateFacadeOperation.js");
+var import_simulateOperation = require("./simulateOperation.js");
+var import_simulatePoolOperation = require("./simulatePoolOperation.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PreviewSimulationError,
+  simulateFacadeOperation,
+  simulateOperation,
+  simulatePoolOperation
+});

package/dist/cjs/preview/simulate/simulateFacadeOperation.js

@@ -0,0 +1,30 @@
+"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 simulateFacadeOperation_exports = {};
+__export(simulateFacadeOperation_exports, {
+  simulateFacadeOperation: () => simulateFacadeOperation
+});
+module.exports = __toCommonJS(simulateFacadeOperation_exports);
+async function simulateFacadeOperation(_input, _options) {
+  throw new Error("not yet implemented");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  simulateFacadeOperation
+});

package/dist/cjs/preview/simulate/simulateOperation.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 simulateOperation_exports = {};
+__export(simulateOperation_exports, {
+  simulateOperation: () => simulateOperation
+});
+module.exports = __toCommonJS(simulateOperation_exports);
+var import_parse = require("../parse/index.js");
+var import_simulateFacadeOperation = require("./simulateFacadeOperation.js");
+var import_simulatePoolOperation = require("./simulatePoolOperation.js");
+async function simulateOperation(input, options) {
+  const { operation } = input;
+  if ((0, import_parse.isPoolOperation)(operation)) {
+    return (0, import_simulatePoolOperation.simulatePoolOperation)({ ...input, operation }, options);
+  }
+  return (0, import_simulateFacadeOperation.simulateFacadeOperation)({ ...input, operation }, options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  simulateOperation
+});

package/dist/cjs/preview/simulate/simulatePoolOperation.js

@@ -0,0 +1,187 @@
+"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 simulatePoolOperation_exports = {};
+__export(simulatePoolOperation_exports, {
+  computePoolOpBalanceChanges: () => computePoolOpBalanceChanges,
+  simulatePoolOperation: () => simulatePoolOperation
+});
+module.exports = __toCommonJS(simulatePoolOperation_exports);
+var import_generated = require("../../abi/310/generated.js");
+var import_iERC20 = require("../../abi/iERC20.js");
+var import_iZapper = require("../../abi/iZapper.js");
+var import_sdk = require("../../sdk/index.js");
+var import_errors = require("./errors.js");
+var import_holders = require("./holders.js");
+function previewRead(operation) {
+  switch (operation.operation) {
+    case "Deposit":
+      return { functionName: "previewDeposit", amount: operation.assets };
+    case "Mint":
+      return { functionName: "previewMint", amount: operation.shares };
+    case "Withdraw":
+      return { functionName: "previewWithdraw", amount: operation.assets };
+    case "Redeem":
+      return { functionName: "previewRedeem", amount: operation.shares };
+  }
+}
+function outsideToken(operation) {
+  switch (operation.operation) {
+    case "Deposit":
+    case "Mint":
+      return operation.tokenIn;
+    case "Withdraw":
+    case "Redeem":
+      return operation.tokenOut;
+  }
+}
+function previewContract(operation) {
+  const { functionName, amount } = previewRead(operation);
+  if (operation.zapper) {
+    return {
+      address: operation.zapper,
+      abi: import_iZapper.iZapperAbi,
+      functionName,
+      args: [amount]
+    };
+  }
+  return {
+    address: operation.pool,
+    abi: import_generated.iPoolV310Abi,
+    functionName,
+    args: [amount]
+  };
+}
+async function simulatePoolOperation(input, options = {}) {
+  const { sdk, operation, wallet } = input;
+  const { blockNumber, logger } = options;
+  const { pool } = operation;
+  try {
+    const holders = (0, import_holders.watchedHolders)(operation, wallet);
+    const tokens = [outsideToken(operation), pool];
+    const balanceCalls = holders.flatMap(
+      (holder) => tokens.map((token) => ({ holder, token }))
+    );
+    const balanceContracts = balanceCalls.map(
+      ({ holder, token }) => ({
+        address: token,
+        abi: import_iERC20.ierc20Abi,
+        functionName: "balanceOf",
+        args: [holder]
+      })
+    );
+    const preview = previewContract(operation);
+    let results;
+    try {
+      results = await sdk.client.multicall({
+        allowFailure: false,
+        // `undefined` lets viem read at `latest`; `blockNumber` is only set for
+        // testnet forks pinned to a specific block.
+        blockNumber,
+        contracts: [...balanceContracts, preview]
+      });
+    } catch (cause) {
+      throw new import_errors.PreviewSimulationError([
+        {
+          source: "multicall",
+          detail: (0, import_errors.decodeSimulationError)({
+            error: cause instanceof Error ? cause : new Error(String(cause))
+          })
+        }
+      ]);
+    }
+    const previewAmount = results[balanceContracts.length];
+    const balances = new import_sdk.AddressMap();
+    for (const [i, { holder, token }] of balanceCalls.entries()) {
+      const tokenBalances = balances.get(holder) ?? new import_sdk.AddressMap();
+      tokenBalances.upsert(token, results[i]);
+      balances.upsert(holder, tokenBalances);
+    }
+    const before = (token, holder) => balances.get(holder)?.get(token) ?? 0n;
+    return {
+      status: "success",
+      balanceChanges: computePoolOpBalanceChanges(
+        operation,
+        wallet,
+        previewAmount,
+        before
+      )
+    };
+  } catch (cause) {
+    const error = (0, import_errors.asPreviewSimulationError)(cause, "multicall");
+    logger?.error(error, "pool operation simulation failed");
+    return { status: "failure", error };
+  }
+}
+function balanceLegs(operation, wallet, previewAmount) {
+  const { pool, receiver } = operation;
+  switch (operation.operation) {
+    case "Deposit":
+      return [
+        { address: wallet, token: operation.tokenIn, delta: -operation.assets },
+        { address: receiver, token: pool, delta: previewAmount }
+      ];
+    case "Mint":
+      return [
+        { address: wallet, token: operation.tokenIn, delta: -previewAmount },
+        { address: receiver, token: pool, delta: operation.shares }
+      ];
+    case "Withdraw":
+      return [
+        { address: operation.owner, token: pool, delta: -previewAmount },
+        {
+          address: receiver,
+          token: operation.tokenOut,
+          delta: operation.assets
+        }
+      ];
+    case "Redeem":
+      return [
+        { address: operation.owner, token: pool, delta: -operation.shares },
+        { address: receiver, token: operation.tokenOut, delta: previewAmount }
+      ];
+  }
+}
+function computePoolOpBalanceChanges(operation, wallet, previewAmount, before) {
+  const byAddress = new import_sdk.AddressMap();
+  for (const { address, token, delta } of balanceLegs(
+    operation,
+    wallet,
+    previewAmount
+  )) {
+    const beforeBalance = before(token, address);
+    const change = {
+      token,
+      before: beforeBalance,
+      after: beforeBalance + delta,
+      delta
+    };
+    const existing = byAddress.get(address);
+    if (existing) {
+      existing.changes.push(change);
+    } else {
+      byAddress.upsert(address, { address, changes: [change] });
+    }
+  }
+  return byAddress.values();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  computePoolOpBalanceChanges,
+  simulatePoolOperation
+});

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

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/cjs/{history → preview/trace}/errors.js

@@ -18,8 +18,6 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var errors_exports = {};
 __export(errors_exports, {
-  AdapterTraceAlignmentError: () => AdapterTraceAlignmentError,
-  ProtocolCallNotFoundError: () => ProtocolCallNotFoundError,
   TransferAlignmentError: () => TransferAlignmentError,
   UnexpectedFacadeEventOrderError: () => UnexpectedFacadeEventOrderError,
   UnknownAdapterError: () => UnknownAdapterError,
@@ -51,28 +49,6 @@ class WithdrawCollateralAlignmentError extends Error {
     this.name = "WithdrawCollateralAlignmentError";
   }
 }
-class ProtocolCallNotFoundError extends Error {
-  targetContract;
-  executeIndex;
-  constructor(targetContract, executeIndex) {
-    super(
-      `protocol call to ${targetContract} not found in trace for Execute #${executeIndex}`
-    );
-    this.name = "ProtocolCallNotFoundError";
-    this.targetContract = targetContract;
-    this.executeIndex = executeIndex;
-  }
-}
-class AdapterTraceAlignmentError extends Error {
-  constructor(expected, actual) {
-    super(`found ${actual} adapter traces for ${expected} execute events`);
-    this.expected = expected;
-    this.actual = actual;
-    this.name = "AdapterTracesAlignmentError";
-  }
-  expected;
-  actual;
-}
 class UnexpectedFacadeEventOrderError extends Error {
   constructor(e) {
     super(
@@ -93,8 +69,6 @@ class UnknownFacadeCallError extends Error {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AdapterTraceAlignmentError,
-  ProtocolCallNotFoundError,
   TransferAlignmentError,
   UnexpectedFacadeEventOrderError,
   UnknownAdapterError,

package/dist/cjs/preview/trace/extractAdapterCallTraces.js

@@ -0,0 +1,58 @@
+"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 extractAdapterCallTraces_exports = {};
+__export(extractAdapterCallTraces_exports, {
+  extractAdapterCallTraces: () => extractAdapterCallTraces
+});
+module.exports = __toCommonJS(extractAdapterCallTraces_exports);
+var import_viem = require("viem");
+var import_trace = require("../../common-utils/utils/trace.js");
+const WITHDRAW_PHANTOM_TOKEN_SELECTOR = (0, import_viem.toFunctionSelector)(
+  "withdrawPhantomToken(address,uint256)"
+);
+const GET_PHANTOM_TOKEN_INFO_SELECTOR = (0, import_viem.toFunctionSelector)(
+  "getPhantomTokenInfo()"
+);
+function isSynthesizedPhantomWithdrawal(siblings, index) {
+  const node = siblings[index];
+  if (node.type !== "CALL" || node.input.slice(0, 10).toLowerCase() !== WITHDRAW_PHANTOM_TOKEN_SELECTOR) {
+    return false;
+  }
+  const [token] = (0, import_viem.decodeAbiParameters)(
+    [{ type: "address" }, { type: "uint256" }],
+    `0x${node.input.slice(10)}`
+  );
+  for (let i = 0; i < index; i++) {
+    const sib = siblings[i];
+    if (sib.type === "STATICCALL" && sib.input.slice(0, 10).toLowerCase() === GET_PHANTOM_TOKEN_INFO_SELECTOR && (0, import_viem.isAddressEqual)(sib.to, token)) {
+      return true;
+    }
+  }
+  return false;
+}
+function extractAdapterCallTraces(facadeTrace) {
+  const subtraces = facadeTrace.calls ?? [];
+  return subtraces.filter(
+    (sub, index) => (0, import_trace.resolveProtocolCall)(sub) !== void 0 && !isSynthesizedPhantomWithdrawal(subtraces, index)
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractAdapterCallTraces
+});

package/dist/cjs/{history → preview/trace}/extractTransfers.js

@@ -22,9 +22,9 @@ __export(extractTransfers_exports, {
 });
 module.exports = __toCommonJS(extractTransfers_exports);
 var import_viem = require("viem");
-var import_generated = require("../abi/310/generated.js");
-var import_iERC20 = require("../abi/iERC20.js");
-var import_sdk = require("../sdk/index.js");
+var import_generated = require("../../abi/310/generated.js");
+var import_iERC20 = require("../../abi/iERC20.js");
+var import_sdk = require("../../sdk/index.js");
 var import_errors = require("./errors.js");
 function extractTransfers(logs, creditAccount, pool, creditFacade) {
   const ranges = buildOperationRanges(logs, creditFacade, creditAccount);
@@ -33,7 +33,7 @@ function extractTransfers(logs, creditAccount, pool, creditFacade) {
     return !!e && (e.eventName === "LiquidateCreditAccount" || e.eventName === "PartiallyLiquidateCreditAccount") && (0, import_viem.isAddressEqual)(e.args.creditAccount, creditAccount);
   });
   let currentEntries = [];
-  const executeResults = [];
+  const executeTransfers = [];
   const directTransfers = [];
   const phantomTokens = new import_sdk.AddressMap();
   const withdrawCollateralEvents = [];
@@ -42,20 +42,17 @@ function extractTransfers(logs, creditAccount, pool, creditFacade) {
     const facadeEvent = tryDecodeFacadeEvent(log, creditFacade);
     if (facadeEvent) {
       if (isExecute(facadeEvent, creditAccount)) {
-        executeResults.push({
-          transfers: currentEntries,
-          targetContract: facadeEvent.args.targetContract
-        });
+        executeTransfers.push(currentEntries);
       } else if (isLiquidation(facadeEvent, creditAccount)) {
         liquidationRemainingFunds = facadeEvent.args.remainingFunds;
       } else if (isWithdrawPhantomToken(facadeEvent, creditAccount)) {
-        const phantomExec = executeResults.pop();
-        if (!phantomExec) {
+        const phantomTransfers = executeTransfers.pop();
+        if (!phantomTransfers) {
           throw new Error(
             `WithdrawPhantomToken without preceding Execute at logIndex ${facadeEvent.logIndex}`
           );
         }
-        const rawDeposit = phantomExec.transfers.find(
+        const rawDeposit = phantomTransfers.find(
           (t) => (0, import_viem.isAddressEqual)(t.to, creditAccount)
         );
         if (!rawDeposit) {
@@ -99,7 +96,7 @@ function extractTransfers(logs, creditAccount, pool, creditFacade) {
     }
   }
   return {
-    executeResults,
+    executeTransfers,
     directTransfers,
     liquidationRemainingFunds,
     phantomTokens,

package/dist/cjs/{history → preview/trace}/findFacadeCalls.js

@@ -22,9 +22,9 @@ __export(findFacadeCalls_exports, {
 });
 module.exports = __toCommonJS(findFacadeCalls_exports);
 var import_viem = require("viem");
-var import_generated = require("../abi/310/generated.js");
+var import_generated = require("../../abi/310/generated.js");
+var import_trace = require("../../common-utils/utils/trace.js");
 var import_errors = require("./errors.js");
-var import_trace_utils = require("./trace-utils.js");
 const FACADE_CALL_TYPES = {
   multicall: "MultiCall",
   botMulticall: "BotMulticall",
@@ -48,7 +48,7 @@ function extractCreditAccount(operation, rawArgs, traceOutput) {
   return ca;
 }
 function findFacadeCalls(trace, creditFacade, creditAccount, register, strict) {
-  const facadeTraces = (0, import_trace_utils.collectTraces)(trace, creditFacade);
+  const facadeTraces = (0, import_trace.collectTraces)(trace, creditFacade);
   const results = [];
   for (const trace2 of facadeTraces) {
     const parsed = register.parseFunctionDataV2(

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

@@ -0,0 +1,30 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var trace_exports = {};
+module.exports = __toCommonJS(trace_exports);
+__reExport(trace_exports, require("./errors.js"), module.exports);
+__reExport(trace_exports, require("./extractAdapterCallTraces.js"), module.exports);
+__reExport(trace_exports, require("./extractTransfers.js"), module.exports);
+__reExport(trace_exports, require("./findFacadeCalls.js"), module.exports);
+__reExport(trace_exports, require("./types.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./errors.js"),
+  ...require("./extractAdapterCallTraces.js"),
+  ...require("./extractTransfers.js"),
+  ...require("./findFacadeCalls.js"),
+  ...require("./types.js")
+});