@toon-protocol/client-mcp 0.29.6 → 0.31.0

package/dist/chunk-4K6S3VPM.js

@@ -0,0 +1,1567 @@
+import { createRequire as __cr } from 'module'; const require = __cr(import.meta.url);
+import {
+  ToonError,
+  buildIlpPrepare,
+  decodeEventFromToon,
+  encodeEventToToon
+} from "./chunk-QHNSETFB.js";
+import {
+  __require
+} from "./chunk-F22GNSF6.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/client-runner.ts
+import { generateSecretKey as generateSecretKey2 } from "nostr-tools/pure";
+
+// ../sdk/dist/chunk-UP2VWCW5.js
+var __require2 = /* @__PURE__ */ ((x) => typeof __require !== "undefined" ? __require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof __require !== "undefined" ? __require : a)[b]
+}) : x)(function(x) {
+  if (typeof __require !== "undefined") return __require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// ../sdk/dist/chunk-XTHUXP63.js
+import { getPublicKey } from "nostr-tools/pure";
+import { generateSecretKey, getPublicKey as getPublicKey2 } from "nostr-tools/pure";
+import { createRumor, createSeal, createWrap } from "nostr-tools/nip59";
+import {
+  encrypt as nip44Encrypt,
+  decrypt as nip44Decrypt,
+  getConversationKey
+} from "nostr-tools/nip44";
+import { getPublicKey as getPublicKey3 } from "nostr-tools/pure";
+var IdentityError = class extends ToonError {
+  constructor(message, cause) {
+    super(message, "IDENTITY_ERROR", cause);
+    this.name = "IdentityError";
+  }
+};
+var GiftWrapError = class extends ToonError {
+  constructor(message, cause) {
+    super(message, "GIFT_WRAP_ERROR", cause);
+    this.name = "GiftWrapError";
+  }
+};
+var SwapHandlerError = class extends ToonError {
+  constructor(message, cause) {
+    super(message, "SWAP_HANDLER_ERROR", cause);
+    this.name = "SwapHandlerError";
+  }
+};
+var StreamSwapError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message);
+    this.name = "StreamSwapError";
+    this.code = code;
+    if (options && "cause" in options) {
+      Object.defineProperty(this, "cause", {
+        value: options.cause,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      });
+    }
+  }
+};
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function base58Decode(str) {
+  let zeros = 0;
+  for (let i = 0; i < str.length && str[i] === "1"; i++) zeros++;
+  let value = 0n;
+  for (const ch of str) {
+    const idx = BASE58_ALPHABET.indexOf(ch);
+    if (idx === -1) throw new IdentityError(`Invalid base58 character: ${ch}`);
+    value = value * 58n + BigInt(idx);
+  }
+  const hex = value === 0n ? "" : value.toString(16);
+  const hexPadded = hex.length % 2 ? "0" + hex : hex;
+  const rawBytes = [];
+  for (let i = 0; i < hexPadded.length; i += 2) {
+    rawBytes.push(parseInt(hexPadded.slice(i, i + 2), 16));
+  }
+  const result = new Uint8Array(zeros + rawBytes.length);
+  result.set(rawBytes, zeros);
+  return result;
+}
+function validateSecretKey(key2, paramName) {
+  if (!(key2 instanceof Uint8Array) || key2.length !== 32) {
+    throw new GiftWrapError(
+      `${paramName} must be a 32-byte Uint8Array, got ${key2 instanceof Uint8Array ? `${key2.length} bytes` : typeof key2}`
+    );
+  }
+}
+function validatePubkey(pubkey, paramName) {
+  if (typeof pubkey !== "string" || !/^[0-9a-f]{64}$/.test(pubkey)) {
+    throw new GiftWrapError(
+      `${paramName} must be a 64-character lowercase hex string`
+    );
+  }
+}
+function wrapSwapPacket(params) {
+  const { rumor, senderSecretKey, recipientPubkey } = params;
+  validateSecretKey(senderSecretKey, "senderSecretKey");
+  validatePubkey(recipientPubkey, "recipientPubkey");
+  try {
+    const rumorEvent = createRumor(rumor, senderSecretKey);
+    const seal = createSeal(rumorEvent, senderSecretKey, recipientPubkey);
+    const giftWrap = createWrap(seal, recipientPubkey);
+    const ephemeralPubkey = giftWrap.pubkey;
+    return { giftWrap, ephemeralPubkey };
+  } catch (error) {
+    throw new GiftWrapError(
+      `Failed to wrap swap packet: ${error instanceof Error ? error.message : String(error)}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+function wrapSwapPacketToToon(params) {
+  const {
+    rumor,
+    senderSecretKey,
+    recipientPubkey,
+    destination,
+    amount,
+    expiresAt
+  } = params;
+  const { giftWrap, ephemeralPubkey } = wrapSwapPacket({
+    rumor,
+    senderSecretKey,
+    recipientPubkey
+  });
+  const toonBinary = encodeEventToToon(giftWrap);
+  const ilpPrepare = buildIlpPrepare({
+    destination,
+    amount,
+    data: toonBinary,
+    expiresAt
+  });
+  return { ilpPrepare, ephemeralPubkey };
+}
+function decryptFulfillClaim(params) {
+  const { ciphertext, ephemeralPubkey, recipientSecretKey } = params;
+  validateSecretKey(recipientSecretKey, "recipientSecretKey");
+  validatePubkey(ephemeralPubkey, "ephemeralPubkey");
+  if (!(ciphertext instanceof Uint8Array) || ciphertext.length === 0) {
+    throw new GiftWrapError("ciphertext must be a non-empty Uint8Array");
+  }
+  let conversationKey = null;
+  try {
+    conversationKey = getConversationKey(recipientSecretKey, ephemeralPubkey);
+    const ciphertextString = new TextDecoder().decode(ciphertext);
+    const claimString = nip44Decrypt(ciphertextString, conversationKey);
+    return new Uint8Array(Buffer.from(claimString, "base64"));
+  } catch (error) {
+    if (error instanceof GiftWrapError) {
+      throw error;
+    }
+    throw new GiftWrapError(
+      `Failed to decrypt FULFILL claim: ${error instanceof Error ? error.message : String(error)}`,
+      error instanceof Error ? error : void 0
+    );
+  } finally {
+    if (conversationKey) {
+      conversationKey.fill(0);
+      conversationKey = null;
+    }
+  }
+}
+var RATE_REGEX = /^(0|[1-9]\d*)(\.\d+)?$/;
+function applyRate(params) {
+  const { sourceAmount, fromScale, toScale, rate } = params;
+  if (!RATE_REGEX.test(rate)) {
+    throw new SwapHandlerError(`Invalid rate format: ${rate}`);
+  }
+  if (/^0(\.0+)?$/.test(rate)) {
+    throw new SwapHandlerError("Rate is zero (pair not quoting)");
+  }
+  if (sourceAmount <= 0n) {
+    throw new SwapHandlerError(
+      `sourceAmount must be positive, got ${sourceAmount}`
+    );
+  }
+  const dotIdx = rate.indexOf(".");
+  const integerPart = dotIdx === -1 ? rate : rate.slice(0, dotIdx);
+  const fractionalPart = dotIdx === -1 ? "" : rate.slice(dotIdx + 1);
+  const rateNumerator = BigInt(integerPart + fractionalPart);
+  const rateDenominator = 10n ** BigInt(fractionalPart.length);
+  const scaleUp = 10n ** BigInt(toScale);
+  const scaleDown = 10n ** BigInt(fromScale);
+  return sourceAmount * rateNumerator * scaleUp / (rateDenominator * scaleDown);
+}
+var RATE_REGEX2 = /^(0|[1-9]\d*)(\.\d+)?$/;
+var HEX64_REGEX = /^[0-9a-f]{64}$/;
+var BASE64_REGEX = /^[A-Za-z0-9+/]+={0,2}$/;
+function isBase64(s) {
+  if (s.length === 0 || s.length % 4 !== 0) return false;
+  return BASE64_REGEX.test(s);
+}
+function chunkAmount(total, count) {
+  if (!Number.isInteger(count) || count <= 0 || count > Number.MAX_SAFE_INTEGER) {
+    throw new StreamSwapError(
+      "INVALID_CHUNKING",
+      `packetCount must be a positive integer, got ${count}`
+    );
+  }
+  if (total < BigInt(count)) {
+    throw new StreamSwapError(
+      "INVALID_CHUNKING",
+      `totalAmount (${total}) must be >= packetCount (${count}) so per-packet amount >= 1`
+    );
+  }
+  const base = total / BigInt(count);
+  const remainder = total - base * BigInt(count);
+  const out = new Array(count);
+  for (let i = 0; i < count; i++) out[i] = base;
+  const last = out[count - 1] ?? 0n;
+  out[count - 1] = last + remainder;
+  return out;
+}
+function buildSwapRumor(input) {
+  const {
+    senderPubkey,
+    pair,
+    sourceAmount,
+    packetIndex,
+    totalPackets,
+    nonce,
+    createdAt,
+    chainRecipient
+  } = input;
+  return {
+    kind: 20032,
+    pubkey: senderPubkey,
+    content: "",
+    created_at: createdAt,
+    tags: [
+      ["swap-from", `${pair.from.assetCode}:${pair.from.chain}`],
+      ["swap-to", `${pair.to.assetCode}:${pair.to.chain}`],
+      ["amount", sourceAmount.toString()],
+      ["seq", String(packetIndex), String(totalPackets)],
+      ["nonce", Buffer.from(nonce).toString("hex")],
+      ["chain-recipient", chainRecipient]
+    ]
+  };
+}
+var EVM_CHANNEL_ID_REGEX = /^0x[0-9a-f]{64}$/;
+var EVM_ADDRESS_REGEX = /^0x[0-9a-f]{40}$/;
+var DECIMAL_UINT_REGEX = /^(0|[1-9]\d*)$/;
+var BASE58_REGEX = /^[1-9A-HJ-NP-Za-km-z]+$/;
+function validateChainAddress(value, chain, kind) {
+  if (chain.startsWith("evm:")) {
+    const normalized = value.toLowerCase();
+    if (kind === "channelId") return EVM_CHANNEL_ID_REGEX.test(normalized);
+    return EVM_ADDRESS_REGEX.test(normalized);
+  }
+  if (chain.startsWith("solana:")) {
+    if (!BASE58_REGEX.test(value)) return false;
+    if (value.length < 32 || value.length > 44) return false;
+    try {
+      return base58Decode(value).length === 32;
+    } catch {
+      return false;
+    }
+  }
+  if (chain.startsWith("mina:")) {
+    return BASE58_REGEX.test(value) && value.length >= 32;
+  }
+  return value.length > 0;
+}
+function decodeFulfillMetadata(data, chain) {
+  if (data === void 0 || data === null || data === "") {
+    throw new StreamSwapError("FULFILL_DECODE_FAILED", "FULFILL data missing");
+  }
+  if (!isBase64(data)) {
+    throw new StreamSwapError(
+      "FULFILL_DECODE_FAILED",
+      "FULFILL data is not valid base64"
+    );
+  }
+  let jsonBytes;
+  try {
+    jsonBytes = Buffer.from(data, "base64");
+  } catch (err) {
+    throw new StreamSwapError(
+      "FULFILL_DECODE_FAILED",
+      `FULFILL data base64 decode failed: ${err instanceof Error ? err.message : String(err)}`,
+      { cause: err }
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonBytes.toString("utf8"));
+  } catch (err) {
+    throw new StreamSwapError(
+      "FULFILL_DECODE_FAILED",
+      `FULFILL data JSON parse failed: ${err instanceof Error ? err.message : String(err)}`,
+      { cause: err }
+    );
+  }
+  if (!parsed || typeof parsed !== "object") {
+    throw new StreamSwapError(
+      "FULFILL_DECODE_FAILED",
+      "FULFILL metadata is not an object"
+    );
+  }
+  const obj = parsed;
+  const claim = obj["claim"];
+  const ephemeralPubkey = obj["ephemeralPubkey"];
+  if (typeof claim !== "string" || !isBase64(claim)) {
+    throw new StreamSwapError(
+      "FULFILL_DECODE_FAILED",
+      "FULFILL metadata.claim is missing or not base64 string"
+    );
+  }
+  if (typeof ephemeralPubkey !== "string" || !HEX64_REGEX.test(ephemeralPubkey)) {
+    throw new StreamSwapError(
+      "FULFILL_DECODE_FAILED",
+      "FULFILL metadata.ephemeralPubkey is missing or not 64-char hex"
+    );
+  }
+  const result = {
+    claim,
+    ephemeralPubkey
+  };
+  if (typeof obj["claimId"] === "string") {
+    result.claimId = obj["claimId"];
+  }
+  if (obj["targetAmount"] !== void 0) {
+    const ta = obj["targetAmount"];
+    if (typeof ta !== "string" || !/^(0|[1-9]\d*)$/.test(ta)) {
+      throw new StreamSwapError(
+        "FULFILL_DECODE_FAILED",
+        "FULFILL metadata.targetAmount must be a non-negative integer decimal string"
+      );
+    }
+    result.targetAmount = ta;
+  }
+  const channelId = obj["channelId"];
+  if (typeof channelId === "string" && (!chain || validateChainAddress(channelId, chain, "channelId"))) {
+    result.channelId = channelId;
+  }
+  const nonce = obj["nonce"];
+  if (typeof nonce === "string" && DECIMAL_UINT_REGEX.test(nonce)) {
+    result.nonce = nonce;
+  }
+  const cumulativeAmount = obj["cumulativeAmount"];
+  if (typeof cumulativeAmount === "string" && DECIMAL_UINT_REGEX.test(cumulativeAmount)) {
+    result.cumulativeAmount = cumulativeAmount;
+  }
+  const recipient = obj["recipient"];
+  if (typeof recipient === "string" && recipient.length > 0) {
+    result.recipient = recipient;
+  }
+  const millSignerAddress = obj["millSignerAddress"];
+  if (typeof millSignerAddress === "string" && (!chain || validateChainAddress(millSignerAddress, chain, "address"))) {
+    result.millSignerAddress = millSignerAddress;
+  }
+  return result;
+}
+var Deferred = class {
+  promise;
+  resolve;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- mirror Promise constructor
+  reject;
+  constructor() {
+    this.promise = new Promise((res, rej) => {
+      this.resolve = res;
+      this.reject = rej;
+    });
+  }
+};
+var noop2 = () => void 0;
+var NOOP_LOGGER2 = {
+  debug: noop2,
+  info: noop2,
+  warn: noop2,
+  error: noop2
+};
+function validateParams(params) {
+  if (typeof params.totalAmount !== "bigint" || params.totalAmount <= 0n) {
+    throw new StreamSwapError(
+      "INVALID_AMOUNT",
+      `totalAmount must be a positive bigint, got ${String(params.totalAmount)}`
+    );
+  }
+  const hasCount = params.packetCount !== void 0;
+  const hasAmounts = params.packetAmounts !== void 0;
+  if (hasCount === hasAmounts) {
+    throw new StreamSwapError(
+      "INVALID_CHUNKING",
+      "Exactly one of packetCount or packetAmounts must be provided"
+    );
+  }
+  if (hasCount) {
+    const c = params.packetCount;
+    if (!Number.isInteger(c) || c <= 0) {
+      throw new StreamSwapError(
+        "INVALID_CHUNKING",
+        `packetCount must be a positive integer, got ${c}`
+      );
+    }
+    if (BigInt(c) > params.totalAmount) {
+      throw new StreamSwapError(
+        "INVALID_CHUNKING",
+        `packetCount (${c}) exceeds totalAmount (${params.totalAmount}); per-packet amount would be < 1 micro-unit`
+      );
+    }
+  } else {
+    const arr = params.packetAmounts;
+    if (!Array.isArray(arr) || arr.length === 0) {
+      throw new StreamSwapError(
+        "INVALID_CHUNKING",
+        "packetAmounts must be a non-empty array"
+      );
+    }
+    let sum = 0n;
+    for (const a of arr) {
+      if (typeof a !== "bigint" || a <= 0n) {
+        throw new StreamSwapError(
+          "INVALID_CHUNKING",
+          `packetAmounts entries must be positive bigint, got ${String(a)}`
+        );
+      }
+      sum += a;
+    }
+    if (sum !== params.totalAmount) {
+      throw new StreamSwapError(
+        "INVALID_CHUNKING",
+        `sum(packetAmounts) (${sum}) !== totalAmount (${params.totalAmount})`
+      );
+    }
+  }
+  if (!(params.senderSecretKey instanceof Uint8Array) || params.senderSecretKey.length !== 32) {
+    throw new StreamSwapError(
+      "INVALID_STATE",
+      "senderSecretKey must be a 32-byte Uint8Array"
+    );
+  }
+  if (typeof params.millPubkey !== "string" || !HEX64_REGEX.test(params.millPubkey)) {
+    throw new StreamSwapError(
+      "INVALID_STATE",
+      "millPubkey must be a 64-char lowercase hex string"
+    );
+  }
+  if (!params.pair || typeof params.pair !== "object") {
+    throw new StreamSwapError("INVALID_PAIR", "pair is required");
+  }
+  if (!params.pair.from || typeof params.pair.from !== "object" || typeof params.pair.from.assetCode !== "string" || typeof params.pair.from.assetScale !== "number" || typeof params.pair.from.chain !== "string") {
+    throw new StreamSwapError(
+      "INVALID_PAIR",
+      "pair.from must have { assetCode: string, assetScale: number, chain: string }"
+    );
+  }
+  if (!params.pair.to || typeof params.pair.to !== "object" || typeof params.pair.to.assetCode !== "string" || typeof params.pair.to.assetScale !== "number" || typeof params.pair.to.chain !== "string") {
+    throw new StreamSwapError(
+      "INVALID_PAIR",
+      "pair.to must have { assetCode: string, assetScale: number, chain: string }"
+    );
+  }
+  if (typeof params.pair.rate !== "string" || !RATE_REGEX2.test(params.pair.rate)) {
+    throw new StreamSwapError(
+      "INVALID_PAIR",
+      `pair.rate must match ${RATE_REGEX2}, got ${params.pair.rate}`
+    );
+  }
+  try {
+    applyRate({
+      sourceAmount: 1n,
+      fromScale: params.pair.from.assetScale,
+      toScale: params.pair.to.assetScale,
+      rate: params.pair.rate
+    });
+  } catch (err) {
+    throw new StreamSwapError(
+      "INVALID_PAIR",
+      `pair failed applyRate sanity check: ${err instanceof Error ? err.message : String(err)}`,
+      { cause: err }
+    );
+  }
+  if (params.rateDeviationThreshold !== void 0 && (typeof params.rateDeviationThreshold !== "number" || !Number.isFinite(params.rateDeviationThreshold) || params.rateDeviationThreshold < 0)) {
+    throw new StreamSwapError(
+      "INVALID_STATE",
+      `rateDeviationThreshold must be a non-negative finite number, got ${params.rateDeviationThreshold}`
+    );
+  }
+  if (typeof params.chainRecipient !== "string" || params.chainRecipient.length === 0) {
+    throw new StreamSwapError(
+      "INVALID_STATE",
+      "chainRecipient must be a non-empty string (sender payout address for pair.to.chain)"
+    );
+  }
+  if (!validateChainAddress(
+    params.chainRecipient,
+    params.pair.to.chain,
+    "address"
+  )) {
+    throw new StreamSwapError(
+      "INVALID_CHAIN_RECIPIENT",
+      `chainRecipient ${params.chainRecipient} is malformed for chain ${params.pair.to.chain}`
+    );
+  }
+}
+async function streamSwap(params) {
+  return streamSwapControlled(params).result;
+}
+function streamSwapControlled(params) {
+  validateParams(params);
+  const logger = params.logger ?? NOOP_LOGGER2;
+  const schedule = params.packetAmounts ? [...params.packetAmounts] : chunkAmount(params.totalAmount, params.packetCount);
+  const frozenPair = Object.freeze({
+    from: Object.freeze({ ...params.pair.from }),
+    to: Object.freeze({ ...params.pair.to }),
+    rate: params.pair.rate
+  });
+  const senderPubkey = getPublicKey3(params.senderSecretKey);
+  let streamState = "running";
+  let resumeDeferred = null;
+  const controller = {
+    pause() {
+      if (streamState === "running") {
+        streamState = "paused";
+      }
+    },
+    resume() {
+      if (streamState === "paused") {
+        streamState = "running";
+        if (resumeDeferred) {
+          resumeDeferred.resolve("resume");
+          resumeDeferred = null;
+        }
+      } else if (streamState === "running") {
+      } else {
+        throw new StreamSwapError(
+          "INVALID_STATE",
+          `Cannot resume from state "${streamState}"`
+        );
+      }
+    },
+    stop() {
+      if (streamState === "completed" || streamState === "failed") return;
+      const prev = streamState;
+      streamState = "stopped";
+      if (prev === "paused" && resumeDeferred) {
+        resumeDeferred.resolve("stop");
+        resumeDeferred = null;
+      }
+    },
+    get state() {
+      return streamState;
+    }
+  };
+  const result = runLoop(
+    params,
+    frozenPair,
+    schedule,
+    senderPubkey,
+    logger,
+    () => streamState,
+    (v) => {
+      streamState = v;
+    },
+    () => {
+      if (streamState !== "paused") return Promise.resolve("resume");
+      if (!resumeDeferred) resumeDeferred = new Deferred();
+      return resumeDeferred.promise;
+    }
+  );
+  return { result, controller };
+}
+async function runLoop(params, pair, schedule, senderPubkey, logger, getState, setState, waitForResumeOrStop) {
+  const claims = [];
+  const rejections = [];
+  const errors = [];
+  let cumulativeSource = 0n;
+  let cumulativeTarget = 0n;
+  let packetsSent = 0;
+  let abortReason = "complete";
+  const totalPackets = schedule.length;
+  const isAborted = () => params.signal?.aborted === true;
+  packetLoop: for (let packetIndex = 0; packetIndex < totalPackets; packetIndex++) {
+    if (isAborted()) {
+      abortReason = "aborted";
+      break;
+    }
+    if (getState() === "stopped") {
+      abortReason = "stopped";
+      break;
+    }
+    if (getState() === "paused") {
+      const resumedBy = await waitForResumeOrStop();
+      if (resumedBy === "stop" || getState() === "stopped") {
+        abortReason = "stopped";
+        break;
+      }
+      if (isAborted()) {
+        abortReason = "aborted";
+        break;
+      }
+    }
+    const sourceAmount = schedule[packetIndex];
+    if (sourceAmount === void 0) {
+      throw new StreamSwapError(
+        "INVALID_STATE",
+        `schedule[${packetIndex}] is undefined; schedule was mutated mid-stream`
+      );
+    }
+    const nonce = new Uint8Array(16);
+    getRandomValues(nonce);
+    const rumor = buildSwapRumor({
+      senderPubkey,
+      pair,
+      sourceAmount,
+      packetIndex: packetIndex + 1,
+      totalPackets,
+      nonce,
+      createdAt: Math.floor(Date.now() / 1e3),
+      chainRecipient: params.chainRecipient
+    });
+    let toonData;
+    try {
+      const wrapped = wrapSwapPacketToToon({
+        rumor,
+        senderSecretKey: params.senderSecretKey,
+        recipientPubkey: params.millPubkey,
+        destination: params.millIlpAddress,
+        amount: sourceAmount
+      });
+      toonData = new Uint8Array(Buffer.from(wrapped.ilpPrepare.data, "base64"));
+    } catch (err) {
+      logger.error({
+        event: "stream_swap.wrap_failed",
+        packetIndex,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      errors.push({
+        packetIndex,
+        cause: err instanceof Error ? err : new Error(String(err))
+      });
+      continue;
+    }
+    let sendResult;
+    try {
+      sendResult = await params.client.sendSwapPacket({
+        destination: params.millIlpAddress,
+        amount: sourceAmount,
+        toonData,
+        timeout: params.packetTimeoutMs ?? 3e4,
+        claim: params.claim
+      });
+      packetsSent += 1;
+    } catch (err) {
+      logger.error({
+        event: "stream_swap.send_failed",
+        packetIndex,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      errors.push({
+        packetIndex,
+        cause: err instanceof Error ? err : new Error(String(err))
+      });
+      continue;
+    }
+    if (!sendResult.accepted) {
+      const code = sendResult.code ?? "F00";
+      const message = sendResult.message ?? "rejected";
+      logger.warn({
+        event: "stream_swap.packet_rejected",
+        packetIndex,
+        code,
+        message
+      });
+      rejections.push({ packetIndex, sourceAmount, code, message });
+      continue;
+    }
+    let metadata;
+    try {
+      metadata = decodeFulfillMetadata(sendResult.data, pair.to.chain);
+    } catch (err) {
+      logger.error({
+        event: "stream_swap.fulfill_decode_failed",
+        packetIndex,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      errors.push({
+        packetIndex,
+        cause: err instanceof Error ? err : new Error(String(err))
+      });
+      continue;
+    }
+    const isEvmTarget = pair.to.chain.startsWith("evm:");
+    const recipientMatches = metadata.recipient === void 0 || (isEvmTarget ? metadata.recipient.toLowerCase() === params.chainRecipient.toLowerCase() : metadata.recipient === params.chainRecipient);
+    if (!recipientMatches) {
+      logger.warn({
+        event: "stream_swap.recipient_mismatch",
+        packetIndex,
+        expected: params.chainRecipient,
+        actual: metadata.recipient
+      });
+      rejections.push({
+        packetIndex,
+        sourceAmount,
+        code: "MILL_RECIPIENT_MISMATCH",
+        message: `Mill echoed recipient ${metadata.recipient} but sender expected ${params.chainRecipient}`
+      });
+      continue;
+    }
+    let claimBytes;
+    try {
+      const ciphertext = new Uint8Array(Buffer.from(metadata.claim, "base64"));
+      claimBytes = decryptFulfillClaim({
+        ciphertext,
+        ephemeralPubkey: metadata.ephemeralPubkey,
+        recipientSecretKey: params.senderSecretKey
+      });
+    } catch (err) {
+      logger.error({
+        event: "stream_swap.decrypt_failed",
+        packetIndex,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      errors.push({
+        packetIndex,
+        cause: err instanceof Error ? err : new Error(String(err))
+      });
+      continue;
+    }
+    if (claimBytes.length === 0) {
+      logger.warn({
+        event: "stream_swap.empty_claim_bytes",
+        packetIndex
+      });
+    }
+    const expectedTargetAmount = applyRate({
+      sourceAmount,
+      fromScale: pair.from.assetScale,
+      toScale: pair.to.assetScale,
+      rate: pair.rate
+    });
+    const targetAmount = metadata.targetAmount !== void 0 ? BigInt(metadata.targetAmount) : expectedTargetAmount;
+    let rateDeviation = 0;
+    if (expectedTargetAmount > 0n) {
+      const diff = targetAmount >= expectedTargetAmount ? targetAmount - expectedTargetAmount : expectedTargetAmount - targetAmount;
+      const scaled = diff * 1000000n / expectedTargetAmount;
+      rateDeviation = Number(scaled) / 1e6;
+    }
+    const advertisedRate = parseFloat(pair.rate);
+    let effectiveRate;
+    if (targetAmount === expectedTargetAmount) {
+      effectiveRate = advertisedRate;
+    } else {
+      const signedDeviation = targetAmount >= expectedTargetAmount ? rateDeviation : -rateDeviation;
+      effectiveRate = advertisedRate * (1 + signedDeviation);
+    }
+    if (!Number.isFinite(effectiveRate)) {
+      effectiveRate = advertisedRate;
+    }
+    cumulativeSource += sourceAmount;
+    cumulativeTarget += targetAmount;
+    const accumulated = {
+      packetIndex,
+      sourceAmount,
+      targetAmount,
+      claimBytes,
+      millEphemeralPubkey: metadata.ephemeralPubkey,
+      pair,
+      receivedAt: Date.now()
+    };
+    if (metadata.claimId !== void 0) accumulated.claimId = metadata.claimId;
+    if (metadata.channelId !== void 0)
+      accumulated.channelId = metadata.channelId;
+    if (metadata.nonce !== void 0) accumulated.nonce = metadata.nonce;
+    if (metadata.cumulativeAmount !== void 0)
+      accumulated.cumulativeAmount = metadata.cumulativeAmount;
+    if (metadata.recipient !== void 0)
+      accumulated.recipient = metadata.recipient;
+    if (metadata.millSignerAddress !== void 0)
+      accumulated.millSignerAddress = metadata.millSignerAddress;
+    claims.push(accumulated);
+    logger.debug({
+      event: "stream_swap.packet_accepted",
+      packetIndex,
+      sourceAmount: sourceAmount.toString(),
+      targetAmount: targetAmount.toString()
+    });
+    if (params.onPacket) {
+      const progress = Object.freeze({
+        index: packetIndex,
+        total: totalPackets,
+        sourceAmount,
+        targetAmount,
+        advertisedRate: pair.rate,
+        effectiveRate,
+        rateDeviation,
+        cumulativeSource,
+        cumulativeTarget,
+        state: getState() === "paused" ? "paused" : getState() === "stopped" ? "stopped" : "running"
+      });
+      try {
+        const maybePromise = params.onPacket(progress);
+        if (maybePromise && typeof maybePromise.then === "function") {
+          await maybePromise;
+        }
+      } catch (err) {
+        logger.warn({
+          event: "stream_swap.callback_threw",
+          packetIndex,
+          error: err instanceof Error ? err.message : String(err)
+        });
+        errors.push({
+          packetIndex,
+          cause: err instanceof Error ? err : new Error(String(err))
+        });
+        abortReason = "callback-throw";
+        break packetLoop;
+      }
+    }
+    if (isAborted()) {
+      abortReason = "aborted";
+      break;
+    }
+    if (getState() === "stopped") {
+      abortReason = "stopped";
+      break;
+    }
+    if (params.rateDeviationThreshold !== void 0 && rateDeviation > params.rateDeviationThreshold) {
+      abortReason = "rate-deviation";
+      break;
+    }
+  }
+  let finalState;
+  if (abortReason === "aborted" || abortReason === "stopped") {
+    finalState = "stopped";
+  } else if (claims.length === 0 && (rejections.length > 0 || errors.length > 0)) {
+    finalState = "failed";
+    if (abortReason === "complete" && rejections.length > 0 && errors.length === 0) {
+      abortReason = "all-rejected";
+    }
+  } else {
+    finalState = "completed";
+  }
+  setState(finalState);
+  return {
+    state: finalState,
+    claims,
+    rejections,
+    errors,
+    abortReason,
+    cumulativeSource,
+    cumulativeTarget,
+    packetsSent,
+    packetsScheduled: totalPackets
+  };
+}
+function getRandomValues(buf) {
+  const g = globalThis;
+  if (g.crypto && typeof g.crypto.getRandomValues === "function") {
+    g.crypto.getRandomValues(buf);
+    return buf;
+  }
+  const nodeCrypto = __require2("crypto");
+  if (nodeCrypto.webcrypto?.getRandomValues) {
+    nodeCrypto.webcrypto.getRandomValues(buf);
+    return buf;
+  }
+  if (nodeCrypto.randomFillSync) {
+    nodeCrypto.randomFillSync(buf);
+    return buf;
+  }
+  throw new StreamSwapError(
+    "INVALID_STATE",
+    "No crypto.getRandomValues available in this environment"
+  );
+}
+
+// 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 };
+  }
+  /**
+   * 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.
+   */
+  async swap(req) {
+    this.assertReady();
+    const senderSecretKey = generateSecretKey2();
+    const result = await streamSwap({
+      client: this.client,
+      millPubkey: req.millPubkey,
+      millIlpAddress: req.destination,
+      pair: req.pair,
+      senderSecretKey,
+      chainRecipient: req.chainRecipient,
+      totalAmount: BigInt(req.amount),
+      packetCount: req.packetCount ?? 1
+    });
+    const firstReject = result.rejections[0];
+    return {
+      accepted: result.claims.length > 0,
+      packetsAccepted: result.claims.length,
+      claims: result.claims.map((c) => ({
+        sourceAmount: c.sourceAmount.toString(),
+        targetAmount: c.targetAmount.toString(),
+        claim: Buffer.from(c.claimBytes).toString("base64"),
+        ...c.channelId ? { channelId: c.channelId } : {},
+        ...c.recipient ? { recipient: c.recipient } : {},
+        ...c.millSignerAddress ? { millSignerAddress: c.millSignerAddress } : {},
+        ...c.claimId ? { claimId: c.claimId } : {},
+        ...c.nonce ? { nonce: c.nonce } : {},
+        ...c.cumulativeAmount ? { cumulativeAmount: c.cumulativeAmount } : {}
+      })),
+      cumulativeSource: result.cumulativeSource.toString(),
+      cumulativeTarget: result.cumulativeTarget.toString(),
+      state: result.state,
+      ...firstReject ? { code: firstReject.code, message: firstReject.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 || !body.millPubkey || !body.pair || !body.chainRecipient) {
+      return sendError(reply, 400, "invalid_swap", {
+        detail: "body.destination, amount, millPubkey, pair, and chainRecipient 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-4K6S3VPM.js.map