@toon-protocol/core 1.1.1

package/dist/index.js

@@ -0,0 +1,3495 @@
+import {
+  InvalidEventError,
+  PeerDiscoveryError,
+  ToonDecodeError,
+  ToonEncodeError,
+  ToonError,
+  decodeEventFromToon,
+  encodeEventToToon,
+  encodeEventToToonString,
+  shallowParseToon
+} from "./chunk-7AHDGE4H.js";
+
+// src/constants.ts
+var ILP_PEER_INFO_KIND = 10032;
+var SERVICE_DISCOVERY_KIND = 10035;
+var SEED_RELAY_LIST_KIND = 10036;
+var TEE_ATTESTATION_KIND = 10033;
+var JOB_REQUEST_KIND_BASE = 5e3;
+var JOB_RESULT_KIND_BASE = 6e3;
+var JOB_FEEDBACK_KIND = 7e3;
+var TEXT_GENERATION_KIND = 5100;
+var IMAGE_GENERATION_KIND = 5200;
+var TEXT_TO_SPEECH_KIND = 5300;
+var TRANSLATION_KIND = 5302;
+
+// src/events/parsers.ts
+function validateChainId(chainId) {
+  if (!chainId) return false;
+  const segments = chainId.split(":");
+  if (segments.length < 2 || segments.length > 3) return false;
+  return segments.every((s) => s.length > 0);
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function parseIlpPeerInfo(event) {
+  if (event.kind !== ILP_PEER_INFO_KIND) {
+    throw new InvalidEventError(
+      `Expected event kind ${ILP_PEER_INFO_KIND}, got ${event.kind}`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(event.content);
+  } catch (err) {
+    throw new InvalidEventError(
+      "Failed to parse event content as JSON",
+      err instanceof Error ? err : void 0
+    );
+  }
+  if (!isObject(parsed)) {
+    throw new InvalidEventError("Event content must be a JSON object");
+  }
+  const {
+    ilpAddress,
+    btpEndpoint,
+    blsHttpEndpoint,
+    settlementEngine,
+    assetCode,
+    assetScale
+  } = parsed;
+  if (typeof ilpAddress !== "string" || ilpAddress.length === 0) {
+    throw new InvalidEventError(
+      "Missing or invalid required field: ilpAddress"
+    );
+  }
+  if (typeof btpEndpoint !== "string" || btpEndpoint.length === 0) {
+    throw new InvalidEventError(
+      "Missing or invalid required field: btpEndpoint"
+    );
+  }
+  if (typeof assetCode !== "string" || assetCode.length === 0) {
+    throw new InvalidEventError("Missing or invalid required field: assetCode");
+  }
+  if (typeof assetScale !== "number" || !Number.isInteger(assetScale)) {
+    throw new InvalidEventError(
+      "Missing or invalid required field: assetScale"
+    );
+  }
+  if (settlementEngine !== void 0 && typeof settlementEngine !== "string") {
+    throw new InvalidEventError(
+      "Invalid optional field: settlementEngine must be a string"
+    );
+  }
+  const {
+    supportedChains,
+    settlementAddresses,
+    preferredTokens,
+    tokenNetworks
+  } = parsed;
+  if (supportedChains !== void 0) {
+    if (!Array.isArray(supportedChains)) {
+      throw new InvalidEventError("supportedChains must be an array");
+    }
+    if (supportedChains.length === 0) {
+      throw new InvalidEventError(
+        "supportedChains must be a non-empty array when provided"
+      );
+    }
+    for (const chainId of supportedChains) {
+      if (typeof chainId !== "string" || !validateChainId(chainId)) {
+        throw new InvalidEventError(
+          `Invalid chain identifier: ${String(chainId)}`
+        );
+      }
+    }
+  }
+  if (settlementAddresses !== void 0) {
+    if (!isObject(settlementAddresses)) {
+      throw new InvalidEventError("settlementAddresses must be an object");
+    }
+    for (const [key, value] of Object.entries(settlementAddresses)) {
+      if (!validateChainId(key)) {
+        throw new InvalidEventError(
+          `Invalid chain identifier in settlementAddresses: ${key}`
+        );
+      }
+      if (typeof value !== "string" || value.length === 0) {
+        throw new InvalidEventError(
+          "settlementAddresses values must be non-empty strings"
+        );
+      }
+    }
+    if (Array.isArray(supportedChains)) {
+      const chainSet = new Set(supportedChains);
+      for (const key of Object.keys(settlementAddresses)) {
+        if (!chainSet.has(key)) {
+          throw new InvalidEventError(
+            `settlementAddresses key '${key}' is not in supportedChains`
+          );
+        }
+      }
+    }
+  }
+  if (preferredTokens !== void 0) {
+    if (!isObject(preferredTokens)) {
+      throw new InvalidEventError("preferredTokens must be an object");
+    }
+  }
+  if (tokenNetworks !== void 0) {
+    if (!isObject(tokenNetworks)) {
+      throw new InvalidEventError("tokenNetworks must be an object");
+    }
+  }
+  return {
+    ilpAddress,
+    btpEndpoint,
+    ...blsHttpEndpoint !== void 0 && typeof blsHttpEndpoint === "string" && { blsHttpEndpoint },
+    assetCode,
+    assetScale,
+    ...settlementEngine !== void 0 && { settlementEngine },
+    supportedChains: supportedChains !== void 0 ? supportedChains : [],
+    settlementAddresses: settlementAddresses !== void 0 ? settlementAddresses : {},
+    ...preferredTokens !== void 0 && {
+      preferredTokens
+    },
+    ...tokenNetworks !== void 0 && {
+      tokenNetworks
+    }
+  };
+}
+
+// src/events/builders.ts
+import { finalizeEvent } from "nostr-tools/pure";
+function buildIlpPeerInfoEvent(info, secretKey) {
+  return finalizeEvent(
+    {
+      kind: ILP_PEER_INFO_KIND,
+      content: JSON.stringify(info),
+      tags: [],
+      created_at: Math.floor(Date.now() / 1e3)
+    },
+    secretKey
+  );
+}
+
+// src/events/seed-relay.ts
+import { finalizeEvent as finalizeEvent2 } from "nostr-tools/pure";
+var PUBKEY_REGEX = /^[0-9a-f]{64}$/;
+function isValidWsUrl(url) {
+  return typeof url === "string" && // nosemgrep: javascript.lang.security.detect-insecure-websocket.detect-insecure-websocket -- validation check, not a connection
+  (url.startsWith("ws://") || url.startsWith("wss://"));
+}
+function isValidPubkey(pubkey) {
+  return typeof pubkey === "string" && PUBKEY_REGEX.test(pubkey);
+}
+function buildSeedRelayListEvent(secretKey, entries) {
+  return finalizeEvent2(
+    {
+      kind: SEED_RELAY_LIST_KIND,
+      content: JSON.stringify(entries),
+      tags: [["d", "toon-seed-list"]],
+      created_at: Math.floor(Date.now() / 1e3)
+    },
+    secretKey
+  );
+}
+function parseSeedRelayList(event) {
+  let parsed;
+  try {
+    parsed = JSON.parse(event.content);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed)) {
+    return [];
+  }
+  const results = [];
+  for (const item of parsed) {
+    if (typeof item !== "object" || item === null) {
+      continue;
+    }
+    const record = item;
+    const url = record["url"];
+    const pubkey = record["pubkey"];
+    if (!isValidWsUrl(url)) {
+      continue;
+    }
+    if (!isValidPubkey(pubkey)) {
+      continue;
+    }
+    const entry = { url, pubkey };
+    const metadata = record["metadata"];
+    if (typeof metadata === "object" && metadata !== null) {
+      const meta = metadata;
+      const entryMeta = {};
+      if (typeof meta["region"] === "string") {
+        entryMeta.region = meta["region"];
+      }
+      if (typeof meta["version"] === "string") {
+        entryMeta.version = meta["version"];
+      }
+      if (Array.isArray(meta["services"])) {
+        entryMeta.services = meta["services"].filter(
+          (s) => typeof s === "string"
+        );
+      }
+      if (Object.keys(entryMeta).length > 0) {
+        entry.metadata = entryMeta;
+      }
+    }
+    results.push(entry);
+  }
+  return results;
+}
+
+// src/events/service-discovery.ts
+import { finalizeEvent as finalizeEvent3 } from "nostr-tools/pure";
+function buildServiceDiscoveryEvent(content, secretKey) {
+  return finalizeEvent3(
+    {
+      kind: SERVICE_DISCOVERY_KIND,
+      content: JSON.stringify(content),
+      tags: [["d", "toon-service-discovery"]],
+      created_at: Math.floor(Date.now() / 1e3)
+    },
+    secretKey
+  );
+}
+function parseServiceDiscovery(event) {
+  let parsed;
+  try {
+    parsed = JSON.parse(event.content);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return null;
+  }
+  const record = parsed;
+  const serviceType = record["serviceType"];
+  if (typeof serviceType !== "string") return null;
+  const ilpAddress = record["ilpAddress"];
+  if (typeof ilpAddress !== "string") return null;
+  const chain = record["chain"];
+  if (typeof chain !== "string") return null;
+  const version = record["version"];
+  if (typeof version !== "string") return null;
+  const pricing = record["pricing"];
+  if (typeof pricing !== "object" || pricing === null || Array.isArray(pricing))
+    return null;
+  const pricingRecord = pricing;
+  const basePricePerByte = pricingRecord["basePricePerByte"];
+  if (typeof basePricePerByte !== "number") return null;
+  if (!isFinite(basePricePerByte) || basePricePerByte < 0) return null;
+  const currency = pricingRecord["currency"];
+  if (typeof currency !== "string") return null;
+  const supportedKinds = record["supportedKinds"];
+  if (!Array.isArray(supportedKinds)) return null;
+  if (!supportedKinds.every(
+    (k) => typeof k === "number" && Number.isInteger(k) && k >= 0
+  )) {
+    return null;
+  }
+  const capabilities = record["capabilities"];
+  if (!Array.isArray(capabilities)) return null;
+  if (!capabilities.every((c) => typeof c === "string")) {
+    return null;
+  }
+  const result = {
+    serviceType,
+    ilpAddress,
+    pricing: { basePricePerByte, currency },
+    supportedKinds,
+    capabilities,
+    chain,
+    version
+  };
+  const x402 = record["x402"];
+  if (x402 !== void 0) {
+    if (typeof x402 !== "object" || x402 === null || Array.isArray(x402))
+      return null;
+    const x402Record = x402;
+    const enabled = x402Record["enabled"];
+    if (typeof enabled !== "boolean") return null;
+    const x402Result = { enabled };
+    const endpoint = x402Record["endpoint"];
+    if (endpoint !== void 0) {
+      if (typeof endpoint !== "string") return null;
+      x402Result.endpoint = endpoint;
+    }
+    result.x402 = x402Result;
+  }
+  const skill = record["skill"];
+  if (skill !== void 0) {
+    if (typeof skill !== "object" || skill === null || Array.isArray(skill))
+      return null;
+    const skillRecord = skill;
+    const skillName = skillRecord["name"];
+    if (typeof skillName !== "string") return null;
+    const skillVersion = skillRecord["version"];
+    if (typeof skillVersion !== "string") return null;
+    const kinds = skillRecord["kinds"];
+    if (!Array.isArray(kinds)) return null;
+    if (!kinds.every(
+      (k) => typeof k === "number" && Number.isInteger(k) && k >= 0
+    )) {
+      return null;
+    }
+    const features = skillRecord["features"];
+    if (!Array.isArray(features)) return null;
+    if (!features.every((f) => typeof f === "string")) {
+      return null;
+    }
+    const inputSchema = skillRecord["inputSchema"];
+    if (typeof inputSchema !== "object" || inputSchema === null || Array.isArray(inputSchema))
+      return null;
+    const skillPricing = skillRecord["pricing"];
+    if (typeof skillPricing !== "object" || skillPricing === null || Array.isArray(skillPricing))
+      return null;
+    const pricingEntries = Object.entries(
+      skillPricing
+    );
+    if (!pricingEntries.every(([, v]) => typeof v === "string")) {
+      return null;
+    }
+    const skillResult = {
+      name: skillName,
+      version: skillVersion,
+      kinds,
+      features,
+      inputSchema,
+      pricing: skillPricing
+    };
+    const models = skillRecord["models"];
+    if (models !== void 0) {
+      if (!Array.isArray(models)) return null;
+      if (!models.every((m) => typeof m === "string")) {
+        return null;
+      }
+      skillResult.models = models;
+    }
+    const attestation = skillRecord["attestation"];
+    if (attestation !== void 0) {
+      if (typeof attestation !== "object" || attestation === null || Array.isArray(attestation))
+        return null;
+      skillResult.attestation = attestation;
+    }
+    result.skill = skillResult;
+  }
+  return result;
+}
+
+// src/events/attestation.ts
+import { finalizeEvent as finalizeEvent4 } from "nostr-tools/pure";
+var PCR_REGEX = /^[0-9a-f]{96}$/;
+var BASE64_REGEX = /^[A-Za-z0-9+/]+={0,2}$/;
+function buildAttestationEvent(attestation, secretKey, options) {
+  return finalizeEvent4(
+    {
+      kind: TEE_ATTESTATION_KIND,
+      content: JSON.stringify(attestation),
+      tags: [
+        ["relay", options.relay],
+        ["chain", options.chain],
+        ["expiry", String(options.expiry)]
+      ],
+      created_at: Math.floor(Date.now() / 1e3)
+    },
+    secretKey
+  );
+}
+function parseAttestation(event, options) {
+  let parsed;
+  try {
+    parsed = JSON.parse(event.content);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return null;
+  }
+  const record = parsed;
+  const enclave = record["enclave"];
+  if (typeof enclave !== "string") return null;
+  const pcr0 = record["pcr0"];
+  if (typeof pcr0 !== "string") return null;
+  const pcr1 = record["pcr1"];
+  if (typeof pcr1 !== "string") return null;
+  const pcr2 = record["pcr2"];
+  if (typeof pcr2 !== "string") return null;
+  const attestationDoc = record["attestationDoc"];
+  if (typeof attestationDoc !== "string") return null;
+  const version = record["version"];
+  if (typeof version !== "string") return null;
+  if (options?.verify) {
+    if (!PCR_REGEX.test(pcr0)) {
+      throw new Error("Invalid PCR0 format: expected 96-char lowercase hex");
+    }
+    if (!PCR_REGEX.test(pcr1)) {
+      throw new Error("Invalid PCR1 format: expected 96-char lowercase hex");
+    }
+    if (!PCR_REGEX.test(pcr2)) {
+      throw new Error("Invalid PCR2 format: expected 96-char lowercase hex");
+    }
+    if (attestationDoc.length === 0) {
+      throw new Error("Attestation document is empty");
+    }
+    if (!BASE64_REGEX.test(attestationDoc)) {
+      throw new Error("Attestation document is not valid base64");
+    }
+  }
+  const relayTag = event.tags.find((t) => t[0] === "relay");
+  const chainTag = event.tags.find((t) => t[0] === "chain");
+  const expiryTag = event.tags.find((t) => t[0] === "expiry");
+  if (!relayTag?.[1] || !chainTag?.[1] || !expiryTag?.[1]) {
+    return null;
+  }
+  const expiry = parseInt(expiryTag[1], 10);
+  if (isNaN(expiry)) {
+    return null;
+  }
+  return {
+    attestation: {
+      enclave,
+      pcr0,
+      pcr1,
+      pcr2,
+      attestationDoc,
+      version
+    },
+    relay: relayTag[1],
+    chain: chainTag[1],
+    expiry
+  };
+}
+
+// src/events/dvm.ts
+import { finalizeEvent as finalizeEvent5 } from "nostr-tools/pure";
+var HEX_64_REGEX = /^[0-9a-f]{64}$/;
+var VALID_STATUSES = /* @__PURE__ */ new Set([
+  "processing",
+  "error",
+  "success",
+  "partial"
+]);
+function buildJobRequestEvent(params, secretKey) {
+  if (params.kind < 5e3 || params.kind > 5999) {
+    throw new ToonError(
+      `Job request kind must be in range 5000-5999, got ${params.kind}`,
+      "DVM_INVALID_KIND"
+    );
+  }
+  if (params.input.data === void 0 || params.input.data === null) {
+    throw new ToonError(
+      "Job request input data is required",
+      "DVM_MISSING_INPUT"
+    );
+  }
+  if (!params.input.type) {
+    throw new ToonError(
+      "Job request input type is required",
+      "DVM_MISSING_INPUT"
+    );
+  }
+  if (typeof params.bid !== "string" || params.bid === "") {
+    throw new ToonError(
+      "Job request bid must be a non-empty string (USDC micro-units)",
+      "DVM_INVALID_BID"
+    );
+  }
+  if (typeof params.output !== "string" || params.output === "") {
+    throw new ToonError(
+      "Job request output MIME type must be a non-empty string",
+      "DVM_MISSING_OUTPUT"
+    );
+  }
+  const tags = [];
+  const iTag = ["i", params.input.data, params.input.type];
+  if (params.input.relay !== void 0) {
+    iTag.push(params.input.relay);
+  }
+  if (params.input.marker !== void 0) {
+    if (params.input.relay === void 0) {
+      iTag.push("");
+    }
+    iTag.push(params.input.marker);
+  }
+  tags.push(iTag);
+  tags.push(["bid", params.bid, "usdc"]);
+  tags.push(["output", params.output]);
+  if (params.targetProvider !== void 0) {
+    if (!HEX_64_REGEX.test(params.targetProvider)) {
+      throw new ToonError(
+        "Job request targetProvider must be a 64-character lowercase hex string",
+        "DVM_INVALID_PUBKEY"
+      );
+    }
+    tags.push(["p", params.targetProvider]);
+  }
+  if (params.params !== void 0) {
+    for (const p of params.params) {
+      tags.push(["param", p.key, p.value]);
+    }
+  }
+  if (params.relays !== void 0 && params.relays.length > 0) {
+    tags.push(["relays", ...params.relays]);
+  }
+  return finalizeEvent5(
+    {
+      kind: params.kind,
+      content: params.content ?? "",
+      tags,
+      created_at: Math.floor(Date.now() / 1e3)
+    },
+    secretKey
+  );
+}
+function buildJobResultEvent(params, secretKey) {
+  if (params.kind < 6e3 || params.kind > 6999) {
+    throw new ToonError(
+      `Job result kind must be in range 6000-6999, got ${params.kind}`,
+      "DVM_INVALID_KIND"
+    );
+  }
+  if (!HEX_64_REGEX.test(params.requestEventId)) {
+    throw new ToonError(
+      "Job result requestEventId must be a 64-character lowercase hex string",
+      "DVM_INVALID_EVENT_ID"
+    );
+  }
+  if (!HEX_64_REGEX.test(params.customerPubkey)) {
+    throw new ToonError(
+      "Job result customerPubkey must be a 64-character lowercase hex string",
+      "DVM_INVALID_PUBKEY"
+    );
+  }
+  if (typeof params.amount !== "string" || params.amount === "") {
+    throw new ToonError(
+      "Job result amount must be a non-empty string (USDC micro-units)",
+      "DVM_INVALID_AMOUNT"
+    );
+  }
+  if (typeof params.content !== "string") {
+    throw new ToonError(
+      "Job result content must be a string",
+      "DVM_MISSING_CONTENT"
+    );
+  }
+  const tags = [
+    ["e", params.requestEventId],
+    ["p", params.customerPubkey],
+    ["amount", params.amount, "usdc"]
+  ];
+  return finalizeEvent5(
+    {
+      kind: params.kind,
+      content: params.content,
+      tags,
+      created_at: Math.floor(Date.now() / 1e3)
+    },
+    secretKey
+  );
+}
+function buildJobFeedbackEvent(params, secretKey) {
+  if (!HEX_64_REGEX.test(params.requestEventId)) {
+    throw new ToonError(
+      "Job feedback requestEventId must be a 64-character lowercase hex string",
+      "DVM_INVALID_EVENT_ID"
+    );
+  }
+  if (!HEX_64_REGEX.test(params.customerPubkey)) {
+    throw new ToonError(
+      "Job feedback customerPubkey must be a 64-character lowercase hex string",
+      "DVM_INVALID_PUBKEY"
+    );
+  }
+  if (!VALID_STATUSES.has(params.status)) {
+    throw new ToonError(
+      `Job feedback status must be one of: processing, error, success, partial. Got: ${String(params.status)}`,
+      "DVM_INVALID_STATUS"
+    );
+  }
+  const tags = [
+    ["e", params.requestEventId],
+    ["p", params.customerPubkey],
+    ["status", params.status]
+  ];
+  return finalizeEvent5(
+    {
+      kind: JOB_FEEDBACK_KIND,
+      content: params.content ?? "",
+      tags,
+      created_at: Math.floor(Date.now() / 1e3)
+    },
+    secretKey
+  );
+}
+function parseJobRequest(event) {
+  if (event.kind < 5e3 || event.kind > 5999) {
+    return null;
+  }
+  const iTag = event.tags.find((t) => t[0] === "i");
+  if (!iTag) return null;
+  const inputData = iTag[1];
+  const inputType = iTag[2];
+  if (inputData === void 0 || inputType === void 0) return null;
+  const bidTag = event.tags.find((t) => t[0] === "bid");
+  if (!bidTag) return null;
+  const bidAmount = bidTag[1];
+  if (bidAmount === void 0 || bidAmount === "") return null;
+  const outputTag = event.tags.find((t) => t[0] === "output");
+  if (!outputTag) return null;
+  const outputMime = outputTag[1];
+  if (outputMime === void 0 || outputMime === "") return null;
+  const input = {
+    data: inputData,
+    type: inputType
+  };
+  const inputRelay = iTag[3];
+  if (inputRelay !== void 0 && inputRelay !== "") {
+    input.relay = inputRelay;
+  }
+  const inputMarker = iTag[4];
+  if (inputMarker !== void 0 && inputMarker !== "") {
+    input.marker = inputMarker;
+  }
+  const pTag = event.tags.find((t) => t[0] === "p");
+  const targetProvider = pTag?.[1];
+  if (targetProvider !== void 0 && !HEX_64_REGEX.test(targetProvider))
+    return null;
+  const paramTags = event.tags.filter((t) => t[0] === "param");
+  const params = [];
+  for (const pt of paramTags) {
+    const key = pt[1];
+    const value = pt[2];
+    if (key !== void 0 && value !== void 0) {
+      params.push({ key, value });
+    }
+  }
+  const relaysTag = event.tags.find((t) => t[0] === "relays");
+  const relays = [];
+  if (relaysTag) {
+    for (let i = 1; i < relaysTag.length; i++) {
+      const url = relaysTag[i];
+      if (url !== void 0) {
+        relays.push(url);
+      }
+    }
+  }
+  const result = {
+    kind: event.kind,
+    input,
+    bid: bidAmount,
+    output: outputMime,
+    content: event.content,
+    params,
+    relays
+  };
+  if (targetProvider !== void 0) {
+    result.targetProvider = targetProvider;
+  }
+  return result;
+}
+function parseJobResult(event) {
+  if (event.kind < 6e3 || event.kind > 6999) {
+    return null;
+  }
+  const eTag = event.tags.find((t) => t[0] === "e");
+  if (!eTag) return null;
+  const requestEventId = eTag[1];
+  if (requestEventId === void 0 || !HEX_64_REGEX.test(requestEventId))
+    return null;
+  const pTag = event.tags.find((t) => t[0] === "p");
+  if (!pTag) return null;
+  const customerPubkey = pTag[1];
+  if (customerPubkey === void 0 || !HEX_64_REGEX.test(customerPubkey))
+    return null;
+  const amountTag = event.tags.find((t) => t[0] === "amount");
+  if (!amountTag) return null;
+  const amount = amountTag[1];
+  if (amount === void 0 || amount === "") return null;
+  return {
+    kind: event.kind,
+    requestEventId,
+    customerPubkey,
+    amount,
+    content: event.content
+  };
+}
+function parseJobFeedback(event) {
+  if (event.kind !== JOB_FEEDBACK_KIND) {
+    return null;
+  }
+  const eTag = event.tags.find((t) => t[0] === "e");
+  if (!eTag) return null;
+  const requestEventId = eTag[1];
+  if (requestEventId === void 0 || !HEX_64_REGEX.test(requestEventId))
+    return null;
+  const pTag = event.tags.find((t) => t[0] === "p");
+  if (!pTag) return null;
+  const customerPubkey = pTag[1];
+  if (customerPubkey === void 0 || !HEX_64_REGEX.test(customerPubkey))
+    return null;
+  const statusTag = event.tags.find((t) => t[0] === "status");
+  if (!statusTag) return null;
+  const statusValue = statusTag[1];
+  if (statusValue === void 0) return null;
+  if (!VALID_STATUSES.has(statusValue)) {
+    return null;
+  }
+  return {
+    requestEventId,
+    customerPubkey,
+    status: statusValue,
+    content: event.content
+  };
+}
+
+// src/discovery/NostrPeerDiscovery.ts
+import { SimplePool } from "nostr-tools/pool";
+var PUBKEY_REGEX2 = /^[0-9a-f]{64}$/;
+var NostrPeerDiscovery = class {
+  relayUrls;
+  pool;
+  /**
+   * Creates a new NostrPeerDiscovery instance.
+   *
+   * @param relayUrls - Array of relay WebSocket URLs to query
+   * @param pool - Optional SimplePool instance (creates new one if not provided)
+   */
+  constructor(relayUrls, pool) {
+    this.relayUrls = relayUrls;
+    this.pool = pool ?? new SimplePool();
+  }
+  /**
+   * Retrieves the list of pubkeys that a given pubkey follows.
+   *
+   * Queries NIP-02 kind:3 events from configured relays and returns
+   * the followed pubkeys from the most recent event.
+   *
+   * @param pubkey - The 64-character hex pubkey to get follows for
+   * @returns Array of followed pubkeys (deduplicated)
+   * @throws PeerDiscoveryError if pubkey format is invalid
+   */
+  async getFollows(pubkey) {
+    if (!PUBKEY_REGEX2.test(pubkey)) {
+      throw new PeerDiscoveryError(
+        `Invalid pubkey format: must be 64-character lowercase hex string`
+      );
+    }
+    const filter = {
+      kinds: [3],
+      authors: [pubkey],
+      limit: 1
+    };
+    try {
+      const events = await this.pool.querySync(this.relayUrls, filter);
+      if (events.length === 0) {
+        return [];
+      }
+      const sortedEvents = events.sort((a, b) => b.created_at - a.created_at);
+      const mostRecent = sortedEvents[0];
+      if (!mostRecent) {
+        return [];
+      }
+      const pubkeys = mostRecent.tags.filter(
+        (tag) => tag[0] === "p" && typeof tag[1] === "string"
+      ).map((tag) => tag[1]);
+      return [...new Set(pubkeys)];
+    } catch (error) {
+      throw new PeerDiscoveryError(
+        "Failed to query relays for follow list",
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Discovers ILP peers by querying follow list and their ILP peer info events.
+   *
+   * For each followed pubkey, queries kind:10032 events to retrieve ILP connection info.
+   * Peers without kind:10032 events or with malformed events are silently excluded.
+   *
+   * @param pubkey - The 64-character hex pubkey to discover peers for
+   * @returns Map of pubkey → IlpPeerInfo for peers with valid ILP info
+   * @throws PeerDiscoveryError if pubkey format is invalid
+   */
+  async discoverPeers(pubkey) {
+    if (!PUBKEY_REGEX2.test(pubkey)) {
+      throw new PeerDiscoveryError(
+        `Invalid pubkey format: must be 64-character lowercase hex string`
+      );
+    }
+    const follows = await this.getFollows(pubkey);
+    if (follows.length === 0) {
+      return /* @__PURE__ */ new Map();
+    }
+    const filter = {
+      kinds: [ILP_PEER_INFO_KIND],
+      authors: follows
+    };
+    const events = await this.pool.querySync(this.relayUrls, filter);
+    const eventsByPubkey = /* @__PURE__ */ new Map();
+    for (const event of events) {
+      const existing = eventsByPubkey.get(event.pubkey);
+      if (!existing || event.created_at > existing.created_at) {
+        eventsByPubkey.set(event.pubkey, event);
+      }
+    }
+    const result = /* @__PURE__ */ new Map();
+    for (const [peerPubkey, event] of eventsByPubkey) {
+      try {
+        const info = parseIlpPeerInfo(event);
+        result.set(peerPubkey, info);
+      } catch {
+      }
+    }
+    return result;
+  }
+  /**
+   * Subscribes to ILP peer info updates from followed pubkeys.
+   *
+   * Sets up a real-time subscription for kind:10032 events from all pubkeys
+   * that the given pubkey follows. The callback is invoked whenever a new
+   * or updated ILP peer info event is received.
+   *
+   * @param pubkey - The 64-character hex pubkey whose follows to monitor
+   * @param callback - Function called with (peerPubkey, parsedInfo) for each update
+   * @returns Subscription object with unsubscribe() method
+   * @throws PeerDiscoveryError if pubkey format is invalid
+   */
+  async subscribeToPeerUpdates(pubkey, callback) {
+    if (!PUBKEY_REGEX2.test(pubkey)) {
+      throw new PeerDiscoveryError(
+        `Invalid pubkey format: must be 64-character lowercase hex string`
+      );
+    }
+    const follows = await this.getFollows(pubkey);
+    if (follows.length === 0) {
+      return {
+        unsubscribe: () => {
+        }
+      };
+    }
+    const peerTimestamps = /* @__PURE__ */ new Map();
+    let isUnsubscribed = false;
+    const filter = {
+      kinds: [ILP_PEER_INFO_KIND],
+      authors: follows
+    };
+    const subCloser = this.pool.subscribeMany(this.relayUrls, filter, {
+      onevent: (event) => {
+        if (isUnsubscribed) return;
+        const lastSeen = peerTimestamps.get(event.pubkey) ?? 0;
+        if (event.created_at <= lastSeen) {
+          return;
+        }
+        peerTimestamps.set(event.pubkey, event.created_at);
+        try {
+          const info = parseIlpPeerInfo(event);
+          callback(event.pubkey, info);
+        } catch {
+        }
+      }
+    });
+    return {
+      unsubscribe: () => {
+        if (!isUnsubscribed) {
+          isUnsubscribed = true;
+          subCloser.close();
+        }
+      }
+    };
+  }
+};
+
+// src/discovery/genesis-peers.json
+var genesis_peers_default = [];
+
+// src/discovery/GenesisPeerLoader.ts
+var PUBKEY_REGEX3 = /^[0-9a-f]{64}$/;
+var ILP_ADDRESS_REGEX = /^g\.[a-zA-Z0-9.-]+$/;
+function isValidPubkey2(pubkey) {
+  return PUBKEY_REGEX3.test(pubkey);
+}
+function isValidRelayUrl(url) {
+  return url.startsWith("wss://") || url.startsWith("ws://");
+}
+function isValidIlpAddress(address) {
+  return ILP_ADDRESS_REGEX.test(address);
+}
+function isValidBtpEndpoint(url) {
+  return url.startsWith("wss://") || url.startsWith("ws://");
+}
+function isValidGenesisPeer(entry) {
+  if (typeof entry !== "object" || entry === null) return false;
+  const obj = entry;
+  return typeof obj["pubkey"] === "string" && typeof obj["relayUrl"] === "string" && typeof obj["ilpAddress"] === "string" && typeof obj["btpEndpoint"] === "string" && isValidPubkey2(obj["pubkey"]) && isValidRelayUrl(obj["relayUrl"]) && isValidIlpAddress(obj["ilpAddress"]) && isValidBtpEndpoint(obj["btpEndpoint"]);
+}
+function deduplicateByPubkey(peers) {
+  const map = /* @__PURE__ */ new Map();
+  for (const peer of peers) {
+    map.set(peer.pubkey, peer);
+  }
+  return [...map.values()];
+}
+function loadGenesisPeers() {
+  const raw = genesis_peers_default;
+  const valid = [];
+  for (const entry of raw) {
+    if (isValidGenesisPeer(entry)) {
+      valid.push(entry);
+    } else {
+      console.warn("Skipping invalid genesis peer entry:", entry);
+    }
+  }
+  return deduplicateByPubkey(valid);
+}
+function loadAdditionalPeers(json) {
+  let parsed;
+  try {
+    parsed = JSON.parse(json);
+  } catch {
+    console.warn("Failed to parse additional peers JSON:", json);
+    return [];
+  }
+  if (!Array.isArray(parsed)) {
+    console.warn("Additional peers JSON is not an array");
+    return [];
+  }
+  const valid = [];
+  for (const entry of parsed) {
+    if (isValidGenesisPeer(entry)) {
+      valid.push(entry);
+    } else {
+      console.warn("Skipping invalid additional peer entry:", entry);
+    }
+  }
+  return valid;
+}
+function loadAllPeers(additionalPeersJson) {
+  const genesis = loadGenesisPeers();
+  if (!additionalPeersJson) {
+    return genesis;
+  }
+  const additional = loadAdditionalPeers(additionalPeersJson);
+  return deduplicateByPubkey([...genesis, ...additional]);
+}
+var GenesisPeerLoader = {
+  loadGenesisPeers,
+  loadAdditionalPeers,
+  loadAllPeers
+};
+
+// src/discovery/ArDrivePeerRegistry.ts
+var DEFAULT_GATEWAY_URL = "https://arweave.net/graphql";
+var GRAPHQL_QUERY = `
+query {
+  transactions(
+    tags: [
+      { name: "App-Name", values: ["toon"] },
+      { name: "type", values: ["ilp-peer-info"] }
+    ],
+    first: 100
+  ) {
+    edges {
+      node {
+        id
+        tags {
+          name
+          value
+        }
+      }
+    }
+  }
+}
+`;
+function isValidIlpPeerInfo(entry) {
+  if (typeof entry !== "object" || entry === null) return false;
+  const obj = entry;
+  return typeof obj["ilpAddress"] === "string" && isValidIlpAddress(obj["ilpAddress"]) && typeof obj["btpEndpoint"] === "string" && isValidBtpEndpoint(obj["btpEndpoint"]) && typeof obj["assetCode"] === "string" && obj["assetCode"].length > 0 && typeof obj["assetScale"] === "number" && Number.isInteger(obj["assetScale"]) && obj["assetScale"] >= 0 && (obj["settlementEngine"] === void 0 || typeof obj["settlementEngine"] === "string");
+}
+function getPubkeyFromTags(tags) {
+  const tag = tags.find((t) => t.name === "pubkey");
+  return tag?.value;
+}
+async function fetchPeers(gatewayUrl = DEFAULT_GATEWAY_URL) {
+  const result = /* @__PURE__ */ new Map();
+  try {
+    const response = await fetch(gatewayUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ query: GRAPHQL_QUERY })
+    });
+    const json = await response.json();
+    const edges = json?.data?.transactions?.edges;
+    if (!Array.isArray(edges)) {
+      return result;
+    }
+    const baseUrl = gatewayUrl.replace(/\/graphql$/, "");
+    for (const edge of edges) {
+      const txId = edge?.node?.id;
+      const tags = edge?.node?.tags;
+      if (!txId || !Array.isArray(tags)) continue;
+      const pubkey = getPubkeyFromTags(tags);
+      if (!pubkey || !isValidPubkey2(pubkey)) continue;
+      if (result.has(pubkey)) continue;
+      try {
+        const dataResponse = await fetch(`${baseUrl}/${txId}`);
+        const data = await dataResponse.json();
+        if (isValidIlpPeerInfo(data)) {
+          result.set(pubkey, data);
+        } else {
+          console.warn(
+            `Skipping transaction ${txId}: invalid IlpPeerInfo data`
+          );
+        }
+      } catch (err) {
+        console.warn(`Failed to fetch transaction data for ${txId}:`, err);
+      }
+    }
+  } catch (err) {
+    console.warn("ArDrive peer registry unavailable:", err);
+  }
+  return result;
+}
+async function publishPeerInfo(peerInfo, pubkey, turboClient) {
+  if (!isValidPubkey2(pubkey)) {
+    throw new PeerDiscoveryError(`Invalid pubkey: ${pubkey}`);
+  }
+  try {
+    const json = JSON.stringify(peerInfo);
+    const result = await turboClient.uploadFile({
+      fileStreamFactory: () => Buffer.from(json, "utf-8"),
+      fileSizeFactory: () => Buffer.byteLength(json, "utf-8"),
+      dataItemOpts: {
+        tags: [
+          { name: "App-Name", value: "toon" },
+          { name: "type", value: "ilp-peer-info" },
+          { name: "pubkey", value: pubkey },
+          { name: "version", value: "1" },
+          { name: "Content-Type", value: "application/json" }
+        ]
+      }
+    });
+    return result.id;
+  } catch (err) {
+    throw new PeerDiscoveryError(
+      "Failed to publish peer info to ArDrive",
+      err instanceof Error ? err : void 0
+    );
+  }
+}
+var ArDrivePeerRegistry = {
+  fetchPeers,
+  publishPeerInfo
+};
+
+// src/discovery/SocialPeerDiscovery.ts
+import { SimplePool as SimplePool2 } from "nostr-tools/pool";
+import { getPublicKey } from "nostr-tools/pure";
+var SocialPeerDiscovery = class {
+  config;
+  pubkey;
+  pool;
+  listeners = [];
+  previousFollows = /* @__PURE__ */ new Set();
+  started = false;
+  /**
+   * Creates a new SocialPeerDiscovery instance.
+   *
+   * @param config - Discovery configuration
+   * @param secretKey - Our Nostr secret key (used to derive pubkey)
+   * @param pool - Optional SimplePool instance (creates new one if not provided)
+   */
+  constructor(config, secretKey, pool) {
+    this.config = config;
+    this.pubkey = getPublicKey(secretKey);
+    this.pool = pool ?? new SimplePool2();
+  }
+  /**
+   * Register a listener for social discovery events.
+   */
+  on(listener) {
+    this.listeners.push(listener);
+  }
+  /**
+   * Remove a previously registered listener.
+   */
+  off(listener) {
+    const idx = this.listeners.indexOf(listener);
+    if (idx !== -1) {
+      this.listeners.splice(idx, 1);
+    }
+  }
+  /**
+   * Start subscribing to kind:3 follow list events for the node's pubkey.
+   *
+   * @returns Subscription with unsubscribe() to stop discovery
+   * @throws PeerDiscoveryError if already started
+   */
+  start() {
+    if (this.started) {
+      throw new PeerDiscoveryError("SocialPeerDiscovery already started");
+    }
+    this.started = true;
+    const subCloser = this.pool.subscribeMany(
+      this.config.relayUrls,
+      { kinds: [3], authors: [this.pubkey] },
+      {
+        onevent: (event) => {
+          const followedPubkeys = event.tags.filter(
+            (tag) => tag[0] === "p" && typeof tag[1] === "string"
+          ).map((tag) => tag[1]);
+          this.processFollowListUpdate(followedPubkeys);
+        }
+      }
+    );
+    return {
+      unsubscribe: () => {
+        subCloser.close();
+        this.started = false;
+      }
+    };
+  }
+  /**
+   * Process a follow list update by diffing against previous state.
+   */
+  processFollowListUpdate(followedPubkeys) {
+    const currentFollows = new Set(followedPubkeys);
+    for (const pubkey of currentFollows) {
+      if (!this.previousFollows.has(pubkey)) {
+        this.emit({ type: "social:follow-discovered", pubkey });
+      }
+    }
+    for (const pubkey of this.previousFollows) {
+      if (!currentFollows.has(pubkey)) {
+        this.emit({ type: "social:follow-removed", pubkey });
+      }
+    }
+    this.previousFollows = currentFollows;
+  }
+  /**
+   * Emit an event to all registered listeners.
+   */
+  emit(event) {
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch (error) {
+        console.warn(
+          "[SocialDiscovery] Listener error:",
+          error instanceof Error ? error.message : "Unknown error"
+        );
+      }
+    }
+  }
+};
+
+// src/discovery/seed-relay-discovery.ts
+import WebSocket from "ws";
+import { getPublicKey as getPublicKey2, verifyEvent } from "nostr-tools/pure";
+var DEFAULT_PUBLISH_CONNECTION_TIMEOUT = 1e4;
+var DEFAULT_PUBLISH_OK_TIMEOUT = 5e3;
+function generateSubId() {
+  return `ct-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function connectWebSocket(url, timeout) {
+  return new Promise((resolve, reject) => {
+    const ws = new WebSocket(url);
+    const timer = setTimeout(() => {
+      ws.close();
+      reject(new Error(`Connection timeout after ${timeout}ms: ${url}`));
+    }, timeout);
+    ws.on("open", () => {
+      clearTimeout(timer);
+      resolve(ws);
+    });
+    ws.on("error", (err) => {
+      clearTimeout(timer);
+      ws.close();
+      reject(new Error(`WebSocket error connecting to ${url}: ${err.message}`));
+    });
+  });
+}
+function subscribeAndCollect(ws, filter, timeout) {
+  return new Promise((resolve) => {
+    const events = [];
+    const subId = generateSubId();
+    let settled = false;
+    const cleanup = () => {
+      if (settled) return;
+      settled = true;
+      ws.removeListener("message", messageHandler);
+    };
+    const messageHandler = (data) => {
+      try {
+        const msg = JSON.parse(String(data));
+        if (!Array.isArray(msg)) return;
+        const msgType = msg[0];
+        if (msgType === "EVENT" && msg[1] === subId && msg[2]) {
+          events.push(msg[2]);
+        }
+        if (msgType === "EOSE" && msg[1] === subId) {
+          clearTimeout(timer);
+          cleanup();
+          try {
+            ws.send(JSON.stringify(["CLOSE", subId]));
+          } catch {
+          }
+          resolve(events);
+        }
+      } catch {
+      }
+    };
+    const timer = setTimeout(() => {
+      cleanup();
+      try {
+        ws.send(JSON.stringify(["CLOSE", subId]));
+      } catch {
+      }
+      resolve(events);
+    }, timeout);
+    ws.on("message", messageHandler);
+    ws.send(JSON.stringify(["REQ", subId, filter]));
+  });
+}
+var SeedRelayDiscovery = class {
+  config;
+  connectionTimeout;
+  queryTimeout;
+  openSockets = [];
+  constructor(config) {
+    this.config = config;
+    this.connectionTimeout = config.connectionTimeout ?? 1e4;
+    this.queryTimeout = config.queryTimeout ?? 5e3;
+  }
+  /**
+   * Discover peers via seed relay list.
+   *
+   * 1. Query publicRelays for kind:10036 events
+   * 2. Parse seed relay entries
+   * 3. Connect to seed relays sequentially (fallback on failure)
+   * 4. Subscribe to kind:10032 on connected seed relay
+   * 5. Return discovered peers
+   *
+   * @throws PeerDiscoveryError if all seed relays are exhausted
+   */
+  async discover() {
+    const seedRelayEntries = await this.querySeedRelayLists();
+    if (seedRelayEntries.length === 0) {
+      throw new PeerDiscoveryError(
+        `All seed relays exhausted -- unable to bootstrap. Tried 0 seed relays from 0 kind:10036 events. Queried ${this.config.publicRelays.length} public relay(s).`
+      );
+    }
+    const uniqueEntries = this.deduplicateByUrl(seedRelayEntries);
+    let connectedSocket;
+    let connectedUrl = "";
+    let attemptedSeeds = 0;
+    for (const entry of uniqueEntries) {
+      attemptedSeeds++;
+      try {
+        const ws = await connectWebSocket(entry.url, this.connectionTimeout);
+        connectedSocket = ws;
+        connectedUrl = entry.url;
+        this.openSockets.push(ws);
+        break;
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "Unknown error";
+        console.warn(
+          `[SeedRelayDiscovery] Failed to connect to seed relay ${entry.url}: ${msg}`
+        );
+      }
+    }
+    if (!connectedSocket) {
+      throw new PeerDiscoveryError(
+        `All seed relays exhausted -- unable to bootstrap. Tried ${attemptedSeeds} seed relays from ${seedRelayEntries.length} kind:10036 events.`
+      );
+    }
+    const peerEvents = await subscribeAndCollect(
+      connectedSocket,
+      { kinds: [ILP_PEER_INFO_KIND] },
+      this.queryTimeout
+    );
+    const discoveredPeers = [];
+    for (const event of peerEvents) {
+      try {
+        if (!verifyEvent(event)) {
+          console.warn(
+            `[SeedRelayDiscovery] Skipping kind:10032 event with invalid signature: ${event.id}`
+          );
+          continue;
+        }
+        const info = parseIlpPeerInfo(event);
+        info.pubkey = event.pubkey;
+        discoveredPeers.push(info);
+      } catch {
+      }
+    }
+    return {
+      seedRelaysConnected: 1,
+      attemptedSeeds,
+      connectedUrls: [connectedUrl],
+      discoveredPeers
+    };
+  }
+  /**
+   * Stop discovery and close all open WebSocket connections.
+   */
+  async close() {
+    for (const ws of this.openSockets) {
+      try {
+        if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+          ws.close();
+        }
+      } catch {
+      }
+    }
+    this.openSockets.length = 0;
+  }
+  /**
+   * Query public relays for kind:10036 events and parse seed relay entries.
+   */
+  async querySeedRelayLists() {
+    const allEntries = [];
+    for (const relayUrl of this.config.publicRelays) {
+      try {
+        const ws = await connectWebSocket(relayUrl, this.connectionTimeout);
+        this.openSockets.push(ws);
+        const events = await subscribeAndCollect(
+          ws,
+          { kinds: [SEED_RELAY_LIST_KIND] },
+          this.queryTimeout
+        );
+        for (const event of events) {
+          if (!verifyEvent(event)) {
+            console.warn(
+              `[SeedRelayDiscovery] Skipping kind:10036 event with invalid signature: ${event.id}`
+            );
+            continue;
+          }
+          const entries = parseSeedRelayList(event);
+          allEntries.push(...entries);
+        }
+        ws.close();
+        const idx = this.openSockets.indexOf(ws);
+        if (idx !== -1) {
+          this.openSockets.splice(idx, 1);
+        }
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : "Unknown error";
+        console.warn(
+          `[SeedRelayDiscovery] Failed to query public relay ${relayUrl}: ${msg}`
+        );
+      }
+    }
+    return allEntries;
+  }
+  /**
+   * Deduplicate seed relay entries by URL, keeping the first occurrence.
+   */
+  deduplicateByUrl(entries) {
+    const seen = /* @__PURE__ */ new Set();
+    const unique = [];
+    for (const entry of entries) {
+      if (!seen.has(entry.url)) {
+        seen.add(entry.url);
+        unique.push(entry);
+      }
+    }
+    return unique;
+  }
+};
+async function publishSeedRelayEntry(config) {
+  const pubkey = getPublicKey2(config.secretKey);
+  const entry = {
+    url: config.relayUrl,
+    pubkey,
+    ...config.metadata && { metadata: config.metadata }
+  };
+  const event = buildSeedRelayListEvent(config.secretKey, [entry]);
+  let publishedTo = 0;
+  for (const relayUrl of config.publicRelays) {
+    try {
+      const ws = await connectWebSocket(
+        relayUrl,
+        DEFAULT_PUBLISH_CONNECTION_TIMEOUT
+      );
+      const published = await new Promise((resolve) => {
+        let settled = false;
+        const cleanup = () => {
+          if (settled) return;
+          settled = true;
+          ws.removeListener("message", messageHandler);
+        };
+        const timer = setTimeout(() => {
+          cleanup();
+          resolve(false);
+        }, DEFAULT_PUBLISH_OK_TIMEOUT);
+        const messageHandler = (data) => {
+          try {
+            const msg = JSON.parse(String(data));
+            if (Array.isArray(msg) && msg[0] === "OK" && msg[1] === event.id) {
+              clearTimeout(timer);
+              cleanup();
+              resolve(msg[2] === true);
+            }
+          } catch {
+          }
+        };
+        ws.on("message", messageHandler);
+        ws.send(JSON.stringify(["EVENT", event]));
+      });
+      if (published) {
+        publishedTo++;
+      }
+      ws.close();
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : "Unknown error";
+      console.warn(
+        `[SeedRelayDiscovery] Failed to publish to ${relayUrl}: ${msg}`
+      );
+    }
+  }
+  return { publishedTo, eventId: event.id };
+}
+
+// src/settlement/settlement.ts
+function negotiateSettlementChain(requesterChains, responderChains, requesterPreferredTokens, responderPreferredTokens) {
+  const responderSet = new Set(responderChains);
+  const intersection = requesterChains.filter(
+    (chain) => responderSet.has(chain)
+  );
+  if (intersection.length === 0) {
+    return null;
+  }
+  if (requesterPreferredTokens) {
+    const requesterMatch = intersection.find(
+      (chain) => requesterPreferredTokens[chain] !== void 0
+    );
+    if (requesterMatch) {
+      return requesterMatch;
+    }
+  }
+  if (responderPreferredTokens) {
+    const responderMatch = intersection.find(
+      (chain) => responderPreferredTokens[chain] !== void 0
+    );
+    if (responderMatch) {
+      return responderMatch;
+    }
+  }
+  return intersection[0] ?? null;
+}
+function resolveTokenForChain(chain, requesterPreferredTokens, responderPreferredTokens) {
+  if (requesterPreferredTokens?.[chain] !== void 0) {
+    return requesterPreferredTokens[chain];
+  }
+  if (responderPreferredTokens?.[chain] !== void 0) {
+    return responderPreferredTokens[chain];
+  }
+  return void 0;
+}
+
+// src/bootstrap/BootstrapService.ts
+import { SimplePool as SimplePool3 } from "nostr-tools/pool";
+import { getPublicKey as getPublicKey3 } from "nostr-tools/pure";
+import WebSocket2 from "ws";
+var BootstrapError = class extends ToonError {
+  constructor(message, cause) {
+    super(message, "BOOTSTRAP_FAILED", cause);
+    this.name = "BootstrapError";
+  }
+};
+var BootstrapService = class {
+  config;
+  secretKey;
+  pubkey;
+  ownIlpInfo;
+  pool;
+  connectorAdmin;
+  channelClient;
+  claimSigner;
+  // ILP-first flow additions
+  ilpClient;
+  settlementInfo;
+  ownIlpAddress;
+  toonEncoder;
+  toonDecoder;
+  basePricePerByte;
+  // Event emitter
+  listeners = [];
+  phase = "discovering";
+  /**
+   * Creates a new BootstrapService instance.
+   *
+   * @param config - Bootstrap configuration with known peers and optional ILP-first settings
+   * @param secretKey - Our Nostr secret key for signing events
+   * @param ownIlpInfo - Our ILP peer info to publish
+   * @param pool - Optional SimplePool instance (creates new one if not provided)
+   */
+  constructor(config, secretKey, ownIlpInfo, pool) {
+    this.config = {
+      knownPeers: config.knownPeers,
+      queryTimeout: config.queryTimeout ?? 5e3,
+      ardriveEnabled: config.ardriveEnabled ?? true,
+      defaultRelayUrl: config.defaultRelayUrl ?? ""
+    };
+    this.secretKey = secretKey;
+    this.pubkey = getPublicKey3(secretKey);
+    this.ownIlpInfo = ownIlpInfo;
+    this.pool = pool ?? new SimplePool3();
+    this.settlementInfo = config.settlementInfo;
+    this.ownIlpAddress = config.ownIlpAddress;
+    this.toonEncoder = config.toonEncoder;
+    this.toonDecoder = config.toonDecoder;
+    this.basePricePerByte = config.basePricePerByte ?? 10n;
+  }
+  /**
+   * Set the ILP client for sending packets via the connector.
+   * Kept separate from constructor for backward compatibility with existing code
+   * that creates the client after construction.
+   */
+  setIlpClient(client) {
+    this.ilpClient = client;
+  }
+  /**
+   * @deprecated Use setIlpClient instead
+   */
+  setAgentRuntimeClient(client) {
+    this.setIlpClient(client);
+  }
+  /**
+   * Set the connector admin client for adding peers/routes.
+   */
+  setConnectorAdmin(admin) {
+    this.connectorAdmin = admin;
+  }
+  /**
+   * Set the channel client for opening payment channels.
+   */
+  setChannelClient(client) {
+    this.channelClient = client;
+  }
+  /**
+   * Set the claim signer for creating signed balance proofs.
+   * Used by clients to sign payment channel claims for ILP packets.
+   */
+  setClaimSigner(signer) {
+    this.claimSigner = signer;
+  }
+  /**
+   * Get the current bootstrap phase.
+   */
+  getPhase() {
+    return this.phase;
+  }
+  /**
+   * Register an event listener.
+   */
+  on(listener) {
+    this.listeners.push(listener);
+  }
+  /**
+   * Unregister an event listener.
+   */
+  off(listener) {
+    this.listeners = this.listeners.filter((l) => l !== listener);
+  }
+  /**
+   * Emit a bootstrap event to all listeners.
+   */
+  emit(event) {
+    for (const listener of this.listeners) {
+      try {
+        listener(event);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Transition to a new phase, emitting phase change event.
+   */
+  setPhase(newPhase) {
+    const previousPhase = this.phase;
+    this.phase = newPhase;
+    this.emit({ type: "bootstrap:phase", phase: newPhase, previousPhase });
+  }
+  /**
+   * Load peers from genesis config, ArDrive, and optional env var JSON.
+   * Merges all sources, deduplicating by pubkey (ArDrive overrides genesis for matching pubkeys).
+   */
+  async loadPeers(additionalPeersJson) {
+    const genesisPeers = GenesisPeerLoader.loadAllPeers(additionalPeersJson);
+    const ardrivePeers = [];
+    if (this.config.ardriveEnabled) {
+      try {
+        const ardriveMap = await ArDrivePeerRegistry.fetchPeers();
+        for (const [pubkey, info] of ardriveMap) {
+          if (!this.config.defaultRelayUrl) continue;
+          ardrivePeers.push({
+            pubkey,
+            relayUrl: this.config.defaultRelayUrl,
+            ilpAddress: info.ilpAddress,
+            btpEndpoint: info.btpEndpoint
+          });
+        }
+      } catch (error) {
+        console.warn(
+          "[Bootstrap] ArDrive peer fetch failed, using genesis peers only:",
+          error instanceof Error ? error.message : "Unknown error"
+        );
+      }
+    }
+    const merged = /* @__PURE__ */ new Map();
+    for (const peer of genesisPeers) {
+      merged.set(peer.pubkey, peer);
+    }
+    for (const peer of ardrivePeers) {
+      merged.set(peer.pubkey, peer);
+    }
+    return [...merged.values()];
+  }
+  /**
+   * Bootstrap with all known peers.
+   *
+   * Loads peers from genesis config, ArDrive, and optional env var JSON,
+   * then attempts to bootstrap with each peer in order.
+   * Returns results for successfully bootstrapped peers.
+   * Continues to next peer on failure.
+   *
+   * @param additionalPeersJson - Optional JSON string of additional peers to merge
+   * @returns Array of successful bootstrap results
+   */
+  async bootstrap(additionalPeersJson) {
+    const results = [];
+    try {
+      this.setPhase("discovering");
+      const allPeers = await this.loadPeers(additionalPeersJson);
+      const knownPeersMap = /* @__PURE__ */ new Map();
+      for (const peer of this.config.knownPeers) {
+        knownPeersMap.set(peer.pubkey, peer);
+      }
+      for (const peer of allPeers) {
+        if (!knownPeersMap.has(peer.pubkey)) {
+          knownPeersMap.set(peer.pubkey, {
+            pubkey: peer.pubkey,
+            relayUrl: peer.relayUrl,
+            btpEndpoint: peer.btpEndpoint
+          });
+        }
+      }
+      this.setPhase("registering");
+      for (const knownPeer of knownPeersMap.values()) {
+        try {
+          const result = await this.bootstrapWithPeer(knownPeer);
+          results.push(result);
+          console.log(
+            `[Bootstrap] Successfully bootstrapped with ${knownPeer.pubkey.slice(0, 16)}...`
+          );
+        } catch (error) {
+          console.warn(
+            `[Bootstrap] Failed to bootstrap with ${knownPeer.pubkey.slice(0, 16)}...:`,
+            error instanceof Error ? error.message : "Unknown error"
+          );
+        }
+      }
+      if (this.ilpClient && results.length > 0) {
+        this.setPhase("announcing");
+        for (const result of results) {
+          try {
+            await this.announceViaIlp(result);
+          } catch (error) {
+            const reason = error instanceof Error ? error.message : "Unknown error";
+            this.emit({
+              type: "bootstrap:announce-failed",
+              peerId: result.registeredPeerId,
+              reason
+            });
+            console.warn(
+              `[Bootstrap] Announce failed for ${result.registeredPeerId}:`,
+              reason
+            );
+          }
+        }
+      }
+      const channelCount = results.filter((r) => r.channelId).length;
+      this.setPhase("ready");
+      this.emit({
+        type: "bootstrap:ready",
+        peerCount: results.length,
+        channelCount
+      });
+    } catch (error) {
+      this.setPhase("failed");
+      console.error(
+        "[Bootstrap] Bootstrap failed:",
+        error instanceof Error ? error.message : "Unknown error"
+      );
+    }
+    return results;
+  }
+  /**
+   * Bootstrap with a single known peer.
+   *
+   * @param knownPeer - The known peer to bootstrap with
+   * @returns Bootstrap result with peer info and registered peer ID
+   * @throws BootstrapError if pubkey is invalid or peer info query fails
+   */
+  async bootstrapWithPeer(knownPeer) {
+    const PUBKEY_REGEX4 = /^[0-9a-f]{64}$/;
+    if (!PUBKEY_REGEX4.test(knownPeer.pubkey)) {
+      throw new BootstrapError(
+        `Invalid pubkey format for known peer: ${knownPeer.pubkey}`
+      );
+    }
+    console.log(`[Bootstrap] Querying ${knownPeer.relayUrl} for peer info...`);
+    const peerInfo = await this.queryPeerInfo(knownPeer);
+    const registeredPeerId = `nostr-${knownPeer.pubkey.slice(0, 16)}`;
+    if (this.connectorAdmin) {
+      try {
+        console.log(`[Bootstrap] Adding peer to connector routing table...`);
+        await this.addPeerToConnector(knownPeer, peerInfo);
+        this.emit({
+          type: "bootstrap:peer-registered",
+          peerId: registeredPeerId,
+          peerPubkey: knownPeer.pubkey,
+          ilpAddress: peerInfo.ilpAddress
+        });
+      } catch (error) {
+        console.warn(
+          `[Bootstrap] Failed to register peer ${registeredPeerId} with connector:`,
+          error instanceof Error ? error.message : "Unknown error"
+        );
+      }
+    }
+    const result = {
+      knownPeer,
+      peerInfo,
+      registeredPeerId
+    };
+    if (this.channelClient && this.settlementInfo?.supportedChains?.length && peerInfo.supportedChains?.length && peerInfo.settlementAddresses) {
+      try {
+        const negotiatedChain = negotiateSettlementChain(
+          this.settlementInfo.supportedChains,
+          peerInfo.supportedChains,
+          this.settlementInfo.preferredTokens,
+          peerInfo.preferredTokens
+        );
+        if (negotiatedChain) {
+          const peerAddress = peerInfo.settlementAddresses[negotiatedChain];
+          const tokenAddress = resolveTokenForChain(
+            negotiatedChain,
+            this.settlementInfo.preferredTokens,
+            peerInfo.preferredTokens
+          );
+          const tokenNetwork = peerInfo.tokenNetworks?.[negotiatedChain];
+          if (peerAddress) {
+            console.log(
+              `[Bootstrap] Opening channel on ${negotiatedChain} with ${registeredPeerId}...`
+            );
+            const channelResult = await this.channelClient.openChannel({
+              peerId: registeredPeerId,
+              chain: negotiatedChain,
+              token: tokenAddress,
+              tokenNetwork,
+              peerAddress,
+              initialDeposit: "100000",
+              settlementTimeout: 86400
+            });
+            result.channelId = channelResult.channelId;
+            result.negotiatedChain = negotiatedChain;
+            result.settlementAddress = peerAddress;
+            console.log(
+              `[Bootstrap] Opened channel ${channelResult.channelId} with ${registeredPeerId}`
+            );
+            this.emit({
+              type: "bootstrap:channel-opened",
+              peerId: registeredPeerId,
+              channelId: channelResult.channelId,
+              negotiatedChain
+            });
+            if (this.connectorAdmin) {
+              await this.connectorAdmin.addPeer({
+                id: registeredPeerId,
+                url: peerInfo.btpEndpoint,
+                authToken: "",
+                routes: [{ prefix: peerInfo.ilpAddress }],
+                settlement: {
+                  preference: negotiatedChain,
+                  ...peerAddress && { evmAddress: peerAddress },
+                  ...tokenAddress && { tokenAddress },
+                  ...tokenNetwork && { tokenNetworkAddress: tokenNetwork },
+                  ...channelResult.channelId && {
+                    channelId: channelResult.channelId
+                  }
+                }
+              });
+            }
+          }
+        }
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : "Unknown error";
+        console.warn(
+          `[Bootstrap] Settlement failed for ${registeredPeerId}:`,
+          reason
+        );
+        this.emit({
+          type: "bootstrap:settlement-failed",
+          peerId: registeredPeerId,
+          reason
+        });
+      }
+    }
+    if (!this.ilpClient) {
+      try {
+        console.log(
+          `[Bootstrap] Publishing our ILP info to ${knownPeer.relayUrl}...`
+        );
+        await this.publishOurInfo(knownPeer.relayUrl);
+      } catch (error) {
+        console.warn(
+          `[Bootstrap] Failed to publish ILP info to ${knownPeer.relayUrl}:`,
+          error instanceof Error ? error.message : "Unknown error"
+        );
+      }
+    }
+    return result;
+  }
+  /**
+   * Announce own kind:10032 as paid ILP PREPARE (Phase 2).
+   */
+  async announceViaIlp(result) {
+    if (!this.ilpClient || !this.toonEncoder) {
+      return;
+    }
+    const ilpInfoEvent = buildIlpPeerInfoEvent(this.ownIlpInfo, this.secretKey);
+    const toonBytes = this.toonEncoder(ilpInfoEvent);
+    const base64Toon = Buffer.from(toonBytes).toString("base64");
+    const amount = String(BigInt(toonBytes.length) * this.basePricePerByte);
+    const ilpResult = await this.ilpClient.sendIlpPacket({
+      destination: result.peerInfo.ilpAddress,
+      amount,
+      data: base64Toon
+    });
+    if (ilpResult.accepted) {
+      console.log(
+        `[Bootstrap] Announced to ${result.registeredPeerId} via ILP (fulfillment: ${ilpResult.fulfillment}, eventId: ${ilpInfoEvent.id})`
+      );
+      this.emit({
+        type: "bootstrap:announced",
+        peerId: result.registeredPeerId,
+        eventId: ilpInfoEvent.id,
+        amount
+      });
+    } else {
+      const reason = `${ilpResult.code} ${ilpResult.message}`;
+      this.emit({
+        type: "bootstrap:announce-failed",
+        peerId: result.registeredPeerId,
+        reason
+      });
+      console.warn(
+        `[Bootstrap] Announce rejected by ${result.registeredPeerId}: ${reason}`
+      );
+    }
+  }
+  /**
+   * Query a peer's relay for their kind:10032 ILP Peer Info event.
+   * Uses direct WebSocket connection for reliable container-to-container communication.
+   */
+  async queryPeerInfo(knownPeer) {
+    const filter = {
+      kinds: [ILP_PEER_INFO_KIND],
+      authors: [knownPeer.pubkey],
+      limit: 1
+    };
+    console.log(`[Bootstrap] Query filter:`, JSON.stringify(filter));
+    console.log(`[Bootstrap] Connecting to ${knownPeer.relayUrl}...`);
+    return new Promise((resolve, reject) => {
+      const events = [];
+      const timeout = this.config.queryTimeout ?? 5e3;
+      const ws = new WebSocket2(knownPeer.relayUrl);
+      const subId = `bootstrap-${Date.now()}`;
+      let resolved = false;
+      const cleanup = () => {
+        if (!resolved) {
+          resolved = true;
+          try {
+            ws.close();
+          } catch {
+          }
+        }
+      };
+      ws.on("open", () => {
+        console.log(
+          `[Bootstrap] Connected to ${knownPeer.relayUrl}, sending REQ`
+        );
+        ws.send(JSON.stringify(["REQ", subId, filter]));
+      });
+      ws.on("message", (data) => {
+        let msg;
+        try {
+          msg = JSON.parse(data.toString());
+        } catch {
+          console.warn("[Bootstrap] Received malformed JSON from relay");
+          return;
+        }
+        console.log(`[Bootstrap] Received message type: ${msg[0]}`);
+        if (msg[0] === "EVENT" && msg[1] === subId) {
+          let event;
+          const rawEvent = msg[2];
+          if (typeof rawEvent === "string") {
+            try {
+              const lines = rawEvent.trim().split("\n");
+              const parsed = {};
+              for (const line of lines) {
+                const colonIndex = line.indexOf(":");
+                if (colonIndex > 0) {
+                  const key = line.substring(0, colonIndex).trim();
+                  const value = line.substring(colonIndex + 1).trim();
+                  if (key.startsWith("tags[")) {
+                    continue;
+                  }
+                  if (value.startsWith('"') && value.endsWith('"')) {
+                    parsed[key] = JSON.parse(value);
+                  } else if (!isNaN(Number(value))) {
+                    parsed[key] = Number(value);
+                  } else {
+                    parsed[key] = value;
+                  }
+                }
+              }
+              event = parsed;
+            } catch (error) {
+              console.warn(`[Bootstrap] Failed to parse TOON event:`, error);
+              return;
+            }
+          } else if (typeof rawEvent === "object" && rawEvent !== null) {
+            event = rawEvent;
+          }
+          if (event && typeof event["id"] === "string") {
+            console.log(
+              `[Bootstrap] Received event: ${event["id"].slice(0, 16)}...`
+            );
+            events.push(event);
+          } else {
+            console.warn(
+              `[Bootstrap] Received EVENT message with invalid event data:`,
+              msg
+            );
+          }
+        } else if (msg[0] === "EOSE" && msg[1] === subId) {
+          console.log(
+            `[Bootstrap] EOSE received, found ${events.length} events`
+          );
+          cleanup();
+          if (events.length === 0) {
+            reject(
+              new BootstrapError(
+                `No kind:${ILP_PEER_INFO_KIND} event found for peer ${knownPeer.pubkey.slice(0, 16)}...`
+              )
+            );
+            return;
+          }
+          const sortedEvents = events.sort(
+            (a, b) => b.created_at - a.created_at
+          );
+          const mostRecent = sortedEvents[0];
+          try {
+            const peerInfo = parseIlpPeerInfo(
+              mostRecent
+            );
+            resolve(peerInfo);
+          } catch (error) {
+            reject(
+              new BootstrapError(
+                `Failed to parse peer info`,
+                error instanceof Error ? error : void 0
+              )
+            );
+          }
+        } else if (msg[0] === "NOTICE") {
+          console.log(`[Bootstrap] Notice from relay: ${msg[1]}`);
+        }
+      });
+      ws.on("error", (error) => {
+        console.error(`[Bootstrap] WebSocket error:`, error.message);
+        cleanup();
+        reject(
+          new BootstrapError(
+            `Failed to connect to ${knownPeer.relayUrl}: ${error.message}`,
+            error
+          )
+        );
+      });
+      ws.on("close", () => {
+        console.log(`[Bootstrap] Connection closed`);
+        if (!resolved) {
+          cleanup();
+          reject(
+            new BootstrapError(
+              `Connection closed before receiving events from ${knownPeer.relayUrl}`
+            )
+          );
+        }
+      });
+      setTimeout(() => {
+        if (resolved) return;
+        console.log(`[Bootstrap] Query timeout after ${timeout}ms`);
+        cleanup();
+        if (events.length > 0) {
+          const sortedEvents = events.sort(
+            (a, b) => b.created_at - a.created_at
+          );
+          const mostRecent = sortedEvents[0];
+          try {
+            const peerInfo = parseIlpPeerInfo(
+              mostRecent
+            );
+            resolve(peerInfo);
+          } catch (error) {
+            reject(
+              new BootstrapError(
+                `Failed to parse peer info`,
+                error instanceof Error ? error : void 0
+              )
+            );
+          }
+        } else {
+          reject(
+            new BootstrapError(
+              `Query timeout: No events received from ${knownPeer.relayUrl} after ${timeout}ms`
+            )
+          );
+        }
+      }, timeout);
+    });
+  }
+  /**
+   * Add a peer to the connector via Admin API.
+   */
+  async addPeerToConnector(knownPeer, peerInfo) {
+    if (!this.connectorAdmin) {
+      throw new BootstrapError("Connector admin client not set");
+    }
+    const peerId = `nostr-${knownPeer.pubkey.slice(0, 16)}`;
+    await this.connectorAdmin.addPeer({
+      id: peerId,
+      url: peerInfo.btpEndpoint,
+      authToken: "",
+      // BTP doesn't need auth
+      routes: [{ prefix: peerInfo.ilpAddress }]
+    });
+  }
+  /**
+   * Publish our own kind:10032 ILP Peer Info to a relay.
+   */
+  async publishOurInfo(relayUrl) {
+    const event = buildIlpPeerInfoEvent(this.ownIlpInfo, this.secretKey);
+    try {
+      await this.pool.publish([relayUrl], event);
+    } catch (error) {
+      throw new BootstrapError(
+        `Failed to publish ILP info to ${relayUrl}`,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Query a peer's relay for other peers' kind:10032 events.
+   *
+   * Used after bootstrapping to discover additional peers
+   * that have also published to the bootstrap node's relay.
+   *
+   * @param relayUrl - The relay URL to query
+   * @param excludePubkeys - Pubkeys to exclude from results (e.g., our own, known peers)
+   * @returns Map of pubkey to IlpPeerInfo for discovered peers
+   */
+  async discoverPeersViaRelay(relayUrl, excludePubkeys = []) {
+    const excludeSet = /* @__PURE__ */ new Set([this.pubkey, ...excludePubkeys]);
+    const filter = {
+      kinds: [ILP_PEER_INFO_KIND]
+    };
+    try {
+      const events = await this.pool.querySync([relayUrl], filter);
+      const eventsByPubkey = /* @__PURE__ */ new Map();
+      for (const event of events) {
+        if (excludeSet.has(event.pubkey)) continue;
+        const existing = eventsByPubkey.get(event.pubkey);
+        if (!existing || event.created_at > existing.created_at) {
+          eventsByPubkey.set(event.pubkey, event);
+        }
+      }
+      const result = /* @__PURE__ */ new Map();
+      for (const [pubkey, event] of eventsByPubkey) {
+        try {
+          const info = parseIlpPeerInfo(event);
+          result.set(pubkey, info);
+        } catch {
+        }
+      }
+      return result;
+    } catch (error) {
+      throw new BootstrapError(
+        `Failed to discover peers from ${relayUrl}`,
+        error instanceof Error ? error : void 0
+      );
+    }
+  }
+  /**
+   * Get our pubkey.
+   */
+  getPubkey() {
+    return this.pubkey;
+  }
+  /**
+   * Publish our ILP info to a specific relay.
+   *
+   * @param relayUrl - The relay URL to publish to (defaults to 'ws://localhost:7100')
+   */
+  async publishToRelay(relayUrl = "ws://localhost:7100") {
+    await this.publishOurInfo(relayUrl);
+  }
+};
+
+// src/bootstrap/discovery-tracker.ts
+import { getPublicKey as getPublicKey4 } from "nostr-tools/pure";
+function createDiscoveryTracker(config) {
+  const pubkey = getPublicKey4(config.secretKey);
+  const excludedPubkeys = /* @__PURE__ */ new Set([pubkey]);
+  let connectorAdmin;
+  let channelClient;
+  let listeners = [];
+  const discoveredPeers = /* @__PURE__ */ new Map();
+  const peeredPubkeys = /* @__PURE__ */ new Set();
+  const peerTimestamps = /* @__PURE__ */ new Map();
+  function emit(event) {
+    for (const listener of listeners) {
+      try {
+        listener(event);
+      } catch {
+      }
+    }
+  }
+  function handleDeregistration(peerPubkey, peerId) {
+    discoveredPeers.delete(peerPubkey);
+    if (peeredPubkeys.has(peerPubkey)) {
+      peeredPubkeys.delete(peerPubkey);
+      if (connectorAdmin?.removePeer) {
+        connectorAdmin.removePeer(peerId).then(() => {
+          emit({
+            type: "bootstrap:peer-deregistered",
+            peerId,
+            peerPubkey,
+            reason: "empty-content"
+          });
+        }).catch((error) => {
+          console.warn(
+            `[DiscoveryTracker] Failed to deregister ${peerId}:`,
+            error instanceof Error ? error.message : "Unknown error"
+          );
+        });
+      } else {
+        emit({
+          type: "bootstrap:peer-deregistered",
+          peerId,
+          peerPubkey,
+          reason: "empty-content"
+        });
+      }
+    }
+  }
+  function processDiscovery(event) {
+    const peerId = `nostr-${event.pubkey.slice(0, 16)}`;
+    let peerInfo;
+    try {
+      peerInfo = parseIlpPeerInfo(event);
+    } catch {
+    }
+    if (!peerInfo || !peerInfo.ilpAddress || !event.content || event.content.trim() === "") {
+      handleDeregistration(event.pubkey, peerId);
+      return;
+    }
+    discoveredPeers.set(event.pubkey, {
+      pubkey: event.pubkey,
+      peerId,
+      peerInfo,
+      discoveredAt: event.created_at
+    });
+    emit({
+      type: "bootstrap:peer-discovered",
+      peerPubkey: event.pubkey,
+      ilpAddress: peerInfo.ilpAddress
+    });
+  }
+  const tracker = {
+    processEvent(event) {
+      if (event.kind !== ILP_PEER_INFO_KIND) return;
+      if (excludedPubkeys.has(event.pubkey)) return;
+      const lastSeen = peerTimestamps.get(event.pubkey) ?? 0;
+      if (event.created_at <= lastSeen) return;
+      peerTimestamps.set(event.pubkey, event.created_at);
+      processDiscovery(event);
+    },
+    async peerWith(targetPubkey) {
+      if (peeredPubkeys.has(targetPubkey)) {
+        return;
+      }
+      const discovered = discoveredPeers.get(targetPubkey);
+      if (!discovered) {
+        throw new BootstrapError(
+          `Peer ${targetPubkey.slice(0, 16)}... not discovered yet`
+        );
+      }
+      if (!connectorAdmin) {
+        throw new BootstrapError(
+          "connectorAdmin must be set before calling peerWith()"
+        );
+      }
+      const { peerId, peerInfo } = discovered;
+      const admin = connectorAdmin;
+      peeredPubkeys.add(targetPubkey);
+      try {
+        await admin.addPeer({
+          id: peerId,
+          url: peerInfo.btpEndpoint,
+          authToken: "",
+          routes: [{ prefix: peerInfo.ilpAddress }]
+        });
+        emit({
+          type: "bootstrap:peer-registered",
+          peerId,
+          peerPubkey: targetPubkey,
+          ilpAddress: peerInfo.ilpAddress
+        });
+      } catch (error) {
+        peeredPubkeys.delete(targetPubkey);
+        const reason = error instanceof Error ? error.message : "Unknown error";
+        console.warn(
+          `[DiscoveryTracker] Failed to register ${peerId}:`,
+          reason
+        );
+        emit({
+          type: "bootstrap:settlement-failed",
+          peerId,
+          reason: `Registration failed: ${reason}`
+        });
+        return;
+      }
+      if (channelClient && config.settlementInfo?.supportedChains?.length && peerInfo.supportedChains?.length && peerInfo.settlementAddresses) {
+        try {
+          const negotiatedChain = negotiateSettlementChain(
+            config.settlementInfo.supportedChains,
+            peerInfo.supportedChains,
+            config.settlementInfo.preferredTokens,
+            peerInfo.preferredTokens
+          );
+          if (negotiatedChain) {
+            const peerAddress = peerInfo.settlementAddresses[negotiatedChain];
+            const tokenAddress = resolveTokenForChain(
+              negotiatedChain,
+              config.settlementInfo.preferredTokens,
+              peerInfo.preferredTokens
+            );
+            const tokenNetwork = peerInfo.tokenNetworks?.[negotiatedChain];
+            if (peerAddress) {
+              const channelResult = await channelClient.openChannel({
+                peerId,
+                chain: negotiatedChain,
+                token: tokenAddress,
+                tokenNetwork,
+                peerAddress,
+                initialDeposit: "100000",
+                settlementTimeout: 86400
+              });
+              await admin.addPeer({
+                id: peerId,
+                url: peerInfo.btpEndpoint,
+                authToken: "",
+                routes: [{ prefix: peerInfo.ilpAddress }],
+                settlement: {
+                  preference: negotiatedChain,
+                  ...peerAddress && { evmAddress: peerAddress },
+                  ...tokenAddress && { tokenAddress },
+                  ...tokenNetwork && {
+                    tokenNetworkAddress: tokenNetwork
+                  },
+                  ...channelResult.channelId && {
+                    channelId: channelResult.channelId
+                  }
+                }
+              });
+              emit({
+                type: "bootstrap:channel-opened",
+                peerId,
+                channelId: channelResult.channelId,
+                negotiatedChain
+              });
+            }
+          }
+        } catch (error) {
+          const reason = error instanceof Error ? error.message : "Unknown error";
+          console.warn(
+            `[DiscoveryTracker] Settlement failed for ${peerId}:`,
+            reason
+          );
+          emit({
+            type: "bootstrap:settlement-failed",
+            peerId,
+            reason
+          });
+        }
+      }
+    },
+    getDiscoveredPeers() {
+      return [...discoveredPeers.values()].filter(
+        (p) => !peeredPubkeys.has(p.pubkey)
+      );
+    },
+    isPeered(targetPubkey) {
+      return peeredPubkeys.has(targetPubkey);
+    },
+    getPeerCount() {
+      return peeredPubkeys.size;
+    },
+    getDiscoveredCount() {
+      return discoveredPeers.size;
+    },
+    on(listener) {
+      listeners.push(listener);
+    },
+    off(listener) {
+      listeners = listeners.filter((l) => l !== listener);
+    },
+    setConnectorAdmin(admin) {
+      connectorAdmin = admin;
+    },
+    setChannelClient(client) {
+      channelClient = client;
+    },
+    addExcludedPubkeys(pubkeys) {
+      for (const pk of pubkeys) {
+        excludedPubkeys.add(pk);
+      }
+    }
+  };
+  return tracker;
+}
+
+// src/bootstrap/ilp-client.ts
+function createHttpIlpClient(baseUrl) {
+  try {
+    new URL(baseUrl);
+  } catch {
+    throw new BootstrapError(`Invalid connector base URL: ${baseUrl}`);
+  }
+  const normalizedUrl = baseUrl.replace(/\/+$/, "");
+  return {
+    async sendIlpPacket(params) {
+      let response;
+      try {
+        response = await fetch(`${normalizedUrl}/admin/ilp/send`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            destination: params.destination,
+            amount: params.amount,
+            data: params.data,
+            ...params.timeout !== void 0 && { timeout: params.timeout }
+          })
+        });
+      } catch (error) {
+        throw new BootstrapError(
+          `Network error sending ILP packet: ${error instanceof Error ? error.message : "Unknown error"}`,
+          error instanceof Error ? error : void 0
+        );
+      }
+      if (!response.ok) {
+        const text = await response.text().catch(() => "Unknown error");
+        throw new BootstrapError(
+          `Connector error (${response.status}): ${text}`
+        );
+      }
+      const data = await response.json();
+      return {
+        accepted: data["accepted"] ?? data["fulfilled"] ?? false,
+        fulfillment: data["fulfillment"],
+        data: data["data"],
+        code: data["code"],
+        message: data["message"]
+      };
+    }
+  };
+}
+var createHttpRuntimeClient = createHttpIlpClient;
+var createAgentRuntimeClient = createHttpIlpClient;
+
+// src/bootstrap/direct-ilp-client.ts
+import { createHash } from "crypto";
+function createDirectIlpClient(connector, config) {
+  return {
+    async sendIlpPacket(params) {
+      try {
+        const amount = BigInt(params.amount);
+        const data = Uint8Array.from(Buffer.from(params.data, "base64"));
+        let executionCondition;
+        if (config?.toonDecoder && data.length > 0) {
+          const decoded = config.toonDecoder(data);
+          const fulfillment = createHash("sha256").update(decoded.id).digest();
+          executionCondition = createHash("sha256").update(fulfillment).digest();
+        }
+        const result = await connector.sendPacket({
+          destination: params.destination,
+          amount,
+          data,
+          executionCondition,
+          expiresAt: new Date(Date.now() + 3e4)
+        });
+        if (result.type === "fulfill" || result.type === 13) {
+          return {
+            accepted: true,
+            fulfillment: Buffer.from(result.fulfillment).toString("base64"),
+            data: result.data ? Buffer.from(result.data).toString("base64") : void 0
+          };
+        }
+        return {
+          accepted: false,
+          code: result.code,
+          message: result.message,
+          data: result.data ? Buffer.from(result.data).toString("base64") : void 0
+        };
+      } catch (error) {
+        if (error instanceof BootstrapError) {
+          throw error;
+        }
+        throw new BootstrapError(
+          `Direct ILP packet send failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+          error instanceof Error ? error : void 0
+        );
+      }
+    }
+  };
+}
+var createDirectRuntimeClient = createDirectIlpClient;
+
+// src/bootstrap/direct-connector-admin.ts
+function createDirectConnectorAdmin(connector) {
+  return {
+    async addPeer(config) {
+      try {
+        await connector.registerPeer({
+          id: config.id,
+          url: config.url,
+          authToken: config.authToken,
+          routes: config.routes,
+          settlement: config.settlement
+        });
+      } catch (error) {
+        if (error instanceof BootstrapError) {
+          throw error;
+        }
+        throw new BootstrapError(
+          `Failed to register peer ${config.id}`,
+          error instanceof Error ? error : void 0
+        );
+      }
+    },
+    async removePeer(peerId) {
+      try {
+        await connector.removePeer(peerId);
+      } catch (error) {
+        if (error instanceof BootstrapError) {
+          throw error;
+        }
+        throw new BootstrapError(
+          `Failed to remove peer ${peerId}`,
+          error instanceof Error ? error : void 0
+        );
+      }
+    }
+  };
+}
+
+// src/bootstrap/direct-channel-client.ts
+function createDirectChannelClient(connector) {
+  return {
+    async openChannel(params) {
+      try {
+        return await connector.openChannel(params);
+      } catch (error) {
+        if (error instanceof BootstrapError) {
+          throw error;
+        }
+        throw new BootstrapError(
+          `Failed to open channel for peer ${params.peerId}`,
+          error instanceof Error ? error : void 0
+        );
+      }
+    },
+    async getChannelState(channelId) {
+      try {
+        return await connector.getChannelState(channelId);
+      } catch (error) {
+        if (error instanceof BootstrapError) {
+          throw error;
+        }
+        throw new BootstrapError(
+          `Failed to get channel state for ${channelId}`,
+          error instanceof Error ? error : void 0
+        );
+      }
+    }
+  };
+}
+
+// src/bootstrap/http-connector-admin.ts
+function createHttpConnectorAdmin(adminUrl, btpSecret) {
+  const baseUrl = adminUrl.replace(/\/$/, "");
+  return {
+    async addPeer(config) {
+      try {
+        const payload = {
+          id: config.id,
+          url: config.url,
+          authToken: config.authToken || JSON.stringify({
+            peerId: config.id,
+            secret: btpSecret
+          }),
+          routes: config.routes,
+          settlement: config.settlement
+        };
+        const response = await fetch(`${baseUrl}/admin/peers`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(payload)
+        });
+        if (!response.ok) {
+          const text = await response.text();
+          throw new Error(`HTTP ${response.status}: ${text}`);
+        }
+      } catch (error) {
+        if (error instanceof BootstrapError) {
+          throw error;
+        }
+        throw new BootstrapError(
+          `Failed to register peer ${config.id} via HTTP`,
+          error instanceof Error ? error : void 0
+        );
+      }
+    },
+    async removePeer(peerId) {
+      try {
+        const response = await fetch(`${baseUrl}/admin/peers/${peerId}`, {
+          method: "DELETE"
+        });
+        if (!response.ok) {
+          const text = await response.text();
+          throw new Error(`HTTP ${response.status}: ${text}`);
+        }
+      } catch (error) {
+        if (error instanceof BootstrapError) {
+          throw error;
+        }
+        throw new BootstrapError(
+          `Failed to remove peer ${peerId} via HTTP`,
+          error instanceof Error ? error : void 0
+        );
+      }
+    }
+  };
+}
+
+// src/bootstrap/http-ilp-client.ts
+function createHttpIlpClient2(connectorUrl) {
+  const baseUrl = connectorUrl.replace(/\/$/, "");
+  return {
+    async sendIlpPacket(params) {
+      try {
+        const response = await fetch(`${baseUrl}/send-packet`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            destination: params.destination,
+            amount: params.amount,
+            data: params.data
+          }),
+          signal: params.timeout ? AbortSignal.timeout(params.timeout) : void 0
+        });
+        if (!response.ok) {
+          const text = await response.text();
+          return {
+            accepted: false,
+            code: "T00",
+            message: `HTTP ${response.status}: ${text}`
+          };
+        }
+        const result = await response.json();
+        if (result["accept"] || result["accepted"]) {
+          return {
+            accepted: true,
+            fulfillment: result["fulfillment"],
+            data: result["data"]
+          };
+        } else {
+          return {
+            accepted: false,
+            code: result["code"] || "T00",
+            message: result["message"] || "Unknown error"
+          };
+        }
+      } catch (error) {
+        if (error instanceof BootstrapError) {
+          throw error;
+        }
+        return {
+          accepted: false,
+          code: "T00",
+          message: `HTTP request failed: ${error instanceof Error ? error.message : "Unknown"}`
+        };
+      }
+    }
+  };
+}
+
+// src/bootstrap/http-channel-client.ts
+function createHttpChannelClient(adminUrl) {
+  const baseUrl = adminUrl.replace(/\/$/, "");
+  return {
+    async openChannel(params) {
+      try {
+        const response = await fetch(`${baseUrl}/admin/channels`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            peerId: params.peerId,
+            chain: params.chain,
+            token: params.token,
+            tokenNetwork: params.tokenNetwork,
+            peerAddress: params.peerAddress,
+            initialDeposit: params.initialDeposit,
+            settlementTimeout: params.settlementTimeout
+          })
+        });
+        if (!response.ok) {
+          const text = await response.text();
+          throw new Error(`HTTP ${response.status}: ${text}`);
+        }
+        const result = await response.json();
+        return {
+          channelId: result["channelId"],
+          status: result["status"]
+        };
+      } catch (error) {
+        if (error instanceof BootstrapError) {
+          throw error;
+        }
+        throw new BootstrapError(
+          `Failed to open channel for peer ${params.peerId} via HTTP`,
+          error instanceof Error ? error : void 0
+        );
+      }
+    },
+    async getChannelState(channelId) {
+      try {
+        const response = await fetch(`${baseUrl}/admin/channels/${channelId}`);
+        if (!response.ok) {
+          const text = await response.text();
+          throw new Error(`HTTP ${response.status}: ${text}`);
+        }
+        const result = await response.json();
+        return {
+          channelId: result["channelId"],
+          status: result["status"],
+          chain: result["chain"]
+        };
+      } catch (error) {
+        if (error instanceof BootstrapError) {
+          throw error;
+        }
+        throw new BootstrapError(
+          `Failed to get channel state for ${channelId} via HTTP`,
+          error instanceof Error ? error : void 0
+        );
+      }
+    }
+  };
+}
+
+// src/bootstrap/AttestationVerifier.ts
+var AttestationState = /* @__PURE__ */ ((AttestationState2) => {
+  AttestationState2["VALID"] = "valid";
+  AttestationState2["STALE"] = "stale";
+  AttestationState2["UNATTESTED"] = "unattested";
+  return AttestationState2;
+})(AttestationState || {});
+var DEFAULT_VALIDITY_SECONDS = 300;
+var DEFAULT_GRACE_SECONDS = 30;
+var AttestationVerifier = class {
+  knownGoodPcrs;
+  validitySeconds;
+  graceSeconds;
+  constructor(config) {
+    this.knownGoodPcrs = new Map(config.knownGoodPcrs);
+    const validity = config.validitySeconds ?? DEFAULT_VALIDITY_SECONDS;
+    const grace = config.graceSeconds ?? DEFAULT_GRACE_SECONDS;
+    if (!Number.isFinite(validity) || validity < 0) {
+      throw new Error(
+        `validitySeconds must be a non-negative finite number, got ${String(validity)}`
+      );
+    }
+    if (!Number.isFinite(grace) || grace < 0) {
+      throw new Error(
+        `graceSeconds must be a non-negative finite number, got ${String(grace)}`
+      );
+    }
+    this.validitySeconds = validity;
+    this.graceSeconds = grace;
+  }
+  /**
+   * Verifies a TEE attestation's PCR values against the known-good registry.
+   *
+   * All three PCR values (pcr0, pcr1, pcr2) must be present and truthy in
+   * the registry for verification to pass.
+   *
+   * @param attestation - The TEE attestation to verify.
+   * @returns Verification result with `valid: true` or `valid: false` with reason.
+   */
+  verify(attestation) {
+    const pcr0Valid = this.knownGoodPcrs.get(attestation.pcr0) === true;
+    const pcr1Valid = this.knownGoodPcrs.get(attestation.pcr1) === true;
+    const pcr2Valid = this.knownGoodPcrs.get(attestation.pcr2) === true;
+    if (pcr0Valid && pcr1Valid && pcr2Valid) {
+      return { valid: true };
+    }
+    return { valid: false, reason: "PCR mismatch" };
+  }
+  /**
+   * Computes the attestation lifecycle state based on timing.
+   *
+   * Boundary behavior:
+   * - At exactly `attestedAt + validitySeconds`: VALID (inclusive <=)
+   * - At exactly `attestedAt + validitySeconds + graceSeconds`: STALE (inclusive <=)
+   * - After grace expires: UNATTESTED
+   *
+   * @param _attestation - The TEE attestation (unused, reserved for future per-attestation logic).
+   * @param attestedAt - Unix timestamp when the attestation was created.
+   * @param now - Optional current unix timestamp (defaults to real clock).
+   * @returns The current attestation state.
+   */
+  getAttestationState(_attestation, attestedAt, now) {
+    if (!Number.isFinite(attestedAt)) {
+      return "unattested" /* UNATTESTED */;
+    }
+    const currentTime = now ?? Math.floor(Date.now() / 1e3);
+    const validityEnd = attestedAt + this.validitySeconds;
+    const graceEnd = validityEnd + this.graceSeconds;
+    if (currentTime <= validityEnd) {
+      return "valid" /* VALID */;
+    }
+    if (currentTime <= graceEnd) {
+      return "stale" /* STALE */;
+    }
+    return "unattested" /* UNATTESTED */;
+  }
+  /**
+   * Ranks peers by attestation status: attested peers first, then non-attested.
+   *
+   * Preserves relative order within each group (stable sort via filter).
+   * Does NOT mutate the input array -- returns a new sorted array.
+   *
+   * Attestation is a preference, not a requirement. Non-attested peers
+   * remain in the result and are connectable.
+   *
+   * @param peers - Array of peer descriptors to rank.
+   * @returns New array with attested peers first, preserving relative order.
+   */
+  rankPeers(peers) {
+    const attested = peers.filter((p) => p.attested);
+    const nonAttested = peers.filter((p) => !p.attested);
+    return [...attested, ...nonAttested];
+  }
+};
+
+// src/bootstrap/AttestationBootstrap.ts
+var AttestationBootstrap = class {
+  config;
+  listeners = [];
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Register an event listener.
+   */
+  on(listener) {
+    this.listeners.push(listener);
+  }
+  /**
+   * Unregister an event listener.
+   */
+  off(listener) {
+    this.listeners = this.listeners.filter((l) => l !== listener);
+  }
+  /**
+   * Emit an attestation bootstrap event to all listeners.
+   */
+  emit(event) {
+    const snapshot = [...this.listeners];
+    for (const listener of snapshot) {
+      try {
+        listener(event);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Execute the attestation-first bootstrap flow.
+   *
+   * Iterates seed relays in order:
+   * 1. Emit seed-connected, query attestation
+   * 2. If null or verify fails or error: emit verification-failed, try next
+   * 3. If valid: emit verified, subscribe peers, emit peers-discovered
+   * 4. Return attested result with discovered peers
+   * 5. If ALL fail: log warning, emit degraded, return degraded result
+   */
+  async bootstrap() {
+    const { seedRelays, verifier, queryAttestation, subscribePeers } = this.config;
+    for (const relayUrl of seedRelays) {
+      this.emit({ type: "attestation:seed-connected", relayUrl });
+      try {
+        const attestationEvent = await queryAttestation(relayUrl);
+        if (attestationEvent === null) {
+          this.emit({
+            type: "attestation:verification-failed",
+            relayUrl,
+            reason: "No attestation event found"
+          });
+          continue;
+        }
+        const raw = await Promise.resolve(verifier.verify(attestationEvent));
+        const isValid = typeof raw === "boolean" ? raw : typeof raw === "object" && raw !== null && "valid" in raw ? raw.valid : false;
+        if (!isValid) {
+          this.emit({
+            type: "attestation:verification-failed",
+            relayUrl,
+            reason: "Attestation verification failed"
+          });
+          continue;
+        }
+        this.emit({
+          type: "attestation:verified",
+          relayUrl,
+          pubkey: attestationEvent.pubkey
+        });
+        const peers = await subscribePeers(relayUrl);
+        this.emit({
+          type: "attestation:peers-discovered",
+          relayUrl,
+          peerCount: peers.length
+        });
+        return {
+          mode: "attested",
+          attestedSeedRelay: relayUrl,
+          discoveredPeers: peers
+        };
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : "Unknown error";
+        this.emit({
+          type: "attestation:verification-failed",
+          relayUrl,
+          reason
+        });
+      }
+    }
+    console.warn(
+      `No attested seed relays found. Tried ${String(seedRelays.length)} relays. Starting in degraded mode.`
+    );
+    this.emit({
+      type: "attestation:degraded",
+      triedCount: seedRelays.length
+    });
+    return {
+      mode: "degraded",
+      attestedSeedRelay: void 0,
+      discoveredPeers: []
+    };
+  }
+};
+
+// src/compose.ts
+function createToonNode(config) {
+  const directIlpClient = createDirectIlpClient(config.connector, {
+    toonDecoder: config.toonDecoder
+  });
+  const directAdminClient = createDirectConnectorAdmin(config.connector);
+  const channelClient = config.connector.openChannel && config.connector.getChannelState ? createDirectChannelClient(
+    config.connector
+  ) : null;
+  const bootstrapService = new BootstrapService(
+    {
+      knownPeers: config.knownPeers ?? [],
+      ardriveEnabled: config.ardriveEnabled ?? true,
+      defaultRelayUrl: config.defaultRelayUrl ?? "",
+      queryTimeout: config.queryTimeout ?? 5e3,
+      settlementInfo: config.settlementInfo,
+      ownIlpAddress: config.ilpInfo.ilpAddress,
+      toonEncoder: config.toonEncoder,
+      toonDecoder: config.toonDecoder,
+      basePricePerByte: config.basePricePerByte ?? 10n
+    },
+    config.secretKey,
+    config.ilpInfo
+  );
+  bootstrapService.setIlpClient(directIlpClient);
+  bootstrapService.setConnectorAdmin(directAdminClient);
+  if (channelClient) {
+    bootstrapService.setChannelClient(channelClient);
+  }
+  const discoveryTracker = createDiscoveryTracker({
+    secretKey: config.secretKey,
+    settlementInfo: config.settlementInfo
+  });
+  discoveryTracker.setConnectorAdmin(directAdminClient);
+  if (channelClient) {
+    discoveryTracker.setChannelClient(channelClient);
+  }
+  let started = false;
+  return {
+    bootstrapService,
+    discoveryTracker,
+    channelClient,
+    ilpClient: directIlpClient,
+    peerWith(pubkey) {
+      return discoveryTracker.peerWith(pubkey);
+    },
+    async start() {
+      if (started) {
+        throw new BootstrapError("ToonNode already started");
+      }
+      try {
+        if (config.connector.setPacketHandler) {
+          config.connector.setPacketHandler(config.handlePacket);
+        }
+        const results = await bootstrapService.bootstrap(
+          config.additionalPeersJson
+        );
+        const bootstrapPeerPubkeys = results.map((r) => r.knownPeer.pubkey);
+        discoveryTracker.addExcludedPubkeys(bootstrapPeerPubkeys);
+        started = true;
+        const channelCount = results.filter((r) => r.channelId).length;
+        return {
+          bootstrapResults: results,
+          peerCount: results.length,
+          channelCount
+        };
+      } catch (error) {
+        throw new BootstrapError(
+          `Failed to start ToonNode: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    },
+    async stop() {
+      if (!started) {
+        return;
+      }
+      started = false;
+    }
+  };
+}
+
+// src/chain/usdc.ts
+var MOCK_USDC_ADDRESS = "0x5FbDB2315678afecb367f032d93F642f64180aa3";
+var USDC_DECIMALS = 6;
+var USDC_SYMBOL = "USDC";
+var USDC_NAME = "USD Coin";
+var MOCK_USDC_CONFIG = {
+  address: MOCK_USDC_ADDRESS,
+  decimals: USDC_DECIMALS,
+  symbol: USDC_SYMBOL,
+  name: USDC_NAME
+};
+
+// src/chain/chain-config.ts
+var CHAIN_PRESETS = {
+  anvil: {
+    name: "anvil",
+    chainId: 31337,
+    rpcUrl: "http://localhost:8545",
+    usdcAddress: MOCK_USDC_ADDRESS,
+    tokenNetworkAddress: "0xCafac3dD18aC6c6e92c921884f9E4176737C052c"
+  },
+  "arbitrum-sepolia": {
+    name: "arbitrum-sepolia",
+    chainId: 421614,
+    rpcUrl: "https://sepolia-rollup.arbitrum.io/rpc",
+    usdcAddress: "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d",
+    tokenNetworkAddress: ""
+  },
+  "arbitrum-one": {
+    name: "arbitrum-one",
+    chainId: 42161,
+    rpcUrl: "https://arb1.arbitrum.io/rpc",
+    usdcAddress: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+    tokenNetworkAddress: ""
+  }
+};
+function resolveChainConfig(chain) {
+  const envChain = process.env["TOON_CHAIN"];
+  const name = envChain || chain || "anvil";
+  const preset = CHAIN_PRESETS[name];
+  if (!preset) {
+    throw new ToonError(
+      `Unknown chain "${name}". Valid chains: anvil, arbitrum-sepolia, arbitrum-one`,
+      "INVALID_CHAIN"
+    );
+  }
+  const resolved = { ...preset };
+  const envRpcUrl = process.env["TOON_RPC_URL"];
+  if (envRpcUrl) {
+    resolved.rpcUrl = envRpcUrl;
+  }
+  const envTokenNetwork = process.env["TOON_TOKEN_NETWORK"];
+  if (envTokenNetwork) {
+    resolved.tokenNetworkAddress = envTokenNetwork;
+  }
+  return resolved;
+}
+function buildEip712Domain(config) {
+  return {
+    name: "TokenNetwork",
+    version: "1",
+    chainId: config.chainId,
+    verifyingContract: config.tokenNetworkAddress
+  };
+}
+
+// src/x402/build-ilp-prepare.ts
+function buildIlpPrepare(params) {
+  return {
+    destination: params.destination,
+    amount: String(params.amount),
+    data: Buffer.from(params.data).toString("base64")
+  };
+}
+
+// src/identity/kms-identity.ts
+import { validateMnemonic, mnemonicToSeedSync } from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english.js";
+import { HDKey } from "@scure/bip32";
+import { getPublicKey as getPublicKey5 } from "nostr-tools/pure";
+var KmsIdentityError = class extends ToonError {
+  constructor(message, cause) {
+    super(message, "KMS_IDENTITY_ERROR", cause);
+    this.name = "KmsIdentityError";
+  }
+};
+var MAX_BIP32_INDEX = 2147483647;
+function deriveFromKmsSeed(seed, options) {
+  if (!(seed instanceof Uint8Array)) {
+    throw new KmsIdentityError(
+      `KMS seed unavailable: expected Uint8Array, got ${seed === null ? "null" : typeof seed}`
+    );
+  }
+  if (seed.length !== 32) {
+    throw new KmsIdentityError(
+      `KMS seed invalid: expected 32 bytes, got ${seed.length} bytes`
+    );
+  }
+  const accountIndex = options?.accountIndex ?? 0;
+  if (!Number.isInteger(accountIndex) || accountIndex < 0 || accountIndex > MAX_BIP32_INDEX) {
+    throw new KmsIdentityError(
+      `Invalid accountIndex: expected a non-negative integer (0 to ${MAX_BIP32_INDEX}), got ${String(accountIndex)}`
+    );
+  }
+  const path2 = `m/44'/1237'/0'/0/${accountIndex}`;
+  let derivationSeed;
+  let masterKey;
+  let childKey;
+  try {
+    if (options?.mnemonic !== void 0) {
+      if (!validateMnemonic(options.mnemonic, wordlist)) {
+        throw new KmsIdentityError(
+          "Invalid BIP-39 mnemonic: the provided words do not form a valid mnemonic phrase"
+        );
+      }
+      derivationSeed = mnemonicToSeedSync(options.mnemonic);
+    } else {
+      derivationSeed = seed;
+    }
+    masterKey = HDKey.fromMasterSeed(derivationSeed);
+    childKey = masterKey.derive(path2);
+    if (!childKey.privateKey) {
+      throw new KmsIdentityError(
+        `Failed to derive private key at path ${path2}`
+      );
+    }
+    const secretKey = childKey.privateKey;
+    const pubkey = getPublicKey5(secretKey);
+    return { secretKey: new Uint8Array(secretKey), pubkey };
+  } catch (error) {
+    if (error instanceof KmsIdentityError) {
+      throw error;
+    }
+    throw new KmsIdentityError(
+      `KMS key derivation failed at path ${path2}: ${error instanceof Error ? error.message : String(error)}`,
+      error instanceof Error ? error : void 0
+    );
+  } finally {
+    masterKey?.wipePrivateData();
+    childKey?.wipePrivateData();
+    if (options?.mnemonic !== void 0 && derivationSeed) {
+      derivationSeed.fill(0);
+    }
+  }
+}
+
+// src/build/nix-builder.ts
+import { execFile as execFileCb } from "child_process";
+import { readFile, mkdtemp, cp, writeFile, rm } from "fs/promises";
+import { tmpdir } from "os";
+import path from "path";
+import { createHash as createHash2 } from "crypto";
+function execFileAsync(cmd, args, options) {
+  return new Promise((resolve, reject) => {
+    execFileCb(cmd, args, options, (error, stdout, stderr) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve({ stdout: stdout.toString(), stderr: stderr.toString() });
+      }
+    });
+  });
+}
+var NixBuilder = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Execute a Nix build and return the result.
+   *
+   * Shells out to `nix build .#docker-image` in the project root directory.
+   * If sourceOverride is configured, creates a temporary modified source tree.
+   *
+   * @throws Error if Nix is not installed or the build fails
+   */
+  async build() {
+    let buildDir = this.config.projectRoot;
+    let tempDir;
+    try {
+      if (this.config.sourceOverride) {
+        tempDir = await mkdtemp(path.join(tmpdir(), "toon-nix-"));
+        await cp(this.config.projectRoot, tempDir, { recursive: true });
+        for (const [relativePath, content] of Object.entries(
+          this.config.sourceOverride
+        )) {
+          const fullPath = path.resolve(tempDir, relativePath);
+          if (!fullPath.startsWith(tempDir + path.sep) && fullPath !== tempDir) {
+            throw new Error(
+              `sourceOverride path traversal detected: "${relativePath}" resolves outside temp directory`
+            );
+          }
+          await writeFile(fullPath, content, "utf-8");
+        }
+        buildDir = tempDir;
+      }
+      const { stdout } = await execFileAsync(
+        "nix",
+        ["build", ".#docker-image", "--print-out-paths"],
+        {
+          cwd: buildDir,
+          timeout: 6e5
+          // 10 minutes -- Nix builds can be slow on first run
+        }
+      );
+      const imagePath = stdout.trim();
+      if (!imagePath.startsWith("/nix/store/")) {
+        throw new Error(
+          `Unexpected Nix build output path: ${imagePath} (expected /nix/store/...)`
+        );
+      }
+      const imageData = await readFile(imagePath);
+      const sha256 = createHash2("sha256").update(imageData).digest("hex");
+      const imageHash = `sha256:${sha256}`;
+      const pcr0 = createHash2("sha384").update(imageData).digest("hex");
+      const KERNEL_REGION_SIZE = 1024 * 1024;
+      const kernelRegion = imageData.subarray(
+        0,
+        Math.min(KERNEL_REGION_SIZE, imageData.length)
+      );
+      const pcr1 = createHash2("sha384").update(kernelRegion).digest("hex");
+      const appRegion = imageData.subarray(
+        Math.min(KERNEL_REGION_SIZE, imageData.length)
+      );
+      const pcr2 = appRegion.length > 0 ? createHash2("sha384").update(appRegion).digest("hex") : createHash2("sha384").update("pcr2:").update(imageData).digest("hex");
+      return {
+        imageHash,
+        pcr0,
+        pcr1,
+        pcr2,
+        imagePath,
+        buildTimestamp: Math.floor(Date.now() / 1e3)
+      };
+    } finally {
+      if (tempDir) {
+        await rm(tempDir, { recursive: true, force: true }).catch(() => {
+        });
+      }
+    }
+  }
+};
+
+// src/build/pcr-validator.ts
+import { readFile as readFile2 } from "fs/promises";
+var PcrReproducibilityError = class extends ToonError {
+  constructor(buildA, buildB) {
+    super(
+      `PCR reproducibility check failed: pcr0 buildA=${buildA.pcr0} buildB=${buildB.pcr0}, pcr1 buildA=${buildA.pcr1} buildB=${buildB.pcr1}, pcr2 buildA=${buildA.pcr2} buildB=${buildB.pcr2}`,
+      "PCR_REPRODUCIBILITY_ERROR"
+    );
+    this.name = "PcrReproducibilityError";
+  }
+};
+async function readDockerfileNix(filePath) {
+  return readFile2(filePath, "utf-8");
+}
+function analyzeDockerfileForNonDeterminism(content, forbiddenPatterns) {
+  const lines = content.split("\n");
+  const violations = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === void 0) continue;
+    const trimmed = line.trim();
+    if (trimmed.startsWith("#")) continue;
+    for (const fp of forbiddenPatterns) {
+      fp.pattern.lastIndex = 0;
+      const match = fp.pattern.exec(line);
+      if (match) {
+        violations.push({
+          line: i + 1,
+          // 1-indexed line numbers
+          patternName: fp.name,
+          matchedText: match[0]
+        });
+      }
+    }
+  }
+  return {
+    deterministic: violations.length === 0,
+    violations,
+    scannedLines: lines.length
+  };
+}
+async function verifyPcrReproducibility(buildA, buildB, options) {
+  const pcr0A = buildA.pcr0.toLowerCase();
+  const pcr0B = buildB.pcr0.toLowerCase();
+  const pcr1A = buildA.pcr1.toLowerCase();
+  const pcr1B = buildB.pcr1.toLowerCase();
+  const pcr2A = buildA.pcr2.toLowerCase();
+  const pcr2B = buildB.pcr2.toLowerCase();
+  const hashA = buildA.imageHash.toLowerCase();
+  const hashB = buildB.imageHash.toLowerCase();
+  const pcr0Match = pcr0A === pcr0B;
+  const pcr1Match = pcr1A === pcr1B;
+  const pcr2Match = pcr2A === pcr2B;
+  const imageHashMatch = hashA === hashB;
+  const reproducible = pcr0Match && pcr1Match && pcr2Match && imageHashMatch;
+  const status = reproducible ? "PASS" : "FAIL";
+  const summaryLines = [
+    `PCR reproducibility: ${status}`,
+    `  PCR0: ${pcr0Match ? "match" : "MISMATCH"} (${pcr0A})`,
+    `  PCR1: ${pcr1Match ? "match" : "MISMATCH"} (${pcr1A})`,
+    `  PCR2: ${pcr2Match ? "match" : "MISMATCH"} (${pcr2A})`,
+    `  Image hash: ${imageHashMatch ? "match" : "MISMATCH"} (${hashA})`
+  ];
+  if (!reproducible) {
+    if (!pcr0Match) {
+      summaryLines.push(`  PCR0 buildB: ${pcr0B}`);
+    }
+    if (!pcr1Match) {
+      summaryLines.push(`  PCR1 buildB: ${pcr1B}`);
+    }
+    if (!pcr2Match) {
+      summaryLines.push(`  PCR2 buildB: ${pcr2B}`);
+    }
+    if (!imageHashMatch) {
+      summaryLines.push(`  Image hash buildB: ${hashB}`);
+    }
+  }
+  const result = {
+    reproducible,
+    pcr0Match,
+    pcr1Match,
+    pcr2Match,
+    imageHashMatch,
+    details: {
+      buildA: {
+        pcr0: buildA.pcr0,
+        pcr1: buildA.pcr1,
+        pcr2: buildA.pcr2,
+        imageHash: buildA.imageHash
+      },
+      buildB: {
+        pcr0: buildB.pcr0,
+        pcr1: buildB.pcr1,
+        pcr2: buildB.pcr2,
+        imageHash: buildB.imageHash
+      }
+    },
+    summary: summaryLines.join("\n")
+  };
+  if (!reproducible && options?.throwOnMismatch) {
+    throw new PcrReproducibilityError(buildA, buildB);
+  }
+  return result;
+}
+
+// src/logger.ts
+var LOG_LEVEL_PRIORITY = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+function createLogger(config) {
+  const minLevel = config.level ?? "info";
+  const jsonOutput = config.json ?? true;
+  const baseContext = config.context ?? {};
+  const component = config.component;
+  function shouldLog(level) {
+    return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[minLevel];
+  }
+  function formatEntry(level, msg, fields) {
+    return {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      component,
+      msg,
+      ...baseContext,
+      ...fields
+    };
+  }
+  function emit(level, msg, fields) {
+    if (!shouldLog(level)) return;
+    const entry = formatEntry(level, msg, fields);
+    if (jsonOutput) {
+      const output = JSON.stringify(entry);
+      if (level === "error") {
+        console.error(output);
+      } else if (level === "warn") {
+        console.warn(output);
+      } else {
+        console.log(output);
+      }
+    } else {
+      const contextStr = Object.keys({ ...baseContext, ...fields }).length > 0 ? " " + JSON.stringify({ ...baseContext, ...fields }) : "";
+      const prefix = `[${level.toUpperCase()}] [${component}]`;
+      const output = `${prefix} ${msg}${contextStr}`;
+      if (level === "error") {
+        console.error(output);
+      } else if (level === "warn") {
+        console.warn(output);
+      } else {
+        console.log(output);
+      }
+    }
+  }
+  const logger = {
+    debug: (msg, fields) => emit("debug", msg, fields),
+    info: (msg, fields) => emit("info", msg, fields),
+    warn: (msg, fields) => emit("warn", msg, fields),
+    error: (msg, fields) => emit("error", msg, fields),
+    child: (context) => createLogger({
+      component,
+      level: minLevel,
+      json: jsonOutput,
+      context: { ...baseContext, ...context }
+    })
+  };
+  return logger;
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+export {
+  ArDrivePeerRegistry,
+  AttestationBootstrap,
+  AttestationState,
+  AttestationVerifier,
+  BootstrapError,
+  BootstrapService,
+  CHAIN_PRESETS,
+  GenesisPeerLoader,
+  ILP_PEER_INFO_KIND,
+  IMAGE_GENERATION_KIND,
+  InvalidEventError,
+  JOB_FEEDBACK_KIND,
+  JOB_REQUEST_KIND_BASE,
+  JOB_RESULT_KIND_BASE,
+  KmsIdentityError,
+  MOCK_USDC_ADDRESS,
+  MOCK_USDC_CONFIG,
+  NixBuilder,
+  NostrPeerDiscovery,
+  PcrReproducibilityError,
+  PeerDiscoveryError,
+  SEED_RELAY_LIST_KIND,
+  SERVICE_DISCOVERY_KIND,
+  SeedRelayDiscovery,
+  SocialPeerDiscovery,
+  TEE_ATTESTATION_KIND,
+  TEXT_GENERATION_KIND,
+  TEXT_TO_SPEECH_KIND,
+  TRANSLATION_KIND,
+  ToonDecodeError,
+  ToonEncodeError,
+  ToonError,
+  USDC_DECIMALS,
+  USDC_NAME,
+  USDC_SYMBOL,
+  VERSION,
+  analyzeDockerfileForNonDeterminism,
+  buildAttestationEvent,
+  buildEip712Domain,
+  buildIlpPeerInfoEvent,
+  buildIlpPrepare,
+  buildJobFeedbackEvent,
+  buildJobRequestEvent,
+  buildJobResultEvent,
+  buildSeedRelayListEvent,
+  buildServiceDiscoveryEvent,
+  createAgentRuntimeClient,
+  createDirectChannelClient,
+  createDirectConnectorAdmin,
+  createDirectIlpClient,
+  createDirectRuntimeClient,
+  createDiscoveryTracker,
+  createHttpChannelClient,
+  createHttpConnectorAdmin,
+  createHttpIlpClient,
+  createHttpRuntimeClient,
+  createHttpIlpClient2 as createHttpRuntimeClientV2,
+  createLogger,
+  createToonNode,
+  decodeEventFromToon,
+  deriveFromKmsSeed,
+  encodeEventToToon,
+  encodeEventToToonString,
+  negotiateSettlementChain,
+  parseAttestation,
+  parseIlpPeerInfo,
+  parseJobFeedback,
+  parseJobRequest,
+  parseJobResult,
+  parseSeedRelayList,
+  parseServiceDiscovery,
+  publishSeedRelayEntry,
+  readDockerfileNix,
+  resolveChainConfig,
+  resolveTokenForChain,
+  shallowParseToon,
+  validateChainId,
+  verifyPcrReproducibility
+};
+//# sourceMappingURL=index.js.map