@gearbox-protocol/sdk 9.14.1 → 9.15.1

package/dist/cjs/permissionless/bindings/pricefeeds/pyth.js

@@ -0,0 +1,65 @@
+"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 pyth_exports = {};
+__export(pyth_exports, {
+  pythPriceFeed: () => pythPriceFeed
+});
+module.exports = __toCommonJS(pyth_exports);
+var import_viem = require("viem");
+const pythPriceFeed = {
+  contractType: "PRICE_FEED::PYTH",
+  version: 310,
+  constructorParams: [
+    {
+      label: "token",
+      type: { type: "address" },
+      displayOrder: 1
+    },
+    {
+      label: "priceFeedId",
+      type: {
+        type: "bytes32",
+        formatValue: (value) => {
+          if (value.startsWith("0x") && value.length === 66) {
+            return value;
+          }
+          return (0, import_viem.toHex)(value, { size: 32 });
+        }
+      }
+    },
+    {
+      label: "pyth",
+      type: { type: "address" }
+    },
+    {
+      label: "maxConfToPriceRatio",
+      type: { type: "uint256" }
+    },
+    {
+      label: "descriptionTicker",
+      type: { type: "string", maxLen: 32 },
+      displayOrder: 2
+    }
+  ],
+  stalenessPeriod: true
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pythPriceFeed
+});

package/dist/cjs/permissionless/bindings/pricefeeds/redstone.js

@@ -0,0 +1,81 @@
+"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 redstone_exports = {};
+__export(redstone_exports, {
+  redstonePriceFeed: () => redstonePriceFeed
+});
+module.exports = __toCommonJS(redstone_exports);
+var import_viem = require("viem");
+const redstonePriceFeed = {
+  contractType: "PRICE_FEED::REDSTONE",
+  version: 310,
+  constructorParams: [
+    {
+      label: "token",
+      type: { type: "address" },
+      displayOrder: 1
+    },
+    {
+      label: "dataServiceId",
+      type: { type: "string" },
+      defaultValue: "redstone-primary-prod",
+      displayOrder: 3
+    },
+    {
+      label: "dataFeedId",
+      type: {
+        type: "bytes32",
+        formatValue: (value) => (0, import_viem.toHex)(value, { size: 32 })
+      },
+      displayOrder: 4
+    },
+    {
+      label: "signer",
+      type: {
+        type: "addressArrayFixed",
+        qty: 10,
+        minNonZero: 0,
+        minNonZeroRefLabel: "signersThreshold"
+      },
+      defaultValue: [
+        "0x8BB8F32Df04c8b654987DAaeD53D6B6091e3B774",
+        "0xdEB22f54738d54976C4c0fe5ce6d408E40d88499",
+        "0x51Ce04Be4b3E32572C4Ec9135221d0691Ba7d202",
+        "0xDD682daEC5A90dD295d14DA4b0bec9281017b5bE",
+        "0x9c5AE89C4Af6aA32cE58588DBaF90d18a855B6de"
+      ],
+      displayOrder: 6
+    },
+    {
+      label: "signersThreshold",
+      type: { type: "uint8" },
+      displayOrder: 5
+    },
+    {
+      label: "descriptionTicker",
+      type: { type: "string", maxLen: 32 },
+      displayOrder: 2
+    }
+  ],
+  stalenessPeriod: true
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  redstonePriceFeed
+});

package/dist/cjs/permissionless/bindings/pricefeeds/wsteth.js

@@ -0,0 +1,63 @@
+"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 wsteth_exports = {};
+__export(wsteth_exports, {
+  wstethPriceFeed: () => wstethPriceFeed
+});
+module.exports = __toCommonJS(wsteth_exports);
+var import_viem = require("viem");
+const wstethPriceFeed = {
+  contractType: "PRICE_FEED::WSTETH",
+  version: 310,
+  constructorParams: [
+    {
+      label: "priceStore",
+      type: { type: "owner" }
+    },
+    {
+      label: "lowerbound",
+      type: {
+        type: "lowerbound",
+        getter: async (values, publicClient) => {
+          const { wstETH } = values;
+          return await publicClient.readContract({
+            abi: (0, import_viem.parseAbi)([
+              "function stEthPerToken() external view returns (uint256)"
+            ]),
+            address: wstETH,
+            functionName: "stEthPerToken"
+          });
+        }
+      }
+    },
+    {
+      label: "wstETH",
+      type: { type: "address" }
+    },
+    {
+      label: "underlyingPriceFeed",
+      type: { type: "pricefeedParamsFlattened" }
+    }
+  ],
+  stalenessPeriod: false
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  wstethPriceFeed
+});

