@toon-protocol/relay 1.3.1 → 1.3.3

package/dist/index.js

@@ -1,675 +1,28 @@
-// src/types.ts
-var DEFAULT_RELAY_CONFIG = {
-  port: 7e3,
-  maxConnections: 100,
-  maxSubscriptionsPerConnection: 20,
-  maxFiltersPerSubscription: 10,
-  databasePath: ":memory:"
-};
-
-// src/filters/matchFilter.ts
-function matchFilter(event, filter) {
-  if (Object.keys(filter).length === 0) {
-    return true;
-  }
-  if (filter.ids !== void 0 && filter.ids.length > 0) {
-    const matches = filter.ids.some((id) => event.id.startsWith(id));
-    if (!matches) return false;
-  }
-  if (filter.authors !== void 0 && filter.authors.length > 0) {
-    const matches = filter.authors.some(
-      (author) => event.pubkey.startsWith(author)
-    );
-    if (!matches) return false;
-  }
-  if (filter.kinds !== void 0 && filter.kinds.length > 0) {
-    if (!filter.kinds.includes(event.kind)) return false;
-  }
-  if (filter.since !== void 0) {
-    if (event.created_at < filter.since) return false;
-  }
-  if (filter.until !== void 0) {
-    if (event.created_at > filter.until) return false;
-  }
-  for (const key of Object.keys(filter)) {
-    if (key.startsWith("#") && key.length === 2) {
-      const tagName = key.slice(1);
-      const filterValues = filter[key];
-      if (filterValues !== void 0 && filterValues.length > 0) {
-        const eventTagValues = event.tags.filter((tag) => tag[0] === tagName).map((tag) => tag[1]);
-        const hasMatch = filterValues.some((v) => eventTagValues.includes(v));
-        if (!hasMatch) return false;
-      }
-    }
-  }
-  return true;
-}
-
-// src/storage/InMemoryEventStore.ts
-var InMemoryEventStore = class {
-  events = /* @__PURE__ */ new Map();
-  store(event) {
-    this.events.set(event.id, event);
-  }
-  get(id) {
-    return this.events.get(id);
-  }
-  query(filters) {
-    const allEvents = Array.from(this.events.values());
-    if (filters.length === 0) {
-      return allEvents.sort((a, b) => b.created_at - a.created_at);
-    }
-    const matchingEvents = [];
-    for (const event of allEvents) {
-      for (const filter of filters) {
-        if (matchFilter(event, filter)) {
-          matchingEvents.push(event);
-          break;
-        }
-      }
-    }
-    matchingEvents.sort((a, b) => b.created_at - a.created_at);
-    const limitFilter = filters.find((f) => f.limit !== void 0);
-    if (limitFilter?.limit !== void 0) {
-      return matchingEvents.slice(0, limitFilter.limit);
-    }
-    return matchingEvents;
-  }
-  /**
-   * Close the storage backend (no-op for in-memory store).
-   */
-  close() {
-  }
-};
-
-// src/storage/SqliteEventStore.ts
-import Database from "better-sqlite3";
-var SCHEMA_SQL = `
-CREATE TABLE IF NOT EXISTS events (
-  id TEXT PRIMARY KEY,
-  pubkey TEXT NOT NULL,
-  kind INTEGER NOT NULL,
-  content TEXT NOT NULL,
-  tags TEXT NOT NULL,
-  created_at INTEGER NOT NULL,
-  sig TEXT NOT NULL,
-  received_at INTEGER NOT NULL
-)
-`;
-var INDEX_SQL = [
-  "CREATE INDEX IF NOT EXISTS idx_events_pubkey ON events(pubkey)",
-  "CREATE INDEX IF NOT EXISTS idx_events_kind ON events(kind)",
-  "CREATE INDEX IF NOT EXISTS idx_events_created_at ON events(created_at)",
-  "CREATE INDEX IF NOT EXISTS idx_events_pubkey_kind ON events(pubkey, kind)"
-];
-function initializeSchema(db) {
-  db.exec(SCHEMA_SQL);
-  for (const indexSql of INDEX_SQL) {
-    db.exec(indexSql);
-  }
-}
-var RelayError = class extends Error {
-  constructor(message, code) {
-    super(message);
-    this.code = code;
-    this.name = "RelayError";
-  }
-};
-function isReplaceableKind(kind) {
-  return kind >= 1e4 && kind <= 19999;
-}
-function isParameterizedReplaceableKind(kind) {
-  return kind >= 3e4 && kind <= 39999;
-}
-function getDTagValue(tags) {
-  const dTag = tags.find((tag) => tag[0] === "d");
-  return dTag?.[1] ?? "";
-}
-var SqliteEventStore = class {
-  db;
-  insertStmt;
-  getStmt;
-  deleteByPubkeyKindStmt;
-  deleteByPubkeyKindDTagStmt;
-  getByPubkeyKindStmt;
-  getByPubkeyKindDTagStmt;
-  /**
-   * Create a new SqliteEventStore.
-   * @param dbPath - Path to the database file. Use ':memory:' for in-memory database.
-   */
-  constructor(dbPath = ":memory:") {
-    try {
-      this.db = new Database(dbPath);
-      initializeSchema(this.db);
-      this.insertStmt = this.db.prepare(`
-        INSERT OR REPLACE INTO events (id, pubkey, kind, content, tags, created_at, sig, received_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-      `);
-      this.getStmt = this.db.prepare("SELECT * FROM events WHERE id = ?");
-      this.deleteByPubkeyKindStmt = this.db.prepare(
-        "DELETE FROM events WHERE pubkey = ? AND kind = ?"
-      );
-      this.deleteByPubkeyKindDTagStmt = this.db.prepare(
-        "DELETE FROM events WHERE pubkey = ? AND kind = ? AND json_extract(tags, '$') LIKE ?"
-      );
-      this.getByPubkeyKindStmt = this.db.prepare(
-        "SELECT id, created_at FROM events WHERE pubkey = ? AND kind = ?"
-      );
-      this.getByPubkeyKindDTagStmt = this.db.prepare(
-        "SELECT id, created_at FROM events WHERE pubkey = ? AND kind = ? AND tags LIKE ?"
-      );
-    } catch (error) {
-      throw new RelayError(
-        `Failed to initialize database: ${error instanceof Error ? error.message : String(error)}`,
-        "STORAGE_ERROR"
-      );
-    }
-  }
-  /**
-   * Store an event in the database.
-   * Handles replaceable and parameterized replaceable events according to NIP-01.
-   */
-  store(event) {
-    try {
-      const tagsJson = JSON.stringify(event.tags);
-      const receivedAt = Math.floor(Date.now() / 1e3);
-      if (isReplaceableKind(event.kind)) {
-        this.storeReplaceableEvent(event, tagsJson, receivedAt);
-      } else if (isParameterizedReplaceableKind(event.kind)) {
-        this.storeParameterizedReplaceableEvent(event, tagsJson, receivedAt);
-      } else {
-        const insertOrIgnore = this.db.prepare(`
-          INSERT OR IGNORE INTO events (id, pubkey, kind, content, tags, created_at, sig, received_at)
-          VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-        `);
-        insertOrIgnore.run(
-          event.id,
-          event.pubkey,
-          event.kind,
-          event.content,
-          tagsJson,
-          event.created_at,
-          event.sig,
-          receivedAt
-        );
-      }
-    } catch (error) {
-      if (error instanceof RelayError) {
-        throw error;
-      }
-      throw new RelayError(
-        `Failed to store event: ${error instanceof Error ? error.message : String(error)}`,
-        "STORAGE_ERROR"
-      );
-    }
-  }
-  /**
-   * Store a replaceable event (kinds 10000-19999).
-   * Only keeps the latest event per pubkey+kind.
-   */
-  storeReplaceableEvent(event, tagsJson, receivedAt) {
-    const existing = this.getByPubkeyKindStmt.get(event.pubkey, event.kind);
-    if (existing) {
-      if (event.created_at > existing.created_at || event.created_at === existing.created_at && event.id < existing.id) {
-        const transaction = this.db.transaction(() => {
-          this.deleteByPubkeyKindStmt.run(event.pubkey, event.kind);
-          this.insertStmt.run(
-            event.id,
-            event.pubkey,
-            event.kind,
-            event.content,
-            tagsJson,
-            event.created_at,
-            event.sig,
-            receivedAt
-          );
-        });
-        transaction();
-      }
-    } else {
-      this.insertStmt.run(
-        event.id,
-        event.pubkey,
-        event.kind,
-        event.content,
-        tagsJson,
-        event.created_at,
-        event.sig,
-        receivedAt
-      );
-    }
-  }
-  /**
-   * Store a parameterized replaceable event (kinds 30000-39999).
-   * Only keeps the latest event per pubkey+kind+d-tag.
-   */
-  storeParameterizedReplaceableEvent(event, tagsJson, receivedAt) {
-    const dTagValue = getDTagValue(event.tags);
-    let existing;
-    if (dTagValue === "") {
-      const candidates = this.db.prepare(
-        "SELECT id, created_at, tags FROM events WHERE pubkey = ? AND kind = ?"
-      ).all(event.pubkey, event.kind);
-      for (const candidate of candidates) {
-        const candidateTags = JSON.parse(candidate.tags);
-        const candidateDTagValue = getDTagValue(candidateTags);
-        if (candidateDTagValue === "") {
-          existing = { id: candidate.id, created_at: candidate.created_at };
-          break;
-        }
-      }
-    } else {
-      const dTagPattern = `%["d","${dTagValue}"%`;
-      existing = this.getByPubkeyKindDTagStmt.get(
-        event.pubkey,
-        event.kind,
-        dTagPattern
-      );
-    }
-    if (existing) {
-      if (event.created_at > existing.created_at || event.created_at === existing.created_at && event.id < existing.id) {
-        const transaction = this.db.transaction(() => {
-          this.db.prepare("DELETE FROM events WHERE id = ?").run(existing.id);
-          this.insertStmt.run(
-            event.id,
-            event.pubkey,
-            event.kind,
-            event.content,
-            tagsJson,
-            event.created_at,
-            event.sig,
-            receivedAt
-          );
-        });
-        transaction();
-      }
-    } else {
-      this.insertStmt.run(
-        event.id,
-        event.pubkey,
-        event.kind,
-        event.content,
-        tagsJson,
-        event.created_at,
-        event.sig,
-        receivedAt
-      );
-    }
-  }
-  /**
-   * Retrieve an event by its ID.
-   */
-  get(id) {
-    try {
-      const row = this.getStmt.get(id);
-      if (!row) {
-        return void 0;
-      }
-      return {
-        id: row.id,
-        pubkey: row.pubkey,
-        kind: row.kind,
-        content: row.content,
-        tags: JSON.parse(row.tags),
-        created_at: row.created_at,
-        sig: row.sig
-      };
-    } catch (error) {
-      throw new RelayError(
-        `Failed to get event: ${error instanceof Error ? error.message : String(error)}`,
-        "STORAGE_ERROR"
-      );
-    }
-  }
-  /**
-   * Query events matching any of the provided filters.
-   */
-  query(filters) {
-    try {
-      const { sql, params } = this.buildQuerySql(filters);
-      const stmt = this.db.prepare(sql);
-      const rows = stmt.all(...params);
-      return rows.map((row) => ({
-        id: row.id,
-        pubkey: row.pubkey,
-        kind: row.kind,
-        content: row.content,
-        tags: JSON.parse(row.tags),
-        created_at: row.created_at,
-        sig: row.sig
-      }));
-    } catch (error) {
-      throw new RelayError(
-        `Failed to query events: ${error instanceof Error ? error.message : String(error)}`,
-        "STORAGE_ERROR"
-      );
-    }
-  }
-  /**
-   * Build SQL query from filters.
-   */
-  buildQuerySql(filters) {
-    if (filters.length === 0) {
-      return {
-        sql: "SELECT * FROM events ORDER BY created_at DESC",
-        params: []
-      };
-    }
-    const conditions = [];
-    const params = [];
-    for (const filter of filters) {
-      const filterConditions = [];
-      if (filter.ids?.length) {
-        const idConditions = filter.ids.map(() => "id LIKE ?");
-        filterConditions.push(`(${idConditions.join(" OR ")})`);
-        params.push(...filter.ids.map((id) => `${id}%`));
-      }
-      if (filter.authors?.length) {
-        const authorConditions = filter.authors.map(() => "pubkey LIKE ?");
-        filterConditions.push(`(${authorConditions.join(" OR ")})`);
-        params.push(...filter.authors.map((a) => `${a}%`));
-      }
-      if (filter.kinds?.length) {
-        filterConditions.push(
-          `kind IN (${filter.kinds.map(() => "?").join(", ")})`
-        );
-        params.push(...filter.kinds);
-      }
-      if (filter.since !== void 0) {
-        filterConditions.push("created_at >= ?");
-        params.push(filter.since);
-      }
-      if (filter.until !== void 0) {
-        filterConditions.push("created_at <= ?");
-        params.push(filter.until);
-      }
-      for (const [key, values] of Object.entries(filter)) {
-        if (key.startsWith("#") && Array.isArray(values) && values.length > 0) {
-          const tagName = key.slice(1);
-          const tagConditions = values.map(() => `tags LIKE ?`);
-          filterConditions.push(`(${tagConditions.join(" OR ")})`);
-          params.push(...values.map((v) => `%["${tagName}","${v}"%`));
-        }
-      }
-      if (filterConditions.length > 0) {
-        conditions.push(`(${filterConditions.join(" AND ")})`);
-      }
-    }
-    let sql = "SELECT * FROM events";
-    if (conditions.length > 0) {
-      sql += ` WHERE ${conditions.join(" OR ")}`;
-    }
-    sql += " ORDER BY created_at DESC";
-    const limitFilter = filters.find((f) => f.limit !== void 0);
-    if (limitFilter?.limit !== void 0) {
-      sql += " LIMIT ?";
-      params.push(limitFilter.limit);
-    }
-    return { sql, params };
-  }
-  /**
-   * Close the database connection.
-   */
-  close() {
-    this.db.close();
-  }
-};
-
-// src/toon/index.ts
 import {
+  ConnectionHandler,
+  DEFAULT_RELAY_CONFIG,
+  EIP_3009_TYPES,
+  InMemoryEventStore,
+  NostrRelayServer,
+  RelayError,
+  RelaySubscriber,
+  SqliteEventStore,
+  ToonDecodeError,
+  ToonEncodeError,
+  USDC_ABI,
+  USDC_EIP712_DOMAIN,
+  calculateX402Price,
+  createEventStorageHandler,
+  createHealthResponse,
+  createX402Handler,
+  decodeEventFromToon,
   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 });
