hood-alerts 0.1.0

package/dist/notifiers/index.cjs

@@ -0,0 +1,620 @@
+"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);
+
+// src/notifiers/index.ts
+var notifiers_exports = {};
+__export(notifiers_exports, {
+  EMBED_COLORS: () => EMBED_COLORS,
+  createCaptureNotifier: () => createCaptureNotifier,
+  createDiscordBotNotifier: () => createDiscordBotNotifier,
+  createDiscordRateLimiter: () => createDiscordRateLimiter,
+  createDiscordWebhookNotifier: () => createDiscordWebhookNotifier,
+  createTelegramClient: () => createTelegramClient,
+  createTelegramNotifier: () => createTelegramNotifier,
+  delivered: () => delivered,
+  detailRows: () => detailRows,
+  displayLabel: () => displayLabel,
+  escapeDiscordMarkdown: () => escapeDiscordMarkdown,
+  escapeHtml: () => escapeHtml,
+  escapeHtmlAttribute: () => escapeHtmlAttribute,
+  escapeMarkdownV2: () => escapeMarkdownV2,
+  escapeMarkdownV2Code: () => escapeMarkdownV2Code,
+  escapeMarkdownV2Url: () => escapeMarkdownV2Url,
+  failed: () => failed,
+  formatAmount: () => formatAmount,
+  formatEth: () => formatEth,
+  formatUsd: () => formatUsd,
+  headline: () => headline,
+  htmlLink: () => htmlLink,
+  markdownV2Link: () => markdownV2Link,
+  numericHeader: () => numericHeader,
+  pick: () => pick,
+  postJson: () => postJson,
+  renderAlert: () => renderAlert,
+  resolveFetch: () => resolveFetch,
+  shortAddress: () => shortAddress,
+  sleep: () => sleep,
+  truncate: () => truncate
+});
+module.exports = __toCommonJS(notifiers_exports);
+
+// src/notifiers/escape.ts
+var MARKDOWN_V2_RESERVED = "_*[]()~`>#+-=|{}.!";
+function escapeMarkdownV2(text) {
+  let out = "";
+  for (const char of text) {
+    if (MARKDOWN_V2_RESERVED.includes(char)) out += "\\";
+    out += char;
+  }
+  return out;
+}
+function escapeMarkdownV2Url(url) {
+  return url.replace(/[\\)]/g, (char) => `\\${char}`);
+}
+function escapeMarkdownV2Code(text) {
+  return text.replace(/[\\`]/g, (char) => `\\${char}`);
+}
+function markdownV2Link(label, url) {
+  return `[${escapeMarkdownV2(label)}](${escapeMarkdownV2Url(url)})`;
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function escapeHtmlAttribute(value) {
+  return escapeHtml(value).replace(/"/g, "&quot;");
+}
+function htmlLink(label, url) {
+  return `<a href="${escapeHtmlAttribute(url)}">${escapeHtml(label)}</a>`;
+}
+var DISCORD_RESERVED = /[\\*_~`|>[\]()]/g;
+function escapeDiscordMarkdown(text) {
+  return text.replace(DISCORD_RESERVED, (char) => `\\${char}`);
+}
+function truncate(text, max) {
+  if (max <= 0) return "";
+  const chars = [...text];
+  if (chars.length <= max) return text;
+  if (max === 1) return "\u2026";
+  return `${chars.slice(0, max - 1).join("")}\u2026`;
+}
+function displayLabel(symbol, address) {
+  const trimmed = symbol?.trim();
+  if (trimmed) return truncate(trimmed, 40);
+  return shortAddress(address);
+}
+function shortAddress(address) {
+  if (address.length <= 12) return address;
+  return `${address.slice(0, 6)}\u2026${address.slice(-4)}`;
+}
+
+// src/notifiers/format.ts
+var import_viem = require("viem");
+var EMBED_COLORS = {
+  launch: 2278750,
+  curve_trade: 3718648,
+  graduation: 11032055,
+  whale_trade: 16096779
+};
+var KIND_EMOJI = {
+  launch: "\u{1F680}",
+  curve_trade: "\u{1F4C8}",
+  graduation: "\u{1F393}",
+  whale_trade: "\u{1F40B}"
+};
+var LAUNCHPAD_NAMES = { noxa: "NOXA", odyssey: "The Odyssey" };
+var usdFormatter = new Intl.NumberFormat("en-US", {
+  style: "currency",
+  currency: "USD",
+  maximumFractionDigits: 2
+});
+function formatUsd(value) {
+  if (value === null || !Number.isFinite(value)) return "unknown";
+  const abs = Math.abs(value);
+  if (abs >= 1e6) return `$${(value / 1e6).toFixed(2)}M`;
+  if (abs >= 1e4) return `$${(value / 1e3).toFixed(1)}K`;
+  return usdFormatter.format(value);
+}
+function formatAmount(value) {
+  const abs = Math.abs(value);
+  if (abs === 0) return "0";
+  if (abs >= 1e9) return `${(value / 1e9).toFixed(2)}B`;
+  if (abs >= 1e6) return `${(value / 1e6).toFixed(2)}M`;
+  if (abs >= 1e3) return `${(value / 1e3).toFixed(2)}K`;
+  if (abs >= 1) return value.toFixed(4).replace(/\.?0+$/, "");
+  return value.toPrecision(4);
+}
+function formatEth(wei) {
+  return `${formatAmount(Number((0, import_viem.formatUnits)(wei < 0n ? -wei : wei, 18)))} ETH`;
+}
+function headline(event) {
+  const label = displayLabel(event.symbol, event.token);
+  const pad = LAUNCHPAD_NAMES[event.launchpad];
+  switch (event.kind) {
+    case "launch":
+      return `${KIND_EMOJI.launch} New launch: ${label} on ${pad}`;
+    case "curve_trade":
+      return `${KIND_EMOJI.curve_trade} Curve ${event.side}: ${label} for ${formatUsd(event.usdValue)}`;
+    case "graduation":
+      return `${KIND_EMOJI.graduation} Graduated: ${label} filled its curve`;
+    case "whale_trade":
+      return `${KIND_EMOJI.whale_trade} Whale ${event.side}: ${formatUsd(event.usdValue)} of ${label}`;
+  }
+}
+function detailRows(event) {
+  const rows = [];
+  rows.push({ label: "Launchpad", value: LAUNCHPAD_NAMES[event.launchpad], inline: true });
+  if (event.name) rows.push({ label: "Name", value: truncate(event.name, 64), inline: true });
+  rows.push({ label: "Token", value: shortAddress(event.token), inline: true });
+  switch (event.kind) {
+    case "launch": {
+      rows.push({
+        label: "Listing",
+        value: event.instantListing ? "Instant (live Uniswap v3 pool, no curve)" : "Bonding curve (graduates when filled)",
+        inline: true
+      });
+      rows.push({ label: "Deployer", value: shortAddress(event.actor), inline: true });
+      if (event.initialBuyAmount > 0n) {
+        rows.push({ label: "Initial buy", value: formatUsd(event.usdValue), inline: true });
+      }
+      break;
+    }
+    case "curve_trade": {
+      rows.push({ label: "Side", value: event.side === "buy" ? "Buy" : "Sell", inline: true });
+      rows.push({ label: "Size", value: formatEth(event.quoteAmountWei), inline: true });
+      rows.push({ label: "Value", value: formatUsd(event.usdValue), inline: true });
+      rows.push({
+        label: "Tokens",
+        value: formatAmount(Number((0, import_viem.formatUnits)(event.tokenAmount, 18))),
+        inline: true
+      });
+      rows.push({ label: "Trader", value: shortAddress(event.actor), inline: true });
+      break;
+    }
+    case "graduation": {
+      rows.push({ label: "Pool", value: shortAddress(event.pool), inline: true });
+      rows.push({ label: "Seeded", value: formatUsd(event.usdValue), inline: true });
+      rows.push({ label: "LP position", value: `#${event.positionId}`, inline: true });
+      break;
+    }
+    case "whale_trade": {
+      rows.push({ label: "Side", value: event.side === "buy" ? "Buy" : "Sell", inline: true });
+      rows.push({ label: "Value", value: formatUsd(event.usdValue), inline: true });
+      rows.push({
+        label: "Size",
+        value: `${formatAmount(event.tokenAmount)} for ${formatAmount(event.quoteAmount)} ${event.quoteSymbol}`,
+        inline: true
+      });
+      rows.push({ label: "Price", value: `${formatAmount(event.price)} ${event.quoteSymbol}`, inline: true });
+      rows.push({ label: "Fee tier", value: `${event.feeTier / 1e4}%`, inline: true });
+      rows.push({ label: "Trader", value: shortAddress(event.actor), inline: true });
+      break;
+    }
+  }
+  return rows;
+}
+function renderAlert(event, options = {}) {
+  const parseMode = options.parseMode ?? "HTML";
+  const title = headline(event);
+  const rows = detailRows(event);
+  const label = displayLabel(event.symbol, event.token);
+  const linkPairs = [
+    { label: "Transaction", url: event.explorer.tx },
+    { label: "Token", url: event.explorer.token }
+  ];
+  if (event.explorer.pool) linkPairs.push({ label: "Pool", url: event.explorer.pool });
+  linkPairs.push({ label: "Actor", url: event.explorer.actor });
+  const text = parseMode === "HTML" ? [
+    `<b>${escapeHtml(title)}</b>`,
+    "",
+    ...rows.map((row) => `${escapeHtml(row.label)}: <b>${escapeHtml(row.value)}</b>`),
+    `Contract: <code>${escapeHtml(event.token)}</code>`,
+    "",
+    linkPairs.map((link) => htmlLink(link.label, link.url)).join(" \xB7 "),
+    ...options.footer ? ["", `<i>${escapeHtml(options.footer)}</i>`] : []
+  ].join("\n") : [
+    `*${escapeMarkdownV2(title)}*`,
+    "",
+    ...rows.map((row) => `${escapeMarkdownV2(row.label)}: *${escapeMarkdownV2(row.value)}*`),
+    `Contract: \`${event.token}\``,
+    "",
+    linkPairs.map((link) => markdownV2Link(link.label, link.url)).join(" \xB7 "),
+    ...options.footer ? ["", `_${escapeMarkdownV2(options.footer)}_`] : []
+  ].join("\n");
+  const fields = rows.map((row) => ({
+    name: truncate(row.label, 256),
+    value: truncate(escapeDiscordMarkdown(row.value), 1024),
+    inline: row.inline ?? false
+  }));
+  fields.push({
+    name: "Links",
+    value: linkPairs.map((link) => `[${link.label}](${link.url})`).join(" \xB7 "),
+    inline: false
+  });
+  const embed = {
+    title: truncate(escapeDiscordMarkdown(title), 256),
+    url: event.explorer.tx,
+    description: `\`${event.token}\``,
+    color: EMBED_COLORS[event.kind],
+    fields,
+    ...options.footer ? { footer: { text: truncate(options.footer, 2048) } } : {},
+    ...event.timestampMs !== null ? { timestamp: new Date(event.timestampMs).toISOString() } : {}
+  };
+  const plain = `${title} | ${label} ${event.token} | block ${event.blockNumber} | ${event.explorer.tx}`;
+  return { text, parseMode, embed, plain };
+}
+
+// src/notifiers/http.ts
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, Math.max(0, ms)));
+function resolveFetch(injected) {
+  if (injected) return injected;
+  if (typeof globalThis.fetch !== "function") {
+    throw new Error("hood-alerts: global fetch is unavailable (Node 20+ required), and none was injected");
+  }
+  return globalThis.fetch;
+}
+async function postJson(fetchImpl, url, payload, headers = {}) {
+  const response = await fetchImpl(url, {
+    method: "POST",
+    headers: { "content-type": "application/json", ...headers },
+    body: JSON.stringify(payload)
+  });
+  const raw = await response.text();
+  let body = null;
+  if (raw) {
+    try {
+      body = JSON.parse(raw);
+    } catch {
+      body = null;
+    }
+  }
+  return { status: response.status, ok: response.ok, headers: response.headers, body, raw };
+}
+function numericHeader(headers, name) {
+  const value = headers.get(name);
+  if (value === null) return null;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function pick(body, ...path) {
+  let current = body;
+  for (const key of path) {
+    if (typeof current !== "object" || current === null) return void 0;
+    current = current[key];
+  }
+  return current;
+}
+
+// src/notifiers/types.ts
+function delivered(status, attempts, messageId) {
+  return { ok: true, status, attempts, messageId, error: null, retryable: false };
+}
+function failed(status, attempts, error, retryable) {
+  return { ok: false, status, attempts, messageId: null, error, retryable };
+}
+
+// src/notifiers/telegram.ts
+var PERMANENT_STATUSES = /* @__PURE__ */ new Set([400, 401, 403, 404]);
+function createTelegramClient(options) {
+  if (!/^\d+:[A-Za-z0-9_-]+$/.test(options.botToken)) {
+    throw new Error('hood-alerts: TELEGRAM_BOT_TOKEN must look like "<bot id>:<secret>"');
+  }
+  const fetchImpl = resolveFetch(options.fetch);
+  const apiBase = (options.apiBase ?? "https://api.telegram.org").replace(/\/+$/, "");
+  const maxAttempts = options.maxAttempts ?? 4;
+  const backoffMs = options.backoffMs ?? 500;
+  const maxWaitMs = options.maxWaitMs ?? 6e4;
+  const sleep2 = options.sleep ?? sleep;
+  let lastAttempts = 0;
+  return {
+    get lastAttempts() {
+      return lastAttempts;
+    },
+    async call(method, params) {
+      const url = `${apiBase}/bot${options.botToken}/${method}`;
+      let attempt = 0;
+      let last = {
+        ok: false,
+        status: 0,
+        result: null,
+        description: "no attempt was made",
+        retryAfterSeconds: null
+      };
+      while (attempt < maxAttempts) {
+        attempt += 1;
+        lastAttempts = attempt;
+        let response;
+        try {
+          response = await postJson(fetchImpl, url, params);
+        } catch (error) {
+          last = {
+            ok: false,
+            status: 0,
+            result: null,
+            description: error instanceof Error ? error.message : String(error),
+            retryAfterSeconds: null
+          };
+          if (attempt >= maxAttempts) break;
+          await sleep2(backoffMs * 2 ** (attempt - 1));
+          continue;
+        }
+        const description = typeof pick(response.body, "description") === "string" ? pick(response.body, "description") : null;
+        const retryAfterField = pick(response.body, "parameters", "retry_after");
+        const retryAfterSeconds = typeof retryAfterField === "number" ? retryAfterField : numericHeader(response.headers, "retry-after");
+        last = {
+          ok: response.status === 200 && pick(response.body, "ok") === true,
+          status: response.status,
+          result: pick(response.body, "result") ?? null,
+          description,
+          retryAfterSeconds
+        };
+        if (last.ok) return last;
+        if (response.status === 429) {
+          const waitMs = (retryAfterSeconds ?? backoffMs / 1e3) * 1e3;
+          if (waitMs > maxWaitMs || attempt >= maxAttempts) return last;
+          await sleep2(waitMs);
+          continue;
+        }
+        if (PERMANENT_STATUSES.has(response.status)) return last;
+        if (attempt >= maxAttempts) return last;
+        await sleep2(backoffMs * 2 ** (attempt - 1));
+      }
+      return last;
+    }
+  };
+}
+function createTelegramNotifier(options) {
+  const client = options.client ?? createTelegramClient(options);
+  const disableWebPagePreview = options.disableWebPagePreview ?? true;
+  const disableNotification = options.disableNotification ?? false;
+  return {
+    platform: "telegram",
+    kind: "bot",
+    async send(target, alert) {
+      if (!/^-?\d+$|^@[A-Za-z][A-Za-z0-9_]{4,}$/.test(target)) {
+        return failed(
+          null,
+          0,
+          `invalid Telegram chat id "${target}": expected a numeric id or an @username`,
+          false
+        );
+      }
+      const response = await client.call("sendMessage", {
+        chat_id: /^-?\d+$/.test(target) ? Number(target) : target,
+        text: alert.text,
+        parse_mode: alert.parseMode,
+        link_preview_options: { is_disabled: disableWebPagePreview },
+        disable_notification: disableNotification
+      });
+      const attempts = client.lastAttempts;
+      if (response.ok) {
+        const messageId = pick(response.result, "message_id");
+        return delivered(response.status, attempts, messageId === void 0 ? null : String(messageId));
+      }
+      const retryable = response.status === 429 || response.status >= 500 || response.status === 0;
+      return failed(
+        response.status || null,
+        attempts,
+        response.description ?? `Telegram sendMessage failed with status ${response.status}`,
+        retryable
+      );
+    }
+  };
+}
+
+// src/notifiers/discord.ts
+function createDiscordRateLimiter(now = Date.now, sleep2 = sleep) {
+  const buckets = /* @__PURE__ */ new Map();
+  let globalResetAtMs = 0;
+  return {
+    async acquire(route) {
+      const globalWait = globalResetAtMs - now();
+      if (globalWait > 0) await sleep2(globalWait);
+      const bucket = buckets.get(route);
+      if (!bucket) return;
+      if (bucket.remaining > 0) return;
+      const wait = bucket.resetAtMs - now();
+      if (wait > 0) await sleep2(wait);
+    },
+    update(route, headers) {
+      const remaining = numericHeader(headers, "x-ratelimit-remaining");
+      const resetAfter = numericHeader(headers, "x-ratelimit-reset-after");
+      if (remaining === null && resetAfter === null) return;
+      buckets.set(route, {
+        remaining: remaining ?? 1,
+        resetAtMs: now() + (resetAfter ?? 0) * 1e3
+      });
+    },
+    penalise(route, retryAfterMs, global) {
+      const resetAtMs = now() + retryAfterMs;
+      if (global) globalResetAtMs = Math.max(globalResetAtMs, resetAtMs);
+      buckets.set(route, { remaining: 0, resetAtMs });
+    }
+  };
+}
+var PERMANENT_STATUSES2 = /* @__PURE__ */ new Set([400, 401, 403, 404, 405]);
+async function deliver(args, options, fetchImpl, limiter) {
+  const maxAttempts = options.maxAttempts ?? 4;
+  const backoffMs = options.backoffMs ?? 500;
+  const maxWaitMs = options.maxWaitMs ?? 6e4;
+  const sleep2 = options.sleep ?? sleep;
+  let attempt = 0;
+  let lastStatus = null;
+  let lastError = "no attempt was made";
+  let retryable = true;
+  while (attempt < maxAttempts) {
+    attempt += 1;
+    await limiter.acquire(args.route);
+    let response;
+    try {
+      response = await postJson(fetchImpl, args.url, args.payload, args.headers);
+    } catch (error) {
+      lastStatus = null;
+      lastError = error instanceof Error ? error.message : String(error);
+      retryable = true;
+      if (attempt >= maxAttempts) break;
+      await sleep2(backoffMs * 2 ** (attempt - 1));
+      continue;
+    }
+    limiter.update(args.route, response.headers);
+    lastStatus = response.status;
+    if (response.status === 429) {
+      const retryAfterField = pick(response.body, "retry_after");
+      const retryAfterSeconds = typeof retryAfterField === "number" ? retryAfterField : numericHeader(response.headers, "retry-after") ?? backoffMs / 1e3;
+      const isGlobal = pick(response.body, "global") === true || response.headers.get("x-ratelimit-global") === "true";
+      const waitMs = retryAfterSeconds * 1e3;
+      limiter.penalise(args.route, waitMs, isGlobal);
+      lastError = `rate limited, retry after ${retryAfterSeconds}s${isGlobal ? " (global)" : ""}`;
+      retryable = true;
+      if (waitMs > maxWaitMs || attempt >= maxAttempts) break;
+      await sleep2(waitMs);
+      continue;
+    }
+    if (response.ok) {
+      const messageId = pick(response.body, "id");
+      return delivered(response.status, attempt, messageId === void 0 ? null : String(messageId));
+    }
+    const message = (typeof pick(response.body, "message") === "string" ? pick(response.body, "message") : null) ?? response.raw.slice(0, 200);
+    lastError = message || `Discord request failed with status ${response.status}`;
+    if (PERMANENT_STATUSES2.has(response.status)) {
+      retryable = false;
+      break;
+    }
+    retryable = true;
+    if (attempt >= maxAttempts) break;
+    await sleep2(backoffMs * 2 ** (attempt - 1));
+  }
+  return failed(lastStatus, attempt, lastError, retryable);
+}
+var WEBHOOK_PATTERN = /^https:\/\/(?:\w+\.)?discord(?:app)?\.com\/api(?:\/v\d+)?\/webhooks\/\d+\/[\w-]+$/;
+function createDiscordWebhookNotifier(options = {}) {
+  const fetchImpl = resolveFetch(options.fetch);
+  const limiter = options.limiter ?? createDiscordRateLimiter(options.now ?? Date.now, options.sleep ?? sleep);
+  return {
+    platform: "discord",
+    kind: "webhook",
+    async send(target, alert) {
+      const url = target || options.webhookUrl;
+      if (!url || !WEBHOOK_PATTERN.test(url)) {
+        return failed(
+          null,
+          0,
+          `invalid Discord webhook URL "${target}": expected https://discord.com/api/webhooks/<id>/<token>`,
+          false
+        );
+      }
+      return deliver(
+        {
+          url: `${url}?wait=true`,
+          // Discord buckets webhook routes per webhook id.
+          route: `webhook:${url.split("/").slice(-2, -1)[0] ?? url}`,
+          payload: {
+            embeds: [alert.embed],
+            ...options.username ? { username: options.username } : {}
+          },
+          headers: {}
+        },
+        options,
+        fetchImpl,
+        limiter
+      );
+    }
+  };
+}
+function createDiscordBotNotifier(options) {
+  if (!options.botToken.trim()) {
+    throw new Error("hood-alerts: DISCORD_BOT_TOKEN is required for the Discord bot notifier");
+  }
+  const fetchImpl = resolveFetch(options.fetch);
+  const apiBase = (options.apiBase ?? "https://discord.com/api/v10").replace(/\/+$/, "");
+  const limiter = options.limiter ?? createDiscordRateLimiter(options.now ?? Date.now, options.sleep ?? sleep);
+  return {
+    platform: "discord",
+    kind: "bot",
+    async send(target, alert) {
+      if (!/^\d{5,25}$/.test(target)) {
+        return failed(null, 0, `invalid Discord channel id "${target}": expected a numeric snowflake`, false);
+      }
+      return deliver(
+        {
+          url: `${apiBase}/channels/${target}/messages`,
+          route: `channel:${target}`,
+          payload: { embeds: [alert.embed] },
+          headers: { authorization: `Bot ${options.botToken}` }
+        },
+        options,
+        fetchImpl,
+        limiter
+      );
+    }
+  };
+}
+
+// src/notifiers/capture.ts
+function createCaptureNotifier(platform, onSend, now = Date.now) {
+  const sent = [];
+  return {
+    platform,
+    kind: "capture",
+    sent,
+    clear() {
+      sent.length = 0;
+    },
+    async send(target, alert) {
+      const delivery = { platform, target, alert, atMs: now() };
+      sent.push(delivery);
+      onSend?.(delivery);
+      return delivered(200, 1, `capture-${sent.length}`);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EMBED_COLORS,
+  createCaptureNotifier,
+  createDiscordBotNotifier,
+  createDiscordRateLimiter,
+  createDiscordWebhookNotifier,
+  createTelegramClient,
+  createTelegramNotifier,
+  delivered,
+  detailRows,
+  displayLabel,
+  escapeDiscordMarkdown,
+  escapeHtml,
+  escapeHtmlAttribute,
+  escapeMarkdownV2,
+  escapeMarkdownV2Code,
+  escapeMarkdownV2Url,
+  failed,
+  formatAmount,
+  formatEth,
+  formatUsd,
+  headline,
+  htmlLink,
+  markdownV2Link,
+  numericHeader,
+  pick,
+  postJson,
+  renderAlert,
+  resolveFetch,
+  shortAddress,
+  sleep,
+  truncate
+});
+//# sourceMappingURL=index.cjs.map