thunder-bridge 0.8.6 → 0.8.9

package/dist/index.js

@@ -1215,9 +1215,155 @@ function minorScaleOf(currency) {
   return 10 ** minorUnitsOf(currency);
 }
 
+// ../core/ed25519.ts
+var ALGORITHM = { name: "Ed25519" };
+var SIGNATURE_BYTES = 64;
+var PUBLIC_KEY_BYTES = 32;
+var PKCS8_HEADER = hexToBytes("302e020100300506032b657004220420");
+async function verifyHex(publicKeyHex, signatureHex, payload) {
+  if (!isHex(publicKeyHex) || publicKeyHex.length !== PUBLIC_KEY_BYTES * 2) return false;
+  if (!isHex(signatureHex) || signatureHex.length !== SIGNATURE_BYTES * 2) return false;
+  try {
+    const key = await crypto.subtle.importKey(
+      "raw",
+      asBuffer2(hexToBytes(publicKeyHex)),
+      ALGORITHM,
+      false,
+      ["verify"]
+    );
+    return await crypto.subtle.verify(
+      ALGORITHM,
+      key,
+      asBuffer2(hexToBytes(signatureHex)),
+      asBuffer2(payload)
+    );
+  } catch {
+    return false;
+  }
+}
+function asBuffer2(bytes) {
+  return bytes.buffer instanceof ArrayBuffer ? bytes : new Uint8Array(bytes);
+}
+
+// src/webhook.ts
+var SIGNATURE_HEADER = "x-signature";
+var TIMESTAMP_HEADER = "x-timestamp";
+var SHARED_SECRET_PREFIX = "sha256=";
+var GATEWAY_KEY_PREFIX = "ed25519=";
+var DEFAULT_TOLERANCE_SECS = 300;
+var CHALLENGE = "webhook-challenge";
+var VERIFY_CHALLENGE = "verify-challenge";
+async function verifyWebhookSignature(body, signature, credential, timestamp, options = {}) {
+  if (!recent(timestamp, options.toleranceSecs ?? DEFAULT_TOLERANCE_SECS)) return false;
+  if (typeof credential !== "string") {
+    if (!signature.startsWith(GATEWAY_KEY_PREFIX)) return false;
+    return verifyHex(
+      credential.publicKey.toLowerCase(),
+      signature.slice(GATEWAY_KEY_PREFIX.length).toLowerCase(),
+      signed(timestamp, body)
+    );
+  }
+  if (signature.startsWith(GATEWAY_KEY_PREFIX)) return false;
+  const received = signature.startsWith(SHARED_SECRET_PREFIX) ? signature.slice(SHARED_SECRET_PREFIX.length) : signature;
+  return equalInConstantTime(await sign(credential, timestamp, body), received.toLowerCase());
+}
+async function parseWebhook(body, signature, credential, timestamp, options = {}) {
+  if (!await verifyWebhookSignature(body, signature, credential, timestamp, options)) return null;
+  const text2 = typeof body === "string" ? body : new TextDecoder().decode(body);
+  try {
+    return paymentFromWire(JSON.parse(text2));
+  } catch {
+    return null;
+  }
+}
+async function parseWebhookRequest(request, credential, options = {}) {
+  const signature = request.headers.get(SIGNATURE_HEADER);
+  const timestamp = request.headers.get(TIMESTAMP_HEADER);
+  if (signature === null || timestamp === null) return null;
+  return parseWebhook(await request.text(), signature, credential, timestamp, options);
+}
+async function parseWatchedWebhook(body, signature, credential, timestamp, options = {}) {
+  if (!await verifyWebhookSignature(body, signature, credential, timestamp, options)) return null;
+  const text2 = typeof body === "string" ? body : new TextDecoder().decode(body);
+  try {
+    return triggerEventFromWire(JSON.parse(text2));
+  } catch {
+    return null;
+  }
+}
+async function parseWatchedWebhookRequest(request, credential, options = {}) {
+  const signature = request.headers.get(SIGNATURE_HEADER);
+  const timestamp = request.headers.get(TIMESTAMP_HEADER);
+  if (signature === null || timestamp === null) return null;
+  return parseWatchedWebhook(await request.text(), signature, credential, timestamp, options);
+}
+async function answerWebhookChallenge(body, signature, credential, timestamp, options = {}) {
+  if (!await verifyWebhookSignature(body, signature, credential, timestamp, options)) return null;
+  const text2 = typeof body === "string" ? body : new TextDecoder().decode(body);
+  const nonce = challenged(text2);
+  if (nonce === null) return null;
+  if (typeof credential !== "string") return JSON.stringify({ nonce });
+  return JSON.stringify({
+    nonce,
+    signature: `${SHARED_SECRET_PREFIX}${await hmacHex(credential, nonce)}`
+  });
+}
+async function answerWebhookChallengeRequest(request, credential, options = {}) {
+  const signature = request.headers.get(SIGNATURE_HEADER);
+  const timestamp = request.headers.get(TIMESTAMP_HEADER);
+  if (signature === null || timestamp === null) return null;
+  const answer = await answerWebhookChallenge(
+    await request.clone().text(),
+    signature,
+    credential,
+    timestamp,
+    options
+  );
+  return answer === null ? null : new Response(answer, { headers: { "content-type": "application/json" } });
+}
+function challenged(text2) {
+  return nonceOf(text2, CHALLENGE);
+}
+function nonceOf(text2, type) {
+  try {
+    const said = JSON.parse(text2);
+    if (said["type"] !== type || typeof said["nonce"] !== "string") return null;
+    return said["nonce"];
+  } catch {
+    return null;
+  }
+}
+function answerVerifyChallenge(body) {
+  const nonce = nonceOf(body, VERIFY_CHALLENGE);
+  return nonce === null ? null : JSON.stringify({ nonce });
+}
+async function answerVerifyChallengeRequest(request) {
+  if (request.method !== "POST") return null;
+  const answer = answerVerifyChallenge(await request.clone().text());
+  return answer === null ? null : new Response(answer, { headers: { "content-type": "application/json" } });
+}
+function recent(timestamp, toleranceSecs) {
+  const sent = Number(timestamp);
+  if (!Number.isFinite(sent)) return false;
+  return Math.abs(Math.floor(Date.now() / 1e3) - sent) <= toleranceSecs;
+}
+async function sign(secret, timestamp, body) {
+  return hmacHex(secret, signed(timestamp, body));
+}
+function signed(timestamp, body) {
+  const encoder = new TextEncoder();
+  const stamp = encoder.encode(`${timestamp}.`);
+  const rest = typeof body === "string" ? encoder.encode(body) : new Uint8Array(body);
+  const payload = new Uint8Array(stamp.length + rest.length);
+  payload.set(stamp);
+  payload.set(rest, stamp.length);
+  return payload;
+}
+
 // src/bank.ts
 var DEFAULT_CURRENCY = "CZK";
 var DEFAULT_LOOK_BACK_SECS = 7 * 24 * 60 * 60;
