@gearbox-protocol/sdk 14.10.10 → 14.11.0-next.10

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

@@ -0,0 +1,47 @@
+"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 extractERC20Transfers_exports = {};
+__export(extractERC20Transfers_exports, {
+  extractERC20Transfers: () => extractERC20Transfers
+});
+module.exports = __toCommonJS(extractERC20Transfers_exports);
+var import_viem = require("viem");
+var import_iERC20 = require("../../abi/iERC20.js");
+function extractERC20Transfers(logs, watch) {
+  const parsed = (0, import_viem.parseEventLogs)({
+    abi: import_iERC20.ierc20Abi,
+    eventName: "Transfer",
+    logs
+  });
+  const transfers = [];
+  for (const log of parsed) {
+    const { from, to, value } = log.args;
+    const involved = watch.some(
+      (address) => (0, import_viem.isAddressEqual)(from, address) || (0, import_viem.isAddressEqual)(to, address)
+    );
+    if (involved) {
+      transfers.push({ token: log.address, amount: value, from, to });
+    }
+  }
+  return transfers;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractERC20Transfers
+});

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

@@ -0,0 +1,45 @@
+"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 holders_exports = {};
+__export(holders_exports, {
+  watchedHolders: () => watchedHolders
+});
+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 = {
+  watchedHolders
+});

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

