@toon-protocol/client-mcp 0.4.0 → 0.4.1

package/dist/{chunk-WGR4UZ34.js → chunk-R75M6TK6.js}

@@ -30,11 +30,7 @@ import {
   utf8ToBytes
 } from "./chunk-VA7XC4FD.js";
 
-// ../client/dist/index.js
-import { generateSecretKey as generateSecretKey3, getPublicKey as getPublicKey22, finalizeEvent as finalizeEvent11 } from "nostr-tools/pure";
-import { generateSecretKey as generateSecretKey2 } from "nostr-tools/pure";
-
-// ../../node_modules/.pnpm/@toon-protocol+core@1.4.2_@toon-protocol+connector@3.13.0_typescript@5.9.3/node_modules/@toon-protocol/core/dist/chunk-5WT7ISKC.js
+// ../../node_modules/.pnpm/@toon-protocol+core@1.6.0_@toon-protocol+connector@3.13.0_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";
@@ -58,99 +54,8 @@ var PeerDiscoveryError = class extends ToonError {
     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@1.4.2_@toon-protocol+connector@3.13.0_typescript@5.9.3/node_modules/@toon-protocol/core/dist/index.js
+// ../../node_modules/.pnpm/@toon-protocol+core@1.6.0_@toon-protocol+connector@3.13.0_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";
@@ -317,6 +222,8 @@ function parseIlpPeerInfo(event) {
   const {
     ilpAddress,
     btpEndpoint,
+    httpEndpoint,
+    supportsUpgrade,
     blsHttpEndpoint,
     settlementEngine,
     assetCode,
@@ -331,6 +238,12 @@ function parseIlpPeerInfo(event) {
   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");
   }
@@ -464,6 +377,8 @@ function parseIlpPeerInfo(event) {
   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,
@@ -483,17 +398,6 @@ function parseIlpPeerInfo(event) {
   };
 }
 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)) {
@@ -1953,15 +1857,14 @@ function resolveClientNetwork(network) {
     status
   };
 }
-function buildIlpPrepare(params) {
-  return {
-    destination: params.destination,
-    amount: String(params.amount),
-    data: Buffer.from(params.data).toString("base64")
-  };
-}
+
+// ../client/dist/chunk-QEMD5EAI.js
+import { verifyEvent as verifyEvent2 } from "nostr-tools/pure";
+import { verifyEvent as verifyEvent22 } from "nostr-tools/pure";
 
 // ../client/dist/index.js
+import { generateSecretKey as generateSecretKey3, getPublicKey as getPublicKey22, finalizeEvent as finalizeEvent11 } from "nostr-tools/pure";
+import { generateSecretKey as generateSecretKey2 } from "nostr-tools/pure";
 import { generateSecretKey, getPublicKey as getPublicKey6 } from "nostr-tools/pure";
 import { privateKeyToAccount } from "viem/accounts";
 import { toHex } from "viem";
@@ -2056,9 +1959,9 @@ function anumArr(label, input) {
 function chain(...args) {
   const id = (a) => a;
   const wrap = (a, b) => (c) => a(b(c));
-  const encode2 = args.map((x) => x.encode).reduceRight(wrap, id);
-  const decode3 = args.map((x) => x.decode).reduce(wrap, id);
-  return { encode: encode2, decode: decode3 };
+  const encode3 = args.map((x) => x.encode).reduceRight(wrap, id);
+  const decode4 = args.map((x) => x.decode).reduce(wrap, id);
+  return { encode: encode3, decode: decode4 };
 }
 // @__NO_SIDE_EFFECTS__
 function alphabet(letters) {
@@ -5831,12 +5734,12 @@ function ecdh(Point2, ecdhOpts = {}) {
   function randomSecretKey(seed = randomBytes_(lengths.seed)) {
     return mapHashToField(_abytes2(seed, lengths.seed, "seed"), Fn.ORDER);
   }
-  function getPublicKey7(secretKey, isCompressed = true) {
+  function getPublicKey8(secretKey, isCompressed = true) {
     return Point2.BASE.multiply(_normFnElement(Fn, secretKey)).toBytes(isCompressed);
   }
   function keygen(seed) {
     const secretKey = randomSecretKey(seed);
-    return { secretKey, publicKey: getPublicKey7(secretKey) };
+    return { secretKey, publicKey: getPublicKey8(secretKey) };
   }
   function isProbPub(item) {
     if (typeof item === "bigint")
@@ -5870,7 +5773,7 @@ function ecdh(Point2, ecdhOpts = {}) {
       return point.precompute(windowSize, false);
     }
   };
-  return Object.freeze({ getPublicKey: getPublicKey7, getSharedSecret, keygen, Point: Point2, utils: utils2, lengths });
+  return Object.freeze({ getPublicKey: getPublicKey8, getSharedSecret, keygen, Point: Point2, utils: utils2, lengths });
 }
 function ecdsa(Point2, hash, ecdsaOpts = {}) {
   ahash(hash);
@@ -5885,7 +5788,7 @@ function ecdsa(Point2, hash, ecdsaOpts = {}) {
   const hmac2 = ecdsaOpts.hmac || ((key, ...msgs) => hmac(hash, key, concatBytes(...msgs)));
   const { Fp, Fn } = Point2;
   const { ORDER: CURVE_ORDER, BITS: fnBits } = Fn;
-  const { keygen, getPublicKey: getPublicKey7, getSharedSecret, utils: utils2, lengths } = ecdh(Point2, ecdsaOpts);
+  const { keygen, getPublicKey: getPublicKey8, getSharedSecret, utils: utils2, lengths } = ecdh(Point2, ecdsaOpts);
   const defaultSigOpts = {
     prehash: false,
     lowS: typeof ecdsaOpts.lowS === "boolean" ? ecdsaOpts.lowS : false,
@@ -6131,7 +6034,7 @@ function ecdsa(Point2, hash, ecdsaOpts = {}) {
   }
   return Object.freeze({
     keygen,
-    getPublicKey: getPublicKey7,
+    getPublicKey: getPublicKey8,
     getSharedSecret,
     utils: utils2,
     lengths,
@@ -11231,6 +11134,484 @@ function writeKeystoreFile(path, keystore) {
 import { readFileSync as readFileSync3 } from "fs";
 import { homedir } from "os";
 import { join as join2 } from "path";
+
+// ../../node_modules/.pnpm/@toon-protocol+core@1.4.2_@toon-protocol+connector@3.13.0_typescript@5.9.3/node_modules/@toon-protocol/core/dist/chunk-5WT7ISKC.js
+import { encode as encode2 } from "@toon-format/toon";
+import { decode as decode3 } from "@toon-format/toon";
+import { decode as decode22 } from "@toon-format/toon";
+var ToonError2 = class extends Error {
+  code;
+  constructor(message, code, cause) {
+    super(message, { cause });
+    this.name = "ToonError";
+    this.code = code;
+  }
+};
+var InvalidEventError2 = class extends ToonError2 {
+  constructor(message, cause) {
+    super(message, "INVALID_EVENT", cause);
+    this.name = "InvalidEventError";
+  }
+};
+var ToonEncodeError2 = class extends ToonError2 {
+  constructor(message, cause) {
+    super(message, "TOON_ENCODE_ERROR", cause);
+    this.name = "ToonEncodeError";
+  }
+};
+function encodeEventToToon2(event) {
+  try {
+    const toonString = encode2(event);
+    return new TextEncoder().encode(toonString);
+  } catch (error) {
+    throw new ToonEncodeError2(
+      `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 ToonDecodeError2 = class extends ToonError2 {
+  constructor(message, cause) {
+    super(message, "TOON_DECODE_ERROR", cause);
+    this.name = "ToonDecodeError";
+  }
+};
+function validateNostrEvent(obj) {
+  if (typeof obj !== "object" || obj === null) {
+    throw new ToonDecodeError2("Decoded value is not an object");
+  }
+  const event = obj;
+  if (!isValidHex(event["id"], 64)) {
+    throw new ToonDecodeError2(
+      "Invalid event id: must be a 64-character hex string"
+    );
+  }
+  if (!isValidHex(event["pubkey"], 64)) {
+    throw new ToonDecodeError2(
+      "Invalid event pubkey: must be a 64-character hex string"
+    );
+  }
+  if (typeof event["kind"] !== "number" || !Number.isInteger(event["kind"])) {
+    throw new ToonDecodeError2("Invalid event kind: must be an integer");
+  }
+  if (typeof event["content"] !== "string") {
+    throw new ToonDecodeError2("Invalid event content: must be a string");
+  }
+  const tags = event["tags"];
+  if (!Array.isArray(tags)) {
+    throw new ToonDecodeError2("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 ToonDecodeError2(`Invalid event tags[${i}]: must be an array`);
+    }
+    for (let j = 0; j < tag.length; j++) {
+      if (typeof tag[j] !== "string") {
+        throw new ToonDecodeError2(
+          `Invalid event tags[${i}][${j}]: must be a string`
+        );
+      }
+    }
+  }
+  if (typeof event["created_at"] !== "number" || !Number.isInteger(event["created_at"])) {
+    throw new ToonDecodeError2("Invalid event created_at: must be an integer");
+  }
+  if (!isValidHex(event["sig"], 128)) {
+    throw new ToonDecodeError2(
+      "Invalid event sig: must be a 128-character hex string"
+    );
+  }
+}
+function decodeEventFromToon2(data) {
+  try {
+    const toonString = new TextDecoder().decode(data);
+    const decoded = decode3(toonString);
+    validateNostrEvent(decoded);
+    return decoded;
+  } catch (error) {
+    if (error instanceof ToonDecodeError2) {
+      throw error;
+    }
+    throw new ToonDecodeError2(
+      `Failed to decode TOON data: ${error instanceof Error ? error.message : String(error)}`,
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+
+// ../../node_modules/.pnpm/@toon-protocol+core@1.4.2_@toon-protocol+connector@3.13.0_typescript@5.9.3/node_modules/@toon-protocol/core/dist/index.js
+import { finalizeEvent as finalizeEvent12 } from "nostr-tools/pure";
+import { finalizeEvent as finalizeEvent23 } from "nostr-tools/pure";
+import { finalizeEvent as finalizeEvent32 } from "nostr-tools/pure";
+import { finalizeEvent as finalizeEvent42 } from "nostr-tools/pure";
+import { finalizeEvent as finalizeEvent52 } from "nostr-tools/pure";
+import { finalizeEvent as finalizeEvent62 } from "nostr-tools/pure";
+import { finalizeEvent as finalizeEvent72 } from "nostr-tools/pure";
+import { finalizeEvent as finalizeEvent82 } from "nostr-tools/pure";
+import { finalizeEvent as finalizeEvent92 } from "nostr-tools/pure";
+import { finalizeEvent as finalizeEvent102 } from "nostr-tools/pure";
+import { SimplePool as SimplePool4 } from "nostr-tools/pool";
+import { SimplePool as SimplePool22 } from "nostr-tools/pool";
+import { getPublicKey as getPublicKey7 } from "nostr-tools/pure";
+import WebSocket3 from "ws";
+import { getPublicKey as getPublicKey23, verifyEvent as verifyEvent3 } from "nostr-tools/pure";
+import { SimplePool as SimplePool32 } from "nostr-tools/pool";
+import { getPublicKey as getPublicKey33 } from "nostr-tools/pure";
+import WebSocket23 from "ws";
+import { getPublicKey as getPublicKey42 } from "nostr-tools/pure";
+import { getPublicKey as getPublicKey52 } from "nostr-tools/pure";
+var ILP_PEER_INFO_KIND2 = 10032;
+var ILP_SEGMENT_PATTERN2 = /^[a-z0-9-]+$/;
+var MAX_ILP_ADDRESS_LENGTH2 = 1023;
+function isValidIlpAddressStructure2(address) {
+  if (!address) return false;
+  if (address.length > MAX_ILP_ADDRESS_LENGTH2) return false;
+  const segments = address.split(".");
+  for (const segment of segments) {
+    if (segment.length === 0) return false;
+    if (!ILP_SEGMENT_PATTERN2.test(segment)) return false;
+  }
+  return true;
+}
+function validateChainId2(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_REGEX2 = /^(0|[1-9]\d*)(\.\d+)?$/;
+var AMOUNT_REGEX2 = /^\d+$/;
+var MAX_NUMERIC_STRING_LENGTH2 = 80;
+function isObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString2(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isNonNegativeInteger2(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function validateAsset2(asset, side) {
+  if (!isObject3(asset)) {
+    return {
+      valid: false,
+      reason: `${side} must be an object`,
+      field: side
+    };
+  }
+  if (!isNonEmptyString2(asset.assetCode)) {
+    return {
+      valid: false,
+      reason: `${side}.assetCode must be a non-empty string`,
+      field: `${side}.assetCode`
+    };
+  }
+  if (!isNonNegativeInteger2(asset.assetScale)) {
+    return {
+      valid: false,
+      reason: `${side}.assetScale must be a non-negative integer`,
+      field: `${side}.assetScale`
+    };
+  }
+  if (typeof asset.chain !== "string" || !validateChainId2(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 isValidSwapPair2(pair) {
+  if (!isObject3(pair)) {
+    return { valid: false, reason: "pair must be an object", field: "" };
+  }
+  const fromResult = validateAsset2(pair.from, "from");
+  if (!fromResult.valid) return fromResult;
+  const toResult = validateAsset2(pair.to, "to");
+  if (!toResult.valid) return toResult;
+  if (typeof pair.rate !== "string" || pair.rate.length > MAX_NUMERIC_STRING_LENGTH2 || !RATE_REGEX2.test(pair.rate)) {
+    return {
+      valid: false,
+      reason: `rate must be a non-negative decimal string (no leading zeros, no exponent, max ${MAX_NUMERIC_STRING_LENGTH2} chars)`,
+      field: "rate"
+    };
+  }
+  if (pair.minAmount !== void 0) {
+    if (typeof pair.minAmount !== "string" || pair.minAmount.length > MAX_NUMERIC_STRING_LENGTH2 || !AMOUNT_REGEX2.test(pair.minAmount)) {
+      return {
+        valid: false,
+        reason: `minAmount must be a non-negative integer string (max ${MAX_NUMERIC_STRING_LENGTH2} digits)`,
+        field: "minAmount"
+      };
+    }
+  }
+  if (pair.maxAmount !== void 0) {
+    if (typeof pair.maxAmount !== "string" || pair.maxAmount.length > MAX_NUMERIC_STRING_LENGTH2 || !AMOUNT_REGEX2.test(pair.maxAmount)) {
+      return {
+        valid: false,
+        reason: `maxAmount must be a non-negative integer string (max ${MAX_NUMERIC_STRING_LENGTH2} 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 formatMessage2(index, result) {
+  return `swapPairs[${index}]: ${result.reason} (field: ${result.field})`;
+}
+function assertSwapPairForParse2(pair, index) {
+  const result = isValidSwapPair2(pair);
+  if (!result.valid) {
+    throw new InvalidEventError2(formatMessage2(index, result));
+  }
+}
+function isObject22(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseIlpPeerInfo2(event) {
+  if (event.kind !== ILP_PEER_INFO_KIND2) {
+    throw new InvalidEventError2(
+      `Expected event kind ${ILP_PEER_INFO_KIND2}, got ${event.kind}`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(event.content);
+  } catch (err) {
+    throw new InvalidEventError2(
+      "Failed to parse event content as JSON",
+      err instanceof Error ? err : void 0
+    );
+  }
+  if (!isObject22(parsed)) {
+    throw new InvalidEventError2("Event content must be a JSON object");
+  }
+  const {
+    ilpAddress,
+    btpEndpoint,
+    blsHttpEndpoint,
+    settlementEngine,
+    assetCode,
+    assetScale,
+    ilpAddresses: rawIlpAddresses
+  } = parsed;
+  if (typeof ilpAddress !== "string" || ilpAddress.length === 0) {
+    throw new InvalidEventError2(
+      "Missing or invalid required field: ilpAddress"
+    );
+  }
+  if (btpEndpoint !== void 0 && typeof btpEndpoint !== "string") {
+    throw new InvalidEventError2("Invalid field: btpEndpoint must be a string");
+  }
+  if (typeof assetCode !== "string" || assetCode.length === 0) {
+    throw new InvalidEventError2("Missing or invalid required field: assetCode");
+  }
+  if (typeof assetScale !== "number" || !Number.isInteger(assetScale)) {
+    throw new InvalidEventError2(
+      "Missing or invalid required field: assetScale"
+    );
+  }
+  if (settlementEngine !== void 0 && typeof settlementEngine !== "string") {
+    throw new InvalidEventError2(
+      "Invalid optional field: settlementEngine must be a string"
+    );
+  }
+  const {
+    supportedChains,
+    settlementAddresses,
+    preferredTokens,
+    tokenNetworks
+  } = parsed;
+  if (supportedChains !== void 0) {
+    if (!Array.isArray(supportedChains)) {
+      throw new InvalidEventError2("supportedChains must be an array");
+    }
+    if (supportedChains.length === 0) {
+      throw new InvalidEventError2(
+        "supportedChains must be a non-empty array when provided"
+      );
+    }
+    for (const chainId of supportedChains) {
+      if (typeof chainId !== "string" || !validateChainId2(chainId)) {
+        throw new InvalidEventError2(
+          `Invalid chain identifier: ${String(chainId)}`
+        );
+      }
+    }
+  }
+  if (settlementAddresses !== void 0) {
+    if (!isObject22(settlementAddresses)) {
+      throw new InvalidEventError2("settlementAddresses must be an object");
+    }
+    for (const [key, value] of Object.entries(settlementAddresses)) {
+      if (!validateChainId2(key)) {
+        throw new InvalidEventError2(
+          `Invalid chain identifier in settlementAddresses: ${key}`
+        );
+      }
+      if (typeof value !== "string" || value.length === 0) {
+        throw new InvalidEventError2(
+          "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 InvalidEventError2(
+            `settlementAddresses key '${key}' is not in supportedChains`
+          );
+        }
+      }
+    }
+  }
+  if (preferredTokens !== void 0) {
+    if (!isObject22(preferredTokens)) {
+      throw new InvalidEventError2("preferredTokens must be an object");
+    }
+  }
+  if (tokenNetworks !== void 0) {
+    if (!isObject22(tokenNetworks)) {
+      throw new InvalidEventError2("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 InvalidEventError2(
+      `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 (!isObject22(rawPrefixPricing)) {
+      throw new InvalidEventError2("prefixPricing must be an object");
+    }
+    const { basePrice } = rawPrefixPricing;
+    if (typeof basePrice !== "string" || !/^\d+$/.test(basePrice)) {
+      throw new InvalidEventError2(
+        `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 InvalidEventError2("swapPairs must be an array");
+    }
+    rawSwapPairs.forEach((pair, index) => {
+      assertSwapPairForParse2(pair, index);
+    });
+    swapPairs = rawSwapPairs;
+  }
+  let ilpAddresses;
+  if (rawIlpAddresses !== void 0) {
+    if (!Array.isArray(rawIlpAddresses)) {
+      throw new InvalidEventError2("ilpAddresses must be an array");
+    }
+    for (const addr of rawIlpAddresses) {
+      if (typeof addr !== "string" || addr.length === 0) {
+        throw new InvalidEventError2(
+          "ilpAddresses elements must be non-empty strings"
+        );
+      }
+      if (!isValidIlpAddressStructure2(addr)) {
+        throw new InvalidEventError2(
+          `Invalid ILP address in ilpAddresses: "${addr}"`
+        );
+      }
+    }
+    ilpAddresses = rawIlpAddresses;
+  } else {
+    ilpAddresses = [ilpAddress];
+  }
+  return {
+    ilpAddress,
+    btpEndpoint: typeof btpEndpoint === "string" ? btpEndpoint : "",
+    ...blsHttpEndpoint !== void 0 && typeof blsHttpEndpoint === "string" && { blsHttpEndpoint },
+    assetCode,
+    assetScale,
+    ...settlementEngine !== void 0 && { settlementEngine },
+    supportedChains: supportedChains !== void 0 ? supportedChains : [],
+    settlementAddresses: settlementAddresses !== void 0 ? settlementAddresses : {},
+    ...preferredTokens !== void 0 && {
+      preferredTokens
+    },
+    ...tokenNetworks !== void 0 && {
+      tokenNetworks
+    },
+    ilpAddresses,
+    feePerByte,
+    ...prefixPricing !== void 0 && { prefixPricing },
+    ...swapPairs !== void 0 && { swapPairs }
+  };
+}
+var EXPIRATION_TAG2 = "expiration";
+function getEventExpiration(event) {
+  const tag = event.tags.find((t) => t[0] === EXPIRATION_TAG2);
+  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;
+}
+var ILP_TO_SEMANTIC2 = 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"
+});
+function buildIlpPrepare(params) {
+  return {
+    destination: params.destination,
+    amount: String(params.amount),
+    data: Buffer.from(params.data).toString("base64")
+  };
+}
+
+// src/daemon/config.ts
 var DEFAULT_KEYSTORE_PASSWORD = "toon-client-default";
 function configDir() {
   return process.env["TOON_CLIENT_HOME"] ?? join2(homedir(), ".toon-client");
@@ -11298,8 +11679,8 @@ function resolveConfig(file) {
       assetCode: "USD",
       assetScale: 6
     },
-    toonEncoder: encodeEventToToon,
-    toonDecoder: decodeEventFromToon,
+    toonEncoder: encodeEventToToon2,
+    toonDecoder: decodeEventFromToon2,
     ...btpUrl ? { btpUrl, btpAuthToken: "" } : {},
     destinationAddress: destination,
     relayUrl: "",
@@ -11597,17 +11978,17 @@ function delay(ms) {
 }
 
 export {
-  ToonError,
-  encodeEventToToon,
-  decodeEventFromToon,
-  ILP_PEER_INFO_KIND,
-  parseIlpPeerInfo,
-  isEventExpired,
-  buildIlpPrepare,
   deriveFullIdentity,
   ToonClient,
   fundWallet,
   generateKeystore,
+  ToonError2 as ToonError,
+  encodeEventToToon2 as encodeEventToToon,
+  decodeEventFromToon2 as decodeEventFromToon,
+  ILP_PEER_INFO_KIND2 as ILP_PEER_INFO_KIND,
+  parseIlpPeerInfo2 as parseIlpPeerInfo,
+  isEventExpired,
+  buildIlpPrepare,
   DEFAULT_KEYSTORE_PASSWORD,
   configDir,
   defaultConfigPath,
@@ -11644,4 +12025,4 @@ export {
 @scure/bip32/lib/esm/index.js:
   (*! scure-bip32 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) *)
 */
-//# sourceMappingURL=chunk-WGR4UZ34.js.map
+//# sourceMappingURL=chunk-R75M6TK6.js.map