@toon-protocol/relay 1.1.1

package/dist/index.js

@@ -0,0 +1,1196 @@
+// src/types.ts
+var DEFAULT_RELAY_CONFIG = {
+  port: 7e3,
+  maxConnections: 100,
+  maxSubscriptionsPerConnection: 20,
+  maxFiltersPerSubscription: 10,
+  databasePath: ":memory:"
+};
+
+// src/filters/matchFilter.ts
+function matchFilter(event, filter) {
+  if (Object.keys(filter).length === 0) {
+    return true;
+  }
+  if (filter.ids !== void 0 && filter.ids.length > 0) {
+    const matches = filter.ids.some((id) => event.id.startsWith(id));
+    if (!matches) return false;
+  }
+  if (filter.authors !== void 0 && filter.authors.length > 0) {
+    const matches = filter.authors.some(
+      (author) => event.pubkey.startsWith(author)
+    );
+    if (!matches) return false;
+  }
+  if (filter.kinds !== void 0 && filter.kinds.length > 0) {
+    if (!filter.kinds.includes(event.kind)) return false;
+  }
+  if (filter.since !== void 0) {
+    if (event.created_at < filter.since) return false;
+  }
+  if (filter.until !== void 0) {
+    if (event.created_at > filter.until) return false;
+  }
+  for (const key of Object.keys(filter)) {
+    if (key.startsWith("#") && key.length === 2) {
+      const tagName = key.slice(1);
+      const filterValues = filter[key];
+      if (filterValues !== void 0 && filterValues.length > 0) {
+        const eventTagValues = event.tags.filter((tag) => tag[0] === tagName).map((tag) => tag[1]);
+        const hasMatch = filterValues.some((v) => eventTagValues.includes(v));
+        if (!hasMatch) return false;
+      }
+    }
+  }
+  return true;
+}
+
+// src/storage/InMemoryEventStore.ts
+var InMemoryEventStore = class {
+  events = /* @__PURE__ */ new Map();
+  store(event) {
+    this.events.set(event.id, event);
+  }
+  get(id) {
+    return this.events.get(id);
+  }
+  query(filters) {
+    const allEvents = Array.from(this.events.values());
+    if (filters.length === 0) {
+      return allEvents.sort((a, b) => b.created_at - a.created_at);
+    }
+    const matchingEvents = [];
+    for (const event of allEvents) {
+      for (const filter of filters) {
+        if (matchFilter(event, filter)) {
+          matchingEvents.push(event);
+          break;
+        }
+      }
+    }
+    matchingEvents.sort((a, b) => b.created_at - a.created_at);
+    const limitFilter = filters.find((f) => f.limit !== void 0);
+    if (limitFilter?.limit !== void 0) {
+      return matchingEvents.slice(0, limitFilter.limit);
+    }
+    return matchingEvents;
+  }
+  /**
+   * Close the storage backend (no-op for in-memory store).
+   */
+  close() {
+  }
+};
+
+// src/storage/SqliteEventStore.ts
+import Database from "better-sqlite3";
+var SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS events (
+  id TEXT PRIMARY KEY,
+  pubkey TEXT NOT NULL,
+  kind INTEGER NOT NULL,
+  content TEXT NOT NULL,
+  tags TEXT NOT NULL,
+  created_at INTEGER NOT NULL,
+  sig TEXT NOT NULL,
+  received_at INTEGER NOT NULL
+)
+`;
+var INDEX_SQL = [
+  "CREATE INDEX IF NOT EXISTS idx_events_pubkey ON events(pubkey)",
+  "CREATE INDEX IF NOT EXISTS idx_events_kind ON events(kind)",
+  "CREATE INDEX IF NOT EXISTS idx_events_created_at ON events(created_at)",
+  "CREATE INDEX IF NOT EXISTS idx_events_pubkey_kind ON events(pubkey, kind)"
+];
+function initializeSchema(db) {
+  db.exec(SCHEMA_SQL);
+  for (const indexSql of INDEX_SQL) {
+    db.exec(indexSql);
+  }
+}
+var RelayError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "RelayError";
+  }
+};
+function isReplaceableKind(kind) {
+  return kind >= 1e4 && kind <= 19999;
+}
+function isParameterizedReplaceableKind(kind) {
+  return kind >= 3e4 && kind <= 39999;
+}
+function getDTagValue(tags) {
+  const dTag = tags.find((tag) => tag[0] === "d");
+  return dTag?.[1] ?? "";
+}
+var SqliteEventStore = class {
+  db;
+  insertStmt;
+  getStmt;
+  deleteByPubkeyKindStmt;
+  deleteByPubkeyKindDTagStmt;
+  getByPubkeyKindStmt;
+  getByPubkeyKindDTagStmt;
+  /**
+   * Create a new SqliteEventStore.
+   * @param dbPath - Path to the database file. Use ':memory:' for in-memory database.
+   */
+  constructor(dbPath = ":memory:") {
+    try {
+      this.db = new Database(dbPath);
+      initializeSchema(this.db);
+      this.insertStmt = this.db.prepare(`
+        INSERT OR REPLACE INTO events (id, pubkey, kind, content, tags, created_at, sig, received_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+      this.getStmt = this.db.prepare("SELECT * FROM events WHERE id = ?");
+      this.deleteByPubkeyKindStmt = this.db.prepare(
+        "DELETE FROM events WHERE pubkey = ? AND kind = ?"
+      );
+      this.deleteByPubkeyKindDTagStmt = this.db.prepare(
+        "DELETE FROM events WHERE pubkey = ? AND kind = ? AND json_extract(tags, '$') LIKE ?"
+      );
+      this.getByPubkeyKindStmt = this.db.prepare(
+        "SELECT id, created_at FROM events WHERE pubkey = ? AND kind = ?"
+      );
+      this.getByPubkeyKindDTagStmt = this.db.prepare(
+        "SELECT id, created_at FROM events WHERE pubkey = ? AND kind = ? AND tags LIKE ?"
+      );
+    } catch (error) {
+      throw new RelayError(
+        `Failed to initialize database: ${error instanceof Error ? error.message : String(error)}`,
+        "STORAGE_ERROR"
+      );
+    }
+  }
+  /**
+   * Store an event in the database.
+   * Handles replaceable and parameterized replaceable events according to NIP-01.
+   */
+  store(event) {
+    try {
+      const tagsJson = JSON.stringify(event.tags);
+      const receivedAt = Math.floor(Date.now() / 1e3);
+      if (isReplaceableKind(event.kind)) {
+        this.storeReplaceableEvent(event, tagsJson, receivedAt);
+      } else if (isParameterizedReplaceableKind(event.kind)) {
+        this.storeParameterizedReplaceableEvent(event, tagsJson, receivedAt);
+      } else {
+        const insertOrIgnore = this.db.prepare(`
+          INSERT OR IGNORE INTO events (id, pubkey, kind, content, tags, created_at, sig, received_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        `);
+        insertOrIgnore.run(
+          event.id,
+          event.pubkey,
+          event.kind,
+          event.content,
+          tagsJson,
+          event.created_at,
+          event.sig,
+          receivedAt
+        );
+      }
+    } catch (error) {
+      if (error instanceof RelayError) {
+        throw error;
+      }
+      throw new RelayError(
+        `Failed to store event: ${error instanceof Error ? error.message : String(error)}`,
+        "STORAGE_ERROR"
+      );
+    }
+  }
+  /**
+   * Store a replaceable event (kinds 10000-19999).
+   * Only keeps the latest event per pubkey+kind.
+   */
+  storeReplaceableEvent(event, tagsJson, receivedAt) {
+    const existing = this.getByPubkeyKindStmt.get(event.pubkey, event.kind);
+    if (existing) {
+      if (event.created_at > existing.created_at || event.created_at === existing.created_at && event.id < existing.id) {
+        const transaction = this.db.transaction(() => {
+          this.deleteByPubkeyKindStmt.run(event.pubkey, event.kind);
+          this.insertStmt.run(
+            event.id,
+            event.pubkey,
+            event.kind,
+            event.content,
+            tagsJson,
+            event.created_at,
+            event.sig,
+            receivedAt
+          );
+        });
+        transaction();
+      }
+    } else {
+      this.insertStmt.run(
+        event.id,
+        event.pubkey,
+        event.kind,
+        event.content,
+        tagsJson,
+        event.created_at,
+        event.sig,
+        receivedAt
+      );
+    }
+  }
+  /**
+   * Store a parameterized replaceable event (kinds 30000-39999).
+   * Only keeps the latest event per pubkey+kind+d-tag.
+   */
+  storeParameterizedReplaceableEvent(event, tagsJson, receivedAt) {
+    const dTagValue = getDTagValue(event.tags);
+    let existing;
+    if (dTagValue === "") {
+      const candidates = this.db.prepare(
+        "SELECT id, created_at, tags FROM events WHERE pubkey = ? AND kind = ?"
+      ).all(event.pubkey, event.kind);
+      for (const candidate of candidates) {
+        const candidateTags = JSON.parse(candidate.tags);
+        const candidateDTagValue = getDTagValue(candidateTags);
+        if (candidateDTagValue === "") {
+          existing = { id: candidate.id, created_at: candidate.created_at };
+          break;
+        }
+      }
+    } else {
+      const dTagPattern = `%["d","${dTagValue}"%`;
+      existing = this.getByPubkeyKindDTagStmt.get(
+        event.pubkey,
+        event.kind,
+        dTagPattern
+      );
+    }
+    if (existing) {
+      if (event.created_at > existing.created_at || event.created_at === existing.created_at && event.id < existing.id) {
+        const transaction = this.db.transaction(() => {
+          this.db.prepare("DELETE FROM events WHERE id = ?").run(existing.id);
+          this.insertStmt.run(
+            event.id,
+            event.pubkey,
+            event.kind,
+            event.content,
+            tagsJson,
+            event.created_at,
+            event.sig,
+            receivedAt
+          );
+        });
+        transaction();
+      }
+    } else {
+      this.insertStmt.run(
+        event.id,
+        event.pubkey,
+        event.kind,
+        event.content,
+        tagsJson,
+        event.created_at,
+        event.sig,
+        receivedAt
+      );
+    }
+  }
+  /**
+   * Retrieve an event by its ID.
+   */
+  get(id) {
+    try {
+      const row = this.getStmt.get(id);
+      if (!row) {
+        return void 0;
+      }
+      return {
+        id: row.id,
+        pubkey: row.pubkey,
+        kind: row.kind,
+        content: row.content,
+        tags: JSON.parse(row.tags),
+        created_at: row.created_at,
+        sig: row.sig
+      };
+    } catch (error) {
+      throw new RelayError(
+        `Failed to get event: ${error instanceof Error ? error.message : String(error)}`,
+        "STORAGE_ERROR"
+      );
+    }
+  }
+  /**
+   * Query events matching any of the provided filters.
+   */
+  query(filters) {
+    try {
+      const { sql, params } = this.buildQuerySql(filters);
+      const stmt = this.db.prepare(sql);
+      const rows = stmt.all(...params);
+      return rows.map((row) => ({
+        id: row.id,
+        pubkey: row.pubkey,
+        kind: row.kind,
+        content: row.content,
+        tags: JSON.parse(row.tags),
+        created_at: row.created_at,
+        sig: row.sig
+      }));
+    } catch (error) {
+      throw new RelayError(
+        `Failed to query events: ${error instanceof Error ? error.message : String(error)}`,
+        "STORAGE_ERROR"
+      );
+    }
+  }
+  /**
+   * Build SQL query from filters.
+   */
+  buildQuerySql(filters) {
+    if (filters.length === 0) {
+      return {
+        sql: "SELECT * FROM events ORDER BY created_at DESC",
+        params: []
+      };
+    }
+    const conditions = [];
+    const params = [];
+    for (const filter of filters) {
+      const filterConditions = [];
+      if (filter.ids?.length) {
+        const idConditions = filter.ids.map(() => "id LIKE ?");
+        filterConditions.push(`(${idConditions.join(" OR ")})`);
+        params.push(...filter.ids.map((id) => `${id}%`));
+      }
+      if (filter.authors?.length) {
+        const authorConditions = filter.authors.map(() => "pubkey LIKE ?");
+        filterConditions.push(`(${authorConditions.join(" OR ")})`);
+        params.push(...filter.authors.map((a) => `${a}%`));
+      }
+      if (filter.kinds?.length) {
+        filterConditions.push(
+          `kind IN (${filter.kinds.map(() => "?").join(", ")})`
+        );
+        params.push(...filter.kinds);
+      }
+      if (filter.since !== void 0) {
+        filterConditions.push("created_at >= ?");
+        params.push(filter.since);
+      }
+      if (filter.until !== void 0) {
+        filterConditions.push("created_at <= ?");
+        params.push(filter.until);
+      }
+      for (const [key, values] of Object.entries(filter)) {
+        if (key.startsWith("#") && Array.isArray(values) && values.length > 0) {
+          const tagName = key.slice(1);
+          const tagConditions = values.map(() => `tags LIKE ?`);
+          filterConditions.push(`(${tagConditions.join(" OR ")})`);
+          params.push(...values.map((v) => `%["${tagName}","${v}"%`));
+        }
+      }
+      if (filterConditions.length > 0) {
+        conditions.push(`(${filterConditions.join(" AND ")})`);
+      }
+    }
+    let sql = "SELECT * FROM events";
+    if (conditions.length > 0) {
+      sql += ` WHERE ${conditions.join(" OR ")}`;
+    }
+    sql += " ORDER BY created_at DESC";
+    const limitFilter = filters.find((f) => f.limit !== void 0);
+    if (limitFilter?.limit !== void 0) {
+      sql += " LIMIT ?";
+      params.push(limitFilter.limit);
+    }
+    return { sql, params };
+  }
+  /**
+   * Close the database connection.
+   */
+  close() {
+    this.db.close();
+  }
+};
+
+// src/toon/index.ts
+import {
+  encodeEventToToon,
+  encodeEventToToonString,
+  ToonEncodeError
+} from "@toon-protocol/core";
+import { decodeEventFromToon, ToonDecodeError } from "@toon-protocol/core";
+
+// src/websocket/ConnectionHandler.ts
+var ConnectionHandler = class {
+  constructor(ws, eventStore, config = {}) {
+    this.ws = ws;
+    this.eventStore = eventStore;
+    this.config = { ...DEFAULT_RELAY_CONFIG, ...config };
+  }
+  subscriptions = /* @__PURE__ */ new Map();
+  config;
+  /**
+   * Handle an incoming message from the WebSocket.
+   */
+  handleMessage(data) {
+    console.log(`[ConnectionHandler] Received message:`, data.slice(0, 150));
+    let message;
+    try {
+      const parsed = JSON.parse(data);
+      if (!Array.isArray(parsed)) {
+        this.sendNotice("error: invalid message format, expected JSON array");
+        return;
+      }
+      message = parsed;
+    } catch {
+      this.sendNotice("error: invalid JSON");
+      return;
+    }
+    const messageType = message[0];
+    console.log(`[ConnectionHandler] Message type: ${messageType}`);
+    if (messageType === "REQ") {
+      const subscriptionId = message[1];
+      const filters = message.slice(2);
+      this.handleReq(subscriptionId, filters);
+    } else if (messageType === "EVENT") {
+      const event = message[1];
+      this.handleEvent(event);
+    } else if (messageType === "CLOSE") {
+      const subscriptionId = message[1];
+      this.handleClose(subscriptionId);
+    } else {
+      this.sendNotice(`error: unknown message type: ${messageType}`);
+    }
+  }
+  /**
+   * Handle a REQ message to create/update a subscription.
+   */
+  handleReq(subscriptionId, filters) {
+    if (typeof subscriptionId !== "string" || subscriptionId.length === 0) {
+      this.sendNotice("error: invalid subscription id");
+      return;
+    }
+    if (!this.subscriptions.has(subscriptionId)) {
+      if (this.subscriptions.size >= this.config.maxSubscriptionsPerConnection) {
+        this.sendNotice("error: too many subscriptions");
+        return;
+      }
+    }
+    if (filters.length > this.config.maxFiltersPerSubscription) {
+      this.sendNotice("error: too many filters");
+      return;
+    }
+    this.subscriptions.set(subscriptionId, {
+      id: subscriptionId,
+      filters
+    });
+    console.log(
+      `[ConnectionHandler] REQ: ${subscriptionId}, filters:`,
+      JSON.stringify(filters).slice(0, 100)
+    );
+    const events = this.eventStore.query(filters);
+    console.log(
+      `[ConnectionHandler] Query returned ${events.length} events for ${subscriptionId}`
+    );
+    for (const event of events) {
+      console.log(
+        `[ConnectionHandler] Sending event ${event.id.slice(0, 16)}... to ${subscriptionId}`
+      );
+      this.sendEvent(subscriptionId, event);
+    }
+    console.log(`[ConnectionHandler] Sending EOSE for ${subscriptionId}`);
+    this.sendEose(subscriptionId);
+  }
+  /**
+   * Handle an EVENT message to store an event.
+   * Accepts events for free (no payment required).
+   */
+  handleEvent(event) {
+    console.log(
+      `[ConnectionHandler] Received EVENT: ${event.id.slice(0, 16)}... kind:${event.kind}`
+    );
+    try {
+      this.eventStore.store(event);
+      console.log(`[ConnectionHandler] Event stored successfully`);
+      this.sendOk(event.id, true, "");
+    } catch (error) {
+      console.error(`[ConnectionHandler] Failed to store event:`, error);
+      this.sendOk(
+        event.id,
+        false,
+        error instanceof Error ? error.message : "storage failed"
+      );
+    }
+  }
+  /**
+   * Handle a CLOSE message to terminate a subscription.
+   */
+  handleClose(subscriptionId) {
+    this.subscriptions.delete(subscriptionId);
+  }
+  /**
+   * Push a new event to all matching subscriptions on this connection.
+   * Used when events are stored outside the WebSocket flow (e.g., via ILP).
+   */
+  notifyNewEvent(event) {
+    for (const sub of this.subscriptions.values()) {
+      const matches = sub.filters.some((f) => matchFilter(event, f));
+      if (matches) {
+        this.sendEvent(sub.id, event);
+      }
+    }
+  }
+  /**
+   * Clean up all subscriptions for this connection.
+   */
+  cleanup() {
+    this.subscriptions.clear();
+  }
+  /**
+   * Get the number of active subscriptions.
+   */
+  getSubscriptionCount() {
+    return this.subscriptions.size;
+  }
+  sendEvent(subscriptionId, event) {
+    this.send(["EVENT", subscriptionId, encodeEventToToonString(event)]);
+  }
+  sendEose(subscriptionId) {
+    this.send(["EOSE", subscriptionId]);
+  }
+  sendOk(eventId, success, message) {
+    this.send(["OK", eventId, success, message]);
+  }
+  sendNotice(message) {
+    this.send(["NOTICE", message]);
+  }
+  send(message) {
+    if (this.ws.readyState === 1) {
+      this.ws.send(JSON.stringify(message));
+    }
+  }
+};
+
+// src/websocket/NostrRelayServer.ts
+import { WebSocketServer } from "ws";
+var NostrRelayServer = class {
+  constructor(config = {}, eventStore) {
+    this.eventStore = eventStore;
+    this.config = { ...DEFAULT_RELAY_CONFIG, ...config };
+  }
+  wss = null;
+  handlers = /* @__PURE__ */ new Map();
+  config;
+  /**
+   * Start the WebSocket server.
+   */
+  async start() {
+    return new Promise((resolve, reject) => {
+      try {
+        this.wss = new WebSocketServer({ port: this.config.port });
+        this.wss.on("connection", (ws) => {
+          this.handleConnection(ws);
+        });
+        this.wss.on("error", (error) => {
+          console.error("[NostrRelayServer] Server error:", error.message);
+        });
+        this.wss.on("listening", () => {
+          const address = this.wss?.address();
+          if (address && typeof address === "object") {
+            console.log(`[NostrRelayServer] Listening on port ${address.port}`);
+          }
+          resolve();
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Stop the WebSocket server and close all connections.
+   */
+  async stop() {
+    return new Promise((resolve) => {
+      if (!this.wss) {
+        resolve();
+        return;
+      }
+      for (const [ws, handler] of this.handlers) {
+        handler.cleanup();
+        ws.close();
+      }
+      this.handlers.clear();
+      this.wss.close(() => {
+        this.wss = null;
+        resolve();
+      });
+    });
+  }
+  /**
+   * Get the port the server is listening on.
+   * Returns 0 if the server is not started.
+   */
+  getPort() {
+    if (!this.wss) return 0;
+    const address = this.wss.address();
+    if (address && typeof address === "object") {
+      return address.port;
+    }
+    return 0;
+  }
+  /**
+   * Get the number of connected clients.
+   */
+  getClientCount() {
+    return this.handlers.size;
+  }
+  /**
+   * Broadcast an event to all connected clients with matching subscriptions.
+   * Call this after storing an event outside the WebSocket flow (e.g., via ILP)
+   * so that discovery subscribers are notified.
+   */
+  broadcastEvent(event) {
+    for (const handler of this.handlers.values()) {
+      handler.notifyNewEvent(event);
+    }
+  }
+  handleConnection(ws) {
+    if (this.handlers.size >= this.config.maxConnections) {
+      ws.close(1013, "max connections reached");
+      return;
+    }
+    console.log("[NostrRelayServer] Client connected");
+    const handler = new ConnectionHandler(ws, this.eventStore, this.config);
+    this.handlers.set(ws, handler);
+    ws.on("message", (data) => {
+      const message = typeof data === "string" ? data : data.toString();
+      handler.handleMessage(message);
+    });
+    ws.on("close", () => {
+      console.log("[NostrRelayServer] Client disconnected");
+      handler.cleanup();
+      this.handlers.delete(ws);
+    });
+    ws.on("error", (error) => {
+      console.error("[NostrRelayServer] Client error:", error.message);
+      handler.cleanup();
+      this.handlers.delete(ws);
+    });
+  }
+};
+
+// src/bls/types.ts
+var PUBKEY_REGEX = /^[0-9a-f]{64}$/;
+function isValidPubkey(pubkey) {
+  return PUBKEY_REGEX.test(pubkey);
+}
+var ILP_ERROR_CODES = {
+  BAD_REQUEST: "F00",
+  INSUFFICIENT_AMOUNT: "F06",
+  INTERNAL_ERROR: "T00"
+};
+var BlsError = class extends RelayError {
+  constructor(message, code = "BLS_ERROR") {
+    super(message, code);
+    this.name = "BlsError";
+  }
+};
+
+// src/bls/BusinessLogicServer.ts
+import { createHash } from "crypto";
+import { Hono } from "hono";
+import { verifyEvent } from "nostr-tools/pure";
+function generateFulfillment(eventId) {
+  const hash = createHash("sha256").update(eventId).digest();
+  return hash.toString("base64");
+}
+var BusinessLogicServer = class {
+  constructor(config, eventStore) {
+    this.config = config;
+    this.eventStore = eventStore;
+    if (config.ownerPubkey !== void 0 && !isValidPubkey(config.ownerPubkey)) {
+      throw new BlsError(
+        "Invalid ownerPubkey format: must be 64 lowercase hex characters",
+        "INVALID_CONFIG"
+      );
+    }
+    this.app = new Hono();
+    this.setupRoutes();
+  }
+  app;
+  /**
+   * Set up HTTP routes.
+   */
+  setupRoutes() {
+    this.app.post("/handle-packet", async (c) => {
+      try {
+        const body = await c.req.json();
+        const response = this.handlePacket(body);
+        return c.json(response, response.accept ? 200 : 400);
+      } catch (error) {
+        const response = {
+          accept: false,
+          code: ILP_ERROR_CODES.INTERNAL_ERROR,
+          message: error instanceof Error ? error.message : "Internal server error"
+        };
+        return c.json(response, 500);
+      }
+    });
+    this.app.get("/health", (c) => {
+      return c.json({
+        status: "healthy",
+        timestamp: Date.now()
+      });
+    });
+  }
+  /**
+   * Process a packet request.
+   *
+   * This method is public to support direct connector integration in embedded mode,
+   * where the connector calls this method directly via setPacketHandler() instead
+   * of making HTTP requests.
+   */
+  handlePacket(request) {
+    if (!request.amount || !request.destination || !request.data) {
+      return {
+        accept: false,
+        code: ILP_ERROR_CODES.BAD_REQUEST,
+        message: "Missing required fields: amount, destination, data"
+      };
+    }
+    let toonBytes;
+    try {
+      toonBytes = Uint8Array.from(Buffer.from(request.data, "base64"));
+    } catch {
+      return {
+        accept: false,
+        code: ILP_ERROR_CODES.BAD_REQUEST,
+        message: "Invalid base64 encoding in data field"
+      };
+    }
+    let event;
+    try {
+      event = decodeEventFromToon(toonBytes);
+    } catch (error) {
+      return {
+        accept: false,
+        code: ILP_ERROR_CODES.BAD_REQUEST,
+        message: `Invalid TOON data: ${error instanceof Error ? error.message : "Unknown error"}`
+      };
+    }
+    if (!verifyEvent(event)) {
+      return {
+        accept: false,
+        code: ILP_ERROR_CODES.BAD_REQUEST,
+        message: "Invalid event signature"
+      };
+    }
+    if (this.config.ownerPubkey && event.pubkey === this.config.ownerPubkey) {
+      try {
+        this.eventStore.store(event);
+      } catch (error) {
+        throw new BlsError(
+          `Failed to store event: ${error instanceof Error ? error.message : "Unknown error"}`,
+          "STORAGE_ERROR"
+        );
+      }
+      return {
+        accept: true,
+        fulfillment: generateFulfillment(event.id),
+        metadata: {
+          eventId: event.id,
+          storedAt: Date.now()
+        }
+      };
+    }
+    const price = this.config.pricingService ? this.config.pricingService.calculatePriceFromBytes(
+      toonBytes,
+      event.kind
+    ) : BigInt(toonBytes.length) * this.config.basePricePerByte;
+    let amount;
+    try {
+      amount = BigInt(request.amount);
+    } catch {
+      return {
+        accept: false,
+        code: ILP_ERROR_CODES.BAD_REQUEST,
+        message: "Invalid amount format"
+      };
+    }
+    if (amount < price) {
+      return {
+        accept: false,
+        code: ILP_ERROR_CODES.INSUFFICIENT_AMOUNT,
+        message: "Insufficient payment amount",
+        metadata: {
+          required: price.toString(),
+          received: amount.toString()
+        }
+      };
+    }
+    try {
+      this.eventStore.store(event);
+    } catch (error) {
+      throw new BlsError(
+        `Failed to store event: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "STORAGE_ERROR"
+      );
+    }
+    const storedAt = Date.now();
+    return {
+      accept: true,
+      fulfillment: generateFulfillment(event.id),
+      metadata: {
+        eventId: event.id,
+        storedAt
+      }
+    };
+  }
+  /**
+   * Get the Hono app instance for testing or composition.
+   */
+  getApp() {
+    return this.app;
+  }
+  /**
+   * Start the HTTP server on the specified port.
+   */
+  start(port) {
+    console.log(`BLS would start on port ${port}`);
+  }
+};
+
+// src/pricing/types.ts
+var PricingError = class extends RelayError {
+  constructor(message, code = "PRICING_ERROR") {
+    super(message, code);
+    this.name = "PricingError";
+  }
+};
+
+// src/pricing/PricingService.ts
+var PricingService = class {
+  basePricePerByte;
+  kindOverrides;
+  constructor(config) {
+    if (config.basePricePerByte < 0n) {
+      throw new PricingError(
+        "basePricePerByte must be non-negative",
+        "INVALID_CONFIG"
+      );
+    }
+    if (config.kindOverrides) {
+      for (const [kind, price] of config.kindOverrides.entries()) {
+        if (price < 0n) {
+          throw new PricingError(
+            `kindOverride for kind ${kind} must be non-negative`,
+            "INVALID_CONFIG"
+          );
+        }
+      }
+    }
+    this.basePricePerByte = config.basePricePerByte;
+    this.kindOverrides = config.kindOverrides ?? /* @__PURE__ */ new Map();
+  }
+  /**
+   * Calculate price for a Nostr event.
+   *
+   * @param event - The Nostr event to price
+   * @returns The calculated price as bigint
+   */
+  calculatePrice(event) {
+    const toonBytes = encodeEventToToon(event);
+    return this.calculatePriceFromBytes(toonBytes, event.kind);
+  }
+  /**
+   * Calculate price from raw TOON bytes and event kind.
+   *
+   * @param bytes - The TOON-encoded event bytes
+   * @param kind - The event kind number
+   * @returns The calculated price as bigint
+   */
+  calculatePriceFromBytes(bytes, kind) {
+    const pricePerByte = this.getPricePerByte(kind);
+    return BigInt(bytes.length) * pricePerByte;
+  }
+  /**
+   * Get the effective price per byte for a given kind.
+   *
+   * @param kind - The event kind number
+   * @returns The price per byte (kind override if exists, otherwise base price)
+   */
+  getPricePerByte(kind) {
+    return this.kindOverrides.get(kind) ?? this.basePricePerByte;
+  }
+};
+
+// src/pricing/config.ts
+import { readFileSync } from "fs";
+function loadPricingConfigFromEnv() {
+  const basePriceStr = process.env["RELAY_BASE_PRICE_PER_BYTE"] ?? "10";
+  let basePricePerByte;
+  try {
+    basePricePerByte = BigInt(basePriceStr);
+  } catch {
+    throw new PricingError(
+      `Invalid RELAY_BASE_PRICE_PER_BYTE: "${basePriceStr}" is not a valid integer`,
+      "INVALID_ENV_CONFIG"
+    );
+  }
+  if (basePricePerByte < 0n) {
+    throw new PricingError(
+      `Invalid RELAY_BASE_PRICE_PER_BYTE: value must be non-negative`,
+      "INVALID_ENV_CONFIG"
+    );
+  }
+  const kindOverridesStr = process.env["RELAY_KIND_OVERRIDES"];
+  let kindOverrides;
+  if (kindOverridesStr) {
+    kindOverrides = parseKindOverridesJson(kindOverridesStr);
+  }
+  return {
+    basePricePerByte,
+    kindOverrides
+  };
+}
+function loadPricingConfigFromFile(path) {
+  let fileContent;
+  try {
+    fileContent = readFileSync(path, "utf-8");
+  } catch (error) {
+    throw new PricingError(
+      `Failed to read config file: ${error instanceof Error ? error.message : "Unknown error"}`,
+      "CONFIG_FILE_ERROR"
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(fileContent);
+  } catch {
+    throw new PricingError(
+      `Invalid JSON in config file: ${path}`,
+      "INVALID_FILE_CONFIG"
+    );
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new PricingError(
+      `Config file must contain a JSON object`,
+      "INVALID_FILE_CONFIG"
+    );
+  }
+  const config = parsed;
+  const basePriceStr = config["basePricePerByte"];
+  if (typeof basePriceStr !== "string" && typeof basePriceStr !== "number") {
+    throw new PricingError(
+      `Config file must contain "basePricePerByte" as string or number`,
+      "INVALID_FILE_CONFIG"
+    );
+  }
+  let basePricePerByte;
+  try {
+    basePricePerByte = BigInt(basePriceStr);
+  } catch {
+    throw new PricingError(
+      `Invalid basePricePerByte: "${basePriceStr}" is not a valid integer`,
+      "INVALID_FILE_CONFIG"
+    );
+  }
+  if (basePricePerByte < 0n) {
+    throw new PricingError(
+      `basePricePerByte must be non-negative`,
+      "INVALID_FILE_CONFIG"
+    );
+  }
+  let kindOverrides;
+  const kindOverridesValue = config["kindOverrides"];
+  if (kindOverridesValue !== void 0) {
+    if (typeof kindOverridesValue !== "object" || kindOverridesValue === null) {
+      throw new PricingError(
+        `kindOverrides must be an object`,
+        "INVALID_FILE_CONFIG"
+      );
+    }
+    kindOverrides = /* @__PURE__ */ new Map();
+    const overridesObj = kindOverridesValue;
+    for (const [kindStr, priceValue] of Object.entries(overridesObj)) {
+      const kind = parseInt(kindStr, 10);
+      if (isNaN(kind)) {
+        throw new PricingError(
+          `Invalid kind in kindOverrides: "${kindStr}" is not a valid integer`,
+          "INVALID_FILE_CONFIG"
+        );
+      }
+      if (typeof priceValue !== "string" && typeof priceValue !== "number") {
+        throw new PricingError(
+          `Invalid price for kind ${kind}: must be string or number`,
+          "INVALID_FILE_CONFIG"
+        );
+      }
+      let price;
+      try {
+        price = BigInt(priceValue);
+      } catch {
+        throw new PricingError(
+          `Invalid price for kind ${kind}: "${priceValue}" is not a valid integer`,
+          "INVALID_FILE_CONFIG"
+        );
+      }
+      if (price < 0n) {
+        throw new PricingError(
+          `Price for kind ${kind} must be non-negative`,
+          "INVALID_FILE_CONFIG"
+        );
+      }
+      kindOverrides.set(kind, price);
+    }
+  }
+  return {
+    basePricePerByte,
+    kindOverrides
+  };
+}
+function parseKindOverridesJson(jsonStr) {
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonStr);
+  } catch {
+    throw new PricingError(
+      `Invalid JSON in RELAY_KIND_OVERRIDES: ${jsonStr}`,
+      "INVALID_ENV_CONFIG"
+    );
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new PricingError(
+      `RELAY_KIND_OVERRIDES must be a JSON object`,
+      "INVALID_ENV_CONFIG"
+    );
+  }
+  const result = /* @__PURE__ */ new Map();
+  const obj = parsed;
+  for (const [kindStr, priceValue] of Object.entries(obj)) {
+    const kind = parseInt(kindStr, 10);
+    if (isNaN(kind)) {
+      throw new PricingError(
+        `Invalid kind in RELAY_KIND_OVERRIDES: "${kindStr}" is not a valid integer`,
+        "INVALID_ENV_CONFIG"
+      );
+    }
+    if (typeof priceValue !== "string" && typeof priceValue !== "number") {
+      throw new PricingError(
+        `Invalid price for kind ${kind} in RELAY_KIND_OVERRIDES: must be string or number`,
+        "INVALID_ENV_CONFIG"
+      );
+    }
+    let price;
+    try {
+      price = BigInt(priceValue);
+    } catch {
+      throw new PricingError(
+        `Invalid price for kind ${kind} in RELAY_KIND_OVERRIDES: "${priceValue}" is not a valid integer`,
+        "INVALID_ENV_CONFIG"
+      );
+    }
+    if (price < 0n) {
+      throw new PricingError(
+        `Price for kind ${kind} in RELAY_KIND_OVERRIDES must be non-negative`,
+        "INVALID_ENV_CONFIG"
+      );
+    }
+    result.set(kind, price);
+  }
+  return result;
+}
+
+// src/subscriber/RelaySubscriber.ts
+import { SimplePool } from "nostr-tools/pool";
+import { verifyEvent as verifyEvent2 } 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 && !verifyEvent2(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/index.ts
+var VERSION = "0.1.0";
+export {
+  BlsError,
+  BusinessLogicServer,
+  ConnectionHandler,
+  DEFAULT_RELAY_CONFIG,
+  ILP_ERROR_CODES,
+  InMemoryEventStore,
+  NostrRelayServer,
+  PricingError,
+  PricingService,
+  RelayError,
+  RelaySubscriber,
+  SqliteEventStore,
+  ToonDecodeError,
+  ToonEncodeError,
+  VERSION,
+  decodeEventFromToon,
+  encodeEventToToon,
+  generateFulfillment,
+  isValidPubkey,
+  loadPricingConfigFromEnv,
+  loadPricingConfigFromFile,
+  matchFilter
+};
+//# sourceMappingURL=index.js.map