@toon-protocol/relay 1.3.3 → 2.0.0

package/dist/chunk-745ADETR.js

@@ -0,0 +1,1027 @@
+// src/version.ts
+var VERSION = "0.1.0";
+
+// src/types.ts
+var DEFAULT_RELAY_CONFIG = {
+  port: 7e3,
+  host: "0.0.0.0",
+  maxConnections: 100,
+  maxSubscriptionsPerConnection: 20,
+  maxFiltersPerSubscription: 10,
+  databasePath: ":memory:"
+};
+
+// src/filters/matchFilter.ts
+function matchFilter(event, filter) {
+  if (Object.keys(filter).length === 0) {
+    return true;
+  }
+  if (filter.ids !== void 0 && filter.ids.length > 0) {
+    const matches = filter.ids.some((id) => event.id.startsWith(id));
+    if (!matches) return false;
+  }
+  if (filter.authors !== void 0 && filter.authors.length > 0) {
+    const matches = filter.authors.some(
+      (author) => event.pubkey.startsWith(author)
+    );
+    if (!matches) return false;
+  }
+  if (filter.kinds !== void 0 && filter.kinds.length > 0) {
+    if (!filter.kinds.includes(event.kind)) return false;
+  }
+  if (filter.since !== void 0) {
+    if (event.created_at < filter.since) return false;
+  }
+  if (filter.until !== void 0) {
+    if (event.created_at > filter.until) return false;
+  }
+  for (const key of Object.keys(filter)) {
+    if (key.startsWith("#") && key.length === 2) {
+      const tagName = key.slice(1);
+      const filterValues = filter[key];
+      if (filterValues !== void 0 && filterValues.length > 0) {
+        const eventTagValues = event.tags.filter((tag) => tag[0] === tagName).map((tag) => tag[1]);
+        const hasMatch = filterValues.some((v) => eventTagValues.includes(v));
+        if (!hasMatch) return false;
+      }
+    }
+  }
+  return true;
+}
+
+// src/storage/InMemoryEventStore.ts
+var InMemoryEventStore = class {
+  events = /* @__PURE__ */ new Map();
+  store(event) {
+    this.events.set(event.id, event);
+  }
+  get(id) {
+    return this.events.get(id);
+  }
+  query(filters) {
+    const allEvents = Array.from(this.events.values());
+    if (filters.length === 0) {
+      return allEvents.sort((a, b) => b.created_at - a.created_at);
+    }
+    const matchingEvents = [];
+    for (const event of allEvents) {
+      for (const filter of filters) {
+        if (matchFilter(event, filter)) {
+          matchingEvents.push(event);
+          break;
+        }
+      }
+    }
+    matchingEvents.sort((a, b) => b.created_at - a.created_at);
+    const limitFilter = filters.find((f) => f.limit !== void 0);
+    if (limitFilter?.limit !== void 0) {
+      return matchingEvents.slice(0, limitFilter.limit);
+    }
+    return matchingEvents;
+  }
+  /**
+   * Close the storage backend (no-op for in-memory store).
+   */
+  close() {
+  }
+};
+
+// src/storage/SqliteEventStore.ts
+import Database from "better-sqlite3";
+var SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS events (
+  id TEXT PRIMARY KEY,
+  pubkey TEXT NOT NULL,
+  kind INTEGER NOT NULL,
+  content TEXT NOT NULL,
+  tags TEXT NOT NULL,
+  created_at INTEGER NOT NULL,
+  sig TEXT NOT NULL,
+  received_at INTEGER NOT NULL
+)
+`;
+var INDEX_SQL = [
+  "CREATE INDEX IF NOT EXISTS idx_events_pubkey ON events(pubkey)",
+  "CREATE INDEX IF NOT EXISTS idx_events_kind ON events(kind)",
+  "CREATE INDEX IF NOT EXISTS idx_events_created_at ON events(created_at)",
+  "CREATE INDEX IF NOT EXISTS idx_events_pubkey_kind ON events(pubkey, kind)"
+];
+function initializeSchema(db) {
+  db.exec(SCHEMA_SQL);
+  for (const indexSql of INDEX_SQL) {
+    db.exec(indexSql);
+  }
+}
+var RelayError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "RelayError";
+  }
+};
+function isReplaceableKind(kind) {
+  return kind >= 1e4 && kind <= 19999 && !(kind >= 10032 && kind <= 10099);
+}
+function isParameterizedReplaceableKind(kind) {
+  return kind >= 3e4 && kind <= 39999 || kind >= 10032 && kind <= 10099;
+}
+function getDTagValue(tags) {
+  const dTag = tags.find((tag) => tag[0] === "d");
+  return dTag?.[1] ?? "";
+}
+var SqliteEventStore = class {
+  db;
+  insertStmt;
+  getStmt;
+  deleteByPubkeyKindStmt;
+  deleteByPubkeyKindDTagStmt;
+  getByPubkeyKindStmt;
+  getByPubkeyKindDTagStmt;
+  /**
+   * Create a new SqliteEventStore.
+   * @param dbPath - Path to the database file. Use ':memory:' for in-memory database.
+   */
+  constructor(dbPath = ":memory:") {
+    try {
+      this.db = new Database(dbPath);
+      initializeSchema(this.db);
+      this.insertStmt = this.db.prepare(`
+        INSERT OR REPLACE INTO events (id, pubkey, kind, content, tags, created_at, sig, received_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+      this.getStmt = this.db.prepare("SELECT * FROM events WHERE id = ?");
+      this.deleteByPubkeyKindStmt = this.db.prepare(
+        "DELETE FROM events WHERE pubkey = ? AND kind = ?"
+      );
+      this.deleteByPubkeyKindDTagStmt = this.db.prepare(
+        "DELETE FROM events WHERE pubkey = ? AND kind = ? AND json_extract(tags, '$') LIKE ?"
+      );
+      this.getByPubkeyKindStmt = this.db.prepare(
+        "SELECT id, created_at FROM events WHERE pubkey = ? AND kind = ?"
+      );
+      this.getByPubkeyKindDTagStmt = this.db.prepare(
+        "SELECT id, created_at FROM events WHERE pubkey = ? AND kind = ? AND tags LIKE ?"
+      );
+    } catch (error) {
+      throw new RelayError(
+        `Failed to initialize database: ${error instanceof Error ? error.message : String(error)}`,
+        "STORAGE_ERROR"
+      );
+    }
+  }
+  /**
+   * Store an event in the database.
+   * Handles replaceable and parameterized replaceable events according to NIP-01.
+   */
+  store(event) {
+    try {
+      const tagsJson = JSON.stringify(event.tags);
+      const receivedAt = Math.floor(Date.now() / 1e3);
+      if (isReplaceableKind(event.kind)) {
+        this.storeReplaceableEvent(event, tagsJson, receivedAt);
+      } else if (isParameterizedReplaceableKind(event.kind)) {
+        this.storeParameterizedReplaceableEvent(event, tagsJson, receivedAt);
+      } else {
+        const insertOrIgnore = this.db.prepare(`
+          INSERT OR IGNORE INTO events (id, pubkey, kind, content, tags, created_at, sig, received_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        `);
+        insertOrIgnore.run(
+          event.id,
+          event.pubkey,
+          event.kind,
+          event.content,
+          tagsJson,
+          event.created_at,
+          event.sig,
+          receivedAt
+        );
+      }
+    } catch (error) {
+      if (error instanceof RelayError) {
+        throw error;
+      }
+      throw new RelayError(
+        `Failed to store event: ${error instanceof Error ? error.message : String(error)}`,
+        "STORAGE_ERROR"
+      );
+    }
+  }
+  /**
+   * Store a replaceable event (kinds 10000-19999).
+   * Only keeps the latest event per pubkey+kind.
+   */
+  storeReplaceableEvent(event, tagsJson, receivedAt) {
+    const existing = this.getByPubkeyKindStmt.get(event.pubkey, event.kind);
+    if (existing) {
+      if (event.created_at > existing.created_at || event.created_at === existing.created_at && event.id < existing.id) {
+        const transaction = this.db.transaction(() => {
+          this.deleteByPubkeyKindStmt.run(event.pubkey, event.kind);
+          this.insertStmt.run(
+            event.id,
+            event.pubkey,
+            event.kind,
+            event.content,
+            tagsJson,
+            event.created_at,
+            event.sig,
+            receivedAt
+          );
+        });
+        transaction();
+      }
+    } else {
+      this.insertStmt.run(
+        event.id,
+        event.pubkey,
+        event.kind,
+        event.content,
+        tagsJson,
+        event.created_at,
+        event.sig,
+        receivedAt
+      );
+    }
+  }
+  /**
+   * Store a parameterized replaceable event (kinds 30000-39999).
+   * Only keeps the latest event per pubkey+kind+d-tag.
+   */
+  storeParameterizedReplaceableEvent(event, tagsJson, receivedAt) {
+    const dTagValue = getDTagValue(event.tags);
+    let existing;
+    if (dTagValue === "") {
+      const candidates = this.db.prepare(
+        "SELECT id, created_at, tags FROM events WHERE pubkey = ? AND kind = ?"
+      ).all(event.pubkey, event.kind);
+      for (const candidate of candidates) {
+        const candidateTags = JSON.parse(candidate.tags);
+        const candidateDTagValue = getDTagValue(candidateTags);
+        if (candidateDTagValue === "") {
+          existing = { id: candidate.id, created_at: candidate.created_at };
+          break;
+        }
+      }
+    } else {
+      const dTagPattern = `%["d","${dTagValue}"%`;
+      existing = this.getByPubkeyKindDTagStmt.get(
+        event.pubkey,
+        event.kind,
+        dTagPattern
+      );
+    }
+    if (existing) {
+      if (event.created_at > existing.created_at || event.created_at === existing.created_at && event.id < existing.id) {
+        const transaction = this.db.transaction(() => {
+          this.db.prepare("DELETE FROM events WHERE id = ?").run(existing.id);
+          this.insertStmt.run(
+            event.id,
+            event.pubkey,
+            event.kind,
+            event.content,
+            tagsJson,
+            event.created_at,
+            event.sig,
+            receivedAt
+          );
+        });
+        transaction();
+      }
+    } else {
+      this.insertStmt.run(
+        event.id,
+        event.pubkey,
+        event.kind,
+        event.content,
+        tagsJson,
+        event.created_at,
+        event.sig,
+        receivedAt
+      );
+    }
+  }
+  /**
+   * Retrieve an event by its ID.
+   */
+  get(id) {
+    try {
+      const row = this.getStmt.get(id);
+      if (!row) {
+        return void 0;
+      }
+      return {
+        id: row.id,
+        pubkey: row.pubkey,
+        kind: row.kind,
+        content: row.content,
+        tags: JSON.parse(row.tags),
+        created_at: row.created_at,
+        sig: row.sig
+      };
+    } catch (error) {
+      throw new RelayError(
+        `Failed to get event: ${error instanceof Error ? error.message : String(error)}`,
+        "STORAGE_ERROR"
+      );
+    }
+  }
+  /**
+   * Query events matching any of the provided filters.
+   */
+  query(filters) {
+    try {
+      const { sql, params } = this.buildQuerySql(filters);
+      const stmt = this.db.prepare(sql);
+      const rows = stmt.all(...params);
+      return rows.map((row) => ({
+        id: row.id,
+        pubkey: row.pubkey,
+        kind: row.kind,
+        content: row.content,
+        tags: JSON.parse(row.tags),
+        created_at: row.created_at,
+        sig: row.sig
+      }));
+    } catch (error) {
+      throw new RelayError(
+        `Failed to query events: ${error instanceof Error ? error.message : String(error)}`,
+        "STORAGE_ERROR"
+      );
+    }
+  }
+  /**
+   * Build SQL query from filters.
+   */
+  buildQuerySql(filters) {
+    if (filters.length === 0) {
+      return {
+        sql: "SELECT * FROM events ORDER BY created_at DESC",
+        params: []
+      };
+    }
+    const conditions = [];
+    const params = [];
+    for (const filter of filters) {
+      const filterConditions = [];
+      if (filter.ids?.length) {
+        const idConditions = filter.ids.map(() => "id LIKE ?");
+        filterConditions.push(`(${idConditions.join(" OR ")})`);
+        params.push(...filter.ids.map((id) => `${id}%`));
+      }
+      if (filter.authors?.length) {
+        const authorConditions = filter.authors.map(() => "pubkey LIKE ?");
+        filterConditions.push(`(${authorConditions.join(" OR ")})`);
+        params.push(...filter.authors.map((a) => `${a}%`));
+      }
+      if (filter.kinds?.length) {
+        filterConditions.push(
+          `kind IN (${filter.kinds.map(() => "?").join(", ")})`
+        );
+        params.push(...filter.kinds);
+      }
+      if (filter.since !== void 0) {
+        filterConditions.push("created_at >= ?");
+        params.push(filter.since);
+      }
+      if (filter.until !== void 0) {
+        filterConditions.push("created_at <= ?");
+        params.push(filter.until);
+      }
+      for (const [key, values] of Object.entries(filter)) {
+        if (key.startsWith("#") && Array.isArray(values) && values.length > 0) {
+          const tagName = key.slice(1);
+          const tagConditions = values.map(() => `tags LIKE ?`);
+          filterConditions.push(`(${tagConditions.join(" OR ")})`);
+          params.push(...values.map((v) => `%["${tagName}","${v}"%`));
+        }
+      }
+      if (filterConditions.length > 0) {
+        conditions.push(`(${filterConditions.join(" AND ")})`);
+      }
+    }
+    let sql = "SELECT * FROM events";
+    if (conditions.length > 0) {
+      sql += ` WHERE ${conditions.join(" OR ")}`;
+    }
+    sql += " ORDER BY created_at DESC";
+    const limitFilter = filters.find((f) => f.limit !== void 0);
+    if (limitFilter?.limit !== void 0) {
+      sql += " LIMIT ?";
+      params.push(limitFilter.limit);
+    }
+    return { sql, params };
+  }
+  /**
+   * Close the database connection.
+   */
+  close() {
+    this.db.close();
+  }
+};
+
+// src/toon/codec.ts
+import { encode, decode } from "@toon-format/toon";
+var ToonEncodeError = class extends Error {
+  code = "TOON_ENCODE_ERROR";
+  constructor(message, cause) {
+    super(message, { cause });
+    this.name = "ToonEncodeError";
+  }
+};
+var ToonDecodeError = class extends Error {
+  code = "TOON_DECODE_ERROR";
+  constructor(message, cause) {
+    super(message, { cause });
+    this.name = "ToonDecodeError";
+  }
+};
+function encodeEventToToon(event) {
+  return new TextEncoder().encode(encodeEventToToonString(event));
+}
+function encodeEventToToonString(event) {
+  try {
+    return encode(event);
+  } catch (error) {
+    throw new ToonEncodeError(
+      `Failed to encode event to TOON: ${error instanceof Error ? error.message : String(error)}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+function isValidHex(value, length) {
+  return typeof value === "string" && value.length === length && /^[0-9a-f]+$/i.test(value);
+}
+function validateNostrEvent(obj) {
+  if (typeof obj !== "object" || obj === null) {
+    throw new ToonDecodeError("Decoded value is not an object");
+  }
+  const event = obj;
+  if (!isValidHex(event["id"], 64)) {
+    throw new ToonDecodeError(
+      "Invalid event id: must be a 64-character hex string"
+    );
+  }
+  if (!isValidHex(event["pubkey"], 64)) {
+    throw new ToonDecodeError(
+      "Invalid event pubkey: must be a 64-character hex string"
+    );
+  }
+  if (typeof event["kind"] !== "number" || !Number.isInteger(event["kind"])) {
+    throw new ToonDecodeError("Invalid event kind: must be an integer");
+  }
+  if (typeof event["content"] !== "string") {
+    throw new ToonDecodeError("Invalid event content: must be a string");
+  }
+  const tags = event["tags"];
+  if (!Array.isArray(tags)) {
+    throw new ToonDecodeError("Invalid event tags: must be an array");
+  }
+  for (let i = 0; i < tags.length; i++) {
+    const tag = tags[i];
+    if (!Array.isArray(tag)) {
+      throw new ToonDecodeError(`Invalid event tags[${i}]: must be an array`);
+    }
+    for (let j = 0; j < tag.length; j++) {
+      if (typeof tag[j] !== "string") {
+        throw new ToonDecodeError(
+          `Invalid event tags[${i}][${j}]: must be a string`
+        );
+      }
+    }
+  }
+  if (typeof event["created_at"] !== "number" || !Number.isInteger(event["created_at"])) {
+    throw new ToonDecodeError("Invalid event created_at: must be an integer");
+  }
+  if (!isValidHex(event["sig"], 128)) {
+    throw new ToonDecodeError(
+      "Invalid event sig: must be a 128-character hex string"
+    );
+  }
+}
+function decodeEventFromToon(data) {
+  let decoded;
+  try {
+    decoded = decode(new TextDecoder().decode(data));
+  } catch (error) {
+    throw new ToonDecodeError(
+      `Failed to decode TOON data: ${error instanceof Error ? error.message : String(error)}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+  validateNostrEvent(decoded);
+  return decoded;
+}
+
+// src/websocket/ConnectionHandler.ts
+var ConnectionHandler = class {
+  constructor(ws, eventStore, config = {}) {
+    this.ws = ws;
+    this.eventStore = eventStore;
+    this.config = { ...DEFAULT_RELAY_CONFIG, ...config };
+  }
+  subscriptions = /* @__PURE__ */ new Map();
+  config;
+  /**
+   * Handle an incoming message from the WebSocket.
+   */
+  handleMessage(data) {
+    console.log(`[ConnectionHandler] Received message:`, data.slice(0, 150));
+    let message;
+    try {
+      const parsed = JSON.parse(data);
+      if (!Array.isArray(parsed)) {
+        this.sendNotice("error: invalid message format, expected JSON array");
+        return;
+      }
+      message = parsed;
+    } catch {
+      this.sendNotice("error: invalid JSON");
+      return;
+    }
+    const messageType = message[0];
+    console.log(`[ConnectionHandler] Message type: ${messageType}`);
+    if (messageType === "REQ") {
+      const subscriptionId = message[1];
+      const filters = message.slice(2);
+      this.handleReq(subscriptionId, filters);
+    } else if (messageType === "EVENT") {
+      const event = message[1];
+      this.handleEvent(event);
+    } else if (messageType === "CLOSE") {
+      const subscriptionId = message[1];
+      this.handleClose(subscriptionId);
+    } else {
+      this.sendNotice(`error: unknown message type: ${messageType}`);
+    }
+  }
+  /**
+   * Handle a REQ message to create/update a subscription.
+   */
+  handleReq(subscriptionId, filters) {
+    if (typeof subscriptionId !== "string" || subscriptionId.length === 0) {
+      this.sendNotice("error: invalid subscription id");
+      return;
+    }
+    if (!this.subscriptions.has(subscriptionId)) {
+      if (this.subscriptions.size >= this.config.maxSubscriptionsPerConnection) {
+        this.sendNotice("error: too many subscriptions");
+        return;
+      }
+    }
+    if (filters.length > this.config.maxFiltersPerSubscription) {
+      this.sendNotice("error: too many filters");
+      return;
+    }
+    this.subscriptions.set(subscriptionId, {
+      id: subscriptionId,
+      filters
+    });
+    console.log(
+      `[ConnectionHandler] REQ: ${subscriptionId}, filters:`,
+      JSON.stringify(filters).slice(0, 100)
+    );
+    const events = this.eventStore.query(filters);
+    console.log(
+      `[ConnectionHandler] Query returned ${events.length} events for ${subscriptionId}`
+    );
+    for (const event of events) {
+      console.log(
+        `[ConnectionHandler] Sending event ${event.id.slice(0, 16)}... to ${subscriptionId}`
+      );
+      this.sendEvent(subscriptionId, event);
+    }
+    console.log(`[ConnectionHandler] Sending EOSE for ${subscriptionId}`);
+    this.sendEose(subscriptionId);
+  }
+  /**
+   * Handle an EVENT message from a WebSocket client.
+   *
+   * Rejects all external writes — the relay is ILP-gated (pay to write).
+   * Events are only stored through the ILP packet handler which calls
+   * eventStore.store() directly and then broadcastEvent() to notify subscribers.
+   */
+  handleEvent(event) {
+    this.sendOk(event.id, false, "restricted: writes require ILP payment");
+  }
+  /**
+   * Handle a CLOSE message to terminate a subscription.
+   */
+  handleClose(subscriptionId) {
+    this.subscriptions.delete(subscriptionId);
+  }
+  /**
+   * Push a new event to all matching subscriptions on this connection.
+   * Used when events are stored outside the WebSocket flow (e.g., via ILP).
+   */
+  notifyNewEvent(event) {
+    for (const sub of this.subscriptions.values()) {
+      const matches = sub.filters.some((f) => matchFilter(event, f));
+      if (matches) {
+        this.sendEvent(sub.id, event);
+      }
+    }
+  }
+  /**
+   * Clean up all subscriptions for this connection.
+   */
+  cleanup() {
+    this.subscriptions.clear();
+  }
+  /**
+   * Get the number of active subscriptions.
+   */
+  getSubscriptionCount() {
+    return this.subscriptions.size;
+  }
+  sendEvent(subscriptionId, event) {
+    this.send(["EVENT", subscriptionId, encodeEventToToonString(event)]);
+  }
+  sendEose(subscriptionId) {
+    this.send(["EOSE", subscriptionId]);
+  }
+  sendOk(eventId, success, message) {
+    this.send(["OK", eventId, success, message]);
+  }
+  sendNotice(message) {
+    this.send(["NOTICE", message]);
+  }
+  send(message) {
+    if (this.ws.readyState === 1) {
+      this.ws.send(JSON.stringify(message));
+    }
+  }
+};
+
+// src/websocket/NostrRelayServer.ts
+import { WebSocketServer } from "ws";
+var NostrRelayServer = class {
+  constructor(config = {}, eventStore) {
+    this.eventStore = eventStore;
+    this.config = { ...DEFAULT_RELAY_CONFIG, ...config };
+  }
+  wss = null;
+  handlers = /* @__PURE__ */ new Map();
+  config;
+  /**
+   * Start the WebSocket server.
+   */
+  async start() {
+    return new Promise((resolve, reject) => {
+      try {
+        this.wss = new WebSocketServer({
+          port: this.config.port,
+          host: this.config.host
+        });
+        this.wss.on("connection", (ws) => {
+          this.handleConnection(ws);
+        });
+        this.wss.on("error", (error) => {
+          console.error("[NostrRelayServer] Server error:", error.message);
+        });
+        this.wss.on("listening", () => {
+          const address = this.wss?.address();
+          if (address && typeof address === "object") {
+            console.log(`[NostrRelayServer] Listening on port ${address.port}`);
+          }
+          resolve();
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Stop the WebSocket server and close all connections.
+   */
+  async stop() {
+    return new Promise((resolve) => {
+      if (!this.wss) {
+        resolve();
+        return;
+      }
+      for (const [ws, handler] of this.handlers) {
+        handler.cleanup();
+        ws.close();
+      }
+      this.handlers.clear();
+      this.wss.close(() => {
+        this.wss = null;
+        resolve();
+      });
+    });
+  }
+  /**
+   * Get the port the server is listening on.
+   * Returns 0 if the server is not started.
+   */
+  getPort() {
+    if (!this.wss) return 0;
+    const address = this.wss.address();
+    if (address && typeof address === "object") {
+      return address.port;
+    }
+    return 0;
+  }
+  /**
+   * Get the number of connected clients.
+   */
+  getClientCount() {
+    return this.handlers.size;
+  }
+  /**
+   * Broadcast an event to all connected clients with matching subscriptions.
+   * Call this after storing an event outside the WebSocket flow (e.g., via ILP)
+   * so that discovery subscribers are notified.
+   */
+  broadcastEvent(event) {
+    for (const handler of this.handlers.values()) {
+      handler.notifyNewEvent(event);
+    }
+  }
+  handleConnection(ws) {
+    if (this.handlers.size >= this.config.maxConnections) {
+      ws.close(1013, "max connections reached");
+      return;
+    }
+    console.log("[NostrRelayServer] Client connected");
+    const handler = new ConnectionHandler(ws, this.eventStore, this.config);
+    this.handlers.set(ws, handler);
+    ws.on("message", (data) => {
+      const message = typeof data === "string" ? data : data.toString();
+      handler.handleMessage(message);
+    });
+    ws.on("close", () => {
+      console.log("[NostrRelayServer] Client disconnected");
+      handler.cleanup();
+      this.handlers.delete(ws);
+    });
+    ws.on("error", (error) => {
+      console.error("[NostrRelayServer] Client error:", error.message);
+      handler.cleanup();
+      this.handlers.delete(ws);
+    });
+  }
+};
+
+// src/subscriber/RelaySubscriber.ts
+import { SimplePool } from "nostr-tools/pool";
+import { verifyEvent } from "nostr-tools/pure";
+var RelaySubscriber = class {
+  config;
+  eventStore;
+  pool;
+  started = false;
+  /**
+   * @param config - Subscriber configuration
+   * @param eventStore - Storage backend to write events into
+   * @param pool - Optional SimplePool instance (creates new one if not provided)
+   */
+  constructor(config, eventStore, pool) {
+    this.config = config;
+    this.eventStore = eventStore;
+    this.pool = pool ?? new SimplePool();
+  }
+  /**
+   * Start subscribing to the configured upstream relays.
+   *
+   * @returns Handle with unsubscribe() to stop the subscription
+   * @throws Error if already started
+   */
+  start() {
+    if (this.started) {
+      throw new Error("RelaySubscriber already started");
+    }
+    this.started = true;
+    const shouldVerify = this.config.verifySignatures !== false;
+    let isUnsubscribed = false;
+    const subCloser = this.pool.subscribeMany(
+      this.config.relayUrls,
+      this.config.filter,
+      {
+        onevent: (event) => {
+          if (isUnsubscribed) return;
+          if (shouldVerify && !verifyEvent(event)) {
+            return;
+          }
+          try {
+            this.eventStore.store(event);
+          } catch (error) {
+            console.warn(
+              "[RelaySubscriber] Failed to store event:",
+              error instanceof Error ? error.message : "Unknown error"
+            );
+          }
+        }
+      }
+    );
+    return {
+      unsubscribe: () => {
+        if (!isUnsubscribed) {
+          isUnsubscribed = true;
+          subCloser.close();
+          this.started = false;
+        }
+      }
+    };
+  }
+};
+
+// src/launcher/handlers/write-handler.ts
+import { verifyEvent as verifyEvent2 } from "nostr-tools/pure";
+function createWriteHandler(config) {
+  return {
+    async handleWrite(c) {
+      let body;
+      try {
+        body = await c.req.json();
+      } catch {
+        return c.json({ error: "Invalid request body" }, 400);
+      }
+      if (!body.event) {
+        return c.json({ error: "Missing required field: event" }, 400);
+      }
+      const event = body.event;
+      const payer = c.req.header("X-TOON-Payer");
+      const amount = c.req.header("X-TOON-Amount");
+      const chain = c.req.header("X-TOON-Chain");
+      console.log(
+        `[write] event=${event.id} payer=${payer ?? "-"} amount=${amount ?? "-"} chain=${chain ?? "-"}`
+      );
+      if (!config.devMode && !verifyEvent2(event)) {
+        return c.json({ error: "Invalid event signature" }, 422);
+      }
+      config.eventStore.store(event);
+      config.onStored?.(event);
+      return c.json(
+        {
+          eventId: event.id,
+          storedAt: Math.floor(Date.now() / 1e3),
+          payer,
+          amount,
+          chain
+        },
+        200
+      );
+    }
+  };
+}
+
+// src/launcher/health.ts
+function createHealthResponse(config) {
+  return {
+    status: "healthy",
+    pubkey: config.pubkey,
+    capabilities: ["relay"],
+    version: VERSION,
+    timestamp: Date.now()
+  };
+}
+
+// src/launcher/relay.ts
+import { mkdirSync } from "fs";
+import { join } from "path";
+import { serve } from "@hono/node-server";
+import { Hono } from "hono";
+import { getPublicKey } from "nostr-tools/pure";
+import { privateKeyFromSeedWords } from "nostr-tools/nip06";
+function deriveIdentity(config) {
+  const hasMnemonic = config.mnemonic !== void 0;
+  const hasSecretKey = config.secretKey !== void 0;
+  if (hasMnemonic && hasSecretKey) {
+    throw new Error(
+      "RelayConfig: provide either mnemonic or secretKey, not both"
+    );
+  }
+  if (!hasMnemonic && !hasSecretKey) {
+    throw new Error("RelayConfig: one of mnemonic or secretKey is required");
+  }
+  const secretKey = hasMnemonic ? privateKeyFromSeedWords(config.mnemonic) : config.secretKey;
+  return { secretKey, pubkey: getPublicKey(secretKey) };
+}
+function createSubscription(relayUrl, filter, eventStore, activeSubscriptions) {
+  if (!relayUrl.startsWith("ws://") && !relayUrl.startsWith("wss://")) {
+    throw new Error(
+      "Invalid relay URL -- must use WebSocket scheme (ws or wss)"
+    );
+  }
+  const subscriber = new RelaySubscriber(
+    { relayUrls: [relayUrl], filter },
+    eventStore
+  );
+  const handle = subscriber.start();
+  let active = true;
+  const subscription = {
+    close() {
+      if (!active) return;
+      active = false;
+      handle.unsubscribe();
+      activeSubscriptions.delete(subscription);
+    },
+    relayUrl,
+    isActive() {
+      return active;
+    }
+  };
+  activeSubscriptions.add(subscription);
+  return subscription;
+}
+async function startRelay(config) {
+  const identity = deriveIdentity(config);
+  const relayPort = config.relayPort ?? 7100;
+  const blsPort = config.blsPort ?? 3100;
+  const host = config.host ?? "0.0.0.0";
+  const dataDir = config.dataDir ?? "./data";
+  const devMode = config.devMode ?? false;
+  const resolvedConfig = {
+    relayPort,
+    blsPort,
+    host,
+    dataDir,
+    devMode
+  };
+  let eventStore;
+  if (config.eventStore) {
+    eventStore = config.eventStore;
+  } else {
+    mkdirSync(dataDir, { recursive: true });
+    eventStore = new SqliteEventStore(join(dataDir, "events.db"));
+  }
+  const wsRelay = new NostrRelayServer({ port: relayPort, host }, eventStore);
+  const app = new Hono();
+  app.get(
+    "/health",
+    (c) => c.json(createHealthResponse({ pubkey: identity.pubkey }))
+  );
+  const writeHandler = createWriteHandler({
+    eventStore,
+    devMode,
+    onStored: (event) => {
+      try {
+        wsRelay.broadcastEvent(event);
+      } catch {
+      }
+    }
+  });
+  app.post("/write", (c) => writeHandler.handleWrite(c));
+  const blsServer = await new Promise((resolve) => {
+    const server = serve(
+      { fetch: app.fetch, port: blsPort },
+      () => resolve(server)
+    );
+  });
+  await wsRelay.start();
+  let running = true;
+  const activeSubscriptions = /* @__PURE__ */ new Set();
+  const instance = {
+    isRunning() {
+      return running;
+    },
+    subscribe(subscribeRelayUrl, filter) {
+      if (!running) {
+        throw new Error("Cannot subscribe: relay is not running");
+      }
+      return createSubscription(
+        subscribeRelayUrl,
+        filter,
+        eventStore,
+        activeSubscriptions
+      );
+    },
+    async stop() {
+      if (!running) return;
+      running = false;
+      for (const sub of activeSubscriptions) {
+        sub.close();
+      }
+      activeSubscriptions.clear();
+      await wsRelay.stop();
+      blsServer.close();
+      if (!config.eventStore) {
+        eventStore.close?.();
+      }
+    },
+    pubkey: identity.pubkey,
+    config: resolvedConfig
+  };
+  return instance;
+}
+
+export {
+  VERSION,
+  DEFAULT_RELAY_CONFIG,
+  matchFilter,
+  InMemoryEventStore,
+  RelayError,
+  SqliteEventStore,
+  ToonEncodeError,
+  ToonDecodeError,
+  encodeEventToToon,
+  decodeEventFromToon,
+  ConnectionHandler,
+  NostrRelayServer,
+  RelaySubscriber,
+  createWriteHandler,
+  createHealthResponse,
+  startRelay
+};
+//# sourceMappingURL=chunk-745ADETR.js.map