thunder-bridge 2.2.1 → 3.0.1

package/dist/index.js

@@ -125,9 +125,9 @@ function fillSchedule(schedule, reader, block) {
     schedule[at] = reader.getUint32(block + at * 4, false);
   }
   for (let at = 16; at < SCHEDULE_WORDS; at++) {
-    const recent2 = schedule[at - 15];
+    const recent = schedule[at - 15];
     const distant = schedule[at - 2];
-    const mixedRecent = rotate(recent2, 7) ^ rotate(recent2, 18) ^ recent2 >>> 3;
+    const mixedRecent = rotate(recent, 7) ^ rotate(recent, 18) ^ recent >>> 3;
     const mixedDistant = rotate(distant, 17) ^ rotate(distant, 19) ^ distant >>> 10;
     schedule[at] = schedule[at - 16] + mixedRecent + schedule[at - 7] + mixedDistant | 0;
   }
@@ -382,7 +382,7 @@ async function sealFor(purpose, secret, plaintext, { stable = false } = {}) {
 }
 async function unsealFor(purpose, secret, sealed) {
   if (!sealed.startsWith(`${PURPOSE_VERSION}.`)) {
-    return await unseal(secret, sealed);
+    return null;
   }
   return await opened(
     await keyFor(secret, `${INFO}/${purpose}`),
@@ -925,13 +925,187 @@ function asBuffer2(bytes) {
   return bytes.buffer instanceof ArrayBuffer ? bytes : new Uint8Array(bytes);
 }
 
-// ../core/caller.ts
-var KEY_HEADER = "x-client-key";
-var SIGNATURE_HEADER = "x-signature";
-var TIMESTAMP_HEADER = "x-timestamp";
-var NONCE_HEADER = "x-nonce";
-var PREFIX = "ed25519=";
+// ../core/signature.ts
+import {
+  parseDictionary,
+  serializeDictionary,
+  serializeInnerList,
+  serializeString
+} from "structured-headers";
+var TOLERANCE_SECS = 300;
+var LABEL = "thunder-bridge";
+var ALGORITHM2 = "ed25519";
 var NONCE_BYTES = 16;
+var SIGNATURE_BYTES2 = 64;
+var PUBLIC_KEY = /^[0-9a-f]{64}$/i;
+var CLIENT_SIGNS = {
+  tag: "thunder-bridge-client",
+  covers: ["@method", "@authority", "@path", "@query", "content-digest"]
+};
+var GATEWAY_SIGNS = {
+  tag: "thunder-bridge-gateway",
+  covers: ["@method", "@scheme", "@authority", "@path", "content-digest"]
+};
+function contentDigest(body) {
+  return serializeDictionary({
+    "sha-256": [Uint8Array.from(sha256(new TextEncoder().encode(body))), /* @__PURE__ */ new Map()]
+  });
+}
+function signatureBase(message, covered) {
+  const lines = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const [name, parameters] of covered[0]) {
+    if (typeof name !== "string" || parameters.size > 0 || seen.has(name)) {
+      return null;
+    }
+    seen.add(name);
+    const value = componentValue(message, name);
+    if (value === null) {
+      return null;
+    }
+    lines.push(`${serializeString(name)}: ${value}`);
+  }
+  lines.push(`"@signature-params": ${serializeInnerList(covered)}`);
+  return lines.join("\n");
+}
+async function signedBy(key, profile, message, body, { created = unixNow(), nonce = randomNonce() } = {}) {
+  const digest = contentDigest(body);
+  const covered = [
+    profile.covers.map((name) => [name, /* @__PURE__ */ new Map()]),
+    /* @__PURE__ */ new Map([
+      ["created", created],
+      ["nonce", nonce],
+      ["keyid", key.publicKeyHex],
+      ["alg", ALGORITHM2],
+      ["tag", profile.tag]
+    ])
+  ];
+  const base = signatureBase(
+    { ...message, headers: new Headers({ "content-digest": digest }) },
+    covered
+  );
+  if (base === null) {
+    throw new Error(`${message.url} cannot be signed as ${profile.tag}`);
+  }
+  const signature = Uint8Array.from(hexToBytes(await key.sign(new TextEncoder().encode(base))));
+  return {
+    "content-digest": digest,
+    "signature-input": serializeDictionary(/* @__PURE__ */ new Map([[LABEL, covered]])),
+    signature: serializeDictionary(/* @__PURE__ */ new Map([[LABEL, [signature, /* @__PURE__ */ new Map()]]]))
+  };
+}
+async function signerOf(message, body, profile, toleranceSecs = TOLERANCE_SECS) {
+  const found = chosen(message.headers, profile.tag);
+  if (found === null) {
+    return null;
+  }
+  const [components, parameters] = found.covered;
+  const named = components.map(([name]) => name);
+  if (!profile.covers.every((name) => named.includes(name))) {
+    return null;
+  }
+  const keyid = parameters.get("keyid");
+  const created = parameters.get("created");
+  const nonce = parameters.get("nonce");
+  const alg = parameters.get("alg");
+  if (typeof keyid !== "string" || !PUBLIC_KEY.test(keyid)) {
+    return null;
+  }
+  if (typeof created !== "number" || !Number.isInteger(created)) {
+    return null;
+  }
+  if (Math.abs(unixNow() - created) > toleranceSecs) {
+    return null;
+  }
+  if (alg !== void 0 && alg !== ALGORITHM2 || nonce !== void 0 && typeof nonce !== "string") {
+    return null;
+  }
+  if (!digestMatches(message.headers.get("content-digest"), body)) {
+    return null;
+  }
+  const base = signatureBase(message, found.covered);
+  if (base === null) {
+    return null;
+  }
+  const signer = keyid.toLowerCase();
+  const proven = await verifyHex(
+    signer,
+    bytesToHex(found.signature),
+    new TextEncoder().encode(base)
+  );
+  return proven ? { keyid: signer, created, nonce: nonce ?? null } : null;
+}
+function componentValue(message, name) {
+  let url;
+  try {
+    url = new URL(message.url);
+  } catch {
+    return null;
+  }
+  switch (name) {
+    case "@method":
+      return message.method;
+    case "@authority":
+      return (message.authority ?? url.host).toLowerCase();
+    case "@scheme":
+      return url.protocol.slice(0, -1).toLowerCase();
+    case "@path":
+      return url.pathname === "" ? "/" : url.pathname;
+    case "@query":
+      return url.search === "" ? "?" : url.search;
+    default:
+      return name.startsWith("@") ? null : message.headers.get(name)?.trim() ?? null;
+  }
+}
+function chosen(headers, tag) {
+  const inputs = dictionaryOf(headers.get("signature-input"));
+  const signatures = dictionaryOf(headers.get("signature"));
+  if (inputs === null || signatures === null) {
+    return null;
+  }
+  for (const [label, member] of inputs) {
+    if (!isInnerList(member) || member[1].get("tag") !== tag) {
+      continue;
+    }
+    const value = signatures.get(label);
+    if (value === void 0 || isInnerList(value) || !(value[0] instanceof ArrayBuffer)) {
+      return null;
+    }
+    const signature = new Uint8Array(value[0]);
+    return signature.length === SIGNATURE_BYTES2 ? { covered: member, signature } : null;
+  }
+  return null;
+}
+function digestMatches(field, body) {
+  const digest = dictionaryOf(field)?.get("sha-256");
+  if (digest === void 0 || isInnerList(digest) || !(digest[0] instanceof ArrayBuffer)) {
+    return false;
+  }
+  const sent = new Uint8Array(digest[0]);
+  const counted = sha256(new TextEncoder().encode(body));
+  return sent.length === counted.length && sent.every((byte, at) => byte === counted[at]);
+}
+function dictionaryOf(field) {
+  if (field === null) {
+    return null;
+  }
+  try {
+    return parseDictionary(field);
+  } catch {
+    return null;
+  }
+}
+function isInnerList(member) {
+  return Array.isArray(member[0]);
+}
+function randomNonce() {
+  return bytesToHex(crypto.getRandomValues(new Uint8Array(NONCE_BYTES)));
+}
+function unixNow() {
+  return Math.floor(Date.now() / 1e3);
+}
+
+// ../core/caller.ts
 var SIGNING_LABEL = "request-signing";
 async function callerKey(secret) {
   return await signingKeyFromSeed(hexToBytes(await hmacHex(secret, SIGNING_LABEL)));
@@ -940,20 +1114,11 @@ function paymentNamedBy(caller, paymentHash) {
   return sha256Hex(`${caller}.payment-id.${paymentHash}`);
 }
 async function signedAs(key, method, path, body, host) {
-  const timestamp = String(Math.floor(Date.now() / 1e3));
-  const nonce = bytesToHex(crypto.getRandomValues(new Uint8Array(NONCE_BYTES)));
-  return {
-    [KEY_HEADER]: key.publicKeyHex,
-    [TIMESTAMP_HEADER]: timestamp,
-    [NONCE_HEADER]: nonce,
-    [SIGNATURE_HEADER]: `${PREFIX}${await key.sign(spokenTo(host, timestamp, nonce, method, path, body))}`
-  };
-}
-function spokenTo(host, timestamp, nonce, method, path, body) {
-  return new TextEncoder().encode(
-    ["v2", host.toLowerCase(), timestamp, nonce, method.toUpperCase(), path, sha256Hex(body)].join(
-      "\n"
-    )
+  return await signedBy(
+    key,
+    CLIENT_SIGNS,
+    { method, url: `https://${host}${path}`, authority: host },
+    body
   );
 }
 
@@ -1135,14 +1300,23 @@ async function addressesToReach(url) {
   return found;
 }
 async function resolved(url) {
-  const { isIP } = await import("net");
+  const { isIP } = await import(
+    /* webpackIgnore: true */
+    "node:net"
+  );
   const host = new URL(url).hostname.replace(/^\[|]$/g, "");
   const literal = isIP(host);
   if (literal !== 0) {
     return [{ address: host, family: literal }];
   }
-  const { Resolver } = await import("dns/promises");
-  const { setTimeout: sleep } = await import("timers/promises");
+  const { Resolver } = await import(
+    /* webpackIgnore: true */
+    "node:dns/promises"
+  );
+  const { setTimeout: sleep } = await import(
+    /* webpackIgnore: true */
+    "node:timers/promises"
+  );
   const resolver = new Resolver({ timeout: LOOKUP_TIMEOUT_MS, tries: 1 });
   const found = await Promise.race([
     Promise.all([
@@ -1229,6 +1403,7 @@ var NoWalletAvailable = class extends Error {
 
 // ../core/lnurl.ts
 var VERIFY_WITHOUT_PREIMAGE = ["zeuspay.com", "zeusnuts.com", "ecash.love"];
+var NAMES_AN_ADDRESS = ["text/identifier", "text/email"];
 var RESOLVE_TIMEOUT_MS = 3e4;
 var NAMES_ONE_ACCOUNT = /^[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*$/;
 var MIN_PACE_SECS = 1;
@@ -1290,6 +1465,12 @@ async function probe(send, address, amountMsat, deadline) {
   if (pay.tag !== "payRequest" || !pay.callback) {
     throw new WalletRefused("unreachable", `${address} answered with no payRequest`);
   }
+  if (!namesTheAddress(pay.metadata, address)) {
+    throw new WalletRefused(
+      "cannot-prove-delivery",
+      `${address} serves metadata that does not name it, so no invoice binds to it`
+    );
+  }
   if (amountMsat < pay.minSendable || amountMsat > pay.maxSendable) {
     throw new WalletRefused(
       "amount-not-accepted",
@@ -1382,6 +1563,19 @@ function ceilingAskedFor(headers) {
   }
   return Math.min(Math.max(perWindow / window, MIN_PER_SECOND), MAX_PER_SECOND);
 }
+function namesTheAddress(metadata, address) {
+  if (typeof metadata !== "string") {
+    return false;
+  }
+  try {
+    const entries = JSON.parse(metadata);
+    return Array.isArray(entries) && entries.some(
+      (entry) => Array.isArray(entry) && NAMES_AN_ADDRESS.includes(entry[0]) && typeof entry[1] === "string" && entry[1].toLowerCase() === address.toLowerCase()
+    );
+  } catch {
+    return false;
+  }
+}
 function cannotReleaseAPreimage(host) {
   const lowered = host.toLowerCase();
   return VERIFY_WITHOUT_PREIMAGE.some(
@@ -1430,8 +1624,14 @@ var pinnedToTheAddressWeVerified = async (url, sent, signal, at) => {
   if (first === void 0) {
     throw new Error(`${url} resolved to nothing worth connecting to`);
   }
-  const { request } = await import("https");
-  const { Readable } = await import("stream");
+  const { request } = await import(
+    /* webpackIgnore: true */
+    "node:https"
+  );
+  const { Readable } = await import(
+    /* webpackIgnore: true */
+    "node:stream"
+  );
   return new Promise((settle, fail) => {
     if (signal.aborted) {
       fail(signal.reason);
@@ -1496,18 +1696,9 @@ function headersOf(raw) {
   return headers;
 }
 
-// ../core/delivery.ts
-function deliverySigned(url, timestamp, body) {
-  const endpoint = new URL(url);
-  return new TextEncoder().encode(
-    ["v2", `${endpoint.origin}${endpoint.pathname}`, timestamp, body].join("\n")
-  );
-}
-
 // src/verify.ts
 var HTTP_TIMEOUT_MS2 = 15e3;
 var ISSUED_SKEW_SECS = 300;
-var NAMES_AN_ADDRESS = ["text/identifier", "text/email"];
 var DEFAULT_WRAP_PROPORTION = 0.01;
 var DEFAULT_WRAP_BASE_MSAT = 1e3;
 async function proveOrigin(payment, asked, askedAt) {
@@ -1554,16 +1745,6 @@ async function proveOrigin(payment, asked, askedAt) {
     throw cheat("invoice_settled");
   }
 }
-function namesTheAddress(metadata, address) {
-  try {
-    const entries = JSON.parse(metadata);
-    return Array.isArray(entries) && entries.some(
-      (entry) => Array.isArray(entry) && NAMES_AN_ADDRESS.includes(entry[0]) && typeof entry[1] === "string" && equalIgnoringCase(entry[1], address)
-    );
-  } catch {
-    return false;
-  }
-}
 async function proveSettlement(payment, asked) {
   await proveOrigin(payment, asked);
   const verified = await reachable(payment.verifyUrl, payment);
@@ -1587,7 +1768,6 @@ function agreesWithItself(report) {
   }
   return preimageMatchesHash(report.preimage, report.paymentHash);
 }
-var carriesProof = agreesWithItself;
 function wrapFeeCeiling(amountMsat, allowance) {
   const proportional = amountMsat * (allowance?.proportion ?? DEFAULT_WRAP_PROPORTION);
   return msat(Math.max(allowance?.baseMsat ?? DEFAULT_WRAP_BASE_MSAT, Math.floor(proportional)));
@@ -1869,10 +2049,6 @@ function isStatus(value) {
 }
 
 // src/webhook.ts
-var SIGNATURE_HEADER2 = "x-signature-v2";
-var TIMESTAMP_HEADER2 = "x-timestamp";
-var GATEWAY_KEY_PREFIX = "ed25519=";
-var DEFAULT_TOLERANCE_SECS = 300;
 var CHALLENGE = "webhook-challenge";
 var VERIFY_CHALLENGE = "verify-challenge";
 async function readPayment(request, credential, options = {}) {
@@ -1896,24 +2072,14 @@ async function answerVerifyChallenge(request) {
   return nonce === null ? null : answered2(nonce);
 }
 async function believable(request, credential, options) {
-  const signature = request.headers.get(SIGNATURE_HEADER2);
-  const timestamp = request.headers.get(TIMESTAMP_HEADER2);
-  if (signature === null || timestamp === null) {
-    return null;
-  }
-  if (!recent(timestamp, options.toleranceSecs ?? DEFAULT_TOLERANCE_SECS)) {
-    return null;
-  }
-  if (!signature.startsWith(GATEWAY_KEY_PREFIX)) {
-    return null;
-  }
   const body = await request.clone().text();
-  const signed = await verifyHex(
-    credential.publicKey.toLowerCase(),
-    signature.slice(GATEWAY_KEY_PREFIX.length).toLowerCase(),
-    deliverySigned(options.url ?? request.url, timestamp, body)
+  const signer = await signerOf(
+    { method: request.method, url: options.url ?? request.url, headers: request.headers },
+    body,
+    GATEWAY_SIGNS,
+    options.toleranceSecs
   );
-  return signed ? body : null;
+  return signer !== null && signer.keyid === credential.publicKey.toLowerCase() ? body : null;
 }
 function proved(read) {
   return read !== null && read.status === "paid" && !agreesWithItself(read) ? null : read;
@@ -1941,13 +2107,6 @@ function nonceOf2(text3, type) {
     return null;
   }
 }
-function recent(timestamp, toleranceSecs) {
-  const sent = Number(timestamp);
-  if (!Number.isFinite(sent)) {
-    return false;
-  }
-  return Math.abs(Math.floor(Date.now() / 1e3) - sent) <= toleranceSecs;
-}
 
 // src/bank.ts
 var DEFAULT_CURRENCY = "CZK";
@@ -2026,7 +2185,7 @@ async function answeredAt(params, subject) {
   return polling.toString();
 }
 async function creditedPreimage(params) {
-  const since = unixNow() - (params.lookBackSecs ?? DEFAULT_LOOK_BACK_SECS);
+  const since = unixNow2() - (params.lookBackSecs ?? DEFAULT_LOOK_BACK_SECS);
   const landed = (await params.statement(since)).some((credit) => pays(credit, params.asked));
   if (!landed) {
     return null;
@@ -2124,7 +2283,7 @@ function refuseUnusable(params, iban, currency) {
 function accountOf(iban) {
   return iban.replace(/\s+/g, "").toUpperCase();
 }
-function unixNow() {
+function unixNow2() {
   return Math.floor(Date.now() / 1e3);
 }
 
@@ -2560,6 +2719,19 @@ function nwcRail(gateway, config) {
 // src/relay.ts
 var DEFAULT_POLL_EVERY_SECS3 = 5;
 var WALLET = "w";
+function verifiedThrough(path) {
+  const through = path.verifyThrough ?? null;
+  const mints = path.gatewayMints === true;
+  if (through !== null && mints) {
+    throw new Error("verifyThrough and gatewayMints are two different paths, name only one");
+  }
+  if (through === null && !mints) {
+    throw new Error(
+      "name verifyThrough, where your serve.lightningVerify is mounted, or gatewayMints: true to let the gateway mint and poll the wallet itself"
+    );
+  }
+  return through;
+}
 function lightningVerifyEndpoint(config) {
   const paced = {
     "cache-control": `max-age=${config.pollEverySecs ?? DEFAULT_POLL_EVERY_SECS3}`
@@ -2638,6 +2810,10 @@ function bankRail(gateway, config) {
   };
 }
 function lightningRail(gateway, config) {
+  const through = verifiedThrough(config);
+  return through === null ? mintedByGateway(gateway, config) : resolvedHere(gateway, config, through);
+}
+function mintedByGateway(gateway, config) {
   return async (order) => {
     const payment = await gateway.mint(
       {
@@ -2661,21 +2837,20 @@ function lightningRail(gateway, config) {
     };
   };
 }
-function blindLightningRail(gateway, config) {
+function resolvedHere(gateway, config, through) {
   return async (order) => {
     const resolved2 = await invoiceFrom(
       config.paidTo,
       await msatForOrder(order, config.amount, config.rate),
       config.send
     );
-    const relay = config.relayThrough;
     const watched = await gateway.watch({
       paymentHash: resolved2.paymentHash,
-      verifyUrl: relay ? await relayedVerifyUrl(
-        relay.endpoint,
+      verifyUrl: await relayedVerifyUrl(
+        through.endpoint,
         { url: resolved2.verifyUrl, hash: resolved2.paymentHash },
-        relay.secret
-      ) : resolved2.verifyUrl,
+        through.secret
+      ),
       expiresAt: resolved2.expiresAt,
       trigger: config.trigger,
       replay: config.replay,
@@ -2718,16 +2893,12 @@ var Rails = class {
     this.gateway = gateway;
   }
   gateway;
-  /** Lightning, with the gateway minting against a priority list of addresses */
-  lightning(config) {
-    return lightningRail(this.gateway, config);
-  }
   /**
-   * Lightning, with the invoice resolved here so the gateway is told neither the
-   * address nor the amount
+   * Lightning against a priority list of addresses, verified through your
+   * `serve.lightningVerify`, or minted by the gateway when you say `gatewayMints`
    */
-  blindLightning(config) {
-    return blindLightningRail(this.gateway, config);
+  lightning(config) {
+    return lightningRail(this.gateway, config);
   }
   /** A bank transfer, proved the way a Lightning payment is */
   bank(config) {
@@ -2793,11 +2964,12 @@ function waitingOf(options) {
 // src/trigger.ts
 var NONCE_BYTES3 = 16;
 function lnurlPayEndpoint(gateway, config) {
+  const through = verifiedThrough(config);
   return async (request) => {
     const url = new URL(request.url);
     const asked = url.searchParams.get("to");
     try {
-      return asked === null ? await offer(gateway, config, url) : await mint(gateway, config, url, asked);
+      return asked === null ? await offer(gateway, config, through, url) : await mint(gateway, config, through, url, asked);
     } catch (failure) {
       return refuse(failure instanceof Error ? failure.message : "the trigger could not be served");
     }
@@ -2815,10 +2987,10 @@ function watchTicketEndpoint(gateway, config) {
 function publicWatchTicketEndpoint(gateway, config) {
   return () => issue(gateway, config);
 }
-async function offer(gateway, config, url) {
+async function offer(gateway, config, through, url) {
   const { least, most } = await spread(config.amount);
-  const winner = await quoted(gateway, config, least);
-  const nonce = randomNonce();
+  const winner = await quoted(gateway, config, through, least);
+  const nonce = randomNonce2();
   const callback = new URL(config.baseUrl ?? `${url.origin}${url.pathname}`);
   callback.searchParams.set("to", winner.address);
   callback.searchParams.set("least", String(least));
@@ -2833,8 +3005,8 @@ async function offer(gateway, config, url) {
     maxSendable: most
   });
 }
-async function quoted(gateway, config, amountMsat) {
-  if (config.blind) {
+async function quoted(gateway, config, through, amountMsat) {
+  if (through !== null) {
     const { won } = await quote(
       config.send ?? pinnedToTheAddressWeVerified,
       listed(config.paidTo),
@@ -2860,7 +3032,7 @@ async function spread(amount) {
   }
   return { least, most };
 }
-async function mint(gateway, config, url, address) {
+async function mint(gateway, config, through, url, address) {
   const least = Number(url.searchParams.get("least"));
   const most = Number(url.searchParams.get("most"));
   const nonce = url.searchParams.get("n") ?? "";
@@ -2879,7 +3051,7 @@ async function mint(gateway, config, url, address) {
       least === most ? `this trigger costs exactly ${least} msat` : `this trigger takes between ${least} and ${most} msat`
     );
   }
-  const minted = config.blind ? await mintBlind(gateway, config, address, amountMsat) : await mintThroughGateway(gateway, config, address, amountMsat, nonce);
+  const minted = through === null ? await mintThroughGateway(gateway, config, address, amountMsat, nonce) : await mintHere(gateway, config, through, address, amountMsat);
   return Response.json({
     status: "OK",
     pr: minted.bolt11,
@@ -2894,7 +3066,7 @@ async function mintThroughGateway(gateway, config, address, amountMsat, nonce) {
   );
   return { bolt11: payment.bolt11, verifyUrl: payment.verifyUrl };
 }
-async function mintBlind(gateway, config, address, amountMsat) {
+async function mintHere(gateway, config, through, address, amountMsat) {
   const resolved2 = await resolve(
     config.send ?? pinnedToTheAddressWeVerified,
     [address],
@@ -2902,15 +3074,14 @@ async function mintBlind(gateway, config, address, amountMsat) {
   );
   const minted = { ...resolved2, amountMsat, lnAddress: resolved2.address };
   const locked = config.sealed;
-  const relay = config.relayThrough;
   try {
     await gateway.watch({
       paymentHash: resolved2.paymentHash,
-      verifyUrl: relay ? await relayedVerifyUrl(
-        relay.endpoint,
+      verifyUrl: await relayedVerifyUrl(
+        through.endpoint,
         { url: resolved2.verifyUrl, hash: resolved2.paymentHash },
-        relay.secret
-      ) : resolved2.verifyUrl,
+        through.secret
+      ),
       expiresAt: resolved2.expiresAt,
       trigger: config.watchSecret,
       replay: config.replay,
@@ -2932,7 +3103,7 @@ function alreadyWatched(refused) {
 function sign(secret, address, least, most, nonce) {
   return hmacHex(secret, `lnurl-callback|${address}|${least}|${most}|${nonce}`);
 }
-function randomNonce() {
+function randomNonce2() {
   const bytes = crypto.getRandomValues(new Uint8Array(NONCE_BYTES3));
   let hex = "";
   for (const byte of bytes) {
@@ -2986,14 +3157,6 @@ var Serve = class {
   lightningVerify(config) {
     return lightningVerifyEndpoint(config);
   }
-  /**
-   * What `lightningVerify` was called before 2.2.0
-   *
-   * @deprecated Use `lightningVerify`, beside `bankVerify` and `nwcVerify`
-   */
-  verify(config) {
-    return this.lightningVerify(config);
-  }
   /** The verify endpoint a bank rail is polled at, answering off your own statement */
   bankVerify(config) {
     return bankVerifyEndpoint(config);
@@ -3015,7 +3178,7 @@ var Serve = class {
    */
   webhook(handlers) {
     const options = { toleranceSecs: handlers.toleranceSecs, url: handlers.url };
-    const once = onceWhileReplayable(handlers.toleranceSecs ?? DEFAULT_TOLERANCE_SECS);
+    const once = onceWhileReplayable(handlers.toleranceSecs ?? TOLERANCE_SECS);
     return async (request) => {
       const credential = await this.credential(handlers);
       const challenge = await answerWebhookChallenge(request, credential, options);
@@ -3865,7 +4028,6 @@ export {
   WrapRefusedError,
   agreesWithItself,
   answerVerifyChallenge,
-  carriesProof,
   decodeInvoice,
   fiat,
   invoiceFrom,