@toon-protocol/client-mcp 0.20.3 → 0.20.4

package/dist/chunk-IYPIOSEF.js

@@ -0,0 +1,3856 @@
+import { createRequire as __cr } from 'module'; const require = __cr(import.meta.url);
+import {
+  Field,
+  aInRange,
+  abignumber,
+  abool,
+  abytes,
+  abytes2,
+  aexists,
+  ahash,
+  anumber,
+  aoutput,
+  asafenumber,
+  asciiToBytes,
+  bitLen,
+  bitMask,
+  bytesToHex,
+  bytesToHex2,
+  bytesToNumberBE,
+  clean,
+  concatBytes2 as concatBytes,
+  createCurveFields,
+  createHasher,
+  createHmacDrbg,
+  createKeygen,
+  getMinHashLength,
+  hexToBytes,
+  hexToBytes2,
+  isBytes,
+  mapHashToField,
+  mulEndoUnsafe,
+  negateCt,
+  normalizeZ,
+  numberToHexUnpadded,
+  pow2,
+  randomBytes,
+  randomBytes2,
+  rotlBH,
+  rotlBL,
+  rotlSH,
+  rotlSL,
+  sha256,
+  split,
+  swap32IfBE,
+  u32,
+  validateObject,
+  wNAF
+} from "./chunk-6GXZ4KRO.js";
+
+// ../../node_modules/.pnpm/@toon-protocol+core@3.1.2_typescript@5.9.3/node_modules/@toon-protocol/core/dist/chunk-5WT7ISKC.js
+import { encode } from "@toon-format/toon";
+import { decode } from "@toon-format/toon";
+import { decode as decode2 } from "@toon-format/toon";
+var ToonError = class extends Error {
+  code;
+  constructor(message, code, cause) {
+    super(message, { cause });
+    this.name = "ToonError";
+    this.code = code;
+  }
+};
+var InvalidEventError = class extends ToonError {
+  constructor(message, cause) {
+    super(message, "INVALID_EVENT", cause);
+    this.name = "InvalidEventError";
+  }
+};
+var PeerDiscoveryError = class extends ToonError {
+  constructor(message, cause) {
+    super(message, "PEER_DISCOVERY_FAILED", cause);
+    this.name = "PeerDiscoveryError";
+  }
+};
+var ToonEncodeError = class extends ToonError {
+  constructor(message, cause) {
+    super(message, "TOON_ENCODE_ERROR", cause);
+    this.name = "ToonEncodeError";
+  }
+};
+function encodeEventToToon(event) {
+  try {
+    const toonString = encode(event);
+    return new TextEncoder().encode(toonString);
+  } catch (error) {
+    throw new ToonEncodeError(
+      `Failed to encode event to TOON: ${error instanceof Error ? error.message : String(error)}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+function isValidHex(value, length) {
+  if (typeof value !== "string") return false;
+  if (value.length !== length) return false;
+  return /^[0-9a-f]+$/i.test(value);
+}
+var ToonDecodeError = class extends ToonError {
+  constructor(message, cause) {
+    super(message, "TOON_DECODE_ERROR", cause);
+    this.name = "ToonDecodeError";
+  }
+};
+function validateNostrEvent(obj) {
+  if (typeof obj !== "object" || obj === null) {
+    throw new ToonDecodeError("Decoded value is not an object");
+  }
+  const event = obj;
+  if (!isValidHex(event["id"], 64)) {
+    throw new ToonDecodeError(
+      "Invalid event id: must be a 64-character hex string"
+    );
+  }
+  if (!isValidHex(event["pubkey"], 64)) {
+    throw new ToonDecodeError(
+      "Invalid event pubkey: must be a 64-character hex string"
+    );
+  }
+  if (typeof event["kind"] !== "number" || !Number.isInteger(event["kind"])) {
+    throw new ToonDecodeError("Invalid event kind: must be an integer");
+  }
+  if (typeof event["content"] !== "string") {
+    throw new ToonDecodeError("Invalid event content: must be a string");
+  }
+  const tags = event["tags"];
+  if (!Array.isArray(tags)) {
+    throw new ToonDecodeError("Invalid event tags: must be an array");
+  }
+  for (let i = 0; i < tags.length; i++) {
+    const tag = tags[i];
+    if (!Array.isArray(tag)) {
+      throw new ToonDecodeError(`Invalid event tags[${i}]: must be an array`);
+    }
+    for (let j = 0; j < tag.length; j++) {
+      if (typeof tag[j] !== "string") {
+        throw new ToonDecodeError(
+          `Invalid event tags[${i}][${j}]: must be a string`
+        );
+      }
+    }
+  }
+  if (typeof event["created_at"] !== "number" || !Number.isInteger(event["created_at"])) {
+    throw new ToonDecodeError("Invalid event created_at: must be an integer");
+  }
+  if (!isValidHex(event["sig"], 128)) {
+    throw new ToonDecodeError(
+      "Invalid event sig: must be a 128-character hex string"
+    );
+  }
+}
+function decodeEventFromToon(data) {
+  try {
+    const toonString = new TextDecoder().decode(data);
+    const decoded = decode(toonString);
+    validateNostrEvent(decoded);
+    return decoded;
+  } catch (error) {
+    if (error instanceof ToonDecodeError) {
+      throw error;
+    }
+    throw new ToonDecodeError(
+      `Failed to decode TOON data: ${error instanceof Error ? error.message : String(error)}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+
+// ../../node_modules/.pnpm/@toon-protocol+core@3.1.2_typescript@5.9.3/node_modules/@toon-protocol/core/dist/index.js
+import { finalizeEvent } from "nostr-tools/pure";
+import { finalizeEvent as finalizeEvent2 } from "nostr-tools/pure";
+import { finalizeEvent as finalizeEvent3 } from "nostr-tools/pure";
+import { finalizeEvent as finalizeEvent4 } from "nostr-tools/pure";
+import { finalizeEvent as finalizeEvent5 } from "nostr-tools/pure";
+import { finalizeEvent as finalizeEvent6 } from "nostr-tools/pure";
+import { finalizeEvent as finalizeEvent7 } from "nostr-tools/pure";
+import { finalizeEvent as finalizeEvent8 } from "nostr-tools/pure";
+import { finalizeEvent as finalizeEvent9 } from "nostr-tools/pure";
+import { finalizeEvent as finalizeEvent10 } from "nostr-tools/pure";
+import { SimplePool } from "nostr-tools/pool";
+import { SimplePool as SimplePool2 } from "nostr-tools/pool";
+import { getPublicKey } from "nostr-tools/pure";
+import WebSocket from "ws";
+import { getPublicKey as getPublicKey2, verifyEvent } from "nostr-tools/pure";
+
+// ../../node_modules/.pnpm/@noble+hashes@2.2.0/node_modules/@noble/hashes/sha3.js
+var _0n = BigInt(0);
+var _1n = BigInt(1);
+var _2n = BigInt(2);
+var _7n = BigInt(7);
+var _256n = BigInt(256);
+var _0x71n = BigInt(113);
+var SHA3_PI = [];
+var SHA3_ROTL = [];
+var _SHA3_IOTA = [];
+for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
+  [x, y] = [y, (2 * x + 3 * y) % 5];
+  SHA3_PI.push(2 * (5 * y + x));
+  SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
+  let t = _0n;
+  for (let j = 0; j < 7; j++) {
+    R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
+    if (R & _2n)
+      t ^= _1n << (_1n << BigInt(j)) - _1n;
+  }
+  _SHA3_IOTA.push(t);
+}
+var IOTAS = split(_SHA3_IOTA, true);
+var SHA3_IOTA_H = IOTAS[0];
+var SHA3_IOTA_L = IOTAS[1];
+var rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
+var rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
+function keccakP(s, rounds = 24) {
+  anumber(rounds, "rounds");
+  if (rounds < 1 || rounds > 24)
+    throw new Error('"rounds" expected integer 1..24');
+  const B = new Uint32Array(5 * 2);
+  for (let round = 24 - rounds; round < 24; round++) {
+    for (let x = 0; x < 10; x++)
+      B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+    for (let x = 0; x < 10; x += 2) {
+      const idx1 = (x + 8) % 10;
+      const idx0 = (x + 2) % 10;
+      const B0 = B[idx0];
+      const B1 = B[idx0 + 1];
+      const Th = rotlH(B0, B1, 1) ^ B[idx1];
+      const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+      for (let y = 0; y < 50; y += 10) {
+        s[x + y] ^= Th;
+        s[x + y + 1] ^= Tl;
+      }
+    }
+    let curH = s[2];
+    let curL = s[3];
+    for (let t = 0; t < 24; t++) {
+      const shift = SHA3_ROTL[t];
+      const Th = rotlH(curH, curL, shift);
+      const Tl = rotlL(curH, curL, shift);
+      const PI = SHA3_PI[t];
+      curH = s[PI];
+      curL = s[PI + 1];
+      s[PI] = Th;
+      s[PI + 1] = Tl;
+    }
+    for (let y = 0; y < 50; y += 10) {
+      const b0 = s[y], b1 = s[y + 1], b2 = s[y + 2], b3 = s[y + 3];
+      s[y] ^= ~s[y + 2] & s[y + 4];
+      s[y + 1] ^= ~s[y + 3] & s[y + 5];
+      s[y + 2] ^= ~s[y + 4] & s[y + 6];
+      s[y + 3] ^= ~s[y + 5] & s[y + 7];
+      s[y + 4] ^= ~s[y + 6] & s[y + 8];
+      s[y + 5] ^= ~s[y + 7] & s[y + 9];
+      s[y + 6] ^= ~s[y + 8] & b0;
+      s[y + 7] ^= ~s[y + 9] & b1;
+      s[y + 8] ^= ~b0 & b2;
+      s[y + 9] ^= ~b1 & b3;
+    }
+    s[0] ^= SHA3_IOTA_H[round];
+    s[1] ^= SHA3_IOTA_L[round];
+  }
+  clean(B);
+}
+var Keccak = class _Keccak {
+  state;
+  pos = 0;
+  posOut = 0;
+  finished = false;
+  state32;
+  destroyed = false;
+  blockLen;
+  suffix;
+  outputLen;
+  canXOF;
+  enableXOF = false;
+  rounds;
+  // NOTE: we accept arguments in bytes instead of bits here.
+  constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+    this.blockLen = blockLen;
+    this.suffix = suffix;
+    this.outputLen = outputLen;
+    this.enableXOF = enableXOF;
+    this.canXOF = enableXOF;
+    this.rounds = rounds;
+    anumber(outputLen, "outputLen");
+    if (!(0 < blockLen && blockLen < 200))
+      throw new Error("only keccak-f1600 function is supported");
+    this.state = new Uint8Array(200);
+    this.state32 = u32(this.state);
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  keccak() {
+    swap32IfBE(this.state32);
+    keccakP(this.state32, this.rounds);
+    swap32IfBE(this.state32);
+    this.posOut = 0;
+    this.pos = 0;
+  }
+  update(data) {
+    aexists(this);
+    abytes(data);
+    const { blockLen, state } = this;
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      for (let i = 0; i < take; i++)
+        state[this.pos++] ^= data[pos++];
+      if (this.pos === blockLen)
+        this.keccak();
+    }
+    return this;
+  }
+  finish() {
+    if (this.finished)
+      return;
+    this.finished = true;
+    const { state, suffix, pos, blockLen } = this;
+    state[pos] ^= suffix;
+    if ((suffix & 128) !== 0 && pos === blockLen - 1)
+      this.keccak();
+    state[blockLen - 1] ^= 128;
+    this.keccak();
+  }
+  writeInto(out) {
+    aexists(this, false);
+    abytes(out);
+    this.finish();
+    const bufferOut = this.state;
+    const { blockLen } = this;
+    for (let pos = 0, len = out.length; pos < len; ) {
+      if (this.posOut >= blockLen)
+        this.keccak();
+      const take = Math.min(blockLen - this.posOut, len - pos);
+      out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+      this.posOut += take;
+      pos += take;
+    }
+    return out;
+  }
+  xofInto(out) {
+    if (!this.enableXOF)
+      throw new Error("XOF is not possible for this instance");
+    return this.writeInto(out);
+  }
+  xof(bytes) {
+    anumber(bytes);
+    return this.xofInto(new Uint8Array(bytes));
+  }
+  digestInto(out) {
+    aoutput(out, this);
+    if (this.finished)
+      throw new Error("digest() was already called");
+    this.writeInto(out.subarray(0, this.outputLen));
+    this.destroy();
+  }
+  digest() {
+    const out = new Uint8Array(this.outputLen);
+    this.digestInto(out);
+    return out;
+  }
+  destroy() {
+    this.destroyed = true;
+    clean(this.state);
+  }
+  _cloneInto(to) {
+    const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+    to ||= new _Keccak(blockLen, suffix, outputLen, enableXOF, rounds);
+    to.blockLen = blockLen;
+    to.state32.set(this.state32);
+    to.pos = this.pos;
+    to.posOut = this.posOut;
+    to.finished = this.finished;
+    to.rounds = rounds;
+    to.suffix = suffix;
+    to.outputLen = outputLen;
+    to.enableXOF = enableXOF;
+    to.canXOF = this.canXOF;
+    to.destroyed = this.destroyed;
+    return to;
+  }
+};
+var genKeccak = (suffix, blockLen, outputLen, info = {}) => createHasher(() => new Keccak(blockLen, suffix, outputLen), info);
+var keccak_256 = /* @__PURE__ */ genKeccak(1, 136, 32);
+
+// ../../node_modules/.pnpm/@noble+hashes@2.2.0/node_modules/@noble/hashes/hmac.js
+var _HMAC = class {
+  oHash;
+  iHash;
+  blockLen;
+  outputLen;
+  canXOF = false;
+  finished = false;
+  destroyed = false;
+  constructor(hash, key) {
+    ahash(hash);
+    abytes(key, void 0, "key");
+    this.iHash = hash.create();
+    if (typeof this.iHash.update !== "function")
+      throw new Error("Expected instance of class which extends utils.Hash");
+    this.blockLen = this.iHash.blockLen;
+    this.outputLen = this.iHash.outputLen;
+    const blockLen = this.blockLen;
+    const pad = new Uint8Array(blockLen);
+    pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);
+    for (let i = 0; i < pad.length; i++)
+      pad[i] ^= 54;
+    this.iHash.update(pad);
+    this.oHash = hash.create();
+    for (let i = 0; i < pad.length; i++)
+      pad[i] ^= 54 ^ 92;
+    this.oHash.update(pad);
+    clean(pad);
+  }
+  update(buf) {
+    aexists(this);
+    this.iHash.update(buf);
+    return this;
+  }
+  digestInto(out) {
+    aexists(this);
+    aoutput(out, this);
+    this.finished = true;
+    const buf = out.subarray(0, this.outputLen);
+    this.iHash.digestInto(buf);
+    this.oHash.update(buf);
+    this.oHash.digestInto(buf);
+    this.destroy();
+  }
+  digest() {
+    const out = new Uint8Array(this.oHash.outputLen);
+    this.digestInto(out);
+    return out;
+  }
+  _cloneInto(to) {
+    to ||= Object.create(Object.getPrototypeOf(this), {});
+    const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
+    to = to;
+    to.finished = finished;
+    to.destroyed = destroyed;
+    to.blockLen = blockLen;
+    to.outputLen = outputLen;
+    to.oHash = oHash._cloneInto(to.oHash);
+    to.iHash = iHash._cloneInto(to.iHash);
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  destroy() {
+    this.destroyed = true;
+    this.oHash.destroy();
+    this.iHash.destroy();
+  }
+};
+var hmac = /* @__PURE__ */ (() => {
+  const hmac_ = ((hash, key, message) => new _HMAC(hash, key).update(message).digest());
+  hmac_.create = (hash, key) => new _HMAC(hash, key);
+  return hmac_;
+})();
+
+// ../../node_modules/.pnpm/@noble+curves@2.2.0/node_modules/@noble/curves/abstract/weierstrass.js
+var divNearest = (num2, den) => (num2 + (num2 >= 0 ? den : -den) / _2n2) / den;
+function _splitEndoScalar(k, basis, n) {
+  aInRange("scalar", k, _0n2, n);
+  const [[a1, b1], [a2, b2]] = basis;
+  const c1 = divNearest(b2 * k, n);
+  const c2 = divNearest(-b1 * k, n);
+  let k1 = k - c1 * a1 - c2 * a2;
+  let k2 = -c1 * b1 - c2 * b2;
+  const k1neg = k1 < _0n2;
+  const k2neg = k2 < _0n2;
+  if (k1neg)
+    k1 = -k1;
+  if (k2neg)
+    k2 = -k2;
+  const MAX_NUM = bitMask(Math.ceil(bitLen(n) / 2)) + _1n2;
+  if (k1 < _0n2 || k1 >= MAX_NUM || k2 < _0n2 || k2 >= MAX_NUM) {
+    throw new Error("splitScalar (endomorphism): failed for k");
+  }
+  return { k1neg, k1, k2neg, k2 };
+}
+function validateSigFormat(format) {
+  if (!["compact", "recovered", "der"].includes(format))
+    throw new Error('Signature format must be "compact", "recovered", or "der"');
+  return format;
+}
+function validateSigOpts(opts, def) {
+  validateObject(opts);
+  const optsn = {};
+  for (let optName of Object.keys(def)) {
+    optsn[optName] = opts[optName] === void 0 ? def[optName] : opts[optName];
+  }
+  abool(optsn.lowS, "lowS");
+  abool(optsn.prehash, "prehash");
+  if (optsn.format !== void 0)
+    validateSigFormat(optsn.format);
+  return optsn;
+}
+var DERErr = class extends Error {
+  constructor(m = "") {
+    super(m);
+  }
+};
+var DER = {
+  // asn.1 DER encoding utils
+  Err: DERErr,
+  // Basic building block is TLV (Tag-Length-Value)
+  _tlv: {
+    encode: (tag, data) => {
+      const { Err: E } = DER;
+      asafenumber(tag, "tag");
+      if (tag < 0 || tag > 255)
+        throw new E("tlv.encode: wrong tag");
+      if (typeof data !== "string")
+        throw new TypeError('"data" expected string, got type=' + typeof data);
+      if (data.length & 1)
+        throw new E("tlv.encode: unpadded data");
+      const dataLen = data.length / 2;
+      const len = numberToHexUnpadded(dataLen);
+      if (len.length / 2 & 128)
+        throw new E("tlv.encode: long form length too big");
+      const lenLen = dataLen > 127 ? numberToHexUnpadded(len.length / 2 | 128) : "";
+      const t = numberToHexUnpadded(tag);
+      return t + lenLen + len + data;
+    },
+    // v - value, l - left bytes (unparsed)
+    decode(tag, data) {
+      const { Err: E } = DER;
+      data = abytes2(data, void 0, "DER data");
+      let pos = 0;
+      if (tag < 0 || tag > 255)
+        throw new E("tlv.encode: wrong tag");
+      if (data.length < 2 || data[pos++] !== tag)
+        throw new E("tlv.decode: wrong tlv");
+      const first = data[pos++];
+      const isLong = !!(first & 128);
+      let length = 0;
+      if (!isLong)
+        length = first;
+      else {
+        const lenLen = first & 127;
+        if (!lenLen)
+          throw new E("tlv.decode(long): indefinite length not supported");
+        if (lenLen > 4)
+          throw new E("tlv.decode(long): byte length is too big");
+        const lengthBytes = data.subarray(pos, pos + lenLen);
+        if (lengthBytes.length !== lenLen)
+          throw new E("tlv.decode: length bytes not complete");
+        if (lengthBytes[0] === 0)
+          throw new E("tlv.decode(long): zero leftmost byte");
+        for (const b of lengthBytes)
+          length = length << 8 | b;
+        pos += lenLen;
+        if (length < 128)
+          throw new E("tlv.decode(long): not minimal encoding");
+      }
+      const v = data.subarray(pos, pos + length);
+      if (v.length !== length)
+        throw new E("tlv.decode: wrong value length");
+      return { v, l: data.subarray(pos + length) };
+    }
+  },
+  // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
+  // since we always use positive integers here. It must always be empty:
+  // - add zero byte if exists
+  // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
+  _int: {
+    encode(num2) {
+      const { Err: E } = DER;
+      abignumber(num2);
+      if (num2 < _0n2)
+        throw new E("integer: negative integers are not allowed");
+      let hex = numberToHexUnpadded(num2);
+      if (Number.parseInt(hex[0], 16) & 8)
+        hex = "00" + hex;
+      if (hex.length & 1)
+        throw new E("unexpected DER parsing assertion: unpadded hex");
+      return hex;
+    },
+    decode(data) {
+      const { Err: E } = DER;
+      if (data.length < 1)
+        throw new E("invalid signature integer: empty");
+      if (data[0] & 128)
+        throw new E("invalid signature integer: negative");
+      if (data.length > 1 && data[0] === 0 && !(data[1] & 128))
+        throw new E("invalid signature integer: unnecessary leading zero");
+      return bytesToNumberBE(data);
+    }
+  },
+  toSig(bytes) {
+    const { Err: E, _int: int, _tlv: tlv } = DER;
+    const data = abytes2(bytes, void 0, "signature");
+    const { v: seqBytes, l: seqLeftBytes } = tlv.decode(48, data);
+    if (seqLeftBytes.length)
+      throw new E("invalid signature: left bytes after parsing");
+    const { v: rBytes, l: rLeftBytes } = tlv.decode(2, seqBytes);
+    const { v: sBytes, l: sLeftBytes } = tlv.decode(2, rLeftBytes);
+    if (sLeftBytes.length)
+      throw new E("invalid signature: left bytes after parsing");
+    return { r: int.decode(rBytes), s: int.decode(sBytes) };
+  },
+  hexFromSig(sig) {
+    const { _tlv: tlv, _int: int } = DER;
+    const rs = tlv.encode(2, int.encode(sig.r));
+    const ss = tlv.encode(2, int.encode(sig.s));
+    const seq = rs + ss;
+    return tlv.encode(48, seq);
+  }
+};
+Object.freeze(DER._tlv);
+Object.freeze(DER._int);
+Object.freeze(DER);
+var _0n2 = /* @__PURE__ */ BigInt(0);
+var _1n2 = /* @__PURE__ */ BigInt(1);
+var _2n2 = /* @__PURE__ */ BigInt(2);
+var _3n = /* @__PURE__ */ BigInt(3);
+var _4n = /* @__PURE__ */ BigInt(4);
+function weierstrass(params, extraOpts = {}) {
+  const validated = createCurveFields("weierstrass", params, extraOpts);
+  const Fp = validated.Fp;
+  const Fn = validated.Fn;
+  let CURVE = validated.CURVE;
+  const { h: cofactor, n: CURVE_ORDER } = CURVE;
+  validateObject(extraOpts, {}, {
+    allowInfinityPoint: "boolean",
+    clearCofactor: "function",
+    isTorsionFree: "function",
+    fromBytes: "function",
+    toBytes: "function",
+    endo: "object"
+  });
+  const { endo, allowInfinityPoint } = extraOpts;
+  if (endo) {
+    if (!Fp.is0(CURVE.a) || typeof endo.beta !== "bigint" || !Array.isArray(endo.basises)) {
+      throw new Error('invalid endo: expected "beta": bigint and "basises": array');
+    }
+  }
+  const lengths = getWLengths(Fp, Fn);
+  function assertCompressionIsSupported() {
+    if (!Fp.isOdd)
+      throw new Error("compression is not supported: Field does not have .isOdd()");
+  }
+  function pointToBytes2(_c, point, isCompressed) {
+    if (allowInfinityPoint && point.is0())
+      return Uint8Array.of(0);
+    const { x, y } = point.toAffine();
+    const bx = Fp.toBytes(x);
+    abool(isCompressed, "isCompressed");
+    if (isCompressed) {
+      assertCompressionIsSupported();
+      const hasEvenY = !Fp.isOdd(y);
+      return concatBytes(pprefix(hasEvenY), bx);
+    } else {
+      return concatBytes(Uint8Array.of(4), bx, Fp.toBytes(y));
+    }
+  }
+  function pointFromBytes(bytes) {
+    abytes2(bytes, void 0, "Point");
+    const { publicKey: comp, publicKeyUncompressed: uncomp } = lengths;
+    const length = bytes.length;
+    const head = bytes[0];
+    const tail = bytes.subarray(1);
+    if (allowInfinityPoint && length === 1 && head === 0)
+      return { x: Fp.ZERO, y: Fp.ZERO };
+    if (length === comp && (head === 2 || head === 3)) {
+      const x = Fp.fromBytes(tail);
+      if (!Fp.isValid(x))
+        throw new Error("bad point: is not on curve, wrong x");
+      const y2 = weierstrassEquation(x);
+      let y;
+      try {
+        y = Fp.sqrt(y2);
+      } catch (sqrtError) {
+        const err = sqrtError instanceof Error ? ": " + sqrtError.message : "";
+        throw new Error("bad point: is not on curve, sqrt error" + err);
+      }
+      assertCompressionIsSupported();
+      const evenY = Fp.isOdd(y);
+      const evenH = (head & 1) === 1;
+      if (evenH !== evenY)
+        y = Fp.neg(y);
+      return { x, y };
+    } else if (length === uncomp && head === 4) {
+      const L = Fp.BYTES;
+      const x = Fp.fromBytes(tail.subarray(0, L));
+      const y = Fp.fromBytes(tail.subarray(L, L * 2));
+      if (!isValidXY(x, y))
+        throw new Error("bad point: is not on curve");
+      return { x, y };
+    } else {
+      throw new Error(`bad point: got length ${length}, expected compressed=${comp} or uncompressed=${uncomp}`);
+    }
+  }
+  const encodePoint = extraOpts.toBytes === void 0 ? pointToBytes2 : extraOpts.toBytes;
+  const decodePoint = extraOpts.fromBytes === void 0 ? pointFromBytes : extraOpts.fromBytes;
+  function weierstrassEquation(x) {
+    const x2 = Fp.sqr(x);
+    const x3 = Fp.mul(x2, x);
+    return Fp.add(Fp.add(x3, Fp.mul(x, CURVE.a)), CURVE.b);
+  }
+  function isValidXY(x, y) {
+    const left = Fp.sqr(y);
+    const right = weierstrassEquation(x);
+    return Fp.eql(left, right);
+  }
+  if (!isValidXY(CURVE.Gx, CURVE.Gy))
+    throw new Error("bad curve params: generator point");
+  const _4a3 = Fp.mul(Fp.pow(CURVE.a, _3n), _4n);
+  const _27b2 = Fp.mul(Fp.sqr(CURVE.b), BigInt(27));
+  if (Fp.is0(Fp.add(_4a3, _27b2)))
+    throw new Error("bad curve params: a or b");
+  function acoord(title, n, banZero = false) {
+    if (!Fp.isValid(n) || banZero && Fp.is0(n))
+      throw new Error(`bad point coordinate ${title}`);
+    return n;
+  }
+  function aprjpoint(other) {
+    if (!(other instanceof Point))
+      throw new Error("Weierstrass Point expected");
+  }
+  function splitEndoScalarN(k) {
+    if (!endo || !endo.basises)
+      throw new Error("no endo");
+    return _splitEndoScalar(k, endo.basises, Fn.ORDER);
+  }
+  function finishEndo(endoBeta, k1p, k2p, k1neg, k2neg) {
+    k2p = new Point(Fp.mul(k2p.X, endoBeta), k2p.Y, k2p.Z);
+    k1p = negateCt(k1neg, k1p);
+    k2p = negateCt(k2neg, k2p);
+    return k1p.add(k2p);
+  }
+  class Point {
+    // base / generator point
+    static BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE);
+    // zero / infinity / identity point
+    static ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO);
+    // 0, 1, 0
+    // math field
+    static Fp = Fp;
+    // scalar field
+    static Fn = Fn;
+    X;
+    Y;
+    Z;
+    /** Does NOT validate if the point is valid. Use `.assertValidity()`. */
+    constructor(X, Y, Z) {
+      this.X = acoord("x", X);
+      this.Y = acoord("y", Y, true);
+      this.Z = acoord("z", Z);
+      Object.freeze(this);
+    }
+    static CURVE() {
+      return CURVE;
+    }
+    /** Does NOT validate if the point is valid. Use `.assertValidity()`. */
+    static fromAffine(p) {
+      const { x, y } = p || {};
+      if (!p || !Fp.isValid(x) || !Fp.isValid(y))
+        throw new Error("invalid affine point");
+      if (p instanceof Point)
+        throw new Error("projective point not allowed");
+      if (Fp.is0(x) && Fp.is0(y))
+        return Point.ZERO;
+      return new Point(x, y, Fp.ONE);
+    }
+    static fromBytes(bytes) {
+      const P = Point.fromAffine(decodePoint(abytes2(bytes, void 0, "point")));
+      P.assertValidity();
+      return P;
+    }
+    static fromHex(hex) {
+      return Point.fromBytes(hexToBytes2(hex));
+    }
+    get x() {
+      return this.toAffine().x;
+    }
+    get y() {
+      return this.toAffine().y;
+    }
+    /**
+     *
+     * @param windowSize
+     * @param isLazy - true will defer table computation until the first multiplication
+     * @returns
+     */
+    precompute(windowSize = 8, isLazy = true) {
+      wnaf.createCache(this, windowSize);
+      if (!isLazy)
+        this.multiply(_3n);
+      return this;
+    }
+    // TODO: return `this`
+    /** A point on curve is valid if it conforms to equation. */
+    assertValidity() {
+      const p = this;
+      if (p.is0()) {
+        if (extraOpts.allowInfinityPoint && Fp.is0(p.X) && Fp.eql(p.Y, Fp.ONE) && Fp.is0(p.Z))
+          return;
+        throw new Error("bad point: ZERO");
+      }
+      const { x, y } = p.toAffine();
+      if (!Fp.isValid(x) || !Fp.isValid(y))
+        throw new Error("bad point: x or y not field elements");
+      if (!isValidXY(x, y))
+        throw new Error("bad point: equation left != right");
+      if (!p.isTorsionFree())
+        throw new Error("bad point: not in prime-order subgroup");
+    }
+    hasEvenY() {
+      const { y } = this.toAffine();
+      if (!Fp.isOdd)
+        throw new Error("Field doesn't support isOdd");
+      return !Fp.isOdd(y);
+    }
+    /** Compare one point to another. */
+    equals(other) {
+      aprjpoint(other);
+      const { X: X1, Y: Y1, Z: Z1 } = this;
+      const { X: X2, Y: Y2, Z: Z2 } = other;
+      const U1 = Fp.eql(Fp.mul(X1, Z2), Fp.mul(X2, Z1));
+      const U2 = Fp.eql(Fp.mul(Y1, Z2), Fp.mul(Y2, Z1));
+      return U1 && U2;
+    }
+    /** Flips point to one corresponding to (x, -y) in Affine coordinates. */
+    negate() {
+      return new Point(this.X, Fp.neg(this.Y), this.Z);
+    }
+    // Renes-Costello-Batina exception-free doubling formula.
+    // There is 30% faster Jacobian formula, but it is not complete.
+    // https://eprint.iacr.org/2015/1060, algorithm 3
+    // Cost: 8M + 3S + 3*a + 2*b3 + 15add.
+    double() {
+      const { a, b } = CURVE;
+      const b3 = Fp.mul(b, _3n);
+      const { X: X1, Y: Y1, Z: Z1 } = this;
+      let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO;
+      let t0 = Fp.mul(X1, X1);
+      let t1 = Fp.mul(Y1, Y1);
+      let t2 = Fp.mul(Z1, Z1);
+      let t3 = Fp.mul(X1, Y1);
+      t3 = Fp.add(t3, t3);
+      Z3 = Fp.mul(X1, Z1);
+      Z3 = Fp.add(Z3, Z3);
+      X3 = Fp.mul(a, Z3);
+      Y3 = Fp.mul(b3, t2);
+      Y3 = Fp.add(X3, Y3);
+      X3 = Fp.sub(t1, Y3);
+      Y3 = Fp.add(t1, Y3);
+      Y3 = Fp.mul(X3, Y3);
+      X3 = Fp.mul(t3, X3);
+      Z3 = Fp.mul(b3, Z3);
+      t2 = Fp.mul(a, t2);
+      t3 = Fp.sub(t0, t2);
+      t3 = Fp.mul(a, t3);
+      t3 = Fp.add(t3, Z3);
+      Z3 = Fp.add(t0, t0);
+      t0 = Fp.add(Z3, t0);
+      t0 = Fp.add(t0, t2);
+      t0 = Fp.mul(t0, t3);
+      Y3 = Fp.add(Y3, t0);
+      t2 = Fp.mul(Y1, Z1);
+      t2 = Fp.add(t2, t2);
+      t0 = Fp.mul(t2, t3);
+      X3 = Fp.sub(X3, t0);
+      Z3 = Fp.mul(t2, t1);
+      Z3 = Fp.add(Z3, Z3);
+      Z3 = Fp.add(Z3, Z3);
+      return new Point(X3, Y3, Z3);
+    }
+    // Renes-Costello-Batina exception-free addition formula.
+    // There is 30% faster Jacobian formula, but it is not complete.
+    // https://eprint.iacr.org/2015/1060, algorithm 1
+    // Cost: 12M + 0S + 3*a + 3*b3 + 23add.
+    add(other) {
+      aprjpoint(other);
+      const { X: X1, Y: Y1, Z: Z1 } = this;
+      const { X: X2, Y: Y2, Z: Z2 } = other;
+      let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO;
+      const a = CURVE.a;
+      const b3 = Fp.mul(CURVE.b, _3n);
+      let t0 = Fp.mul(X1, X2);
+      let t1 = Fp.mul(Y1, Y2);
+      let t2 = Fp.mul(Z1, Z2);
+      let t3 = Fp.add(X1, Y1);
+      let t4 = Fp.add(X2, Y2);
+      t3 = Fp.mul(t3, t4);
+      t4 = Fp.add(t0, t1);
+      t3 = Fp.sub(t3, t4);
+      t4 = Fp.add(X1, Z1);
+      let t5 = Fp.add(X2, Z2);
+      t4 = Fp.mul(t4, t5);
+      t5 = Fp.add(t0, t2);
+      t4 = Fp.sub(t4, t5);
+      t5 = Fp.add(Y1, Z1);
+      X3 = Fp.add(Y2, Z2);
+      t5 = Fp.mul(t5, X3);
+      X3 = Fp.add(t1, t2);
+      t5 = Fp.sub(t5, X3);
+      Z3 = Fp.mul(a, t4);
+      X3 = Fp.mul(b3, t2);
+      Z3 = Fp.add(X3, Z3);
+      X3 = Fp.sub(t1, Z3);
+      Z3 = Fp.add(t1, Z3);
+      Y3 = Fp.mul(X3, Z3);
+      t1 = Fp.add(t0, t0);
+      t1 = Fp.add(t1, t0);
+      t2 = Fp.mul(a, t2);
+      t4 = Fp.mul(b3, t4);
+      t1 = Fp.add(t1, t2);
+      t2 = Fp.sub(t0, t2);
+      t2 = Fp.mul(a, t2);
+      t4 = Fp.add(t4, t2);
+      t0 = Fp.mul(t1, t4);
+      Y3 = Fp.add(Y3, t0);
+      t0 = Fp.mul(t5, t4);
+      X3 = Fp.mul(t3, X3);
+      X3 = Fp.sub(X3, t0);
+      t0 = Fp.mul(t3, t1);
+      Z3 = Fp.mul(t5, Z3);
+      Z3 = Fp.add(Z3, t0);
+      return new Point(X3, Y3, Z3);
+    }
+    subtract(other) {
+      aprjpoint(other);
+      return this.add(other.negate());
+    }
+    is0() {
+      return this.equals(Point.ZERO);
+    }
+    /**
+     * Constant time multiplication.
+     * Uses wNAF method. Windowed method may be 10% faster,
+     * but takes 2x longer to generate and consumes 2x memory.
+     * Uses precomputes when available.
+     * Uses endomorphism for Koblitz curves.
+     * @param scalar - by which the point would be multiplied
+     * @returns New point
+     */
+    multiply(scalar) {
+      const { endo: endo2 } = extraOpts;
+      if (!Fn.isValidNot0(scalar))
+        throw new RangeError("invalid scalar: out of range");
+      let point, fake;
+      const mul = (n) => wnaf.cached(this, n, (p) => normalizeZ(Point, p));
+      if (endo2) {
+        const { k1neg, k1, k2neg, k2 } = splitEndoScalarN(scalar);
+        const { p: k1p, f: k1f } = mul(k1);
+        const { p: k2p, f: k2f } = mul(k2);
+        fake = k1f.add(k2f);
+        point = finishEndo(endo2.beta, k1p, k2p, k1neg, k2neg);
+      } else {
+        const { p, f } = mul(scalar);
+        point = p;
+        fake = f;
+      }
+      return normalizeZ(Point, [point, fake])[0];
+    }
+    /**
+     * Non-constant-time multiplication. Uses double-and-add algorithm.
+     * It's faster, but should only be used when you don't care about
+     * an exposed secret key e.g. sig verification, which works over *public* keys.
+     */
+    multiplyUnsafe(scalar) {
+      const { endo: endo2 } = extraOpts;
+      const p = this;
+      const sc = scalar;
+      if (!Fn.isValid(sc))
+        throw new RangeError("invalid scalar: out of range");
+      if (sc === _0n2 || p.is0())
+        return Point.ZERO;
+      if (sc === _1n2)
+        return p;
+      if (wnaf.hasCache(this))
+        return this.multiply(sc);
+      if (endo2) {
+        const { k1neg, k1, k2neg, k2 } = splitEndoScalarN(sc);
+        const { p1, p2 } = mulEndoUnsafe(Point, p, k1, k2);
+        return finishEndo(endo2.beta, p1, p2, k1neg, k2neg);
+      } else {
+        return wnaf.unsafe(p, sc);
+      }
+    }
+    /**
+     * Converts Projective point to affine (x, y) coordinates.
+     * (X, Y, Z) ∋ (x=X/Z, y=Y/Z).
+     * @param invertedZ - Z^-1 (inverted zero) - optional, precomputation is useful for invertBatch
+     */
+    toAffine(invertedZ) {
+      const p = this;
+      let iz = invertedZ;
+      const { X, Y, Z } = p;
+      if (Fp.eql(Z, Fp.ONE))
+        return { x: X, y: Y };
+      const is0 = p.is0();
+      if (iz == null)
+        iz = is0 ? Fp.ONE : Fp.inv(Z);
+      const x = Fp.mul(X, iz);
+      const y = Fp.mul(Y, iz);
+      const zz = Fp.mul(Z, iz);
+      if (is0)
+        return { x: Fp.ZERO, y: Fp.ZERO };
+      if (!Fp.eql(zz, Fp.ONE))
+        throw new Error("invZ was invalid");
+      return { x, y };
+    }
+    /**
+     * Checks whether Point is free of torsion elements (is in prime subgroup).
+     * Always torsion-free for cofactor=1 curves.
+     */
+    isTorsionFree() {
+      const { isTorsionFree } = extraOpts;
+      if (cofactor === _1n2)
+        return true;
+      if (isTorsionFree)
+        return isTorsionFree(Point, this);
+      return wnaf.unsafe(this, CURVE_ORDER).is0();
+    }
+    clearCofactor() {
+      const { clearCofactor } = extraOpts;
+      if (cofactor === _1n2)
+        return this;
+      if (clearCofactor)
+        return clearCofactor(Point, this);
+      return this.multiplyUnsafe(cofactor);
+    }
+    isSmallOrder() {
+      if (cofactor === _1n2)
+        return this.is0();
+      return this.clearCofactor().is0();
+    }
+    toBytes(isCompressed = true) {
+      abool(isCompressed, "isCompressed");
+      this.assertValidity();
+      return encodePoint(Point, this, isCompressed);
+    }
+    toHex(isCompressed = true) {
+      return bytesToHex2(this.toBytes(isCompressed));
+    }
+    toString() {
+      return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
+    }
+  }
+  const bits = Fn.BITS;
+  const wnaf = new wNAF(Point, extraOpts.endo ? Math.ceil(bits / 2) : bits);
+  if (bits >= 8)
+    Point.BASE.precompute(8);
+  Object.freeze(Point.prototype);
+  Object.freeze(Point);
+  return Point;
+}
+function pprefix(hasEvenY) {
+  return Uint8Array.of(hasEvenY ? 2 : 3);
+}
+function getWLengths(Fp, Fn) {
+  return {
+    secretKey: Fn.BYTES,
+    publicKey: 1 + Fp.BYTES,
+    publicKeyUncompressed: 1 + 2 * Fp.BYTES,
+    publicKeyHasPrefix: true,
+    // Raw compact `(r || s)` signature width; DER and recovered signatures use
+    // different lengths outside this helper.
+    signature: 2 * Fn.BYTES
+  };
+}
+function ecdh(Point, ecdhOpts = {}) {
+  const { Fn } = Point;
+  const randomBytes_ = ecdhOpts.randomBytes === void 0 ? randomBytes2 : ecdhOpts.randomBytes;
+  const lengths = Object.assign(getWLengths(Point.Fp, Fn), {
+    seed: Math.max(getMinHashLength(Fn.ORDER), 16)
+  });
+  function isValidSecretKey(secretKey) {
+    try {
+      const num2 = Fn.fromBytes(secretKey);
+      return Fn.isValidNot0(num2);
+    } catch (error) {
+      return false;
+    }
+  }
+  function isValidPublicKey(publicKey, isCompressed) {
+    const { publicKey: comp, publicKeyUncompressed } = lengths;
+    try {
+      const l = publicKey.length;
+      if (isCompressed === true && l !== comp)
+        return false;
+      if (isCompressed === false && l !== publicKeyUncompressed)
+        return false;
+      return !!Point.fromBytes(publicKey);
+    } catch (error) {
+      return false;
+    }
+  }
+  function randomSecretKey(seed) {
+    seed = seed === void 0 ? randomBytes_(lengths.seed) : seed;
+    return mapHashToField(abytes2(seed, lengths.seed, "seed"), Fn.ORDER);
+  }
+  function getPublicKey6(secretKey, isCompressed = true) {
+    return Point.BASE.multiply(Fn.fromBytes(secretKey)).toBytes(isCompressed);
+  }
+  function isProbPub(item) {
+    const { secretKey, publicKey, publicKeyUncompressed } = lengths;
+    const allowedLengths = Fn._lengths;
+    if (!isBytes(item))
+      return void 0;
+    const l = abytes2(item, void 0, "key").length;
+    const isPub = l === publicKey || l === publicKeyUncompressed;
+    const isSec = l === secretKey || !!allowedLengths?.includes(l);
+    if (isPub && isSec)
+      return void 0;
+    return isPub;
+  }
+  function getSharedSecret(secretKeyA, publicKeyB, isCompressed = true) {
+    if (isProbPub(secretKeyA) === true)
+      throw new Error("first arg must be private key");
+    if (isProbPub(publicKeyB) === false)
+      throw new Error("second arg must be public key");
+    const s = Fn.fromBytes(secretKeyA);
+    const b = Point.fromBytes(publicKeyB);
+    return b.multiply(s).toBytes(isCompressed);
+  }
+  const utils = {
+    isValidSecretKey,
+    isValidPublicKey,
+    randomSecretKey
+  };
+  const keygen = createKeygen(randomSecretKey, getPublicKey6);
+  Object.freeze(utils);
+  Object.freeze(lengths);
+  return Object.freeze({ getPublicKey: getPublicKey6, getSharedSecret, keygen, Point, utils, lengths });
+}
+function ecdsa(Point, hash, ecdsaOpts = {}) {
+  const hash_ = hash;
+  ahash(hash_);
+  validateObject(ecdsaOpts, {}, {
+    hmac: "function",
+    lowS: "boolean",
+    randomBytes: "function",
+    bits2int: "function",
+    bits2int_modN: "function"
+  });
+  ecdsaOpts = Object.assign({}, ecdsaOpts);
+  const randomBytes3 = ecdsaOpts.randomBytes === void 0 ? randomBytes2 : ecdsaOpts.randomBytes;
+  const hmac2 = ecdsaOpts.hmac === void 0 ? (key, msg) => hmac(hash_, key, msg) : ecdsaOpts.hmac;
+  const { Fp, Fn } = Point;
+  const { ORDER: CURVE_ORDER, BITS: fnBits } = Fn;
+  const { keygen, getPublicKey: getPublicKey6, getSharedSecret, utils, lengths } = ecdh(Point, ecdsaOpts);
+  const defaultSigOpts = {
+    prehash: true,
+    lowS: typeof ecdsaOpts.lowS === "boolean" ? ecdsaOpts.lowS : true,
+    format: "compact",
+    extraEntropy: false
+  };
+  const hasLargeRecoveryLifts = CURVE_ORDER * _2n2 + _1n2 < Fp.ORDER;
+  function isBiggerThanHalfOrder(number) {
+    const HALF = CURVE_ORDER >> _1n2;
+    return number > HALF;
+  }
+  function validateRS(title, num2) {
+    if (!Fn.isValidNot0(num2))
+      throw new Error(`invalid signature ${title}: out of range 1..Point.Fn.ORDER`);
+    return num2;
+  }
+  function assertRecoverableCurve() {
+    if (hasLargeRecoveryLifts)
+      throw new Error('"recovered" sig type is not supported for cofactor >2 curves');
+  }
+  function validateSigLength(bytes, format) {
+    validateSigFormat(format);
+    const size = lengths.signature;
+    const sizer = format === "compact" ? size : format === "recovered" ? size + 1 : void 0;
+    return abytes2(bytes, sizer);
+  }
+  class Signature {
+    r;
+    s;
+    recovery;
+    constructor(r, s, recovery) {
+      this.r = validateRS("r", r);
+      this.s = validateRS("s", s);
+      if (recovery != null) {
+        assertRecoverableCurve();
+        if (![0, 1, 2, 3].includes(recovery))
+          throw new Error("invalid recovery id");
+        this.recovery = recovery;
+      }
+      Object.freeze(this);
+    }
+    static fromBytes(bytes, format = defaultSigOpts.format) {
+      validateSigLength(bytes, format);
+      let recid;
+      if (format === "der") {
+        const { r: r2, s: s2 } = DER.toSig(abytes2(bytes));
+        return new Signature(r2, s2);
+      }
+      if (format === "recovered") {
+        recid = bytes[0];
+        format = "compact";
+        bytes = bytes.subarray(1);
+      }
+      const L = lengths.signature / 2;
+      const r = bytes.subarray(0, L);
+      const s = bytes.subarray(L, L * 2);
+      return new Signature(Fn.fromBytes(r), Fn.fromBytes(s), recid);
+    }
+    static fromHex(hex, format) {
+      return this.fromBytes(hexToBytes2(hex), format);
+    }
+    assertRecovery() {
+      const { recovery } = this;
+      if (recovery == null)
+        throw new Error("invalid recovery id: must be present");
+      return recovery;
+    }
+    addRecoveryBit(recovery) {
+      return new Signature(this.r, this.s, recovery);
+    }
+    // Unlike the top-level helper below, this method expects a digest that has
+    // already been hashed to the curve's message representative.
+    recoverPublicKey(messageHash) {
+      const { r, s } = this;
+      const recovery = this.assertRecovery();
+      const radj = recovery === 2 || recovery === 3 ? r + CURVE_ORDER : r;
+      if (!Fp.isValid(radj))
+        throw new Error("invalid recovery id: sig.r+curve.n != R.x");
+      const x = Fp.toBytes(radj);
+      const R = Point.fromBytes(concatBytes(pprefix((recovery & 1) === 0), x));
+      const ir = Fn.inv(radj);
+      const h = bits2int_modN(abytes2(messageHash, void 0, "msgHash"));
+      const u1 = Fn.create(-h * ir);
+      const u2 = Fn.create(s * ir);
+      const Q = Point.BASE.multiplyUnsafe(u1).add(R.multiplyUnsafe(u2));
+      if (Q.is0())
+        throw new Error("invalid recovery: point at infinify");
+      Q.assertValidity();
+      return Q;
+    }
+    // Signatures should be low-s, to prevent malleability.
+    hasHighS() {
+      return isBiggerThanHalfOrder(this.s);
+    }
+    toBytes(format = defaultSigOpts.format) {
+      validateSigFormat(format);
+      if (format === "der")
+        return hexToBytes2(DER.hexFromSig(this));
+      const { r, s } = this;
+      const rb = Fn.toBytes(r);
+      const sb = Fn.toBytes(s);
+      if (format === "recovered") {
+        assertRecoverableCurve();
+        return concatBytes(Uint8Array.of(this.assertRecovery()), rb, sb);
+      }
+      return concatBytes(rb, sb);
+    }
+    toHex(format) {
+      return bytesToHex2(this.toBytes(format));
+    }
+  }
+  Object.freeze(Signature.prototype);
+  Object.freeze(Signature);
+  const bits2int = ecdsaOpts.bits2int === void 0 ? function bits2int_def(bytes) {
+    if (bytes.length > 8192)
+      throw new Error("input is too large");
+    const num2 = bytesToNumberBE(bytes);
+    const delta = bytes.length * 8 - fnBits;
+    return delta > 0 ? num2 >> BigInt(delta) : num2;
+  } : ecdsaOpts.bits2int;
+  const bits2int_modN = ecdsaOpts.bits2int_modN === void 0 ? function bits2int_modN_def(bytes) {
+    return Fn.create(bits2int(bytes));
+  } : ecdsaOpts.bits2int_modN;
+  const ORDER_MASK = bitMask(fnBits);
+  function int2octets(num2) {
+    aInRange("num < 2^" + fnBits, num2, _0n2, ORDER_MASK);
+    return Fn.toBytes(num2);
+  }
+  function validateMsgAndHash(message, prehash) {
+    abytes2(message, void 0, "message");
+    return prehash ? abytes2(hash_(message), void 0, "prehashed message") : message;
+  }
+  function prepSig(message, secretKey, opts) {
+    const { lowS, prehash, extraEntropy } = validateSigOpts(opts, defaultSigOpts);
+    message = validateMsgAndHash(message, prehash);
+    const h1int = bits2int_modN(message);
+    const d = Fn.fromBytes(secretKey);
+    if (!Fn.isValidNot0(d))
+      throw new Error("invalid private key");
+    const seedArgs = [int2octets(d), int2octets(h1int)];
+    if (extraEntropy != null && extraEntropy !== false) {
+      const e = extraEntropy === true ? randomBytes3(lengths.secretKey) : extraEntropy;
+      seedArgs.push(abytes2(e, void 0, "extraEntropy"));
+    }
+    const seed = concatBytes(...seedArgs);
+    const m = h1int;
+    function k2sig(kBytes) {
+      const k = bits2int(kBytes);
+      if (!Fn.isValidNot0(k))
+        return;
+      const ik = Fn.inv(k);
+      const q = Point.BASE.multiply(k).toAffine();
+      const r = Fn.create(q.x);
+      if (r === _0n2)
+        return;
+      const s = Fn.create(ik * Fn.create(m + r * d));
+      if (s === _0n2)
+        return;
+      let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n2);
+      let normS = s;
+      if (lowS && isBiggerThanHalfOrder(s)) {
+        normS = Fn.neg(s);
+        recovery ^= 1;
+      }
+      return new Signature(r, normS, hasLargeRecoveryLifts ? void 0 : recovery);
+    }
+    return { seed, k2sig };
+  }
+  function sign(message, secretKey, opts = {}) {
+    const { seed, k2sig } = prepSig(message, secretKey, opts);
+    const drbg = createHmacDrbg(hash_.outputLen, Fn.BYTES, hmac2);
+    const sig = drbg(seed, k2sig);
+    return sig.toBytes(opts.format);
+  }
+  function verify(signature, message, publicKey, opts = {}) {
+    const { lowS, prehash, format } = validateSigOpts(opts, defaultSigOpts);
+    publicKey = abytes2(publicKey, void 0, "publicKey");
+    message = validateMsgAndHash(message, prehash);
+    if (!isBytes(signature)) {
+      const end = signature instanceof Signature ? ", use sig.toBytes()" : "";
+      throw new Error("verify expects Uint8Array signature" + end);
+    }
+    validateSigLength(signature, format);
+    try {
+      const sig = Signature.fromBytes(signature, format);
+      const P = Point.fromBytes(publicKey);
+      if (lowS && sig.hasHighS())
+        return false;
+      const { r, s } = sig;
+      const h = bits2int_modN(message);
+      const is = Fn.inv(s);
+      const u1 = Fn.create(h * is);
+      const u2 = Fn.create(r * is);
+      const R = Point.BASE.multiplyUnsafe(u1).add(P.multiplyUnsafe(u2));
+      if (R.is0())
+        return false;
+      const v = Fn.create(R.x);
+      return v === r;
+    } catch (e) {
+      return false;
+    }
+  }
+  function recoverPublicKey(signature, message, opts = {}) {
+    const { prehash } = validateSigOpts(opts, defaultSigOpts);
+    message = validateMsgAndHash(message, prehash);
+    return Signature.fromBytes(signature, "recovered").recoverPublicKey(message).toBytes();
+  }
+  return Object.freeze({
+    keygen,
+    getPublicKey: getPublicKey6,
+    getSharedSecret,
+    utils,
+    lengths,
+    Point,
+    sign,
+    verify,
+    recoverPublicKey,
+    Signature,
+    hash: hash_
+  });
+}
+
+// ../../node_modules/.pnpm/@noble+curves@2.2.0/node_modules/@noble/curves/secp256k1.js
+var secp256k1_CURVE = {
+  p: BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"),
+  n: BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"),
+  h: BigInt(1),
+  a: BigInt(0),
+  b: BigInt(7),
+  Gx: BigInt("0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"),
+  Gy: BigInt("0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8")
+};
+var secp256k1_ENDO = {
+  beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
+  basises: [
+    [BigInt("0x3086d221a7d46bcde86c90e49284eb15"), -BigInt("0xe4437ed6010e88286f547fa90abfe4c3")],
+    [BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"), BigInt("0x3086d221a7d46bcde86c90e49284eb15")]
+  ]
+};
+var _0n3 = /* @__PURE__ */ BigInt(0);
+var _2n3 = /* @__PURE__ */ BigInt(2);
+function sqrtMod(y) {
+  const P = secp256k1_CURVE.p;
+  const _3n2 = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);
+  const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);
+  const b2 = y * y * y % P;
+  const b3 = b2 * b2 * y % P;
+  const b6 = pow2(b3, _3n2, P) * b3 % P;
+  const b9 = pow2(b6, _3n2, P) * b3 % P;
+  const b11 = pow2(b9, _2n3, P) * b2 % P;
+  const b22 = pow2(b11, _11n, P) * b11 % P;
+  const b44 = pow2(b22, _22n, P) * b22 % P;
+  const b88 = pow2(b44, _44n, P) * b44 % P;
+  const b176 = pow2(b88, _88n, P) * b88 % P;
+  const b220 = pow2(b176, _44n, P) * b44 % P;
+  const b223 = pow2(b220, _3n2, P) * b3 % P;
+  const t1 = pow2(b223, _23n, P) * b22 % P;
+  const t2 = pow2(t1, _6n, P) * b2 % P;
+  const root = pow2(t2, _2n3, P);
+  if (!Fpk1.eql(Fpk1.sqr(root), y))
+    throw new Error("Cannot find square root");
+  return root;
+}
+var Fpk1 = Field(secp256k1_CURVE.p, { sqrt: sqrtMod });
+var Pointk1 = /* @__PURE__ */ weierstrass(secp256k1_CURVE, {
+  Fp: Fpk1,
+  endo: secp256k1_ENDO
+});
+var secp256k1 = /* @__PURE__ */ ecdsa(Pointk1, sha256);
+var TAGGED_HASH_PREFIXES = {};
+function taggedHash(tag, ...messages) {
+  let tagP = TAGGED_HASH_PREFIXES[tag];
+  if (tagP === void 0) {
+    const tagH = sha256(asciiToBytes(tag));
+    tagP = concatBytes(tagH, tagH);
+    TAGGED_HASH_PREFIXES[tag] = tagP;
+  }
+  return sha256(concatBytes(tagP, ...messages));
+}
+var pointToBytes = (point) => point.toBytes(true).slice(1);
+var hasEven = (y) => y % _2n3 === _0n3;
+function schnorrGetExtPubKey(priv) {
+  const { Fn, BASE } = Pointk1;
+  const d_ = Fn.fromBytes(priv);
+  const p = BASE.multiply(d_);
+  const scalar = hasEven(p.y) ? d_ : Fn.neg(d_);
+  return { scalar, bytes: pointToBytes(p) };
+}
+function lift_x(x) {
+  const Fp = Fpk1;
+  if (!Fp.isValidNot0(x))
+    throw new Error("invalid x: Fail if x \u2265 p");
+  const xx = Fp.create(x * x);
+  const c = Fp.create(xx * x + BigInt(7));
+  let y = Fp.sqrt(c);
+  if (!hasEven(y))
+    y = Fp.neg(y);
+  const p = Pointk1.fromAffine({ x, y });
+  p.assertValidity();
+  return p;
+}
+var num = bytesToNumberBE;
+function challenge(...args) {
+  return Pointk1.Fn.create(num(taggedHash("BIP0340/challenge", ...args)));
+}
+function schnorrGetPublicKey(secretKey) {
+  return schnorrGetExtPubKey(secretKey).bytes;
+}
+function schnorrSign(message, secretKey, auxRand = randomBytes(32)) {
+  const { Fn, BASE } = Pointk1;
+  const m = abytes2(message, void 0, "message");
+  const { bytes: px, scalar: d } = schnorrGetExtPubKey(secretKey);
+  const a = abytes2(auxRand, 32, "auxRand");
+  const t = Fn.toBytes(d ^ num(taggedHash("BIP0340/aux", a)));
+  const rand = taggedHash("BIP0340/nonce", t, px, m);
+  const k_ = Fn.create(num(rand));
+  if (k_ === 0n)
+    throw new Error("sign failed: k is zero");
+  const p = BASE.multiply(k_);
+  const k = hasEven(p.y) ? k_ : Fn.neg(k_);
+  const rx = pointToBytes(p);
+  const e = challenge(rx, px, m);
+  const sig = new Uint8Array(64);
+  sig.set(rx, 0);
+  sig.set(Fn.toBytes(Fn.create(k + e * d)), 32);
+  if (!schnorrVerify(sig, m, px))
+    throw new Error("sign: Invalid signature produced");
+  return sig;
+}
+function schnorrVerify(signature, message, publicKey) {
+  const { Fp, Fn, BASE } = Pointk1;
+  const sig = abytes2(signature, 64, "signature");
+  const m = abytes2(message, void 0, "message");
+  const pub = abytes2(publicKey, 32, "publicKey");
+  try {
+    const P = lift_x(num(pub));
+    const r = num(sig.subarray(0, 32));
+    if (!Fp.isValidNot0(r))
+      return false;
+    const s = num(sig.subarray(32, 64));
+    if (!Fn.isValidNot0(s))
+      return false;
+    const e = challenge(Fn.toBytes(r), pointToBytes(P), m);
+    const R = BASE.multiplyUnsafe(s).add(P.multiplyUnsafe(Fn.neg(e)));
+    const { x, y } = R.toAffine();
+    if (R.is0() || !hasEven(y) || x !== r)
+      return false;
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+var schnorr = /* @__PURE__ */ (() => {
+  const size = 32;
+  const seedLength = 48;
+  const randomSecretKey = (seed) => {
+    seed = seed === void 0 ? randomBytes(seedLength) : seed;
+    return mapHashToField(seed, secp256k1_CURVE.n);
+  };
+  return Object.freeze({
+    keygen: createKeygen(randomSecretKey, schnorrGetPublicKey),
+    getPublicKey: schnorrGetPublicKey,
+    sign: schnorrSign,
+    verify: schnorrVerify,
+    Point: Pointk1,
+    utils: Object.freeze({
+      randomSecretKey,
+      taggedHash,
+      lift_x,
+      pointToBytes
+    }),
+    lengths: Object.freeze({
+      secretKey: size,
+      publicKey: size,
+      publicKeyHasPrefix: false,
+      signature: size * 2,
+      seed: seedLength
+    })
+  });
+})();
+
+// ../../node_modules/.pnpm/@toon-protocol+settlement-digest@1.0.0/node_modules/@toon-protocol/settlement-digest/dist/index.js
+function hexToBytes3(hex) {
+  const clean2 = hex.startsWith("0x") ? hex.slice(2) : hex;
+  if (clean2.length % 2 !== 0 || !/^[0-9a-fA-F]*$/.test(clean2)) {
+    throw new Error(`Invalid hex string: ${hex}`);
+  }
+  return hexToBytes(clean2);
+}
+function bigintToBytes32BE(x) {
+  if (x < 0n) {
+    throw new Error("bigint must be non-negative for balance-proof encoding");
+  }
+  const out = new Uint8Array(32);
+  let v = x;
+  for (let i = 31; i >= 0; i--) {
+    out[i] = Number(v & 0xffn);
+    v >>= 8n;
+  }
+  if (v !== 0n) {
+    throw new Error("bigint exceeds 256 bits");
+  }
+  return out;
+}
+function concatBytes2(...parts) {
+  let len = 0;
+  for (const p of parts) len += p.length;
+  const out = new Uint8Array(len);
+  let o = 0;
+  for (const p of parts) {
+    out.set(p, o);
+    o += p.length;
+  }
+  return out;
+}
+var EIP712_PREFIX = new Uint8Array([25, 1]);
+var EIP712DOMAIN_TYPEHASH = keccak_256(
+  new TextEncoder().encode(
+    "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
+  )
+);
+var DOMAIN_NAME_HASH = keccak_256(
+  new TextEncoder().encode("RollingSwapChannel")
+);
+var DOMAIN_VERSION_HASH = keccak_256(
+  new TextEncoder().encode("2")
+);
+var CLAIM_TYPEHASH = keccak_256(
+  new TextEncoder().encode(
+    "ClaimBalanceProof(bytes32 channelId,uint256 cumulativeAmount,uint256 nonce,address recipient)"
+  )
+);
+var COOP_CLOSE_TYPEHASH = keccak_256(
+  new TextEncoder().encode(
+    "CooperativeClose(bytes32 channelId,uint256 cumulativeAmount,uint256 nonce)"
+  )
+);
+function leftPad32(bytes) {
+  if (bytes.length > 32) {
+    throw new Error(`cannot left-pad ${bytes.length} bytes into 32`);
+  }
+  const out = new Uint8Array(32);
+  out.set(bytes, 32 - bytes.length);
+  return out;
+}
+function eip712DomainSeparatorEvm(chainId, verifyingContractBytes) {
+  if (verifyingContractBytes.length !== 20) {
+    throw new Error(
+      `verifyingContract must be 20 bytes (got ${verifyingContractBytes.length})`
+    );
+  }
+  return keccak_256(
+    concatBytes2(
+      EIP712DOMAIN_TYPEHASH,
+      DOMAIN_NAME_HASH,
+      DOMAIN_VERSION_HASH,
+      bigintToBytes32BE(chainId),
+      leftPad32(verifyingContractBytes)
+    )
+  );
+}
+function eip712Digest(domainSeparator, structHash) {
+  return keccak_256(concatBytes2(EIP712_PREFIX, domainSeparator, structHash));
+}
+function balanceProofHashEvm(channelIdBytes, cumulativeAmount, nonce, recipientBytes, chainId, verifyingContractBytes) {
+  if (channelIdBytes.length !== 32) {
+    throw new Error(
+      `channelId must be 32 bytes (got ${channelIdBytes.length})`
+    );
+  }
+  if (recipientBytes.length !== 20) {
+    throw new Error(
+      `recipient must be 20 bytes (got ${recipientBytes.length})`
+    );
+  }
+  const structHash = keccak_256(
+    concatBytes2(
+      CLAIM_TYPEHASH,
+      channelIdBytes,
+      bigintToBytes32BE(cumulativeAmount),
+      bigintToBytes32BE(nonce),
+      leftPad32(recipientBytes)
+    )
+  );
+  return eip712Digest(
+    eip712DomainSeparatorEvm(chainId, verifyingContractBytes),
+    structHash
+  );
+}
+function balanceProofHashSolana(channelId, cumulativeAmount, nonce, recipient) {
+  return sha256(
+    concatBytes2(
+      new TextEncoder().encode(channelId),
+      bigintToBytes32BE(cumulativeAmount),
+      bigintToBytes32BE(nonce),
+      new TextEncoder().encode(recipient)
+    )
+  );
+}
+function minaHashToField(s) {
+  const digestHex = bytesToHex(sha256(new TextEncoder().encode(s)));
+  return BigInt("0x" + digestHex.slice(0, 60));
+}
+function balanceProofFieldsMina(channelId, cumulativeAmount, nonce, recipient) {
+  return [
+    minaHashToField(channelId),
+    cumulativeAmount,
+    nonce,
+    minaHashToField(recipient)
+  ];
+}
+function recoverEvmSigner(digest, sig65) {
+  if (sig65.length !== 65) {
+    throw new Error(
+      `EVM signature must be 65 bytes (r||s||v), got ${sig65.length}`
+    );
+  }
+  const v = sig65[64];
+  if (v !== 27 && v !== 28) {
+    throw new Error(`EVM signature v must be 27 or 28, got ${v}`);
+  }
+  const recovery = v - 27;
+  const compactRS = sig65.slice(0, 64);
+  const sig = secp256k1.Signature.fromBytes(
+    compactRS,
+    "compact"
+  ).addRecoveryBit(recovery);
+  const point = sig.recoverPublicKey(digest);
+  const uncompressedPubkey = point.toBytes(false);
+  const addrHash = keccak_256(uncompressedPubkey.slice(1));
+  return "0x" + bytesToHex(addrHash.slice(-20)).toLowerCase();
+}
+
+// ../../node_modules/.pnpm/@toon-protocol+core@3.1.2_typescript@5.9.3/node_modules/@toon-protocol/core/dist/index.js
+import { SimplePool as SimplePool3 } from "nostr-tools/pool";
+import { getPublicKey as getPublicKey3 } from "nostr-tools/pure";
+import WebSocket2 from "ws";
+import { getPublicKey as getPublicKey4 } from "nostr-tools/pure";
+import { getPublicKey as getPublicKey5 } from "nostr-tools/pure";
+var ILP_PEER_INFO_KIND = 10032;
+var BLOB_STORAGE_REQUEST_KIND = 5094;
+var ILP_SEGMENT_PATTERN = /^[a-z0-9-]+$/;
+var MAX_ILP_ADDRESS_LENGTH = 1023;
+function isValidIlpAddressStructure(address) {
+  if (!address) return false;
+  if (address.length > MAX_ILP_ADDRESS_LENGTH) return false;
+  const segments = address.split(".");
+  for (const segment of segments) {
+    if (segment.length === 0) return false;
+    if (!ILP_SEGMENT_PATTERN.test(segment)) return false;
+  }
+  return true;
+}
+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);
+}
+var RATE_REGEX = /^(0|[1-9]\d*)(\.\d+)?$/;
+var AMOUNT_REGEX = /^\d+$/;
+var MAX_NUMERIC_STRING_LENGTH = 80;
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function validateAsset(asset, side) {
+  if (!isObject(asset)) {
+    return {
+      valid: false,
+      reason: `${side} must be an object`,
+      field: side
+    };
+  }
+  if (!isNonEmptyString(asset.assetCode)) {
+    return {
+      valid: false,
+      reason: `${side}.assetCode must be a non-empty string`,
+      field: `${side}.assetCode`
+    };
+  }
+  if (!isNonNegativeInteger(asset.assetScale)) {
+    return {
+      valid: false,
+      reason: `${side}.assetScale must be a non-negative integer`,
+      field: `${side}.assetScale`
+    };
+  }
+  if (typeof asset.chain !== "string" || !validateChainId(asset.chain)) {
+    return {
+      valid: false,
+      reason: `${side}.chain must be a valid chain identifier (e.g., "evm:base:8453")`,
+      field: `${side}.chain`
+    };
+  }
+  return { valid: true };
+}
+function isValidSwapPair(pair) {
+  if (!isObject(pair)) {
+    return { valid: false, reason: "pair must be an object", field: "" };
+  }
+  const fromResult = validateAsset(pair.from, "from");
+  if (!fromResult.valid) return fromResult;
+  const toResult = validateAsset(pair.to, "to");
+  if (!toResult.valid) return toResult;
+  if (typeof pair.rate !== "string" || pair.rate.length > MAX_NUMERIC_STRING_LENGTH || !RATE_REGEX.test(pair.rate)) {
+    return {
+      valid: false,
+      reason: `rate must be a non-negative decimal string (no leading zeros, no exponent, max ${MAX_NUMERIC_STRING_LENGTH} chars)`,
+      field: "rate"
+    };
+  }
+  if (pair.minAmount !== void 0) {
+    if (typeof pair.minAmount !== "string" || pair.minAmount.length > MAX_NUMERIC_STRING_LENGTH || !AMOUNT_REGEX.test(pair.minAmount)) {
+      return {
+        valid: false,
+        reason: `minAmount must be a non-negative integer string (max ${MAX_NUMERIC_STRING_LENGTH} digits)`,
+        field: "minAmount"
+      };
+    }
+  }
+  if (pair.maxAmount !== void 0) {
+    if (typeof pair.maxAmount !== "string" || pair.maxAmount.length > MAX_NUMERIC_STRING_LENGTH || !AMOUNT_REGEX.test(pair.maxAmount)) {
+      return {
+        valid: false,
+        reason: `maxAmount must be a non-negative integer string (max ${MAX_NUMERIC_STRING_LENGTH} digits)`,
+        field: "maxAmount"
+      };
+    }
+  }
+  if (pair.minAmount !== void 0 && pair.maxAmount !== void 0) {
+    if (BigInt(pair.minAmount) > BigInt(pair.maxAmount)) {
+      return {
+        valid: false,
+        reason: "minAmount must not exceed maxAmount",
+        field: "minAmount/maxAmount"
+      };
+    }
+  }
+  return { valid: true };
+}
+function formatMessage(index, result) {
+  return `swapPairs[${index}]: ${result.reason} (field: ${result.field})`;
+}
+function assertSwapPairForBuild(pair, index) {
+  const result = isValidSwapPair(pair);
+  if (!result.valid) {
+    throw new ToonError(formatMessage(index, result), "INVALID_SWAP_PAIR");
+  }
+}
+function assertSwapPairForParse(pair, index) {
+  const result = isValidSwapPair(pair);
+  if (!result.valid) {
+    throw new InvalidEventError(formatMessage(index, result));
+  }
+}
+function isObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+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 (!isObject2(parsed)) {
+    throw new InvalidEventError("Event content must be a JSON object");
+  }
+  const {
+    ilpAddress,
+    btpEndpoint,
+    httpEndpoint,
+    supportsUpgrade,
+    blsHttpEndpoint,
+    settlementEngine,
+    assetCode,
+    assetScale,
+    ilpAddresses: rawIlpAddresses
+  } = parsed;
+  if (typeof ilpAddress !== "string" || ilpAddress.length === 0) {
+    throw new InvalidEventError(
+      "Missing or invalid required field: ilpAddress"
+    );
+  }
+  if (btpEndpoint !== void 0 && typeof btpEndpoint !== "string") {
+    throw new InvalidEventError("Invalid field: btpEndpoint must be a string");
+  }
+  if (httpEndpoint !== void 0 && typeof httpEndpoint !== "string") {
+    throw new InvalidEventError("Invalid field: httpEndpoint must be a string");
+  }
+  if (supportsUpgrade !== void 0 && typeof supportsUpgrade !== "boolean") {
+    throw new InvalidEventError("Invalid field: supportsUpgrade must be a boolean");
+  }
+  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 (!isObject2(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 (!isObject2(preferredTokens)) {
+      throw new InvalidEventError("preferredTokens must be an object");
+    }
+  }
+  if (tokenNetworks !== void 0) {
+    if (!isObject2(tokenNetworks)) {
+      throw new InvalidEventError("tokenNetworks must be an object");
+    }
+  }
+  const { feePerByte: rawFeePerByte } = parsed;
+  let feePerByte;
+  if (rawFeePerByte === void 0) {
+    feePerByte = "0";
+  } else if (typeof rawFeePerByte !== "string" || !/^\d+$/.test(rawFeePerByte)) {
+    throw new InvalidEventError(
+      `Invalid feePerByte: "${String(rawFeePerByte)}" must be a non-negative integer string`
+    );
+  } else {
+    feePerByte = rawFeePerByte;
+  }
+  const { prefixPricing: rawPrefixPricing } = parsed;
+  let prefixPricing;
+  if (rawPrefixPricing !== void 0) {
+    if (!isObject2(rawPrefixPricing)) {
+      throw new InvalidEventError("prefixPricing must be an object");
+    }
+    const { basePrice } = rawPrefixPricing;
+    if (typeof basePrice !== "string" || !/^\d+$/.test(basePrice)) {
+      throw new InvalidEventError(
+        `Invalid prefixPricing.basePrice: "${String(basePrice)}" must be a non-negative integer string`
+      );
+    }
+    prefixPricing = { basePrice };
+  }
+  const { swapPairs: rawSwapPairs } = parsed;
+  let swapPairs;
+  if (rawSwapPairs !== void 0) {
+    if (!Array.isArray(rawSwapPairs)) {
+      throw new InvalidEventError("swapPairs must be an array");
+    }
+    rawSwapPairs.forEach((pair, index) => {
+      assertSwapPairForParse(pair, index);
+    });
+    swapPairs = rawSwapPairs;
+  }
+  let ilpAddresses;
+  if (rawIlpAddresses !== void 0) {
+    if (!Array.isArray(rawIlpAddresses)) {
+      throw new InvalidEventError("ilpAddresses must be an array");
+    }
+    for (const addr of rawIlpAddresses) {
+      if (typeof addr !== "string" || addr.length === 0) {
+        throw new InvalidEventError(
+          "ilpAddresses elements must be non-empty strings"
+        );
+      }
+      if (!isValidIlpAddressStructure(addr)) {
+        throw new InvalidEventError(
+          `Invalid ILP address in ilpAddresses: "${addr}"`
+        );
+      }
+    }
+    ilpAddresses = rawIlpAddresses;
+  } else {
+    ilpAddresses = [ilpAddress];
+  }
+  return {
+    ilpAddress,
+    btpEndpoint: typeof btpEndpoint === "string" ? btpEndpoint : "",
+    ...httpEndpoint !== void 0 && typeof httpEndpoint === "string" && { httpEndpoint },
+    ...supportsUpgrade !== void 0 && typeof supportsUpgrade === "boolean" && { supportsUpgrade },
+    ...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
+    },
+    ilpAddresses,
+    feePerByte,
+    ...prefixPricing !== void 0 && { prefixPricing },
+    ...swapPairs !== void 0 && { swapPairs }
+  };
+}
+var EXPIRATION_TAG = "expiration";
+function getEventExpiration(event) {
+  const tag = event.tags.find((t) => t[0] === EXPIRATION_TAG);
+  if (!tag || tag[1] === void 0) return void 0;
+  const ts = Number(tag[1]);
+  if (!Number.isFinite(ts) || ts < 0) return void 0;
+  return ts;
+}
+function isEventExpired(event, nowSeconds = Math.floor(Date.now() / 1e3)) {
+  const exp = getEventExpiration(event);
+  return exp !== void 0 && exp <= nowSeconds;
+}
+function buildIlpPeerInfoEvent(info, secretKey, options = {}) {
+  if (info.feePerByte !== void 0) {
+    if (typeof info.feePerByte !== "string" || !/^\d+$/.test(info.feePerByte)) {
+      throw new ToonError(
+        `Invalid feePerByte: "${String(info.feePerByte)}" must be a non-negative integer string`,
+        "INVALID_FEE"
+      );
+    }
+  }
+  let effectiveInfo = info;
+  if (info.ilpAddresses !== void 0) {
+    const addresses = info.ilpAddresses;
+    if (addresses.length === 0) {
+      throw new ToonError(
+        "ilpAddresses must be a non-empty array: a node must have at least one address",
+        "ADDRESS_EMPTY_ADDRESSES"
+      );
+    }
+    for (const addr of addresses) {
+      if (!isValidIlpAddressStructure(addr)) {
+        throw new ToonError(
+          `Invalid ILP address in ilpAddresses: "${addr}"`,
+          "ADDRESS_INVALID_PREFIX"
+        );
+      }
+    }
+    const primaryAddress = addresses[0];
+    effectiveInfo = {
+      ...info,
+      ilpAddress: primaryAddress
+    };
+  }
+  if (info.swapPairs !== void 0) {
+    if (!Array.isArray(info.swapPairs)) {
+      throw new ToonError(
+        "swapPairs must be an array when provided",
+        "INVALID_SWAP_PAIR"
+      );
+    }
+    info.swapPairs.forEach((pair, index) => {
+      assertSwapPairForBuild(pair, index);
+    });
+  }
+  const createdAt = Math.floor(Date.now() / 1e3);
+  const tags = [];
+  if (options.ttlSeconds !== void 0 && options.ttlSeconds > 0) {
+    tags.push([
+      EXPIRATION_TAG,
+      String(createdAt + Math.floor(options.ttlSeconds))
+    ]);
+  }
+  return finalizeEvent(
+    {
+      kind: ILP_PEER_INFO_KIND,
+      content: JSON.stringify(effectiveInfo),
+      tags,
+      created_at: createdAt
+    },
+    secretKey
+  );
+}
+function buildBlobStorageRequest(params, secretKey) {
+  if (!params.blobData || params.blobData.length === 0) {
+    throw new ToonError(
+      "Blob storage request blobData is required and must not be empty",
+      "DVM_MISSING_INPUT"
+    );
+  }
+  if (typeof params.bid !== "string" || params.bid === "") {
+    throw new ToonError(
+      "Blob storage request bid must be a non-empty string (USDC micro-units)",
+      "DVM_INVALID_BID"
+    );
+  }
+  const contentType = params.contentType ?? "application/octet-stream";
+  const base64Blob = params.blobData.toString("base64");
+  const tags = [];
+  tags.push(["i", base64Blob, "blob"]);
+  tags.push(["bid", params.bid, "usdc"]);
+  tags.push(["output", contentType]);
+  if (params.params !== void 0) {
+    for (const p of params.params) {
+      tags.push(["param", p.key, p.value]);
+    }
+  }
+  return finalizeEvent9(
+    {
+      kind: BLOB_STORAGE_REQUEST_KIND,
+      content: "",
+      tags,
+      created_at: Math.floor(Date.now() / 1e3)
+    },
+    secretKey
+  );
+}
+var genesis_peers_default = [
+  {
+    pubkey: "2813187eb66741f9509de2055161f328a0f04e01e1fc20188610b8dbd0591ea5",
+    relayUrl: "wss://relay-ws.devnet.toonprotocol.dev",
+    ilpAddress: "g.proxy",
+    btpEndpoint: "wss://proxy.devnet.toonprotocol.dev:443"
+  }
+];
+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 envOverride = process.env["TOON_GENESIS_PEERS"];
+  if (envOverride !== void 0) {
+    let parsed;
+    try {
+      parsed = JSON.parse(envOverride);
+    } catch {
+      console.warn("Failed to parse TOON_GENESIS_PEERS JSON:", envOverride);
+      return [];
+    }
+    if (!Array.isArray(parsed)) {
+      console.warn("TOON_GENESIS_PEERS JSON is not an array");
+      return [];
+    }
+    const valid2 = [];
+    for (const entry of parsed) {
+      if (isValidGenesisPeer(entry)) {
+        valid2.push(entry);
+      } else {
+        console.warn("Skipping invalid TOON_GENESIS_PEERS entry:", entry);
+      }
+    }
+    return deduplicateByPubkey(valid2);
+  }
+  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
+};
+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
+};
+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;
+}
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function base58Encode(bytes) {
+  let zeros = 0;
+  for (let i = 0; i < bytes.length && bytes[i] === 0; i++) zeros++;
+  let value = 0n;
+  for (const byte of bytes) {
+    value = value * 256n + BigInt(byte);
+  }
+  let result = "";
+  while (value > 0n) {
+    result = BASE58_ALPHABET[Number(value % 58n)] + result;
+    value = value / 58n;
+  }
+  for (let i = 0; i < zeros; i++) {
+    result = "1" + result;
+  }
+  return result || "1";
+}
+function base58Decode(str) {
+  let zeros = 0;
+  for (let i = 0; i < str.length && str[i] === "1"; i++) zeros++;
+  let value = 0n;
+  for (const ch of str) {
+    const idx = BASE58_ALPHABET.indexOf(ch);
+    if (idx === -1) throw new Error(`Invalid base58 character: ${ch}`);
+    value = value * 58n + BigInt(idx);
+  }
+  const hex = value === 0n ? "" : value.toString(16);
+  const hexPadded = hex.length % 2 ? "0" + hex : hex;
+  const rawBytes = [];
+  for (let i = 0; i < hexPadded.length; i += 2) {
+    rawBytes.push(parseInt(hexPadded.slice(i, i + 2), 16));
+  }
+  const result = new Uint8Array(zeros + rawBytes.length);
+  result.set(rawBytes, zeros);
+  return result;
+}
+var MINA_PRIVATE_KEY_VERSION = 90;
+function hexToMinaBase58PrivateKey(privateKey) {
+  if (!/^(0x)?[0-9a-fA-F]{64}$/.test(privateKey)) {
+    return privateKey;
+  }
+  const beScalar = hexToBytes3(privateKey);
+  const leScalar = Uint8Array.from(beScalar).reverse();
+  const payload = concatBytes2(
+    Uint8Array.from([MINA_PRIVATE_KEY_VERSION, 1]),
+    leScalar
+  );
+  const checksum = sha256(sha256(payload)).slice(0, 4);
+  return base58Encode(concatBytes2(payload, checksum));
+}
+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] Negotiated ${negotiatedChain} with ${registeredPeerId} (lazy \u2014 channel deferred)`
+            );
+            result.negotiatedChain = negotiatedChain;
+            result.settlementAddress = peerAddress;
+            result.tokenAddress = tokenAddress;
+            result.tokenNetwork = tokenNetwork;
+            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 }
+                }
+              });
+            }
+          }
+        }
+      } 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);
+    let ilpResult;
+    if (this.claimSigner && result.channelId && this.ilpClient.sendIlpPacketWithClaim) {
+      const claim = await this.claimSigner(result.channelId, BigInt(amount));
+      ilpResult = await this.ilpClient.sendIlpPacketWithClaim(
+        { destination: result.peerInfo.ilpAddress, amount, data: base64Toon },
+        claim
+      );
+    } else {
+      ilpResult = await this.ilpClient.sendIlpPacket({
+        destination: result.peerInfo.ilpAddress,
+        amount,
+        data: base64Toon
+      });
+    }
+    if (ilpResult.accepted) {
+      console.log(
+        `[Bootstrap] Announced to ${result.registeredPeerId} via ILP (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
+      );
+    }
+  }
+  /**
+   * Re-advertise own kind:10032 to all previously bootstrapped peers.
+   *
+   * Called after topology changes (addUpstreamPeer/removeUpstreamPeer) to
+   * propagate updated ILP address lists to the network. Uses the same
+   * ILP-first announcement path as the initial Phase 2 bootstrap.
+   *
+   * For non-ILP mode, publishes directly to each peer's relay URL.
+   *
+   * @param results - The bootstrap results from the initial bootstrap() call
+   * @returns Number of peers successfully re-announced to
+   */
+  async republish(results) {
+    if (results.length === 0) {
+      return 0;
+    }
+    let successCount = 0;
+    if (this.ilpClient && this.toonEncoder) {
+      for (const result of results) {
+        try {
+          await this.announceViaIlp(result);
+          successCount++;
+        } catch (error) {
+          const reason = error instanceof Error ? error.message : "Unknown error";
+          this.emit({
+            type: "bootstrap:announce-failed",
+            peerId: result.registeredPeerId,
+            reason: `republish: ${reason}`
+          });
+          console.warn(
+            `[Bootstrap] Republish failed for ${result.registeredPeerId}:`,
+            reason
+          );
+        }
+      }
+    } else {
+      for (const result of results) {
+        try {
+          await this.publishOurInfo(result.knownPeer.relayUrl);
+          successCount++;
+        } catch (error) {
+          console.warn(
+            `[Bootstrap] Republish to ${result.knownPeer.relayUrl} failed:`,
+            error instanceof Error ? error.message : "Unknown error"
+          );
+        }
+      }
+    }
+    return successCount;
+  }
+  /**
+   * 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);
+  }
+};
+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 peerNegotiations = /* @__PURE__ */ new Map();
+  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 %s: %s",
+            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 %s: %s",
+          peerId,
+          reason
+        );
+        emit({
+          type: "bootstrap:settlement-failed",
+          peerId,
+          reason: `Registration failed: ${reason}`
+        });
+        return;
+      }
+      if (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) {
+              peerNegotiations.set(peerId, {
+                chain: negotiatedChain,
+                chainType: negotiatedChain.split(":")[0] ?? negotiatedChain,
+                settlementAddress: peerAddress,
+                tokenAddress,
+                tokenNetwork
+              });
+              console.log(
+                "[DiscoveryTracker] Negotiated %s with %s (lazy \u2014 channel deferred)",
+                negotiatedChain,
+                peerId
+              );
+            }
+          }
+        } catch (error) {
+          const reason = error instanceof Error ? error.message : "Unknown error";
+          console.warn(
+            "[DiscoveryTracker] Settlement negotiation failed for %s: %s",
+            peerId,
+            reason
+          );
+          emit({
+            type: "bootstrap:settlement-failed",
+            peerId,
+            reason
+          });
+        }
+      }
+    },
+    getDiscoveredPeers() {
+      return [...discoveredPeers.values()].filter(
+        (p) => !peeredPubkeys.has(p.pubkey)
+      );
+    },
+    getAllDiscoveredPeers() {
+      return [...discoveredPeers.values()];
+    },
+    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;
+    },
+    getPeerNegotiation(peerId) {
+      return peerNegotiations.get(peerId);
+    },
+    addExcludedPubkeys(pubkeys) {
+      for (const pk of pubkeys) {
+        excludedPubkeys.add(pk);
+      }
+    }
+  };
+  return tracker;
+}
+var ILP_TO_SEMANTIC = Object.freeze({
+  T00: "internal_error",
+  T04: "insufficient_funds",
+  F00: "invalid_request",
+  // F01 ("Invalid Packet" in ILP terms — emitted by the swap handler for
+  // "Invalid gift wrap" / "Invalid amount") has NO dedicated entry in the
+  // connector's REJECT_CODE_MAP (accepted semantics are: insufficient_funds,
+  // expired, unreachable, invalid_request, invalid_amount,
+  // insufficient_destination_amount, unexpected_payment, application_error,
+  // internal_error, timeout). The closest faithful reason is `invalid_request`,
+  // which the connector re-encodes to wire code F00. We map F01 EXPLICITLY
+  // (rather than relying on the fallback below) so the F01 -> F00 normalization
+  // is intentional and test-pinned, not a silent collapse that misleads callers
+  // into thinking they hit a different failure class. See issue #86.
+  F01: "invalid_request",
+  F02: "unreachable",
+  F03: "invalid_amount",
+  F04: "insufficient_destination_amount",
+  F06: "unexpected_payment",
+  R00: "expired"
+});
+var MOCK_USDC_ADDRESS = "0x5FbDB2315678afecb367f032d93F642f64180aa3";
+var CHAIN_PRESETS = {
+  anvil: {
+    name: "anvil",
+    chainId: 31337,
+    rpcUrl: "http://localhost:8545",
+    usdcAddress: MOCK_USDC_ADDRESS,
+    tokenNetworkAddress: "0xCafac3dD18aC6c6e92c921884f9E4176737C052c",
+    registryAddress: "0xe7f1725e7734ce288f8367e1bb143e90bb3f0512"
+  },
+  "arbitrum-sepolia": {
+    name: "arbitrum-sepolia",
+    chainId: 421614,
+    rpcUrl: "https://sepolia-rollup.arbitrum.io/rpc",
+    usdcAddress: "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d",
+    tokenNetworkAddress: "0x91d62b1F7C5d1129A64EE3915c480DBF288B1cBa",
+    registryAddress: ""
+  },
+  "arbitrum-one": {
+    name: "arbitrum-one",
+    chainId: 42161,
+    rpcUrl: "https://arb1.arbitrum.io/rpc",
+    usdcAddress: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+    tokenNetworkAddress: "",
+    registryAddress: ""
+  },
+  // Base Sepolia (public testnet) — TOON's deployed public-testnet settlement
+  // environment (source of truth: e2e/testnets.json). USDC is the deployed test
+  // token the TokenNetwork was opened against (NOT Circle's native testnet USDC,
+  // which the channel would not recognise). Registry + TokenNetwork are live, so
+  // this preset is settlement-complete: `--network testnet|devnet` settles here.
+  "base-sepolia": {
+    name: "base-sepolia",
+    chainId: 84532,
+    // The old `https://sepolia.base.org` is a stale-read load balancer: reads
+    // work, but openChannel->setTotalDeposit fails with InvalidChannelState
+    // (0xf806e9d9) because a follow-up read lands on a lagging replica. publicnode
+    // is the working devnet/testnet default (source of truth: toon-meta
+    // docs/deployment.md).
+    rpcUrl: "https://base-sepolia-rpc.publicnode.com",
+    // Post-2026-07-19 public-chain cutover addresses (source of truth: toon-meta
+    // docs/deployment.md). USDC is a 6-decimal mock with an ungated mint; the
+    // retired e2e deployment (18-decimal USDC 0xac806…, TokenNetwork 0x47616F4b…,
+    // registry 0xb9516c…) is still on-chain but MUST NOT be used.
+    usdcAddress: "0x49beE1Bca5d15Fb0963117923403F9498119a9Ce",
+    tokenNetworkAddress: "0x1E95493fEF46707E034b4a1945f25a8C76A1823D",
+    registryAddress: "0xcC9079adE929b168B54145f6d25262b64FAB9D5b"
+  },
+  // Base mainnet (public). USDC is Circle's native USDC on Base.
+  // TOON TokenNetwork/registry not deployed yet → settlement relay-only.
+  "base-mainnet": {
+    name: "base-mainnet",
+    chainId: 8453,
+    rpcUrl: "https://mainnet.base.org",
+    usdcAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    tokenNetworkAddress: "",
+    registryAddress: ""
+  }
+};
+var EVM_TIER = {
+  mainnet: { primary: "base-mainnet", also: ["arbitrum-one"] },
+  testnet: { primary: "base-sepolia", also: ["arbitrum-sepolia"] },
+  // EVM has no public devnet → the public Sepolia testnets serve the devnet tier.
+  devnet: { primary: "base-sepolia", also: ["arbitrum-sepolia"] }
+};
+var SOLANA_DEPLOYED_DEVNET = {
+  rpcUrl: "https://api.devnet.solana.com",
+  cluster: "devnet",
+  // Post-2026-07-19 public-chain cutover (source of truth: toon-meta
+  // docs/deployment.md). USDC mint authority is the faucet treasury
+  // AEPoA5xT…; the pre-cutover self-hosted-validator values (mint
+  // 9FtYCX…, program EdJxYPD…) are retired and MUST NOT be used.
+  usdcMint: "xyc5J8MgKFiEN13PnfftdXxUzYH34FEvw1LCrFwN7in",
+  programId: "2aEVJ8koKD8LTZrLRSGtAtU7LBt4e7QjjCgf1kzQ7Rip"
+};
+var SOLANA_TIER = {
+  mainnet: {
+    rpcUrl: "https://api.mainnet-beta.solana.com",
+    cluster: "mainnet-beta",
+    usdcMint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+    programId: ""
+    // TOON payment-channel program not deployed on mainnet
+  },
+  testnet: SOLANA_DEPLOYED_DEVNET,
+  devnet: SOLANA_DEPLOYED_DEVNET
+};
+var MINA_DEPLOYED_DEVNET = {
+  graphqlUrl: "https://api.minascan.io/node/devnet/v1/graphql",
+  network: "devnet",
+  // Post-2026-07-19 public-chain cutover (source of truth: toon-meta
+  // docs/deployment.md). This is the CURRENT deployed PaymentChannel zkApp; the
+  // previous address (B62qrH1As4…) is retired and MUST NOT be used. The channels
+  // settle a custom USDC token, so the tokenId is required to read balances /
+  // open channels against the right token.
+  zkAppAddress: "B62qmgPhv2Xo6QVEtwjLja8UZJUtu8yapRFAR6gaoGtbM9zE5hG7Tkf",
+  tokenId: "9497120696276615621907376728658022802954262638363646162765282600447713419198"
+};
+var MINA_TIER = {
+  mainnet: {
+    graphqlUrl: "https://api.minascan.io/node/mainnet/v1/graphql",
+    network: "mainnet",
+    zkAppAddress: ""
+    // TOON payment-channel zkApp not deployed on mainnet
+  },
+  testnet: MINA_DEPLOYED_DEVNET,
+  devnet: MINA_DEPLOYED_DEVNET
+};
+function evmSettlementComplete(p) {
+  return p.registryAddress !== "" && p.tokenNetworkAddress !== "";
+}
+function evmClientId(preset) {
+  const family = preset.name.split("-")[0] ?? preset.name;
+  return `evm:${family}:${preset.chainId}`;
+}
+function resolveClientNetwork(network) {
+  const supportedChains = [];
+  const chainRpcUrls = {};
+  const preferredTokens = {};
+  const tokenNetworks = {};
+  const status = {
+    evm: "unconfigured",
+    solana: "unconfigured",
+    mina: "unconfigured"
+  };
+  const evm = CHAIN_PRESETS[EVM_TIER[network].primary];
+  const evmId = evmClientId(evm);
+  supportedChains.push(evmId);
+  chainRpcUrls[evmId] = evm.rpcUrl;
+  if (evm.usdcAddress) preferredTokens[evmId] = evm.usdcAddress;
+  if (evmSettlementComplete(evm)) {
+    tokenNetworks[evmId] = evm.tokenNetworkAddress;
+    status.evm = "configured";
+  }
+  const sol = SOLANA_TIER[network];
+  const solId = `solana:${sol.cluster}`;
+  supportedChains.push(solId);
+  chainRpcUrls[solId] = sol.rpcUrl;
+  if (sol.usdcMint) preferredTokens[solId] = sol.usdcMint;
+  let solanaChannel;
+  if (sol.programId) {
+    solanaChannel = {
+      rpcUrl: sol.rpcUrl,
+      programId: sol.programId,
+      ...sol.usdcMint && { tokenMint: sol.usdcMint }
+    };
+    status.solana = "configured";
+  }
+  const mina = MINA_TIER[network];
+  const minaId = `mina:${mina.network}`;
+  supportedChains.push(minaId);
+  chainRpcUrls[minaId] = mina.graphqlUrl;
+  let minaChannel;
+  if (mina.zkAppAddress) {
+    minaChannel = {
+      graphqlUrl: mina.graphqlUrl,
+      zkAppAddress: mina.zkAppAddress,
+      networkId: mina.network === "mainnet" ? "mainnet" : "devnet",
+      ...mina.tokenId && { tokenId: mina.tokenId }
+    };
+    status.mina = "configured";
+  }
+  return {
+    supportedChains,
+    chainRpcUrls,
+    preferredTokens,
+    tokenNetworks,
+    ...solanaChannel && { solanaChannel },
+    ...minaChannel && { minaChannel },
+    status
+  };
+}
+function buildIlpPrepare(params) {
+  return {
+    destination: params.destination,
+    amount: String(params.amount),
+    data: Buffer.from(params.data).toString("base64"),
+    ...params.expiresAt !== void 0 && {
+      expiresAt: params.expiresAt.toISOString()
+    }
+  };
+}
+
+// ../client/dist/chunk-OM3MHJHC.js
+var cachedO1js = null;
+var cachedPaymentChannel = null;
+var compiledContract = null;
+var runtimeOverride = null;
+async function loadMinaRuntime() {
+  if (cachedO1js && cachedPaymentChannel) {
+    return { o1js: cachedO1js, PaymentChannel: cachedPaymentChannel };
+  }
+  if (runtimeOverride) {
+    const injected = await runtimeOverride();
+    cachedO1js = injected.o1js;
+    cachedPaymentChannel = injected.PaymentChannel;
+    return injected;
+  }
+  const { createRequire } = await import("module");
+  const nodePath = await import("path");
+  const requireHere = createRequire(import.meta.url);
+  const mzkPkgPath = requireHere.resolve(
+    "@toon-protocol/mina-zkapp/package.json"
+  );
+  const requireFromMzk = createRequire(mzkPkgPath);
+  const o1js = requireFromMzk("o1js");
+  const mzkPkgJson = requireFromMzk(mzkPkgPath);
+  const mzkDir = nodePath.dirname(mzkPkgPath);
+  const mzkEntry = nodePath.join(mzkDir, mzkPkgJson.main ?? "dist/index.js");
+  const mzk = requireFromMzk(mzkEntry);
+  const PaymentChannel = mzk.PaymentChannel ?? mzk.default?.PaymentChannel;
+  if (!PaymentChannel) {
+    throw new Error(
+      "@toon-protocol/mina-zkapp does not export PaymentChannel \u2014 cannot open a Mina channel"
+    );
+  }
+  cachedO1js = o1js;
+  cachedPaymentChannel = PaymentChannel;
+  return { o1js, PaymentChannel };
+}
+async function getO1js() {
+  return (await loadMinaRuntime()).o1js;
+}
+var compiledVerificationKeyHash;
+async function getCompiledPaymentChannel() {
+  const { PaymentChannel } = await loadMinaRuntime();
+  if (!compiledContract) {
+    const compiled = await PaymentChannel.compile();
+    compiledVerificationKeyHash = compiled?.verificationKey?.hash?.toString() ?? void 0;
+    compiledContract = PaymentChannel;
+  }
+  return compiledContract;
+}
+function getCompiledVerificationKeyHash() {
+  return compiledVerificationKeyHash;
+}
+var MINA_CHANNEL_STATE_OPEN = 1n;
+var MINA_CHANNEL_STATE_UNINITIALIZED = 0n;
+async function openMinaChannelOnChain(params) {
+  const { Mina, PrivateKey, PublicKey, Field: Field2, AccountUpdate, fetchAccount } = await getO1js();
+  const network = Mina.Network(params.graphqlUrl);
+  Mina.setActiveInstance(network);
+  const txFee = params.feeNanomina ?? 100000000n;
+  const payerKeyBase58 = hexToMinaBase58PrivateKey(params.payerPrivateKey);
+  const payerPrivateKey = PrivateKey.fromBase58(payerKeyBase58);
+  const payerPublicKey = payerPrivateKey.toPublicKey();
+  const zkAppPublicKey = PublicKey.fromBase58(params.zkAppAddress);
+  const readChannelState = async () => {
+    const res = await fetchAccount({ publicKey: zkAppPublicKey });
+    if (res.error || !res.account) {
+      throw new Error(
+        `Mina zkApp account ${params.zkAppAddress} not found on-chain (${String(
+          res.error
+        )}) \u2014 deploy the PaymentChannel zkApp before opening a channel`
+      );
+    }
+    const appState = res.account.zkapp?.appState;
+    const raw = appState?.[3]?.toString() ?? "0";
+    return BigInt(raw);
+  };
+  const readDepositTotal = async () => {
+    const res = await fetchAccount({ publicKey: zkAppPublicKey });
+    if (res.error || !res.account) {
+      throw new Error(
+        `Mina zkApp account ${params.zkAppAddress} not found on-chain (${String(
+          res.error
+        )}) \u2014 deploy the PaymentChannel zkApp before opening a channel`
+      );
+    }
+    const appState = res.account.zkapp?.appState;
+    const raw = appState?.[4]?.toString() ?? "0";
+    return BigInt(raw);
+  };
+  const currentState = await readChannelState();
+  await fetchAccount({ publicKey: payerPublicKey });
+  let opened = false;
+  let initTxHash;
+  let zkApp;
+  const getZkApp = async () => {
+    if (!zkApp) {
+      const PaymentChannel = await getCompiledPaymentChannel();
+      zkApp = new PaymentChannel(zkAppPublicKey);
+    }
+    return zkApp;
+  };
+  if (currentState === MINA_CHANNEL_STATE_UNINITIALIZED) {
+    const channel = await getZkApp();
+    const participantA = payerPublicKey;
+    const participantB = params.peerPublicKey ? PublicKey.fromBase58(params.peerPublicKey) : payerPublicKey;
+    const nonce = Field2(0);
+    const timeoutField = Field2((params.timeout ?? 86400n).toString());
+    const tokenIdField = Field2(params.tokenId ?? "1");
+    await fetchAccount({ publicKey: zkAppPublicKey });
+    await fetchAccount({ publicKey: payerPublicKey });
+    const initTx = await Mina.transaction(
+      { sender: payerPublicKey, fee: Number(txFee) },
+      async () => {
+        await channel.initializeChannel(
+          participantA,
+          participantB,
+          nonce,
+          timeoutField,
+          tokenIdField
+        );
+      }
+    );
+    await initTx.prove();
+    const sentInit = await initTx.sign([payerPrivateKey]).send();
+    initTxHash = sentInit.hash ?? void 0;
+    opened = true;
+    await sentInit.wait();
+    await fetchAccount({ publicKey: zkAppPublicKey });
+    await fetchAccount({ publicKey: payerPublicKey });
+  } else if (currentState !== MINA_CHANNEL_STATE_OPEN) {
+    throw new Error(
+      `Mina channel ${params.zkAppAddress} is in state ${currentState} (not UNINITIALIZED/OPEN) \u2014 cannot open`
+    );
+  }
+  let depositTxHash;
+  if (params.deposit && params.deposit.amount > 0n) {
+    const channel = await getZkApp();
+    await fetchAccount({ publicKey: zkAppPublicKey });
+    const amountField = Field2(params.deposit.amount.toString());
+    const depositTx = await Mina.transaction(
+      { sender: payerPublicKey, fee: Number(txFee) },
+      async () => {
+        await channel.deposit(amountField, payerPublicKey);
+      }
+    );
+    await depositTx.prove();
+    const sentDeposit = await depositTx.sign([payerPrivateKey]).send();
+    depositTxHash = sentDeposit.hash ?? void 0;
+    await sentDeposit.wait();
+    await fetchAccount({ publicKey: zkAppPublicKey });
+    await fetchAccount({ publicKey: payerPublicKey });
+  }
+  let finalState;
+  try {
+    finalState = Number(await readChannelState());
+  } catch {
+    finalState = opened ? Number(MINA_CHANNEL_STATE_OPEN) : Number(currentState);
+  }
+  if (opened && finalState === Number(MINA_CHANNEL_STATE_UNINITIALIZED)) {
+    finalState = Number(MINA_CHANNEL_STATE_OPEN);
+  }
+  void AccountUpdate;
+  let depositTotal;
+  try {
+    depositTotal = await readDepositTotal();
+  } catch {
+    depositTotal = 0n;
+  }
+  return {
+    zkAppAddress: params.zkAppAddress,
+    opened,
+    initTxHash,
+    depositTxHash,
+    channelState: finalState,
+    depositTotal
+  };
+}
+var APPSTATE_CHANNEL_HASH = 0;
+var APPSTATE_CHANNEL_STATE = 3;
+var STATE_UNINITIALIZED = 0n;
+var STATE_OPEN = 1n;
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function deployMinaChannelZkApp(params) {
+  const { o1js } = await loadMinaRuntime();
+  const { Mina, PrivateKey, AccountUpdate, fetchAccount } = o1js;
+  const progress = params.onProgress ?? (() => {
+  });
+  const network = Mina.Network(params.graphqlUrl);
+  Mina.setActiveInstance(network);
+  const payerKeyBase58 = hexToMinaBase58PrivateKey(params.payerPrivateKey);
+  const payerPrivateKey = PrivateKey.fromBase58(payerKeyBase58);
+  const payerPublicKey = payerPrivateKey.toPublicKey();
+  progress(
+    "compiling the PaymentChannel circuit (one-time, can take 1-3 minutes)\u2026"
+  );
+  const PaymentChannel = await getCompiledPaymentChannel();
+  const zkAppPrivateKey = PrivateKey.random();
+  const zkAppPublicKey = zkAppPrivateKey.toPublicKey();
+  const zkAppAddress = zkAppPublicKey.toBase58();
+  const zkApp = new PaymentChannel(zkAppPublicKey);
+  await fetchAccount({ publicKey: payerPublicKey });
+  progress(
+    `deploying a dedicated PaymentChannel zkApp ${zkAppAddress} (costs the 1 MINA account-creation fee + tx fee)\u2026`
+  );
+  const fee = Number(params.feeNanomina ?? 100000000n);
+  const deployTx = await Mina.transaction(
+    { sender: payerPublicKey, fee },
+    async () => {
+      AccountUpdate.fundNewAccount(payerPublicKey);
+      await zkApp.deploy();
+    }
+  );
+  await deployTx.prove();
+  const sent = await deployTx.sign([payerPrivateKey, zkAppPrivateKey]).send();
+  const deployTxHash = sent.hash ?? void 0;
+  progress(
+    `deploy tx sent${deployTxHash ? ` (${deployTxHash})` : ""} \u2014 waiting for inclusion (devnet blocks are ~3 minutes)\u2026`
+  );
+  const interval = params.pollIntervalMs ?? 15e3;
+  const budget = params.pollTimeoutMs ?? 54e4;
+  const started = Date.now();
+  try {
+    await sent.wait();
+  } catch {
+  }
+  for (; ; ) {
+    const res = await fetchAccount({ publicKey: zkAppPublicKey });
+    if (!res.error && res.account) break;
+    if (Date.now() - started > budget) {
+      throw new Error(
+        `Mina zkApp ${zkAppAddress} did not appear on-chain within ${Math.round(budget / 6e4)} minutes of the deploy tx${deployTxHash ? ` (${deployTxHash})` : ""} \u2014 check the tx on minascan before retrying (the zkApp key has been recorded)`
+      );
+    }
+    await sleep(interval);
+  }
+  progress(`zkApp ${zkAppAddress} is on-chain (bare \u2014 initialize follows).`);
+  return {
+    zkAppAddress,
+    zkAppPrivateKey: zkAppPrivateKey.toBase58(),
+    feePayer: payerPublicKey.toBase58(),
+    ...deployTxHash !== void 0 ? { deployTxHash } : {},
+    ...getCompiledVerificationKeyHash() !== void 0 ? { vkHash: getCompiledVerificationKeyHash() } : {}
+  };
+}
+async function ensureOwnedMinaZkApp(params) {
+  const { o1js } = await loadMinaRuntime();
+  const { Mina, PrivateKey, PublicKey, Field: Field2, Poseidon, fetchAccount } = o1js;
+  const progress = params.onProgress ?? (() => {
+  });
+  const network = Mina.Network(params.graphqlUrl);
+  Mina.setActiveInstance(network);
+  const payerKeyBase58 = hexToMinaBase58PrivateKey(params.payerPrivateKey);
+  const clientPublicKey = PrivateKey.fromBase58(payerKeyBase58).toPublicKey();
+  const peerPublicKey = PublicKey.fromBase58(params.peerPublicKey);
+  if (!Poseidon) {
+    throw new Error(
+      "the loaded o1js runtime does not expose Poseidon \u2014 cannot derive the pair hash"
+    );
+  }
+  const expectedChannelHash = Poseidon.hash([
+    clientPublicKey.x,
+    peerPublicKey.x,
+    Field2(0)
+  ]).toString();
+  const candidates = [];
+  if (params.deployed?.zkAppAddress) {
+    candidates.push({ address: params.deployed.zkAppAddress, ownRecord: true });
+  }
+  if (params.candidateZkAppAddress && params.candidateZkAppAddress !== params.deployed?.zkAppAddress) {
+    candidates.push({
+      address: params.candidateZkAppAddress,
+      ownRecord: false
+    });
+  }
+  for (const candidate of candidates) {
+    let appState;
+    try {
+      const res = await fetchAccount({
+        publicKey: PublicKey.fromBase58(candidate.address)
+      });
+      if (res.error || !res.account) continue;
+      appState = res.account.zkapp?.appState;
+    } catch {
+      continue;
+    }
+    const channelHash = appState?.[APPSTATE_CHANNEL_HASH]?.toString() ?? "";
+    const channelState = BigInt(
+      appState?.[APPSTATE_CHANNEL_STATE]?.toString() ?? "0"
+    );
+    if (channelState === STATE_OPEN && channelHash === expectedChannelHash) {
+      progress(`reusing our open Mina channel zkApp ${candidate.address}.`);
+      return { zkAppAddress: candidate.address, deployed: false };
+    }
+    if (candidate.ownRecord && channelState === STATE_UNINITIALIZED) {
+      progress(
+        `reusing our recorded (uninitialized) Mina zkApp ${candidate.address}.`
+      );
+      return { zkAppAddress: candidate.address, deployed: false };
+    }
+  }
+  const record = await deployMinaChannelZkApp(params);
+  await params.onDeployed?.(record);
+  return { zkAppAddress: record.zkAppAddress, deployed: true, record };
+}
+
+export {
+  ToonError,
+  encodeEventToToon,
+  decodeEventFromToon,
+  keccak_256,
+  secp256k1,
+  schnorr,
+  hexToBytes3 as hexToBytes,
+  bigintToBytes32BE,
+  concatBytes2 as concatBytes,
+  balanceProofHashEvm,
+  balanceProofHashSolana,
+  balanceProofFieldsMina,
+  recoverEvmSigner,
+  ILP_PEER_INFO_KIND,
+  parseIlpPeerInfo,
+  isEventExpired,
+  buildBlobStorageRequest,
+  GenesisPeerLoader,
+  base58Encode,
+  base58Decode,
+  hexToMinaBase58PrivateKey,
+  BootstrapService,
+  createDiscoveryTracker,
+  resolveClientNetwork,
+  buildIlpPrepare,
+  openMinaChannelOnChain,
+  deployMinaChannelZkApp,
+  ensureOwnedMinaZkApp
+};
+/*! Bundled license information:
+
+@noble/curves/abstract/weierstrass.js:
+@noble/curves/secp256k1.js:
+  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/
+//# sourceMappingURL=chunk-IYPIOSEF.js.map