@gearbox-protocol/cli-utils 6.16.2 → 9.0.0-beta.11

package/dist/index.js

@@ -1,19 +1,1402 @@
-export * from "./CensoredString.js";
-export * from "./CensoredURL.js";
-export * from "./compressedConfig.js";
-export * from "./createPinoCensor.js";
-export * from "./fetchRetry.js";
-export * from "./getFirstHttpTransportOptions.js";
-export * from "./getProviders.js";
-export * from "./notifications/index.js";
-export * from "./providers.js";
-export * from "./providers-schema.js";
-export * from "./resolveYamlFiles.js";
-export * from "./SecretsManager.js";
-export * from "./SSMManager.js";
-export * from "./schema-primitives.js";
-export * from "./sleep.js";
-export * from "./uncensorMap.js";
-export * from "./Whitelist.js";
-export * from "./whitelist-schema.js";
-export * from "./Zommand.js";
+// src/CensoredString.ts
+var CensoredString = class _CensoredString {
+  #value;
+  #censored;
+  static transform(value) {
+    if (value instanceof _CensoredString) {
+      return value;
+    }
+    return new _CensoredString(value);
+  }
+  constructor(value) {
+    this.#value = value;
+    const visibleLen = Math.min(4, Math.floor(0.2 * value.length));
+    if (visibleLen < 1) {
+      this.#censored = "*".repeat(Math.min(8, value.length));
+    } else {
+      this.#censored = "*".repeat(Math.min(8, value.length - visibleLen)) + value.slice(-1 * visibleLen);
+    }
+  }
+  get value() {
+    return this.#value;
+  }
+  toString() {
+    return this.#censored;
+  }
+  toJSON() {
+    return this.toString();
+  }
+};
+
+// src/CensoredURL.ts
+var CensoredURL = class _CensoredURL {
+  #value;
+  #censored;
+  static transform(value) {
+    if (value instanceof _CensoredURL) {
+      return value;
+    }
+    return new _CensoredURL(value);
+  }
+  constructor(url) {
+    this.#value = url;
+    if (url.includes("127.0.0.1") || url.includes("localhost") || url.includes("host.docker.internal")) {
+      this.#censored = url;
+    } else {
+      try {
+        const u = new URL(url);
+        if (u.username || u.password) {
+          u.username = u.username ? "****" : "";
+          u.password = u.password ? "****" : "";
+        }
+        u.pathname = "/";
+        u.search = "";
+        this.#censored = `${u.href}******`;
+      } catch {
+        const visibleLen = Math.min(4, Math.floor(0.2 * url.length));
+        if (visibleLen < 1) {
+          this.#censored = "*".repeat(Math.min(8, url.length));
+        } else {
+          this.#censored = "*".repeat(Math.min(8, url.length - visibleLen)) + url.slice(-1 * visibleLen);
+        }
+      }
+    }
+  }
+  get value() {
+    return this.#value;
+  }
+  toString() {
+    return this.#censored;
+  }
+  toJSON() {
+    return this.toString();
+  }
+};
+
+// src/compressedConfig.ts
+import { deflateSync, inflateSync } from "zlib";
+
+// src/resolveYamlFiles.ts
+import { readFile } from "fs/promises";
+import { dirname, resolve as pathResolve } from "path";
+import { GetObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import YAML, { isPair, isScalar, isSeq } from "yaml";
+
+// src/getPromisePath.ts
+async function getPromisePath(object, path) {
+  return getPromised(object, path.split("."));
+}
+async function getPromised(object, keys) {
+  if (keys.length === 0) {
+    return Promise.resolve(object);
+  }
+  const [key, ...rest] = keys;
+  const value = object[key];
+  const resolved = await Promise.resolve(value);
+  return getPromised(resolved, rest);
+}
+
+// src/resolveYamlFiles.ts
+var templateKeyRegex = /\$\{([\w-]+(?:\.[\w-]+)*)(?::-([^}]*))?\}/g;
+async function resolveScalarValue(val, templateData) {
+  const matches = val.matchAll(templateKeyRegex);
+  for (const match of matches) {
+    const [whole, key, defaultValue] = match;
+    const resolved = await getPromisePath(templateData, key);
+    if (resolved !== void 0 && resolved !== null && resolved !== "") {
+      val = val.replace(whole, String(resolved));
+    } else if (defaultValue !== void 0) {
+      val = val.replace(whole, defaultValue);
+    }
+  }
+  return val;
+}
+async function resolveYamlFiles(file, templateData) {
+  const doc = await resolveYamlDoc(file, templateData);
+  const obj = doc.toJSON();
+  return Object.fromEntries(
+    Object.entries(obj).filter(([k]) => !k.startsWith("x-"))
+  );
+}
+async function resolveYamlDoc(file, templateData) {
+  const content = await loadFile(file);
+  let cfgRaw = YAML.parseDocument(content, { merge: true });
+  if (cfgRaw.has("extends")) {
+    const baseFile = cfgRaw.get("extends");
+    const extended = cfgRaw;
+    cfgRaw = await resolveYamlDoc(
+      getRelativePath(file, baseFile),
+      templateData
+    );
+    YAML.visit(extended, {
+      Pair(_, pair, rawPath) {
+        const path = getNodesPath(rawPath);
+        if (isScalar(pair.key) && (isScalar(pair.value) || isSeq(pair.value))) {
+          if (pair.key.value === "extends") {
+            return;
+          }
+          cfgRaw.setIn([...path, pair.key.value], pair.value);
+          return YAML.visit.SKIP;
+        }
+      }
+    });
+  }
+  await YAML.visitAsync(cfgRaw, {
+    Scalar: async (_, node) => {
+      if (typeof node.value === "string") {
+        node.value = await resolveScalarValue(node.value, templateData);
+      }
+    }
+  });
+  return cfgRaw;
+}
+async function resolveFromObject(json, templateData) {
+  const content = YAML.stringify(json);
+  const cfgRaw = YAML.parseDocument(content, { merge: true });
+  await YAML.visitAsync(cfgRaw, {
+    Scalar: async (_, node) => {
+      if (typeof node.value === "string") {
+        node.value = await resolveScalarValue(node.value, templateData);
+      }
+    }
+  });
+  return cfgRaw.toJSON();
+}
+function getNodesPath(nodes) {
+  return nodes.map((n) => {
+    if (isPair(n) && isScalar(n.key)) {
+      return n.key.value;
+    }
+    return "";
+  }).filter(Boolean);
+}
+async function loadFile(file) {
+  if (file.startsWith("s3://")) {
+    return await loadS3File(file);
+  }
+  return await readFile(file, "utf-8");
+}
+async function loadS3File(file) {
+  const url = new URL(file);
+  const bucket = url.hostname;
+  const key = url.pathname.slice(1);
+  const s3 = new S3Client({});
+  const response = await s3.send(
+    new GetObjectCommand({
+      Bucket: bucket,
+      Key: key
+    })
+  );
+  if (!response.Body) {
+    throw new Error(`file ${file} not found`);
+  }
+  return response.Body.transformToString("utf-8");
+}
+function getRelativePath(baseFile, relativeFile) {
+  if (baseFile.startsWith("s3://")) {
+    const url = new URL(baseFile);
+    const relPathname = pathResolve(dirname(url.pathname), relativeFile);
+    url.pathname = relPathname;
+    return url.toString();
+  }
+  return pathResolve(dirname(baseFile), relativeFile);
+}
+
+// src/compressedConfig.ts
+function compressObject(obj) {
+  const json = JSON.stringify(obj);
+  const compressed = deflateSync(Buffer.from(json, "utf8"));
+  return compressed.toString("base64url");
+}
+async function decompressObject(value, templateData) {
+  const compressed = Buffer.from(value, "base64url");
+  const str = inflateSync(compressed).toString("utf8");
+  const json = JSON.parse(str);
+  const result = await resolveFromObject(json, templateData);
+  return result;
+}
+
+// src/createPinoCensor.ts
+var MIN_SECRET_LENGTH = 4;
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function collectSecrets(value, out) {
+  if (value == null) {
+    return;
+  }
+  if (value instanceof CensoredString || value instanceof CensoredURL) {
+    const raw = value.value;
+    if (raw.length >= MIN_SECRET_LENGTH) {
+      out.set(raw, value.toString());
+    }
+    return;
+  }
+  if (typeof value !== "object") {
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      collectSecrets(item, out);
+    }
+    return;
+  }
+  for (const item of Object.values(value)) {
+    collectSecrets(item, out);
+  }
+}
+function createPinoCensor(config) {
+  const map = /* @__PURE__ */ new Map();
+  collectSecrets(config, map);
+  if (map.size === 0) {
+    return (s) => s;
+  }
+  const pattern = [...map.keys()].sort((a, b) => b.length - a.length).map(escapeRegExp).join("|");
+  const re = new RegExp(pattern, "g");
+  return (s) => s.replace(re, (m) => map.get(m) ?? m);
+}
+
+// src/sleep.ts
+async function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+
+// src/fetchRetry.ts
+var DEFAULT_RETRIES = 5;
+var DEFAULT_RETRY_INTERVAL = 1e3;
+async function fetchRetry(input, init = {}) {
+  const {
+    retries = DEFAULT_RETRIES,
+    retryInterval = DEFAULT_RETRY_INTERVAL,
+    validateResponse,
+    ...options
+  } = init;
+  try {
+    const response = await fetch(input, options);
+    validateResponse?.(response);
+    return response;
+  } catch (e) {
+    if (retries > 0) {
+      await sleep(retryInterval);
+      return fetchRetry(input, {
+        ...options,
+        retries: retries - 1,
+        retryInterval,
+        validateResponse
+      });
+    } else {
+      throw e;
+    }
+  }
+}
+
+// src/providers.ts
+import { chains, getChain } from "@gearbox-protocol/sdk";
+function getAlchemyUrl(network, apiKey, protocol = "http") {
+  const alchemyDomain = ALCHEMY_DOMAINS[network];
+  if (!alchemyDomain) {
+    return void 0;
+  }
+  return `${protocol}s://${alchemyDomain}.g.alchemy.com/v2/${apiKey}`;
+}
+var DRPC_NETS = {
+  Arbitrum: "arbitrum",
+  Base: "base",
+  BNB: "bsc",
+  Mainnet: "ethereum",
+  Optimism: "optimism",
+  Sonic: "sonic",
+  WorldChain: "worldchain",
+  Berachain: "berachain",
+  Avalanche: "avalanche",
+  Monad: "monad",
+  Hemi: "hemi",
+  Lisk: "lisk",
+  MegaETH: null,
+  Etherlink: null,
+  Plasma: "plasma",
+  Somnia: null
+};
+var ALCHEMY_DOMAINS = {
+  Mainnet: "eth-mainnet",
+  Arbitrum: "arb-mainnet",
+  Optimism: "opt-mainnet",
+  Base: "base-mainnet",
+  Sonic: "sonic-mainnet",
+  Monad: "monad-mainnet",
+  Berachain: "berachain-mainnet",
+  Avalanche: "avax-mainnet",
+  BNB: "bnb-mainnet",
+  WorldChain: "worldchain-mainnet",
+  MegaETH: null,
+  Etherlink: null,
+  Hemi: null,
+  Lisk: null,
+  Plasma: "plasma-mainnet",
+  Somnia: null
+};
+function getDrpcUrl(network, apiKey, protocol = "http") {
+  const net = DRPC_NETS[network];
+  return net ? `${protocol}s://lb.drpc.org/${net}/${apiKey}` : void 0;
+}
+var ANKR_DOMAINS = {
+  Arbitrum: "arbitrum",
+  Avalanche: "avalanche",
+  Base: "base",
+  Berachain: null,
+  BNB: "bsc",
+  Etherlink: "etherlink_mainnet",
+  Hemi: null,
+  Lisk: null,
+  Mainnet: "eth",
+  MegaETH: null,
+  Monad: null,
+  Optimism: "optimism",
+  Plasma: null,
+  Sonic: "sonic_mainnet",
+  WorldChain: null,
+  Somnia: "somnia_mainnet"
+};
+function getAnkrUrl(network, apiKey, protocol = "http") {
+  const net = ANKR_DOMAINS[network];
+  const sep = protocol === "ws" ? "/ws/" : "/";
+  return net ? `${protocol}s://rpc.ankr.com/${net}${sep}${apiKey}` : void 0;
+}
+var THIRDWEB_DOMAINS = {
+  Arbitrum: chains.Arbitrum.id.toString(),
+  Avalanche: chains.Avalanche.id.toString(),
+  Base: chains.Base.id.toString(),
+  Berachain: chains.Berachain.id.toString(),
+  BNB: chains.BNB.id.toString(),
+  Etherlink: chains.Etherlink.id.toString(),
+  Hemi: chains.Hemi.id.toString(),
+  Lisk: chains.Lisk.id.toString(),
+  Mainnet: chains.Mainnet.id.toString(),
+  MegaETH: chains.MegaETH.id.toString(),
+  Monad: chains.Monad.id.toString(),
+  Optimism: chains.Optimism.id.toString(),
+  Plasma: chains.Plasma.id.toString(),
+  Sonic: chains.Sonic.id.toString(),
+  WorldChain: chains.WorldChain.id.toString(),
+  Somnia: chains.Somnia.id.toString()
+};
+function getThirdWebUrl(network, apiKey, protocol = "http") {
+  if (protocol === "ws") {
+    return void 0;
+  }
+  const net = THIRDWEB_DOMAINS[network];
+  return `https://${net}.rpc.thirdweb.com/${apiKey}`;
+}
+function getErpcKey(network, projectId, urlBase) {
+  if (!projectId || !urlBase) {
+    return void 0;
+  }
+  const chain = getChain(network);
+  return `${urlBase}/${projectId}/evm/${chain.id}`;
+}
+
+// src/getProviders.ts
+function getProviders(config, logger) {
+  const {
+    network,
+    enabledProviders = [
+      "erpc",
+      "custom",
+      "drpc",
+      "alchemy",
+      "ankr",
+      "thirdweb"
+    ],
+    alchemyKeys = [],
+    ankrKeys = [],
+    drpcKeys = [],
+    thirdwebKeys = [],
+    jsonRpcProviders = [],
+    erpcProjectId,
+    erpcUrl
+  } = config;
+  const result = [];
+  for (const p of enabledProviders) {
+    switch (p) {
+      case "alchemy":
+        result.push(
+          ...alchemyKeys.map((k) => ({
+            name: "alchemy",
+            url: getAlchemyUrl(network, k.value)
+          }))
+        );
+        break;
+      case "drpc":
+        result.push(
+          ...drpcKeys.map((k) => ({
+            name: "drpc",
+            url: getDrpcUrl(network, k.value)
+          }))
+        );
+        break;
+      case "ankr":
+        result.push(
+          ...ankrKeys.map((k) => ({
+            name: "ankr",
+            url: getAnkrUrl(network, k.value)
+          }))
+        );
+        break;
+      case "thirdweb":
+        result.push(
+          ...thirdwebKeys.map((k) => ({
+            name: "thirdweb",
+            url: getThirdWebUrl(network, k.value)
+          }))
+        );
+        break;
+      case "custom":
+        result.push(
+          ...jsonRpcProviders.map((url) => {
+            const urlObj = new URL(url.value);
+            const hasCredentials = urlObj.username || urlObj.password;
+            let cleanUrl = url.value;
+            let httpTransportOptions = {};
+            if (hasCredentials) {
+              const cleanUrlObj = new URL(url.value);
+              cleanUrlObj.username = "";
+              cleanUrlObj.password = "";
+              cleanUrl = cleanUrlObj.toString();
+              const credentials = `${urlObj.username}:${urlObj.password}`;
+              const encodedCredentials = Buffer.from(credentials).toString("base64");
+              httpTransportOptions = {
+                fetchOptions: {
+                  headers: {
+                    Authorization: `Basic ${encodedCredentials}`
+                  }
+                }
+              };
+            }
+            return {
+              name: getTopLevelDomain(urlObj),
+              url: cleanUrl,
+              httpTransportOptions
+            };
+          })
+        );
+        break;
+      case "erpc":
+        if (erpcProjectId && erpcUrl) {
+          result.push({
+            name: "erpc",
+            url: getErpcKey(network, erpcProjectId, erpcUrl)
+          });
+        }
+        break;
+    }
+  }
+  if (logger) {
+    const providers = result.filter((p) => !!p.url).map((p) => ({
+      name: p.name,
+      url: new CensoredURL(p.url)
+    }));
+    logger.debug({ providers, network }, "gathered providers");
+  }
+  return result.map((p) => ({
+    ...p,
+    httpClientOptions: {
+      ...p.httpTransportOptions,
+      methods: { exclude: ["eth_fillTransaction"] }
+    }
+  })).filter((p) => !!p.url);
+}
+function getTopLevelDomain({ hostname }) {
+  const parts = hostname.split(".");
+  return parts.length >= 2 ? parts.slice(-2).join(".") : hostname;
+}
+
+// src/getFirstHttpTransportOptions.ts
+function getFirstHttpTransportOptions(config) {
+  const [provider] = getProviders(config);
+  if (!provider) {
+    throw new Error("No provider found");
+  }
+  return {
+    url: provider.url,
+    config: {
+      ...provider.httpTransportOptions
+    }
+  };
+}
+
+// src/notifications/createNotifier.ts
+import { prettifyError } from "zod";
+
+// src/notifications/SlackNotifier.ts
+var SlackNotifier = class {
+  #config;
+  #logger;
+  constructor(config, logger) {
+    this.#config = config;
+    this.#logger = logger;
+  }
+  notify(message, severity) {
+    if (this.#config.alertsOnly && severity === "notification") {
+      return;
+    }
+    const emoji = severity === "alert" ? "\u{1F6A8}" : "\u2139\uFE0F";
+    const messageText = typeof message === "string" ? message : message.plain;
+    void this.#sendToSlack(`${emoji} Alert: ${messageText}`);
+  }
+  async #sendToSlack(text) {
+    try {
+      this.#logger?.debug(`Sending message to Slack: ${text}`);
+      const response = await fetch(this.#config.webhookUrl.value, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({ text })
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+      this.#logger?.debug("Slack message sent successfully");
+    } catch (error) {
+      this.#logger?.error("Error sending Slack message:", error);
+      throw error;
+    }
+  }
+};
+
+// src/notifications/schema.ts
+import { z as z2 } from "zod/v4";
+
+// src/schema-primitives.ts
+import { getAddress, isAddress } from "viem";
+import { z } from "zod/v4";
+var boolLike = () => z.any().transform((v) => {
+  if (typeof v === "string") {
+    return ["true", "1"].includes(v.toLowerCase());
+  }
+  return Boolean(v);
+});
+var stringArrayLike = () => z.union([z.array(z.string()), z.string().transform((val) => val.split(","))]);
+var optionalStringArrayLike = () => stringArrayLike().optional().transform((v) => v?.length ? v : void 0);
+var addressLike = () => z.string().transform((val, ctx) => {
+  if (!isAddress(val)) {
+    ctx.issues.push({
+      code: "custom",
+      message: `invalid address ${val}`,
+      input: ctx.value
+    });
+  }
+  return getAddress(val);
+});
+var addressArrayLike = () => stringArrayLike().pipe(z.array(addressLike()));
+var optionalAddressArrayLike = () => stringArrayLike().pipe(z.array(addressLike())).optional().transform((v) => v?.length ? v : void 0);
+
+// src/notifications/schema.ts
+var TelegramConfig = z2.object({
+  type: z2.literal("telegram"),
+  token: z2.union([z2.string(), z2.instanceof(CensoredString)]).transform(CensoredString.transform),
+  alertsChannel: z2.union([z2.string().startsWith("-"), z2.instanceof(CensoredString)]).transform(CensoredString.transform),
+  /**
+   * Optional channel to send notifications to
+   * If not set, notifications will not be sent
+   */
+  notificationsChannel: z2.union([z2.string().startsWith("-"), z2.instanceof(CensoredString)]).transform(CensoredString.transform).optional(),
+  prefix: z2.string().optional()
+});
+var SlackConfig = z2.object({
+  type: z2.literal("slack"),
+  /**
+   * Slack webhook URL for sending notifications
+   */
+  webhookUrl: z2.union([z2.string(), z2.instanceof(CensoredString)]).transform(CensoredString.transform),
+  /**
+   * If true, only alerts will be sent. Informational notifications are suppressed
+   */
+  alertsOnly: boolLike().optional()
+});
+var NotificationConfig = z2.discriminatedUnion("type", [
+  TelegramConfig,
+  SlackConfig
+]);
+var SignlConfig = z2.object({
+  apiKey: z2.union([z2.string(), z2.instanceof(CensoredString)]).transform(CensoredString.transform),
+  teamId: z2.union([z2.string(), z2.instanceof(CensoredString)]).transform(CensoredString.transform)
+});
+
+// src/notifications/TelegramNotifier.ts
+import { md } from "@vlad-yakovlev/telegram-md";
+import Queue from "p-queue";
+import { withRetry } from "viem";
+
+// src/notifications/ThrottleManager.ts
+import { LRUCache } from "lru-cache";
+function defaultBackoffFn(prevWait) {
+  return Math.min(
+    prevWait ? prevWait * 2 : 10 * 60 * 1e3,
+    // 10 minutes
+    24 * 60 * 60 * 1e3
+    // 24 hours
+  );
+}
+var ThrottleManager = class {
+  #state = new LRUCache({ max: 5e3 });
+  /**
+   * Checks if it's permitted to send a message for the given dedupe key
+   * @returns
+   */
+  canSend(dedupeKey) {
+    if (!dedupeKey) {
+      return true;
+    }
+    const state = this.#getState(dedupeKey);
+    const timeSinceLastAlert = Date.now() - state.lastAlertTime;
+    return timeSinceLastAlert >= state.currentWait;
+  }
+  /**
+   * Records that notification was sent for the given dedupe key
+   */
+  onSent(dedupeKey, throttleFn = defaultBackoffFn) {
+    if (!dedupeKey) {
+      return;
+    }
+    const state = this.#getState(dedupeKey);
+    this.#state.set(dedupeKey, {
+      lastAlertTime: Date.now(),
+      currentWait: throttleFn(state.currentWait)
+    });
+  }
+  #getState(dedupeKey) {
+    return this.#state.get(dedupeKey) ?? { lastAlertTime: 0, currentWait: 0 };
+  }
+};
+
+// src/notifications/TelegramNotifier.ts
+var DEFAULT_RETRY_INTERVAL2 = 1e3;
+var DEFAULT_RETRY_COUNT = 5;
+var DEFAULT_MAX_CHUNK_SIZE = 4096;
+var TelegramNotifier = class {
+  #logger;
+  #alertsChannel;
+  #notificationsChannel;
+  #botToken;
+  #prefix;
+  #retryInterval;
+  #retryCount;
+  #maxChunkSize;
+  #fetchFn;
+  #queue = new Queue({
+    concurrency: 1,
+    // https://core.telegram.org/bots/faq#my-bot-is-hitting-limits-how-do-i-avoid-this
+    // 20 messages/minute limit
+    interval: 6e4,
+    intervalCap: 20,
+    strict: true
+  });
+  #throttleManager = new ThrottleManager();
+  constructor(opts, logger) {
+    this.#logger = logger;
+    this.#alertsChannel = opts.alertsChannel.value;
+    this.#botToken = opts.token.value;
+    this.#notificationsChannel = opts.notificationsChannel?.value;
+    this.#prefix = opts.prefix;
+    this.#retryInterval = opts.retryInterval ?? DEFAULT_RETRY_INTERVAL2;
+    this.#retryCount = opts.retryCount ?? DEFAULT_RETRY_COUNT;
+    this.#maxChunkSize = opts.maxChunkSize ?? DEFAULT_MAX_CHUNK_SIZE;
+    this.#fetchFn = opts.fetchFn ?? fetch;
+  }
+  notify(message, severity) {
+    const dest = severity === "alert" ? this.#alertsChannel : this.#notificationsChannel;
+    if (!dest) {
+      return;
+    }
+    this.#enqueueTelegram(message, dest, severity === "alert");
+  }
+  async #enqueueTelegram(message, channelId, severe = false) {
+    if (!this.#throttleManager.canSend(message.dedupeKey)) {
+      return;
+    }
+    const payloads = this.#toTelegramPayloads(message);
+    for (const payload of payloads) {
+      this.#queue.add(
+        () => this.#sendToTelegram(payload, channelId, severe).catch(
+          (e) => this.#logger?.error(e)
+        ),
+        {
+          priority: severe ? 100 : 0,
+          timeout: this.#retryInterval * this.#retryCount * 2
+        }
+      );
+    }
+    this.#throttleManager.onSent(message.dedupeKey, message.throttleFn);
+  }
+  async #sendToTelegram(payload, channelId, severe = false) {
+    const severity = severe ? "alert" : "notification";
+    this.#logger?.debug(
+      `sending telegram ${severity} to channel ${channelId}...`
+    );
+    const url = `https://api.telegram.org/bot${this.#botToken}/sendMessage`;
+    try {
+      await withRetry(
+        async () => {
+          const resp = await this.#fetchFn(url, {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              ...payload,
+              chat_id: channelId
+            })
+          });
+          if (resp.ok) {
+            this.#logger?.debug(`telegram ${severity} sent successfully`);
+          } else {
+            const txt = await resp.text();
+            throw new Error(`api error ${resp.status}: ${txt}`);
+          }
+        },
+        { delay: this.#retryInterval, retryCount: this.#retryCount }
+      );
+    } catch (e) {
+      this.#logger?.error(`cannot send telegram ${severity}: ${e}`);
+    }
+  }
+  #toTelegramPayloads(message) {
+    const { md: mdMessage, plain } = message;
+    if (!mdMessage) {
+      return this.#slicePlainText(plain);
+    }
+    let text = mdMessage;
+    if (this.#prefix) {
+      text = md.join([md.bold(this.#prefix), text], " ");
+    }
+    const mdText = text.toString();
+    if (mdText.length > this.#maxChunkSize) {
+      return this.#slicePlainText(plain);
+    }
+    return [{ text: mdText, parse_mode: "MarkdownV2" }];
+  }
+  /**
+   * Telegram has a limit on message size (default 4096 characters).
+   * This function slices the text into chunks respecting the limit.
+   * Each chunk is prefixed with the prefix (if set), ensuring the total length <= maxChunkSize.
+   * @param text - The text to slice.
+   * @returns An array of texts.
+   */
+  #slicePlainText(text) {
+    const chunks = [];
+    const prefix = this.#prefix ? `${this.#prefix} ` : "";
+    const maxChunkSize = this.#maxChunkSize - prefix.length;
+    for (let i = 0; i < text.length; i += maxChunkSize) {
+      const chunkText = text.slice(i, i + maxChunkSize);
+      chunks.push({ text: `${prefix}${chunkText}` });
+    }
+    return chunks;
+  }
+};
+
+// src/notifications/createNotifier.ts
+function createNotifier(config, logger) {
+  const parsed = NotificationConfig.safeParse(config);
+  if (!parsed.success) {
+    console.log(">>>>", parsed.error);
+    logger?.warn(`invalid notification config: ${prettifyError(parsed.error)}`);
+    return void 0;
+  }
+  switch (parsed.data.type) {
+    case "telegram":
+      return new TelegramNotifier(parsed.data, logger);
+    case "slack":
+      return new SlackNotifier(parsed.data, logger);
+  }
+}
+
+// src/notifications/NotificationsService.ts
+import { ADDRESS_0X0, AddressMap } from "@gearbox-protocol/sdk";
+
+// src/notifications/SignlNotifier.ts
+import { withRetry as withRetry2 } from "viem";
+var DEFAULT_RETRY_INTERVAL3 = 1e3;
+var DEFAULT_RETRY_COUNT2 = 5;
+var SignlNotifier = class {
+  #logger;
+  #apiKey;
+  #teamId;
+  #retryInterval;
+  #retryCount;
+  #throttleManager = new ThrottleManager();
+  #throttleFn;
+  constructor(opts, logger) {
+    this.#apiKey = opts.apiKey;
+    this.#teamId = opts.teamId;
+    this.#retryInterval = opts.retryInterval ?? DEFAULT_RETRY_INTERVAL3;
+    this.#retryCount = opts.retryCount ?? DEFAULT_RETRY_COUNT2;
+    this.#logger = logger;
+    this.#throttleFn = opts.throttleFn;
+    this.#logger?.info(opts, "signl notifier configured");
+  }
+  alert(message, dedupeKey) {
+    void this.#sendAlert(message, dedupeKey).catch((e) => this.#logger?.error(e));
+  }
+  async #sendAlert(message, dedupeKey) {
+    if (dedupeKey && !this.#throttleManager.canSend(dedupeKey)) {
+      return;
+    }
+    const text = message.slice(0, 64);
+    this.#logger?.debug("sending signl alert");
+    await withRetry2(
+      async () => {
+        const resp = await fetch(
+          `https://connect.signl4.com/api/v2/alerts?x-s4-api-key=${this.#apiKey.value}`,
+          {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+              category: "emergency",
+              severity: 0,
+              teamId: this.#teamId.value,
+              text,
+              title: "GEARBOX ALERT"
+            })
+          }
+        );
+        if (resp.ok) {
+          this.#logger?.warn("signl alert sent");
+          const data = await resp.json();
+          this.#logger?.info(`signl alert response: ${JSON.stringify(data)}`);
+        } else {
+          throw new Error(`signl api error ${resp.status}: ${resp.statusText}`);
+        }
+      },
+      { delay: this.#retryInterval, retryCount: this.#retryCount }
+    );
+    if (dedupeKey) {
+      this.#throttleManager.onSent(dedupeKey, this.#throttleFn);
+    }
+  }
+};
+
+// src/notifications/NotificationsService.ts
+var NotificationsService = class {
+  #logger;
+  #notifiers = new AddressMap();
+  #signlNotifier;
+  constructor(options, logger) {
+    this.#logger = logger;
+    for (const n of options.notifications) {
+      const recipient = n.recipient ?? ADDRESS_0X0;
+      const notifier = createNotifier(n, logger);
+      if (notifier) {
+        this.#notifiers.upsert(recipient, notifier);
+      }
+    }
+    if (options.signl) {
+      this.#signlNotifier = new SignlNotifier(options.signl);
+    } else {
+      this.#logger?.warn("signl notifier not configured");
+    }
+  }
+  registerRecipient(address, options) {
+    const notifier = createNotifier(options, this.#logger);
+    if (notifier) {
+      this.#notifiers.upsert(address, notifier);
+    }
+  }
+  signl(message, dedupeKey) {
+    this.#signlNotifier?.alert(message, dedupeKey);
+  }
+  alert(msg) {
+    this.#notify(msg, "alert");
+  }
+  notify(msg) {
+    this.#notify(msg, "notification");
+  }
+  #notify(msg, severity) {
+    const message = this.#toNotification(msg);
+    for (const [addr, notifier] of this.#notifiers.entries()) {
+      const recipient = addr === ADDRESS_0X0 ? void 0 : addr;
+      const recipientNotification = message.messageFor(recipient);
+      if (recipientNotification) {
+        const notification = this.#toDedupableNotification(
+          recipientNotification
+        );
+        notifier.notify(notification, severity);
+        if (addr === ADDRESS_0X0) {
+          if (severity === "alert") {
+            this.#logger?.warn(notification.plain);
+          } else {
+            this.#logger?.debug(notification.plain);
+          }
+        }
+      }
+    }
+  }
+  #toNotification(message) {
+    if (typeof message === "string" || !("messageFor" in message)) {
+      return {
+        messageFor: (recipient) => recipient ? void 0 : message
+      };
+    }
+    return message;
+  }
+  #toDedupableNotification(msg) {
+    if (typeof msg === "string") {
+      return {
+        plain: msg
+      };
+    }
+    return msg;
+  }
+};
+
+// src/providers-schema.ts
+import { SUPPORTED_NETWORKS } from "@gearbox-protocol/sdk";
+import { z as z3 } from "zod/v4";
+
+// src/Zommand.ts
+import { Command, Option } from "@commander-js/extra-typings";
+import * as z4 from "zod/v4/core";
+var zommandRegistry = z4.registry();
+var Zommand = class extends Command {
+  #schema;
+  #templatedData;
+  #envToObjectKeys = {};
+  constructor(name, opts) {
+    super(name);
+    const {
+      schema,
+      templateData,
+      configFile = true,
+      inlineConfig = true
+    } = opts;
+    this.#schema = schema;
+    this.#templatedData = templateData;
+    const def = this.#schema._zod.def;
+    if (def.type === "object") {
+      this.#addOptionsFromObject(def);
+    } else if (def.type === "union") {
+      for (const o of def.options) {
+        const opt = o;
+        if (opt._zod.def.type === "object") {
+          this.#addOptionsFromObject(opt._zod.def);
+        }
+      }
+    } else {
+      throw new Error(
+        `expected object schema, got ${this.#schema._zod.def.type}`
+      );
+    }
+    if (configFile) {
+      let opt = new Option("--config [file]", "config file (or s3 link");
+      if (typeof configFile === "string") {
+        opt = opt.default(configFile);
+      }
+      this.addOption(opt);
+    }
+    if (inlineConfig) {
+      this.addOption(new Option("--inline-config [config]", "inline config"));
+    }
+  }
+  #addOptionsFromObject(def) {
+    const shape = def.shape;
+    for (const [key, optionSchema] of Object.entries(shape)) {
+      const meta = zommandRegistry.get(optionSchema);
+      if (!meta) {
+        continue;
+      }
+      const existing = this.options.find((o) => o.flags === meta.flags);
+      if (!existing) {
+        let description = meta.description;
+        if (meta.env) {
+          description = `${description} (env variable ${meta.env})`;
+        }
+        this.addOption(new Option(meta.flags, description));
+        if (meta.env) {
+          this.#envToObjectKeys[meta.env] = key;
+        }
+      }
+    }
+  }
+  action(fn) {
+    return super.action(async (...args) => {
+      const argz = args;
+      const _cmd = argz.splice(-1);
+      const [{ config, inlineConfig, ...opts }] = argz.splice(-1);
+      let fromYaml = {};
+      if (config) {
+        fromYaml = await resolveYamlFiles(config, {
+          ...process.env,
+          ...this.#templatedData
+        });
+      }
+      let fromInlineConfig = {};
+      if (inlineConfig) {
+        fromInlineConfig = await decompressObject(
+          inlineConfig,
+          this.#templatedData
+        );
+      } else if (process.env.INLINE_CONFIG) {
+        fromInlineConfig = await decompressObject(
+          process.env.INLINE_CONFIG,
+          this.#templatedData
+        );
+      }
+      const schemaFromEnv = {};
+      for (const [env, key] of Object.entries(this.#envToObjectKeys)) {
+        if (process.env[env]) {
+          schemaFromEnv[key] = process.env[env];
+        }
+      }
+      const combined = {
+        ...schemaFromEnv,
+        ...fromYaml,
+        ...fromInlineConfig,
+        ...opts
+      };
+      const data = z4.parse(this.#schema, combined);
+      await fn.apply(this, [...argz, data, this]);
+    });
+  }
+};
+
+// src/providers-schema.ts
+var RpcProvider = z3.enum([
+  "alchemy",
+  "drpc",
+  "ankr",
+  "thirdweb",
+  "custom",
+  "erpc"
+]);
+var ProvidersSchema = z3.object({
+  network: z3.enum(SUPPORTED_NETWORKS).register(zommandRegistry, {
+    flags: "--network <network>",
+    description: "Gearbox-supported network",
+    env: "NETWORK"
+  }),
+  /**
+   * RPC providers to use
+   */
+  jsonRpcProviders: stringArrayLike().pipe(z3.array(z3.url().transform(CensoredURL.transform))).transform((a) => a.length ? a : void 0).optional().register(zommandRegistry, {
+    flags: "--json-rpc-providers <urls...>",
+    description: "RPC providers to use, comma separated full http urls.",
+    env: "JSON_RPC_PROVIDERS"
+  }),
+  /**
+   * RPC providers to use with their keys
+   * Order matters
+   */
+  enabledProviders: stringArrayLike().pipe(z3.array(RpcProvider)).optional().register(zommandRegistry, {
+    flags: "--enabled-providers <providers...>",
+    description: "Keyed RPC providers to use, comma separated, order matters. Possible values: custom (for full json rpc urls)/alchemy/drpc/ankr/thirdweb",
+    env: "ENABLED_PROVIDERS"
+  }),
+  /**
+   * Alchemy API keys to use
+   */
+  alchemyKeys: stringArrayLike().pipe(z3.array(z3.string().transform(CensoredString.transform))).transform((a) => a.length ? a : void 0).optional().register(zommandRegistry, {
+    flags: "--alchemy-keys <keys...>",
+    description: "Alchemy API keys to use, comma separated",
+    env: "ALCHEMY_KEYS"
+  }),
+  /**
+   * DRPC API keys to use
+   */
+  drpcKeys: stringArrayLike().pipe(z3.array(z3.string().transform(CensoredString.transform))).transform((a) => a.length ? a : void 0).optional().register(zommandRegistry, {
+    flags: "--drpc-keys <keys...>",
+    description: "DRPC API keys to use, comma separated",
+    env: "DRPC_KEYS"
+  }),
+  /**
+   * Ankr API keys to use
+   */
+  ankrKeys: stringArrayLike().pipe(z3.array(z3.string().transform(CensoredString.transform))).transform((a) => a.length ? a : void 0).optional().register(zommandRegistry, {
+    flags: "--ankr-keys <keys...>",
+    description: "Ankr API keys to use, comma separated",
+    env: "ANKR_KEYS"
+  }),
+  /**
+   * Thirdweb API keys to use
+   */
+  thirdwebKeys: stringArrayLike().pipe(z3.array(z3.string().transform(CensoredString.transform))).transform((a) => a.length ? a : void 0).optional().register(zommandRegistry, {
+    flags: "--thirdweb-keys <keys...>",
+    description: "Thirdweb API keys to use, comma separated",
+    env: "THIRDWEB_KEYS"
+  }),
+  /**
+   * If set, eRPC will be added as first provider
+   */
+  erpcProjectId: z3.string().optional().register(zommandRegistry, {
+    flags: "--erpc-project-id <project-id>",
+    description: "If set, eRPC will be added as first provider",
+    env: "ERPC_PROJECT_ID"
+  }),
+  /**
+   * eRPC URL to use
+   */
+  erpcUrl: z3.url().default("http://erpc.local").register(zommandRegistry, {
+    flags: "--erpc-url <url>",
+    description: "eRPC URL to use",
+    env: "ERPC_URL"
+  }),
+  /**
+   * Timeout for JSON RPC requests, in milliseconds
+   */
+  jsonRpcTimeout: z3.coerce.number().int().positive().optional().register(zommandRegistry, {
+    flags: "--json-rpc-timeout <timeout>",
+    description: "Timeout for JSON RPC requests, in milliseconds",
+    env: "JSON_RPC_TIMEOUT"
+  })
+});
+
+// src/SecretsManager.ts
+import {
+  GetSecretValueCommand,
+  SecretsManagerClient
+} from "@aws-sdk/client-secrets-manager";
+var SecretsManager = class {
+  #smClient;
+  #secrets = /* @__PURE__ */ new Map();
+  async secret(key) {
+    const [SecretId, ...jsonPath] = key.split(".");
+    const secretStr = await this.#getSecret(SecretId);
+    if (!jsonPath.length) {
+      return secretStr;
+    }
+    let v = JSON.parse(secretStr);
+    for (const p of jsonPath) {
+      v = v[p];
+    }
+    if (!v || typeof v !== "string") {
+      throw new Error(`cannot find secret '${key}'`);
+    }
+    return v;
+  }
+  async secretRaw(key) {
+    const val = await this.#getSecret(key);
+    try {
+      return JSON.parse(val);
+    } catch {
+      return val;
+    }
+  }
+  async #getSecret(SecretId) {
+    if (this.#secrets.has(SecretId)) {
+      return this.#secrets.get(SecretId);
+    }
+    if (!this.#smClient) {
+      this.#smClient = new SecretsManagerClient({});
+    }
+    const { SecretString } = await this.#smClient.send(
+      new GetSecretValueCommand({ SecretId })
+    );
+    if (!SecretString) {
+      throw new Error(`secret '${SecretId}' not found`);
+    }
+    this.#secrets.set(SecretId, SecretString);
+    return SecretString;
+  }
+};
+var secretsManagerProxy = (mgr) => new Proxy(mgr ?? new SecretsManager(), {
+  get(target, prop) {
+    if (typeof prop === "string" && !["secret", "secretRaw", "then", "catch", "finally"].includes(prop)) {
+      return target.secretRaw(prop);
+    }
+  }
+});
+
+// src/SSMManager.ts
+import { GetParameterCommand, SSMClient } from "@aws-sdk/client-ssm";
+var SSMManager = class {
+  #ssmClient;
+  #parameters = /* @__PURE__ */ new Map();
+  async parameter(name) {
+    if (this.#parameters.has(name)) {
+      return this.#parameters.get(name);
+    }
+    if (!this.#ssmClient) {
+      this.#ssmClient = new SSMClient({});
+    }
+    const response = await this.#ssmClient.send(
+      new GetParameterCommand({
+        Name: name
+      })
+    );
+    const value = response.Parameter?.Value;
+    if (!value) {
+      throw new Error(`parameter ${name} value not found`);
+    }
+    this.#parameters.set(name, value);
+    return value;
+  }
+};
+var ssmManagerProxy = (mgr) => new Proxy(mgr ?? new SSMManager(), {
+  get(target, prop) {
+    if (typeof prop === "string" && !["parameter", "then", "catch", "finally"].includes(prop)) {
+      return target.parameter(prop);
+    }
+  }
+});
+
+// src/uncensorMap.ts
+function uncensorMap(map) {
+  return Object.fromEntries(Object.entries(map).map(([k, v]) => [k, v.value]));
+}
+
+// src/Whitelist.ts
+import { setInterval } from "timers";
+import { AddressMap as AddressMap2 } from "@gearbox-protocol/sdk";
+import { z as z6 } from "zod/v4";
+
+// src/whitelist-schema.ts
+import { NetworkType } from "@gearbox-protocol/sdk";
+import { z as z5 } from "zod/v4";
+var WhitelistItemsSchema = z5.object({
+  network: NetworkType,
+  addresses: z5.array(addressLike()).min(1),
+  reason: z5.string().default(""),
+  issue: z5.string().optional(),
+  expiresAt: z5.number().optional()
+});
+var WhitelistItemSchema = z5.object({
+  network: NetworkType,
+  category: z5.string(),
+  address: addressLike(),
+  reason: z5.string().default(""),
+  issue: z5.string().optional(),
+  contractType: z5.string().optional(),
+  createdAt: z5.number(),
+  expiresAt: z5.number().optional()
+});
+
+// src/Whitelist.ts
+var REFRESH_INTERVAL_MS = 10 * 60 * 1e3;
+var WhitelistResponse = z6.array(WhitelistItemSchema);
+var Whitelist = class {
+  #url;
+  #network;
+  #logger;
+  #items = new AddressMap2();
+  #refreshInterval;
+  constructor({ url, network, logger }) {
+    this.#url = url;
+    this.#network = network;
+    this.#logger = logger?.child?.({ name: "whitelist" }) ?? logger;
+  }
+  /**
+   * Performs the initial fetch and starts the periodic refresh timer.
+   * Failure of the initial fetch is non-fatal: the whitelist stays empty.
+   */
+  async start() {
+    this.#logger?.info(
+      `loading ${this.#network} whitelist from ${this.#url}, refresh every ${REFRESH_INTERVAL_MS / 1e3}s`
+    );
+    await this.#refresh();
+    this.#refreshInterval = setInterval(() => {
+      this.#refresh().catch((e) => {
+        this.#logger?.warn(`unexpected whitelist refresh error: ${e}`);
+      });
+    }, REFRESH_INTERVAL_MS);
+  }
+  /** Stops the refresh timer. */
+  stop() {
+    if (this.#refreshInterval) {
+      clearInterval(this.#refreshInterval);
+      this.#refreshInterval = void 0;
+    }
+  }
+  /**
+   * Fetches the whitelist from the backend, parses it and atomically
+   * replaces the in-memory map. On any error logs a warning and retains
+   * the previous map.
+   */
+  async #refresh() {
+    try {
+      const resp = await fetchRetry(this.#url);
+      if (!resp.ok) {
+        throw new Error(
+          `whitelist fetch failed: ${resp.status} ${resp.statusText}`
+        );
+      }
+      const data = await resp.json();
+      const items = WhitelistResponse.parse(data).filter(
+        (i) => i.network === this.#network
+      );
+      const next = new AddressMap2();
+      for (const item of items) {
+        next.upsert(item.address, item);
+      }
+      this.#items = next;
+      this.#logger?.debug(
+        `loaded ${items.length} whitelist entries for ${this.#network}`
+      );
+    } catch (e) {
+      this.#logger?.warn(
+        `failed to refresh whitelist from ${this.#url}, keeping previous version: ${e}`
+      );
+    }
+  }
+  /**
+   * Returns the matching whitelist entry for the given address, or
+   * `undefined` if absent or expired.
+   */
+  has(address) {
+    const item = this.#items.get(address);
+    if (!item) {
+      return void 0;
+    }
+    if (item.expiresAt !== void 0 && Date.now() / 1e3 >= item.expiresAt) {
+      return void 0;
+    }
+    return item;
+  }
+};
+export {
+  CensoredString,
+  CensoredURL,
+  NotificationConfig,
+  NotificationsService,
+  ProvidersSchema,
+  RpcProvider,
+  SSMManager,
+  SecretsManager,
+  SignlConfig,
+  SlackConfig,
+  TelegramConfig,
+  Whitelist,
+  WhitelistItemSchema,
+  WhitelistItemsSchema,
+  Zommand,
+  addressArrayLike,
+  addressLike,
+  boolLike,
+  compressObject,
+  createNotifier,
+  createPinoCensor,
+  decompressObject,
+  fetchRetry,
+  getAlchemyUrl,
+  getAnkrUrl,
+  getDrpcUrl,
+  getErpcKey,
+  getFirstHttpTransportOptions,
+  getProviders,
+  getRelativePath,
+  getThirdWebUrl,
+  optionalAddressArrayLike,
+  optionalStringArrayLike,
+  resolveFromObject,
+  resolveYamlDoc,
+  resolveYamlFiles,
+  secretsManagerProxy,
+  sleep,
+  ssmManagerProxy,
+  stringArrayLike,
+  uncensorMap,
+  zommandRegistry
+};
+//# sourceMappingURL=index.js.map