@toon-protocol/client-mcp 0.19.0 → 0.20.0

package/dist/{chunk-OGMD7Z2F.js → chunk-HSSJFB3I.js}

@@ -1,19 +1,27 @@
 import { createRequire as __cr } from 'module'; const require = __cr(import.meta.url);
 import {
   __require
-} from "./chunk-CTDRHEDX.js";
+} from "./chunk-SLMGETW7.js";
 import {
   HashMD,
+  rotlBH as rotlBH2,
+  rotlBL as rotlBL2,
+  rotlSH as rotlSH2,
+  rotlSL as rotlSL2,
   sha256 as sha2562,
-  sha512
-} from "./chunk-LR7W2ISE.js";
+  sha512,
+  split as split2
+} from "./chunk-HMD5EVQI.js";
 import {
   hmac
-} from "./chunk-32QD72IL.js";
+} from "./chunk-T3WCTWRP.js";
 import {
+  Hash,
   abytes as abytes3,
+  aexists as aexists2,
   ahash as ahash2,
   anumber as anumber2,
+  aoutput as aoutput2,
   bytesToHex as bytesToHex3,
   checkOpts,
   clean as clean2,
@@ -23,10 +31,13 @@ import {
   hexToBytes as hexToBytes3,
   isBytes as isBytes2,
   kdfInputToBytes,
-  randomBytes as randomBytes2,
+  randomBytes as randomBytes3,
   rotl,
+  swap32IfBE as swap32IfBE2,
+  toBytes,
+  u32 as u322,
   utf8ToBytes
-} from "./chunk-VA7XC4FD.js";
+} from "./chunk-3DDN4CJQ.js";
 import {
   Field,
   aInRange,
@@ -39,6 +50,7 @@ import {
   anumber,
   aoutput,
   asafenumber,
+  asciiToBytes,
   bitLen,
   bitMask,
   bytesToHex,
@@ -62,6 +74,7 @@ import {
   numberToHexUnpadded,
   pow2,
   randomBytes,
+  randomBytes2,
   rotlBH,
   rotlBL,
   rotlSH,
@@ -72,13 +85,13 @@ import {
   u32,
   validateObject,
   wNAF
-} from "./chunk-XQUUFAIM.js";
+} from "./chunk-LN2OF264.js";
 import {
   createBase58check,
   utils
 } from "./chunk-NL7NYWPC.js";
 
-// ../../node_modules/.pnpm/@toon-protocol+core@2.1.0_typescript@5.9.3/node_modules/@toon-protocol/core/dist/chunk-5WT7ISKC.js
+// ../../node_modules/.pnpm/@toon-protocol+core@3.0.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";
@@ -194,7 +207,7 @@ function decodeEventFromToon(data) {
   }
 }
 
-// ../../node_modules/.pnpm/@toon-protocol+core@2.1.0_typescript@5.9.3/node_modules/@toon-protocol/core/dist/index.js
+// ../../node_modules/.pnpm/@toon-protocol+core@3.0.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";
@@ -411,7 +424,7 @@ var Keccak = class _Keccak {
 var genKeccak = (suffix, blockLen, outputLen, info = {}) => createHasher(() => new Keccak(blockLen, suffix, outputLen), info);
 var keccak_256 = /* @__PURE__ */ genKeccak(1, 136, 32);
 
-// ../../node_modules/.pnpm/@toon-protocol+core@2.1.0_typescript@5.9.3/node_modules/@toon-protocol/core/dist/index.js
+// ../../node_modules/.pnpm/@toon-protocol+core@3.0.0_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 WebSocket22 from "ws";
@@ -494,7 +507,7 @@ var hmac2 = /* @__PURE__ */ (() => {
 })();
 
 // ../../node_modules/.pnpm/@noble+curves@2.2.0/node_modules/@noble/curves/abstract/weierstrass.js
-var divNearest = (num, den) => (num + (num >= 0 ? den : -den) / _2n2) / den;
+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;
@@ -600,12 +613,12 @@ var DER = {
   // - add zero byte if exists
   // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
   _int: {
-    encode(num) {
+    encode(num2) {
       const { Err: E } = DER;
-      abignumber(num);
-      if (num < _0n2)
+      abignumber(num2);
+      if (num2 < _0n2)
         throw new E("integer: negative integers are not allowed");
-      let hex = numberToHexUnpadded(num);
+      let hex = numberToHexUnpadded(num2);
       if (Number.parseInt(hex[0], 16) & 8)
         hex = "00" + hex;
       if (hex.length & 1)
@@ -676,7 +689,7 @@ function weierstrass(params, extraOpts = {}) {
     if (!Fp.isOdd)
       throw new Error("compression is not supported: Field does not have .isOdd()");
   }
-  function pointToBytes(_c, point, isCompressed) {
+  function pointToBytes2(_c, point, isCompressed) {
     if (allowInfinityPoint && point.is0())
       return Uint8Array.of(0);
     const { x, y } = point.toAffine();
@@ -727,7 +740,7 @@ function weierstrass(params, extraOpts = {}) {
       throw new Error(`bad point: got length ${length}, expected compressed=${comp} or uncompressed=${uncomp}`);
     }
   }
-  const encodePoint = extraOpts.toBytes === void 0 ? pointToBytes : extraOpts.toBytes;
+  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);
@@ -1100,14 +1113,14 @@ function getWLengths(Fp, Fn) {
 }
 function ecdh(Point2, ecdhOpts = {}) {
   const { Fn } = Point2;
-  const randomBytes_ = ecdhOpts.randomBytes === void 0 ? randomBytes : ecdhOpts.randomBytes;
+  const randomBytes_ = ecdhOpts.randomBytes === void 0 ? randomBytes2 : ecdhOpts.randomBytes;
   const lengths = Object.assign(getWLengths(Point2.Fp, Fn), {
     seed: Math.max(getMinHashLength(Fn.ORDER), 16)
   });
   function isValidSecretKey(secretKey) {
     try {
-      const num = Fn.fromBytes(secretKey);
-      return Fn.isValidNot0(num);
+      const num2 = Fn.fromBytes(secretKey);
+      return Fn.isValidNot0(num2);
     } catch (error) {
       return false;
     }
@@ -1174,7 +1187,7 @@ function ecdsa(Point2, hash, ecdsaOpts = {}) {
     bits2int_modN: "function"
   });
   ecdsaOpts = Object.assign({}, ecdsaOpts);
-  const randomBytes3 = ecdsaOpts.randomBytes === void 0 ? randomBytes : ecdsaOpts.randomBytes;
+  const randomBytes4 = ecdsaOpts.randomBytes === void 0 ? randomBytes2 : ecdsaOpts.randomBytes;
   const hmac3 = ecdsaOpts.hmac === void 0 ? (key2, msg) => hmac2(hash_, key2, msg) : ecdsaOpts.hmac;
   const { Fp, Fn } = Point2;
   const { ORDER: CURVE_ORDER, BITS: fnBits } = Fn;
@@ -1190,10 +1203,10 @@ function ecdsa(Point2, hash, ecdsaOpts = {}) {
     const HALF = CURVE_ORDER >> _1n2;
     return number > HALF;
   }
-  function validateRS(title, num) {
-    if (!Fn.isValidNot0(num))
+  function validateRS(title, num2) {
+    if (!Fn.isValidNot0(num2))
       throw new Error(`invalid signature ${title}: out of range 1..Point.Fn.ORDER`);
-    return num;
+    return num2;
   }
   function assertRecoverableCurve() {
     if (hasLargeRecoveryLifts)
@@ -1295,17 +1308,17 @@ function ecdsa(Point2, hash, ecdsaOpts = {}) {
   const bits2int = ecdsaOpts.bits2int === void 0 ? function bits2int_def(bytes) {
     if (bytes.length > 8192)
       throw new Error("input is too large");
-    const num = bytesToNumberBE(bytes);
+    const num2 = bytesToNumberBE(bytes);
     const delta = bytes.length * 8 - fnBits;
-    return delta > 0 ? num >> BigInt(delta) : num;
+    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(num) {
-    aInRange("num < 2^" + fnBits, num, _0n2, ORDER_MASK);
-    return Fn.toBytes(num);
+  function int2octets(num2) {
+    aInRange("num < 2^" + fnBits, num2, _0n2, ORDER_MASK);
+    return Fn.toBytes(num2);
   }
   function validateMsgAndHash(message, prehash) {
     abytes2(message, void 0, "message");
@@ -1320,7 +1333,7 @@ function ecdsa(Point2, hash, ecdsaOpts = {}) {
       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;
+      const e = extraEntropy === true ? randomBytes4(lengths.secretKey) : extraEntropy;
       seedArgs.push(abytes2(e, void 0, "extraEntropy"));
     }
     const seed = concatBytes(...seedArgs);
@@ -1418,6 +1431,7 @@ var secp256k1_ENDO = {
     [BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"), BigInt("0x3086d221a7d46bcde86c90e49284eb15")]
   ]
 };
+var _0n3 = /* @__PURE__ */ BigInt(0);
 var _2n3 = /* @__PURE__ */ BigInt(2);
 function sqrtMod(y) {
   const P = secp256k1_CURVE.p;
@@ -1447,8 +1461,119 @@ var Pointk1 = /* @__PURE__ */ weierstrass(secp256k1_CURVE, {
   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+core@2.1.0_typescript@5.9.3/node_modules/@toon-protocol/core/dist/index.js
+// ../../node_modules/.pnpm/@toon-protocol+core@3.0.0_typescript@5.9.3/node_modules/@toon-protocol/core/dist/index.js
 import { getPublicKey as getPublicKey5 } from "nostr-tools/pure";
 var ILP_PEER_INFO_KIND = 10032;
 var BLOB_STORAGE_REQUEST_KIND = 5094;
@@ -2152,15 +2277,71 @@ function concatBytes3(...parts) {
   }
   return out;
 }
-function balanceProofHashEvm(channelIdBytes, cumulativeAmount, nonce, recipientBytes) {
+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(
     concatBytes3(
+      EIP712DOMAIN_TYPEHASH,
+      DOMAIN_NAME_HASH,
+      DOMAIN_VERSION_HASH,
+      bigintToBytes32BE(chainId),
+      leftPad32(verifyingContractBytes)
+    )
+  );
+}
+function eip712Digest(domainSeparator, structHash) {
+  return keccak_256(concatBytes3(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(
+    concatBytes3(
+      CLAIM_TYPEHASH,
       channelIdBytes,
       bigintToBytes32BE(cumulativeAmount),
       bigintToBytes32BE(nonce),
-      recipientBytes
+      leftPad32(recipientBytes)
     )
   );
+  return eip712Digest(
+    eip712DomainSeparatorEvm(chainId, verifyingContractBytes),
+    structHash
+  );
 }
 function balanceProofHashSolana(channelId, cumulativeAmount, nonce, recipient) {
   return sha256(
@@ -3407,7 +3588,7 @@ function generateMnemonic(wordlist2, strength = 128) {
   anumber2(strength);
   if (strength % 32 !== 0 || strength > 256)
     throw new TypeError("Invalid entropy");
-  return entropyToMnemonic(randomBytes2(strength / 8), wordlist2);
+  return entropyToMnemonic(randomBytes3(strength / 8), wordlist2);
 }
 var calcChecksum = (entropy) => {
   const bitsLeft = 8 - entropy.length / 4;
@@ -5497,7 +5678,7 @@ zone
 zoo`.split("\n");
 
 // ../../node_modules/.pnpm/@noble+curves@1.9.7/node_modules/@noble/curves/esm/utils.js
-var _0n3 = /* @__PURE__ */ BigInt(0);
+var _0n4 = /* @__PURE__ */ BigInt(0);
 var _1n3 = /* @__PURE__ */ BigInt(1);
 function _abool2(value, title = "") {
   if (typeof value !== "boolean") {
@@ -5518,14 +5699,14 @@ function _abytes2(value, length, title = "") {
   }
   return value;
 }
-function numberToHexUnpadded2(num) {
-  const hex = num.toString(16);
+function numberToHexUnpadded2(num2) {
+  const hex = num2.toString(16);
   return hex.length & 1 ? "0" + hex : hex;
 }
 function hexToNumber(hex) {
   if (typeof hex !== "string")
     throw new Error("hex string expected, got " + typeof hex);
-  return hex === "" ? _0n3 : BigInt("0x" + hex);
+  return hex === "" ? _0n4 : BigInt("0x" + hex);
 }
 function bytesToNumberBE2(bytes) {
   return hexToNumber(bytesToHex3(bytes));
@@ -5558,7 +5739,7 @@ function ensureBytes(title, hex, expectedLength) {
     throw new Error(title + " of length " + expectedLength + " expected, got " + len);
   return res;
 }
-var isPosBig = (n) => typeof n === "bigint" && _0n3 <= n;
+var isPosBig = (n) => typeof n === "bigint" && _0n4 <= n;
 function inRange(n, min, max) {
   return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
 }
@@ -5568,7 +5749,7 @@ function aInRange2(title, n, min, max) {
 }
 function bitLen2(n) {
   let len;
-  for (len = 0; n > _0n3; n >>= _1n3, len += 1)
+  for (len = 0; n > _0n4; n >>= _1n3, len += 1)
     ;
   return len;
 }
@@ -5599,7 +5780,7 @@ function createHmacDrbg2(hashLen, qByteLen, hmacFn) {
     k = h(u8of(1), seed);
     v = h();
   };
-  const gen = () => {
+  const gen2 = () => {
     if (i++ >= 1e3)
       throw new Error("drbg: tried 1000 values");
     let len = 0;
@@ -5616,7 +5797,7 @@ function createHmacDrbg2(hashLen, qByteLen, hmacFn) {
     reset();
     reseed(seed);
     let res = void 0;
-    while (!(res = pred(gen())))
+    while (!(res = pred(gen2())))
       reseed();
     reset();
     return res;
@@ -5650,7 +5831,7 @@ function memoized(fn) {
 }
 
 // ../../node_modules/.pnpm/@noble+curves@1.9.7/node_modules/@noble/curves/esm/abstract/modular.js
-var _0n4 = BigInt(0);
+var _0n5 = BigInt(0);
 var _1n4 = BigInt(1);
 var _2n4 = /* @__PURE__ */ BigInt(2);
 var _3n2 = /* @__PURE__ */ BigInt(3);
@@ -5662,25 +5843,25 @@ var _9n = /* @__PURE__ */ BigInt(9);
 var _16n = /* @__PURE__ */ BigInt(16);
 function mod(a, b) {
   const result = a % b;
-  return result >= _0n4 ? result : b + result;
+  return result >= _0n5 ? result : b + result;
 }
 function pow22(x, power, modulo) {
   let res = x;
-  while (power-- > _0n4) {
+  while (power-- > _0n5) {
     res *= res;
     res %= modulo;
   }
   return res;
 }
 function invert(number, modulo) {
-  if (number === _0n4)
+  if (number === _0n5)
     throw new Error("invert: expected non-zero number");
-  if (modulo <= _0n4)
+  if (modulo <= _0n5)
     throw new Error("invert: expected positive modulus, got " + modulo);
   let a = mod(number, modulo);
   let b = modulo;
-  let x = _0n4, y = _1n4, u = _1n4, v = _0n4;
-  while (a !== _0n4) {
+  let x = _0n5, y = _1n4, u = _1n4, v = _0n5;
+  while (a !== _0n5) {
     const q = b / a;
     const r = b % a;
     const m = x - u * q;
@@ -5739,7 +5920,7 @@ function tonelliShanks(P) {
     throw new Error("sqrt is not defined for small field");
   let Q = P - _1n4;
   let S = 0;
-  while (Q % _2n4 === _0n4) {
+  while (Q % _2n4 === _0n5) {
     Q /= _2n4;
     S++;
   }
@@ -5825,16 +6006,16 @@ function validateField2(field) {
   _validateObject(field, opts);
   return field;
 }
-function FpPow(Fp, num, power) {
-  if (power < _0n4)
+function FpPow(Fp, num2, power) {
+  if (power < _0n5)
     throw new Error("invalid exponent, negatives unsupported");
-  if (power === _0n4)
+  if (power === _0n5)
     return Fp.ONE;
   if (power === _1n4)
-    return num;
+    return num2;
   let p = Fp.ONE;
-  let d = num;
-  while (power > _0n4) {
+  let d = num2;
+  while (power > _0n5) {
     if (power & _1n4)
       p = Fp.mul(p, d);
     d = Fp.sqr(d);
@@ -5844,18 +6025,18 @@ function FpPow(Fp, num, power) {
 }
 function FpInvertBatch2(Fp, nums, passZero = false) {
   const inverted = new Array(nums.length).fill(passZero ? Fp.ZERO : void 0);
-  const multipliedAcc = nums.reduce((acc, num, i) => {
-    if (Fp.is0(num))
+  const multipliedAcc = nums.reduce((acc, num2, i) => {
+    if (Fp.is0(num2))
       return acc;
     inverted[i] = acc;
-    return Fp.mul(acc, num);
+    return Fp.mul(acc, num2);
   }, Fp.ONE);
   const invertedAcc = Fp.inv(multipliedAcc);
-  nums.reduceRight((acc, num, i) => {
-    if (Fp.is0(num))
+  nums.reduceRight((acc, num2, i) => {
+    if (Fp.is0(num2))
       return acc;
     inverted[i] = Fp.mul(acc, inverted[i]);
-    return Fp.mul(acc, num);
+    return Fp.mul(acc, num2);
   }, invertedAcc);
   return inverted;
 }
@@ -5877,7 +6058,7 @@ function nLength(n, nBitLength) {
   return { nBitLength: _nBitLength, nByteLength };
 }
 function Field2(ORDER, bitLenOrOpts, isLE = false, opts = {}) {
-  if (ORDER <= _0n4)
+  if (ORDER <= _0n5)
     throw new Error("invalid field: expected ORDER > 0, got " + ORDER);
   let _nbitLength = void 0;
   let _sqrt = void 0;
@@ -5912,39 +6093,39 @@ function Field2(ORDER, bitLenOrOpts, isLE = false, opts = {}) {
     BITS,
     BYTES,
     MASK: bitMask2(BITS),
-    ZERO: _0n4,
+    ZERO: _0n5,
     ONE: _1n4,
     allowedLengths,
-    create: (num) => mod(num, ORDER),
-    isValid: (num) => {
-      if (typeof num !== "bigint")
-        throw new Error("invalid field element: expected bigint, got " + typeof num);
-      return _0n4 <= num && num < ORDER;
+    create: (num2) => mod(num2, ORDER),
+    isValid: (num2) => {
+      if (typeof num2 !== "bigint")
+        throw new Error("invalid field element: expected bigint, got " + typeof num2);
+      return _0n5 <= num2 && num2 < ORDER;
     },
-    is0: (num) => num === _0n4,
+    is0: (num2) => num2 === _0n5,
     // is valid and invertible
-    isValidNot0: (num) => !f.is0(num) && f.isValid(num),
-    isOdd: (num) => (num & _1n4) === _1n4,
-    neg: (num) => mod(-num, ORDER),
+    isValidNot0: (num2) => !f.is0(num2) && f.isValid(num2),
+    isOdd: (num2) => (num2 & _1n4) === _1n4,
+    neg: (num2) => mod(-num2, ORDER),
     eql: (lhs, rhs) => lhs === rhs,
-    sqr: (num) => mod(num * num, ORDER),
+    sqr: (num2) => mod(num2 * num2, ORDER),
     add: (lhs, rhs) => mod(lhs + rhs, ORDER),
     sub: (lhs, rhs) => mod(lhs - rhs, ORDER),
     mul: (lhs, rhs) => mod(lhs * rhs, ORDER),
-    pow: (num, power) => FpPow(f, num, power),
+    pow: (num2, power) => FpPow(f, num2, power),
     div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),
     // Same as above, but doesn't normalize
-    sqrN: (num) => num * num,
+    sqrN: (num2) => num2 * num2,
     addN: (lhs, rhs) => lhs + rhs,
     subN: (lhs, rhs) => lhs - rhs,
     mulN: (lhs, rhs) => lhs * rhs,
-    inv: (num) => invert(num, ORDER),
+    inv: (num2) => invert(num2, ORDER),
     sqrt: _sqrt || ((n) => {
       if (!sqrtP)
         sqrtP = FpSqrt(ORDER);
       return sqrtP(f, n);
     }),
-    toBytes: (num) => isLE ? numberToBytesLE(num, BYTES) : numberToBytesBE(num, BYTES),
+    toBytes: (num2) => isLE ? numberToBytesLE(num2, BYTES) : numberToBytesBE(num2, BYTES),
     fromBytes: (bytes, skipValidation = true) => {
       if (allowedLengths) {
         if (!allowedLengths.includes(bytes.length) || bytes.length > BYTES) {
@@ -5989,13 +6170,13 @@ function mapHashToField2(key2, fieldOrder, isLE = false) {
   const minLen = getMinHashLength2(fieldOrder);
   if (len < 16 || len < minLen || len > 1024)
     throw new Error("expected " + minLen + "-1024 bytes of input, got " + len);
-  const num = isLE ? bytesToNumberLE(key2) : bytesToNumberBE2(key2);
-  const reduced = mod(num, fieldOrder - _1n4) + _1n4;
+  const num2 = isLE ? bytesToNumberLE(key2) : bytesToNumberBE2(key2);
+  const reduced = mod(num2, fieldOrder - _1n4) + _1n4;
   return isLE ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
 }
 
 // ../../node_modules/.pnpm/@noble+curves@1.9.7/node_modules/@noble/curves/esm/abstract/curve.js
-var _0n5 = BigInt(0);
+var _0n6 = BigInt(0);
 var _1n5 = BigInt(1);
 function negateCt2(condition, item) {
   const neg = item.negate();
@@ -6056,7 +6237,7 @@ function getW(P) {
   return pointWindowSizes.get(P) || 1;
 }
 function assert0(n) {
-  if (n !== _0n5)
+  if (n !== _0n6)
     throw new Error("invalid wNAF");
 }
 var wNAF2 = class {
@@ -6070,7 +6251,7 @@ var wNAF2 = class {
   // non-const time multiplication ladder
   _unsafeLadder(elm, n, p = this.ZERO) {
     let d = elm;
-    while (n > _0n5) {
+    while (n > _0n6) {
       if (n & _1n5)
         p = p.add(d);
       d = d.double();
@@ -6138,7 +6319,7 @@ var wNAF2 = class {
   wNAFUnsafe(W, precomputes, n, acc = this.ZERO) {
     const wo = calcWOpts(W, this.bits);
     for (let window2 = 0; window2 < wo.windows; window2++) {
-      if (n === _0n5)
+      if (n === _0n6)
         break;
       const { nextN, offset, isZero, isNeg } = calcOffsets(n, window2, wo);
       n = nextN;
@@ -6190,7 +6371,7 @@ function mulEndoUnsafe2(Point2, point, k1, k2) {
   let acc = point;
   let p1 = Point2.ZERO;
   let p2 = Point2.ZERO;
-  while (k1 > _0n5 || k2 > _0n5) {
+  while (k1 > _0n6 || k2 > _0n6) {
     if (k1 & _1n5)
       p1 = p1.add(acc);
     if (k2 & _1n5)
@@ -6257,7 +6438,7 @@ function _createCurveFields(type, CURVE, curveOpts = {}, FpFnLE) {
     throw new Error(`expected valid ${type} CURVE object`);
   for (const p of ["p", "n", "h"]) {
     const val = CURVE[p];
-    if (!(typeof val === "bigint" && val > _0n5))
+    if (!(typeof val === "bigint" && val > _0n6))
       throw new Error(`CURVE.${p} must be positive bigint`);
   }
   const Fp = createField(CURVE.p, curveOpts.Fp, FpFnLE);
@@ -6273,21 +6454,21 @@ function _createCurveFields(type, CURVE, curveOpts = {}, FpFnLE) {
 }
 
 // ../../node_modules/.pnpm/@noble+curves@1.9.7/node_modules/@noble/curves/esm/abstract/weierstrass.js
-var divNearest2 = (num, den) => (num + (num >= 0 ? den : -den) / _2n5) / den;
+var divNearest2 = (num2, den) => (num2 + (num2 >= 0 ? den : -den) / _2n5) / den;
 function _splitEndoScalar2(k, basis, n) {
   const [[a1, b1], [a2, b2]] = basis;
   const c1 = divNearest2(b2 * k, n);
   const c2 = divNearest2(-b1 * k, n);
   let k1 = k - c1 * a1 - c2 * a2;
   let k2 = -c1 * b1 - c2 * b2;
-  const k1neg = k1 < _0n6;
-  const k2neg = k2 < _0n6;
+  const k1neg = k1 < _0n7;
+  const k2neg = k2 < _0n7;
   if (k1neg)
     k1 = -k1;
   if (k2neg)
     k2 = -k2;
   const MAX_NUM = bitMask2(Math.ceil(bitLen2(n) / 2)) + _1n6;
-  if (k1 < _0n6 || k1 >= MAX_NUM || k2 < _0n6 || k2 >= MAX_NUM) {
+  if (k1 < _0n7 || k1 >= MAX_NUM || k2 < _0n7 || k2 >= MAX_NUM) {
     throw new Error("splitScalar (endomorphism): failed, k=" + k);
   }
   return { k1neg, k1, k2neg, k2 };
@@ -6373,11 +6554,11 @@ var DER2 = {
   // - add zero byte if exists
   // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
   _int: {
-    encode(num) {
+    encode(num2) {
       const { Err: E } = DER2;
-      if (num < _0n6)
+      if (num2 < _0n7)
         throw new E("integer: negative integers are not allowed");
-      let hex = numberToHexUnpadded2(num);
+      let hex = numberToHexUnpadded2(num2);
       if (Number.parseInt(hex[0], 16) & 8)
         hex = "00" + hex;
       if (hex.length & 1)
@@ -6413,27 +6594,27 @@ var DER2 = {
     return tlv.encode(48, seq);
   }
 };
-var _0n6 = BigInt(0);
+var _0n7 = BigInt(0);
 var _1n6 = BigInt(1);
 var _2n5 = BigInt(2);
 var _3n3 = BigInt(3);
 var _4n3 = BigInt(4);
 function _normFnElement(Fn, key2) {
   const { BYTES: expected } = Fn;
-  let num;
+  let num2;
   if (typeof key2 === "bigint") {
-    num = key2;
+    num2 = key2;
   } else {
     let bytes = ensureBytes("private key", key2);
     try {
-      num = Fn.fromBytes(bytes);
+      num2 = Fn.fromBytes(bytes);
     } catch (error) {
       throw new Error(`invalid private key: expected ui8a of size ${expected}, got ${typeof key2}`);
     }
   }
-  if (!Fn.isValidNot0(num))
+  if (!Fn.isValidNot0(num2))
     throw new Error("invalid private key: out of range [1..N-1]");
-  return num;
+  return num2;
 }
 function weierstrassN(params, extraOpts = {}) {
   const validated = _createCurveFields("weierstrass", params, extraOpts);
@@ -6460,7 +6641,7 @@ function weierstrassN(params, extraOpts = {}) {
     if (!Fp.isOdd)
       throw new Error("compression is not supported: Field does not have .isOdd()");
   }
-  function pointToBytes(_c, point, isCompressed) {
+  function pointToBytes2(_c, point, isCompressed) {
     const { x, y } = point.toAffine();
     const bx = Fp.toBytes(x);
     _abool2(isCompressed, "isCompressed");
@@ -6507,7 +6688,7 @@ function weierstrassN(params, extraOpts = {}) {
       throw new Error(`bad point: got length ${length}, expected compressed=${comp} or uncompressed=${uncomp}`);
     }
   }
-  const encodePoint = extraOpts.toBytes || pointToBytes;
+  const encodePoint = extraOpts.toBytes || pointToBytes2;
   const decodePoint = extraOpts.fromBytes || pointFromBytes;
   function weierstrassEquation(x) {
     const x2 = Fp.sqr(x);
@@ -6787,7 +6968,7 @@ function weierstrassN(params, extraOpts = {}) {
       const p = this;
       if (!Fn.isValid(sc))
         throw new Error("invalid scalar: out of range");
-      if (sc === _0n6 || p.is0())
+      if (sc === _0n7 || p.is0())
         return Point2.ZERO;
       if (sc === _1n6)
         return p;
@@ -6895,7 +7076,7 @@ function getWLengths2(Fp, Fn) {
 }
 function ecdh2(Point2, ecdhOpts = {}) {
   const { Fn } = Point2;
-  const randomBytes_ = ecdhOpts.randomBytes || randomBytes2;
+  const randomBytes_ = ecdhOpts.randomBytes || randomBytes3;
   const lengths = Object.assign(getWLengths2(Point2.Fp, Fn), { seed: getMinHashLength2(Fn.ORDER) });
   function isValidSecretKey(secretKey) {
     try {
@@ -6970,7 +7151,7 @@ function ecdsa2(Point2, hash, ecdsaOpts = {}) {
     bits2int: "function",
     bits2int_modN: "function"
   });
-  const randomBytes3 = ecdsaOpts.randomBytes || randomBytes2;
+  const randomBytes4 = ecdsaOpts.randomBytes || randomBytes3;
   const hmac3 = ecdsaOpts.hmac || ((key2, ...msgs) => hmac(hash, key2, concatBytes2(...msgs)));
   const { Fp, Fn } = Point2;
   const { ORDER: CURVE_ORDER, BITS: fnBits } = Fn;
@@ -6987,10 +7168,10 @@ function ecdsa2(Point2, hash, ecdsaOpts = {}) {
     const HALF = CURVE_ORDER >> _1n6;
     return number > HALF;
   }
-  function validateRS(title, num) {
-    if (!Fn.isValidNot0(num))
+  function validateRS(title, num2) {
+    if (!Fn.isValidNot0(num2))
       throw new Error(`invalid signature ${title}: out of range 1..Point.Fn.ORDER`);
-    return num;
+    return num2;
   }
   function validateSigLength(bytes, format) {
     validateSigFormat2(format);
@@ -7100,17 +7281,17 @@ function ecdsa2(Point2, hash, ecdsaOpts = {}) {
   const bits2int = ecdsaOpts.bits2int || function bits2int_def(bytes) {
     if (bytes.length > 8192)
       throw new Error("input is too large");
-    const num = bytesToNumberBE2(bytes);
+    const num2 = bytesToNumberBE2(bytes);
     const delta = bytes.length * 8 - fnBits;
-    return delta > 0 ? num >> BigInt(delta) : num;
+    return delta > 0 ? num2 >> BigInt(delta) : num2;
   };
   const bits2int_modN = ecdsaOpts.bits2int_modN || function bits2int_modN_def(bytes) {
     return Fn.create(bits2int(bytes));
   };
   const ORDER_MASK = bitMask2(fnBits);
-  function int2octets(num) {
-    aInRange2("num < 2^" + fnBits, num, _0n6, ORDER_MASK);
-    return Fn.toBytes(num);
+  function int2octets(num2) {
+    aInRange2("num < 2^" + fnBits, num2, _0n7, ORDER_MASK);
+    return Fn.toBytes(num2);
   }
   function validateMsgAndHash(message, prehash) {
     _abytes2(message, void 0, "message");
@@ -7125,7 +7306,7 @@ function ecdsa2(Point2, hash, ecdsaOpts = {}) {
     const d = _normFnElement(Fn, privateKey);
     const seedArgs = [int2octets(d), int2octets(h1int)];
     if (extraEntropy != null && extraEntropy !== false) {
-      const e = extraEntropy === true ? randomBytes3(lengths.secretKey) : extraEntropy;
+      const e = extraEntropy === true ? randomBytes4(lengths.secretKey) : extraEntropy;
       seedArgs.push(ensureBytes("extraEntropy", e));
     }
     const seed = concatBytes2(...seedArgs);
@@ -7137,10 +7318,10 @@ function ecdsa2(Point2, hash, ecdsaOpts = {}) {
       const ik = Fn.inv(k);
       const q = Point2.BASE.multiply(k).toAffine();
       const r = Fn.create(q.x);
-      if (r === _0n6)
+      if (r === _0n7)
         return;
       const s = Fn.create(ik * Fn.create(m + r * d));
-      if (s === _0n6)
+      if (s === _0n7)
         return;
       let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n6);
       let normS = s;
@@ -7461,10 +7642,10 @@ function bytesToNumber(bytes) {
   const h = bytes.length === 0 ? "0" : bytesToHex3(bytes);
   return BigInt("0x" + h);
 }
-function numberToBytes(num) {
-  if (typeof num !== "bigint")
+function numberToBytes(num2) {
+  if (typeof num2 !== "bigint")
     throw new Error("bigint expected");
-  return hexToBytes3(num.toString(16).padStart(64, "0"));
+  return hexToBytes3(num2.toString(16).padStart(64, "0"));
 }
 var MASTER_SECRET = utf8ToBytes("Bitcoin seed");
 var BITCOIN_VERSIONS = { private: 76066276, public: 76067358 };
@@ -7712,7 +7893,7 @@ import { toHex as toHex3 } from "viem";
 import { readFileSync, writeFileSync, existsSync } from "fs";
 import { createPublicClient as createPublicClient2, http as http2, defineChain as defineChain2 } from "viem";
 
-// ../../node_modules/.pnpm/@toon-protocol+sdk@2.1.0_mina-signer@3.1.0_typescript@5.9.3/node_modules/@toon-protocol/sdk/dist/chunk-7LBYFU4L.js
+// ../../node_modules/.pnpm/@toon-protocol+sdk@3.0.0_mina-signer@3.1.0_typescript@5.9.3/node_modules/@toon-protocol/sdk/dist/chunk-RAZRWSJF.js
 import { getPublicKey as getPublicKey6 } from "nostr-tools/pure";
 import { generateSecretKey, getPublicKey as getPublicKey22 } from "nostr-tools/pure";
 import { createRumor, createSeal, createWrap } from "nostr-tools/nip59";
@@ -7874,10 +8055,218 @@ function decryptFulfillClaim(params) {
     }
   }
 }
+var STREAM_RECEIPT_VERSION = 1;
+var STREAM_RECEIPT_SIGNING_TAG = "toon.stream-receipt.v1";
+var STREAM_NONCE_REGEX = /^[0-9a-f]{32}$/;
+var SIG_REGEX = /^[0-9a-f]{128}$/;
+var HEX64_REGEX = /^[0-9a-f]{64}$/;
+var DECIMAL_UINT_REGEX = /^(0|[1-9]\d*)$/;
 var RATE_REGEX2 = /^(0|[1-9]\d*)(\.\d+)?$/;
+function isValidStreamNonce(value) {
+  return typeof value === "string" && STREAM_NONCE_REGEX.test(value);
+}
+function parseStreamReceipt(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("receipt must be an object");
+  }
+  const obj = value;
+  if (obj["v"] !== STREAM_RECEIPT_VERSION) {
+    throw new Error(
+      `receipt.v must be ${STREAM_RECEIPT_VERSION}, got ${String(obj["v"])}`
+    );
+  }
+  if (!isValidStreamNonce(obj["streamNonce"])) {
+    throw new Error("receipt.streamNonce must be 32-char lowercase hex");
+  }
+  const seq = obj["seq"];
+  if (typeof seq !== "number" || !Number.isSafeInteger(seq) || seq < 1) {
+    throw new Error("receipt.seq must be a positive safe integer");
+  }
+  const cumulativeDelivered = obj["cumulativeDelivered"];
+  if (typeof cumulativeDelivered !== "string" || !DECIMAL_UINT_REGEX.test(cumulativeDelivered)) {
+    throw new Error(
+      "receipt.cumulativeDelivered must be a non-negative integer decimal string"
+    );
+  }
+  const rate = obj["rate"];
+  if (typeof rate !== "string" || !RATE_REGEX2.test(rate) || /^0(\.0+)?$/.test(rate)) {
+    throw new Error("receipt.rate must be a positive decimal string");
+  }
+  const rateTimestamp = obj["rateTimestamp"];
+  if (typeof rateTimestamp !== "number" || !Number.isInteger(rateTimestamp) || rateTimestamp <= 0) {
+    throw new Error(
+      "receipt.rateTimestamp must be a positive integer (unix ms)"
+    );
+  }
+  const sig = obj["sig"];
+  if (typeof sig !== "string" || !SIG_REGEX.test(sig)) {
+    throw new Error("receipt.sig must be 128-char lowercase hex");
+  }
+  return {
+    v: STREAM_RECEIPT_VERSION,
+    streamNonce: obj["streamNonce"],
+    seq,
+    cumulativeDelivered,
+    rate,
+    rateTimestamp,
+    sig
+  };
+}
+function encodeReceiptSigningPayload(fields) {
+  if (!isValidStreamNonce(fields.streamNonce)) {
+    throw new Error("streamNonce must be 32-char lowercase hex");
+  }
+  const tag = Buffer.from(STREAM_RECEIPT_SIGNING_TAG, "utf8");
+  const cumulative = Buffer.from(fields.cumulativeDelivered, "utf8");
+  const rate = Buffer.from(fields.rate, "utf8");
+  const buf = Buffer.alloc(
+    4 + tag.length + 1 + 16 + 8 + 4 + cumulative.length + 4 + rate.length + 8
+  );
+  let off = 0;
+  buf.writeUInt32BE(tag.length, off);
+  off += 4;
+  tag.copy(buf, off);
+  off += tag.length;
+  buf.writeUInt8(fields.v, off);
+  off += 1;
+  Buffer.from(hexToBytes(fields.streamNonce)).copy(buf, off);
+  off += 16;
+  buf.writeBigUInt64BE(BigInt(fields.seq), off);
+  off += 8;
+  buf.writeUInt32BE(cumulative.length, off);
+  off += 4;
+  cumulative.copy(buf, off);
+  off += cumulative.length;
+  buf.writeUInt32BE(rate.length, off);
+  off += 4;
+  rate.copy(buf, off);
+  off += rate.length;
+  buf.writeBigUInt64BE(BigInt(fields.rateTimestamp), off);
+  return new Uint8Array(buf);
+}
+function verifyStreamReceipt(receipt, makerPubkey) {
+  if (typeof makerPubkey !== "string" || !HEX64_REGEX.test(makerPubkey)) {
+    return false;
+  }
+  if (typeof receipt.sig !== "string" || !SIG_REGEX.test(receipt.sig)) {
+    return false;
+  }
+  try {
+    const { sig: _sig, ...fields } = receipt;
+    const digest = sha256(encodeReceiptSigningPayload(fields));
+    return schnorr.verify(
+      hexToBytes(receipt.sig),
+      digest,
+      hexToBytes(makerPubkey)
+    );
+  } catch {
+    return false;
+  }
+}
+var ReceiptChainTracker = class {
+  #streamNonce;
+  #makerPubkey;
+  /** Verified receipts, kept sorted by ascending seq. */
+  #receipts = [];
+  #seqs = /* @__PURE__ */ new Set();
+  constructor(input) {
+    if (!isValidStreamNonce(input.streamNonce)) {
+      throw new Error("streamNonce must be 32-char lowercase hex");
+    }
+    if (typeof input.makerPubkey !== "string" || !HEX64_REGEX.test(input.makerPubkey)) {
+      throw new Error("makerPubkey must be a 64-char lowercase hex string");
+    }
+    this.#streamNonce = input.streamNonce;
+    this.#makerPubkey = input.makerPubkey;
+  }
+  get streamNonce() {
+    return this.#streamNonce;
+  }
+  /** Number of verified receipts accumulated so far. */
+  get size() {
+    return this.#receipts.length;
+  }
+  /**
+   * Verify + accumulate one receipt. On `{ok: false}` the receipt is NOT
+   * added and the chain is unchanged.
+   */
+  add(receipt) {
+    if (receipt.streamNonce !== this.#streamNonce) {
+      return {
+        ok: false,
+        code: "WRONG_STREAM_NONCE",
+        message: `receipt streamNonce ${receipt.streamNonce} does not match session ${this.#streamNonce}`
+      };
+    }
+    if (!verifyStreamReceipt(receipt, this.#makerPubkey)) {
+      return {
+        ok: false,
+        code: "BAD_SIGNATURE",
+        message: `receipt seq ${receipt.seq} signature does not verify against maker key ${this.#makerPubkey}`
+      };
+    }
+    if (this.#seqs.has(receipt.seq)) {
+      return {
+        ok: false,
+        code: "DUPLICATE_SEQ",
+        message: `duplicate receipt seq ${receipt.seq}`
+      };
+    }
+    let lo = 0;
+    let hi = this.#receipts.length;
+    while (lo < hi) {
+      const mid = lo + hi >>> 1;
+      const midReceipt = this.#receipts[mid];
+      if (midReceipt.seq < receipt.seq) lo = mid + 1;
+      else hi = mid;
+    }
+    const cumulative = BigInt(receipt.cumulativeDelivered);
+    const lower = lo > 0 ? this.#receipts[lo - 1] : void 0;
+    const higher = lo < this.#receipts.length ? this.#receipts[lo] : void 0;
+    if (lower && BigInt(lower.cumulativeDelivered) > cumulative) {
+      return {
+        ok: false,
+        code: "NON_MONOTONIC",
+        message: `receipt seq ${receipt.seq} cumulativeDelivered ${receipt.cumulativeDelivered} is below seq ${lower.seq}'s ${lower.cumulativeDelivered}`
+      };
+    }
+    if (higher && BigInt(higher.cumulativeDelivered) < cumulative) {
+      return {
+        ok: false,
+        code: "NON_MONOTONIC",
+        message: `receipt seq ${receipt.seq} cumulativeDelivered ${receipt.cumulativeDelivered} is above seq ${higher.seq}'s ${higher.cumulativeDelivered}`
+      };
+    }
+    this.#receipts.splice(lo, 0, receipt);
+    this.#seqs.add(receipt.seq);
+    return { ok: true };
+  }
+  /**
+   * Snapshot the accumulated chain: sorted receipts, the superseding latest,
+   * the signed total delivered, and any `seq` holes in `[1, latest.seq]`.
+   */
+  chain() {
+    const receipts = [...this.#receipts];
+    const latest = receipts[receipts.length - 1];
+    const holes = [];
+    if (latest) {
+      for (let seq = 1; seq <= latest.seq; seq++) {
+        if (!this.#seqs.has(seq)) holes.push(seq);
+      }
+    }
+    return {
+      streamNonce: this.#streamNonce,
+      receipts,
+      ...latest !== void 0 && { latest },
+      totalDelivered: latest?.cumulativeDelivered ?? "0",
+      holes
+    };
+  }
+};
+var RATE_REGEX22 = /^(0|[1-9]\d*)(\.\d+)?$/;
 function applyRate(params) {
   const { sourceAmount, fromScale, toScale, rate } = params;
-  if (!RATE_REGEX2.test(rate)) {
+  if (!RATE_REGEX22.test(rate)) {
     throw new SwapHandlerError(`Invalid rate format: ${rate}`);
   }
   if (/^0(\.0+)?$/.test(rate)) {
@@ -7897,8 +8286,8 @@ function applyRate(params) {
   const scaleDown = 10n ** BigInt(fromScale);
   return sourceAmount * rateNumerator * scaleUp / (rateDenominator * scaleDown);
 }
-var RATE_REGEX22 = /^(0|[1-9]\d*)(\.\d+)?$/;
-var HEX64_REGEX = /^[0-9a-f]{64}$/;
+var RATE_REGEX3 = /^(0|[1-9]\d*)(\.\d+)?$/;
+var HEX64_REGEX2 = /^[0-9a-f]{64}$/;
 var BASE64_REGEX = /^[A-Za-z0-9+/]+={0,2}$/;
 function isBase64(s) {
   if (s.length === 0 || s.length % 4 !== 0) return false;
@@ -7934,26 +8323,29 @@ function buildSwapRumor(input) {
     totalPackets,
     nonce,
     createdAt,
-    chainRecipient
+    chainRecipient,
+    streamNonce
   } = input;
+  const tags = [
+    ["swap-from", `${pair.from.assetCode}:${pair.from.chain}`],
+    ["swap-to", `${pair.to.assetCode}:${pair.to.chain}`],
+    ["amount", sourceAmount.toString()],
+    ["seq", String(packetIndex), String(totalPackets)],
+    ["nonce", Buffer.from(nonce).toString("hex")],
+    ["chain-recipient", chainRecipient]
+  ];
+  if (streamNonce !== void 0) tags.push(["stream-nonce", streamNonce]);
   return {
     kind: 20032,
     pubkey: senderPubkey,
     content: "",
     created_at: createdAt,
-    tags: [
-      ["swap-from", `${pair.from.assetCode}:${pair.from.chain}`],
-      ["swap-to", `${pair.to.assetCode}:${pair.to.chain}`],
-      ["amount", sourceAmount.toString()],
-      ["seq", String(packetIndex), String(totalPackets)],
-      ["nonce", Buffer.from(nonce).toString("hex")],
-      ["chain-recipient", chainRecipient]
-    ]
+    tags
   };
 }
 var EVM_CHANNEL_ID_REGEX = /^0x[0-9a-f]{64}$/;
 var EVM_ADDRESS_REGEX = /^0x[0-9a-f]{40}$/;
-var DECIMAL_UINT_REGEX = /^(0|[1-9]\d*)$/;
+var DECIMAL_UINT_REGEX2 = /^(0|[1-9]\d*)$/;
 var BASE58_REGEX = /^[1-9A-HJ-NP-Za-km-z]+$/;
 function validateChainAddress(value, chain, kind) {
   if (chain.startsWith("evm:")) {
@@ -8020,7 +8412,7 @@ function decodeFulfillMetadata(data, chain, opts) {
       "FULFILL metadata.claim is missing or not base64 string"
     );
   }
-  if (typeof ephemeralPubkey !== "string" || !HEX64_REGEX.test(ephemeralPubkey)) {
+  if (typeof ephemeralPubkey !== "string" || !HEX64_REGEX2.test(ephemeralPubkey)) {
     throw new StreamSwapError(
       "FULFILL_DECODE_FAILED",
       "FULFILL metadata.ephemeralPubkey is missing or not 64-char hex"
@@ -8054,7 +8446,7 @@ function decodeFulfillMetadata(data, chain, opts) {
     );
   }
   if (hasRate) {
-    if (typeof tapeRate !== "string" || !RATE_REGEX22.test(tapeRate) || /^0(\.0+)?$/.test(tapeRate)) {
+    if (typeof tapeRate !== "string" || !RATE_REGEX3.test(tapeRate) || /^0(\.0+)?$/.test(tapeRate)) {
       throw new StreamSwapError(
         "FULFILL_DECODE_FAILED",
         "FULFILL metadata.rate must be a positive decimal string"
@@ -8074,16 +8466,27 @@ function decodeFulfillMetadata(data, chain, opts) {
       "FULFILL metadata is missing the quote tape (rate + rateTimestamp) required when minExchangeRate is set"
     );
   }
+  if (obj["receipt"] !== void 0) {
+    try {
+      result.receipt = parseStreamReceipt(obj["receipt"]);
+    } catch (err) {
+      throw new StreamSwapError(
+        "FULFILL_DECODE_FAILED",
+        `FULFILL metadata.receipt is malformed: ${err instanceof Error ? err.message : String(err)}`,
+        { cause: err }
+      );
+    }
+  }
   const channelId = obj["channelId"];
   if (typeof channelId === "string" && (!chain || validateChainAddress(channelId, chain, "channelId"))) {
     result.channelId = channelId;
   }
   const nonce = obj["nonce"];
-  if (typeof nonce === "string" && DECIMAL_UINT_REGEX.test(nonce)) {
+  if (typeof nonce === "string" && DECIMAL_UINT_REGEX2.test(nonce)) {
     result.nonce = nonce;
   }
   const cumulativeAmount = obj["cumulativeAmount"];
-  if (typeof cumulativeAmount === "string" && DECIMAL_UINT_REGEX.test(cumulativeAmount)) {
+  if (typeof cumulativeAmount === "string" && DECIMAL_UINT_REGEX2.test(cumulativeAmount)) {
     result.cumulativeAmount = cumulativeAmount;
   }
   const recipient = obj["recipient"];
@@ -8097,12 +8500,12 @@ function decodeFulfillMetadata(data, chain, opts) {
   return result;
 }
 function compareDecimalRates(a, b) {
-  const split2 = (s) => {
+  const split3 = (s) => {
     const dot = s.indexOf(".");
     return dot === -1 ? { int: s, frac: "" } : { int: s.slice(0, dot), frac: s.slice(dot + 1) };
   };
-  const pa = split2(a);
-  const pb = split2(b);
+  const pa = split3(a);
+  const pb = split3(b);
   const scale = Math.max(pa.frac.length, pb.frac.length);
   const av = BigInt(pa.int + pa.frac.padEnd(scale, "0"));
   const bv = BigInt(pb.int + pb.frac.padEnd(scale, "0"));
@@ -8199,7 +8602,7 @@ function validateParams(params) {
       "senderSecretKey must be a 32-byte Uint8Array"
     );
   }
-  if (typeof params.swapPubkey !== "string" || !HEX64_REGEX.test(params.swapPubkey)) {
+  if (typeof params.swapPubkey !== "string" || !HEX64_REGEX2.test(params.swapPubkey)) {
     throw new StreamSwapError(
       "INVALID_STATE",
       "swapPubkey must be a 64-char lowercase hex string"
@@ -8220,10 +8623,10 @@ function validateParams(params) {
       "pair.to must have { assetCode: string, assetScale: number, chain: string }"
     );
   }
-  if (typeof params.pair.rate !== "string" || !RATE_REGEX22.test(params.pair.rate)) {
+  if (typeof params.pair.rate !== "string" || !RATE_REGEX3.test(params.pair.rate)) {
     throw new StreamSwapError(
       "INVALID_PAIR",
-      `pair.rate must match ${RATE_REGEX22}, got ${params.pair.rate}`
+      `pair.rate must match ${RATE_REGEX3}, got ${params.pair.rate}`
     );
   }
   try {
@@ -8247,15 +8650,27 @@ function validateParams(params) {
     );
   }
   if (params.minExchangeRate !== void 0) {
-    if (typeof params.minExchangeRate !== "string" || !RATE_REGEX22.test(params.minExchangeRate) || /^0(\.0+)?$/.test(params.minExchangeRate)) {
+    if (typeof params.minExchangeRate !== "string" || !RATE_REGEX3.test(params.minExchangeRate) || /^0(\.0+)?$/.test(params.minExchangeRate)) {
       throw new StreamSwapError(
         "INVALID_STATE",
-        `minExchangeRate must be a positive decimal string matching ${RATE_REGEX22}, got ${String(
+        `minExchangeRate must be a positive decimal string matching ${RATE_REGEX3}, got ${String(
           params.minExchangeRate
         )}`
       );
     }
   }
+  if (params.receiptPubkey !== void 0 && (typeof params.receiptPubkey !== "string" || !HEX64_REGEX2.test(params.receiptPubkey))) {
+    throw new StreamSwapError(
+      "INVALID_STATE",
+      "receiptPubkey must be a 64-char lowercase hex string"
+    );
+  }
+  if (params.requireReceipts !== void 0 && typeof params.requireReceipts !== "boolean") {
+    throw new StreamSwapError(
+      "INVALID_STATE",
+      `requireReceipts must be a boolean, got ${String(params.requireReceipts)}`
+    );
+  }
   if (params.packetExpiryMs !== void 0 && (typeof params.packetExpiryMs !== "number" || !Number.isInteger(params.packetExpiryMs) || params.packetExpiryMs <= 0)) {
     throw new StreamSwapError(
       "INVALID_STATE",
@@ -8292,6 +8707,9 @@ function streamSwapControlled(params) {
     rate: params.pair.rate
   });
   const senderPubkey = getPublicKey32(params.senderSecretKey);
+  const streamNonceBytes = new Uint8Array(16);
+  getRandomValues(streamNonceBytes);
+  const streamNonce = Buffer.from(streamNonceBytes).toString("hex");
   let streamState = "running";
   let resumeDeferred = null;
   const controller = {
@@ -8342,6 +8760,7 @@ function streamSwapControlled(params) {
     params,
     frozenPair,
     senderPubkey,
+    streamNonce,
     logger,
     getState,
     setState,
@@ -8351,6 +8770,7 @@ function streamSwapControlled(params) {
     frozenPair,
     schedule,
     senderPubkey,
+    streamNonce,
     logger,
     getState,
     setState,
@@ -8359,7 +8779,15 @@ function streamSwapControlled(params) {
   return { result, controller };
 }
 function buildAndWrapPacket(input) {
-  const { params, pair, senderPubkey, sourceAmount, seq, totalPackets } = input;
+  const {
+    params,
+    pair,
+    senderPubkey,
+    sourceAmount,
+    seq,
+    totalPackets,
+    streamNonce
+  } = input;
   const nonce = new Uint8Array(16);
   getRandomValues(nonce);
   const rumor = buildSwapRumor({
@@ -8370,7 +8798,8 @@ function buildAndWrapPacket(input) {
     totalPackets,
     nonce,
     createdAt: Math.floor(Date.now() / 1e3),
-    chainRecipient: params.chainRecipient
+    chainRecipient: params.chainRecipient,
+    streamNonce
   });
   const packetExpiresAt = params.packetExpiryMs !== void 0 ? new Date(Date.now() + params.packetExpiryMs) : void 0;
   const wrapped = wrapSwapPacketToToon({
@@ -8460,6 +8889,47 @@ async function processAcceptedPacket(ctx, args) {
       return { status: "below-floor" };
     }
   }
+  let verifiedReceipt;
+  if (metadata.receipt !== void 0) {
+    const receipt = metadata.receipt;
+    let failure;
+    if (metadata.rate !== void 0 && receipt.rate !== metadata.rate) {
+      failure = `receipt.rate ${receipt.rate} does not match tape rate ${metadata.rate}`;
+    } else if (metadata.rateTimestamp !== void 0 && receipt.rateTimestamp !== metadata.rateTimestamp) {
+      failure = `receipt.rateTimestamp ${receipt.rateTimestamp} does not match tape rateTimestamp ${metadata.rateTimestamp}`;
+    } else {
+      const added = ctx.receiptTracker.add(receipt);
+      if (!added.ok) failure = `${added.code}: ${added.message}`;
+    }
+    if (failure !== void 0) {
+      logger.warn({
+        event: "stream_swap.receipt_invalid",
+        packetIndex,
+        seq: receipt.seq,
+        error: failure
+      });
+      ctx.rejections.push({
+        packetIndex,
+        sourceAmount,
+        code: "RECEIPT_INVALID",
+        message: `Stream receipt failed verification: ${failure}`
+      });
+      return { status: "receipt-invalid" };
+    }
+    verifiedReceipt = receipt;
+  } else if (params.requireReceipts === true) {
+    logger.warn({
+      event: "stream_swap.receipt_missing",
+      packetIndex
+    });
+    ctx.rejections.push({
+      packetIndex,
+      sourceAmount,
+      code: "RECEIPT_MISSING",
+      message: "FULFILL carried no stream receipt but requireReceipts is set (legacy maker without rfc-0039 receipt support?)"
+    });
+    return { status: "receipt-invalid" };
+  }
   let claimBytes;
   try {
     const ciphertext = new Uint8Array(Buffer.from(metadata.claim, "base64"));
@@ -8535,6 +9005,7 @@ async function processAcceptedPacket(ctx, args) {
     accumulated.rate = metadata.rate;
     accumulated.rateTimestamp = metadata.rateTimestamp;
   }
+  if (verifiedReceipt !== void 0) accumulated.receipt = verifiedReceipt;
   ctx.claims.push(accumulated);
   logger.debug({
     event: "stream_swap.packet_accepted",
@@ -8559,6 +9030,8 @@ async function processAcceptedPacket(ctx, args) {
         rate: metadata.rate,
         rateTimestamp: metadata.rateTimestamp
       },
+      // Issue #84: surface the verified per-fulfill receipt to the callback.
+      ...verifiedReceipt !== void 0 && { receipt: verifiedReceipt },
       state: ctx.getState() === "paused" ? "paused" : ctx.getState() === "stopped" ? "stopped" : "running"
     });
     try {
@@ -8613,10 +9086,13 @@ function finalizeResult(input) {
     cumulativeSource: cumulative.source,
     cumulativeTarget: cumulative.target,
     packetsSent: input.packetsSent,
-    packetsScheduled: input.packetsScheduled
+    packetsScheduled: input.packetsScheduled,
+    // Issue #84: the verified receipt chain — present on abort too,
+    // covering exactly the packets that filled before the halt.
+    receipts: input.ctx.receiptTracker.chain()
   };
 }
-async function runLoop(params, pair, schedule, senderPubkey, logger, getState, setState, waitForResumeOrStop) {
+async function runLoop(params, pair, schedule, senderPubkey, streamNonce, logger, getState, setState, waitForResumeOrStop) {
   const ctx = {
     params,
     pair,
@@ -8625,7 +9101,11 @@ async function runLoop(params, pair, schedule, senderPubkey, logger, getState, s
     claims: [],
     rejections: [],
     errors: [],
-    cumulative: { source: 0n, target: 0n }
+    cumulative: { source: 0n, target: 0n },
+    receiptTracker: new ReceiptChainTracker({
+      streamNonce,
+      makerPubkey: params.receiptPubkey ?? params.swapPubkey
+    })
   };
   let packetsSent = 0;
   let abortReason = "complete";
@@ -8666,7 +9146,8 @@ async function runLoop(params, pair, schedule, senderPubkey, logger, getState, s
         senderPubkey,
         sourceAmount,
         seq: packetIndex + 1,
-        totalPackets
+        totalPackets,
+        streamNonce
       });
     } catch (err) {
       logger.error({
@@ -8729,6 +9210,10 @@ async function runLoop(params, pair, schedule, senderPubkey, logger, getState, s
       abortReason = "below-floor";
       break packetLoop;
     }
+    if (outcome.status === "receipt-invalid") {
+      abortReason = "receipt-invalid";
+      break packetLoop;
+    }
     if (outcome.status === "callback-throw") {
       abortReason = "callback-throw";
       break packetLoop;
@@ -8764,7 +9249,7 @@ function classifyReject(code, message) {
   }
   return "reject";
 }
-async function runAdaptiveLoop(params, pair, senderPubkey, logger, getState, setState, waitForResumeOrStop) {
+async function runAdaptiveLoop(params, pair, senderPubkey, streamNonce, logger, getState, setState, waitForResumeOrStop) {
   const controller = params.controller;
   const ctx = {
     params,
@@ -8774,7 +9259,11 @@ async function runAdaptiveLoop(params, pair, senderPubkey, logger, getState, set
     claims: [],
     rejections: [],
     errors: [],
-    cumulative: { source: 0n, target: 0n }
+    cumulative: { source: 0n, target: 0n },
+    receiptTracker: new ReceiptChainTracker({
+      streamNonce,
+      makerPubkey: params.receiptPubkey ?? params.swapPubkey
+    })
   };
   let packetsSent = 0;
   let abortReason = "complete";
@@ -8841,7 +9330,8 @@ async function runAdaptiveLoop(params, pair, senderPubkey, logger, getState, set
             seq: packetIndex + 1,
             // Adaptive mode: the final packet count is unknown upfront —
             // `0` in the rumor's `seq` tag total position means "open".
-            totalPackets: 0
+            totalPackets: 0,
+            streamNonce
           });
         } catch (err) {
           logger.error({
@@ -8961,6 +9451,14 @@ async function runAdaptiveLoop(params, pair, senderPubkey, logger, getState, set
         });
         halt("below-floor");
         break;
+      case "receipt-invalid":
+        await observeSafe({
+          resolution: "reject",
+          rttMs: settled.rttMs,
+          remaining
+        });
+        halt("receipt-invalid");
+        break;
       case "callback-throw":
         await observeSafe({
           resolution: "fulfill",
@@ -9019,18 +9517,18 @@ function getRandomValues(buf) {
   );
 }
 
-// ../../node_modules/.pnpm/@toon-protocol+sdk@2.1.0_mina-signer@3.1.0_typescript@5.9.3/node_modules/@toon-protocol/sdk/dist/index.js
+// ../../node_modules/.pnpm/@toon-protocol+sdk@3.0.0_mina-signer@3.1.0_typescript@5.9.3/node_modules/@toon-protocol/sdk/dist/index.js
 var SwapControllerError = class extends ToonError {
   constructor(message, cause) {
     super(message, "SWAP_CONTROLLER_ERROR", cause);
     this.name = "SwapControllerError";
   }
 };
-var DECIMAL_UINT_REGEX2 = /^(0|[1-9]\d*)$/;
+var DECIMAL_UINT_REGEX3 = /^(0|[1-9]\d*)$/;
 function isSwapControllerState(value) {
   if (!value || typeof value !== "object") return false;
   const s = value;
-  return s["v"] === 1 && typeof s["delta"] === "string" && DECIMAL_UINT_REGEX2.test(s["delta"]) && typeof s["W"] === "number" && Number.isInteger(s["W"]) && s["W"] >= 1 && typeof s["vEwma"] === "number" && Number.isFinite(s["vEwma"]) && s["vEwma"] >= 0 && typeof s["tauEwma"] === "number" && Number.isFinite(s["tauEwma"]) && s["tauEwma"] >= 0 && typeof s["cleanStreak"] === "number" && Number.isInteger(s["cleanStreak"]) && s["cleanStreak"] >= 0 && typeof s["everShrunk"] === "boolean" && (s["lastWidened"] === "delta" || s["lastWidened"] === "window") && typeof s["updatedAt"] === "number";
+  return s["v"] === 1 && typeof s["delta"] === "string" && DECIMAL_UINT_REGEX3.test(s["delta"]) && typeof s["W"] === "number" && Number.isInteger(s["W"]) && s["W"] >= 1 && typeof s["vEwma"] === "number" && Number.isFinite(s["vEwma"]) && s["vEwma"] >= 0 && typeof s["tauEwma"] === "number" && Number.isFinite(s["tauEwma"]) && s["tauEwma"] >= 0 && typeof s["cleanStreak"] === "number" && Number.isInteger(s["cleanStreak"]) && s["cleanStreak"] >= 0 && typeof s["everShrunk"] === "boolean" && (s["lastWidened"] === "delta" || s["lastWidened"] === "window") && typeof s["updatedAt"] === "number";
 }
 function swapControllerStateKey(params) {
   const { makerPubkey, pair } = params;
@@ -9379,7 +9877,19 @@ var EVM_SETTLEMENT_FUNCTION_SELECTOR = keccak_256(
 var EVM_SETTLEMENT_EVENT_TOPIC = "0x" + bytesToHex(
   keccak_256(new TextEncoder().encode(EVM_SETTLEMENT_EVENT_SIGNATURE))
 );
-function recoverEvmSignerAddress(claim) {
+function recoverEvmSignerAddress(claim, chainId, verifyingContract) {
+  if (typeof chainId !== "number" || !Number.isInteger(chainId) || chainId <= 0) {
+    throw new SettlementTxError(
+      "INVALID_INPUT",
+      `EVM v2 digest requires a positive integer chainId, got ${chainId}`
+    );
+  }
+  if (!verifyingContract) {
+    throw new SettlementTxError(
+      "INVALID_INPUT",
+      "EVM v2 digest requires verifyingContract (RollingSwapChannel address)"
+    );
+  }
   if (claim.channelId === void 0 || claim.cumulativeAmount === void 0 || claim.nonce === void 0 || claim.recipient === void 0) {
     throw new SettlementTxError(
       "MISSING_SETTLEMENT_METADATA",
@@ -9406,6 +9916,7 @@ function recoverEvmSignerAddress(claim) {
   try {
     const channelIdBytes = hexToBytes4(claim.channelId);
     const recipientBytes = hexToBytes4(claim.recipient);
+    const verifyingContractBytes = hexToBytes4(verifyingContract);
     if (channelIdBytes.length !== 32) {
       throw new Error(
         `channelId must be 32 bytes (got ${channelIdBytes.length})`
@@ -9416,11 +9927,18 @@ function recoverEvmSignerAddress(claim) {
         `recipient must be 20 bytes (got ${recipientBytes.length})`
       );
     }
+    if (verifyingContractBytes.length !== 20) {
+      throw new Error(
+        `verifyingContract must be 20 bytes (got ${verifyingContractBytes.length})`
+      );
+    }
     msgHash = balanceProofHashEvm(
       channelIdBytes,
       BigInt(claim.cumulativeAmount),
       BigInt(claim.nonce),
-      recipientBytes
+      recipientBytes,
+      BigInt(chainId),
+      verifyingContractBytes
     );
     const sig = secp256k1.Signature.fromBytes(
       compactRS,
@@ -9594,8 +10112,8 @@ function buildEvmSettlementTx(winner, signer, recipient, selectedClaimIndex, cla
     sourceAssetCode: winner.pair.from.assetCode
   };
 }
-function verifyEvmClaimSignature(claim, expectedAddress) {
-  const recovered = recoverEvmSignerAddress(claim);
+function verifyEvmClaimSignature(claim, expectedAddress, chainId, verifyingContract) {
+  const recovered = recoverEvmSignerAddress(claim, chainId, verifyingContract);
   const expected = expectedAddress.toLowerCase();
   return {
     valid: recovered.toLowerCase() === expected,
@@ -9953,7 +10471,9 @@ function buildSettlementTx(params) {
       try {
         const { valid, recovered } = verifyEvmClaimSignature(
           claim,
-          signer.address
+          signer.address,
+          signer.chainId,
+          signer.contractAddress
         );
         if (!valid) {
           rejected.push({
@@ -10203,10 +10723,18 @@ function buildSettlementTx(params) {
 function verifyAccumulatedClaim(claim, signer, minaSignerClient) {
   const kind = chainKindOf(claim.pair.to.chain);
   if (kind === "evm") {
+    if (typeof signer.chainId !== "number" || !Number.isInteger(signer.chainId) || signer.chainId <= 0 || !signer.contractAddress) {
+      return {
+        valid: false,
+        reason: "INVALID_INPUT: EVM signer requires chainId (positive integer) + contractAddress for the v2 EIP-712 digest (connector#324 finding #1)"
+      };
+    }
     try {
       const { valid, recovered } = verifyEvmClaimSignature(
         claim,
-        signer.address
+        signer.address,
+        signer.chainId,
+        signer.contractAddress
       );
       if (valid) return { valid: true };
       return {
@@ -10269,6 +10797,192 @@ import {
 } from "viem";
 import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync } from "fs";
 import { dirname } from "path";
+import {
+  hashTypedData
+} from "viem";
+
+// ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/sha3.js
+var _0n8 = BigInt(0);
+var _1n7 = BigInt(1);
+var _2n7 = BigInt(2);
+var _7n3 = BigInt(7);
+var _256n2 = BigInt(256);
+var _0x71n2 = BigInt(113);
+var SHA3_PI2 = [];
+var SHA3_ROTL2 = [];
+var _SHA3_IOTA2 = [];
+for (let round = 0, R = _1n7, x = 1, y = 0; round < 24; round++) {
+  [x, y] = [y, (2 * x + 3 * y) % 5];
+  SHA3_PI2.push(2 * (5 * y + x));
+  SHA3_ROTL2.push((round + 1) * (round + 2) / 2 % 64);
+  let t = _0n8;
+  for (let j = 0; j < 7; j++) {
+    R = (R << _1n7 ^ (R >> _7n3) * _0x71n2) % _256n2;
+    if (R & _2n7)
+      t ^= _1n7 << (_1n7 << /* @__PURE__ */ BigInt(j)) - _1n7;
+  }
+  _SHA3_IOTA2.push(t);
+}
+var IOTAS2 = split2(_SHA3_IOTA2, true);
+var SHA3_IOTA_H2 = IOTAS2[0];
+var SHA3_IOTA_L2 = IOTAS2[1];
+var rotlH2 = (h, l, s) => s > 32 ? rotlBH2(h, l, s) : rotlSH2(h, l, s);
+var rotlL2 = (h, l, s) => s > 32 ? rotlBL2(h, l, s) : rotlSL2(h, l, s);
+function keccakP2(s, rounds = 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 = rotlH2(B0, B1, 1) ^ B[idx1];
+      const Tl = rotlL2(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_ROTL2[t];
+      const Th = rotlH2(curH, curL, shift);
+      const Tl = rotlL2(curH, curL, shift);
+      const PI = SHA3_PI2[t];
+      curH = s[PI];
+      curL = s[PI + 1];
+      s[PI] = Th;
+      s[PI + 1] = Tl;
+    }
+    for (let y = 0; y < 50; y += 10) {
+      for (let x = 0; x < 10; x++)
+        B[x] = s[y + x];
+      for (let x = 0; x < 10; x++)
+        s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+    }
+    s[0] ^= SHA3_IOTA_H2[round];
+    s[1] ^= SHA3_IOTA_L2[round];
+  }
+  clean2(B);
+}
+var Keccak2 = class _Keccak extends Hash {
+  // NOTE: we accept arguments in bytes instead of bits here.
+  constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+    super();
+    this.pos = 0;
+    this.posOut = 0;
+    this.finished = false;
+    this.destroyed = false;
+    this.enableXOF = false;
+    this.blockLen = blockLen;
+    this.suffix = suffix;
+    this.outputLen = outputLen;
+    this.enableXOF = enableXOF;
+    this.rounds = rounds;
+    anumber2(outputLen);
+    if (!(0 < blockLen && blockLen < 200))
+      throw new Error("only keccak-f1600 function is supported");
+    this.state = new Uint8Array(200);
+    this.state32 = u322(this.state);
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  keccak() {
+    swap32IfBE2(this.state32);
+    keccakP2(this.state32, this.rounds);
+    swap32IfBE2(this.state32);
+    this.posOut = 0;
+    this.pos = 0;
+  }
+  update(data) {
+    aexists2(this);
+    data = toBytes(data);
+    abytes3(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) {
+    aexists2(this, false);
+    abytes3(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) {
+    anumber2(bytes);
+    return this.xofInto(new Uint8Array(bytes));
+  }
+  digestInto(out) {
+    aoutput2(out, this);
+    if (this.finished)
+      throw new Error("digest() was already called");
+    this.writeInto(out);
+    this.destroy();
+    return out;
+  }
+  digest() {
+    return this.digestInto(new Uint8Array(this.outputLen));
+  }
+  destroy() {
+    this.destroyed = true;
+    clean2(this.state);
+  }
+  _cloneInto(to) {
+    const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+    to || (to = new _Keccak(blockLen, suffix, outputLen, enableXOF, rounds));
+    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.destroyed = this.destroyed;
+    return to;
+  }
+};
+var gen = (suffix, blockLen, outputLen) => createHasher2(() => new Keccak2(blockLen, suffix, outputLen));
+var keccak_2562 = /* @__PURE__ */ (() => gen(1, 136, 256 / 8))();
+
+// ../client/dist/index.js
 import { finalizeEvent as finalizeEvent22 } from "nostr-tools/pure";
 import { nip19 } from "nostr-tools";
 import { getPublicKey as getPublicKey33 } from "nostr-tools/pure";
@@ -10360,9 +11074,9 @@ function deriveEvmIdentity(secretKey) {
   };
 }
 async function deriveSolanaKey(seed, accountIndex = 0) {
-  const { hmac: hmac3 } = await import("./hmac-CMZORX4Y.js");
-  const { sha512: sha5122 } = await import("./sha512-4LOCATJH.js");
-  const { ed25519: ed255194 } = await import("./ed25519-U4PTEOFD.js");
+  const { hmac: hmac3 } = await import("./hmac-GNBDA4UC.js");
+  const { sha512: sha5122 } = await import("./sha512-D7TTPT7I.js");
+  const { ed25519: ed255194 } = await import("./ed25519-VBPL32VX.js");
   const encoder = new TextEncoder();
   let I = hmac3(sha5122, encoder.encode("ed25519 seed"), seed);
   let key2 = I.slice(0, 32);
@@ -10452,12 +11166,12 @@ async function deriveFullIdentity(mnemonic, accountIndex = 0) {
 }
 var BASE58_ALPHABET3 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
 function toBase58(bytes) {
-  let num = BigInt(0);
-  for (const b of bytes) num = num * 256n + BigInt(b);
+  let num2 = BigInt(0);
+  for (const b of bytes) num2 = num2 * 256n + BigInt(b);
   let result = "";
-  while (num > 0n) {
-    result = BASE58_ALPHABET3[Number(num % 58n)] + result;
-    num = num / 58n;
+  while (num2 > 0n) {
+    result = BASE58_ALPHABET3[Number(num2 % 58n)] + result;
+    num2 = num2 / 58n;
   }
   for (const b of bytes) {
     if (b === 0) result = "1" + result;
@@ -11454,7 +12168,7 @@ var IsomorphicBtpClient = class {
 };
 var CONDITION_LENGTH = 32;
 function mintExecutionCondition() {
-  const preimage = randomBytes2(CONDITION_LENGTH);
+  const preimage = randomBytes3(CONDITION_LENGTH);
   return { preimage, condition: sha2562(preimage) };
 }
 function isZeroCondition(condition) {
@@ -14493,8 +15207,8 @@ var Http402Client = class {
       ...opts.timeout !== void 0 ? { signal: AbortSignal.timeout(opts.timeout) } : {}
     });
     if (probe.status !== 402) return probe;
-    const challenge = await parseX402Challenge(probe.clone());
-    const accept = challenge.toonChannel;
+    const challenge2 = await parseX402Challenge(probe.clone());
+    const accept = challenge2.toonChannel;
     if (!accept || !this.resolveClaim) return probe;
     return this.payOverToon(url, method, opts, accept, this.resolveClaim);
   }
@@ -14774,6 +15488,7 @@ function buildSwapSettlements(params) {
         claims: [entryToAccumulatedClaim(entry)],
         signers: { [entry.chain]: signer },
         recipients: { [entry.chain]: entry.recipient },
+        ...params.verifySignatures !== void 0 ? { verifySignatures: params.verifySignatures } : {},
         ...params.minaSignerClient ? { minaSignerClient: params.minaSignerClient } : {}
       });
       const firstRejected = result.rejected[0];
@@ -14821,7 +15536,9 @@ function decodeEvmSettlementTx(bundle) {
   const chainIdHex = fields[6];
   const chainId = Number.parseInt(chainIdHex === "0x" ? "0x0" : chainIdHex, 16);
   if (typeof to !== "string" || to.length !== 42) {
-    throw new Error(`settlement tx "to" is not a 20-byte address: ${String(to)}`);
+    throw new Error(
+      `settlement tx "to" is not a 20-byte address: ${String(to)}`
+    );
   }
   return { to, data: data === "0x" ? "0x" : data, chainId };
 }
@@ -14838,7 +15555,10 @@ async function submitEvmSettlement(bundle, params) {
     nativeCurrency: { name: "ETH", symbol: "ETH", decimals: 18 },
     rpcUrls: { default: { http: [params.rpcUrl] } }
   });
-  const publicClient = createPublicClient3({ chain, transport: http3(params.rpcUrl) });
+  const publicClient = createPublicClient3({
+    chain,
+    transport: http3(params.rpcUrl)
+  });
   const [nonce, gasPrice, gas] = await Promise.all([
     publicClient.getTransactionCount({
       address: params.account.address,
@@ -16237,6 +16957,85 @@ function fromJson(entry) {
     ...entry.settleTxHash !== void 0 ? { settleTxHash: entry.settleTxHash } : {}
   };
 }
+var ROLLING_SWAP_DOMAIN_NAME = "RollingSwapChannel";
+var ROLLING_SWAP_DOMAIN_VERSION = "2";
+var CLAIM_TYPES = {
+  ClaimBalanceProof: [
+    { name: "channelId", type: "bytes32" },
+    { name: "cumulativeAmount", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "recipient", type: "address" }
+  ]
+};
+function normalizeAddress(addr) {
+  return addr.toLowerCase();
+}
+function domainOf(ctx) {
+  return {
+    name: ROLLING_SWAP_DOMAIN_NAME,
+    version: ROLLING_SWAP_DOMAIN_VERSION,
+    chainId: ctx.chainId,
+    verifyingContract: normalizeAddress(ctx.verifyingContract)
+  };
+}
+function evmClaimDigest(ctx, message) {
+  return hashTypedData({
+    domain: domainOf(ctx),
+    types: CLAIM_TYPES,
+    primaryType: "ClaimBalanceProof",
+    message: {
+      channelId: message.channelId,
+      cumulativeAmount: message.cumulativeAmount,
+      nonce: message.nonce,
+      recipient: normalizeAddress(message.recipient)
+    }
+  });
+}
+var SIG_BYTES = 65;
+function signatureToBytes(sig) {
+  if (typeof sig !== "string") return sig;
+  const hex = sig.startsWith("0x") ? sig.slice(2) : sig;
+  return hexToBytes3(hex);
+}
+function recoverEvmClaimSigner(ctx, message, signature) {
+  const bytes = signatureToBytes(signature);
+  if (bytes.length !== SIG_BYTES) {
+    throw new Error(
+      `EVM signature must be 65 bytes (r||s||v), got ${bytes.length}`
+    );
+  }
+  const v = bytes[64];
+  if (v !== 27 && v !== 28) {
+    throw new Error(`EVM signature v must be 27 or 28, got ${v}`);
+  }
+  const digest = evmClaimDigest(ctx, message).slice(2);
+  const recovered = secp256k1.Signature.fromBytes(bytes.slice(0, 64), "compact").addRecoveryBit(v - 27).recoverPublicKey(hexToBytes3(digest));
+  const uncompressed = recovered.toBytes(false);
+  const addrHash = keccak_2562(uncompressed.slice(1));
+  return `0x${bytesToHex3(addrHash.slice(-20))}`;
+}
+function verifyEvmClaimSignature2(params) {
+  let recovered;
+  try {
+    recovered = recoverEvmClaimSigner(
+      params.ctx,
+      params.message,
+      params.signature
+    );
+  } catch (err) {
+    return {
+      valid: false,
+      reason: `SIGNATURE_INVALID: ${err instanceof Error ? err.message : String(err)}`
+    };
+  }
+  if (recovered.toLowerCase() !== params.expectedSigner.toLowerCase()) {
+    return {
+      valid: false,
+      reason: `SIGNER_MISMATCH: recovered ${recovered}, expected ${params.expectedSigner}`
+    };
+  }
+  return { valid: true, recovered };
+}
 function hasSettlementMetadata(claim) {
   return claim.channelId !== void 0 && claim.nonce !== void 0 && claim.cumulativeAmount !== void 0 && claim.recipient !== void 0 && claim.swapSignerAddress !== void 0;
 }
@@ -16291,11 +17090,49 @@ function ingestReceivedClaims(params) {
       continue;
     }
     const expectedSigner = params.expectedSignerAddress ?? claim.swapSignerAddress;
-    const sig = verifyAccumulatedClaim(
-      claim,
-      { address: expectedSigner },
-      params.minaSignerClient
-    );
+    let sig;
+    if (chain.startsWith("evm")) {
+      const chainId = parseEvmChainId2(chain);
+      const verifyingContract = params.tokenNetworks?.[chain];
+      if (chainId === void 0 || !verifyingContract) {
+        reject(
+          claim,
+          "MISSING_CHAIN_CONFIG",
+          `EVM v2 balance-proof verification for ${chain} needs a numeric chain id in the chain key AND tokenNetworks["${chain}"] (the RollingSwapChannel / verifyingContract) to reconstruct the EIP-712 domain; supply it from the connector/swap session context.`
+        );
+        continue;
+      }
+      let msgNonce;
+      let msgCumulative;
+      try {
+        msgNonce = BigInt(claim.nonce);
+        msgCumulative = BigInt(claim.cumulativeAmount);
+      } catch {
+        reject(
+          claim,
+          "MALFORMED_METADATA",
+          `nonce "${claim.nonce}" / cumulativeAmount "${claim.cumulativeAmount}" are not decimal integers`
+        );
+        continue;
+      }
+      sig = verifyEvmClaimSignature2({
+        ctx: { chainId, verifyingContract },
+        message: {
+          channelId: claim.channelId,
+          cumulativeAmount: msgCumulative,
+          nonce: msgNonce,
+          recipient: claim.recipient
+        },
+        signature: claim.claimBytes,
+        expectedSigner
+      });
+    } else {
+      sig = verifyAccumulatedClaim(
+        claim,
+        { address: expectedSigner },
+        params.minaSignerClient
+      );
+    }
     if (!sig.valid) {
       reject(claim, signatureRejectionCode(sig.reason), sig.reason);
       continue;
@@ -17220,4 +18057,4 @@ export {
 @scure/bip32/lib/esm/index.js:
   (*! scure-bip32 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) *)
 */
-//# sourceMappingURL=chunk-OGMD7Z2F.js.map
+//# sourceMappingURL=chunk-HSSJFB3I.js.map