@toon-protocol/relay 1.3.3 → 2.0.0

package/dist/chunk-ZKWFGHZ7.js

@@ -1,2029 +0,0 @@
-// src/types.ts
-var DEFAULT_RELAY_CONFIG = {
-  port: 7e3,
-  host: "0.0.0.0",
-  maxConnections: 100,
-  maxSubscriptionsPerConnection: 20,
-  maxFiltersPerSubscription: 10,
-  databasePath: ":memory:"
-};
-
-// src/filters/matchFilter.ts
-function matchFilter(event, filter) {
-  if (Object.keys(filter).length === 0) {
-    return true;
-  }
-  if (filter.ids !== void 0 && filter.ids.length > 0) {
-    const matches = filter.ids.some((id) => event.id.startsWith(id));
-    if (!matches) return false;
-  }
-  if (filter.authors !== void 0 && filter.authors.length > 0) {
-    const matches = filter.authors.some(
-      (author) => event.pubkey.startsWith(author)
-    );
-    if (!matches) return false;
-  }
-  if (filter.kinds !== void 0 && filter.kinds.length > 0) {
-    if (!filter.kinds.includes(event.kind)) return false;
-  }
-  if (filter.since !== void 0) {
-    if (event.created_at < filter.since) return false;
-  }
-  if (filter.until !== void 0) {
-    if (event.created_at > filter.until) return false;
-  }
-  for (const key of Object.keys(filter)) {
-    if (key.startsWith("#") && key.length === 2) {
-      const tagName = key.slice(1);
-      const filterValues = filter[key];
-      if (filterValues !== void 0 && filterValues.length > 0) {
-        const eventTagValues = event.tags.filter((tag) => tag[0] === tagName).map((tag) => tag[1]);
-        const hasMatch = filterValues.some((v) => eventTagValues.includes(v));
-        if (!hasMatch) return false;
-      }
-    }
-  }
-  return true;
-}
-
-// src/storage/InMemoryEventStore.ts
-var InMemoryEventStore = class {
-  events = /* @__PURE__ */ new Map();
-  store(event) {
-    this.events.set(event.id, event);
-  }
-  get(id) {
-    return this.events.get(id);
-  }
-  query(filters) {
-    const allEvents = Array.from(this.events.values());
-    if (filters.length === 0) {
-      return allEvents.sort((a, b) => b.created_at - a.created_at);
-    }
-    const matchingEvents = [];
-    for (const event of allEvents) {
-      for (const filter of filters) {
-        if (matchFilter(event, filter)) {
-          matchingEvents.push(event);
-          break;
-        }
-      }
-    }
-    matchingEvents.sort((a, b) => b.created_at - a.created_at);
-    const limitFilter = filters.find((f) => f.limit !== void 0);
-    if (limitFilter?.limit !== void 0) {
-      return matchingEvents.slice(0, limitFilter.limit);
-    }
-    return matchingEvents;
-  }
-  /**
-   * Close the storage backend (no-op for in-memory store).
-   */
-  close() {
-  }
-};
-
-// src/storage/SqliteEventStore.ts
-import Database from "better-sqlite3";
-var SCHEMA_SQL = `
-CREATE TABLE IF NOT EXISTS events (
-  id TEXT PRIMARY KEY,
-  pubkey TEXT NOT NULL,
-  kind INTEGER NOT NULL,
-  content TEXT NOT NULL,
-  tags TEXT NOT NULL,
-  created_at INTEGER NOT NULL,
-  sig TEXT NOT NULL,
-  received_at INTEGER NOT NULL
-)
-`;
-var INDEX_SQL = [
-  "CREATE INDEX IF NOT EXISTS idx_events_pubkey ON events(pubkey)",
-  "CREATE INDEX IF NOT EXISTS idx_events_kind ON events(kind)",
-  "CREATE INDEX IF NOT EXISTS idx_events_created_at ON events(created_at)",
-  "CREATE INDEX IF NOT EXISTS idx_events_pubkey_kind ON events(pubkey, kind)"
-];
-function initializeSchema(db) {
-  db.exec(SCHEMA_SQL);
-  for (const indexSql of INDEX_SQL) {
-    db.exec(indexSql);
-  }
-}
-var RelayError = class extends Error {
-  constructor(message, code) {
-    super(message);
-    this.code = code;
-    this.name = "RelayError";
-  }
-};
-function isReplaceableKind(kind) {
-  return kind >= 1e4 && kind <= 19999 && !(kind >= 10032 && kind <= 10099);
-}
-function isParameterizedReplaceableKind(kind) {
-  return kind >= 3e4 && kind <= 39999 || kind >= 10032 && kind <= 10099;
-}
-function getDTagValue(tags) {
-  const dTag = tags.find((tag) => tag[0] === "d");
-  return dTag?.[1] ?? "";
-}
-var SqliteEventStore = class {
-  db;
-  insertStmt;
-  getStmt;
-  deleteByPubkeyKindStmt;
-  deleteByPubkeyKindDTagStmt;
-  getByPubkeyKindStmt;
-  getByPubkeyKindDTagStmt;
-  /**
-   * Create a new SqliteEventStore.
-   * @param dbPath - Path to the database file. Use ':memory:' for in-memory database.
-   */
-  constructor(dbPath = ":memory:") {
-    try {
-      this.db = new Database(dbPath);
-      initializeSchema(this.db);
-      this.insertStmt = this.db.prepare(`
-        INSERT OR REPLACE INTO events (id, pubkey, kind, content, tags, created_at, sig, received_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-      `);
-      this.getStmt = this.db.prepare("SELECT * FROM events WHERE id = ?");
-      this.deleteByPubkeyKindStmt = this.db.prepare(
-        "DELETE FROM events WHERE pubkey = ? AND kind = ?"
-      );
-      this.deleteByPubkeyKindDTagStmt = this.db.prepare(
-        "DELETE FROM events WHERE pubkey = ? AND kind = ? AND json_extract(tags, '$') LIKE ?"
-      );
-      this.getByPubkeyKindStmt = this.db.prepare(
-        "SELECT id, created_at FROM events WHERE pubkey = ? AND kind = ?"
-      );
-      this.getByPubkeyKindDTagStmt = this.db.prepare(
-        "SELECT id, created_at FROM events WHERE pubkey = ? AND kind = ? AND tags LIKE ?"
-      );
-    } catch (error) {
-      throw new RelayError(
-        `Failed to initialize database: ${error instanceof Error ? error.message : String(error)}`,
-        "STORAGE_ERROR"
-      );
-    }
-  }
-  /**
-   * Store an event in the database.
-   * Handles replaceable and parameterized replaceable events according to NIP-01.
-   */
-  store(event) {
-    try {
-      const tagsJson = JSON.stringify(event.tags);
-      const receivedAt = Math.floor(Date.now() / 1e3);
-      if (isReplaceableKind(event.kind)) {
-        this.storeReplaceableEvent(event, tagsJson, receivedAt);
-      } else if (isParameterizedReplaceableKind(event.kind)) {
-        this.storeParameterizedReplaceableEvent(event, tagsJson, receivedAt);
-      } else {
-        const insertOrIgnore = this.db.prepare(`
-          INSERT OR IGNORE INTO events (id, pubkey, kind, content, tags, created_at, sig, received_at)
-          VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-        `);
-        insertOrIgnore.run(
-          event.id,
-          event.pubkey,
-          event.kind,
-          event.content,
-          tagsJson,
-          event.created_at,
-          event.sig,
-          receivedAt
-        );
-      }
-    } catch (error) {
-      if (error instanceof RelayError) {
-        throw error;
-      }
-      throw new RelayError(
-        `Failed to store event: ${error instanceof Error ? error.message : String(error)}`,
-        "STORAGE_ERROR"
-      );
-    }
-  }
-  /**
-   * Store a replaceable event (kinds 10000-19999).
-   * Only keeps the latest event per pubkey+kind.
-   */
-  storeReplaceableEvent(event, tagsJson, receivedAt) {
-    const existing = this.getByPubkeyKindStmt.get(event.pubkey, event.kind);
-    if (existing) {
-      if (event.created_at > existing.created_at || event.created_at === existing.created_at && event.id < existing.id) {
-        const transaction = this.db.transaction(() => {
-          this.deleteByPubkeyKindStmt.run(event.pubkey, event.kind);
-          this.insertStmt.run(
-            event.id,
-            event.pubkey,
-            event.kind,
-            event.content,
-            tagsJson,
-            event.created_at,
-            event.sig,
-            receivedAt
-          );
-        });
-        transaction();
-      }
-    } else {
-      this.insertStmt.run(
-        event.id,
-        event.pubkey,
-        event.kind,
-        event.content,
-        tagsJson,
-        event.created_at,
-        event.sig,
-        receivedAt
-      );
-    }
-  }
-  /**
-   * Store a parameterized replaceable event (kinds 30000-39999).
-   * Only keeps the latest event per pubkey+kind+d-tag.
-   */
-  storeParameterizedReplaceableEvent(event, tagsJson, receivedAt) {
-    const dTagValue = getDTagValue(event.tags);
-    let existing;
-    if (dTagValue === "") {
-      const candidates = this.db.prepare(
-        "SELECT id, created_at, tags FROM events WHERE pubkey = ? AND kind = ?"
-      ).all(event.pubkey, event.kind);
-      for (const candidate of candidates) {
-        const candidateTags = JSON.parse(candidate.tags);
-        const candidateDTagValue = getDTagValue(candidateTags);
-        if (candidateDTagValue === "") {
-          existing = { id: candidate.id, created_at: candidate.created_at };
-          break;
-        }
-      }
-    } else {
-      const dTagPattern = `%["d","${dTagValue}"%`;
-      existing = this.getByPubkeyKindDTagStmt.get(
-        event.pubkey,
-        event.kind,
-        dTagPattern
-      );
-    }
-    if (existing) {
-      if (event.created_at > existing.created_at || event.created_at === existing.created_at && event.id < existing.id) {
-        const transaction = this.db.transaction(() => {
-          this.db.prepare("DELETE FROM events WHERE id = ?").run(existing.id);
-          this.insertStmt.run(
-            event.id,
-            event.pubkey,
-            event.kind,
-            event.content,
-            tagsJson,
-            event.created_at,
-            event.sig,
-            receivedAt
-          );
-        });
-        transaction();
-      }
-    } else {
-      this.insertStmt.run(
-        event.id,
-        event.pubkey,
-        event.kind,
-        event.content,
-        tagsJson,
-        event.created_at,
-        event.sig,
-        receivedAt
-      );
-    }
-  }
-  /**
-   * Retrieve an event by its ID.
-   */
-  get(id) {
-    try {
-      const row = this.getStmt.get(id);
-      if (!row) {
-        return void 0;
-      }
-      return {
-        id: row.id,
-        pubkey: row.pubkey,
-        kind: row.kind,
-        content: row.content,
-        tags: JSON.parse(row.tags),
-        created_at: row.created_at,
-        sig: row.sig
-      };
-    } catch (error) {
-      throw new RelayError(
-        `Failed to get event: ${error instanceof Error ? error.message : String(error)}`,
-        "STORAGE_ERROR"
-      );
-    }
-  }
-  /**
-   * Query events matching any of the provided filters.
-   */
-  query(filters) {
-    try {
-      const { sql, params } = this.buildQuerySql(filters);
-      const stmt = this.db.prepare(sql);
-      const rows = stmt.all(...params);
-      return rows.map((row) => ({
-        id: row.id,
-        pubkey: row.pubkey,
-        kind: row.kind,
-        content: row.content,
-        tags: JSON.parse(row.tags),
-        created_at: row.created_at,
-        sig: row.sig
-      }));
-    } catch (error) {
-      throw new RelayError(
-        `Failed to query events: ${error instanceof Error ? error.message : String(error)}`,
-        "STORAGE_ERROR"
-      );
-    }
-  }
-  /**
-   * Build SQL query from filters.
-   */
-  buildQuerySql(filters) {
-    if (filters.length === 0) {
-      return {
-        sql: "SELECT * FROM events ORDER BY created_at DESC",
-        params: []
-      };
-    }
-    const conditions = [];
-    const params = [];
-    for (const filter of filters) {
-      const filterConditions = [];
-      if (filter.ids?.length) {
-        const idConditions = filter.ids.map(() => "id LIKE ?");
-        filterConditions.push(`(${idConditions.join(" OR ")})`);
-        params.push(...filter.ids.map((id) => `${id}%`));
-      }
-      if (filter.authors?.length) {
-        const authorConditions = filter.authors.map(() => "pubkey LIKE ?");
-        filterConditions.push(`(${authorConditions.join(" OR ")})`);
-        params.push(...filter.authors.map((a) => `${a}%`));
-      }
-      if (filter.kinds?.length) {
-        filterConditions.push(
-          `kind IN (${filter.kinds.map(() => "?").join(", ")})`
-        );
-        params.push(...filter.kinds);
-      }
-      if (filter.since !== void 0) {
-        filterConditions.push("created_at >= ?");
-        params.push(filter.since);
-      }
-      if (filter.until !== void 0) {
-        filterConditions.push("created_at <= ?");
-        params.push(filter.until);
-      }
-      for (const [key, values] of Object.entries(filter)) {
-        if (key.startsWith("#") && Array.isArray(values) && values.length > 0) {
-          const tagName = key.slice(1);
-          const tagConditions = values.map(() => `tags LIKE ?`);
-          filterConditions.push(`(${tagConditions.join(" OR ")})`);
-          params.push(...values.map((v) => `%["${tagName}","${v}"%`));
-        }
-      }
-      if (filterConditions.length > 0) {
-        conditions.push(`(${filterConditions.join(" AND ")})`);
-      }
-    }
-    let sql = "SELECT * FROM events";
-    if (conditions.length > 0) {
-      sql += ` WHERE ${conditions.join(" OR ")}`;
-    }
-    sql += " ORDER BY created_at DESC";
-    const limitFilter = filters.find((f) => f.limit !== void 0);
-    if (limitFilter?.limit !== void 0) {
-      sql += " LIMIT ?";
-      params.push(limitFilter.limit);
-    }
-    return { sql, params };
-  }
-  /**
-   * Close the database connection.
-   */
-  close() {
-    this.db.close();
-  }
-};
-
-// src/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 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 };
-  }
-  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-ZKWFGHZ7.js.map