@toon-protocol/relay 2.0.2 → 2.1.0

package/dist/{chunk-QZQRHQEQ.js → chunk-IZOSPMWV.js}

@@ -5,16 +5,17 @@ import {
 } from "./chunk-SMT6G3XD.js";
 
 // src/version.ts
-var VERSION = "0.1.0";
+var VERSION = "2.1.0";
 
 // src/types.ts
 var DEFAULT_RELAY_CONFIG = {
-  port: 7e3,
+  port: 7100,
   host: "0.0.0.0",
   maxConnections: 4096,
   maxSubscriptionsPerConnection: 20,
   maxFiltersPerSubscription: 10,
-  databasePath: ":memory:"
+  databasePath: ":memory:",
+  enforceExpiration: true
 };
 
 // src/filters/matchFilter.ts
@@ -55,17 +56,98 @@ function matchFilter(event, filter) {
   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 {
+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) {
-    return this.events.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 allEvents = Array.from(this.events.values());
+    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);
     }
@@ -85,12 +167,72 @@ var InMemoryEventStore = class {
     }
     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";
@@ -103,17 +245,56 @@ CREATE TABLE IF NOT EXISTS events (
   tags TEXT NOT NULL,
   created_at INTEGER NOT NULL,
   sig TEXT NOT NULL,
-  received_at INTEGER 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)"
+  "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);
   }
@@ -135,7 +316,7 @@ function getDTagValue(tags) {
   const dTag = tags.find((tag) => tag[0] === "d");
   return dTag?.[1] ?? "";
 }
-var SqliteEventStore = class {
+var SqliteEventStore = class _SqliteEventStore {
   db;
   insertStmt;
   insertOrIgnoreStmt;
@@ -144,25 +325,58 @@ var SqliteEventStore = class {
   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:") {
+  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)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        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)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        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 = ?"
       );
