@toon-protocol/client-mcp 0.30.0 → 0.31.0

package/dist/chunk-2MY6AQK6.js

@@ -1,667 +0,0 @@
-import { createRequire as __cr } from 'module'; const require = __cr(import.meta.url);
-import {
-  decodeEventFromToon
-} from "./chunk-TEMKXTNH.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.routeChildPeersThroughApexChannel();
-      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}"`);
-  }
-  /**
-   * Route additional apex CHILD peers (e.g. `dvm`, `mill`) through the SAME
-   * apex payment channel. In the parent→child apex model the client holds ONE
-   * channel with the apex (g.townhouse) and pays via it regardless of which
-   * child the ILP destination addresses; but `ToonClient.resolvePeerId` keys off
-   * the destination's last segment (`town`/`dvm`/`mill`), so without this each
-   * child would (a) fail the "no negotiation for peer" guard and (b) try to open
-   * a SECOND on-chain channel to the same apex receive (which reverts —
-   * channel-exists). So: inject the same apex negotiation under each child peer
-   * AND pre-map its peer→channel to the already-open apex channel so
-   * `ensureChannel` reuses it (no second open; one shared nonce sequence).
-   */
-  routeChildPeersThroughApexChannel() {
-    const apex = this.config.apex;
-    const children = this.config.apexChildPeers ?? [];
-    if (!apex || !this.apexChannelId || children.length === 0) return;
-    const client = this.client;
-    const negotiations = client.peerNegotiations;
-    const peerChannels = client.channelManager?.peerChannels;
-    if (!(negotiations instanceof Map) || !(peerChannels instanceof Map)) {
-      this.log(
-        "[runner] cannot route child peers \u2014 ToonClient internals layout changed"
-      );
-      return;
-    }
-    for (const peer of children) {
-      if (peer === apex.peerId) continue;
-      negotiations.set(peer, {
-        chain: apex.chainKey,
-        chainType: apex.chain,
-        chainId: apex.chainId,
-        settlementAddress: apex.settlementAddress,
-        tokenAddress: apex.tokenAddress,
-        tokenNetwork: apex.tokenNetwork
-      });
-      peerChannels.set(peer, this.apexChannelId);
-      this.log(
-        `[runner] routed child peer "${peer}" through apex channel ${this.apexChannelId}`
-      );
-    }
-  }
-  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-2MY6AQK6.js.map