@toon-protocol/relay 1.3.1 → 1.3.2

package/dist/chunk-4RYYKZXO.js

@@ -0,0 +1,2033 @@
+// src/types.ts
+var DEFAULT_RELAY_CONFIG = {
+  port: 7e3,
+  host: "0.0.0.0",
+  maxConnections: 100,
+  maxSubscriptionsPerConnection: 20,
+  maxFiltersPerSubscription: 10,
+  databasePath: ":memory:"
+};
+
+// src/filters/matchFilter.ts
+function matchFilter(event, filter) {
+  if (Object.keys(filter).length === 0) {
+    return true;
+  }
+  if (filter.ids !== void 0 && filter.ids.length > 0) {
+    const matches = filter.ids.some((id) => event.id.startsWith(id));
+    if (!matches) return false;
+  }
+  if (filter.authors !== void 0 && filter.authors.length > 0) {
+    const matches = filter.authors.some(
+      (author) => event.pubkey.startsWith(author)
+    );
+    if (!matches) return false;
+  }
+  if (filter.kinds !== void 0 && filter.kinds.length > 0) {
+    if (!filter.kinds.includes(event.kind)) return false;
+  }
+  if (filter.since !== void 0) {
+    if (event.created_at < filter.since) return false;
+  }
+  if (filter.until !== void 0) {
+    if (event.created_at > filter.until) return false;
+  }
+  for (const key of Object.keys(filter)) {
+    if (key.startsWith("#") && key.length === 2) {
+      const tagName = key.slice(1);
+      const filterValues = filter[key];
+      if (filterValues !== void 0 && filterValues.length > 0) {
+        const eventTagValues = event.tags.filter((tag) => tag[0] === tagName).map((tag) => tag[1]);
+        const hasMatch = filterValues.some((v) => eventTagValues.includes(v));
+        if (!hasMatch) return false;
+      }
+    }
+  }
+  return true;
+}
+
+// src/storage/InMemoryEventStore.ts
+var InMemoryEventStore = class {
+  events = /* @__PURE__ */ new Map();
+  store(event) {
+    this.events.set(event.id, event);
+  }
+  get(id) {
+    return this.events.get(id);
+  }
+  query(filters) {
+    const allEvents = Array.from(this.events.values());
+    if (filters.length === 0) {
+      return allEvents.sort((a, b) => b.created_at - a.created_at);
+    }
+    const matchingEvents = [];
+    for (const event of allEvents) {
+      for (const filter of filters) {
+        if (matchFilter(event, filter)) {
+          matchingEvents.push(event);
+          break;
+        }
+      }
+    }
+    matchingEvents.sort((a, b) => b.created_at - a.created_at);
+    const limitFilter = filters.find((f) => f.limit !== void 0);
+    if (limitFilter?.limit !== void 0) {
+      return matchingEvents.slice(0, limitFilter.limit);
+    }
+    return matchingEvents;
+  }
+  /**
+   * Close the storage backend (no-op for in-memory store).
+   */
+  close() {
+  }
+};
+
+// src/storage/SqliteEventStore.ts
+import Database from "better-sqlite3";
+var SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS events (
+  id TEXT PRIMARY KEY,
+  pubkey TEXT NOT NULL,
+  kind INTEGER NOT NULL,
+  content TEXT NOT NULL,
+  tags TEXT NOT NULL,
+  created_at INTEGER NOT NULL,
+  sig TEXT NOT NULL,
+  received_at INTEGER NOT NULL
+)
+`;
+var INDEX_SQL = [
+  "CREATE INDEX IF NOT EXISTS idx_events_pubkey ON events(pubkey)",
+  "CREATE INDEX IF NOT EXISTS idx_events_kind ON events(kind)",
+  "CREATE INDEX IF NOT EXISTS idx_events_created_at ON events(created_at)",
+  "CREATE INDEX IF NOT EXISTS idx_events_pubkey_kind ON events(pubkey, kind)"
+];
+function initializeSchema(db) {
+  db.exec(SCHEMA_SQL);
+  for (const indexSql of INDEX_SQL) {
+    db.exec(indexSql);
+  }
+}
+var RelayError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "RelayError";
+  }
+  code;
+};
+function isReplaceableKind(kind) {
+  return kind >= 1e4 && kind <= 19999 && !(kind >= 10032 && kind <= 10099);
+}
+function isParameterizedReplaceableKind(kind) {
+  return kind >= 3e4 && kind <= 39999 || kind >= 10032 && kind <= 10099;
+}
+function getDTagValue(tags) {
+  const dTag = tags.find((tag) => tag[0] === "d");
+  return dTag?.[1] ?? "";
+}
+var SqliteEventStore = class {
+  db;
+  insertStmt;
+  getStmt;
+  deleteByPubkeyKindStmt;
+  deleteByPubkeyKindDTagStmt;
+  getByPubkeyKindStmt;
+  getByPubkeyKindDTagStmt;
+  /**
+   * Create a new SqliteEventStore.
+   * @param dbPath - Path to the database file. Use ':memory:' for in-memory database.
+   */
+  constructor(dbPath = ":memory:") {
+    try {
+      this.db = new Database(dbPath);
+      initializeSchema(this.db);
+      this.insertStmt = this.db.prepare(`
+        INSERT OR REPLACE INTO events (id, pubkey, kind, content, tags, created_at, sig, received_at)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+      this.getStmt = this.db.prepare("SELECT * FROM events WHERE id = ?");
+      this.deleteByPubkeyKindStmt = this.db.prepare(
+        "DELETE FROM events WHERE pubkey = ? AND kind = ?"
+      );
+      this.deleteByPubkeyKindDTagStmt = this.db.prepare(
+        "DELETE FROM events WHERE pubkey = ? AND kind = ? AND json_extract(tags, '$') LIKE ?"
+      );
+      this.getByPubkeyKindStmt = this.db.prepare(
+        "SELECT id, created_at FROM events WHERE pubkey = ? AND kind = ?"
+      );
+      this.getByPubkeyKindDTagStmt = this.db.prepare(
+        "SELECT id, created_at FROM events WHERE pubkey = ? AND kind = ? AND tags LIKE ?"
+      );
+    } catch (error) {
+      throw new RelayError(
+        `Failed to initialize database: ${error instanceof Error ? error.message : String(error)}`,
+        "STORAGE_ERROR"
+      );
+    }
+  }
+  /**
+   * Store an event in the database.
+   * Handles replaceable and parameterized replaceable events according to NIP-01.
+   */
+  store(event) {
+    try {
+      const tagsJson = JSON.stringify(event.tags);
+      const receivedAt = Math.floor(Date.now() / 1e3);
+      if (isReplaceableKind(event.kind)) {
+        this.storeReplaceableEvent(event, tagsJson, receivedAt);
+      } else if (isParameterizedReplaceableKind(event.kind)) {
+        this.storeParameterizedReplaceableEvent(event, tagsJson, receivedAt);
+      } else {
+        const insertOrIgnore = this.db.prepare(`
+          INSERT OR IGNORE INTO events (id, pubkey, kind, content, tags, created_at, sig, received_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        `);
+        insertOrIgnore.run(
+          event.id,
+          event.pubkey,
+          event.kind,
+          event.content,
+          tagsJson,
+          event.created_at,
+          event.sig,
+          receivedAt
+        );
+      }
+    } catch (error) {
+      if (error instanceof RelayError) {
+        throw error;
+      }
+      throw new RelayError(
+        `Failed to store event: ${error instanceof Error ? error.message : String(error)}`,
+        "STORAGE_ERROR"
+      );
+    }
+  }
+  /**
+   * Store a replaceable event (kinds 10000-19999).
+   * Only keeps the latest event per pubkey+kind.
+   */
+  storeReplaceableEvent(event, tagsJson, receivedAt) {
+    const existing = this.getByPubkeyKindStmt.get(event.pubkey, event.kind);
+    if (existing) {
+      if (event.created_at > existing.created_at || event.created_at === existing.created_at && event.id < existing.id) {
+        const transaction = this.db.transaction(() => {
+          this.deleteByPubkeyKindStmt.run(event.pubkey, event.kind);
+          this.insertStmt.run(
+            event.id,
+            event.pubkey,
+            event.kind,
+            event.content,
+            tagsJson,
+            event.created_at,
+            event.sig,
+            receivedAt
+          );
+        });
+        transaction();
+      }
+    } else {
+      this.insertStmt.run(
+        event.id,
+        event.pubkey,
+        event.kind,
+        event.content,
+        tagsJson,
+        event.created_at,
+        event.sig,
+        receivedAt
+      );
+    }
+  }
+  /**
+   * Store a parameterized replaceable event (kinds 30000-39999).
+   * Only keeps the latest event per pubkey+kind+d-tag.
+   */
+  storeParameterizedReplaceableEvent(event, tagsJson, receivedAt) {
+    const dTagValue = getDTagValue(event.tags);
+    let existing;
+    if (dTagValue === "") {
+      const candidates = this.db.prepare(
+        "SELECT id, created_at, tags FROM events WHERE pubkey = ? AND kind = ?"
+      ).all(event.pubkey, event.kind);
+      for (const candidate of candidates) {
+        const candidateTags = JSON.parse(candidate.tags);
+        const candidateDTagValue = getDTagValue(candidateTags);
+        if (candidateDTagValue === "") {
+          existing = { id: candidate.id, created_at: candidate.created_at };
+          break;
+        }
+      }
+    } else {
+      const dTagPattern = `%["d","${dTagValue}"%`;
+      existing = this.getByPubkeyKindDTagStmt.get(
+        event.pubkey,
+        event.kind,
+        dTagPattern
+      );
+    }
+    if (existing) {
+      if (event.created_at > existing.created_at || event.created_at === existing.created_at && event.id < existing.id) {
+        const transaction = this.db.transaction(() => {
+          this.db.prepare("DELETE FROM events WHERE id = ?").run(existing.id);
+          this.insertStmt.run(
+            event.id,
+            event.pubkey,
+            event.kind,
+            event.content,
+            tagsJson,
+            event.created_at,
+            event.sig,
+            receivedAt
+          );
+        });
+        transaction();
+      }
+    } else {
+      this.insertStmt.run(
+        event.id,
+        event.pubkey,
+        event.kind,
+        event.content,
+        tagsJson,
+        event.created_at,
+        event.sig,
+        receivedAt
+      );
+    }
+  }
+  /**
+   * Retrieve an event by its ID.
+   */
+  get(id) {
+    try {
+      const row = this.getStmt.get(id);
+      if (!row) {
+        return void 0;
+      }
+      return {
+        id: row.id,
+        pubkey: row.pubkey,
+        kind: row.kind,
+        content: row.content,
+        tags: JSON.parse(row.tags),
+        created_at: row.created_at,
+        sig: row.sig
+      };
+    } catch (error) {
+      throw new RelayError(
+        `Failed to get event: ${error instanceof Error ? error.message : String(error)}`,
+        "STORAGE_ERROR"
+      );
+    }
+  }
+  /**
+   * Query events matching any of the provided filters.
+   */
+  query(filters) {
+    try {
+      const { sql, params } = this.buildQuerySql(filters);
+      const stmt = this.db.prepare(sql);
+      const rows = stmt.all(...params);
+      return rows.map((row) => ({
+        id: row.id,
+        pubkey: row.pubkey,
+        kind: row.kind,
+        content: row.content,
+        tags: JSON.parse(row.tags),
+        created_at: row.created_at,
+        sig: row.sig
+      }));
+    } catch (error) {
+      throw new RelayError(
+        `Failed to query events: ${error instanceof Error ? error.message : String(error)}`,
+        "STORAGE_ERROR"
+      );
+    }
+  }
+  /**
+   * Build SQL query from filters.
+   */
+  buildQuerySql(filters) {
+    if (filters.length === 0) {
+      return {
+        sql: "SELECT * FROM events ORDER BY created_at DESC",
+        params: []
+      };
+    }
+    const conditions = [];
+    const params = [];
+    for (const filter of filters) {
+      const filterConditions = [];
+      if (filter.ids?.length) {
+        const idConditions = filter.ids.map(() => "id LIKE ?");
+        filterConditions.push(`(${idConditions.join(" OR ")})`);
+        params.push(...filter.ids.map((id) => `${id}%`));
+      }
+      if (filter.authors?.length) {
+        const authorConditions = filter.authors.map(() => "pubkey LIKE ?");
+        filterConditions.push(`(${authorConditions.join(" OR ")})`);
+        params.push(...filter.authors.map((a) => `${a}%`));
+      }
+      if (filter.kinds?.length) {
+        filterConditions.push(
+          `kind IN (${filter.kinds.map(() => "?").join(", ")})`
+        );
+        params.push(...filter.kinds);
+      }
+      if (filter.since !== void 0) {
+        filterConditions.push("created_at >= ?");
+        params.push(filter.since);
+      }
+      if (filter.until !== void 0) {
+        filterConditions.push("created_at <= ?");
+        params.push(filter.until);
+      }
+      for (const [key, values] of Object.entries(filter)) {
+        if (key.startsWith("#") && Array.isArray(values) && values.length > 0) {
+          const tagName = key.slice(1);
+          const tagConditions = values.map(() => `tags LIKE ?`);
+          filterConditions.push(`(${tagConditions.join(" OR ")})`);
+          params.push(...values.map((v) => `%["${tagName}","${v}"%`));
+        }
+      }
+      if (filterConditions.length > 0) {
+        conditions.push(`(${filterConditions.join(" AND ")})`);
+      }
+    }
+    let sql = "SELECT * FROM events";
+    if (conditions.length > 0) {
+      sql += ` WHERE ${conditions.join(" OR ")}`;
+    }
+    sql += " ORDER BY created_at DESC";
+    const limitFilter = filters.find((f) => f.limit !== void 0);
+    if (limitFilter?.limit !== void 0) {
+      sql += " LIMIT ?";
+      params.push(limitFilter.limit);
+    }
+    return { sql, params };
+  }
+  /**
+   * Close the database connection.
+   */
+  close() {
+    this.db.close();
+  }
+};
+
+// src/toon/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 };
+  }
+  ws;
+  eventStore;
+  subscriptions = /* @__PURE__ */ new Map();
+  config;
+  /**
+   * Handle an incoming message from the WebSocket.
+   */
+  handleMessage(data) {
+    console.log(`[ConnectionHandler] Received message:`, data.slice(0, 150));
+    let message;
+    try {
+      const parsed = JSON.parse(data);
+      if (!Array.isArray(parsed)) {
+        this.sendNotice("error: invalid message format, expected JSON array");
+        return;
+      }
+      message = parsed;
+    } catch {
+      this.sendNotice("error: invalid JSON");
+      return;
+    }
+    const messageType = message[0];
+    console.log(`[ConnectionHandler] Message type: ${messageType}`);
+    if (messageType === "REQ") {
+      const subscriptionId = message[1];
+      const filters = message.slice(2);
+      this.handleReq(subscriptionId, filters);
+    } else if (messageType === "EVENT") {
+      const event = message[1];
+      this.handleEvent(event);
+    } else if (messageType === "CLOSE") {
+      const subscriptionId = message[1];
+      this.handleClose(subscriptionId);
+    } else {
+      this.sendNotice(`error: unknown message type: ${messageType}`);
+    }
+  }
+  /**
+   * Handle a REQ message to create/update a subscription.
+   */
+  handleReq(subscriptionId, filters) {
+    if (typeof subscriptionId !== "string" || subscriptionId.length === 0) {
+      this.sendNotice("error: invalid subscription id");
+      return;
+    }
+    if (!this.subscriptions.has(subscriptionId)) {
+      if (this.subscriptions.size >= this.config.maxSubscriptionsPerConnection) {
+        this.sendNotice("error: too many subscriptions");
+        return;
+      }
+    }
+    if (filters.length > this.config.maxFiltersPerSubscription) {
+      this.sendNotice("error: too many filters");
+      return;
+    }
+    this.subscriptions.set(subscriptionId, {
+      id: subscriptionId,
+      filters
+    });
+    console.log(
+      `[ConnectionHandler] REQ: ${subscriptionId}, filters:`,
+      JSON.stringify(filters).slice(0, 100)
+    );
+    const events = this.eventStore.query(filters);
+    console.log(
+      `[ConnectionHandler] Query returned ${events.length} events for ${subscriptionId}`
+    );
+    for (const event of events) {
+      console.log(
+        `[ConnectionHandler] Sending event ${event.id.slice(0, 16)}... to ${subscriptionId}`
+      );
+      this.sendEvent(subscriptionId, event);
+    }
+    console.log(`[ConnectionHandler] Sending EOSE for ${subscriptionId}`);
+    this.sendEose(subscriptionId);
+  }
+  /**
+   * Handle an EVENT message from a WebSocket client.
+   *
+   * Rejects all external writes — the relay is ILP-gated (pay to write).
+   * Events are only stored through the ILP packet handler which calls
+   * eventStore.store() directly and then broadcastEvent() to notify subscribers.
+   */
+  handleEvent(event) {
+    this.sendOk(event.id, false, "restricted: writes require ILP payment");
+  }
+  /**
+   * Handle a CLOSE message to terminate a subscription.
+   */
+  handleClose(subscriptionId) {
+    this.subscriptions.delete(subscriptionId);
+  }
+  /**
+   * Push a new event to all matching subscriptions on this connection.
+   * Used when events are stored outside the WebSocket flow (e.g., via ILP).
+   */
+  notifyNewEvent(event) {
+    for (const sub of this.subscriptions.values()) {
+      const matches = sub.filters.some((f) => matchFilter(event, f));
+      if (matches) {
+        this.sendEvent(sub.id, event);
+      }
+    }
+  }
+  /**
+   * Clean up all subscriptions for this connection.
+   */
+  cleanup() {
+    this.subscriptions.clear();
+  }
+  /**
+   * Get the number of active subscriptions.
+   */
+  getSubscriptionCount() {
+    return this.subscriptions.size;
+  }
+  sendEvent(subscriptionId, event) {
+    this.send(["EVENT", subscriptionId, encodeEventToToonString(event)]);
+  }
+  sendEose(subscriptionId) {
+    this.send(["EOSE", subscriptionId]);
+  }
+  sendOk(eventId, success, message) {
+    this.send(["OK", eventId, success, message]);
+  }
+  sendNotice(message) {
+    this.send(["NOTICE", message]);
+  }
+  send(message) {
+    if (this.ws.readyState === 1) {
+      this.ws.send(JSON.stringify(message));
+    }
+  }
+};
+
+// src/websocket/NostrRelayServer.ts
+import { WebSocketServer } from "ws";
+var NostrRelayServer = class {
+  constructor(config = {}, eventStore) {
+    this.eventStore = eventStore;
+    this.config = { ...DEFAULT_RELAY_CONFIG, ...config };
+  }
+  eventStore;
+  wss = null;
+  handlers = /* @__PURE__ */ new Map();
+  config;
+  /**
+   * Start the WebSocket server.
+   */
+  async start() {
+    return new Promise((resolve, reject) => {
+      try {
+        this.wss = new WebSocketServer({
+          port: this.config.port,
+          host: this.config.host
+        });
+        this.wss.on("connection", (ws) => {
+          this.handleConnection(ws);
+        });
+        this.wss.on("error", (error) => {
+          console.error("[NostrRelayServer] Server error:", error.message);
+        });
+        this.wss.on("listening", () => {
+          const address = this.wss?.address();
+          if (address && typeof address === "object") {
+            console.log(`[NostrRelayServer] Listening on port ${address.port}`);
+          }
+          resolve();
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  /**
+   * Stop the WebSocket server and close all connections.
+   */
+  async stop() {
+    return new Promise((resolve) => {
+      if (!this.wss) {
+        resolve();
+        return;
+      }
+      for (const [ws, handler] of this.handlers) {
+        handler.cleanup();
+        ws.close();
+      }
+      this.handlers.clear();
+      this.wss.close(() => {
+        this.wss = null;
+        resolve();
+      });
+    });
+  }
+  /**
+   * Get the port the server is listening on.
+   * Returns 0 if the server is not started.
+   */
+  getPort() {
+    if (!this.wss) return 0;
+    const address = this.wss.address();
+    if (address && typeof address === "object") {
+      return address.port;
+    }
+    return 0;
+  }
+  /**
+   * Get the number of connected clients.
+   */
+  getClientCount() {
+    return this.handlers.size;
+  }
+  /**
+   * Broadcast an event to all connected clients with matching subscriptions.
+   * Call this after storing an event outside the WebSocket flow (e.g., via ILP)
+   * so that discovery subscribers are notified.
+   */
+  broadcastEvent(event) {
+    for (const handler of this.handlers.values()) {
+      handler.notifyNewEvent(event);
+    }
+  }
+  handleConnection(ws) {
+    if (this.handlers.size >= this.config.maxConnections) {
+      ws.close(1013, "max connections reached");
+      return;
+    }
+    console.log("[NostrRelayServer] Client connected");
+    const handler = new ConnectionHandler(ws, this.eventStore, this.config);
+    this.handlers.set(ws, handler);
+    ws.on("message", (data) => {
+      const message = typeof data === "string" ? data : data.toString();
+      handler.handleMessage(message);
+    });
+    ws.on("close", () => {
+      console.log("[NostrRelayServer] Client disconnected");
+      handler.cleanup();
+      this.handlers.delete(ws);
+    });
+    ws.on("error", (error) => {
+      console.error("[NostrRelayServer] Client error:", error.message);
+      handler.cleanup();
+      this.handlers.delete(ws);
+    });
+  }
+};
+
+// src/subscriber/RelaySubscriber.ts
+import { SimplePool } from "nostr-tools/pool";
+import { verifyEvent } from "nostr-tools/pure";
+var RelaySubscriber = class {
+  config;
+  eventStore;
+  pool;
+  started = false;
+  /**
+   * @param config - Subscriber configuration
+   * @param eventStore - Storage backend to write events into
+   * @param pool - Optional SimplePool instance (creates new one if not provided)
+   */
+  constructor(config, eventStore, pool) {
+    this.config = config;
+    this.eventStore = eventStore;
+    this.pool = pool ?? new SimplePool();
+  }
+  /**
+   * Start subscribing to the configured upstream relays.
+   *
+   * @returns Handle with unsubscribe() to stop the subscription
+   * @throws Error if already started
+   */
+  start() {
+    if (this.started) {
+      throw new Error("RelaySubscriber already started");
+    }
+    this.started = true;
+    const shouldVerify = this.config.verifySignatures !== false;
+    let isUnsubscribed = false;
+    const subCloser = this.pool.subscribeMany(
+      this.config.relayUrls,
+      this.config.filter,
+      {
+        onevent: (event) => {
+          if (isUnsubscribed) return;
+          if (shouldVerify && !verifyEvent(event)) {
+            return;
+          }
+          try {
+            this.eventStore.store(event);
+          } catch (error) {
+            console.warn(
+              "[RelaySubscriber] Failed to store event:",
+              error instanceof Error ? error.message : "Unknown error"
+            );
+          }
+        }
+      }
+    );
+    return {
+      unsubscribe: () => {
+        if (!isUnsubscribed) {
+          isUnsubscribed = true;
+          subCloser.close();
+          this.started = false;
+        }
+      }
+    };
+  }
+};
+
+// src/launcher/handlers/event-storage-handler.ts
+function createEventStorageHandler(config) {
+  const { eventStore } = config;
+  return async (ctx) => {
+    const event = ctx.decode();
+    eventStore.store(event);
+    return ctx.accept({ eventId: event.id, storedAt: Date.now() });
+  };
+}
+
+// src/launcher/handlers/x402-pricing.ts
+function calculateX402Price(config, toonLength) {
+  const clampedBuffer = Math.max(0, Math.min(200, config.routingBufferPercent));
+  const basePrice = config.basePricePerByte * BigInt(toonLength);
+  const buffer = basePrice * BigInt(clampedBuffer) / 100n;
+  return basePrice + buffer;
+}
+
+// src/launcher/handlers/x402-types.ts
+var EIP_3009_TYPES = {
+  TransferWithAuthorization: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "bytes32" }
+  ]
+};
+var USDC_EIP712_DOMAIN = {
+  name: "USD Coin",
+  version: "2"
+};
+var USDC_ABI = [
+  {
+    name: "balanceOf",
+    type: "function",
+    stateMutability: "view",
+    inputs: [{ name: "account", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "authorizationState",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "authorizer", type: "address" },
+      { name: "nonce", type: "bytes32" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  },
+  {
+    name: "transferWithAuthorization",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "validAfter", type: "uint256" },
+      { name: "validBefore", type: "uint256" },
+      { name: "nonce", type: "bytes32" },
+      { name: "v", type: "uint8" },
+      { name: "r", type: "bytes32" },
+      { name: "s", type: "bytes32" }
+    ],
+    outputs: []
+  }
+];
+
+// src/launcher/handlers/x402-preflight.ts
+import { verifyTypedData } from "viem";
+import { shallowParseToon } from "@toon-protocol/core/toon";
+async function runPreflight(authorization, toonData, destination, config) {
+  const checksPerformed = [];
+  checksPerformed.push("eip3009-signature");
+  try {
+    const domain = {
+      ...USDC_EIP712_DOMAIN,
+      chainId: config.chainConfig.chainId,
+      verifyingContract: config.chainConfig.usdcAddress
+    };
+    const valid = await verifyTypedData({
+      address: authorization.from,
+      domain,
+      types: EIP_3009_TYPES,
+      primaryType: "TransferWithAuthorization",
+      message: {
+        from: authorization.from,
+        to: authorization.to,
+        value: authorization.value,
+        validAfter: BigInt(authorization.validAfter),
+        validBefore: BigInt(authorization.validBefore),
+        nonce: authorization.nonce
+      },
+      signature: encodeSignature(authorization)
+    });
+    if (!valid) {
+      return {
+        passed: false,
+        failedCheck: "eip3009-signature",
+        checksPerformed
+      };
+    }
+  } catch {
+    return { passed: false, failedCheck: "eip3009-signature", checksPerformed };
+  }
+  checksPerformed.push("usdc-balance");
+  if (config.publicClient) {
+    try {
+      const balance = await config.publicClient.readContract({
+        address: config.chainConfig.usdcAddress,
+        abi: USDC_ABI,
+        functionName: "balanceOf",
+        args: [authorization.from]
+      });
+      if (balance < authorization.value) {
+        return { passed: false, failedCheck: "usdc-balance", checksPerformed };
+      }
+    } catch {
+      return { passed: false, failedCheck: "usdc-balance", checksPerformed };
+    }
+  }
+  checksPerformed.push("nonce-freshness");
+  if (config.publicClient) {
+    try {
+      const used = await config.publicClient.readContract({
+        address: config.chainConfig.usdcAddress,
+        abi: USDC_ABI,
+        functionName: "authorizationState",
+        args: [
+          authorization.from,
+          authorization.nonce
+        ]
+      });
+      if (used) {
+        return {
+          passed: false,
+          failedCheck: "nonce-freshness",
+          checksPerformed
+        };
+      }
+    } catch {
+      return { passed: false, failedCheck: "nonce-freshness", checksPerformed };
+    }
+  }
+  checksPerformed.push("toon-shallow-parse");
+  let toonMeta;
+  try {
+    const toonBytes = Buffer.from(toonData, "base64");
+    toonMeta = shallowParseToon(toonBytes);
+  } catch {
+    return {
+      passed: false,
+      failedCheck: "toon-shallow-parse",
+      checksPerformed
+    };
+  }
+  checksPerformed.push("schnorr-signature");
+  if (!config.devMode && config.schnorrVerify) {
+    try {
+      const valid = await config.schnorrVerify(toonMeta);
+      if (!valid) {
+        return {
+          passed: false,
+          failedCheck: "schnorr-signature",
+          checksPerformed
+        };
+      }
+    } catch {
+      return {
+        passed: false,
+        failedCheck: "schnorr-signature",
+        checksPerformed
+      };
+    }
+  }
+  checksPerformed.push("destination-reachability");
+  if (config.eventStore) {
+    try {
+      const events = config.eventStore.query([{ kinds: [10032] }]);
+      if (events.length === 0) {
+        return {
+          passed: false,
+          failedCheck: "destination-reachability",
+          checksPerformed
+        };
+      }
+    } catch {
+      return {
+        passed: false,
+        failedCheck: "destination-reachability",
+        checksPerformed
+      };
+    }
+  }
+  return { passed: true, checksPerformed };
+}
+function encodeSignature(auth) {
+  const r = auth.r.startsWith("0x") ? auth.r.slice(2) : auth.r;
+  const s = auth.s.startsWith("0x") ? auth.s.slice(2) : auth.s;
+  const v = auth.v.toString(16).padStart(2, "0");
+  return `0x${r}${s}${v}`;
+}
+
+// src/launcher/handlers/x402-settlement.ts
+async function settleEip3009(authorization, config) {
+  try {
+    const hash = await config.walletClient.writeContract({
+      address: config.chainConfig.usdcAddress,
+      abi: USDC_ABI,
+      functionName: "transferWithAuthorization",
+      args: [
+        authorization.from,
+        authorization.to,
+        authorization.value,
+        BigInt(authorization.validAfter),
+        BigInt(authorization.validBefore),
+        authorization.nonce,
+        authorization.v,
+        authorization.r,
+        authorization.s
+      ],
+      chain: null,
+      // Use the wallet client's configured chain
+      account: config.walletClient.account ?? null
+    });
+    if (config.publicClient) {
+      const receipt = await config.publicClient.waitForTransactionReceipt({
+        hash
+      });
+      if (receipt.status === "reverted") {
+        return {
+          success: false,
+          error: "Transaction reverted on-chain"
+        };
+      }
+    }
+    return {
+      success: true,
+      txHash: hash
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown settlement error";
+    return {
+      success: false,
+      error: message
+    };
+  }
+}
+
+// src/launcher/handlers/x402-publish-handler.ts
+import { buildIlpPrepare, encodeEventToToon as encodeEventToToon2 } from "@toon-protocol/core";
+function createX402Handler(config) {
+  const encoder = config.toonEncoder ?? encodeEventToToon2;
+  if (config.x402Enabled && (!config.facilitatorAddress || !/^0x[0-9a-fA-F]{40}$/.test(config.facilitatorAddress))) {
+    throw new Error(
+      "x402 enabled but facilitatorAddress is not a valid EVM address"
+    );
+  }
+  return {
+    async handlePublish(c) {
+      if (!config.x402Enabled) {
+        return c.json({ error: "x402 not enabled" }, 404);
+      }
+      let body;
+      try {
+        body = await c.req.json();
+      } catch {
+        return c.json({ error: "Invalid request body" }, 400);
+      }
+      if (!body.event || !body.destination) {
+        return c.json(
+          { error: "Missing required fields: event, destination" },
+          400
+        );
+      }
+      if (typeof body.destination !== "string" || !body.destination.startsWith("g.")) {
+        return c.json(
+          { error: "Invalid destination: must be a global ILP address (g.*)" },
+          400
+        );
+      }
+      let toonBytes;
+      try {
+        toonBytes = encoder(body.event);
+      } catch {
+        return c.json({ error: "Failed to TOON-encode event" }, 400);
+      }
+      const toonBase64 = Buffer.from(toonBytes).toString("base64");
+      const paymentHeader = c.req.header("X-PAYMENT");
+      if (!paymentHeader) {
+        const price = calculateX402Price(
+          {
+            basePricePerByte: config.basePricePerByte,
+            routingBufferPercent: config.routingBufferPercent
+          },
+          toonBytes.length
+        );
+        const pricing = {
+          amount: String(price),
+          facilitatorAddress: config.facilitatorAddress,
+          paymentNetwork: "eip-3009",
+          chainId: config.chainConfig.chainId,
+          usdcAddress: config.chainConfig.usdcAddress
+        };
+        return c.json(pricing, 402);
+      }
+      let authorization;
+      try {
+        const parsed = JSON.parse(paymentHeader);
+        authorization = parseAuthorization(parsed);
+      } catch {
+        return c.json({ error: "Invalid X-PAYMENT header" }, 400);
+      }
+      const preflightConfig = {
+        chainConfig: config.chainConfig,
+        basePricePerByte: config.basePricePerByte,
+        ownPubkey: config.ownPubkey,
+        devMode: config.devMode,
+        publicClient: config.publicClient,
+        eventStore: config.eventStore
+      };
+      try {
+        const preflightFn = config.runPreflightFn ?? runPreflight;
+        const preflightResult = await preflightFn(
+          authorization,
+          toonBase64,
+          body.destination,
+          preflightConfig
+        );
+        if (!preflightResult.passed) {
+          return c.json(
+            {
+              error: `Pre-flight check failed: ${preflightResult.failedCheck}`,
+              failedCheck: preflightResult.failedCheck
+            },
+            400
+          );
+        }
+      } catch {
+        console.error("[x402] Pre-flight error");
+        return c.json({ error: "Internal server error" }, 500);
+      }
+      let settlementResult;
+      try {
+        const settleFn = config.settle ?? settleEip3009;
+        if (!config.settle && !config.walletClient) {
+          console.error("[x402] Settlement error: walletClient not configured");
+          return c.json({ error: "Internal server error" }, 500);
+        }
+        const settlementConfig = {
+          chainConfig: config.chainConfig,
+          walletClient: config.walletClient,
+          publicClient: config.publicClient
+        };
+        settlementResult = await settleFn(authorization, settlementConfig);
+      } catch {
+        console.error("[x402] Settlement error");
+        return c.json({ error: "Internal server error" }, 500);
+      }
+      if (!settlementResult.success) {
+        console.error(
+          "[x402] Settlement failed:",
+          settlementResult.error ?? "unknown"
+        );
+        return c.json({ error: "Settlement failed" }, 400);
+      }
+      const amount = config.basePricePerByte * BigInt(toonBytes.length);
+      const prepareParams = {
+        destination: body.destination,
+        amount,
+        data: toonBytes
+      };
+      const prepare = buildIlpPrepare(prepareParams);
+      let deliveryStatus = "rejected";
+      if (config.ilpClient) {
+        try {
+          const ilpResult = await config.ilpClient.sendIlpPacket(prepare);
+          deliveryStatus = ilpResult.accepted ? "fulfilled" : "rejected";
+        } catch {
+          deliveryStatus = "rejected";
+        }
+      }
+      const response = {
+        eventId: body.event.id,
+        settlementTxHash: settlementResult.txHash ?? "",
+        deliveryStatus,
+        refundInitiated: false
+      };
+      return c.json(response, 200);
+    }
+  };
+}
+function isValidHex(value, expectedLength) {
+  if (value.length !== expectedLength) return false;
+  if (!value.startsWith("0x")) return false;
+  return /^0x[0-9a-fA-F]+$/.test(value);
+}
+function parseAuthorization(parsed) {
+  if (typeof parsed !== "object" || parsed === null) {
+    throw new Error("Authorization must be an object");
+  }
+  const obj = parsed;
+  const from = obj["from"];
+  const to = obj["to"];
+  const value = obj["value"];
+  const validAfter = obj["validAfter"];
+  const validBefore = obj["validBefore"];
+  const nonce = obj["nonce"];
+  const v = obj["v"];
+  const r = obj["r"];
+  const s = obj["s"];
+  if (typeof from !== "string" || !isValidHex(from, 42)) {
+    throw new Error("Invalid from address");
+  }
+  if (typeof to !== "string" || !isValidHex(to, 42)) {
+    throw new Error("Invalid to address");
+  }
+  if (typeof nonce !== "string" || !isValidHex(nonce, 66)) {
+    throw new Error("Invalid nonce");
+  }
+  if (typeof r !== "string" || !isValidHex(r, 66)) {
+    throw new Error("Invalid r");
+  }
+  if (typeof s !== "string" || !isValidHex(s, 66)) {
+    throw new Error("Invalid s");
+  }
+  if (typeof v !== "number" || v !== 27 && v !== 28) {
+    throw new Error("Invalid v");
+  }
+  const parsedValidAfter = Number(validAfter);
+  const parsedValidBefore = Number(validBefore);
+  if (Number.isNaN(parsedValidAfter) || parsedValidAfter < 0) {
+    throw new Error("Invalid validAfter");
+  }
+  if (Number.isNaN(parsedValidBefore) || parsedValidBefore < 0) {
+    throw new Error("Invalid validBefore");
+  }
+  const valueStr = String(value);
+  let valueBigInt;
+  try {
+    valueBigInt = BigInt(valueStr);
+  } catch {
+    throw new Error("Invalid value");
+  }
+  if (valueBigInt < 0n) {
+    throw new Error("Invalid value: must be non-negative");
+  }
+  return {
+    from,
+    to,
+    value: valueBigInt,
+    validAfter: parsedValidAfter,
+    validBefore: parsedValidBefore,
+    nonce,
+    v,
+    r,
+    s
+  };
+}
+
+// src/launcher/health.ts
+import { VERSION } from "@toon-protocol/core";
+function createHealthResponse(config) {
+  const response = {
+    status: "healthy",
+    phase: config.phase,
+    pubkey: config.pubkey,
+    ilpAddress: config.ilpAddress,
+    peerCount: config.peerCount,
+    discoveredPeerCount: config.discoveredPeerCount,
+    channelCount: config.channelCount,
+    pricing: {
+      basePricePerByte: Number(config.basePricePerByte),
+      currency: "USDC"
+    },
+    capabilities: config.x402Enabled ? ["relay", "x402"] : ["relay"],
+    chain: config.chain,
+    version: VERSION,
+    sdk: true,
+    timestamp: Date.now()
+  };
+  if (config.x402Enabled) {
+    response.x402 = {
+      enabled: true,
+      endpoint: "/publish"
+    };
+  }
+  if (config.tee) {
+    response.tee = config.tee;
+  }
+  return response;
+}
+
+// src/launcher/town.ts
+import { mkdirSync } from "fs";
+import { join } from "path";
+import { serve } from "@hono/node-server";
+import { Hono } from "hono";
+import {
+  HandlerRegistry,
+  createVerificationPipeline,
+  createPricingValidator,
+  createHandlerContext,
+  fromMnemonic,
+  fromSecretKey
+} from "@toon-protocol/sdk";
+import {
+  BootstrapService,
+  createDiscoveryTracker,
+  ILP_PEER_INFO_KIND,
+  createDirectIlpClient,
+  createDirectConnectorAdmin,
+  createDirectChannelClient,
+  SocialPeerDiscovery,
+  buildIlpPeerInfoEvent,
+  resolveChainConfig,
+  SeedRelayDiscovery,
+  publishSeedRelayEntry,
+  buildServiceDiscoveryEvent,
+  VERSION as VERSION2
+} from "@toon-protocol/core";
+import {
+  shallowParseToon as shallowParseToon2,
+  decodeEventFromToon as decodeEventFromToon2,
+  encodeEventToToon as encodeEventToToon3
+} from "@toon-protocol/core/toon";
+import {
+  ConnectorNode,
+  createLogger as createConnectorLogger
+} from "@toon-protocol/connector";
+import {
+  createPublicClient,
+  createWalletClient,
+  defineChain,
+  http
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+var MAX_PAYLOAD_BASE64_LENGTH = 1048576;
+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;
+  let _lastSeenTimestamp = 0;
+  void _lastSeenTimestamp;
+  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 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 hasConnector = config.connector !== void 0;
+  const hasConnectorUrl = config.connectorUrl !== void 0;
+  if (hasConnector && hasConnectorUrl) {
+    throw new Error(
+      "RelayConfig: provide either connector or connectorUrl, not both"
+    );
+  }
+  if (hasConnectorUrl && config.ilpAddress === void 0) {
+    throw new Error(
+      "RelayConfig: ilpAddress is required when connectorUrl is set (must fall under the parent connector prefix, e.g. g.townhouse.<self>)"
+    );
+  }
+  const identity = hasMnemonic ? fromMnemonic(config.mnemonic) : fromSecretKey(config.secretKey);
+  const relayPort = config.relayPort ?? 7100;
+  const blsPort = config.blsPort ?? 3100;
+  const pubkeyShort = identity.pubkey.slice(0, 16);
+  const ilpAddress = config.ilpAddress ?? `g.toon.${pubkeyShort}`;
+  const btpEndpoint = config.btpEndpoint ?? "";
+  const nodeId = config.nodeId ?? `toon-${pubkeyShort}`;
+  const parentPeerId = config.parentPeerId ?? "apex";
+  const parentAuthToken = config.parentAuthToken ?? "";
+  const connectorUrl = config.connectorUrl;
+  const basePricePerByte = config.feePerEvent !== void 0 ? BigInt(config.feePerEvent) : config.basePricePerByte ?? 10n;
+  const routingBufferPercent = config.routingBufferPercent ?? 10;
+  const x402Enabled = config.x402Enabled ?? false;
+  const knownPeers = [...config.knownPeers ?? []];
+  const dataDir = config.dataDir ?? "./data";
+  const devMode = config.devMode ?? false;
+  const ardriveEnabled = config.ardriveEnabled ?? false;
+  const relayUrls = config.relayUrls ?? [`ws://localhost:${relayPort}`];
+  const assetCode = config.assetCode ?? "USD";
+  const assetScale = config.assetScale ?? 6;
+  const discovery = config.discovery ?? "genesis";
+  const announcementTtlSeconds = (() => {
+    const fromEnv = process.env["TOON_ANNOUNCEMENT_TTL_SECONDS"];
+    const raw = fromEnv !== void 0 && fromEnv !== "" ? Number(fromEnv) : config.announcementTtlSeconds;
+    if (raw === void 0) return 3600;
+    if (!Number.isFinite(raw) || raw < 0) return 3600;
+    return Math.floor(raw);
+  })();
+  const seedRelays = config.seedRelays ?? [];
+  const publishSeedEntryFlag = config.publishSeedEntry ?? false;
+  const externalRelayUrl = config.externalRelayUrl ?? (config.ator?.enabled && config.ator.anonAddress ? config.ator.anonAddress : void 0);
+  const requestedChain = process.env["TOON_CHAIN"] || config.chain;
+  const relayOnly = requestedChain === "none";
+  if (relayOnly) {
+    console.log("[Town] connector.relay_only", {
+      reason: "no settlement chain configured (chain=none)"
+    });
+  }
+  const chainConfig = relayOnly ? {
+    name: "none",
+    chainId: 0,
+    rpcUrl: "",
+    usdcAddress: "",
+    tokenNetworkAddress: "",
+    registryAddress: ""
+  } : resolveChainConfig(config.chain);
+  const chainKey = `evm:base:${chainConfig.chainId}`;
+  const resolvedConfig = {
+    relayPort,
+    blsPort,
+    ilpAddress,
+    btpEndpoint,
+    nodeId,
+    ...connectorUrl && { connectorUrl, parentPeerId },
+    basePricePerByte,
+    routingBufferPercent,
+    x402Enabled,
+    knownPeers,
+    dataDir,
+    devMode,
+    ardriveEnabled,
+    relayUrls,
+    assetCode,
+    assetScale,
+    discovery,
+    seedRelays,
+    publishSeedEntry: publishSeedEntryFlag,
+    ...externalRelayUrl && { externalRelayUrl },
+    chain: chainConfig.name
+  };
+  let autoCreatedConnector = null;
+  if (!hasConnector) {
+    const btpServerPort = config.btpServerPort ?? 3e3;
+    const connectorLogger = createConnectorLogger(
+      nodeId,
+      process.env["TOON_CONNECTOR_LOG_LEVEL"] ?? "warn"
+    );
+    const routes = [{ prefix: ilpAddress, nextHop: nodeId, priority: 100 }];
+    const peers = [];
+    if (hasConnectorUrl) {
+      peers.push({
+        id: parentPeerId,
+        url: connectorUrl,
+        authToken: parentAuthToken,
+        // Tag the upstream as our PARENT so the embedded connector's
+        // relation-aware logic applies (toon-protocol/connector#78): a child
+        // skips the inbound per-packet-claim requirement for PREPAREs forwarded
+        // by its parent (the parent settles in aggregate and attaches no
+        // per-packet claim to a child). Without this the peer defaults to
+        // 'peer' and the child F06-rejects every parent-forwarded paid packet.
+        // NOTE: `parentPeerId` MUST equal the parent connector's nodeId (its BTP
+        // auth identity), since the connector keys peerRelations by the
+        // auth-declared peerId of the inbound session — not a local alias.
+        relation: "parent",
+        // When the operator publishes their EVM treasury address to the
+        // parent, the apex can open a settlement channel toward this child
+        // without needing to discover the address via kind:10032. The
+        // connector schema treats this field as optional metadata.
+        ...config.parentEvmAddress && { evmAddress: config.parentEvmAddress }
+      });
+      routes.push({ prefix: "g", nextHop: parentPeerId, priority: 0 });
+    }
+    const hasSettlementAddresses = !!chainConfig.rpcUrl && !!chainConfig.registryAddress && !!chainConfig.tokenNetworkAddress && !!chainConfig.usdcAddress;
+    let chainProvidersEntry = null;
+    if (hasSettlementAddresses) {
+      const keyHex = config.settlementPrivateKey ?? `0x${Buffer.from(identity.secretKey).toString("hex")}`;
+      if (!/^0x[0-9a-fA-F]{64}$/.test(keyHex)) {
+        throw new Error(
+          `RelayConfig.settlementPrivateKey must be a 0x-prefixed 32-byte hex string (got length ${keyHex.length}); cannot wire chainProviders for ${chainConfig.name}`
+        );
+      }
+      chainProvidersEntry = {
+        chainType: "evm",
+        chainId: `evm:${chainConfig.chainId}`,
+        rpcUrl: chainConfig.rpcUrl,
+        registryAddress: chainConfig.registryAddress,
+        tokenAddress: chainConfig.usdcAddress,
+        keyId: keyHex
+      };
+    } else {
+      console.warn("[Town] connector.chain_providers_skipped", {
+        chain: chainConfig.name,
+        reason: "missing settlement addresses"
+      });
+    }
+    const connectorConfig = {
+      nodeId,
+      btpServerPort,
+      environment: "development",
+      deploymentMode: "embedded",
+      peers,
+      routes,
+      localDelivery: { enabled: false },
+      // Children don't expose an admin API — the apex parent is the
+      // operator-facing surface. Disabling avoids a hard runtime dep on
+      // express in the town docker bundle.
+      adminApi: { enabled: false },
+      // Belt-and-braces: zero connector forwarding fee. Combined with the
+      // packet-handler's automatic skip for local-delivery hops this keeps the
+      // child fee surface flat regardless of peering topology.
+      settlement: {
+        connectorFeePercentage: 0
+      },
+      ...chainProvidersEntry && { chainProviders: [chainProvidersEntry] }
+    };
+    if (config.ator?.enabled && config.ator.anonAddress) {
+      connectorConfig.transport = {
+        type: "socks5",
+        socksProxy: config.ator.socksProxy ?? "socks5h://127.0.0.1:9050",
+        externalUrl: config.ator.anonAddress,
+        managed: false
+      };
+    }
+    autoCreatedConnector = new ConnectorNode(connectorConfig, connectorLogger);
+  }
+  const effectiveConnector = config.connector ?? autoCreatedConnector;
+  mkdirSync(dataDir, { recursive: true });
+  const dbPath = join(dataDir, "events.db");
+  const eventStore = new SqliteEventStore(dbPath);
+  const effectiveChainRpcUrls = config.chainRpcUrls ?? (relayOnly ? void 0 : { [chainKey]: chainConfig.rpcUrl });
+  const effectivePreferredTokens = config.preferredTokens ?? (relayOnly ? void 0 : { [chainKey]: chainConfig.usdcAddress });
+  const effectiveTokenNetworks = config.tokenNetworks ?? (chainConfig.tokenNetworkAddress ? { [chainKey]: chainConfig.tokenNetworkAddress } : void 0);
+  let channelClient;
+  let settlementInfo;
+  const hasSettlement = effectiveChainRpcUrls || effectiveTokenNetworks || effectivePreferredTokens || config.settlementAddresses;
+  if (hasSettlement) {
+    const supportedChains = Array.from(
+      /* @__PURE__ */ new Set([
+        ...Object.keys(effectiveChainRpcUrls ?? {}),
+        ...Object.keys(effectiveTokenNetworks ?? {}),
+        ...Object.keys(effectivePreferredTokens ?? {}),
+        ...Object.keys(config.settlementAddresses ?? {})
+      ])
+    );
+    const settlementAddresses = {};
+    for (const chain of supportedChains) {
+      settlementAddresses[chain] = config.settlementAddresses?.[chain] ?? identity.evmAddress;
+    }
+    settlementInfo = {
+      supportedChains,
+      settlementAddresses,
+      preferredTokens: effectivePreferredTokens,
+      tokenNetworks: effectiveTokenNetworks
+    };
+    if (effectiveConnector.openChannel && effectiveConnector.getChannelState) {
+      channelClient = createDirectChannelClient(
+        effectiveConnector
+      );
+    }
+  }
+  const adminClient = createDirectConnectorAdmin(effectiveConnector);
+  const verifier = createVerificationPipeline({ devMode });
+  const pricer = createPricingValidator({
+    basePricePerByte,
+    ownPubkey: identity.pubkey
+  });
+  const registry = new HandlerRegistry();
+  registry.onDefault(createEventStorageHandler({ eventStore }));
+  const toonDecoder = (toon) => {
+    const bytes = Buffer.from(toon, "base64");
+    return decodeEventFromToon2(bytes);
+  };
+  const handlePacket = async (request) => {
+    if (request.data.length > MAX_PAYLOAD_BASE64_LENGTH) {
+      return { accept: false, code: "F08", message: "Payload too large" };
+    }
+    const toonBytes = Buffer.from(request.data, "base64");
+    let meta;
+    try {
+      meta = shallowParseToon2(toonBytes);
+    } catch {
+      return { accept: false, code: "F06", message: "Invalid TOON payload" };
+    }
+    const verifyResult = await verifier.verify(meta, request.data);
+    if (!verifyResult.verified) {
+      if (verifyResult.rejection) {
+        return verifyResult.rejection;
+      }
+      return { accept: false, code: "F06", message: "Verification failed" };
+    }
+    let amount;
+    try {
+      amount = BigInt(request.amount);
+    } catch {
+      return {
+        accept: false,
+        code: "T00",
+        message: "Invalid payment amount"
+      };
+    }
+    const priceResult = pricer.validate(meta, amount);
+    if (!priceResult.accepted) {
+      if (priceResult.rejection) {
+        return priceResult.rejection;
+      }
+      return {
+        accept: false,
+        code: "F04",
+        message: "Pricing validation failed"
+      };
+    }
+    const ctx = createHandlerContext({
+      toon: request.data,
+      meta,
+      amount,
+      destination: request.destination,
+      toonDecoder
+    });
+    try {
+      const result = await registry.dispatch(ctx);
+      if (result.accept) {
+        try {
+          const event = decodeEventFromToon2(toonBytes);
+          wsRelayRef.current?.broadcastEvent(event);
+        } catch {
+        }
+      }
+      return result;
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : "Unknown error";
+      console.error("[Town] Handler dispatch failed:", errMsg);
+      return { accept: false, code: "T00", message: "Internal error" };
+    }
+  };
+  const bootstrapService = new BootstrapService(
+    {
+      knownPeers,
+      ardriveEnabled,
+      defaultRelayUrl: `ws://localhost:${relayPort}`,
+      ...settlementInfo && { settlementInfo },
+      ownIlpAddress: ilpAddress,
+      toonEncoder: encodeEventToToon3,
+      toonDecoder: decodeEventFromToon2,
+      basePricePerByte
+    },
+    identity.secretKey,
+    {
+      ilpAddress,
+      btpEndpoint,
+      assetCode,
+      assetScale
+    }
+  );
+  let peerCount = 0;
+  let channelCount = 0;
+  const discoveryTrackerRef = {};
+  const wsRelayRef = {};
+  const app = new Hono();
+  app.get("/health", (c) => {
+    const bootstrapPhase = bootstrapService.getPhase();
+    const dt = discoveryTrackerRef.current;
+    return c.json(
+      createHealthResponse({
+        phase: bootstrapPhase,
+        pubkey: identity.pubkey,
+        ilpAddress,
+        peerCount: (dt ? dt.getPeerCount() : 0) + peerCount,
+        discoveredPeerCount: dt ? dt.getDiscoveredCount() : 0,
+        channelCount,
+        basePricePerByte,
+        x402Enabled,
+        chain: chainConfig.name
+      })
+    );
+  });
+  app.post("/handle-packet", async (c) => {
+    try {
+      const body = await c.req.json();
+      if (body.amount === void 0 || body.amount === null || body.destination === void 0 || body.destination === null || body.data === void 0 || body.data === null) {
+        return c.json(
+          { accept: false, code: "F00", message: "Missing required fields" },
+          400
+        );
+      }
+      const result = await handlePacket(body);
+      if (result.accept) {
+        try {
+          const toonBytes = Buffer.from(body.data, "base64");
+          const decoded = decodeEventFromToon2(toonBytes);
+          if (decoded && decoded.kind === ILP_PEER_INFO_KIND) {
+            discoveryTrackerRef.current?.processEvent(decoded);
+          }
+        } catch {
+        }
+      }
+      return c.json(result, result.accept ? 200 : 400);
+    } catch (error) {
+      console.error("[Town] handle-packet error:", error);
+      return c.json(
+        { accept: false, code: "T00", message: "Internal server error" },
+        500
+      );
+    }
+  });
+  const ilpClient = createDirectIlpClient(effectiveConnector, {
+    toonDecoder: (bytes) => decodeEventFromToon2(bytes)
+  });
+  let x402WalletClient;
+  let x402PublicClient;
+  if (x402Enabled) {
+    let keyBuffer;
+    try {
+      keyBuffer = Buffer.from(identity.secretKey);
+      const privateKeyHex = `0x${keyBuffer.toString("hex")}`;
+      const account = privateKeyToAccount(privateKeyHex);
+      const viemChain = defineChain({
+        id: chainConfig.chainId,
+        name: chainConfig.name,
+        nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
+        rpcUrls: { default: { http: [] } }
+      });
+      x402PublicClient = createPublicClient({
+        chain: viemChain,
+        transport: http(chainConfig.rpcUrl)
+      });
+      x402WalletClient = createWalletClient({
+        account,
+        chain: viemChain,
+        transport: http(chainConfig.rpcUrl)
+      });
+    } catch (error) {
+      throw new Error(
+        `x402 initialization failed: could not derive EVM account from identity key: ${error instanceof Error ? error.message : String(error)}`
+      );
+    } finally {
+      if (keyBuffer) {
+        keyBuffer.fill(0);
+      }
+    }
+  }
+  const x402Handler = createX402Handler({
+    x402Enabled,
+    chainConfig,
+    basePricePerByte,
+    routingBufferPercent,
+    facilitatorAddress: config.facilitatorAddress ?? identity.evmAddress,
+    ownPubkey: identity.pubkey,
+    devMode,
+    eventStore,
+    ilpClient,
+    walletClient: x402WalletClient,
+    publicClient: x402PublicClient
+  });
+  app.get("/publish", (c) => x402Handler.handlePublish(c));
+  app.post("/publish", (c) => x402Handler.handlePublish(c));
+  const blsServer = serve({
+    fetch: app.fetch,
+    port: blsPort
+  });
+  const relayHost = config.ator?.enabled ? "127.0.0.1" : void 0;
+  const wsRelay = new NostrRelayServer(
+    { port: relayPort, host: relayHost },
+    eventStore
+  );
+  wsRelayRef.current = wsRelay;
+  await wsRelay.start();
+  await new Promise((resolve) => setTimeout(resolve, 500));
+  let running = true;
+  bootstrapService.setConnectorAdmin(adminClient);
+  if (channelClient) {
+    bootstrapService.setChannelClient(channelClient);
+  }
+  bootstrapService.setIlpClient(ilpClient);
+  bootstrapService.on((event) => {
+    switch (event.type) {
+      case "bootstrap:peer-registered":
+        peerCount++;
+        break;
+      case "bootstrap:channel-opened":
+        channelCount++;
+        break;
+      case "bootstrap:ready":
+        break;
+    }
+  });
+  if (effectiveConnector.setPacketHandler) {
+    effectiveConnector.setPacketHandler(async (request) => {
+      const result = await handlePacket(request);
+      if (result.accept && discoveryTrackerRef.current) {
+        try {
+          const toonBytes = Buffer.from(
+            request.data,
+            "base64"
+          );
+          const decoded = decodeEventFromToon2(toonBytes);
+          if (decoded && decoded.kind === ILP_PEER_INFO_KIND) {
+            discoveryTrackerRef.current.processEvent(decoded);
+          }
+        } catch {
+        }
+      }
+      return result;
+    });
+  }
+  if (autoCreatedConnector) {
+    await autoCreatedConnector.start();
+  }
+  const discoveryTracker = createDiscoveryTracker({
+    secretKey: identity.secretKey,
+    settlementInfo
+  });
+  discoveryTracker.setConnectorAdmin(adminClient);
+  if (channelClient) {
+    discoveryTracker.setChannelClient(channelClient);
+  }
+  discoveryTrackerRef.current = discoveryTracker;
+  let seedRelayDiscovery;
+  if (discovery === "seed-list" && seedRelays.length > 0) {
+    seedRelayDiscovery = new SeedRelayDiscovery({
+      publicRelays: seedRelays
+    });
+    try {
+      const seedResult = await seedRelayDiscovery.discover();
+      const seedPeers = seedResult.discoveredPeers.filter((info) => info.pubkey).map((info) => ({
+        pubkey: info.pubkey,
+        relayUrl: seedResult.connectedUrls[0] ?? `ws://localhost:${relayPort}`,
+        btpEndpoint: info.btpEndpoint
+      }));
+      const existingPubkeys = new Set(knownPeers.map((p) => p.pubkey));
+      for (const seedPeer of seedPeers) {
+        if (!existingPubkeys.has(seedPeer.pubkey)) {
+          knownPeers.push(seedPeer);
+        }
+      }
+      console.log(
+        `[Town] Seed relay discovery: found ${seedPeers.length} peers from ${seedResult.connectedUrls.length} seed relay(s)`
+      );
+    } catch (seedError) {
+      const msg = seedError instanceof Error ? seedError.message : "Unknown error";
+      console.warn(`[Town] Seed relay discovery failed: ${msg}`);
+    }
+  }
+  let announcementHeartbeat;
+  try {
+    const results = await bootstrapService.bootstrap();
+    const ownIlpInfo = {
+      ilpAddress,
+      btpEndpoint,
+      assetCode,
+      assetScale,
+      // Advertise the publish price (per byte, in ILP base units) so clients can
+      // compute the amount to attach before sending — derived from feePerEvent /
+      // basePricePerByte. Previously omitted, leaving peers to assume free.
+      feePerByte: String(basePricePerByte),
+      // Public Nostr relay URL for FREE reads, so clients discover where to
+      // subscribe (separate from btpEndpoint, which is the pay-to-write path).
+      // Set when the operator exposes the relay publicly (HS .anyone or direct).
+      ...externalRelayUrl && { relayUrl: externalRelayUrl },
+      ...settlementInfo?.supportedChains && {
+        supportedChains: settlementInfo.supportedChains
+      },
+      ...settlementInfo?.settlementAddresses && {
+        settlementAddresses: settlementInfo.settlementAddresses
+      },
+      ...settlementInfo?.preferredTokens && {
+        preferredTokens: settlementInfo.preferredTokens
+      },
+      ...settlementInfo?.tokenNetworks && {
+        tokenNetworks: settlementInfo.tokenNetworks
+      }
+    };
+    const publishOwnAnnouncement = () => {
+      try {
+        const ilpInfoEvent = buildIlpPeerInfoEvent(
+          ownIlpInfo,
+          identity.secretKey,
+          announcementTtlSeconds > 0 ? { ttlSeconds: announcementTtlSeconds } : {}
+        );
+        eventStore.store(ilpInfoEvent);
+        const firstPeer = knownPeers[0];
+        const genesisResult = results[0];
+        if (firstPeer && genesisResult) {
+          const genesisIlpAddress = genesisResult.peerInfo.ilpAddress;
+          const toonBytes = encodeEventToToon3(ilpInfoEvent);
+          const base64Toon = Buffer.from(toonBytes).toString("base64");
+          const ilpAmount = String(BigInt(toonBytes.length) * basePricePerByte);
+          ilpClient.sendIlpPacket({
+            destination: genesisIlpAddress,
+            amount: ilpAmount,
+            data: base64Toon
+          }).catch((err) => {
+            const msg = err instanceof Error ? err.message : "Unknown";
+            console.warn("[Town] Failed to publish via ILP:", msg);
+          });
+        }
+      } catch (error) {
+        console.warn("[Town] Failed to publish ILP info:", error);
+      }
+    };
+    publishOwnAnnouncement();
+    if (announcementTtlSeconds > 0) {
+      const heartbeatMs = Math.max(
+        1,
+        Math.floor(announcementTtlSeconds * 1e3 / 2)
+      );
+      announcementHeartbeat = setInterval(publishOwnAnnouncement, heartbeatMs);
+      announcementHeartbeat.unref?.();
+    }
+    try {
+      const serviceDiscoveryContent = {
+        serviceType: "relay",
+        ilpAddress,
+        pricing: {
+          basePricePerByte: Number(basePricePerByte),
+          currency: "USDC"
+        },
+        supportedKinds: [1, 10032, 10035, 10036],
+        capabilities: x402Enabled ? ["relay", "x402"] : ["relay"],
+        chain: chainConfig.name,
+        version: VERSION2
+      };
+      if (x402Enabled) {
+        serviceDiscoveryContent.x402 = {
+          enabled: true,
+          endpoint: "/publish"
+        };
+      }
+      if (config.skill) {
+        serviceDiscoveryContent.skill = config.skill;
+      }
+      const serviceDiscoveryEvent = buildServiceDiscoveryEvent(
+        serviceDiscoveryContent,
+        identity.secretKey
+      );
+      eventStore.store(serviceDiscoveryEvent);
+      const firstPeer = knownPeers[0];
+      const genesisResult = results[0];
+      if (firstPeer && genesisResult) {
+        const genesisIlpAddress = genesisResult.peerInfo.ilpAddress;
+        const sdToonBytes = encodeEventToToon3(serviceDiscoveryEvent);
+        const sdBase64Toon = Buffer.from(sdToonBytes).toString("base64");
+        const sdIlpAmount = String(
+          BigInt(sdToonBytes.length) * basePricePerByte
+        );
+        ilpClient.sendIlpPacket({
+          destination: genesisIlpAddress,
+          amount: sdIlpAmount,
+          data: sdBase64Toon
+        }).catch((err) => {
+          const msg = err instanceof Error ? err.message : "Unknown";
+          console.warn(
+            "[Town] Failed to publish service discovery via ILP:",
+            msg
+          );
+        });
+      }
+    } catch (error) {
+      console.warn("[Town] Failed to publish service discovery:", error);
+    }
+    const bootstrapPeerPubkeys = results.map((r) => r.knownPeer.pubkey);
+    discoveryTracker.addExcludedPubkeys(bootstrapPeerPubkeys);
+  } catch (error) {
+    console.error("[Town] Bootstrap failed:", error);
+  }
+  if (publishSeedEntryFlag && !externalRelayUrl) {
+    console.warn(
+      "[Town] publishSeedEntry is true but externalRelayUrl is not set -- skipping seed relay entry publication"
+    );
+  }
+  if (publishSeedEntryFlag && externalRelayUrl && seedRelays.length > 0) {
+    publishSeedRelayEntry({
+      secretKey: identity.secretKey,
+      relayUrl: externalRelayUrl,
+      publicRelays: seedRelays
+    }).then(({ publishedTo, eventId }) => {
+      console.log(
+        `[Town] Published seed relay entry to ${publishedTo} relay(s), eventId: ${eventId}`
+      );
+    }).catch((err) => {
+      const msg = err instanceof Error ? err.message : "Unknown error";
+      console.warn(`[Town] Failed to publish seed relay entry: ${msg}`);
+    });
+  }
+  const socialDiscovery = new SocialPeerDiscovery(
+    { relayUrls },
+    identity.secretKey
+  );
+  const socialSubscription = socialDiscovery.start();
+  const activeSubscriptions = /* @__PURE__ */ new Set();
+  const instance = {
+    isRunning() {
+      return running;
+    },
+    subscribe(subscribeRelayUrl, filter) {
+      if (!running) {
+        throw new Error("Cannot subscribe: town is not running");
+      }
+      return createSubscription(
+        subscribeRelayUrl,
+        filter,
+        eventStore,
+        activeSubscriptions
+      );
+    },
+    async stop() {
+      if (!running) return;
+      running = false;
+      if (announcementHeartbeat) {
+        clearInterval(announcementHeartbeat);
+        announcementHeartbeat = void 0;
+      }
+      for (const sub of activeSubscriptions) {
+        sub.close();
+      }
+      activeSubscriptions.clear();
+      if (socialSubscription) {
+        socialSubscription.unsubscribe();
+      }
+      if (seedRelayDiscovery) {
+        await seedRelayDiscovery.close();
+      }
+      await wsRelay.stop();
+      blsServer.close();
+      if (autoCreatedConnector) {
+        await autoCreatedConnector.stop();
+      }
+      eventStore.close?.();
+    },
+    pubkey: identity.pubkey,
+    evmAddress: identity.evmAddress,
+    config: resolvedConfig,
+    bootstrapResult: {
+      peerCount,
+      channelCount
+    },
+    discoveryMode: discovery
+  };
+  return instance;
+}
+var startTown = startRelay;
+
+export {
+  DEFAULT_RELAY_CONFIG,
+  matchFilter,
+  InMemoryEventStore,
+  RelayError,
+  SqliteEventStore,
+  encodeEventToToon,
+  ToonEncodeError,
+  decodeEventFromToon,
+  ToonDecodeError,
+  ConnectionHandler,
+  NostrRelayServer,
+  RelaySubscriber,
+  createEventStorageHandler,
+  calculateX402Price,
+  EIP_3009_TYPES,
+  USDC_EIP712_DOMAIN,
+  USDC_ABI,
+  runPreflight,
+  settleEip3009,
+  createX402Handler,
+  createHealthResponse,
+  startRelay,
+  startTown
+};
+//# sourceMappingURL=chunk-4RYYKZXO.js.map