@@ -0,0 +1,40 @@
+"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, {
+  ETH_SIMULATE_V1_NETWORKS: () => import_constants.ETH_SIMULATE_V1_NETWORKS,
+  PreviewSimulationError: () => import_errors.PreviewSimulationError,
+  simulateFacadeOperation: () => import_simulateFacadeOperation.simulateFacadeOperation,
+  simulateOperation: () => import_simulateOperation.simulateOperation,
+  simulatePoolOperation: () => import_simulatePoolOperation.simulatePoolOperation
+});
+module.exports = __toCommonJS(simulate_exports);
+var import_constants = require("./constants.js");
+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 = {
+  ETH_SIMULATE_V1_NETWORKS,
+  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/simulatePoolOpMulticall.js

@@ -0,0 +1,155 @@
+"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 simulatePoolOpMulticall_exports = {};
+__export(simulatePoolOpMulticall_exports, {
+  computePoolOpBalanceChanges: () => computePoolOpBalanceChanges,
+  simulatePoolOpMulticall: () => simulatePoolOpMulticall
+});
+module.exports = __toCommonJS(simulatePoolOpMulticall_exports);
+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");
+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 };
+  }
+}
+async function simulatePoolOpMulticall(input, options = {}) {
+  const { sdk, operation, wallet } = input;
+  const { blockNumber } = options;
+  const { underlying, pool } = operation;
+  const holders = (0, import_holders.watchedHolders)(operation, wallet);
+  const tokens = [underlying, 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 { functionName, amount } = previewRead(operation);
+  const previewContract = {
+    address: pool,
+    abi: import_generated.iPoolV310Abi,
+    functionName,
+    args: [amount]
+  };
+  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, previewContract]
+    });
+  } 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 {
+    balanceChanges: computePoolOpBalanceChanges(
+      operation,
+      wallet,
+      previewAmount,
+      before
+    ),
+    transfers: void 0
+  };
+}
+function balanceLegs(operation, wallet, previewAmount) {
+  const { underlying, pool, receiver } = operation;
+  switch (operation.operation) {
+    case "Deposit":
+      return [
+        { address: wallet, token: underlying, delta: -operation.assets },
+        { address: receiver, token: pool, delta: previewAmount }
+      ];
+    case "Mint":
+      return [
+        { address: wallet, token: underlying, delta: -previewAmount },
+        { address: receiver, token: pool, delta: operation.shares }
+      ];
+    case "Withdraw":
+      return [
+        { address: operation.owner, token: pool, delta: -previewAmount },
+        { address: receiver, token: underlying, delta: operation.assets }
+      ];
+    case "Redeem":
+      return [
+        { address: operation.owner, token: pool, delta: -operation.shares },
+        { address: receiver, token: underlying, 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,
+  simulatePoolOpMulticall
+});

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

@@ -0,0 +1,106 @@
+"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 simulatePoolOpV1_exports = {};
+__export(simulatePoolOpV1_exports, {
+  simulatePoolOpV1: () => simulatePoolOpV1
+});
+module.exports = __toCommonJS(simulatePoolOpV1_exports);
+var import_actions = require("viem/actions");
+var import_iERC20 = require("../../abi/iERC20.js");
+var import_errors = require("./errors.js");
+var import_extractERC20Transfers = require("./extractERC20Transfers.js");
+var import_holders = require("./holders.js");
+async function simulatePoolOpV1(input, options = {}) {
+  const { sdk, operation, to, calldata, wallet } = input;
+  const { blockNumber } = options;
+  const { underlying, pool } = operation;
+  const holders = (0, import_holders.watchedHolders)(operation, wallet);
+  const tokens = [underlying, pool];
+  const balanceOf = (token, holder) => ({
+    to: token,
+    abi: import_iERC20.ierc20Abi,
+    functionName: "balanceOf",
+    args: [holder]
+  });
+  const balanceCalls = holders.flatMap(
+    (holder) => tokens.map((token) => balanceOf(token, holder))
+  );
+  let results;
+  try {
+    ({ results } = await (0, import_actions.simulateCalls)(sdk.client, {
+      account: wallet,
+      // `undefined` lets viem simulate at `latest`; `blockNumber` is only set
+      // for testnet forks pinned to a specific block.
+      blockNumber,
+      calls: [...balanceCalls, { to, data: calldata }, ...balanceCalls]
+    }));
+  } catch (cause) {
+    throw new import_errors.PreviewSimulationError([
+      {
+        source: "eth_simulateV1",
+        detail: (0, import_errors.decodeSimulationError)({
+          error: cause instanceof Error ? cause : new Error(String(cause))
+        })
+      }
+    ]);
+  }
+  const sim = results;
+  const txIndex = balanceCalls.length;
+  const afterOffset = txIndex + 1;
+  const txResult = sim[txIndex];
+  if (!txResult || txResult.status === "failure") {
+    throw new import_errors.PreviewSimulationError([
+      {
+        source: "eth_simulateV1",
+        detail: (0, import_errors.decodeSimulationError)({
+          error: txResult?.error,
+          data: txResult?.data
+        })
+      }
+    ]);
+  }
+  const balanceChanges = [];
+  for (const [holderIndex, address] of holders.entries()) {
+    const changes = [];
+    for (const [tokenIndex, token] of tokens.entries()) {
+      const slot = holderIndex * tokens.length + tokenIndex;
+      const before = readBalance(sim[slot]);
+      const after = readBalance(sim[afterOffset + slot]);
+      const delta = after - before;
+      const magnitude = delta >= 0n ? delta : -delta;
+      if (magnitude > 1n) {
+        changes.push({ token, before, after, delta });
+      }
+    }
+    if (changes.length > 0) {
+      balanceChanges.push({ address, changes });
+    }
+  }
+  return {
+    transfers: (0, import_extractERC20Transfers.extractERC20Transfers)(txResult.logs ?? [], holders),
+    balanceChanges
+  };
+}
+function readBalance(result) {
+  return result?.status === "success" ? result.result : 0n;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  simulatePoolOpV1
+});

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

@@ -0,0 +1,62 @@
+"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, {
+  simulatePoolOperation: () => simulatePoolOperation
+});
+module.exports = __toCommonJS(simulatePoolOperation_exports);
+var import_constants = require("./constants.js");
+var import_errors = require("./errors.js");
+var import_simulatePoolOpMulticall = require("./simulatePoolOpMulticall.js");
+var import_simulatePoolOpV1 = require("./simulatePoolOpV1.js");
+async function simulatePoolOperation(input, options = {}) {
+  const { sdk } = input;
+  const { logger } = options;
+  const useSimulateV1 = options.useSimulateV1 ?? import_constants.ETH_SIMULATE_V1_NETWORKS.has(sdk.networkType);
+  logger?.debug(
+    { wallet: input.wallet, to: input.to },
+    "simulating pool operation"
+  );
+  const [v1, multicall] = await Promise.allSettled([
+    useSimulateV1 ? (0, import_simulatePoolOpV1.simulatePoolOpV1)(input, options) : void 0,
+    (0, import_simulatePoolOpMulticall.simulatePoolOpMulticall)(input, options)
+  ]);
+  if (v1.status === "fulfilled" && v1.value) {
+    return { status: "success", ...v1.value };
+  }
+  if (multicall.status === "fulfilled") {
+    if (v1.status === "rejected") {
+      logger?.debug(
+        (0, import_errors.asPreviewSimulationError)(v1.reason, "eth_simulateV1"),
+        "eth_simulateV1 flow failed; falling back to multicall result"
+      );
+    }
+    return { status: "success", ...multicall.value };
+  }
+  const error = (0, import_errors.combinePreviewSimulationErrors)(
+    v1.status === "rejected" ? (0, import_errors.asPreviewSimulationError)(v1.reason, "eth_simulateV1") : void 0,
+    (0, import_errors.asPreviewSimulationError)(multicall.reason, "multicall")
+  );
+  logger?.error(error, "pool operation simulation failed");
+  return { status: "failure", error };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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
+});