@@ -184,27 +398,26 @@ var SqliteEventStore = class {
   }
   /**
    * Store an event in the database.
-   * Handles replaceable and parameterized replaceable events according to NIP-01.
+   *
+   * 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.insertOrIgnoreStmt.run(
-          event.id,
-          event.pubkey,
-          event.kind,
-          event.content,
-          tagsJson,
-          event.created_at,
-          event.sig,
-          receivedAt
-        );
+        this.runInsert(this.insertOrIgnoreStmt, event, tagsJson, receivedAt);
       }
     } catch (error) {
       if (error instanceof RelayError) {
@@ -226,30 +439,12 @@ var SqliteEventStore = class {
       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
-          );
+          this.runInsert(this.insertStmt, event, tagsJson, receivedAt);
         });
         transaction();
       }
     } else {
-      this.insertStmt.run(
-        event.id,
-        event.pubkey,
-        event.kind,
-        event.content,
-        tagsJson,
-        event.created_at,
-        event.sig,
-        receivedAt
-      );
+      this.runInsert(this.insertStmt, event, tagsJson, receivedAt);
     }
   }
   /**
@@ -283,34 +478,136 @@ var SqliteEventStore = class {
       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
-          );
+          this.runInsert(this.insertStmt, event, tagsJson, receivedAt);
         });
         transaction();
       }
     } else {
-      this.insertStmt.run(
-        event.id,
-        event.pubkey,
-        event.kind,
-        event.content,
-        tagsJson,
-        event.created_at,
-        event.sig,
-        receivedAt
+      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 {
@@ -318,6 +615,9 @@ var SqliteEventStore = class {
       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,
@@ -362,14 +662,19 @@ var SqliteEventStore = class {
    * 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 ORDER BY created_at DESC",
-        params: []
+        sql: `SELECT * FROM events${liveClause ? ` WHERE ${liveClause}` : ""} ORDER BY created_at DESC`,
+        params
       };
     }
     const conditions = [];
-    const params = [];
     for (const filter of filters) {
       const filterConditions = [];
       if (filter.ids?.length) {
@@ -408,9 +713,12 @@ var SqliteEventStore = class {
         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 (conditions.length > 0) {
-      sql += ` WHERE ${conditions.join(" OR ")}`;
+    if (whereParts.length > 0) {
+      sql += ` WHERE ${whereParts.join(" AND ")}`;
     }
     sql += " ORDER BY created_at DESC";
     const limitFilter = filters.find((f) => f.limit !== void 0);
@@ -428,6 +736,23 @@ var SqliteEventStore = class {
   }
 };
 
+// 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";
@@ -654,6 +979,9 @@ var ConnectionHandler = class {
    *   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));
@@ -967,6 +1295,11 @@ function createMetricsRegistry(info) {
           maxMs: round(maxMs),
           p50Ms: round(percentileOf(recent, 0.5)),
           p99Ms: round(percentileOf(recent, 0.99))
+        },
+        ephemeralWriteLane: {
+          enabled: true,
+          rateLimit: info.ephemeralRateLimit,
+          maxBodyBytes: info.ephemeralMaxBodyBytes
         }
       };
     },
@@ -979,6 +1312,22 @@ function createMetricsRegistry(info) {
   };
 }
 
+// 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;
@@ -999,13 +1348,10 @@ function createWriteHandler(config) {
         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");
+      const payment = readPaymentAttribution(c);
       if (logWrites) {
-        console.log(
-          `[write] event=${event.id} payer=${payer ?? "-"} amount=${amount ?? "-"} chain=${chain ?? "-"}`
-        );
+        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) {
@@ -1024,9 +1370,106 @@ function createWriteHandler(config) {
         {
           eventId: event.id,
           storedAt: Math.floor(Date.now() / 1e3),
-          payer,
-          amount,
-          chain
+          ...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
       );
@@ -1139,7 +1582,13 @@ async function startRelay(config) {
   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,
@@ -1150,19 +1599,63 @@ async function startRelay(config) {
     devMode,
     verifyEphemeral,
     verifyWorkers,
-    logWrites
+    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"));
+    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 },
+    { 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",
@@ -1170,8 +1663,10 @@ async function startRelay(config) {
   );
   const metrics = createMetricsRegistry({
     verifyImplementation,
-    verifyWorkers: 0
+    verifyWorkers: 0,
     // updated once the pool reports its live size below
+    ephemeralRateLimit,
+    ephemeralMaxBodyBytes
   });
   const verifyPool = createVerifyPool({
     size: verifyWorkers,
@@ -1187,23 +1682,39 @@ async function startRelay(config) {
   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: (event) => {
-      metrics.setVerifyWorkers(verifyPool.size);
-      return verifyPool.verify(event);
-    },
+    verifyEvent: verifyViaPool,
     logWrites,
-    onStored: (event) => {
-      try {
-        wsRelay.broadcastEvent(event);
-      } catch {
-      }
-    }
+    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 },
@@ -1235,6 +1746,7 @@ async function startRelay(config) {
         sub.close();
       }
       activeSubscriptions.clear();
+      if (reapTimer) clearInterval(reapTimer);
       await wsRelay.stop();
       blsServer.close();
       metrics.stop();
@@ -1253,9 +1765,18 @@ export {
   VERSION,
   DEFAULT_RELAY_CONFIG,
   matchFilter,
+  EXPIRATION_TAG,
+  getExpiration,
+  isExpired,
+  DELETION_KIND,
+  isDeletionKind,
+  parseAddressCoordinate,
+  parseDeletionTargets,
+  isDeletableBy,
   InMemoryEventStore,
   RelayError,
   SqliteEventStore,
+  parseBlockedEventIds,
   defaultVerifyWorkers,
   createVerifyPool,
   serializeEventFrame,
@@ -1264,10 +1785,15 @@ export {
   NostrRelayServer,
   RelaySubscriber,
   createMetricsRegistry,
+  readPaymentAttribution,
   createWriteHandler,
+  createRateLimiter,
+  DEFAULT_EPHEMERAL_RATE_LIMIT,
+  DEFAULT_EPHEMERAL_MAX_BODY_BYTES,
+  createEphemeralWriteHandler,
   createHealthResponse,
   isInternalBindHost,
   warnIfWritePortExposed,
   startRelay
 };
-//# sourceMappingURL=chunk-QZQRHQEQ.js.map
+//# sourceMappingURL=chunk-IZOSPMWV.js.map