@toon-protocol/client-mcp 0.26.2

package/dist/chunk-2SGZPDGE.js

@@ -0,0 +1,625 @@
+import { createRequire as __cr } from 'module'; const require = __cr(import.meta.url);
+import {
+  decodeEventFromToon
+} from "./chunk-WMYY5I3H.js";
+
+// src/relay-subscription.ts
+import { createRequire } from "module";
+var nodeRequire = createRequire(import.meta.url);
+var DEFAULT_BUFFER = 5e3;
+var DEFAULT_BASE_MS = 1e3;
+var DEFAULT_MAX_MS = 3e4;
+var noop = () => void 0;
+var RelaySubscription = class {
+  relayUrl;
+  socksProxy;
+  bufferSize;
+  reconnectBaseMs;
+  reconnectMaxMs;
+  log;
+  wsFactory;
+  decodeEvent;
+  /** Active subscriptions: subId -> filters (re-sent on every (re)connect). */
+  subscriptions = /* @__PURE__ */ new Map();
+  /** Ring buffer of received events, ordered by ascending `seq`. */
+  buffer = [];
+  /** De-dup index: event.id -> seq (kept in lockstep with the buffer). */
+  seen = /* @__PURE__ */ new Set();
+  seqCounter = 0;
+  subIdCounter = 0;
+  ws = null;
+  connected = false;
+  closing = false;
+  reconnectAttempts = 0;
+  reconnectTimer = null;
+  constructor(opts) {
+    this.relayUrl = opts.relayUrl;
+    this.socksProxy = opts.socksProxy;
+    this.bufferSize = opts.bufferSize ?? DEFAULT_BUFFER;
+    this.reconnectBaseMs = opts.reconnectBaseMs ?? DEFAULT_BASE_MS;
+    this.reconnectMaxMs = opts.reconnectMaxMs ?? DEFAULT_MAX_MS;
+    this.log = opts.logger ?? noop;
+    this.wsFactory = opts.wsFactory ?? defaultWebSocketFactory(this.socksProxy);
+    this.decodeEvent = opts.decodeEvent;
+  }
+  /** Whether the underlying socket is currently open. */
+  isConnected() {
+    return this.connected;
+  }
+  /** Number of events currently held in the buffer. */
+  bufferedCount() {
+    return this.buffer.length;
+  }
+  /** Active subscription ids. */
+  activeSubscriptions() {
+    return [...this.subscriptions.keys()];
+  }
+  /** Open the connection (idempotent). */
+  start() {
+    this.closing = false;
+    if (this.ws) return;
+    this.open();
+  }
+  /**
+   * Register a persistent subscription and (if connected) send the REQ.
+   * Returns the subscription id (caller-supplied or generated).
+   */
+  subscribe(filters, subId) {
+    const id = subId ?? `sub-${++this.subIdCounter}`;
+    const list = Array.isArray(filters) ? filters : [filters];
+    this.subscriptions.set(id, list);
+    if (this.connected) this.sendReq(id, list);
+    return id;
+  }
+  /** Cancel a subscription and send CLOSE if connected. */
+  unsubscribe(subId) {
+    if (!this.subscriptions.delete(subId)) return;
+    if (this.connected) this.sendRaw(["CLOSE", subId]);
+  }
+  /**
+   * Drain events newer than `cursor`. The cursor is the highest `seq` returned;
+   * pass it back to fetch only events received since. Filtering by `subId`
+   * restricts to one subscription.
+   */
+  getEvents(opts = {}) {
+    const after = opts.cursor ?? 0;
+    const limit = opts.limit ?? 200;
+    const matches = this.buffer.filter(
+      (b) => b.seq > after && (opts.subId === void 0 || b.subId === opts.subId)
+    );
+    const page = matches.slice(0, limit);
+    const hasMore = matches.length > page.length;
+    const last = page.at(-1);
+    const cursor = last ? last.seq : after;
+    return { events: page.map((b) => b.event), cursor, hasMore };
+  }
+  /** Close the connection permanently and stop reconnecting. */
+  close() {
+    this.closing = true;
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      try {
+        this.ws.close();
+      } catch {
+      }
+      this.ws = null;
+    }
+    this.connected = false;
+  }
+  // ── internals ────────────────────────────────────────────────────────────
+  open() {
+    let ws;
+    try {
+      ws = this.wsFactory(this.relayUrl);
+    } catch (err) {
+      this.log(`[relay] connect failed: ${errMsg(err)}`);
+      this.scheduleReconnect();
+      return;
+    }
+    this.ws = ws;
+    ws.on("open", () => {
+      this.connected = true;
+      this.reconnectAttempts = 0;
+      this.log(`[relay] connected to ${this.relayUrl}`);
+      for (const [id, filters] of this.subscriptions) this.sendReq(id, filters);
+    });
+    ws.on("message", (data) => this.handleMessage(data));
+    ws.on("error", (err) => {
+      this.log(`[relay] socket error: ${errMsg(err)}`);
+    });
+    ws.on("close", () => {
+      this.connected = false;
+      this.ws = null;
+      if (!this.closing) {
+        this.log("[relay] disconnected; scheduling reconnect");
+        this.scheduleReconnect();
+      }
+    });
+  }
+  scheduleReconnect() {
+    if (this.closing || this.reconnectTimer) return;
+    const delay = Math.min(
+      this.reconnectMaxMs,
+      this.reconnectBaseMs * 2 ** this.reconnectAttempts
+    );
+    this.reconnectAttempts += 1;
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      if (!this.closing) this.open();
+    }, delay);
+    this.reconnectTimer.unref?.();
+  }
+  sendReq(subId, filters) {
+    this.sendRaw(["REQ", subId, ...filters]);
+  }
+  sendRaw(message) {
+    if (!this.ws || !this.connected) return;
+    try {
+      this.ws.send(JSON.stringify(message));
+    } catch (err) {
+      this.log(`[relay] send failed: ${errMsg(err)}`);
+    }
+  }
+  handleMessage(data) {
+    let parsed;
+    try {
+      parsed = JSON.parse(toText(data));
+    } catch {
+      return;
+    }
+    if (!Array.isArray(parsed) || parsed.length === 0) return;
+    const type = parsed[0];
+    switch (type) {
+      case "EVENT": {
+        const subId = typeof parsed[1] === "string" ? parsed[1] : "";
+        const event = this.parseEventPayload(parsed[2]);
+        if (event && typeof event.id === "string")
+          this.bufferEvent(subId, event);
+        break;
+      }
+      case "EOSE":
+        break;
+      case "CLOSED":
+        this.log(
+          `[relay] subscription closed by relay: ${String(parsed[2] ?? "")}`
+        );
+        break;
+      case "NOTICE":
+        this.log(`[relay] NOTICE: ${String(parsed[1] ?? "")}`);
+        break;
+      default:
+        break;
+    }
+  }
+  /**
+   * Normalise an `EVENT` payload to a NostrEvent. Standard relays send a JSON
+   * object; the TOON relay sends a TOON-encoded string, decoded via the injected
+   * `decodeEvent`. Returns undefined when it can't be parsed.
+   */
+  parseEventPayload(raw) {
+    if (raw && typeof raw === "object" && typeof raw.id === "string") {
+      return raw;
+    }
+    if (typeof raw === "string" && this.decodeEvent) {
+      try {
+        return this.decodeEvent(raw);
+      } catch (err) {
+        this.log(`[relay] event decode failed: ${errMsg(err)}`);
+        return void 0;
+      }
+    }
+    return void 0;
+  }
+  bufferEvent(subId, event) {
+    if (this.seen.has(event.id)) return;
+    this.seen.add(event.id);
+    this.buffer.push({ seq: ++this.seqCounter, subId, event });
+    if (this.buffer.length > this.bufferSize) {
+      const evicted = this.buffer.shift();
+      if (evicted) this.seen.delete(evicted.event.id);
+    }
+  }
+};
+function toText(data) {
+  if (typeof data === "string") return data;
+  if (data instanceof Uint8Array) return Buffer.from(data).toString("utf8");
+  if (Buffer.isBuffer(data)) return data.toString("utf8");
+  return String(data);
+}
+function errMsg(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function defaultWebSocketFactory(socksProxy) {
+  return (url) => {
+    const WebSocketImpl = nodeRequire("ws");
+    let agent;
+    if (socksProxy) {
+      const { SocksProxyAgent } = nodeRequire("socks-proxy-agent");
+      agent = new SocksProxyAgent(socksProxy);
+    }
+    return new WebSocketImpl(url, agent ? { agent } : void 0);
+  };
+}
+
+// src/daemon/apex-channel-store.ts
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname } from "path";
+function key(destination, chain) {
+  return `${destination}|${chain}`;
+}
+function readStore(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return {};
+  }
+}
+function loadApexChannel(path, destination, chain) {
+  return readStore(path)[key(destination, chain)] ?? null;
+}
+function saveApexChannel(path, destination, chain, record) {
+  const store = readStore(path);
+  store[key(destination, chain)] = record;
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(store, null, 2), { mode: 384 });
+}
+
+// src/daemon/client-runner.ts
+var ClientRunner = class {
+  config;
+  client;
+  relay;
+  log;
+  startedAt = Date.now();
+  bootstrapping = false;
+  ready = false;
+  lastError;
+  /** Channel opened against the default apex destination. */
+  apexChannelId;
+  stopped = false;
+  constructor(deps) {
+    this.config = deps.config;
+    this.client = deps.createClient();
+    this.relay = deps.createRelay?.() ?? new RelaySubscription({
+      relayUrl: deps.config.relayUrl,
+      socksProxy: deps.config.socksProxy,
+      logger: deps.logger,
+      // The TOON relay sends events TOON-encoded (text) on reads, not as JSON.
+      decodeEvent: (raw) => decodeEventFromToon(new TextEncoder().encode(raw))
+    });
+    this.log = deps.logger ?? (() => void 0);
+  }
+  /**
+   * Begin bootstrapping in the background. Resolves once kicked off; the
+   * connection becomes ready asynchronously. Awaitable for tests via the
+   * returned promise of the underlying work.
+   */
+  start() {
+    if (this.bootstrapping || this.ready) return;
+    this.bootstrapping = true;
+    this.relay.start();
+    void this.bootstrap();
+  }
+  /** The background bootstrap routine (exposed for awaiting in tests). */
+  async bootstrap() {
+    try {
+      await this.client.start();
+      this.injectApexNegotiation(this.config.apex);
+      this.apexChannelId = await this.openOrResumeApexChannel();
+      this.ready = true;
+      this.lastError = void 0;
+      this.log(`[runner] ready; apex channel ${this.apexChannelId}`);
+    } catch (err) {
+      this.lastError = err instanceof Error ? err.message : String(err);
+      this.log(`[runner] bootstrap failed: ${this.lastError}`);
+    } finally {
+      this.bootstrapping = false;
+    }
+  }
+  /**
+   * Open the apex channel — or, on a restart, RESUME the existing one.
+   *
+   * `ChannelManager` persists the nonce watermark (by channelId) but not the
+   * peer→channelId mapping, so a naive `openChannel()` after restart re-deposits
+   * into a fresh channel and reverts on-chain. We persist the channelId here and,
+   * when present, `trackChannel()` the live channel (which rehydrates the nonce
+   * from the channel store) — no on-chain write, watermark continues.
+   */
+  async openOrResumeApexChannel() {
+    const { destination, chain, apexChannelStorePath } = this.config;
+    const saved = loadApexChannel(apexChannelStorePath, destination, chain);
+    const cm = this.client.channelManager;
+    if (saved && cm && typeof cm.trackChannel === "function") {
+      cm.trackChannel(saved.channelId, saved.context);
+      this.log(
+        `[runner] resumed apex channel ${saved.channelId} (tracked, no re-deposit)`
+      );
+      return saved.channelId;
+    }
+    const channelId = await this.client.openChannel(destination);
+    if (this.config.apex) {
+      const a = this.config.apex;
+      saveApexChannel(apexChannelStorePath, destination, chain, {
+        channelId,
+        context: {
+          chainType: a.chain,
+          chainId: a.chainId,
+          tokenNetworkAddress: a.tokenNetwork ?? "",
+          tokenAddress: a.tokenAddress,
+          recipient: a.settlementAddress
+        }
+      });
+    }
+    return channelId;
+  }
+  /**
+   * Inject the apex settlement negotiation directly into the ToonClient when
+   * configured. Required for HS / direct-apex mode where bootstrap discovers 0
+   * peers (no relay-based discovery). Mirrors the docker entrypoint's approach.
+   */
+  injectApexNegotiation(apex) {
+    if (!apex) return;
+    const negotiations = this.client.peerNegotiations;
+    if (!(negotiations instanceof Map)) {
+      throw new Error(
+        "ToonClient.peerNegotiations layout changed \u2014 cannot inject apex negotiation"
+      );
+    }
+    negotiations.set(apex.peerId, {
+      chain: apex.chainKey,
+      chainType: apex.chain,
+      chainId: apex.chainId,
+      settlementAddress: apex.settlementAddress,
+      tokenAddress: apex.tokenAddress,
+      tokenNetwork: apex.tokenNetwork
+    });
+    this.log(`[runner] injected apex negotiation for peer "${apex.peerId}"`);
+  }
+  isReady() {
+    return this.ready;
+  }
+  isBootstrapping() {
+    return this.bootstrapping;
+  }
+  getStatus() {
+    const net = this.client.getNetworkStatus();
+    const network = net ? ["evm", "solana", "mina"].map((c) => ({
+      chain: c,
+      ready: net[c] === "configured",
+      detail: net[c]
+    })) : void 0;
+    return {
+      uptimeMs: Date.now() - this.startedAt,
+      bootstrapping: this.bootstrapping,
+      ready: this.ready,
+      settlementChain: this.config.chain,
+      identity: {
+        nostrPubkey: safe(() => this.client.getPublicKey()) ?? "",
+        evmAddress: safe(() => this.client.getEvmAddress()),
+        solanaAddress: safe(() => this.client.getSolanaAddress()),
+        minaAddress: safe(() => this.client.getMinaAddress())
+      },
+      transport: {
+        type: this.config.socksProxy ? "socks5" : "direct",
+        socksProxy: this.config.socksProxy,
+        btpUrl: this.config.toonClientConfig.btpUrl
+      },
+      relay: {
+        url: this.config.relayUrl,
+        connected: this.relay.isConnected(),
+        buffered: this.relay.bufferedCount(),
+        subscriptions: this.relay.activeSubscriptions()
+      },
+      ...network ? { network } : {},
+      ...this.lastError ? { lastError: this.lastError } : {}
+    };
+  }
+  /** Pay-to-write a single event. Throws NOT_READY while bootstrapping. */
+  async publish(req) {
+    this.assertReady();
+    const channelId = this.apexChannelId ?? await this.client.openChannel(req.destination);
+    const fee = req.fee !== void 0 ? BigInt(req.fee) : this.config.feePerEvent;
+    const claim = await this.client.signBalanceProof(channelId, fee);
+    const result = await this.client.publishEvent(req.event, {
+      destination: req.destination,
+      claim,
+      ilpAmount: fee
+    });
+    if (!result.success) {
+      throw new PublishRejectedError(result.error ?? "relay rejected event");
+    }
+    return {
+      eventId: result.eventId ?? req.event.id,
+      data: result.data,
+      channelId,
+      nonce: this.client.getChannelNonce(channelId)
+    };
+  }
+  /** Register a free-read subscription (does not require the paid path). */
+  subscribe(req) {
+    const subId = this.relay.subscribe(req.filters, req.subId);
+    return { subId };
+  }
+  /** Drain buffered events newer than the cursor (free read). */
+  getEvents(query) {
+    const opts = {};
+    if (query.subId !== void 0) opts.subId = query.subId;
+    if (query.cursor !== void 0) opts.cursor = query.cursor;
+    if (query.limit !== void 0) opts.limit = query.limit;
+    const { events, cursor, hasMore } = this.relay.getEvents(opts);
+    return { events, cursor, hasMore };
+  }
+  /** Open (or return) a payment channel for a destination. */
+  async openChannel(destination) {
+    this.assertReady();
+    const channelId = await this.client.openChannel(
+      destination ?? this.config.destination
+    );
+    if (!destination || destination === this.config.destination) {
+      this.apexChannelId = channelId;
+    }
+    return { channelId };
+  }
+  /** List tracked channels with their nonce watermark + cumulative amount. */
+  getChannels() {
+    const channels = this.client.getTrackedChannels().map((channelId) => ({
+      channelId,
+      nonce: this.client.getChannelNonce(channelId),
+      cumulativeAmount: this.client.getChannelCumulativeAmount(channelId).toString()
+    }));
+    return { channels };
+  }
+  /** Send a swap packet to a mill peer. */
+  async swap(req) {
+    this.assertReady();
+    const toonData = req.toonData ? new Uint8Array(Buffer.from(req.toonData, "base64")) : new Uint8Array(0);
+    const result = await this.client.sendSwapPacket({
+      destination: req.destination,
+      amount: BigInt(req.amount),
+      toonData
+    });
+    return {
+      accepted: result.accepted,
+      data: result.data,
+      code: result.code,
+      message: result.message
+    };
+  }
+  /** Graceful teardown of the relay subscription + ToonClient. */
+  async stop() {
+    if (this.stopped) return;
+    this.stopped = true;
+    this.relay.close();
+    try {
+      await this.client.stop();
+    } catch (err) {
+      this.log(
+        `[runner] client stop error: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  assertReady() {
+    if (!this.ready) {
+      throw new NotReadyError(
+        this.bootstrapping ? "Daemon is still bootstrapping (BTP/anon coming up) \u2014 retry shortly." : this.lastError ?? "Daemon is not ready."
+      );
+    }
+  }
+};
+var NotReadyError = class extends Error {
+  retryable = true;
+  constructor(message) {
+    super(message);
+    this.name = "NotReadyError";
+  }
+};
+var PublishRejectedError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PublishRejectedError";
+  }
+};
+function safe(fn) {
+  try {
+    return fn();
+  } catch {
+    return void 0;
+  }
+}
+
+// src/daemon/routes.ts
+function registerRoutes(app, runner) {
+  app.get("/status", async () => runner.getStatus());
+  app.post("/publish", async (req, reply) => {
+    const body = req.body;
+    if (!body || !isSignedEvent(body.event)) {
+      return sendError(reply, 400, "invalid_event", {
+        detail: "body.event must be a fully-signed Nostr event (id + sig)."
+      });
+    }
+    try {
+      return await runner.publish(body);
+    } catch (err) {
+      return mapError(reply, err);
+    }
+  });
+  app.post("/subscribe", async (req, reply) => {
+    const body = req.body;
+    if (!body || body.filters === void 0) {
+      return sendError(reply, 400, "invalid_filters", {
+        detail: "body.filters is required (a NIP-01 filter or array of filters)."
+      });
+    }
+    return runner.subscribe(body);
+  });
+  app.get(
+    "/events",
+    async (req) => {
+      const q = req.query;
+      const query = {};
+      if (q.subId) query.subId = q.subId;
+      if (q.cursor !== void 0) query.cursor = Number(q.cursor);
+      if (q.limit !== void 0) query.limit = Number(q.limit);
+      return runner.getEvents(query);
+    }
+  );
+  app.post("/channels", async (req, reply) => {
+    try {
+      return await runner.openChannel(req.body?.destination);
+    } catch (err) {
+      return mapError(reply, err);
+    }
+  });
+  app.get("/channels", async () => runner.getChannels());
+  app.post("/swap", async (req, reply) => {
+    const body = req.body;
+    if (!body || !body.destination || body.amount === void 0) {
+      return sendError(reply, 400, "invalid_swap", {
+        detail: "body.destination and body.amount are required."
+      });
+    }
+    try {
+      return await runner.swap(body);
+    } catch (err) {
+      return mapError(reply, err);
+    }
+  });
+}
+function isSignedEvent(event) {
+  if (typeof event !== "object" || event === null) return false;
+  const e = event;
+  return typeof e["id"] === "string" && typeof e["sig"] === "string" && typeof e["pubkey"] === "string" && typeof e["kind"] === "number";
+}
+function mapError(reply, err) {
+  if (err instanceof NotReadyError) {
+    return sendError(reply, 503, "bootstrapping", {
+      detail: err.message,
+      retryable: true
+    });
+  }
+  if (err instanceof PublishRejectedError) {
+    return sendError(reply, 502, "rejected", { detail: err.message });
+  }
+  return sendError(reply, 500, "internal_error", {
+    detail: err instanceof Error ? err.message : String(err)
+  });
+}
+function sendError(reply, status, error, extra = {}) {
+  return reply.status(status).send({
+    error,
+    ...extra.detail ? { detail: extra.detail } : {},
+    ...extra.retryable ? { retryable: true } : {}
+  });
+}
+
+export {
+  RelaySubscription,
+  ClientRunner,
+  NotReadyError,
+  PublishRejectedError,
+  registerRoutes
+};
+//# sourceMappingURL=chunk-2SGZPDGE.js.map