@toon-protocol/relay 2.0.1 → 2.1.0

package/dist/chunk-IZOSPMWV.js

@@ -0,0 +1,1799 @@
+import {
+  verifyEventId,
+  verifyEventSignature,
+  verifyImplementation
+} from "./chunk-SMT6G3XD.js";
+
+// src/version.ts
+var VERSION = "2.1.0";
+
+// src/types.ts
+var DEFAULT_RELAY_CONFIG = {
+  port: 7100,
+  host: "0.0.0.0",
+  maxConnections: 4096,
+  maxSubscriptionsPerConnection: 20,
+  maxFiltersPerSubscription: 10,
+  databasePath: ":memory:",
+  enforceExpiration: true
+};
+
+// 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/nips/expiration.ts
+var EXPIRATION_TAG = "expiration";
+function getExpiration(event) {
+  for (const tag of event.tags) {
+    if (tag[0] !== EXPIRATION_TAG) continue;
+    const raw = tag[1];
+    if (raw === void 0) continue;
+    if (!/^\d+$/.test(raw)) continue;
+    const seconds = Number(raw);
+    if (!Number.isSafeInteger(seconds)) continue;
+    return seconds;
+  }
+  return void 0;
+}
+function isExpired(event, nowSeconds2) {
+  const expiration = getExpiration(event);
+  return expiration !== void 0 && expiration <= nowSeconds2;
+}
+
+// src/nips/deletion.ts
+var DELETION_KIND = 5;
+function isDeletionKind(kind) {
+  return kind === DELETION_KIND;
+}
+var HEX_64 = /^[0-9a-f]{64}$/;
+function parseAddressCoordinate(value) {
+  const firstSep = value.indexOf(":");
+  if (firstSep < 0) return void 0;
+  const secondSep = value.indexOf(":", firstSep + 1);
+  if (secondSep < 0) return void 0;
+  const kindPart = value.slice(0, firstSep);
+  const pubkey = value.slice(firstSep + 1, secondSep);
+  const identifier = value.slice(secondSep + 1);
+  if (!/^\d+$/.test(kindPart)) return void 0;
+  const kind = Number(kindPart);
+  if (!Number.isSafeInteger(kind)) return void 0;
+  if (!HEX_64.test(pubkey)) return void 0;
+  return { kind, pubkey, identifier };
+}
+function parseDeletionTargets(event) {
+  const ids = /* @__PURE__ */ new Set();
+  const addresses = /* @__PURE__ */ new Map();
+  for (const tag of event.tags) {
+    const value = tag[1];
+    if (value === void 0) continue;
+    if (tag[0] === "e") {
+      if (HEX_64.test(value)) ids.add(value);
+    } else if (tag[0] === "a") {
+      const coordinate = parseAddressCoordinate(value);
+      if (coordinate) addresses.set(value, coordinate);
+    }
+  }
+  return { ids: [...ids], addresses: [...addresses.values()] };
+}
+function isDeletableBy(target, deletion) {
+  return target.pubkey === deletion.pubkey && target.created_at <= deletion.created_at;
+}
+
+// src/storage/InMemoryEventStore.ts
+var InMemoryEventStore = class _InMemoryEventStore {
+  events = /* @__PURE__ */ new Map();
+  /** NIP-09 id tombstones: event id -> the pubkey that requested deletion. */
+  deletedIds = /* @__PURE__ */ new Map();
+  /** NIP-09 address tombstones: `<kind>:<pubkey>:<d>` -> deletion created_at. */
+  deletedAddresses = /* @__PURE__ */ new Map();
+  enforceExpiration;
+  blockedEventIds;
+  constructor(options = {}) {
+    this.enforceExpiration = options.enforceExpiration ?? true;
+    this.blockedEventIds = new Set(options.blockedEventIds ?? []);
+  }
+  store(event) {
+    if (this.blockedEventIds.has(event.id)) return;
+    if (this.isRetracted(event)) return;
+    if (isDeletionKind(event.kind)) {
+      this.applyDeletion(event);
+    }
+    this.events.set(event.id, event);
+  }
+  get(id) {
+    const event = this.events.get(id);
+    if (!event) return void 0;
+    if (this.enforceExpiration && isExpired(event, nowSeconds())) {
+      return void 0;
+    }
+    return event;
+  }
+  query(filters) {
+    const now = nowSeconds();
+    const allEvents = Array.from(this.events.values()).filter(
+      (event) => !this.enforceExpiration || !isExpired(event, now)
+    );
+    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;
+  }
+  /**
+   * Drop events expired for longer than `graceSeconds` (NIP-40).
+   *
+   * @param now - Current unix time in seconds.
+   * @param graceSeconds - Extra time an expired event is kept.
+   * @returns The number of events removed.
+   */
+  reapExpired(now, graceSeconds = 0) {
+    let removed = 0;
+    for (const [id, event] of this.events) {
+      if (isExpired(event, now - graceSeconds)) {
+        this.events.delete(id);
+        removed++;
+      }
+    }
+    return removed;
+  }
+  /** The NIP-01 addressable coordinate of an event, `<kind>:<pubkey>:<d>`. */
+  static coordinateOf(event) {
+    const identifier = event.tags.find((tag) => tag[0] === "d")?.[1] ?? "";
+    return `${event.kind}:${event.pubkey}:${identifier}`;
+  }
+  /** Whether a NIP-09 request already retracted this event (same author). */
+  isRetracted(event) {
+    if (this.deletedIds.get(event.id) === event.pubkey) return true;
+    const deletedAt = this.deletedAddresses.get(
+      _InMemoryEventStore.coordinateOf(event)
+    );
+    return deletedAt !== void 0 && event.created_at <= deletedAt;
+  }
+  /** Apply a kind:5 request to the author's OWN events only. */
+  applyDeletion(deletion) {
+    const targets = parseDeletionTargets(deletion);
+    for (const id of targets.ids) {
+      this.deletedIds.set(id, deletion.pubkey);
+      const target = this.events.get(id);
+      if (target && isDeletableBy(target, deletion)) {
+        this.events.delete(id);
+      }
+    }
+    for (const address of targets.addresses) {
+      if (address.pubkey !== deletion.pubkey) continue;
+      const coordinate = `${address.kind}:${address.pubkey}:${address.identifier}`;
+      this.deletedAddresses.set(
+        coordinate,
+        Math.max(
+          this.deletedAddresses.get(coordinate) ?? deletion.created_at,
+          deletion.created_at
+        )
+      );
+      for (const [id, target] of this.events) {
+        if (_InMemoryEventStore.coordinateOf(target) === coordinate && isDeletableBy(target, deletion)) {
+          this.events.delete(id);
+        }
+      }
+    }
+  }
+  /**
+   * Close the storage backend (no-op for in-memory store).
+   */
+  close() {
+  }
+};
+function nowSeconds() {
+  return Math.floor(Date.now() / 1e3);
+}
+
+// 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,
+  expires_at INTEGER
+)
+`;
+var DELETED_EVENTS_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS deleted_events (
+  event_id TEXT PRIMARY KEY,
+  pubkey TEXT NOT NULL,
+  deleted_at INTEGER NOT NULL
+)
+`;
+var DELETED_ADDRESSES_SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS deleted_addresses (
+  coordinate TEXT PRIMARY KEY,
+  deleted_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)",
+  // Partial index: only the small minority of events that expire at all.
+  "CREATE INDEX IF NOT EXISTS idx_events_expires_at ON events(expires_at) WHERE expires_at IS NOT NULL"
+];
+function migrateExpiresAtColumn(db) {
+  const columns = db.prepare("PRAGMA table_info(events)").all();
+  if (columns.some((column) => column.name === "expires_at")) return;
+  db.exec("ALTER TABLE events ADD COLUMN expires_at INTEGER");
+  const candidates = db.prepare(`SELECT id, tags FROM events WHERE tags LIKE '%"expiration"%'`).all();
+  const update = db.prepare("UPDATE events SET expires_at = ? WHERE id = ?");
+  const backfill = db.transaction(() => {
+    for (const row of candidates) {
+      let tags;
+      try {
+        tags = JSON.parse(row.tags);
+      } catch {
+        continue;
+      }
+      const expiresAt = getExpiration({ tags });
+      if (expiresAt !== void 0) update.run(expiresAt, row.id);
+    }
+  });
+  backfill();
+}
+function initializeSchema(db) {
+  db.exec(SCHEMA_SQL);
+  db.exec(DELETED_EVENTS_SCHEMA_SQL);
+  db.exec(DELETED_ADDRESSES_SCHEMA_SQL);
+  migrateExpiresAtColumn(db);
+  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 _SqliteEventStore {
+  db;
+  insertStmt;
+  insertOrIgnoreStmt;
+  getStmt;
+  deleteByPubkeyKindStmt;
+  deleteByPubkeyKindDTagStmt;
+  getByPubkeyKindStmt;
+  getByPubkeyKindDTagStmt;
+  tombstoneIdStmt;
+  getTombstoneStmt;
+  tombstoneAddressStmt;
+  getAddressTombstoneStmt;
+  deleteExpiredStmt;
+  enforceExpiration;
+  blockedEventIds;
+  /**
+   * Create a new SqliteEventStore.
+   * @param dbPath - Path to the database file. Use ':memory:' for in-memory database.
+   * @param options - Expiry-enforcement and operator-blocklist settings.
+   */
+  constructor(dbPath = ":memory:", options = {}) {
+    this.enforceExpiration = options.enforceExpiration ?? true;
+    this.blockedEventIds = new Set(options.blockedEventIds ?? []);
+    try {
+      this.db = new Database(dbPath);
+      this.db.pragma("journal_mode = WAL");
+      this.db.pragma("synchronous = NORMAL");
+      initializeSchema(this.db);
+      this.insertStmt = this.db.prepare(`
+        INSERT OR REPLACE INTO events (id, pubkey, kind, content, tags, created_at, sig, received_at, expires_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+      this.insertOrIgnoreStmt = this.db.prepare(`
+        INSERT OR IGNORE INTO events (id, pubkey, kind, content, tags, created_at, sig, received_at, expires_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+      this.getStmt = this.db.prepare("SELECT * FROM events WHERE id = ?");
+      this.tombstoneIdStmt = this.db.prepare(
+        "INSERT OR REPLACE INTO deleted_events (event_id, pubkey, deleted_at) VALUES (?, ?, ?)"
+      );
+      this.getTombstoneStmt = this.db.prepare(
+        "SELECT pubkey FROM deleted_events WHERE event_id = ?"
+      );
+      this.tombstoneAddressStmt = this.db.prepare(
+        `INSERT INTO deleted_addresses (coordinate, deleted_at) VALUES (?, ?)
+         ON CONFLICT(coordinate) DO UPDATE SET deleted_at = MAX(deleted_at, excluded.deleted_at)`
+      );
+      this.getAddressTombstoneStmt = this.db.prepare(
+        "SELECT deleted_at FROM deleted_addresses WHERE coordinate = ?"
+      );
+      this.deleteExpiredStmt = this.db.prepare(
+        "DELETE FROM events WHERE expires_at IS NOT NULL AND expires_at <= ?"
+      );
+      if (this.blockedEventIds.size > 0) {
+        const purge = this.db.prepare("DELETE FROM events WHERE id = ?");
+        const purgeAll = this.db.transaction(() => {
+          for (const id of this.blockedEventIds) purge.run(id);
+        });
+        purgeAll();
+      }
+      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, applies NIP-09 deletion requests, and refuses events the operator
+   * has blocked or that a previous NIP-09 request already retracted.
+   */
+  store(event) {
+    try {
+      if (this.blockedEventIds.has(event.id)) return;
+      if (this.isRetracted(event)) return;
+      const tagsJson = JSON.stringify(event.tags);
+      const receivedAt = Math.floor(Date.now() / 1e3);
+      if (isDeletionKind(event.kind)) {
+        this.applyDeletion(event);
+      }
+      if (isReplaceableKind(event.kind)) {
+        this.storeReplaceableEvent(event, tagsJson, receivedAt);
+      } else if (isParameterizedReplaceableKind(event.kind)) {
+        this.storeParameterizedReplaceableEvent(event, tagsJson, receivedAt);
+      } else {
+        this.runInsert(this.insertOrIgnoreStmt, event, tagsJson, 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.runInsert(this.insertStmt, event, tagsJson, receivedAt);
+        });
+        transaction();
+      }
+    } else {
+      this.runInsert(this.insertStmt, event, tagsJson, 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.runInsert(this.insertStmt, event, tagsJson, receivedAt);
+        });
+        transaction();
+      }
+    } else {
+      this.runInsert(this.insertStmt, event, tagsJson, receivedAt);
+    }
+  }
+  /**
+   * Bind an event to one of the prepared INSERT statements.
+   *
+   * The `expires_at` column is derived here, at the single point every write
+   * funnels through, so no insert path can forget it.
+   */
+  runInsert(stmt, event, tagsJson, receivedAt) {
+    stmt.run(
+      event.id,
+      event.pubkey,
+      event.kind,
+      event.content,
+      tagsJson,
+      event.created_at,
+      event.sig,
+      receivedAt,
+      getExpiration(event) ?? null
+    );
+  }
+  /**
+   * The NIP-01 addressable coordinate of an event, `<kind>:<pubkey>:<d>`.
+   * The `d` value is the empty string for events that carry no `d` tag —
+   * which is every kind:10032 announce on the network today.
+   */
+  static coordinateOf(event) {
+    return `${event.kind}:${event.pubkey}:${getDTagValue(event.tags)}`;
+  }
+  /**
+   * Whether a NIP-09 deletion request already retracted this event, so it
+   * must not be re-admitted.
+   *
+   * The id tombstone only bites when the arriving event's OWN pubkey matches
+   * the pubkey that asked for the deletion; otherwise anyone could pre-block
+   * an id they merely predicted. Address tombstones already carry the
+   * author's pubkey inside the coordinate.
+   */
+  isRetracted(event) {
+    const tombstone = this.getTombstoneStmt.get(event.id);
+    if (tombstone && tombstone.pubkey === event.pubkey) return true;
+    const address = this.getAddressTombstoneStmt.get(
+      _SqliteEventStore.coordinateOf(event)
+    );
+    return address !== void 0 && event.created_at <= address.deleted_at;
+  }
+  /**
+   * Apply a NIP-09 deletion request: remove the author's own targeted events
+   * and record tombstones so a re-publish cannot resurrect them.
+   *
+   * Every statement here is scoped by `pubkey = <the requester>`, which is
+   * what makes a cross-author deletion a no-op rather than a privilege.
+   */
+  applyDeletion(deletion) {
+    const targets = parseDeletionTargets(deletion);
+    if (targets.ids.length === 0 && targets.addresses.length === 0) return;
+    const deleteById = this.db.prepare(
+      "DELETE FROM events WHERE id = ? AND pubkey = ? AND created_at <= ?"
+    );
+    const apply = this.db.transaction(() => {
+      for (const id of targets.ids) {
+        this.tombstoneIdStmt.run(id, deletion.pubkey, deletion.created_at);
+        deleteById.run(id, deletion.pubkey, deletion.created_at);
+      }
+      for (const address of targets.addresses) {
+        if (address.pubkey !== deletion.pubkey) continue;
+        const coordinate = `${address.kind}:${address.pubkey}:${address.identifier}`;
+        this.tombstoneAddressStmt.run(coordinate, deletion.created_at);
+        for (const row of this.findByCoordinate(address.kind, address.pubkey)) {
+          if (getDTagValue(row.tags) === address.identifier && isDeletableBy(row, deletion)) {
+            this.db.prepare("DELETE FROM events WHERE id = ?").run(row.id);
+          }
+        }
+      }
+    });
+    apply();
+  }
+  /**
+   * Rows for a (kind, pubkey) pair with their parsed tags, so the caller can
+   * compare `d` values in code. SQL cannot distinguish `["d",""]` from a
+   * missing `d` tag, and both mean "the empty identifier".
+   */
+  findByCoordinate(kind, pubkey) {
+    const rows = this.db.prepare(
+      "SELECT id, pubkey, created_at, tags FROM events WHERE pubkey = ? AND kind = ?"
+    ).all(pubkey, kind);
+    return rows.map((row) => ({
+      id: row.id,
+      pubkey: row.pubkey,
+      created_at: row.created_at,
+      tags: JSON.parse(row.tags)
+    }));
+  }
+  /**
+   * NIP-40 reaper: permanently delete events whose expiration is further than
+   * `graceSeconds` in the past.
+   *
+   * The grace window is the safety net for enforcement itself. Serve-time
+   * filtering is instantly reversible (flip `enforceExpiration` off and every
+   * still-present event is served again); a DELETE is not. Keeping recently
+   * expired events on disk for a while means an operator who discovers that
+   * enforcement broke discovery can undo it without having lost the data.
+   *
+   * @param nowSeconds - Current unix time in seconds.
+   * @param graceSeconds - Extra time to keep an expired event on disk.
+   * @returns The number of rows deleted.
+   */
+  reapExpired(nowSeconds2, graceSeconds = 0) {
+    try {
+      const result = this.deleteExpiredStmt.run(nowSeconds2 - graceSeconds);
+      return result.changes;
+    } catch (error) {
+      throw new RelayError(
+        `Failed to reap expired events: ${error instanceof Error ? error.message : String(error)}`,
+        "STORAGE_ERROR"
+      );
+    }
+  }
+  /**
+   * Retrieve an event by its ID.
+   *
+   * Returns undefined for an event that is past its NIP-40 expiration while
+   * enforcement is on, even though the row may still be on disk inside the
+   * reaper's grace window.
+   */
+  get(id) {
+    try {
+      const row = this.getStmt.get(id);
+      if (!row) {
+        return void 0;
+      }
+      if (this.enforceExpiration && row.expires_at !== null && row.expires_at <= Math.floor(Date.now() / 1e3)) {
+        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) {
+    const params = [];
+    let liveClause = "";
+    if (this.enforceExpiration) {
+      liveClause = "(expires_at IS NULL OR expires_at > ?)";
+      params.push(Math.floor(Date.now() / 1e3));
+    }
+    if (filters.length === 0) {
+      return {
+        sql: `SELECT * FROM events${liveClause ? ` WHERE ${liveClause}` : ""} ORDER BY created_at DESC`,
+        params
+      };
+    }
+    const conditions = [];
+    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 ")})`);
+      }
+    }
+    const whereParts = [];
+    if (liveClause) whereParts.push(liveClause);
+    if (conditions.length > 0) whereParts.push(`(${conditions.join(" OR ")})`);
+    let sql = "SELECT * FROM events";
+    if (whereParts.length > 0) {
+      sql += ` WHERE ${whereParts.join(" AND ")}`;
+    }
+    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/nips/blocklist.ts
+var HEX_642 = /^[0-9a-f]{64}$/;
+function parseBlockedEventIds(raw) {
+  const ids = /* @__PURE__ */ new Set();
+  const invalid = [];
+  for (const entry of (raw ?? "").split(/[\s,]+/)) {
+    if (entry === "") continue;
+    const normalized = entry.toLowerCase();
+    if (HEX_642.test(normalized)) {
+      ids.add(normalized);
+    } else {
+      invalid.push(entry);
+    }
+  }
+  return { ids: [...ids], invalid };
+}
+
+// src/crypto/verify-pool.ts
+import { existsSync } from "fs";
+import { cpus } from "os";
+import { fileURLToPath } from "url";
+import { Worker } from "worker_threads";
+import { performance } from "perf_hooks";
+import { verifiedSymbol } from "nostr-tools/pure";
+function defaultVerifyWorkers() {
+  return Math.max(0, cpus().length - 1);
+}
+function resolveWorkerUrl() {
+  for (const candidate of [
+    new URL("./verify-worker.js", import.meta.url),
+    new URL("../../dist/verify-worker.js", import.meta.url)
+  ]) {
+    try {
+      if (existsSync(fileURLToPath(candidate))) return candidate;
+    } catch {
+    }
+  }
+  return null;
+}
+function createVerifyPool(options = {}) {
+  const requestedSize = options.size ?? defaultVerifyWorkers();
+  const onMeasure = options.onMeasure;
+  const measured = (fn) => {
+    if (!onMeasure) return fn();
+    const start = performance.now();
+    const result = fn();
+    onMeasure(performance.now() - start);
+    return result;
+  };
+  const inlineVerify = (event) => Promise.resolve(measured(() => verifyEventSignature(event)));
+  const workerUrl = requestedSize > 0 ? resolveWorkerUrl() : null;
+  if (requestedSize > 0 && !workerUrl) {
+    console.warn(
+      "[relay] verify pool: compiled worker (dist/verify-worker.js) not found -- falling back to inline verification (build the package to enable workers)"
+    );
+  }
+  const workers = [];
+  let seq = 0;
+  let destroyed = false;
+  const retireWorker = (pw, reason) => {
+    const index = workers.indexOf(pw);
+    if (index === -1) return;
+    workers.splice(index, 1);
+    if (!destroyed) {
+      console.warn(
+        `[relay] verify pool: worker retired (${reason}); ` + (workers.length > 0 ? `${workers.length} worker(s) remain` : "falling back to inline verification")
+      );
+    }
+    for (const { resolve, event } of pw.pending.values()) {
+      resolve(verifyEventSignature(event));
+    }
+    pw.pending.clear();
+  };
+  if (workerUrl) {
+    for (let i = 0; i < requestedSize; i++) {
+      const worker = new Worker(workerUrl);
+      const pw = { worker, pending: /* @__PURE__ */ new Map() };
+      worker.on("message", (reply) => {
+        const entry = pw.pending.get(reply.seq);
+        if (!entry) return;
+        pw.pending.delete(reply.seq);
+        entry.event[verifiedSymbol] = reply.ok;
+        entry.resolve(reply.ok);
+      });
+      worker.on(
+        "error",
+        (error) => retireWorker(pw, `error: ${error.message}`)
+      );
+      worker.on("exit", () => retireWorker(pw, "exit"));
+      workers.push(pw);
+    }
+  }
+  const poolVerify = (event) => {
+    const cached = event[verifiedSymbol];
+    if (typeof cached === "boolean") return Promise.resolve(cached);
+    let target = workers[0];
+    if (!target) return inlineVerify(event);
+    for (const pw of workers) {
+      if (pw.pending.size < target.pending.size) target = pw;
+    }
+    const start = performance.now();
+    return new Promise((resolve) => {
+      const id = ++seq;
+      target.pending.set(id, {
+        event,
+        resolve: (ok) => {
+          onMeasure?.(performance.now() - start);
+          resolve(ok);
+        }
+      });
+      target.worker.postMessage({ seq: id, event });
+    });
+  };
+  return {
+    verify(event) {
+      return workers.length > 0 ? poolVerify(event) : inlineVerify(event);
+    },
+    get size() {
+      return workers.length;
+    },
+    async destroy() {
+      destroyed = true;
+      const toTerminate = [...workers];
+      for (const pw of toTerminate) {
+        retireWorker(pw, "destroy");
+      }
+      await Promise.all(toTerminate.map((pw) => pw.worker.terminate()));
+    }
+  };
+}
+
+// src/websocket/ConnectionHandler.ts
+function serializeEventFrame(subscriptionId, eventJson) {
+  return `["EVENT",${JSON.stringify(subscriptionId)},${eventJson}]`;
+}
+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).
+   *
+   * @param event - The event to fan out (used for filter matching).
+   * @param eventJson - Optional pre-serialized `JSON.stringify(event)`.
+   *   `NostrRelayServer.broadcastEvent` serializes the event ONCE and passes
+   *   it here so a 500-subscriber fan-out costs one serialization, not 500
+   *   (relay#91). When omitted (direct callers), the event is serialized
+   *   on first matching send.
+   */
+  notifyNewEvent(event, eventJson) {
+    if (this.config.enforceExpiration && isExpired(event, Math.floor(Date.now() / 1e3))) {
+      return;
+    }
+    let json = eventJson;
+    for (const sub of this.subscriptions.values()) {
+      const matches = sub.filters.some((f) => matchFilter(event, f));
+      if (matches) {
+        json ??= JSON.stringify(event);
+        this.send(serializeEventFrame(sub.id, json));
+      }
+    }
+  }
+  /**
+   * 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.
+   * serializeEventFrame is byte-identical to the full JSON.stringify
+   * envelope (pinned by tests).
+   */
+  sendEvent(subscriptionId, event) {
+    this.send(serializeEventFrame(subscriptionId, JSON.stringify(event)));
+  }
+  sendEose(subscriptionId) {
+    this.send(["EOSE", subscriptionId]);
+  }
+  sendOk(eventId, success, message) {
+    this.send(["OK", eventId, success, message]);
+  }
+  sendNotice(message) {
+    this.send(["NOTICE", message]);
+  }
+  /** Send a message: pre-serialized frames go out as-is (relay#91). */
+  send(message) {
+    if (this.ws.readyState === 1) {
+      this.ws.send(
+        typeof message === "string" ? message : JSON.stringify(message)
+      );
+    }
+  }
+};
+
+// src/websocket/NostrRelayServer.ts
+import { readFileSync } from "fs";
+import { WebSocketServer } from "ws";
+var FD_HEADROOM = 128;
+function readOpenFilesSoftLimit(read = (p) => readFileSync(p, "utf8")) {
+  try {
+    const line = read("/proc/self/limits").split("\n").find((l) => l.startsWith("Max open files"));
+    const match = line?.match(/Max open files\s+(\S+)/);
+    if (!match?.[1]) return null;
+    if (match[1] === "unlimited") return Infinity;
+    const limit = parseInt(match[1], 10);
+    return Number.isNaN(limit) ? null : limit;
+  } catch {
+    return null;
+  }
+}
+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}`);
+          }
+          const fdLimit = readOpenFilesSoftLimit();
+          if (fdLimit !== null && Number.isFinite(fdLimit) && this.config.maxConnections > fdLimit - FD_HEADROOM) {
+            console.warn(
+              `[NostrRelayServer] maxConnections (${this.config.maxConnections}) exceeds the process fd soft limit (${fdLimit}) minus ${FD_HEADROOM} headroom -- connections will fail with EMFILE before the cap. Raise \`ulimit -n\` or lower maxConnections.`
+            );
+          }
+          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.
+   *
+   * Serialize-once fan-out (relay#91): the event payload is stringified ONE
+   * time here and reused for every matching subscriber -- only the small
+   * per-subscription `["EVENT",<subId>,...]` envelope is spliced per send.
+   * Previously each of N subscribers re-serialized the identical event
+   * (N=500 pinned a core doing 500 identical stringifies per frame).
+   */
+  broadcastEvent(event) {
+    const eventJson = JSON.stringify(event);
+    for (const handler of this.handlers.values()) {
+      handler.notifyNewEvent(event, eventJson);
+    }
+  }
+  handleConnection(ws) {
+    if (this.handlers.size >= this.config.maxConnections) {
+      console.warn(
+        `[NostrRelayServer] connection rejected: maxConnections (${this.config.maxConnections}) reached -- raise TOON_MAX_CONNECTIONS if this box has headroom (relay#90)`
+      );
+      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/metrics.ts
+import { monitorEventLoopDelay } from "perf_hooks";
+var VERIFY_WINDOW = 2048;
+var NS_PER_MS = 1e6;
+function percentileOf(sorted, fraction) {
+  if (sorted.length === 0) return 0;
+  const index = Math.min(
+    sorted.length - 1,
+    Math.ceil(fraction * sorted.length) - 1
+  );
+  return sorted[Math.max(0, index)] ?? 0;
+}
+function round(value) {
+  if (!Number.isFinite(value)) return 0;
+  return Math.round(value * 1e3) / 1e3;
+}
+function createMetricsRegistry(info) {
+  const loopDelay = monitorEventLoopDelay({
+    resolution: 20
+  });
+  loopDelay.enable();
+  let verifyWorkers = info.verifyWorkers;
+  let count = 0;
+  let totalMs = 0;
+  let maxMs = 0;
+  const window = new Array(VERIFY_WINDOW);
+  let windowFill = 0;
+  let windowCursor = 0;
+  return {
+    recordVerify(ms) {
+      count += 1;
+      totalMs += ms;
+      if (ms > maxMs) maxMs = ms;
+      window[windowCursor] = ms;
+      windowCursor = (windowCursor + 1) % VERIFY_WINDOW;
+      if (windowFill < VERIFY_WINDOW) windowFill += 1;
+    },
+    snapshot() {
+      const recent = window.slice(0, windowFill).sort((a, b) => a - b);
+      return {
+        timestamp: Date.now(),
+        eventLoopDelayMs: {
+          mean: round(loopDelay.mean / NS_PER_MS),
+          p50: round(loopDelay.percentile(50) / NS_PER_MS),
+          p99: round(loopDelay.percentile(99) / NS_PER_MS),
+          max: round(loopDelay.max / NS_PER_MS)
+        },
+        verify: {
+          implementation: info.verifyImplementation,
+          workers: verifyWorkers,
+          count,
+          meanMs: round(count > 0 ? totalMs / count : 0),
+          maxMs: round(maxMs),
+          p50Ms: round(percentileOf(recent, 0.5)),
+          p99Ms: round(percentileOf(recent, 0.99))
+        },
+        ephemeralWriteLane: {
+          enabled: true,
+          rateLimit: info.ephemeralRateLimit,
+          maxBodyBytes: info.ephemeralMaxBodyBytes
+        }
+      };
+    },
+    setVerifyWorkers(workers) {
+      verifyWorkers = workers;
+    },
+    stop() {
+      loopDelay.disable();
+    }
+  };
+}
+
+// src/launcher/handlers/payment-attribution.ts
+var EVM_PAYER = /^evm:0x[0-9a-f]{64}$/;
+var SOLANA_PAYER = /^solana:[1-9A-HJ-NP-Za-km-z]{32,44}$/;
+var AMOUNT = /^[0-9]+$/;
+function readPaymentAttribution(c) {
+  const payer = c.req.header("X-TOON-Payer");
+  const amount = c.req.header("X-TOON-Amount");
+  const chain = c.req.header("X-TOON-Chain");
+  if (!payer || !amount || !chain) return void 0;
+  if (chain !== "evm" && chain !== "solana") return void 0;
+  if (!AMOUNT.test(amount)) return void 0;
+  const payerMatchesChain = chain === "evm" ? EVM_PAYER.test(payer) : SOLANA_PAYER.test(payer);
+  if (!payerMatchesChain) return void 0;
+  return { payer, amount, chain };
+}
+
+// src/launcher/handlers/write-handler.ts
+function isEphemeralKind(kind) {
+  return kind >= 2e4 && kind < 3e4;
+}
+function createWriteHandler(config) {
+  const logWrites = config.logWrites ?? false;
+  const verifyEphemeral = config.verifyEphemeral ?? false;
+  const verifyEvent2 = config.verifyEvent ?? verifyEventSignature;
+  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 payment = readPaymentAttribution(c);
+      if (logWrites) {
+        const attribution = payment ? ` payer=${payment.payer} amount=${payment.amount} chain=${payment.chain}` : "";
+        console.log(`[write] event=${event.id} handler=write${attribution}`);
+      }
+      if (!config.devMode) {
+        if (isEphemeralKind(event.kind) && !verifyEphemeral) {
+          if (!verifyEventId(event)) {
+            return c.json({ error: "Invalid event id" }, 422);
+          }
+        } else if (!await verifyEvent2(event)) {
+          return c.json({ error: "Invalid event signature" }, 422);
+        }
+      }
+      if (!isEphemeralKind(event.kind)) {
+        config.eventStore.store(event);
+      }
+      config.onStored?.(event);
+      return c.json(
+        {
+          eventId: event.id,
+          storedAt: Math.floor(Date.now() / 1e3),
+          ...payment ? { payment } : {}
+        },
+        200
+      );
+    }
+  };
+}
+
+// src/launcher/rate-limiter.ts
+function createRateLimiter(options) {
+  const { maxRequests, windowMs } = options;
+  const now = options.now ?? Date.now;
+  const hits = /* @__PURE__ */ new Map();
+  return {
+    allow(key) {
+      const t = now();
+      const windowStart = t - windowMs;
+      const timestamps = (hits.get(key) ?? []).filter(
+        (ts) => ts >= windowStart
+      );
+      hits.set(key, timestamps);
+      if (timestamps.length >= maxRequests) {
+        return false;
+      }
+      timestamps.push(t);
+      return true;
+    }
+  };
+}
+
+// src/launcher/handlers/write-ephemeral-handler.ts
+import { getConnInfo } from "@hono/node-server/conninfo";
+function isEphemeralKind2(kind) {
+  return kind >= 2e4 && kind < 3e4;
+}
+var DEFAULT_EPHEMERAL_RATE_LIMIT = {
+  maxRequests: 200,
+  windowMs: 1e4
+};
+var DEFAULT_EPHEMERAL_MAX_BODY_BYTES = 8 * 1024;
+function defaultClientKey(c) {
+  try {
+    return getConnInfo(c).remote.address ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function createEphemeralWriteHandler(config = {}) {
+  const logWrites = config.logWrites ?? false;
+  const verifyEvent2 = config.verifyEvent ?? verifyEventSignature;
+  const maxBodyBytes = config.maxBodyBytes ?? DEFAULT_EPHEMERAL_MAX_BODY_BYTES;
+  const rateLimiter = config.rateLimiter ?? createRateLimiter(config.rateLimit ?? DEFAULT_EPHEMERAL_RATE_LIMIT);
+  const getClientKey = config.getClientKey ?? defaultClientKey;
+  return {
+    async handleWrite(c) {
+      if (!rateLimiter.allow(getClientKey(c))) {
+        return c.json({ error: "Rate limit exceeded" }, 429);
+      }
+      const contentLengthHeader = c.req.header("content-length");
+      if (contentLengthHeader !== void 0 && Number(contentLengthHeader) > maxBodyBytes) {
+        return c.json({ error: "Request body too large" }, 413);
+      }
+      let rawBody;
+      try {
+        rawBody = await c.req.text();
+      } catch {
+        return c.json({ error: "Invalid request body" }, 400);
+      }
+      if (Buffer.byteLength(rawBody, "utf8") > maxBodyBytes) {
+        return c.json({ error: "Request body too large" }, 413);
+      }
+      let body;
+      try {
+        body = JSON.parse(rawBody);
+      } 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;
+      if (!isEphemeralKind2(event.kind)) {
+        return c.json(
+          {
+            error: "Only ephemeral kinds (20000-29999) are accepted on this lane"
+          },
+          400
+        );
+      }
+      if (logWrites) {
+        console.log(`[write] event=${event.id} handler=write-ephemeral`);
+      }
+      if (!await verifyEvent2(event)) {
+        return c.json({ error: "Invalid event signature" }, 422);
+      }
+      config.onBroadcast?.(event);
+      return c.json(
+        {
+          eventId: event.id,
+          broadcastAt: Math.floor(Date.now() / 1e3)
+        },
+        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 isInternalBindHost(host) {
+  const h = host.trim().toLowerCase();
+  if (h === "localhost" || h === "::1" || h === "[::1]") return true;
+  if (h.startsWith("127.")) return true;
+  if (h.startsWith("10.")) return true;
+  if (h.startsWith("192.168.")) return true;
+  if (/^172\.(1[6-9]|2\d|3[01])\./.test(h)) return true;
+  if (/^f[cd][0-9a-f]{2}:/.test(h)) return true;
+  if (h.startsWith("fe80:")) return true;
+  return false;
+}
+function warnIfWritePortExposed(writeHost, blsPort, options) {
+  const skipActive = options.devMode || !options.verifyEphemeral;
+  if (!skipActive || isInternalBindHost(writeHost)) {
+    return false;
+  }
+  console.warn(
+    [
+      "",
+      "!".repeat(72),
+      `[relay] WARNING: POST /write is binding ${writeHost}:${blsPort} (a`,
+      "[relay] non-loopback/non-internal interface) while event verification",
+      options.devMode ? "[relay] is fully DISABLED (devMode)." : "[relay] is SKIPPED for paid ephemeral kinds (relay#85 default).",
+      "[relay] This is safe ONLY if the write port is reachable exclusively",
+      "[relay] through the payment-gating connector. In docker, do NOT",
+      "[relay] host-publish this port (`expose:`, never `ports:` -- published",
+      "[relay] ports bypass ufw). If the port is directly reachable, either",
+      "[relay] bind it internally (TOON_WRITE_HOST=127.0.0.1) or restore full",
+      "[relay] verification (TOON_VERIFY_EPHEMERAL=true).",
+      "!".repeat(72),
+      ""
+    ].join("\n")
+  );
+  return true;
+}
+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 writeHost = config.writeHost ?? "0.0.0.0";
+  const maxConnections = config.maxConnections ?? DEFAULT_RELAY_CONFIG.maxConnections;
+  const dataDir = config.dataDir ?? "./data";
+  const devMode = config.devMode ?? false;
+  const verifyEphemeral = config.verifyEphemeral ?? false;
+  const verifyWorkers = config.verifyWorkers ?? defaultVerifyWorkers();
+  const ephemeralRateLimit = config.ephemeralRateLimit ?? DEFAULT_EPHEMERAL_RATE_LIMIT;
+  const ephemeralMaxBodyBytes = config.ephemeralMaxBodyBytes ?? DEFAULT_EPHEMERAL_MAX_BODY_BYTES;
+  const logWrites = config.logWrites ?? false;
+  const enforceExpiration = config.enforceExpiration ?? true;
+  const expirationReapGraceSeconds = config.expirationReapGraceSeconds ?? 86400;
+  const expirationReapIntervalSeconds = config.expirationReapIntervalSeconds ?? 3600;
+  const blockedEventIds = config.blockedEventIds ?? [];
+  const resolvedConfig = {
+    relayPort,
+    blsPort,
+    host,
+    writeHost,
+    maxConnections,
+    dataDir,
+    devMode,
+    verifyEphemeral,
+    verifyWorkers,
+    ephemeralRateLimit,
+    ephemeralMaxBodyBytes,
+    logWrites,
+    enforceExpiration,
+    expirationReapGraceSeconds,
+    expirationReapIntervalSeconds,
+    blockedEventIds
+  };
+  let eventStore;
+  if (config.eventStore) {
+    eventStore = config.eventStore;
+  } else {
+    mkdirSync(dataDir, { recursive: true });
+    eventStore = new SqliteEventStore(join(dataDir, "events.db"), {
+      enforceExpiration,
+      blockedEventIds
+    });
+  }
+  console.log(
+    `[relay] NIP-40 expiration: ${enforceExpiration ? `enforced (reap grace ${expirationReapGraceSeconds}s, sweep ${expirationReapIntervalSeconds > 0 ? `every ${expirationReapIntervalSeconds}s` : "disabled"})` : "NOT enforced -- expired events are still served (TOON_ENFORCE_EXPIRATION=false)"}`
+  );
+  console.log("[relay] NIP-09 deletion: enabled (author-signed kind:5 only)");
+  if (blockedEventIds.length > 0) {
+    console.warn(
+      `[relay] OPERATOR BLOCKLIST ACTIVE -- ${blockedEventIds.length} event id(s) refused on write and swept from storage:`
+    );
+    for (const id of blockedEventIds) {
+      console.warn(`[relay]   blocked ${id}`);
+    }
+  }
+  const wsRelay = new NostrRelayServer(
+    { port: relayPort, host, maxConnections, enforceExpiration },
+    eventStore
+  );
+  let reapTimer;
+  if (enforceExpiration && expirationReapIntervalSeconds > 0 && eventStore.reapExpired) {
+    const reap = () => {
+      try {
+        const removed = eventStore.reapExpired?.(
+          Math.floor(Date.now() / 1e3),
+          expirationReapGraceSeconds
+        );
+        if (removed) {
+          console.log(
+            `[relay] NIP-40 reaper removed ${removed} expired event(s)`
+          );
+        }
+      } catch (error) {
+        console.warn(
+          `[relay] NIP-40 reaper failed: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    };
+    reap();
+    reapTimer = setInterval(reap, expirationReapIntervalSeconds * 1e3);
+    reapTimer.unref();
+  }
+  const app = new Hono();
+  app.get(
+    "/health",
+    (c) => c.json(createHealthResponse({ pubkey: identity.pubkey }))
+  );
+  const metrics = createMetricsRegistry({
+    verifyImplementation,
+    verifyWorkers: 0,
+    // updated once the pool reports its live size below
+    ephemeralRateLimit,
+    ephemeralMaxBodyBytes
+  });
+  const verifyPool = createVerifyPool({
+    size: verifyWorkers,
+    onMeasure: (ms) => metrics.recordVerify(ms)
+  });
+  metrics.setVerifyWorkers(verifyPool.size);
+  app.get("/metrics", (c) => c.json(metrics.snapshot()));
+  console.log(`[relay] event signature verify: ${verifyImplementation}`);
+  console.log(
+    `[relay] ephemeral-kind schnorr verify: ${devMode ? "skipped (devMode)" : verifyEphemeral ? "full (TOON_VERIFY_EPHEMERAL)" : "skipped -- payment-gated write path, id check kept (relay#85)"}`
+  );
+  warnIfWritePortExposed(writeHost, blsPort, { verifyEphemeral, devMode });
+  console.log(
+    `[relay] verify pool: ${verifyPool.size > 0 ? `${verifyPool.size} worker thread(s)` : "inline (0 workers -- verification on the event loop)"}`
+  );
+  const verifyViaPool = (event) => {
+    metrics.setVerifyWorkers(verifyPool.size);
+    return verifyPool.verify(event);
+  };
+  const broadcastToReaders = (event) => {
+    try {
+      wsRelay.broadcastEvent(event);
+    } catch {
+    }
+  };
+  const writeHandler = createWriteHandler({
+    eventStore,
+    devMode,
+    verifyEphemeral,
+    verifyEvent: verifyViaPool,
+    logWrites,
+    onStored: broadcastToReaders
+  });
+  app.post("/write", (c) => writeHandler.handleWrite(c));
+  console.log(
+    `[relay] ephemeral free write lane: enabled on POST /write-ephemeral (full schnorr verify always; rate limit ${ephemeralRateLimit.maxRequests} req / ${ephemeralRateLimit.windowMs}ms per key; max body ${ephemeralMaxBodyBytes} bytes)`
+  );
+  const ephemeralWriteHandler = createEphemeralWriteHandler({
+    rateLimit: ephemeralRateLimit,
+    maxBodyBytes: ephemeralMaxBodyBytes,
+    verifyEvent: verifyViaPool,
+    logWrites,
+    onBroadcast: broadcastToReaders
+  });
+  app.post(
+    "/write-ephemeral",
+    (c) => ephemeralWriteHandler.handleWrite(c)
+  );
+  const blsServer = await new Promise((resolve) => {
+    const server = serve(
+      { fetch: app.fetch, port: blsPort, hostname: writeHost },
+      () => 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();
+      if (reapTimer) clearInterval(reapTimer);
+      await wsRelay.stop();
+      blsServer.close();
+      metrics.stop();
+      await verifyPool.destroy();
+      if (!config.eventStore) {
+        eventStore.close?.();
+      }
+    },
+    pubkey: identity.pubkey,
+    config: resolvedConfig
+  };
+  return instance;
+}
+
+export {
+  VERSION,
+  DEFAULT_RELAY_CONFIG,
+  matchFilter,
+  EXPIRATION_TAG,
+  getExpiration,
+  isExpired,
+  DELETION_KIND,
+  isDeletionKind,
+  parseAddressCoordinate,
+  parseDeletionTargets,
+  isDeletableBy,
+  InMemoryEventStore,
+  RelayError,
+  SqliteEventStore,
+  parseBlockedEventIds,
+  defaultVerifyWorkers,
+  createVerifyPool,
+  serializeEventFrame,
+  ConnectionHandler,
+  readOpenFilesSoftLimit,
+  NostrRelayServer,
+  RelaySubscriber,
+  createMetricsRegistry,
+  readPaymentAttribution,
+  createWriteHandler,
+  createRateLimiter,
+  DEFAULT_EPHEMERAL_RATE_LIMIT,
+  DEFAULT_EPHEMERAL_MAX_BODY_BYTES,
+  createEphemeralWriteHandler,
+  createHealthResponse,
+  isInternalBindHost,
+  warnIfWritePortExposed,
+  startRelay
+};
+//# sourceMappingURL=chunk-IZOSPMWV.js.map