@toon-protocol/client-mcp 0.31.2 → 0.33.0

package/dist/{chunk-PRFPAEGG.js → chunk-7WCDT25E.js}

@@ -1,6 +1,7 @@
 import { createRequire as __cr } from 'module'; const require = __cr(import.meta.url);
 import {
   DEFAULT_KEYSTORE_PASSWORD,
+  ILP_PEER_INFO_KIND,
   ToonError,
   buildIlpPrepare,
   configDir,
@@ -9,8 +10,9 @@ import {
   deriveFullIdentity,
   encodeEventToToon,
   generateKeystore,
+  parseIlpPeerInfo,
   readConfigFile
-} from "./chunk-ARFPM2PT.js";
+} from "./chunk-ALMTQYYJ.js";
 import {
   startManagedAnonProxy
 } from "./chunk-SKQTKZIH.js";
@@ -128,6 +130,7 @@ var RelaySubscription = class {
   log;
   wsFactory;
   decodeEvent;
+  onEvent;
   /** Active subscriptions: subId -> filters (re-sent on every (re)connect). */
   subscriptions = /* @__PURE__ */ new Map();
   /** Ring buffer of received events, ordered by ascending `seq`. */
@@ -150,6 +153,7 @@ var RelaySubscription = class {
     this.log = opts.logger ?? noop;
     this.wsFactory = opts.wsFactory ?? defaultWebSocketFactory(this.socksProxy);
     this.decodeEvent = opts.decodeEvent;
+    this.onEvent = opts.onEvent;
   }
   /** Whether the underlying socket is currently open. */
   isConnected() {
@@ -250,7 +254,7 @@ var RelaySubscription = class {
   }
   scheduleReconnect() {
     if (this.closing || this.reconnectTimer) return;
-    const delay = Math.min(
+    const delay2 = Math.min(
       this.reconnectMaxMs,
       this.reconnectBaseMs * 2 ** this.reconnectAttempts
     );
@@ -258,7 +262,7 @@ var RelaySubscription = class {
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null;
       if (!this.closing) this.open();
-    }, delay);
+    }, delay2);
     this.reconnectTimer.unref?.();
   }
   sendReq(subId, filters) {
@@ -330,6 +334,7 @@ var RelaySubscription = class {
       const evicted = this.buffer.shift();
       if (evicted) this.seen.delete(evicted.event.id);
     }
+    this.onEvent?.(subId, event);
   }
 };
 function toText(data) {
@@ -1239,54 +1244,499 @@ function saveApexChannel(path, destination, chain, record) {
   writeFileSync2(path, JSON.stringify(store, null, 2), { mode: 384 });
 }
 
+// src/daemon/targets-store.ts
+import { mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname3, join as join2 } from "path";
+function defaultTargetsPath() {
+  return join2(configDir(), "targets.json");
+}
+function loadTargets(path = defaultTargetsPath()) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync2(path, "utf8"));
+  } catch {
+    return { relays: [], apexes: [] };
+  }
+  return {
+    relays: Array.isArray(parsed.relays) ? parsed.relays : [],
+    apexes: Array.isArray(parsed.apexes) ? parsed.apexes : []
+  };
+}
+function write(path, data) {
+  mkdirSync3(dirname3(path), { recursive: true });
+  writeFileSync3(path, JSON.stringify(data, null, 2), { mode: 384 });
+}
+function saveRelayTarget(relayUrl, path = defaultTargetsPath()) {
+  const store = loadTargets(path);
+  if (!store.relays.some((r) => r.relayUrl === relayUrl)) {
+    store.relays.push({ relayUrl });
+    write(path, store);
+  }
+}
+function removeRelayTarget(relayUrl, path = defaultTargetsPath()) {
+  const store = loadTargets(path);
+  const next = store.relays.filter((r) => r.relayUrl !== relayUrl);
+  if (next.length === store.relays.length) return false;
+  store.relays = next;
+  write(path, store);
+  return true;
+}
+function saveApexTarget(target, path = defaultTargetsPath()) {
+  const store = loadTargets(path);
+  store.apexes = store.apexes.filter((a) => a.btpUrl !== target.btpUrl);
+  store.apexes.push(target);
+  write(path, store);
+}
+function removeApexTarget(btpUrl, path = defaultTargetsPath()) {
+  const store = loadTargets(path);
+  const next = store.apexes.filter((a) => a.btpUrl !== btpUrl);
+  if (next.length === store.apexes.length) return false;
+  store.apexes = next;
+  write(path, store);
+  return true;
+}
+
+// src/daemon/apex-discovery.ts
+var ApexDiscoveryError = class extends Error {
+  constructor(message, retryable = false) {
+    super(message);
+    this.retryable = retryable;
+    this.name = "ApexDiscoveryError";
+  }
+};
+async function discoverApex(params) {
+  const { relay, ilpAddress, pubkey, chain, childPeers } = params;
+  const timeoutMs = params.timeoutMs ?? 15e3;
+  const pollMs = params.pollMs ?? 250;
+  const subId = relay.subscribe(
+    [
+      {
+        kinds: [ILP_PEER_INFO_KIND],
+        ...pubkey ? { authors: [pubkey] } : {}
+      }
+    ],
+    `apex-discovery-${ilpAddress}`
+  );
+  try {
+    const deadline = Date.now() + timeoutMs;
+    let cursor = 0;
+    while (Date.now() < deadline) {
+      const { events, cursor: next } = relay.getEvents({ subId, cursor });
+      cursor = next;
+      const match = events.find((e) => matchesApex(e, ilpAddress));
+      if (match) return mapAnnouncement(match, { chain, childPeers });
+      await delay(pollMs);
+    }
+    throw new ApexDiscoveryError(
+      `Timed out after ${timeoutMs}ms waiting for the apex kind:${ILP_PEER_INFO_KIND} announcement for "${ilpAddress}" on the relay. Is the relay reachable and the apex online?`,
+      true
+      // retryable: the apex may just be slow/offline
+    );
+  } finally {
+    relay.unsubscribe(subId);
+  }
+}
+function matchesApex(event, ilpAddress) {
+  if (event.kind !== ILP_PEER_INFO_KIND) return false;
+  try {
+    const info = parseIlpPeerInfo(event);
+    const addrs = info.ilpAddresses ?? [info.ilpAddress];
+    return addrs.includes(ilpAddress) || info.ilpAddress === ilpAddress;
+  } catch {
+    return false;
+  }
+}
+function mapAnnouncement(event, opts) {
+  const info = parseIlpPeerInfo(event);
+  const chains = info.supportedChains ?? [];
+  if (chains.length === 0) {
+    throw new ApexDiscoveryError(
+      `Apex "${info.ilpAddress}" announced no supportedChains \u2014 cannot settle.`
+    );
+  }
+  const chainKey = (opts.chain ? chains.find((c) => c.split(":")[0] === opts.chain) : void 0) ?? chains[0];
+  if (!chainKey) {
+    throw new ApexDiscoveryError(
+      `Apex "${info.ilpAddress}" announced no usable settlement chain.`
+    );
+  }
+  const family = chainKey.split(":")[0];
+  const settlementAddress = info.settlementAddresses?.[chainKey];
+  if (!settlementAddress) {
+    throw new ApexDiscoveryError(
+      `Apex "${info.ilpAddress}" announced no settlementAddress for chain "${chainKey}".`
+    );
+  }
+  const btpUrl = info.btpEndpoint;
+  if (!btpUrl) {
+    throw new ApexDiscoveryError(
+      `Apex "${info.ilpAddress}" announced an empty btpEndpoint \u2014 cannot open a BTP session.`
+    );
+  }
+  const negotiation = {
+    destination: info.ilpAddress,
+    peerId: info.ilpAddress.split(".").at(-1) ?? info.ilpAddress,
+    chain: family,
+    chainKey,
+    // EVM chainKeys are `evm:<network>:<chainId>`; non-EVM carry no numeric id.
+    chainId: family === "evm" ? Number(chainKey.split(":")[2] ?? 0) : 0,
+    settlementAddress,
+    ...info.preferredTokens?.[chainKey] ? { tokenAddress: info.preferredTokens[chainKey] } : {},
+    ...info.tokenNetworks?.[chainKey] ? { tokenNetwork: info.tokenNetworks[chainKey] } : {}
+  };
+  return {
+    btpUrl,
+    negotiation,
+    ...opts.childPeers && opts.childPeers.length > 0 ? { apexChildPeers: opts.childPeers } : {}
+  };
+}
+function delay(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
 // src/daemon/client-runner.ts
+var MERGED_BUFFER = 5e3;
 var ClientRunner = class {
   config;
-  client;
-  relay;
+  createClient;
+  createRelay;
   startReadProxy;
   log;
+  targetsPath;
   startedAt = Date.now();
-  bootstrapping = false;
-  ready = false;
-  lastError;
-  /** Channel opened against the default apex destination. */
-  apexChannelId;
-  /** Teardown for a daemon-managed read proxy (btp-direct + relay-`.anyone`). */
+  /** Apex write targets, keyed by btpUrl. */
+  apexes = /* @__PURE__ */ new Map();
+  /** Relay read targets, keyed by relayUrl. */
+  relays = /* @__PURE__ */ new Map();
+  /** Runner-level merged read buffer across all relays (de-duped by event.id). */
+  merged = [];
+  mergedSeen = /* @__PURE__ */ new Set();
+  mergedSeq = 0;
+  /**
+   * Fan-out subscriptions (no relayUrl restriction): replayed onto relays added
+   * later so a new relay immediately participates in existing reads.
+   */
+  fanoutSubs = /* @__PURE__ */ new Map();
+  subIdCounter = 0;
+  defaultBtpUrl;
+  defaultRelayUrl;
+  /** Teardown for the daemon-managed read proxy (btp-direct + relay-`.anyone`). */
   stopReadProxy;
-  /** Error from the read proxy (kept separate from the paid-path `lastError`). */
   readProxyError;
   stopped = false;
+  started = 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.
+    this.createClient = deps.createClient;
+    this.log = deps.logger ?? (() => void 0);
+    if (deps.targetsPath !== void 0) this.targetsPath = deps.targetsPath;
+    this.defaultBtpUrl = deps.config.toonClientConfig.btpUrl ?? "";
+    this.defaultRelayUrl = deps.config.relayUrl;
+    this.createRelay = deps.createRelay ?? ((opts) => new RelaySubscription({
+      relayUrl: opts.relayUrl,
+      ...opts.socksProxy ? { socksProxy: opts.socksProxy } : {},
+      ...opts.logger ? { logger: opts.logger } : {},
+      onEvent: opts.onEvent,
+      // The TOON relay sends events TOON-encoded (text) on reads, not JSON.
       decodeEvent: (raw) => decodeEventFromToon(new TextEncoder().encode(raw))
-    });
+    }));
     this.startReadProxy = deps.startReadProxy ?? ((opts) => startManagedAnonProxy({
       socksPort: opts.socksPort,
       ...opts.log ? { log: opts.log } : {}
     }));