package/dist/cjs/permissionless/bindings/pricefeeds/zero.js

@@ -0,0 +1,33 @@
+"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 zero_exports = {};
+__export(zero_exports, {
+  zeroPriceFeed: () => zeroPriceFeed
+});
+module.exports = __toCommonJS(zero_exports);
+const zeroPriceFeed = {
+  contractType: "PRICE_FEED::ZERO",
+  version: 310,
+  constructorParams: [],
+  stalenessPeriod: false
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  zeroPriceFeed
+});

package/dist/cjs/permissionless/bindings/router/index.js

@@ -0,0 +1,22 @@
+"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 router_exports = {};
+module.exports = __toCommonJS(router_exports);
+__reExport(router_exports, require("./routing-manager.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./routing-manager.js")
+});

package/dist/cjs/permissionless/bindings/router/routing-manager.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 routing_manager_exports = {};
+__export(routing_manager_exports, {
+  RoutingManagerContract: () => RoutingManagerContract
+});
+module.exports = __toCommonJS(routing_manager_exports);
+var import_viem = require("viem");
+var import_routingManager = require("../../../abi/router/routingManager.js");
+var import_base_contract = require("../base-contract.js");
+const abi = import_routingManager.routingManagerAbi;
+class RoutingManagerContract extends import_base_contract.BaseContract {
+  constructor(address, client) {
+    super(abi, address, client, "RoutingManager");
+  }
+  parseFunctionParams(params) {
+    const { functionName, args } = params;
+    switch (functionName) {
+      case "setAdapterToWorkerType": {
+        const [adapterType, workerType] = args;
+        return {
+          chainId: 0,
+          target: this.address,
+          label: this.name,
+          functionName,
+          args: {
+            adapterType: (0, import_viem.hexToString)(adapterType, {
+              size: 32
+            }),
+            workerType: (0, import_viem.hexToString)(workerType, { size: 32 })
+          }
+        };
+      }
+      default:
+        return void 0;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RoutingManagerContract
+});

package/dist/cjs/permissionless/bindings/treasury-splitter.js

@@ -0,0 +1,60 @@
+"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 treasury_splitter_exports = {};
+__export(treasury_splitter_exports, {
+  TreasurySplitterContract: () => TreasurySplitterContract
+});
+module.exports = __toCommonJS(treasury_splitter_exports);
+var import_iTreasurySplitter = require("../../abi/310/iTreasurySplitter.js");
+var import_base_contract = require("./base-contract.js");
+const abi = import_iTreasurySplitter.ITreasurySplitterAbi;
+class TreasurySplitterContract extends import_base_contract.BaseContract {
+  constructor(address, client) {
+    super(abi, address, client, "TreasurySplitter");
+  }
+  distribute(token) {
+    return this.createRawTx({
+      functionName: "distribute",
+      args: [token]
+    });
+  }
+  parseFunctionParams(params) {
+    const { functionName, args } = params;
+    switch (functionName) {
+      case "distribute": {
+        const [token] = args;
+        return {
+          chainId: 0,
+          target: this.address,
+          label: this.name,
+          functionName,
+          args: {
+            token
+          }
+        };
+      }
+      default:
+        return void 0;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TreasurySplitterContract
+});

package/dist/cjs/permissionless/bindings/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/permissionless/chains/archive-transport.js

@@ -0,0 +1,274 @@
+"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 archive_transport_exports = {};
+__export(archive_transport_exports, {
+  ArchiveTransport: () => ArchiveTransport
+});
+module.exports = __toCommonJS(archive_transport_exports);
+var import_viem = require("viem");
+class ArchiveTransport {
+  config;
+  primaryTransport;
+  archiveTransport;
+  cachedTransport;
+  constructor(config) {
+    this.config = {
+      retryCount: 3,
+      retryDelay: 150,
+      timeout: 1e4,
+      enableLogging: false,
+      ...config
+    };
+    this.primaryTransport = (0, import_viem.http)(this.config.primaryRpcUrl, {
+      retryCount: this.config.retryCount,
+      retryDelay: this.config.retryDelay,
+      timeout: this.config.timeout
+    });
+    this.archiveTransport = (0, import_viem.http)(this.config.archiveRpcUrl, {
+      retryCount: this.config.retryCount,
+      retryDelay: this.config.retryDelay,
+      timeout: this.config.timeout
+    });
+  }
+  /**
+   * Get the configured transport instance
+   */
+  getTransport() {
+    if (this.cachedTransport) {
+      return this.cachedTransport;
+    }
+    const transport = ({
+      chain,
+      retryCount: transportRetryCount,
+      timeout: transportTimeout
+    }) => {
+      const primaryClient = this.primaryTransport({
+        chain,
+        retryCount: transportRetryCount,
+        timeout: transportTimeout
+      });
+      const archiveClient = this.archiveTransport({
+        chain,
+        retryCount: transportRetryCount,
+        timeout: transportTimeout
+      });
+      return {
+        config: {
+          key: "archive-class",
+          name: "Archive Transport Class",
+          request: primaryClient.config.request,
+          retryCount: transportRetryCount ?? this.config.retryCount,
+          retryDelay: this.config.retryDelay,
+          timeout: transportTimeout ?? this.config.timeout,
+          type: "archive"
+        },
+        request: async (args) => {
+          const { method, params } = args;
+          if (method !== "eth_getLogs") {
+            return await primaryClient.request({ method, params });
+          }
+          try {
+            return await this.handleGetLogsRequest(
+              method,
+              params,
+              primaryClient,
+              archiveClient
+            );
+          } catch (error) {
+            this.log(
+              "Archive transport error, falling back to primary RPC:",
+              error
+            );
+            return await primaryClient.request({ method, params });
+          }
+        },
+        value: primaryClient.value
+      };
+    };
+    this.cachedTransport = transport;
+    return this.cachedTransport;
+  }
+  /**
+   * Handle eth_getLogs requests with intelligent routing
+   */
+  async handleGetLogsRequest(method, params, primaryClient, archiveClient) {
+    const latestBlockHex = await primaryClient.request({
+      method: "eth_blockNumber",
+      params: []
+    });
+    const latestBlock = parseInt(latestBlockHex, 16);
+    const thresholdBlock = latestBlock - this.config.blockThreshold;
+    const logsParams = params;
+    const filter = logsParams[0] || {};
+    const { fromBlock, toBlock } = this.parseBlockNumbers(filter, latestBlock);
+    const allRecent = fromBlock >= thresholdBlock;
+    const allHistorical = toBlock < thresholdBlock;
+    const spansBoth = fromBlock < thresholdBlock && toBlock >= thresholdBlock;
+    if (allRecent) {
+      this.log(`Primary RPC: blocks [${fromBlock}-${toBlock}]`);
+      return await primaryClient.request({
+        method,
+        params
+      });
+    } else if (allHistorical) {
+      this.log(`Archive RPC: blocks [${fromBlock}-${toBlock}]`);
+      return await archiveClient.request({ method, params });
+    } else if (spansBoth) {
+      return await this.handleSplitRequest(
+        method,
+        filter,
+        fromBlock,
+        toBlock,
+        thresholdBlock,
+        primaryClient,
+        archiveClient
+      );
+    } else {
+      return await primaryClient.request({
+        method,
+        params
+      });
+    }
+  }
+  /**
+   * Handle split requests that span both historical and recent blocks
+   */
+  async handleSplitRequest(method, filter, fromBlock, toBlock, thresholdBlock, primaryClient, archiveClient) {
+    this.log(
+      `Splitting request: historical [${fromBlock}-${thresholdBlock - 1}] + recent [${thresholdBlock}-${toBlock}]`
+    );
+    const historicalFilter = {
+      ...filter,
+      fromBlock: `0x${fromBlock.toString(16)}`,
+      toBlock: `0x${(thresholdBlock - 1).toString(16)}`
+    };
+    const recentFilter = {
+      ...filter,
+      fromBlock: `0x${thresholdBlock.toString(16)}`,
+      toBlock: `0x${toBlock.toString(16)}`
+    };
+    try {
+      const [historicalResult, recentResult] = await Promise.all([
+        archiveClient.request({ method, params: [historicalFilter] }),
+        primaryClient.request({ method, params: [recentFilter] })
+      ]);
+      const historicalLogs = historicalResult;
+      const recentLogs = recentResult;
+      const mergedLogs = [...historicalLogs, ...recentLogs];
+      mergedLogs.sort((a, b) => {
+        const blockA = parseInt(a.blockNumber, 16);
+        const blockB = parseInt(b.blockNumber, 16);
+        if (blockA !== blockB) {
+          return blockA - blockB;
+        }
+        const logIndexA = parseInt(a.logIndex || "0x0", 16);
+        const logIndexB = parseInt(b.logIndex || "0x0", 16);
+        return logIndexA - logIndexB;
+      });
+      this.log(
+        `Merged ${historicalLogs.length} historical + ${recentLogs.length} recent = ${mergedLogs.length} total logs`
+      );
+      return mergedLogs;
+    } catch (error) {
+      this.log("Split request failed, falling back to archive RPC:", error);
+      return await archiveClient.request({
+        method,
+        params: [filter]
+      });
+    }
+  }
+  /**
+   * Parse block numbers from filter parameters
+   */
+  parseBlockNumbers(filter, latestBlock) {
+    let fromBlock;
+    let toBlock;
+    if (filter.fromBlock !== void 0) {
+      if (filter.fromBlock === "latest" || filter.fromBlock === "pending") {
+        fromBlock = latestBlock;
+      } else if (filter.fromBlock === "earliest") {
+        fromBlock = 0;
+      } else if (typeof filter.fromBlock === "string") {
+        fromBlock = parseInt(filter.fromBlock, 16);
+      } else {
+        fromBlock = filter.fromBlock;
+      }
+    }
+    if (filter.toBlock !== void 0) {
+      if (filter.toBlock === "latest" || filter.toBlock === "pending") {
+        toBlock = latestBlock;
+      } else if (filter.toBlock === "earliest") {
+        toBlock = 0;
+      } else if (typeof filter.toBlock === "string") {
+        toBlock = parseInt(filter.toBlock, 16);
+      } else {
+        toBlock = filter.toBlock;
+      }
+    }
+    return {
+      fromBlock: fromBlock ?? 0,
+      toBlock: toBlock ?? latestBlock
+    };
+  }
+  /**
+   * Log messages if logging is enabled
+   */
+  log(message, ...args) {
+    if (this.config.enableLogging) {
+      console.log(`[ArchiveTransport] ${message}`, ...args);
+    }
+  }
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update configuration (will invalidate cached transport)
+   */
+  updateConfig(updates) {
+    this.config = { ...this.config, ...updates };
+    this.cachedTransport = void 0;
+    if (updates.primaryRpcUrl) {
+      this.primaryTransport = (0, import_viem.http)(this.config.primaryRpcUrl, {
+        retryCount: this.config.retryCount,
+        retryDelay: this.config.retryDelay,
+        timeout: this.config.timeout
+      });
+    }
+    if (updates.archiveRpcUrl) {
+      this.archiveTransport = (0, import_viem.http)(this.config.archiveRpcUrl, {
+        retryCount: this.config.retryCount,
+        retryDelay: this.config.retryDelay,
+        timeout: this.config.timeout
+      });
+    }
+  }
+  /**
+   * Enable or disable logging
+   */
+  setLogging(enabled) {
+    this.config.enableLogging = enabled;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ArchiveTransport
+});

package/dist/cjs/permissionless/core/auditor.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 auditor_exports = {};
+module.exports = __toCommonJS(auditor_exports);