@toon-protocol/relay 2.0.1 → 2.1.0

package/dist/chunk-FXQSNOCG.js

@@ -1,939 +0,0 @@
-// 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/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;
-  }
-  /**
-   * Emit an outbound NIP-01 EVENT frame.
-   *
-   * The event MUST go on the wire as canonical NIP-01 JSON —
-   * `["EVENT", <subId>, {id, pubkey, created_at, kind, tags, content, sig}]`
-   * with the event as a plain JSON object — so any standard nostr client can
-   * parse it and verify `id`/`sig` from the wire bytes (#46). Never re-encode
-   * the event (TOON text, double-JSON-stringify, etc.) at this boundary.
-   */
-  sendEvent(subscriptionId, event) {
-    this.send(["EVENT", subscriptionId, 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,
-  ConnectionHandler,
-  NostrRelayServer,
-  RelaySubscriber,
-  createWriteHandler,
-  createHealthResponse,
-  startRelay
-};
-//# sourceMappingURL=chunk-FXQSNOCG.js.map