cabalspy-id 0.0.0-stage → 0.5.2

package/dist/chunk-XLBO2RSL.js

@@ -0,0 +1,1301 @@
+import {
+  AuthenticationError,
+  BadRequestError,
+  CabalSpyIDError,
+  ConnectionError,
+  EMPTY_RATE_LIMIT,
+  InvalidResponseError,
+  PermissionError,
+  RateLimitError,
+  WebhookVerificationError,
+  errorFromStatus,
+  isRetryable
+} from "./chunk-VOTYIQAY.js";
+
+// src/types.ts
+var CHAINS = ["solana", "bnb", "base", "eth", "rh"];
+var PERIODS = ["6h", "1d", "7d", "30d"];
+var LEADERBOARD_SORTS = ["volume", "pnl", "pnl_usd", "win_rate", "trades"];
+var CURRENCY_BY_CHAIN = {
+  solana: "SOL",
+  bnb: "BNB",
+  base: "ETH",
+  eth: "ETH",
+  rh: "ETH"
+};
+var THESIS_EMOJIS = ["like", "\u{1F525}", "\u{1F680}", "\u{1F48E}", "\u{1F440}", "\u{1F602}", "\u{1F91D}", "\u{1F480}", "\u{1F402}", "\u{1F43B}"];
+var THESIS_REPORT_REASONS = ["spam", "scam", "abuse", "impersonation", "other"];
+var THESIS_MAX_BODY = 1e3;
+
+// src/stream.ts
+var FATAL_CODES = /* @__PURE__ */ new Set([
+  "invalid_api_key",
+  "plan_required",
+  "invalid_parameter",
+  "missing_parameter",
+  "scope_not_allowed",
+  "product_not_enabled"
+]);
+function streamError(code, message) {
+  const opts = { code };
+  if (code === "invalid_parameter" || code === "missing_parameter") return new BadRequestError(message, { ...opts, status: 400 });
+  if (code === "too_many_connections") return new RateLimitError(message, { ...opts, status: 429 });
+  if (FATAL_CODES.has(code)) return new PermissionError(message, { ...opts, status: 403 });
+  return new CabalSpyIDError(message, opts);
+}
+var CabalSpyIDStream = class {
+  constructor(url, apiKey, options = {}) {
+    this.url = url;
+    this.apiKey = apiKey;
+    this.options = options;
+    const events = options.events ?? ["trades"];
+    if (!events.length || events.some((e) => e !== "trades" && e !== "theses")) {
+      throw new BadRequestError("events must contain 'trades' and/or 'theses'", {
+        code: "invalid_parameter",
+        parameter: "events",
+        allowed: ["trades", "theses"]
+      });
+    }
+    if (options.mint && !options.blockchain) {
+      throw new BadRequestError("mint needs blockchain", { code: "missing_parameter", parameter: "blockchain" });
+    }
+    if (options.blockchain && !CHAINS.includes(options.blockchain)) {
+      throw new BadRequestError(`Unknown blockchain '${options.blockchain}'`, {
+        code: "invalid_parameter",
+        parameter: "blockchain",
+        allowed: [...CHAINS]
+      });
+    }
+    this.opts = {
+      reconnect: options.reconnect ?? true,
+      reconnectDelay: options.reconnectDelay ?? 1e3,
+      maxReconnectDelay: options.maxReconnectDelay ?? 3e4,
+      heartbeatTimeout: options.heartbeatTimeout ?? 75e3
+    };
+  }
+  url;
+  apiKey;
+  options;
+  ws = null;
+  opts;
+  handlers = /* @__PURE__ */ new Map();
+  reconnectAttempt = 0;
+  reconnectTimer = null;
+  watchdog = null;
+  closedByUser = false;
+  fatal = null;
+  /** True while the socket is open. */
+  get connected() {
+    return this.ws?.readyState === 1;
+  }
+  /** The stream URL including query parameters, with the key masked. */
+  get safeUrl() {
+    return this.buildUrl("***");
+  }
+  buildUrl(key) {
+    const sp = new URLSearchParams({ api_key: key });
+    if (this.options.events) sp.set("events", [...new Set(this.options.events)].join(","));
+    if (this.options.blockchain) sp.set("blockchain", this.options.blockchain);
+    if (this.options.mint) sp.set("mint", this.options.mint);
+    if (this.options.scope) sp.set("scope", this.options.scope);
+    if (this.options.instance) sp.set("instance", this.options.instance);
+    return `${this.url}?${sp.toString()}`;
+  }
+  on(event, handler) {
+    let set = this.handlers.get(event);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      this.handlers.set(event, set);
+    }
+    set.add(handler);
+    return this;
+  }
+  off(event, handler) {
+    this.handlers.get(event)?.delete(handler);
+    return this;
+  }
+  emit(event, payload) {
+    const set = this.handlers.get(event);
+    if (!set) return;
+    for (const h of [...set]) {
+      try {
+        h(payload);
+      } catch (err) {
+        if (event !== "error") {
+          this.emit("error", err instanceof CabalSpyIDError ? err : new CabalSpyIDError(String(err?.message ?? err), { code: "handler_error" }));
+        }
+      }
+    }
+  }
+  /** Opens the socket. Resolves once the server sent `subscribed`. */
+  connect() {
+    this.closedByUser = false;
+    this.fatal = null;
+    const WS = this.options.WebSocketImpl ?? globalThis.WebSocket;
+    if (!WS) {
+      return Promise.reject(
+        new ConnectionError("No WebSocket implementation found. On Node < 22, run `npm i ws` and pass { WebSocketImpl: WebSocket }.", {
+          code: "no_websocket"
+        })
+      );
+    }
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const settle = (err, value) => {
+        if (settled) return;
+        settled = true;
+        if (err) reject(err);
+        else resolve(value);
+      };
+      let ws;
+      try {
+        ws = new WS(this.buildUrl(this.apiKey));
+      } catch (err) {
+        settle(new ConnectionError(`Could not open ${this.safeUrl}: ${err?.message ?? err}`, { code: "ws_error" }));
+        return;
+      }
+      this.ws = ws;
+      ws.onopen = () => {
+        this.armWatchdog();
+        this.emit("open", void 0);
+      };
+      ws.onmessage = (ev) => {
+        if (this.ws !== ws) return;
+        this.armWatchdog();
+        let msg;
+        try {
+          msg = JSON.parse(typeof ev.data === "string" ? ev.data : String(ev.data));
+        } catch {
+          return;
+        }
+        this.emit("message", msg);
+        switch (msg.event) {
+          case "trade":
+            this.emit("trade", msg.data);
+            break;
+          case "subscribed": {
+            this.reconnectAttempt = 0;
+            const data = msg.data ?? {};
+            this.emit("subscribed", data);
+            settle(null, data);
+            break;
+          }
+          case "thesis":
+          case "thesis.reply":
+          case "thesis.reaction":
+          case "thesis.removed":
+            this.emit(msg.event, msg.data);
+            break;
+          case "heartbeat":
+            this.emit("heartbeat", { ts: Number(msg.ts) });
+            break;
+          case "pong":
+            this.emit("pong", {});
+            break;
+          case "error": {
+            const e = msg.error ?? {};
+            const err = streamError(e.code ?? "stream_error", e.message ?? "Stream error");
+            if (FATAL_CODES.has(err.code)) this.fatal = err;
+            this.emit("error", err);
+            settle(err);
+            break;
+          }
+          default:
+            break;
+        }
+      };
+      ws.onerror = (ev) => {
+        if (this.ws !== ws) return;
+        const err = new ConnectionError(`WebSocket error on ${this.safeUrl}: ${describeWsEvent(ev)}`, { code: "ws_error" });
+        this.emit("error", err);
+        settle(err);
+      };
+      ws.onclose = (ev) => {
+        if (this.ws !== ws) return;
+        this.clearWatchdog();
+        this.ws = null;
+        const e = ev ?? {};
+        this.emit("close", { code: e.code, reason: e.reason });
+        settle(
+          new ConnectionError(`Stream closed before it was ready (code ${e.code ?? "unknown"}${e.reason ? `, ${e.reason}` : ""})`, {
+            code: "ws_closed_early"
+          })
+        );
+        if (!this.closedByUser && !this.fatal && this.opts.reconnect) this.scheduleReconnect();
+      };
+    });
+  }
+  scheduleReconnect() {
+    const delay = Math.min(this.opts.reconnectDelay * 2 ** this.reconnectAttempt, this.opts.maxReconnectDelay) + Math.random() * 250;
+    this.reconnectAttempt++;
+    this.emit("reconnecting", { attempt: this.reconnectAttempt, delay });
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      if (this.closedByUser) return;
+      this.connect().catch(() => {
+      });
+    }, delay);
+  }
+  armWatchdog() {
+    if (!this.opts.heartbeatTimeout) return;
+    this.clearWatchdog();
+    this.watchdog = setTimeout(() => {
+      this.emit("error", new ConnectionError("No heartbeat from the stream; reconnecting", { code: "heartbeat_timeout" }));
+      this.ws?.close(4e3, "heartbeat timeout");
+    }, this.opts.heartbeatTimeout);
+  }
+  clearWatchdog() {
+    if (this.watchdog) clearTimeout(this.watchdog);
+    this.watchdog = null;
+  }
+  /**
+   * Sends a ping; the server answers with 'pong'. Not needed to keep the
+   * connection alive (the server sends heartbeats), and pinging more often
+   * than every 30 s suppresses those heartbeats.
+   */
+  ping() {
+    if (this.ws?.readyState === 1) this.ws.send("ping");
+  }
+  /** Closes the connection and stops reconnecting. */
+  close() {
+    this.closedByUser = true;
+    this.clearWatchdog();
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    this.reconnectTimer = null;
+    const ws = this.ws;
+    this.ws = null;
+    ws?.close(1e3, "client closed");
+    this.emit("close", { code: 1e3, reason: "client closed" });
+  }
+  /**
+   * Iterates over trades. Connects if needed; ends when close() is called or
+   * a fatal error occurs (which is thrown). Breaking out of the loop closes a
+   * connection the iterator opened.
+   */
+  [Symbol.asyncIterator]() {
+    return this.iterate(["trade"], (_e, d) => d);
+  }
+  /**
+   * Iterates over thesis events (`thesis`, `thesis.reply`, `thesis.reaction`,
+   * `thesis.removed`). Open the stream with `events: ['theses']`.
+   *
+   *   for await (const { event, data } of csid.stream({ events: ['theses'] }).theses()) { … }
+   */
+  theses() {
+    return this.iterate(
+      ["thesis", "thesis.reply", "thesis.reaction", "thesis.removed"],
+      (event, data) => ({ event, data })
+    );
+  }
+  async *iterate(names, wrap) {
+    const queue = [];
+    let wake = null;
+    let failure = null;
+    let done = false;
+    const listeners = names.map((name) => {
+      const fn = (data) => {
+        queue.push(wrap(name, data));
+        wake?.();
+      };
+      return [name, fn];
+    });
+    const onError = () => {
+      if (this.fatal) {
+        failure = this.fatal;
+        wake?.();
+      }
+    };
+    const onClose = () => {
+      if (this.closedByUser || !this.opts.reconnect) {
+        done = true;
+        wake?.();
+      }
+    };
+    for (const [name, fn] of listeners) this.on(name, fn);
+    this.on("error", onError).on("close", onClose);
+    const ownsConnection = !this.ws;
+    try {
+      if (ownsConnection) await this.connect();
+      while (true) {
+        while (queue.length) yield queue.shift();
+        if (failure) throw failure;
+        if (done) return;
+        await new Promise((r) => wake = r);
+        wake = null;
+      }
+    } finally {
+      for (const [name, fn] of listeners) this.off(name, fn);
+      this.off("error", onError).off("close", onClose);
+      if (ownsConnection && !this.closedByUser) this.close();
+    }
+  }
+};
+function describeWsEvent(ev) {
+  if (!ev || typeof ev !== "object") return "no detail available";
+  const e = ev;
+  return e.error?.message ?? e.message ?? (e.error?.code ? `errno ${e.error.code}` : void 0) ?? e.type ?? "no detail available";
+}
+
+// src/thesesStream.ts
+var MAX_THESES_STREAM_TOKENS = 200;
+var THESIS_EVENT_NAMES = ["thesis", "thesis.reply", "thesis.reaction", "thesis.removed"];
+function keyOf(t) {
+  const mint = t.blockchain === "solana" ? t.mint.trim() : t.mint.trim().toLowerCase();
+  return `${t.blockchain}:${mint}`;
+}
+function connectionError(code, message) {
+  if (code === "invalid_parameter") return new BadRequestError(message, { code, status: 400 });
+  if (code === "too_many_connections") return new RateLimitError(message, { code, status: 429 });
+  return new PermissionError(message, { code, status: 403 });
+}
+var ThesesStream = class {
+  constructor(url, apiKey, options = {}) {
+    this.url = url;
+    this.apiKey = apiKey;
+    this.options = options;
+    if (options.scope && options.scope !== "global" && options.scope !== "instance") {
+      throw new BadRequestError(`Invalid value for 'scope': ${options.scope}`, {
+        code: "invalid_parameter",
+        parameter: "scope",
+        allowed: ["global", "instance"]
+      });
+    }
+    this.opts = {
+      reconnect: options.reconnect ?? true,
+      reconnectDelay: options.reconnectDelay ?? 1e3,
+      maxReconnectDelay: options.maxReconnectDelay ?? 3e4,
+      heartbeatTimeout: options.heartbeatTimeout ?? 75e3
+    };
+  }
+  url;
+  apiKey;
+  options;
+  ws = null;
+  handlers = /* @__PURE__ */ new Map();
+  tokens = /* @__PURE__ */ new Map();
+  all = false;
+  attempt = 0;
+  closedByUser = false;
+  fatal = null;
+  ready = false;
+  reconnectTimer = null;
+  watchdog = null;
+  opts;
+  buildUrl(key) {
+    const sp = new URLSearchParams({ api_key: key });
+    if (this.options.scope) sp.set("scope", this.options.scope);
+    if (this.options.instance) sp.set("instance", this.options.instance);
+    return `${this.url}?${sp.toString()}`;
+  }
+  /** The URL with the key masked, safe to log. */
+  get safeUrl() {
+    return this.buildUrl("***");
+  }
+  get connected() {
+    return this.ws?.readyState === 1 && this.ready;
+  }
+  /** The tokens currently subscribed (kept across reconnects). */
+  get subscriptions() {
+    return { all: this.all, tokens: [...this.tokens.values()] };
+  }
+  on(event, handler) {
+    let set = this.handlers.get(event);
+    if (!set) this.handlers.set(event, set = /* @__PURE__ */ new Set());
+    set.add(handler);
+    return this;
+  }
+  off(event, handler) {
+    this.handlers.get(event)?.delete(handler);
+    return this;
+  }
+  emit(event, payload) {
+    for (const h of [...this.handlers.get(event) ?? []]) {
+      try {
+        h(payload);
+      } catch (err) {
+        if (event !== "error") this.emit("error", new CabalSpyIDError(String(err?.message ?? err), { code: "handler_error" }));
+      }
+    }
+  }
+  send(frame) {
+    if (this.ws?.readyState === 1 && this.ready) this.ws.send(JSON.stringify(frame));
+  }
+  // ── subscriptions ─────────────────────────────────────────────────────────
+  /** Adds tokens (at most 200 per connection). Sent now if connected, and after every reconnect. */
+  subscribe(tokens) {
+    const fresh = [];
+    for (const t of tokens) {
+      if (!t || !CHAINS.includes(t.blockchain)) {
+        throw new BadRequestError(`Unknown blockchain '${t?.blockchain}'`, {
+          code: "invalid_parameter",
+          parameter: "blockchain",
+          allowed: [...CHAINS]
+        });
+      }
+      if (!t.mint) throw new BadRequestError("Parameter 'mint' is required", { code: "missing_parameter", parameter: "mint" });
+      const k = keyOf(t);
+      if (!this.tokens.has(k)) fresh.push({ blockchain: t.blockchain, mint: t.mint.trim() });
+    }
+    if (this.tokens.size + fresh.length > MAX_THESES_STREAM_TOKENS) {
+      throw new BadRequestError(`At most ${MAX_THESES_STREAM_TOKENS} tokens per connection`, {
+        code: "too_many_tokens",
+        parameter: "tokens"
+      });
+    }
+    for (const t of fresh) this.tokens.set(keyOf(t), t);
+    if (fresh.length) this.send({ op: "subscribe", tokens: fresh });
+    return this;
+  }
+  /** Removes tokens. */
+  unsubscribe(tokens) {
+    const gone = tokens.filter((t) => this.tokens.delete(keyOf(t)));
+    if (gone.length) this.send({ op: "unsubscribe", tokens: gone });
+    return this;
+  }
+  /** Every token (all theses). */
+  subscribeAll() {
+    this.all = true;
+    this.send({ op: "subscribe", all: true });
+    return this;
+  }
+  /** Drops every subscription, including subscribeAll(). */
+  unsubscribeAll() {
+    this.all = false;
+    this.tokens.clear();
+    this.send({ op: "unsubscribe", all: true });
+    return this;
+  }
+  resubscribe() {
+    if (this.all) this.send({ op: "subscribe", all: true });
+    const list = [...this.tokens.values()];
+    if (list.length) this.send({ op: "subscribe", tokens: list });
+  }
+  // ── connection ────────────────────────────────────────────────────────────
+  /** Opens the socket; resolves on `ready` (after sending the remembered subscriptions). */
+  connect() {
+    this.closedByUser = false;
+    this.fatal = null;
+    const WS = this.options.WebSocketImpl ?? globalThis.WebSocket;
+    if (!WS) {
+      return Promise.reject(
+        new ConnectionError("No WebSocket implementation found. On Node < 22, run `npm i ws` and pass { WebSocketImpl: WebSocket }.", {
+          code: "no_websocket"
+        })
+      );
+    }
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const settle = (err, value) => {
+        if (settled) return;
+        settled = true;
+        if (err) reject(err);
+        else resolve(value);
+      };
+      this.ready = false;
+      const ws = new WS(this.buildUrl(this.apiKey));
+      this.ws = ws;
+      ws.onopen = () => {
+        this.arm();
+        this.emit("open", void 0);
+      };
+      ws.onmessage = (ev) => {
+        if (this.ws !== ws) return;
+        this.arm();
+        let msg;
+        try {
+          msg = JSON.parse(typeof ev.data === "string" ? ev.data : String(ev.data));
+        } catch {
+          return;
+        }
+        const event = msg.event;
+        if (event === "ready") {
+          this.ready = true;
+          this.attempt = 0;
+          this.resubscribe();
+          const data = msg.data;
+          this.emit("ready", data);
+          settle(null, data);
+        } else if (event === "subscribed") {
+          this.emit("subscribed", msg.data);
+        } else if (event && THESIS_EVENT_NAMES.includes(event)) {
+          this.emit(event, msg.data);
+        } else if (event === "heartbeat") {
+          this.emit("heartbeat", { ts: Number(msg.ts) });
+        } else if (event === "pong") {
+          this.emit("pong", {});
+        } else if (event === "error") {
+          const code = msg.error?.code ?? "stream_error";
+          const message = msg.error?.message ?? "Stream error";
+          if (!this.ready) {
+            const err = connectionError(code, message);
+            if (code !== "too_many_connections") this.fatal = err;
+            this.emit("error", err);
+            settle(err);
+          } else {
+            this.emit("error", new BadRequestError(message, { code, status: 400 }));
+          }
+        }
+      };
+      ws.onerror = () => {
+        if (this.ws !== ws) return;
+        const err = new ConnectionError(`WebSocket error on ${this.safeUrl}`, { code: "ws_error" });
+        this.emit("error", err);
+        settle(err);
+      };
+      ws.onclose = (ev) => {
+        if (this.ws !== ws) return;
+        this.ws = null;
+        this.ready = false;
+        this.disarm();
+        const e = ev ?? {};
+        this.emit("close", { code: e.code, reason: e.reason });
+        settle(new ConnectionError(`Theses stream closed before it was ready (code ${e.code ?? "unknown"})`, { code: "ws_closed_early" }));
+        if (!this.closedByUser && !this.fatal && this.opts.reconnect) this.scheduleReconnect();
+      };
+    });
+  }
+  scheduleReconnect() {
+    const delay = Math.min(this.opts.reconnectDelay * 2 ** this.attempt, this.opts.maxReconnectDelay) + Math.random() * 250;
+    this.attempt++;
+    this.emit("reconnecting", { attempt: this.attempt, delay });
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      if (!this.closedByUser) this.connect().catch(() => void 0);
+    }, delay);
+  }
+  arm() {
+    if (!this.opts.heartbeatTimeout) return;
+    this.disarm();
+    this.watchdog = setTimeout(() => {
+      this.emit("error", new ConnectionError("No heartbeat from the theses stream; reconnecting", { code: "heartbeat_timeout" }));
+      this.ws?.close(4e3, "heartbeat timeout");
+    }, this.opts.heartbeatTimeout);
+  }
+  disarm() {
+    if (this.watchdog) clearTimeout(this.watchdog);
+    this.watchdog = null;
+  }
+  /** Sends a ping (answered with `pong`). Pinging more often than every 30 s suppresses heartbeats. */
+  ping() {
+    if (this.ws?.readyState === 1) this.ws.send(JSON.stringify({ op: "ping" }));
+  }
+  /** Closes the socket and stops reconnecting. Subscriptions are kept for a later connect(). */
+  close() {
+    this.closedByUser = true;
+    this.disarm();
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    this.reconnectTimer = null;
+    const ws = this.ws;
+    this.ws = null;
+    this.ready = false;
+    ws?.close(1e3, "client closed");
+    this.emit("close", { code: 1e3, reason: "client closed" });
+  }
+  /**
+   * Iterates over thesis events as `{ event, data }`. Connects if needed;
+   * breaking out closes a connection the iterator opened.
+   */
+  async *[Symbol.asyncIterator]() {
+    const queue = [];
+    let wake = null;
+    let failure = null;
+    let done = false;
+    const listeners = THESIS_EVENT_NAMES.map((name) => {
+      const fn = (data) => {
+        queue.push({ event: name, data });
+        wake?.();
+      };
+      return [name, fn];
+    });
+    const onError = () => {
+      if (this.fatal) {
+        failure = this.fatal;
+        wake?.();
+      }
+    };
+    const onClose = () => {
+      if (this.closedByUser || !this.opts.reconnect) {
+        done = true;
+        wake?.();
+      }
+    };
+    for (const [name, fn] of listeners) this.on(name, fn);
+    this.on("error", onError).on("close", onClose);
+    const owns = !this.ws;
+    try {
+      if (owns) await this.connect();
+      while (true) {
+        while (queue.length) yield queue.shift();
+        if (failure) throw failure;
+        if (done) return;
+        await new Promise((r) => wake = r);
+        wake = null;
+      }
+    } finally {
+      for (const [name, fn] of listeners) this.off(name, fn);
+      this.off("error", onError).off("close", onClose);
+      if (owns && !this.closedByUser) this.close();
+    }
+  }
+};
+
+// src/util.ts
+var SDK_VERSION = "0.5.2";
+var USER_AGENT = `cabalspy-id-sdk/${SDK_VERSION}`;
+var enc = new TextEncoder();
+var dec = new TextDecoder();
+function utf8(text) {
+  return enc.encode(text);
+}
+function fromUtf8(bytes) {
+  return dec.decode(bytes);
+}
+function bytesToBase64(bytes) {
+  let s = "";
+  for (let i = 0; i < bytes.length; i++) s += String.fromCharCode(bytes[i]);
+  return btoa(s);
+}
+function base64ToBytes(b64) {
+  const bin = atob(b64);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+}
+function base64UrlEncode(bytes) {
+  return bytesToBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function base64UrlDecode(text) {
+  const b64 = text.replace(/-/g, "+").replace(/_/g, "/");
+  return base64ToBytes(b64 + "=".repeat((4 - b64.length % 4) % 4));
+}
+var cryptoPromise = null;
+function getCrypto() {
+  const g = globalThis.crypto;
+  if (g?.subtle) return Promise.resolve(g);
+  if (!cryptoPromise) {
+    const mod = "node:crypto";
+    cryptoPromise = import(
+      /* webpackIgnore: true */
+      /* @vite-ignore */
+      mod
+    ).then(
+      (m) => m.webcrypto
+    );
+  }
+  return cryptoPromise;
+}
+async function randomToken(bytes = 32) {
+  const c = await getCrypto();
+  const a = new Uint8Array(bytes);
+  c.getRandomValues(a);
+  return base64UrlEncode(a);
+}
+async function sha256Base64Url(text) {
+  const c = await getCrypto();
+  return base64UrlEncode(new Uint8Array(await c.subtle.digest("SHA-256", utf8(text))));
+}
+function timingSafeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  return diff === 0;
+}
+function env(name) {
+  return globalThis.process?.env?.[name];
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api-id.cabalspy.xyz/v1";
+var DEFAULT_STREAM_URL = "wss://api-id.cabalspy.xyz/v1/stream";
+var DEFAULT_THESES_STREAM_URL = "wss://api-id.cabalspy.xyz/v1/theses/stream";
+function buildQuery(params) {
+  const sp = new URLSearchParams();
+  for (const [k, v] of Object.entries(params)) {
+    if (v === void 0 || v === null || v === "") continue;
+    sp.append(k, typeof v === "boolean" ? v ? "true" : "false" : String(v));
+  }
+  const s = sp.toString();
+  return s ? `?${s}` : "";
+}
+function parseNumHeader(h, name) {
+  const raw = h.get(name);
+  if (raw == null) return null;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) ? n : null;
+}
+function backoffDelay(attempt, lastError) {
+  if (lastError instanceof RateLimitError && lastError.retryAfter != null) {
+    return Math.min(lastError.retryAfter * 1e3, 6e4);
+  }
+  const base = 500 * 2 ** (attempt - 1);
+  return Math.min(base, 8e3) + Math.random() * 250;
+}
+function assertOneOf(value, allowed, parameter) {
+  if (value === void 0) return;
+  if (!allowed.includes(value)) {
+    throw new BadRequestError(`Invalid value for '${parameter}': ${value}`, {
+      code: "invalid_parameter",
+      parameter,
+      allowed: [...allowed]
+    });
+  }
+}
+function assertRequired(value, parameter) {
+  if (value === void 0 || value === null || value === "") {
+    throw new BadRequestError(`Parameter '${parameter}' is required`, { code: "missing_parameter", parameter });
+  }
+}
+function assertToken(p) {
+  assertRequired(p.blockchain, "blockchain");
+  assertOneOf(p.blockchain, CHAINS, "blockchain");
+  assertRequired(p.mint, "mint");
+}
+function assertWallet(p) {
+  assertRequired(p.blockchain, "blockchain");
+  assertOneOf(p.blockchain, CHAINS, "blockchain");
+  assertRequired(p.address, "address");
+}
+var CabalSpyID = class {
+  baseUrl;
+  streamUrl;
+  thesesStreamUrl;
+  timeout;
+  maxRetries;
+  instance;
+  apiKey;
+  extraHeaders;
+  fetchImpl;
+  /** Rate limit state from the most recent request. */
+  lastRateLimit = { ...EMPTY_RATE_LIMIT };
+  constructor(options = {}) {
+    this.apiKey = options.apiKey ?? (env("CABALSPY_ID_API_KEY") || env("CABALSPY_API_KEY") || "");
+    this.instance = options.instance ?? (env("CABALSPY_ID_INSTANCE") || void 0);
+    this.baseUrl = (options.baseUrl ?? (env("CABALSPY_ID_BASE_URL") || DEFAULT_BASE_URL)).replace(/\/+$/, "");
+    this.streamUrl = (options.streamUrl ?? (env("CABALSPY_ID_STREAM_URL") || DEFAULT_STREAM_URL)).replace(/\/+$/, "");
+    this.thesesStreamUrl = (options.thesesStreamUrl ?? DEFAULT_THESES_STREAM_URL).replace(/\/+$/, "");
+    this.timeout = options.timeout ?? 3e4;
+    this.maxRetries = options.maxRetries ?? 2;
+    this.extraHeaders = options.headers ?? {};
+    const f = options.fetch ?? globalThis.fetch;
+    if (typeof f !== "function") {
+      throw new CabalSpyIDError("No fetch implementation available. Use Node 18+ or pass { fetch }.", {
+        code: "no_fetch"
+      });
+    }
+    this.fetchImpl = options.fetch ?? f.bind(globalThis);
+  }
+  // ── HTTP core ─────────────────────────────────────────────────────────────
+  authedQuery(query, auth) {
+    if (auth && !this.apiKey) {
+      throw new AuthenticationError(
+        "Missing API key. Pass { apiKey } or set CABALSPY_ID_API_KEY (the CabalSpy API key with CabalSpy ID enabled).",
+        { status: 401, code: "missing_api_key" }
+      );
+    }
+    return auth && this.instance && query.instance === void 0 ? { ...query, instance: this.instance } : query;
+  }
+  /** GET returning the full envelope: data, pagination, meta and rate limit. */
+  async getRaw(path, query = {}, opts = {}) {
+    const auth = opts.auth ?? true;
+    return this.request("GET", path + buildQuery(this.authedQuery(query, auth)), auth);
+  }
+  /** GET returning only the data payload. */
+  async get(path, query = {}) {
+    return (await this.getRaw(path, query)).data;
+  }
+  /**
+   * POST with a JSON body, returning the full envelope. POSTs are not retried
+   * after a server or network error (the write may have happened); only the
+   * API's own rate limit (429 rate_limit_exceeded) is retried.
+   */
+  async postRaw(path, body) {
+    return this.request("POST", path + buildQuery(this.authedQuery({}, true)), true, body);
+  }
+  /** POST returning only the data payload. */
+  async post(path, body) {
+    return (await this.postRaw(path, body)).data;
+  }
+  async request(method, path, auth, body) {
+    const url = `${this.baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
+    const label = `${method} ${stripQuery(path)}`;
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      if (attempt > 0) await sleep(backoffDelay(attempt, lastError));
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), this.timeout);
+      let res;
+      let text;
+      try {
+        res = await this.fetchImpl(url, {
+          method,
+          signal: controller.signal,
+          headers: {
+            ...auth ? { Authorization: `Bearer ${this.apiKey}` } : {},
+            Accept: "application/json",
+            "User-Agent": USER_AGENT,
+            ...body !== void 0 ? { "Content-Type": "application/json" } : {},
+            ...this.extraHeaders
+          },
+          body: body !== void 0 ? JSON.stringify(body) : void 0
+        });
+        text = await res.text();
+      } catch (err) {
+        const aborted = err?.name === "AbortError";
+        lastError = new ConnectionError(
+          aborted ? `Request timed out after ${this.timeout} ms: ${label}` : `Network error: ${err?.message ?? String(err)}`,
+          { code: aborted ? "timeout" : "connection_error" }
+        );
+        if (method !== "GET") throw lastError;
+        continue;
+      } finally {
+        clearTimeout(timer);
+      }
+      const rateLimit = {
+        limit: parseNumHeader(res.headers, "X-RateLimit-Limit"),
+        remaining: parseNumHeader(res.headers, "X-RateLimit-Remaining"),
+        reset: parseNumHeader(res.headers, "X-RateLimit-Reset")
+      };
+      this.lastRateLimit = rateLimit;
+      let parsed = null;
+      if (text) {
+        try {
+          parsed = JSON.parse(text);
+        } catch {
+          parsed = null;
+        }
+      }
+      if (!res.ok) {
+        const errBody = parsed?.error ?? null;
+        const retryAfter = parseNumHeader(res.headers, "Retry-After");
+        const error = errorFromStatus(res.status, errBody, rateLimit, retryAfter, `HTTP ${res.status} on ${label}`);
+        const retryable = method === "GET" ? isRetryable(error) : error instanceof RateLimitError && error.code === "rate_limit_exceeded";
+        if (retryable && attempt < this.maxRetries) {
+          lastError = error;
+          continue;
+        }
+        throw error;
+      }
+      if (parsed == null || typeof parsed !== "object" || !("data" in parsed)) {
+        throw new InvalidResponseError(`Unexpected response shape on ${label}: no data field`, {
+          status: res.status,
+          code: "invalid_response",
+          rateLimit
+        });
+      }
+      return { ...parsed, rateLimit, status: res.status };
+    }
+    throw lastError ?? new ConnectionError(`Request failed: ${label}`);
+  }
+  /**
+   * Walks a cursor-paginated route and yields whole pages.
+   *
+   *   for await (const page of csid.pages((cursor) => csid.usersRaw({ cursor }))) …
+   *
+   * Reads `pagination` from the envelope or, for the leaderboard, from `data`.
+   */
+  async *pages(fetchPage, opts = {}) {
+    let cursor = opts.cursor;
+    const maxPages = opts.maxPages ?? Infinity;
+    for (let i = 0; i < maxPages; i++) {
+      const page = await fetchPage(cursor);
+      const inner = page.data?.pagination;
+      const pagination = page.pagination ?? inner;
+      yield { ...page, pagination };
+      const next = pagination?.next_cursor;
+      if (!pagination?.has_more || !next) return;
+      cursor = next;
+    }
+  }
+  // ── account ───────────────────────────────────────────────────────────────
+  /** GET /v1/health — service health and trade sync freshness. No API key required. */
+  async health() {
+    return (await this.getRaw("/health", {}, { auth: false })).data;
+  }
+  /** GET /v1/me — the key's instance, plan, request rate and number of users with data. */
+  async me() {
+    return this.get("/me");
+  }
+  // ── users ─────────────────────────────────────────────────────────────────
+  /** GET /v1/users — users of your instance (within the plan's user limit), newest first. */
+  async users(params = {}) {
+    return (await this.usersRaw(params)).data;
+  }
+  async usersRaw(params = {}) {
+    return this.getRaw("/users", {
+      limit: params.limit,
+      kol: params.kol ? "true" : void 0,
+      cursor: params.cursor,
+      scope: params.scope
+    });
+  }
+  /** Iterates over every user, following `next_cursor`. */
+  async *iterUsers(params = {}) {
+    for await (const page of this.pages((cursor) => this.usersRaw({ ...params, cursor }), { cursor: params.cursor })) {
+      yield* page.data;
+    }
+  }
+  /**
+   * GET /v1/profile — one user by X username, by `csid_id` (the `sub` of their
+   * ID token) or by a verified wallet address. Pass exactly one.
+   *
+   * An anonymous `anon_…` sub throws PlanUserLimitError.
+   */
+  async profile(params) {
+    const p = params;
+    const given = [p.username, p.csid_id, p.address].filter((v) => v !== void 0 && v !== "").length;
+    if (given !== 1) {
+      throw new BadRequestError("Pass exactly one of: username, csid_id, address.", {
+        code: "missing_parameter",
+        parameter: "username|csid_id|address"
+      });
+    }
+    return this.get("/profile", {
+      username: p.username?.replace(/^@/, ""),
+      csid_id: p.csid_id,
+      address: p.address,
+      scope: p.scope
+    });
+  }
+  /** GET /v1/wallets/lookup — which of your users verified this wallet (by an on-chain payment). */
+  async walletLookup(address, params = {}) {
+    assertRequired(address, "address");
+    return this.get("/wallets/lookup", { address, scope: params.scope });
+  }
+  // ── trading ───────────────────────────────────────────────────────────────
+  /**
+   * GET /v1/wallets/tracker — stats, realized PnL, win-rate distribution,
+   * tokens, PnL chart (cumulative from 0) and trades of a verified wallet for a
+   * period. Same numbers as the CabalSpy API.
+   */
+  async tracker(params) {
+    assertWallet(params);
+    assertOneOf(params.period, PERIODS, "period");
+    return this.get("/wallets/tracker", { ...params });
+  }
+  /** GET /v1/wallets/history — lifetime stats, token overview and one page of trades. */
+  async history(params) {
+    return (await this.historyRaw(params)).data;
+  }
+  async historyRaw(params) {
+    assertWallet(params);
+    return this.getRaw("/wallets/history", { ...params });
+  }
+  /** Iterates over every trade of a wallet, newest first, following `next_cursor`. */
+  async *iterHistory(params) {
+    for await (const page of this.pages((cursor) => this.historyRaw({ ...params, cursor }), { cursor: params.cursor })) {
+      yield* page.data.trades;
+    }
+  }
+  /** GET /v1/wallets/holdings — current token balances with USD value (dust under $0.01 hidden). */
+  async holdings(params) {
+    assertWallet(params);
+    return this.get("/wallets/holdings", { ...params });
+  }
+  /** GET /v1/wallets/pnl_calendar — realized PnL per UTC day, grouped by month. */
+  async pnlCalendar(params) {
+    assertWallet(params);
+    return this.get("/wallets/pnl_calendar", { ...params });
+  }
+  /** GET /v1/wallets/leaderboard — your users ranked by volume, PnL, win rate or trades. */
+  async leaderboard(params) {
+    return (await this.leaderboardRaw(params)).data;
+  }
+  async leaderboardRaw(params) {
+    assertRequired(params.blockchain, "blockchain");
+    assertOneOf(params.blockchain, CHAINS, "blockchain");
+    assertOneOf(params.period, PERIODS, "period");
+    assertOneOf(params.sort, LEADERBOARD_SORTS, "sort");
+    return this.getRaw("/wallets/leaderboard", { ...params });
+  }
+  /** Iterates over every leaderboard entry, following `next_cursor`. */
+  async *iterLeaderboard(params) {
+    for await (const page of this.pages((cursor) => this.leaderboardRaw({ ...params, cursor }), { cursor: params.cursor })) {
+      yield* page.data.leaderboard;
+    }
+  }
+  /** GET /v1/transactions/latest — the newest trades of your users, each with the trader. */
+  async latestTransactions(params = {}) {
+    assertOneOf(params.blockchain, CHAINS, "blockchain");
+    return this.get("/transactions/latest", { ...params });
+  }
+  // -- theses ----------------------------------------------------------------
+  // Reading: theses are public; any key reads them, also outside its instance.
+  /** GET /v1/theses — theses on a token, newest or top first. */
+  async listTheses(params) {
+    return (await this.listThesesRaw(params)).data;
+  }
+  async listThesesRaw(params) {
+    assertToken(params);
+    assertOneOf(params.sort, ["new", "top"], "sort");
+    assertOneOf(params.stance, ["bull", "bear"], "stance");
+    assertOneOf(params.scope, ["global", "instance"], "scope");
+    return this.getRaw("/theses", { ...params });
+  }
+  /** Iterates over every thesis on a token, following `next_cursor`. */
+  async *iterTheses(params) {
+    for await (const page of this.pages((cursor) => this.listThesesRaw({ ...params, cursor }), { cursor: params.cursor })) {
+      yield* page.data;
+    }
+  }
+  /** GET /v1/theses/summary — counts (theses, bull, bear, authors) and token info. */
+  async thesisSummary(params) {
+    assertToken(params);
+    assertOneOf(params.scope, ["global", "instance"], "scope");
+    return this.get("/theses/summary", { blockchain: params.blockchain, mint: params.mint, scope: params.scope });
+  }
+  /** GET /v1/theses/item — one thesis or reply. */
+  async thesis(id, params = {}) {
+    assertRequired(id, "id");
+    return this.get("/theses/item", { id, csid_id: params.csid_id });
+  }
+  /** GET /v1/theses/replies — replies to a thesis. */
+  async thesisReplies(params) {
+    return (await this.thesisRepliesRaw(params)).data;
+  }
+  async thesisRepliesRaw(params) {
+    assertRequired(params.id, "id");
+    return this.getRaw("/theses/replies", { ...params });
+  }
+  /** Iterates over every reply of a thesis. */
+  async *iterThesisReplies(params) {
+    for await (const page of this.pages((cursor) => this.thesisRepliesRaw({ ...params, cursor }), { cursor: params.cursor })) {
+      yield* page.data;
+    }
+  }
+  /** GET /v1/theses/latest — newest theses on every token (or only your users'). */
+  async latestTheses(params = {}) {
+    return (await this.latestThesesRaw(params)).data;
+  }
+  async latestThesesRaw(params = {}) {
+    assertOneOf(params.blockchain, CHAINS, "blockchain");
+    assertOneOf(params.users, ["all", "instance"], "users");
+    assertOneOf(params.scope, ["global", "instance"], "scope");
+    return this.getRaw("/theses/latest", { ...params });
+  }
+  /** GET /v1/theses/user — theses of one user, by csid_id or X username. */
+  async userTheses(params) {
+    return (await this.userThesesRaw(params)).data;
+  }
+  async userThesesRaw(params) {
+    const p = params;
+    if (!!p.csid_id === !!p.username) {
+      throw new BadRequestError("Pass exactly one of: csid_id, username.", {
+        code: "missing_parameter",
+        parameter: "csid_id|username"
+      });
+    }
+    return this.getRaw("/theses/user", { ...p, username: p.username?.replace(/^@/, "") });
+  }
+  /**
+   * GET /v1/theses/eligibility — may this user post (holder, not paused) and
+   * reply on this token through your app? `reason` says why not
+   * (consent_required, plan_user_limit, sandbox_user).
+   */
+  async thesisEligibility(params) {
+    assertToken(params);
+    assertRequired(params.csid_id, "csid_id");
+    return this.get("/theses/eligibility", { ...params });
+  }
+  // Writing, in the name of one of your users (scope `thesis`).
+  /** POST /v1/theses — posts a thesis. Holders only (`not_a_holder` otherwise). */
+  async postThesis(params) {
+    assertToken(params);
+    assertRequired(params.body, "body");
+    assertRequired(params.csid_id, "csid_id");
+    assertOneOf(params.stance, ["bull", "bear"], "stance");
+    return this.post("/theses", { ...params });
+  }
+  /** POST /v1/theses/replies — replies to a thesis. */
+  async replyToThesis(params) {
+    assertRequired(params.thesis_id, "thesis_id");
+    assertRequired(params.body, "body");
+    assertRequired(params.csid_id, "csid_id");
+    return this.post("/theses/replies", { ...params });
+  }
+  /** POST /v1/theses/reactions — adds (or with `on: false` removes) a reaction. */
+  async reactToThesis(params) {
+    assertRequired(params.thesis_id, "thesis_id");
+    assertOneOf(params.emoji, THESIS_EMOJIS, "emoji");
+    assertRequired(params.csid_id, "csid_id");
+    return this.post("/theses/reactions", { ...params, on: params.on ?? true });
+  }
+  /** POST /v1/theses/report — reports a post (hidden for review after 3 reports). */
+  async reportThesis(params) {
+    assertRequired(params.thesis_id, "thesis_id");
+    assertOneOf(params.reason, THESIS_REPORT_REASONS, "reason");
+    assertRequired(params.csid_id, "csid_id");
+    return this.post("/theses/report", { ...params });
+  }
+  /**
+   * GET /v1/theses/notifications — moderation notifications of one of your users
+   * (warnings, hidden posts, pauses, appeal results), with the unread count.
+   */
+  async thesisNotifications(csidId) {
+    assertRequired(csidId, "csid_id");
+    return this.get("/theses/notifications", { csid_id: csidId });
+  }
+  /**
+   * POST /v1/theses/appeal — appeals a moderation decision in the user's name
+   * (an `appealable` notification, within 30 days; message 10-1000 characters).
+   */
+  async appealThesisDecision(csidId, notificationId, message) {
+    assertRequired(csidId, "csid_id");
+    assertRequired(notificationId, "notification_id");
+    assertRequired(message, "message");
+    return this.post("/theses/appeal", { csid_id: csidId, notification_id: notificationId, message });
+  }
+  /** POST /v1/theses/delete — deletes the user's own thesis or reply. */
+  async deleteThesis(params) {
+    assertRequired(params.thesis_id, "thesis_id");
+    assertRequired(params.csid_id, "csid_id");
+    return this.post("/theses/delete", { ...params });
+  }
+  // ── stream ────────────────────────────────────────────────────────────────
+  /**
+   * Live trades of your users over WebSocket (Pro plan and up).
+   *
+   *   const stream = csid.stream({ blockchain: 'solana' });
+   *   stream.on('trade', (trade) => console.log(trade));
+   *   await stream.connect();
+   */
+  stream(options = {}) {
+    if (!this.apiKey) {
+      throw new AuthenticationError("The stream needs an API key.", { status: 401, code: "missing_api_key" });
+    }
+    return new CabalSpyIDStream(this.streamUrl, this.apiKey, { instance: this.instance, ...options });
+  }
+  /**
+   * Live theses for the tokens you subscribe to (every plan), e.g. for a chart.
+   *
+   *   const ts = csid.thesesStream();
+   *   ts.on('thesis', (t) => addMarker(t));
+   *   await ts.connect();
+   *   ts.subscribe([{ blockchain: 'solana', mint }]);
+   */
+  thesesStream(options = {}) {
+    if (!this.apiKey) {
+      throw new AuthenticationError("The theses stream needs an API key.", { status: 401, code: "missing_api_key" });
+    }
+    return new ThesesStream(this.thesesStreamUrl, this.apiKey, { instance: this.instance, ...options });
+  }
+};
+function stripQuery(path) {
+  const i = path.indexOf("?");
+  return i === -1 ? path : path.slice(0, i);
+}
+
+// src/webhooks.ts
+function header(headers, name) {
+  if (typeof headers.get === "function") {
+    return headers.get(name) ?? void 0;
+  }
+  const rec = headers;
+  const key = Object.keys(rec).find((k) => k.toLowerCase() === name);
+  const v = key === void 0 ? void 0 : rec[key];
+  return Array.isArray(v) ? v[0] : v;
+}
+function toBytes(payload) {
+  if (typeof payload === "string") return utf8(payload);
+  return new Uint8Array(payload instanceof Uint8Array ? payload : new Uint8Array(payload));
+}
+function secretKey(secret) {
+  try {
+    return base64ToBytes(secret.startsWith("whsec_") ? secret.slice(6) : secret);
+  } catch {
+    throw new WebhookVerificationError("The webhook secret is not valid base64 (expected whsec_\u2026)", { code: "invalid_secret" });
+  }
+}
+async function hmac(secret, content) {
+  const c = await getCrypto();
+  const key = await c.subtle.importKey("raw", secretKey(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  return bytesToBase64(new Uint8Array(await c.subtle.sign("HMAC", key, content)));
+}
+function signedContent(id, timestamp, body) {
+  const prefix = utf8(`${id}.${timestamp}.`);
+  const out = new Uint8Array(prefix.length + body.length);
+  out.set(prefix, 0);
+  out.set(body, prefix.length);
+  return out;
+}
+async function signWebhook(secret, id, timestamp, payload) {
+  return `v1,${await hmac(secret, signedContent(id, timestamp, toBytes(payload)))}`;
+}
+async function verifyWebhook(options) {
+  const { headers, secret } = options;
+  if (!secret) throw new WebhookVerificationError("Missing webhook secret", { code: "invalid_secret" });
+  const id = header(headers, "webhook-id");
+  const ts = header(headers, "webhook-timestamp");
+  const sigs = header(headers, "webhook-signature");
+  if (!id || !ts || !sigs) {
+    throw new WebhookVerificationError("Missing webhook-id, webhook-timestamp or webhook-signature header", {
+      code: "missing_headers"
+    });
+  }
+  const timestamp = Number(ts);
+  if (!/^\d+$/.test(ts) || !Number.isSafeInteger(timestamp)) {
+    throw new WebhookVerificationError("Invalid webhook-timestamp", { code: "invalid_timestamp" });
+  }
+  const now = options.now ?? Math.floor(Date.now() / 1e3);
+  const tolerance = options.toleranceSeconds ?? 300;
+  if (now - timestamp > tolerance) throw new WebhookVerificationError("Webhook timestamp is too old", { code: "timestamp_too_old" });
+  if (timestamp - now > tolerance) throw new WebhookVerificationError("Webhook timestamp is in the future", { code: "timestamp_too_new" });
+  const body = toBytes(options.payload);
+  const expected = await hmac(secret, signedContent(id, ts, body));
+  const match = sigs.split(" ").map((s) => s.trim()).filter(Boolean).some((s) => {
+    const [version, sig] = s.split(",", 2);
+    return version === "v1" && sig !== void 0 && timingSafeEqual(sig, expected);
+  });
+  if (!match) throw new WebhookVerificationError("No matching webhook signature", { code: "invalid_signature" });
+  try {
+    return JSON.parse(fromUtf8(body));
+  } catch {
+    throw new WebhookVerificationError("Webhook body is not valid JSON", { code: "invalid_payload" });
+  }
+}
+
+// src/users.ts
+function handleKind(handle) {
+  if (handle.startsWith("tg.")) return "telegram";
+  if (handle.startsWith("id.")) return "google";
+  return "x";
+}
+function hasX(user) {
+  if (!user) return false;
+  if (user.x !== void 0) return user.x !== null;
+  if (user.twitter !== void 0) return Boolean(user.twitter);
+  const handle = user.preferred_username ?? user.username;
+  return typeof handle === "string" && handle.length > 0 && handleKind(handle) === "x";
+}
+
+export {
+  CHAINS,
+  PERIODS,
+  LEADERBOARD_SORTS,
+  CURRENCY_BY_CHAIN,
+  THESIS_EMOJIS,
+  THESIS_REPORT_REASONS,
+  THESIS_MAX_BODY,
+  CabalSpyIDStream,
+  MAX_THESES_STREAM_TOKENS,
+  ThesesStream,
+  SDK_VERSION,
+  USER_AGENT,
+  utf8,
+  fromUtf8,
+  base64UrlDecode,
+  getCrypto,
+  randomToken,
+  sha256Base64Url,
+  timingSafeEqual,
+  env,
+  DEFAULT_BASE_URL,
+  DEFAULT_STREAM_URL,
+  DEFAULT_THESES_STREAM_URL,
+  CabalSpyID,
+  signWebhook,
+  verifyWebhook,
+  handleKind,
+  hasX
+};
+//# sourceMappingURL=chunk-XLBO2RSL.js.map