+var DEFAULT_POLL_EVERY_SECS = 30;
 var IBAN = /^[A-Z]{2}[0-9]{2}[0-9A-Z]{8,30}$/;
 var FORBIDDEN_IN_SPD = "*";
 async function bankTransfer(params) {
@@ -1244,7 +1390,12 @@ async function bankTransfer(params) {
   return { id: watched.id, paymentHash: watched.paymentHash, verifyUrl, spd };
 }
 function bankVerifyEndpoint(config) {
+  const paced = {
+    "cache-control": `max-age=${config.pollEverySecs ?? DEFAULT_POLL_EVERY_SECS}`
+  };
   return async (request) => {
+    const consented = await answerVerifyChallengeRequest(request);
+    if (consented !== null) return consented;
     const asked = readQuery(new URL(request.url));
     if (asked === null) return Response.json({ settled: false }, { status: 400 });
     const subject = subjectOf(asked.reference, asked.amountMinor, asked.currency);
@@ -1254,11 +1405,11 @@ function bankVerifyEndpoint(config) {
     }
     const since = unixNow() - (config.lookBackSecs ?? DEFAULT_LOOK_BACK_SECS);
     const landed = (await config.statement(since)).some((credit) => pays(credit, asked));
-    if (!landed) return Response.json({ settled: false });
-    return Response.json({
-      settled: true,
-      preimage: await hmacHex(config.secret, `preimage|${subject}`)
-    });
+    if (!landed) return Response.json({ settled: false }, { headers: paced });
+    return Response.json(
+      { settled: true, preimage: await hmacHex(config.secret, `preimage|${subject}`) },
+      { headers: paced }
+    );
   };
 }
 function readQuery(url) {
@@ -1715,138 +1866,6 @@ function refusals2(answers) {
     (answer) => answer.reason instanceof Error ? answer.reason.message : String(answer.reason)
   ).join("; ");
 }
-
-// ../core/ed25519.ts
-var ALGORITHM = { name: "Ed25519" };
-var SIGNATURE_BYTES = 64;
-var PUBLIC_KEY_BYTES = 32;
-var PKCS8_HEADER = hexToBytes("302e020100300506032b657004220420");
-async function verifyHex(publicKeyHex, signatureHex, payload) {
-  if (!isHex(publicKeyHex) || publicKeyHex.length !== PUBLIC_KEY_BYTES * 2) return false;
-  if (!isHex(signatureHex) || signatureHex.length !== SIGNATURE_BYTES * 2) return false;
-  try {
-    const key = await crypto.subtle.importKey(
-      "raw",
-      asBuffer2(hexToBytes(publicKeyHex)),
-      ALGORITHM,
-      false,
-      ["verify"]
-    );
-    return await crypto.subtle.verify(
-      ALGORITHM,
-      key,
-      asBuffer2(hexToBytes(signatureHex)),
-      asBuffer2(payload)
-    );
-  } catch {
-    return false;
-  }
-}
-function asBuffer2(bytes) {
-  return bytes.buffer instanceof ArrayBuffer ? bytes : new Uint8Array(bytes);
-}
-
-// src/webhook.ts
-var SIGNATURE_HEADER = "x-signature";
-var TIMESTAMP_HEADER = "x-timestamp";
-var SHARED_SECRET_PREFIX = "sha256=";
-var GATEWAY_KEY_PREFIX = "ed25519=";
-var DEFAULT_TOLERANCE_SECS = 300;
-var CHALLENGE = "webhook-challenge";
-async function verifyWebhookSignature(body, signature, credential, timestamp, options = {}) {
-  if (!recent(timestamp, options.toleranceSecs ?? DEFAULT_TOLERANCE_SECS)) return false;
-  if (typeof credential !== "string") {
-    if (!signature.startsWith(GATEWAY_KEY_PREFIX)) return false;
-    return verifyHex(
-      credential.publicKey.toLowerCase(),
-      signature.slice(GATEWAY_KEY_PREFIX.length).toLowerCase(),
-      signed(timestamp, body)
-    );
-  }
-  if (signature.startsWith(GATEWAY_KEY_PREFIX)) return false;
-  const received = signature.startsWith(SHARED_SECRET_PREFIX) ? signature.slice(SHARED_SECRET_PREFIX.length) : signature;
-  return equalInConstantTime(await sign(credential, timestamp, body), received.toLowerCase());
-}
-async function parseWebhook(body, signature, credential, timestamp, options = {}) {
-  if (!await verifyWebhookSignature(body, signature, credential, timestamp, options)) return null;
-  const text2 = typeof body === "string" ? body : new TextDecoder().decode(body);
-  try {
-    return paymentFromWire(JSON.parse(text2));
-  } catch {
-    return null;
-  }
-}
-async function parseWebhookRequest(request, credential, options = {}) {
-  const signature = request.headers.get(SIGNATURE_HEADER);
-  const timestamp = request.headers.get(TIMESTAMP_HEADER);
-  if (signature === null || timestamp === null) return null;
-  return parseWebhook(await request.text(), signature, credential, timestamp, options);
-}
-async function parseWatchedWebhook(body, signature, credential, timestamp, options = {}) {
-  if (!await verifyWebhookSignature(body, signature, credential, timestamp, options)) return null;
-  const text2 = typeof body === "string" ? body : new TextDecoder().decode(body);
-  try {
-    return triggerEventFromWire(JSON.parse(text2));
-  } catch {
-    return null;
-  }
-}
-async function parseWatchedWebhookRequest(request, credential, options = {}) {
-  const signature = request.headers.get(SIGNATURE_HEADER);
-  const timestamp = request.headers.get(TIMESTAMP_HEADER);
-  if (signature === null || timestamp === null) return null;
-  return parseWatchedWebhook(await request.text(), signature, credential, timestamp, options);
-}
-async function answerWebhookChallenge(body, signature, credential, timestamp, options = {}) {
-  if (!await verifyWebhookSignature(body, signature, credential, timestamp, options)) return null;
-  const text2 = typeof body === "string" ? body : new TextDecoder().decode(body);
-  const nonce = challenged(text2);
-  if (nonce === null) return null;
-  if (typeof credential !== "string") return JSON.stringify({ nonce });
-  return JSON.stringify({
-    nonce,
-    signature: `${SHARED_SECRET_PREFIX}${await hmacHex(credential, nonce)}`
-  });
-}
-async function answerWebhookChallengeRequest(request, credential, options = {}) {
-  const signature = request.headers.get(SIGNATURE_HEADER);
-  const timestamp = request.headers.get(TIMESTAMP_HEADER);
-  if (signature === null || timestamp === null) return null;
-  const answer = await answerWebhookChallenge(
-    await request.clone().text(),
-    signature,
-    credential,
-    timestamp,
-    options
-  );
-  return answer === null ? null : new Response(answer, { headers: { "content-type": "application/json" } });
-}
-function challenged(text2) {
-  try {
-    const said = JSON.parse(text2);
-    if (said["type"] !== CHALLENGE || typeof said["nonce"] !== "string") return null;
-    return said["nonce"];
-  } catch {
-    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;
-}
-async function sign(secret, timestamp, body) {
-  return hmacHex(secret, signed(timestamp, body));
-}
-function signed(timestamp, body) {
-  const encoder = new TextEncoder();
-  const stamp = encoder.encode(`${timestamp}.`);
-  const rest = typeof body === "string" ? encoder.encode(body) : new Uint8Array(body);
-  const payload = new Uint8Array(stamp.length + rest.length);
-  payload.set(stamp);
-  payload.set(rest, stamp.length);
-  return payload;
-}
 export {
   GatewayCheatError,
   IDEMPOTENCY_KEY_REUSED,
@@ -1858,6 +1877,8 @@ export {
   REQUEST_IN_FLIGHT,
   ThunderBridge,
   UnverifiedRecipientError,
+  answerVerifyChallenge,
+  answerVerifyChallengeRequest,
   answerWebhookChallenge,
   answerWebhookChallengeRequest,
   bankRail,

package/dist/{rail-CdKeyVGn.d.cts → rail-J8QoYbSr.d.cts}

@@ -362,6 +362,16 @@ interface BlindLightningRailConfig {
     sealed?: (order: Order) => string | Promise<string>;
     webhookUrl?: string;
     webhookSecret?: string;
+    /**
+     * Where your own `lightningVerifyEndpoint` is mounted, and the secret it
+     * unseals with. Set both and the gateway is handed your URL rather than the
+     * wallet's, so it polls you, never a third party, and learns nothing about
+     * which provider the recipient uses. Leave them out and it polls the wallet
+     */
+    relayVerifyThrough?: {
+        endpoint: string;
+        secret: string;
+    };
     /** What `Leg.rail` reads, for a shop running more than one wallet */
     name?: string;
 }

package/dist/{rail-CdKeyVGn.d.ts → rail-J8QoYbSr.d.ts}

@@ -362,6 +362,16 @@ interface BlindLightningRailConfig {
     sealed?: (order: Order) => string | Promise<string>;
     webhookUrl?: string;
     webhookSecret?: string;
+    /**
+     * Where your own `lightningVerifyEndpoint` is mounted, and the secret it
+     * unseals with. Set both and the gateway is handed your URL rather than the
+     * wallet's, so it polls you, never a third party, and learns nothing about
+     * which provider the recipient uses. Leave them out and it polls the wallet
+     */
+    relayVerifyThrough?: {
+        endpoint: string;
+        secret: string;
+    };
     /** What `Leg.rail` reads, for a shop running more than one wallet */
     name?: string;
 }

package/dist/server.cjs

@@ -31,7 +31,9 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var server_exports = {};
 __export(server_exports, {
   blindLightningRail: () => blindLightningRail,
-  lnurlPayEndpoint: () => lnurlPayEndpoint
+  lightningVerifyEndpoint: () => lightningVerifyEndpoint,
+  lnurlPayEndpoint: () => lnurlPayEndpoint,
+  relayedVerifyUrl: () => relayedVerifyUrl
 });
 module.exports = __toCommonJS(server_exports);
 
@@ -41,6 +43,16 @@ function bytesToHex(bytes) {
   for (const byte of bytes) hex += byte.toString(16).padStart(2, "0");
   return hex;
 }
+function hexToBytes(hex) {
+  const bytes = new Uint8Array(hex.length >> 1);
+  for (let at = 0; at < bytes.length; at++) {
+    bytes[at] = parseInt(hex.slice(at * 2, at * 2 + 2), 16);
+  }
+  return bytes;
+}
+function isHex(text2) {
+  return /^[0-9a-f]+$/i.test(text2) && text2.length % 2 === 0;
+}
 
 // ../core/hmac.ts
 async function hmacHex(secret, payload) {
@@ -248,6 +260,10 @@ function decodeInvoice(bolt11) {
     expiresAt: expiryOf(parts.words, tagged)
   };
 }
+function preimageMatchesHash(preimage, paymentHash) {
+  if (!isHex(preimage)) return false;
+  return bytesToHex(sha256(hexToBytes(preimage))) === paymentHash.toLowerCase();
+}
 function splitBech32(bolt11) {
   const lower = bolt11.toLowerCase();
   if (isBolt12Encoding(lower)) return null;
@@ -428,19 +444,19 @@ async function refuseUnlessPublic(url) {
   if (!await resolvesNothingPrivate(url)) throw new Error(`${url} resolves to an address we do not reach`);
 }
 async function answerOf(response) {
-  const { status, ok } = response;
+  const { status, ok, headers } = response;
   const reader = response.body?.getReader();
-  if (!reader) return { status, ok, body: "", truncated: false };
+  if (!reader) return { status, ok, body: "", truncated: false, headers };
   const read = [];
   let bytes = 0;
   while (bytes <= BODY_LIMIT_BYTES) {
     const { done, value } = await reader.read();
-    if (done) return { status, ok, body: text(read), truncated: false };
+    if (done) return { status, ok, body: text(read), truncated: false, headers };
     read.push(value);
     bytes += value.length;
   }
   await reader.cancel();
-  return { status, ok, body: text(read), truncated: true };
+  return { status, ok, body: text(read), truncated: true, headers };
 }
 function withoutBody(sent) {
   const headers = { ...sent.headers };
@@ -478,6 +494,11 @@ var NoWalletAvailable = class extends Error {
 // ../core/lnurl.ts
 var VERIFY_WITHOUT_PREIMAGE = ["zeuspay.com", "zeusnuts.com", "ecash.love"];
 var RESOLVE_TIMEOUT_MS = 3e4;
+var NAMES_ONE_ACCOUNT = /^[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)*$/;
+var MIN_PACE_SECS = 1;
+var MAX_PACE_SECS = 3600;
+var MIN_PER_SECOND = 0.01;
+var MAX_PER_SECOND = 100;
 async function resolve(addresses, amountMsat) {
   const served = await firstThatServes(
     addresses,
@@ -565,6 +586,31 @@ function decodeIssued(address, bolt11) {
   }
   return { paymentHash, descriptionHash, amountMsat, expiresAt };
 }
+async function checkSettled(verifyUrl, paymentHash) {
+  const answer = await answeredJson(verifyUrl);
+  const asked = {
+    pace: paceAskedFor(answer.headers),
+    ceiling: ceilingAskedFor(answer.headers)
+  };
+  if (!answer.said.settled || !answer.said.preimage) return { preimage: null, ...asked };
+  if (!preimageMatchesHash(answer.said.preimage, paymentHash)) {
+    throw new Error(`verify returned a preimage that does not hash to ${paymentHash}`);
+  }
+  return { preimage: answer.said.preimage, ...asked };
+}
+function paceAskedFor(headers) {
+  const asked = /max-age\s*=\s*(\d+)/i.exec(headers.get("cache-control") ?? "");
+  if (!asked) return null;
+  return Math.min(Math.max(Number(asked[1]), MIN_PACE_SECS), MAX_PACE_SECS);
+}
+function ceilingAskedFor(headers) {
+  const asked = /^\s*(\d+)\s*(?:;\s*w\s*=\s*(\d+))?/i.exec(headers.get("ratelimit-limit") ?? "");
+  if (!asked) return null;
+  const perWindow = Number(asked[1]);
+  const window = asked[2] === void 0 ? 1 : Number(asked[2]);
+  if (perWindow === 0 || window === 0) return null;
+  return Math.min(Math.max(perWindow / window, MIN_PER_SECOND), MAX_PER_SECOND);
+}
 function cannotReleaseAPreimage(host) {
   const lowered = host.toLowerCase();
   return VERIFY_WITHOUT_PREIMAGE.some(
@@ -577,18 +623,29 @@ function withAmount(callback, amountMsat) {
 }
 function splitAddress(address) {
   const [user, domain, ...rest] = address.split("@");
-  if (!user || !domain || rest.length > 0 || !publicHttps(`https://${domain}/`)) {
+  if (!user || !domain || rest.length > 0 || !NAMES_ONE_ACCOUNT.test(user) || !isNothingButAHost(domain) || !publicHttps(`https://${domain}/`)) {
     throw new WalletRefused("address-unusable", `${address} is not a usable lightning address`);
   }
   return [user, domain];
 }
+function isNothingButAHost(domain) {
+  try {
+    const parsed = new URL(`https://${domain}/`);
+    return parsed.host === domain.toLowerCase() && parsed.pathname === "/" && parsed.search === "" && parsed.hash === "";
+  } catch {
+    return false;
+  }
+}
 async function fetchJson(url, deadline) {
+  return (await answeredJson(url, deadline)).said;
+}
+async function answeredJson(url, deadline) {
   const answer = await ask(url, { headers: { accept: "application/json" }, deadline });
   if (!answer.ok) throw new Error(`${url} answered ${answer.status}`);
   if (answer.truncated) {
     throw new Error(`${url} answered with more than the ${BODY_LIMIT_BYTES} bytes we read`);
   }
-  return JSON.parse(answer.body);
+  return { said: JSON.parse(answer.body), headers: answer.headers };
 }
 
 // ../core/sealed.ts
@@ -610,6 +667,22 @@ async function seal(secret, plaintext) {
   joined.set(cipher, iv.length);
   return `${VERSION}.${toBase64Url(joined)}`;
 }
+async function unseal(secret, sealed) {
+  const key = await keyFor(secret);
+  if (!sealed.startsWith(`${VERSION}.`)) return null;
+  const joined = fromBase64Url(sealed.slice(VERSION.length + 1));
+  if (joined === null || joined.length <= IV_BYTES) return null;
+  try {
+    const body = await crypto.subtle.decrypt(
+      { name: "AES-GCM", iv: joined.slice(0, IV_BYTES) },
+      key,
+      joined.slice(IV_BYTES)
+    );
+    return new TextDecoder().decode(body);
+  } catch {
+    return null;
+  }
+}
 async function keyFor(secret) {
   if (secret.length < MIN_SECRET_CHARS) {
     throw new Error(`the sealing secret needs ${MIN_SECRET_CHARS} characters of randomness`);
@@ -634,6 +707,17 @@ function toBase64Url(bytes) {
   for (const byte of bytes) binary += String.fromCharCode(byte);
   return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
 }
+function fromBase64Url(text2) {
+  if (text2.length === 0 || !/^[A-Za-z0-9_-]+$/.test(text2)) return null;
+  try {
+    const binary = atob(text2.replace(/-/g, "+").replace(/_/g, "/"));
+    const bytes = new Uint8Array(binary.length);
+    for (let at = 0; at < bytes.length; at++) bytes[at] = binary.charCodeAt(at);
+    return bytes;
+  } catch {
+    return null;
+  }
+}
 
 // src/errors.ts
 var ProblemError = class extends Error {
@@ -756,6 +840,30 @@ function refuse(reason) {
   return Response.json({ status: "ERROR", reason });
 }
 
+// ../core/ed25519.ts
+var PKCS8_HEADER = hexToBytes("302e020100300506032b657004220420");
+
+// src/webhook.ts
+var VERIFY_CHALLENGE = "verify-challenge";
+function nonceOf(text2, type) {
+  try {
+    const said = JSON.parse(text2);
+    if (said["type"] !== type || typeof said["nonce"] !== "string") return null;
+    return said["nonce"];
+  } catch {
+    return null;
+  }
+}
+function answerVerifyChallenge(body) {
+  const nonce = nonceOf(body, VERIFY_CHALLENGE);
+  return nonce === null ? null : JSON.stringify({ nonce });
+}
+async function answerVerifyChallengeRequest(request) {
+  if (request.method !== "POST") return null;
+  const answer = answerVerifyChallenge(await request.clone().text());
+  return answer === null ? null : new Response(answer, { headers: { "content-type": "application/json" } });
+}
+
 // src/qr.ts
 var import_uqr = require("uqr");
 function encodeForQr(destination) {
@@ -767,14 +875,48 @@ function isLnAddress(destination) {
   return at > 0 && destination.slice(at + 1).includes(".");
 }
 
+// src/relay.ts
+var DEFAULT_POLL_EVERY_SECS = 5;
+var WALLET = "w";
+function lightningVerifyEndpoint(config) {
+  const paced = {
+    "cache-control": `max-age=${config.pollEverySecs ?? DEFAULT_POLL_EVERY_SECS}`
+  };
+  return async (request) => {
+    const consented = await answerVerifyChallengeRequest(request);
+    if (consented !== null) return consented;
+    const sealed = new URL(request.url).searchParams.get(WALLET);
+    if (sealed === null) return Response.json({ settled: false }, { status: 400 });
+    const opened = await unseal(config.secret, sealed);
+    if (opened === null) return Response.json({ settled: false }, { status: 403 });
+    const wallet = JSON.parse(opened);
+    const asked = await checkSettled(wallet.url, wallet.hash).catch(() => null);
+    if (asked === null) return Response.json({ settled: false }, { status: 502 });
+    return Response.json(
+      { settled: asked.preimage !== null, preimage: asked.preimage },
+      { headers: paced }
+    );
+  };
+}
+async function relayedVerifyUrl(endpoint, wallet, secret) {
+  const relayed = new URL(endpoint);
+  relayed.searchParams.set(WALLET, await seal(secret, JSON.stringify(wallet)));
+  return relayed.toString();
+}
+
 // src/rail.ts
 var LIGHTNING = "lightning";
 function blindLightningRail(config) {
   return async (order) => {
     const resolved = await invoiceFrom(config.lnAddresses, await config.amountMsat(order));
+    const relay = config.relayVerifyThrough;
     const watched = await config.gateway.watchPayment({
       paymentHash: resolved.paymentHash,
-      verifyUrl: resolved.verifyUrl,
+      verifyUrl: relay ? await relayedVerifyUrl(
+        relay.endpoint,
+        { url: resolved.verifyUrl, hash: resolved.paymentHash },
+        relay.secret
+      ) : resolved.verifyUrl,
       expiresAt: resolved.expiresAt,
       trigger: config.trigger,
       sealed: await config.sealed?.(order),
@@ -803,5 +945,7 @@ async function invoiceFrom(lnAddresses, amountMsat) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   blindLightningRail,
-  lnurlPayEndpoint
+  lightningVerifyEndpoint,
+  lnurlPayEndpoint,
+  relayedVerifyUrl
 });

package/dist/server.d.cts

@@ -1,5 +1,5 @@
-import { T as ThunderBridge } from './rail-CdKeyVGn.cjs';
-export { m as BlindLightningRailConfig, n as blindLightningRail } from './rail-CdKeyVGn.cjs';
+import { T as ThunderBridge } from './rail-J8QoYbSr.cjs';
+export { m as BlindLightningRailConfig, n as blindLightningRail } from './rail-J8QoYbSr.cjs';
 
 interface TriggerConfig {
     /** The gateway that quotes the addresses and mints the invoice */
@@ -61,4 +61,43 @@ interface Minted {
  */
 declare function lnurlPayEndpoint(config: TriggerConfig): (request: Request) => Promise<Response>;
 
-export { type Minted, type TriggerConfig, lnurlPayEndpoint };
+/** The wallet's own LUD-21 URL and the hash its preimage has to match */
+interface Relayed {
+    url: string;
+    hash: string;
+}
+interface LightningVerifyConfig {
+    /** The secret the sealed wallet URL was made with, and nothing else uses it */
+    secret: string;
+    /**
+     * How often you want the gateway to ask, in seconds. It goes out as
+     * `Cache-Control: max-age`, so the pace is yours rather than the operator's.
+     * Five by default, which is what a Lightning checkout wants
+     */
+    pollEverySecs?: number;
+}
+/**
+ * A verify endpoint of your own that asks the recipient's wallet for you, so the
+ * gateway polls you and never the wallet.
+ *
+ * `relayedVerifyUrl` seals the wallet's own LUD-21 URL into the query with your
+ * secret, so what the gateway stores and replicates is opaque: not the wallet's
+ * host, not which provider the recipient uses, nothing but a blob it cannot read.
+ * This handler unseals it, asks the wallet, and answers the same LUD-21 shape.
+ *
+ * It relays rather than decides. The preimage still comes from the recipient's
+ * own server and still has to hash to the payment hash, so standing between the
+ * two buys privacy and pacing without becoming something anyone has to trust.
+ *
+ * A wallet it cannot reach answers `502` rather than "not settled", because those
+ * are different claims and only one of them is true. The gateway logs a failed
+ * poll and asks again, which is what a broken relay should look like.
+ */
+declare function lightningVerifyEndpoint(config: LightningVerifyConfig): (request: Request) => Promise<Response>;
+/**
+ * The URL to hand the gateway instead of the wallet's own, with the wallet's
+ * sealed inside it. Point it at wherever `lightningVerifyEndpoint` is mounted
+ */
+declare function relayedVerifyUrl(endpoint: string, wallet: Relayed, secret: string): Promise<string>;
+
+export { type LightningVerifyConfig, type Minted, type Relayed, type TriggerConfig, lightningVerifyEndpoint, lnurlPayEndpoint, relayedVerifyUrl };