-    this.log = deps.logger ?? (() => void 0);
+    this.registerRelay(this.defaultRelayUrl, this.config.socksProxy);
+    const defaultApex = this.makeApex({
+      btpUrl: this.defaultBtpUrl,
+      client: this.createClient(this.config.toonClientConfig),
+      ...this.config.apex ? { negotiation: this.config.apex } : {},
+      childPeers: this.config.apexChildPeers ?? [],
+      destination: this.config.destination,
+      chain: this.config.chain,
+      channelStorePath: this.config.toonClientConfig.channelStorePath ?? this.apexChannelStorePathFor(this.defaultBtpUrl),
+      feePerEvent: this.config.feePerEvent,
+      isDefault: true
+    });
+    this.apexes.set(defaultApex.btpUrl, defaultApex);
   }
   /**
-   * 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 the live connections: the shared read proxy, every relay socket, the
+   * default apex bootstrap (non-blocking), then replay persisted dynamic
+   * targets. Returns immediately; apexes become ready asynchronously.
    */
   start() {
-    if (this.bootstrapping || this.ready) return;
-    this.bootstrapping = true;
+    if (this.started) return;
+    this.started = true;
     if (this.config.manageReadProxy) void this.bringUpReadProxy();
-    this.relay.start();
+    for (const relay of this.relays.values()) relay.start();
     void this.bootstrap();
+    this.replayPersistedTargets();
+  }
+  /** Await the default apex's bootstrap (kicking it off if not already running). */
+  bootstrap() {
+    const apex = this.apexes.get(this.defaultBtpUrl);
+    if (!apex) return Promise.resolve();
+    return this.bootstrapApex(apex);
+  }
+  // ── Relays (reads) ─────────────────────────────────────────────────────────
+  /**
+   * Build + register a relay (idempotent by URL), wiring its events into the
+   * merged buffer and replaying active fan-out subscriptions. Does NOT start the
+   * socket — callers start it (so construction stays side-effect-free for tests).
+   */
+  registerRelay(relayUrl, socksProxy) {
+    const existing = this.relays.get(relayUrl);
+    if (existing) return existing;
+    const relay = this.createRelay({
+      relayUrl,
+      ...socksProxy ? { socksProxy } : {},
+      logger: this.log,
+      onEvent: (subId, event) => this.pushMerged(relayUrl, subId, event)
+    });
+    this.relays.set(relayUrl, relay);
+    for (const [subId, filters] of this.fanoutSubs)
+      relay.subscribe(filters, subId);
+    return relay;
+  }
+  /**
+   * Add a relay read target at runtime. `.anyone` relays reuse the managed read
+   * proxy (started here if needed). Persisted unless `persist` is false.
+   */
+  async addRelay(relayUrl, persist = true) {
+    if (this.relays.has(relayUrl)) return;
+    let socksProxy = this.config.socksProxy;
+    if (isAnyoneHost(relayUrl) && !socksProxy) {
+      await this.ensureReadProxy();
+      socksProxy = `socks5h://127.0.0.1:${this.config.readProxySocksPort ?? 9050}`;
+    }
+    const relay = this.registerRelay(relayUrl, socksProxy);
+    relay.start();
+    if (persist) saveRelayTarget(relayUrl, this.targetsPath);
+  }
+  /** Remove a relay read target. The config-seeded default cannot be removed. */
+  removeRelay(relayUrl) {
+    if (relayUrl === this.defaultRelayUrl) {
+      throw new TargetError("Cannot remove the default (config-seeded) relay.");
+    }
+    const relay = this.relays.get(relayUrl);
+    if (!relay) throw new TargetError(`No such relay: ${relayUrl}`);
+    relay.close();
+    this.relays.delete(relayUrl);
+    this.merged = this.merged.filter((m) => {
+      if (m.relayUrl === relayUrl) {
+        this.mergedSeen.delete(m.event.id);
+        return false;
+      }
+      return true;
+    });
+    removeRelayTarget(relayUrl, this.targetsPath);
+  }
+  /** Mirror a newly-buffered relay event into the merged cross-relay buffer. */
+  pushMerged(relayUrl, subId, event) {
+    if (this.mergedSeen.has(event.id)) return;
+    this.mergedSeen.add(event.id);
+    this.merged.push({ seq: ++this.mergedSeq, relayUrl, subId, event });
+    if (this.merged.length > MERGED_BUFFER) {
+      const evicted = this.merged.shift();
+      if (evicted) this.mergedSeen.delete(evicted.event.id);
+    }
+  }
+  /**
+   * Register a free-read subscription. With no `relayUrl` it FANS OUT across
+   * every relay (and onto relays added later); with one it targets that relay.
+   */
+  subscribe(req) {
+    const subId = req.subId ?? `sub-${++this.subIdCounter}`;
+    const filters = Array.isArray(req.filters) ? req.filters : [req.filters];
+    const targets = req.relayUrl ? [req.relayUrl] : [...this.relays.keys()];
+    if (req.relayUrl && !this.relays.has(req.relayUrl)) {
+      throw new TargetError(`No such relay: ${req.relayUrl}`);
+    }
+    if (!req.relayUrl) this.fanoutSubs.set(subId, filters);
+    for (const url of targets) this.relays.get(url)?.subscribe(filters, subId);
+    return { subId, relays: targets };
+  }
+  /** Drain merged events newer than the cursor (free read), optionally scoped. */
+  getEvents(query) {
+    const after = query.cursor ?? 0;
+    const limit = query.limit ?? 200;
+    const matches = this.merged.filter(
+      (m) => m.seq > after && (query.subId === void 0 || m.subId === query.subId) && (query.relayUrl === void 0 || m.relayUrl === query.relayUrl)
+    );
+    const page = matches.slice(0, limit);
+    const hasMore = matches.length > page.length;
+    const last = page.at(-1);
+    return {
+      events: page.map((m) => m.event),
+      cursor: last ? last.seq : after,
+      hasMore
+    };
+  }
+  // ── Apexes (writes) ──────────────────────────────────────────────────────
+  makeApex(init) {
+    return {
+      ...init,
+      ready: false,
+      bootstrapping: false
+    };
+  }
+  /**
+   * Bootstrap one apex (memoized): start, inject negotiation, open/resume the
+   * channel, route child peers. Concurrent callers await the same in-flight
+   * work rather than re-running it.
+   */
+  bootstrapApex(apex) {
+    if (apex.ready) return Promise.resolve();
+    if (!apex.bootstrapPromise) {
+      apex.bootstrapPromise = this.doBootstrapApex(apex);
+    }
+    return apex.bootstrapPromise;
+  }
+  async doBootstrapApex(apex) {
+    apex.bootstrapping = true;
+    try {
+      await apex.client.start();
+      this.injectApexNegotiation(apex);
+      apex.apexChannelId = await this.openOrResumeApexChannel(apex);
+      this.routeChildPeersThroughApexChannel(apex);
+      apex.ready = true;
+      apex.lastError = void 0;
+      this.log(
+        `[runner] apex ${apex.btpUrl} ready; channel ${apex.apexChannelId}`
+      );
+    } catch (err) {
+      apex.lastError = err instanceof Error ? err.message : String(err);
+      this.log(
+        `[runner] apex ${apex.btpUrl} bootstrap failed: ${apex.lastError}`
+      );
+    } finally {
+      apex.bootstrapping = false;
+    }
+  }
+  /**
+   * Add an apex write target. Settlement params are discovered by reading the
+   * apex's kind:10032 off the given relay (added first if unknown). Persisted.
+   */
+  async addApex(req) {
+    await this.addRelay(req.relayUrl);
+    const relay = this.relays.get(req.relayUrl);
+    if (!relay) throw new TargetError(`Relay unavailable: ${req.relayUrl}`);
+    const discovered = await discoverApex({
+      relay,
+      ilpAddress: req.ilpAddress,
+      ...req.pubkey ? { pubkey: req.pubkey } : {},
+      ...req.chain ? { chain: req.chain } : {},
+      ...req.childPeers ? { childPeers: req.childPeers } : {}
+    });
+    const feePerEvent = req.feePerEvent !== void 0 ? BigInt(req.feePerEvent) : this.config.feePerEvent;
+    await this.instantiateApex(
+      {
+        btpUrl: discovered.btpUrl,
+        negotiation: discovered.negotiation,
+        ...discovered.apexChildPeers ? { apexChildPeers: discovered.apexChildPeers } : {},
+        feePerEvent: req.feePerEvent ?? feePerEvent.toString(),
+        discoveredFrom: req.relayUrl
+      },
+      true
+    );
+    const apex = this.apexes.get(discovered.btpUrl);
+    if (!apex) {
+      throw new TargetError(
+        `Apex ${discovered.btpUrl} failed to register after discovery.`
+      );
+    }
+    return {
+      btpUrl: apex.btpUrl,
+      destination: apex.destination,
+      chain: apex.chain,
+      ready: apex.ready
+    };
+  }
+  /** Build + register + bootstrap an apex from a (persisted) target record. */
+  async instantiateApex(target, persist) {
+    if (this.apexes.has(target.btpUrl)) return;
+    const clientConfig = this.deriveApexClientConfig(
+      target.btpUrl,
+      target.negotiation.destination
+    );
+    const apex = this.makeApex({
+      btpUrl: target.btpUrl,
+      client: this.createClient(clientConfig),
+      negotiation: target.negotiation,
+      childPeers: target.apexChildPeers ?? [],
+      destination: target.negotiation.destination,
+      chain: target.negotiation.chain,
+      channelStorePath: this.apexChannelStorePathFor(target.btpUrl),
+      feePerEvent: BigInt(target.feePerEvent ?? this.config.feePerEvent),
+      isDefault: false
+    });
+    this.apexes.set(apex.btpUrl, apex);
+    if (persist) saveApexTarget(target, this.targetsPath);
+    await this.bootstrapApex(apex);
+  }
+  /** Remove an apex write target. The config-seeded default cannot be removed. */
+  async removeApex(btpUrl) {
+    if (btpUrl === this.defaultBtpUrl) {
+      throw new TargetError("Cannot remove the default (config-seeded) apex.");
+    }
+    const apex = this.apexes.get(btpUrl);
+    if (!apex) throw new TargetError(`No such apex: ${btpUrl}`);
+    try {
+      await apex.client.stop();
+    } catch (err) {
+      this.log(
+        `[runner] apex ${btpUrl} stop error: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    this.apexes.delete(btpUrl);
+    removeApexTarget(btpUrl, this.targetsPath);
+  }
+  /** Derive a per-apex ToonClientConfig from the default (shared identity/transport). */
+  deriveApexClientConfig(btpUrl, destination) {
+    const base = this.config.toonClientConfig;
+    return {
+      ...base,
+      btpUrl,
+      destinationAddress: destination,
+      // Distinct nonce-watermark store per apex so parallel ChannelManagers in
+      // this process never race a shared channels.json.
+      channelStorePath: this.apexChannelStorePathFor(btpUrl),
+      ilpInfo: { ...base.ilpInfo, btpEndpoint: btpUrl }
+    };
+  }
+  apexChannelStorePathFor(btpUrl) {
+    return `${configDir()}/channels-${sanitize(btpUrl)}.json`;
+  }
+  // ── Persisted-target replay ────────────────────────────────────────────────
+  replayPersistedTargets() {
+    let store;
+    try {
+      store = loadTargets(this.targetsPath);
+    } catch (err) {
+      this.log(
+        `[runner] failed to load targets store: ${err instanceof Error ? err.message : String(err)}`
+      );
+      return;
+    }
+    for (const r of store.relays) {
+      if (r.relayUrl === this.defaultRelayUrl) continue;
+      void this.addRelay(r.relayUrl, false).catch(
+        (err) => this.log(`[runner] replay relay ${r.relayUrl} failed: ${errMsg2(err)}`)
+      );
+    }
+    for (const a of store.apexes) {
+      if (a.btpUrl === this.defaultBtpUrl) continue;
+      void this.instantiateApex(a, false).catch(
+        (err) => this.log(`[runner] replay apex ${a.btpUrl} failed: ${errMsg2(err)}`)
+      );
+    }
+  }
+  // ── Shared read proxy ──────────────────────────────────────────────────────
+  async ensureReadProxy() {
+    if (this.stopReadProxy) return;
+    await this.bringUpReadProxy();
   }
-  /** Start the daemon-managed `anon` read proxy (best-effort; logs on failure). */
   async bringUpReadProxy() {
+    if (this.stopReadProxy) return;
     const socksPort = this.config.readProxySocksPort ?? 9050;
     try {
       this.log(
@@ -1308,36 +1758,13 @@ var ClientRunner = class {
       this.log(`[runner] managed read proxy failed: ${this.readProxyError}`);
     }
   }
-  /** 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;
+  // ── Channel / negotiation helpers (per-apex) ───────────────────────────────
+  /** Open the apex channel — or, on a restart, RESUME the existing one. */
+  async openOrResumeApexChannel(apex) {
+    const { destination, chain } = apex;
+    const { apexChannelStorePath } = this.config;
     const saved = loadApexChannel(apexChannelStorePath, destination, chain);
-    const cm = this.client.channelManager;
+    const cm = apex.client.channelManager;
     if (saved && cm && typeof cm.trackChannel === "function") {
       cm.trackChannel(saved.channelId, saved.context);
       this.log(
@@ -1345,62 +1772,47 @@ var ClientRunner = class {
       );
       return saved.channelId;
     }
-    const channelId = await this.client.openChannel(destination);
-    if (this.config.apex) {
-      const a = this.config.apex;
+    const channelId = await apex.client.openChannel(destination);
+    if (apex.negotiation) {
+      const a = apex.negotiation;
       saveApexChannel(apexChannelStorePath, destination, chain, {
         channelId,
         context: {
           chainType: a.chain,
           chainId: a.chainId,
           tokenNetworkAddress: a.tokenNetwork ?? "",
-          tokenAddress: a.tokenAddress,
+          ...a.tokenAddress ? { 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.
-   */
+  /** Inject the apex settlement negotiation directly into its ToonClient. */
   injectApexNegotiation(apex) {
-    if (!apex) return;
-    const negotiations = this.client.peerNegotiations;
+    const a = apex.negotiation;
+    if (!a) return;
+    const negotiations = apex.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
+    negotiations.set(a.peerId, {
+      chain: a.chainKey,
+      chainType: a.chain,
+      chainId: a.chainId,
+      settlementAddress: a.settlementAddress,
+      tokenAddress: a.tokenAddress,
+      tokenNetwork: a.tokenNetwork
     });
-    this.log(`[runner] injected apex negotiation for peer "${apex.peerId}"`);
+    this.log(`[runner] injected apex negotiation for peer "${a.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;
+  /** Route apex CHILD peers (dvm/mill) through the SAME apex payment channel. */
+  routeChildPeersThroughApexChannel(apex) {
+    const a = apex.negotiation;
+    if (!a || !apex.apexChannelId || apex.childPeers.length === 0) return;
+    const client = apex.client;
     const negotiations = client.peerNegotiations;
     const peerChannels = client.channelManager?.peerChannels;
     if (!(negotiations instanceof Map) || !(peerChannels instanceof Map)) {
@@ -1409,70 +1821,103 @@ var ClientRunner = class {
       );
       return;
     }
-    for (const peer of children) {
-      if (peer === apex.peerId) continue;
+    for (const peer of apex.childPeers) {
+      if (peer === a.peerId) continue;
       negotiations.set(peer, {
-        chain: apex.chainKey,
-        chainType: apex.chain,
-        chainId: apex.chainId,
-        settlementAddress: apex.settlementAddress,
-        tokenAddress: apex.tokenAddress,
-        tokenNetwork: apex.tokenNetwork
+        chain: a.chainKey,
+        chainType: a.chain,
+        chainId: a.chainId,
+        settlementAddress: a.settlementAddress,
+        tokenAddress: a.tokenAddress,
+        tokenNetwork: a.tokenNetwork
       });
-      peerChannels.set(peer, this.apexChannelId);
+      peerChannels.set(peer, apex.apexChannelId);
       this.log(
-        `[runner] routed child peer "${peer}" through apex channel ${this.apexChannelId}`
+        `[runner] routed child peer "${peer}" through apex channel ${apex.apexChannelId}`
       );
     }
   }
+  // ── Status ─────────────────────────────────────────────────────────────────
+  defaultApex() {
+    return this.apexes.get(this.defaultBtpUrl);
+  }
+  /** Whether any apex has finished bootstrapping. */
   isReady() {
-    return this.ready;
+    return [...this.apexes.values()].some((a) => a.ready);
   }
   isBootstrapping() {
-    return this.bootstrapping;
+    return [...this.apexes.values()].some((a) => a.bootstrapping);
   }
   getStatus() {
-    const net = this.client.getNetworkStatus();
+    const apex = this.defaultApex();
+    const client = apex?.client;
+    const net = client?.getNetworkStatus();
     const network = net ? ["evm", "solana", "mina"].map((c) => ({
       chain: c,
       ready: net[c] === "configured",
       detail: net[c]
     })) : void 0;
+    const relay = this.relays.get(this.defaultRelayUrl);
     return {
       uptimeMs: Date.now() - this.startedAt,
-      bootstrapping: this.bootstrapping,
-      ready: this.ready,
+      bootstrapping: apex?.bootstrapping ?? false,
+      ready: apex?.ready ?? false,
       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())
+        nostrPubkey: safe(() => client?.getPublicKey()) ?? "",
+        evmAddress: safe(() => client?.getEvmAddress()),
+        solanaAddress: safe(() => client?.getSolanaAddress()),
+        minaAddress: safe(() => client?.getMinaAddress())
       },
       transport: {
         type: this.config.socksProxy ? "socks5" : "direct",
-        socksProxy: this.config.socksProxy,
-        btpUrl: this.config.toonClientConfig.btpUrl
+        ...this.config.socksProxy ? { socksProxy: this.config.socksProxy } : {},
+        ...apex ? { btpUrl: apex.btpUrl } : {}
       },
       relay: {
-        url: this.config.relayUrl,
-        connected: this.relay.isConnected(),
-        buffered: this.relay.bufferedCount(),
-        subscriptions: this.relay.activeSubscriptions(),
+        url: this.defaultRelayUrl,
+        connected: relay?.isConnected() ?? false,
+        buffered: relay?.bufferedCount() ?? 0,
+        subscriptions: relay?.activeSubscriptions() ?? [],
         ...this.readProxyError ? { proxyError: this.readProxyError } : {}
       },
       ...network ? { network } : {},
-      ...this.lastError ? { lastError: this.lastError } : {}
+      ...apex?.lastError ? { lastError: apex.lastError } : {}
     };
   }
-  /** Pay-to-write a single event. Throws NOT_READY while bootstrapping. */
+  /** Full registry of relay + apex targets with per-target status. */
+  getTargets() {
+    const relays = [...this.relays.entries()].map(
+      ([relayUrl, r]) => ({
+        relayUrl,
+        connected: r.isConnected(),
+        buffered: r.bufferedCount(),
+        subscriptions: r.activeSubscriptions(),
+        isDefault: relayUrl === this.defaultRelayUrl
+      })
+    );
+    const apexes = [...this.apexes.values()].map((a) => ({
+      btpUrl: a.btpUrl,
+      destination: a.destination,
+      chain: a.chain,
+      ready: a.ready,
+      bootstrapping: a.bootstrapping,
+      ...a.apexChannelId ? { channelId: a.apexChannelId } : {},
+      ...a.lastError ? { lastError: a.lastError } : {},
+      isDefault: a.isDefault
+    }));
+    return { relays, apexes };
+  }
+  // ── Paid operations ──────────────────────────────────────────────────────
+  /** Pay-to-write a single event through the selected (or default) apex. */
   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,
+    const apex = this.selectApex(req.btpUrl);
+    this.assertApexReady(apex);
+    const channelId = apex.apexChannelId ?? await apex.client.openChannel(req.destination);
+    const fee = req.fee !== void 0 ? BigInt(req.fee) : apex.feePerEvent;
+    const claim = await apex.client.signBalanceProof(channelId, fee);
+    const result = await apex.client.publishEvent(req.event, {
+      ...req.destination ? { destination: req.destination } : {},
       claim,
       ilpAmount: fee
     });
@@ -1481,63 +1926,47 @@ var ClientRunner = class {
     }
     return {
       eventId: result.eventId ?? req.event.id,
-      data: result.data,
+      ...result.data !== void 0 ? { data: result.data } : {},
       channelId,
-      nonce: this.client.getChannelNonce(channelId)
+      nonce: apex.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
+  /** Open (or return) a payment channel on the selected (or default) apex. */
+  async openChannel(destination, btpUrl) {
+    const apex = this.selectApex(btpUrl);
+    this.assertApexReady(apex);
+    const channelId = await apex.client.openChannel(
+      destination ?? apex.destination
     );
-    if (!destination || destination === this.config.destination) {
-      this.apexChannelId = channelId;
+    if (!destination || destination === apex.destination) {
+      apex.apexChannelId = channelId;
     }
     return { channelId };
   }
-  /** List tracked channels with their nonce watermark + cumulative amount. */
+  /** List tracked channels across ALL apexes with nonce + cumulative amount. */
   getChannels() {
-    const channels = this.client.getTrackedChannels().map((channelId) => ({
-      channelId,
-      nonce: this.client.getChannelNonce(channelId),
-      cumulativeAmount: this.client.getChannelCumulativeAmount(channelId).toString()
-    }));
+    const seen = /* @__PURE__ */ new Set();
+    const channels = [];
+    for (const apex of this.apexes.values()) {
+      for (const channelId of apex.client.getTrackedChannels()) {
+        if (seen.has(channelId)) continue;
+        seen.add(channelId);
+        channels.push({
+          channelId,
+          nonce: apex.client.getChannelNonce(channelId),
+          cumulativeAmount: apex.client.getChannelCumulativeAmount(channelId).toString()
+        });
+      }
+    }
     return { channels };
   }
-  /**
-   * Swap source asset → target asset against a mill peer.
-   *
-   * Uses SDK `streamSwap`, which builds a NIP-59 gift-wrapped kind:20032 swap
-   * rumor per packet and sends it over the open BTP session. The source-asset
-   * balance proof is signed by the ToonClient's ChannelManager against the apex
-   * channel — so the mill peer MUST be routed via `apexChildPeers` (otherwise
-   * there is no channel to sign against and the mill rejects with F99).
-   *
-   * A fresh ephemeral gift-wrap key is generated per swap (used for sealing the
-   * rumor AND decrypting the FULFILL claims) — independent of the daemon's
-   * settlement identity, so callers never need to expose a key.
-   */
+  /** Swap source→target asset against a mill peer via the selected apex. */
   async swap(req) {
-    this.assertReady();
+    const apex = this.selectApex(req.btpUrl);
+    this.assertApexReady(apex);
     const senderSecretKey = generateSecretKey2();
     const result = await streamSwap({
-      client: this.client,
+      client: apex.client,
       millPubkey: req.millPubkey,
       millIlpAddress: req.destination,
       pair: req.pair,
@@ -1567,33 +1996,42 @@ var ClientRunner = class {
       ...firstReject ? { code: firstReject.code, message: firstReject.message } : {}
     };
   }
-  /** Graceful teardown of the relay subscription + ToonClient. */
+  /** Graceful teardown: close every relay + stop every apex client + read proxy. */
   async stop() {
     if (this.stopped) return;
     this.stopped = true;
-    this.relay.close();
+    for (const relay of this.relays.values()) relay.close();
     if (this.stopReadProxy) {
       try {
         await this.stopReadProxy();
       } catch (err) {
-        this.log(
-          `[runner] read proxy stop error: ${err instanceof Error ? err.message : String(err)}`
-        );
+        this.log(`[runner] read proxy stop error: ${errMsg2(err)}`);
       }
       this.stopReadProxy = void 0;
     }
-    try {
-      await this.client.stop();
-    } catch (err) {
-      this.log(
-        `[runner] client stop error: ${err instanceof Error ? err.message : String(err)}`
-      );
+    for (const apex of this.apexes.values()) {
+      try {
+        await apex.client.stop();
+      } catch (err) {
+        this.log(`[runner] client stop error (${apex.btpUrl}): ${errMsg2(err)}`);
+      }
     }
   }
-  assertReady() {
-    if (!this.ready) {
+  // ── internals ────────────────────────────────────────────────────────────
+  selectApex(btpUrl) {
+    if (btpUrl) {
+      const apex = this.apexes.get(btpUrl);
+      if (!apex) throw new TargetError(`No such apex: ${btpUrl}`);
+      return apex;
+    }
+    const def = this.defaultApex();
+    if (!def) throw new NotReadyError("No apex configured.");
+    return def;
+  }
+  assertApexReady(apex) {
+    if (!apex.ready) {
       throw new NotReadyError(
-        this.bootstrapping ? "Daemon is still bootstrapping (BTP/anon coming up) \u2014 retry shortly." : this.lastError ?? "Daemon is not ready."
+        apex.bootstrapping ? "Apex is still bootstrapping (BTP/anon coming up) \u2014 retry shortly." : apex.lastError ?? "Apex is not ready."
       );
     }
   }
@@ -1611,6 +2049,12 @@ var PublishRejectedError = class extends Error {
     this.name = "PublishRejectedError";
   }
 };
+var TargetError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TargetError";
+  }
+};
 function safe(fn) {
   try {
     return fn();
@@ -1618,6 +2062,19 @@ function safe(fn) {
     return void 0;
   }
 }
+function errMsg2(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function sanitize(s) {
+  return s.replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
+}
+function isAnyoneHost(url) {
+  try {
+    return new URL(url).hostname.endsWith(".anyone");
+  } catch {
+    return false;
+  }
+}
 
 // src/daemon/routes.ts
 function registerRoutes(app, runner) {
@@ -1642,19 +2099,21 @@ function registerRoutes(app, runner) {
         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);
+    try {
+      return runner.subscribe(body);
+    } catch (err) {
+      return mapError(reply, err);
     }
-  );
+  });
+  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);
+    if (q.relayUrl) query.relayUrl = q.relayUrl;
+    return runner.getEvents(query);
+  });
   app.post("/channels", async (req, reply) => {
     try {
       return await runner.openChannel(req.body?.destination);
@@ -1676,6 +2135,62 @@ function registerRoutes(app, runner) {
       return mapError(reply, err);
     }
   });
+  app.get("/targets", async () => runner.getTargets());
+  app.post("/relays", async (req, reply) => {
+    const url = req.body?.relayUrl;
+    if (!url) {
+      return sendError(reply, 400, "invalid_relay", {
+        detail: "body.relayUrl is required."
+      });
+    }
+    try {
+      await runner.addRelay(url);
+      return runner.getTargets();
+    } catch (err) {
+      return mapError(reply, err);
+    }
+  });
+  app.delete("/relays", async (req, reply) => {
+    const url = req.body?.relayUrl;
+    if (!url) {
+      return sendError(reply, 400, "invalid_relay", {
+        detail: "body.relayUrl is required."
+      });
+    }
+    try {
+      runner.removeRelay(url);
+      return runner.getTargets();
+    } catch (err) {
+      return mapError(reply, err);
+    }
+  });
+  app.post("/apex", async (req, reply) => {
+    const body = req.body;
+    if (!body || !body.ilpAddress || !body.relayUrl) {
+      return sendError(reply, 400, "invalid_apex", {
+        detail: "body.ilpAddress and body.relayUrl are required."
+      });
+    }
+    try {
+      return await runner.addApex(body);
+    } catch (err) {
+      return mapError(reply, err);
+    }
+  });
+  app.delete("/apex", async (req, reply) => {
+    const url = req.body?.btpUrl;
+    if (!url) {
+      return sendError(reply, 400, "invalid_apex", {
+        detail: "body.btpUrl is required."
+      });
+    }
+    try {
+      await runner.removeApex(url);
+      return runner.getTargets();
+    } catch (err) {
+      return mapError(reply, err);
+    }
+  });
 }
 function isSignedEvent(event) {
   if (typeof event !== "object" || event === null) return false;
@@ -1692,6 +2207,16 @@ function mapError(reply, err) {
   if (err instanceof PublishRejectedError) {
     return sendError(reply, 502, "rejected", { detail: err.message });
   }
+  if (err instanceof TargetError) {
+    const status = /no such/i.test(err.message) ? 404 : 400;
+    return sendError(reply, status, "invalid_target", { detail: err.message });
+  }
+  if (err instanceof ApexDiscoveryError) {
+    return err.retryable ? sendError(reply, 504, "discovery_timeout", {
+      detail: err.message,
+      retryable: true
+    }) : sendError(reply, 502, "discovery_failed", { detail: err.message });
+  }
   return sendError(reply, 500, "internal_error", {
     detail: err instanceof Error ? err.message : String(err)
   });
@@ -1714,4 +2239,4 @@ export {
   PublishRejectedError,
   registerRoutes
 };
-//# sourceMappingURL=chunk-PRFPAEGG.js.map
+//# sourceMappingURL=chunk-7WCDT25E.js.map