-        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);
-    });
-  }
-};
+  matchFilter,
+  runPreflight,
+  settleEip3009,
+  startRelay,
+  startTown
+} from "./chunk-ZKWFGHZ7.js";
 
 // src/bls/types.ts
 var PUBKEY_REGEX = /^[0-9a-f]{64}$/;
@@ -1086,69 +439,6 @@ function parseKindOverridesJson(jsonStr) {
   return result;
 }
 
-// src/subscriber/RelaySubscriber.ts
-import { SimplePool } from "nostr-tools/pool";
-import { verifyEvent as verifyEvent2 } from "nostr-tools/pure";
-var RelaySubscriber = class {
-  config;
-  eventStore;
-  pool;
-  started = false;
-  /**
-   * @param config - Subscriber configuration
-   * @param eventStore - Storage backend to write events into
-   * @param pool - Optional SimplePool instance (creates new one if not provided)
-   */
-  constructor(config, eventStore, pool) {
-    this.config = config;
-    this.eventStore = eventStore;
-    this.pool = pool ?? new SimplePool();
-  }
-  /**
-   * Start subscribing to the configured upstream relays.
-   *
-   * @returns Handle with unsubscribe() to stop the subscription
-   * @throws Error if already started
-   */
-  start() {
-    if (this.started) {
-      throw new Error("RelaySubscriber already started");
-    }
-    this.started = true;
-    const shouldVerify = this.config.verifySignatures !== false;
-    let isUnsubscribed = false;
-    const subCloser = this.pool.subscribeMany(
-      this.config.relayUrls,
-      this.config.filter,
-      {
-        onevent: (event) => {
-          if (isUnsubscribed) return;
-          if (shouldVerify && !verifyEvent2(event)) {
-            return;
-          }
-          try {
-            this.eventStore.store(event);
-          } catch (error) {
-            console.warn(
-              "[RelaySubscriber] Failed to store event:",
-              error instanceof Error ? error.message : "Unknown error"
-            );
-          }
-        }
-      }
-    );
-    return {
-      unsubscribe: () => {
-        if (!isUnsubscribed) {
-          isUnsubscribed = true;
-          subCloser.close();
-          this.started = false;
-        }
-      }
-    };
-  }
-};
-
 // src/index.ts
 var VERSION = "0.1.0";
 export {
@@ -1156,6 +446,7 @@ export {
   BusinessLogicServer,
   ConnectionHandler,
   DEFAULT_RELAY_CONFIG,
+  EIP_3009_TYPES,
   ILP_ERROR_CODES,
   InMemoryEventStore,
   NostrRelayServer,
@@ -1166,12 +457,22 @@ export {
   SqliteEventStore,
   ToonDecodeError,
   ToonEncodeError,
+  USDC_ABI,
+  USDC_EIP712_DOMAIN,
   VERSION,
+  calculateX402Price,
+  createEventStorageHandler,
+  createHealthResponse,
+  createX402Handler,
   decodeEventFromToon,
   encodeEventToToon,
   isValidPubkey,
   loadPricingConfigFromEnv,
   loadPricingConfigFromFile,
-  matchFilter
+  matchFilter,
+  runPreflight,
+  settleEip3009,
+  startRelay,
+  startTown
 };
 //# sourceMappingURL=index.js.map