thunder-bridge 0.8.2 → 0.8.4

package/dist/index.js

@@ -71,8 +71,8 @@ function hexToBytes(hex) {
   }
   return bytes;
 }
-function isHex(text3) {
-  return /^[0-9a-f]+$/i.test(text3) && text3.length % 2 === 0;
+function isHex(text2) {
+  return /^[0-9a-f]+$/i.test(text2) && text2.length % 2 === 0;
 }
 
 // ../core/sha256.ts
@@ -166,8 +166,8 @@ function sha256(bytes) {
   }
   return asBytes(state);
 }
-function sha256Hex(text3) {
-  return bytesToHex(sha256(new TextEncoder().encode(text3)));
+function sha256Hex(text2) {
+  return bytesToHex(sha256(new TextEncoder().encode(text2)));
 }
 function withPadding(bytes) {
   const padded = new Uint8Array(
@@ -541,7 +541,8 @@ function watchRequestBody(params, trigger) {
     verify_url: params.verifyUrl,
     expires_at: expiresAt.toISOString(),
     trigger: trigger ?? void 0,
-    sealed: params.sealed
+    sealed: params.sealed,
+    webhook: params.webhookUrl ? { url: params.webhookUrl, secret: params.webhookSecret } : void 0
   });
 }
 function triggerEventFromWire(body) {
@@ -1114,10 +1115,10 @@ function toBase64Url(bytes) {
   for (const byte of bytes) binary += String.fromCharCode(byte);
   return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
 }
-function fromBase64Url(text3) {
-  if (text3.length === 0 || !/^[A-Za-z0-9_-]+$/.test(text3)) return null;
+function fromBase64Url(text2) {
+  if (text2.length === 0 || !/^[A-Za-z0-9_-]+$/.test(text2)) return null;
   try {
-    const binary = atob(text3.replace(/-/g, "+").replace(/_/g, "/"));
+    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;
@@ -1149,368 +1150,6 @@ function asBuffer(bytes) {
   return bytes instanceof Uint8Array && bytes.buffer instanceof ArrayBuffer ? bytes : new Uint8Array(bytes);
 }
 
-// ../core/outbound.ts
-import { lookup } from "dns/promises";
-import { setTimeout as sleep } from "timers/promises";
-var HTTP_TIMEOUT_MS2 = 15e3;
-var LOOKUP_TIMEOUT_MS = 5e3;
-var HOPS_FOLLOWED = 2;
-var REDIRECTS = [301, 302, 303, 307, 308];
-var KEEPS_THE_METHOD = [307, 308];
-var CREDENTIALS = ["authorization", "cookie", "proxy-authorization"];
-var BODY_LIMIT_BYTES = 262144;
-async function ask(url, sent = {}) {
-  const capped = AbortSignal.timeout(HTTP_TIMEOUT_MS2);
-  const signal = sent.deadline ? AbortSignal.any([sent.deadline, capped]) : capped;
-  let target = url;
-  let carried = sent;
-  for (let hop = 0; hop <= HOPS_FOLLOWED; hop += 1) {
-    await refuseUnlessPublic(target);
-    const response = await fetch(target, {
-      method: carried.method ?? "GET",
-      headers: carried.headers ?? {},
-      body: carried.body,
-      redirect: "manual",
-      signal
-    });
-    if (!REDIRECTS.includes(response.status)) return await answerOf(response);
-    const location = response.headers.get("location");
-    if (location === null) {
-      throw new Error(`${target} answered ${response.status} without saying where to`);
-    }
-    await response.body?.cancel();
-    const next = new URL(location, target).toString();
-    carried = KEEPS_THE_METHOD.includes(response.status) ? carried : withoutBody(carried);
-    carried = sameOrigin(target, next) ? carried : withoutCredentials(carried);
-    target = next;
-  }
-  throw new Error(`${url} redirected more than ${HOPS_FOLLOWED} times`);
-}
-async function resolvesNothingPrivate(url) {
-  const host = new URL(url).hostname.replace(/^\[|]$/g, "");
-  const found = await Promise.race([
-    lookup(host, { all: true, verbatim: true }).catch(() => []),
-    sleep(LOOKUP_TIMEOUT_MS, null, { ref: false })
-  ]);
-  return found !== null && found.every((one) => publicAddress(one.address));
-}
-async function refuseUnlessPublic(url) {
-  if (!publicHttps(url)) throw new Error(`${url} is not a public https 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 reader = response.body?.getReader();
-  if (!reader) return { status, ok, body: "", truncated: false };
-  const read = [];
-  let bytes = 0;
-  while (bytes <= BODY_LIMIT_BYTES) {
-    const { done, value } = await reader.read();
-    if (done) return { status, ok, body: text2(read), truncated: false };
-    read.push(value);
-    bytes += value.length;
-  }
-  await reader.cancel();
-  return { status, ok, body: text2(read), truncated: true };
-}
-function withoutBody(sent) {
-  const headers = { ...sent.headers };
-  delete headers["content-type"];
-  return { ...sent, method: "GET", headers, body: void 0 };
-}
-function withoutCredentials(sent) {
-  const headers = { ...sent.headers };
-  for (const named of CREDENTIALS) delete headers[named];
-  return { ...sent, headers };
-}
-function text2(chunks) {
-  const decoder = new TextDecoder();
-  let decoded = "";
-  for (const chunk of chunks) decoded += decoder.decode(chunk, { stream: true });
-  return decoded + decoder.decode();
-}
-
-// ../core/refusal.ts
-var WalletRefused = class extends Error {
-  reason;
-  constructor(reason, message) {
-    super(message);
-    this.reason = reason;
-  }
-};
-var NoWalletAvailable = class extends Error {
-  wallets;
-  constructor(wallets) {
-    super(wallets.map((wallet) => `${wallet.address} ${wallet.reason}`).join(", "));
-    this.wallets = wallets;
-  }
-};
-
-// ../core/lnurl.ts
-var VERIFY_WITHOUT_PREIMAGE = ["zeuspay.com", "zeusnuts.com", "ecash.love"];
-var BECH32_CHARSET2 = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
-var BECH32_GENERATOR = [996825010, 642813549, 513874426, 1027748829, 705979059];
-var CHECKSUM_SLOTS = [0, 1, 2, 3, 4, 5];
-var LNURL_HRP = "lnurl";
-var RESOLVE_TIMEOUT_MS = 3e4;
-async function resolve(addresses, amountMsat) {
-  const served = await firstThatServes(
-    addresses,
-    (address, deadline) => resolveAddress(address, amountMsat, deadline)
-  );
-  return served.won;
-}
-async function firstThatServes(addresses, attempt) {
-  const deadline = AbortSignal.timeout(RESOLVE_TIMEOUT_MS);
-  const refusals3 = [];
-  for (const address of addresses) {
-    if (deadline.aborted) break;
-    try {
-      return { won: await attempt(address, deadline), refusals: refusals3 };
-    } catch (refusal) {
-      if (!(refusal instanceof WalletRefused)) throw refusal;
-      console.warn(`wallet ${address} refused, ${refusal.reason}: ${refusal.message}`);
-      refusals3.push({ address, reason: refusal.reason });
-    }
-  }
-  throw new NoWalletAvailable(refusals3);
-}
-async function probe(address, amountMsat, deadline) {
-  const [user, domain] = splitAddress(address);
-  if (cannotReleaseAPreimage(domain)) {
-    throw new WalletRefused("cannot-prove-delivery", `${address} never releases a preimage`);
-  }
-  const pay = await answered(
-    `https://${domain}/.well-known/lnurlp/${user}`,
-    deadline
-  );
-  if (pay.tag !== "payRequest" || !pay.callback) {
-    throw new WalletRefused("unreachable", `${address} answered with no payRequest`);
-  }
-  if (amountMsat < pay.minSendable || amountMsat > pay.maxSendable) {
-    throw new WalletRefused(
-      "amount-not-accepted",
-      `${address} takes [${pay.minSendable}, ${pay.maxSendable}] msat, not ${amountMsat}`
-    );
-  }
-  return { address, pay };
-}
-async function resolveAddress(address, amountMsat, deadline) {
-  const { pay } = await probe(address, amountMsat, deadline);
-  const invoice = await answered(withAmount(pay.callback, amountMsat), deadline);
-  if (!invoice.pr) throw new WalletRefused("unreachable", `${address} returned no invoice`);
-  if (!invoice.verify || !publicHttps(invoice.verify)) {
-    throw new WalletRefused(
-      "cannot-prove-delivery",
-      `${address} publishes no usable LUD-21 verify URL`
-    );
-  }
-  const issued = decodeIssued(address, invoice.pr);
-  if (issued.amountMsat !== amountMsat) {
-    throw new WalletRefused(
-      "invoice-refused",
-      `${address} issued an invoice for ${issued.amountMsat} msat, not ${amountMsat}`
-    );
-  }
-  if (issued.descriptionHash !== sha256Hex(pay.metadata)) {
-    throw new WalletRefused(
-      "invoice-refused",
-      `${address} does not bind its invoice to the metadata it serves`
-    );
-  }
-  return {
-    address,
-    bolt11: invoice.pr,
-    verifyUrl: invoice.verify,
-    paymentHash: issued.paymentHash,
-    expiresAt: issued.expiresAt
-  };
-}
-async function answered(url, deadline) {
-  try {
-    return await fetchJson(url, deadline);
-  } catch (cause) {
-    throw new WalletRefused("unreachable", String(cause));
-  }
-}
-function decodeIssued(address, bolt11) {
-  const { paymentHash, descriptionHash, amountMsat, expiresAt } = decodeInvoice(bolt11);
-  if (paymentHash === null || expiresAt === null) {
-    throw new WalletRefused("invoice-refused", `${address} issued an invoice we cannot decode`);
-  }
-  return { paymentHash, descriptionHash, amountMsat, expiresAt };
-}
-function cannotReleaseAPreimage(host) {
-  const lowered = host.toLowerCase();
-  return VERIFY_WITHOUT_PREIMAGE.some(
-    (known) => lowered === known || lowered.endsWith(`.${known}`)
-  );
-}
-function toLnurl(endpoint) {
-  const scheme = parsedScheme(endpoint);
-  if (scheme !== "https:" && scheme !== "http:") {
-    throw new Error(`${endpoint} is not an http or https URL`);
-  }
-  const words = toWords(new TextEncoder().encode(endpoint));
-  const data = [...words, ...checksumWords(LNURL_HRP, words)];
-  return `${LNURL_HRP}1${data.map((word) => BECH32_CHARSET2[word]).join("")}`.toUpperCase();
-}
-function parsedScheme(endpoint) {
-  try {
-    return new URL(endpoint).protocol;
-  } catch {
-    return null;
-  }
-}
-function toWords(bytes) {
-  const words = [];
-  let accumulator = 0;
-  let bits = 0;
-  for (const byte of bytes) {
-    accumulator = accumulator << 8 | byte;
-    bits += 8;
-    while (bits >= 5) {
-      bits -= 5;
-      words.push(accumulator >> bits & 31);
-    }
-  }
-  if (bits > 0) words.push(accumulator << 5 - bits & 31);
-  return words;
-}
-function checksumWords(hrp, words) {
-  const expanded = [...hrp].map((char) => char.charCodeAt(0));
-  const values = [
-    ...expanded.map((code) => code >> 5),
-    0,
-    ...expanded.map((code) => code & 31),
-    ...words,
-    ...CHECKSUM_SLOTS.map(() => 0)
-  ];
-  const polymod = bech32Polymod(values) ^ 1;
-  return CHECKSUM_SLOTS.map((slot) => polymod >> 5 * (5 - slot) & 31);
-}
-function bech32Polymod(values) {
-  let checksum = 1;
-  for (const value of values) {
-    const top = checksum >> 25;
-    checksum = (checksum & 33554431) << 5 ^ value;
-    for (let bit = 0; bit < 5; bit++) {
-      if (top >> bit & 1) checksum ^= BECH32_GENERATOR[bit];
-    }
-  }
-  return checksum;
-}
-function withAmount(callback, amountMsat) {
-  const separator = callback.includes("?") ? "&" : "?";
-  return `${callback}${separator}amount=${amountMsat}`;
-}
-function splitAddress(address) {
-  const [user, domain, ...rest] = address.split("@");
-  if (!user || !domain || rest.length > 0 || !publicHttps(`https://${domain}/`)) {
-    throw new WalletRefused("address-unusable", `${address} is not a usable lightning address`);
-  }
-  return [user, domain];
-}
-async function fetchJson(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);
-}
-
-// src/trigger.ts
-var NONCE_BYTES = 16;
-function lnurlPayEndpoint(config) {
-  return async (request) => {
-    const url = new URL(request.url);
-    const asked = url.searchParams.get("to");
-    try {
-      return asked === null ? await offer(config, url) : await mint(config, url, asked);
-    } catch (failure) {
-      return refuse(failure instanceof Error ? failure.message : "the trigger could not be served");
-    }
-  };
-}
-async function offer(config, url) {
-  const amountMsat = await config.amountMsat();
-  const quote = await config.gateway.createQuote({
-    lnAddresses: config.lnAddresses,
-    amountMsat
-  });
-  const nonce = randomNonce();
-  const callback = new URL(config.baseUrl ?? `${url.origin}${url.pathname}`);
-  callback.searchParams.set("to", quote.lnAddress);
-  callback.searchParams.set("msat", String(amountMsat));
-  callback.searchParams.set("n", nonce);
-  callback.searchParams.set("sig", await sign(config.secret, quote.lnAddress, amountMsat, nonce));
-  return Response.json({
-    tag: "payRequest",
-    callback: callback.toString(),
-    metadata: quote.metadata,
-    minSendable: amountMsat,
-    maxSendable: amountMsat
-  });
-}
-async function mint(config, url, address) {
-  const amountMsat = Number(url.searchParams.get("msat"));
-  const nonce = url.searchParams.get("n") ?? "";
-  const signature = url.searchParams.get("sig") ?? "";
-  const expected = await sign(config.secret, address, amountMsat, nonce);
-  if (!equalInConstantTime(signature, expected)) return refuse("this callback was not signed here");
-  const wanted = url.searchParams.get("amount");
-  if (wanted !== null && Number(wanted) !== amountMsat) {
-    return refuse(`this trigger costs exactly ${amountMsat} msat`);
-  }
-  const minted = config.blind ? await mintBlind(config, address, amountMsat) : await mintThroughGateway(config, address, amountMsat, nonce);
-  return Response.json({
-    status: "OK",
-    pr: minted.bolt11,
-    routes: [],
-    verify: minted.verifyUrl
-  });
-}
-async function mintThroughGateway(config, address, amountMsat, nonce) {
-  const payment = await config.gateway.createPayment(
-    { lnAddresses: [address], amountMsat },
-    { idempotencyKey: nonce, trigger: config.watchSecret }
-  );
-  return { bolt11: payment.bolt11, verifyUrl: payment.verifyUrl };
-}
-async function mintBlind(config, address, amountMsat) {
-  const resolved = await resolve([address], amountMsat);
-  const minted = { ...resolved, amountMsat, lnAddress: resolved.address };
-  const locked = config.sealed;
-  try {
-    await config.gateway.watchPayment({
-      paymentHash: resolved.paymentHash,
-      verifyUrl: resolved.verifyUrl,
-      expiresAt: resolved.expiresAt,
-      trigger: config.watchSecret,
-      sealed: locked ? await seal(locked.secret, JSON.stringify(locked.data(minted))) : void 0
-    });
-  } catch (refused) {
-    if (!alreadyWatched(refused)) throw refused;
-  }
-  return { bolt11: resolved.bolt11, verifyUrl: resolved.verifyUrl };
-}
-function alreadyWatched(refused) {
-  return refused instanceof ProblemError && isProblemType(refused, PAYMENT_ALREADY_WATCHED);
-}
-function sign(secret, address, amountMsat, nonce) {
-  return hmacHex(secret, `${address}|${amountMsat}|${nonce}`);
-}
-function randomNonce() {
-  const bytes = crypto.getRandomValues(new Uint8Array(NONCE_BYTES));
-  let hex = "";
-  for (const byte of bytes) hex += byte.toString(16).padStart(2, "0");
-  return hex;
-}
-function refuse(reason) {
-  return Response.json({ status: "ERROR", reason });
-}
-
 // src/currency.ts
 var ISO_4217_MINOR_UNITS = {
   BHD: 3,
@@ -1575,7 +1214,9 @@ async function bankTransfer(params) {
     verifyUrl,
     expiresAt: params.expiresAt,
     trigger: params.trigger,
-    sealed: params.sealed
+    sealed: params.sealed,
+    webhookUrl: params.webhookUrl,
+    webhookSecret: params.webhookSecret
   });
   return { id: watched.id, paymentHash: watched.paymentHash, verifyUrl, spd };
 }
@@ -1754,6 +1395,66 @@ function asDate(unix) {
   return new Date(unix * MILLIS).toISOString().slice(0, DATE_CHARS);
 }
 
+// ../core/lnurl.ts
+var BECH32_CHARSET2 = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+var BECH32_GENERATOR = [996825010, 642813549, 513874426, 1027748829, 705979059];
+var CHECKSUM_SLOTS = [0, 1, 2, 3, 4, 5];
+var LNURL_HRP = "lnurl";
+function toLnurl(endpoint) {
+  const scheme = parsedScheme(endpoint);
+  if (scheme !== "https:" && scheme !== "http:") {
+    throw new Error(`${endpoint} is not an http or https URL`);
+  }
+  const words = toWords(new TextEncoder().encode(endpoint));
+  const data = [...words, ...checksumWords(LNURL_HRP, words)];
+  return `${LNURL_HRP}1${data.map((word) => BECH32_CHARSET2[word]).join("")}`.toUpperCase();
+}
+function parsedScheme(endpoint) {
+  try {
+    return new URL(endpoint).protocol;
+  } catch {
+    return null;
+  }
+}
+function toWords(bytes) {
+  const words = [];
+  let accumulator = 0;
+  let bits = 0;
+  for (const byte of bytes) {
+    accumulator = accumulator << 8 | byte;
+    bits += 8;
+    while (bits >= 5) {
+      bits -= 5;
+      words.push(accumulator >> bits & 31);
+    }
+  }
+  if (bits > 0) words.push(accumulator << 5 - bits & 31);
+  return words;
+}
+function checksumWords(hrp, words) {
+  const expanded = [...hrp].map((char) => char.charCodeAt(0));
+  const values = [
+    ...expanded.map((code) => code >> 5),
+    0,
+    ...expanded.map((code) => code & 31),
+    ...words,
+    ...CHECKSUM_SLOTS.map(() => 0)
+  ];
+  const polymod = bech32Polymod(values) ^ 1;
+  return CHECKSUM_SLOTS.map((slot) => polymod >> 5 * (5 - slot) & 31);
+}
+function bech32Polymod(values) {
+  let checksum = 1;
+  for (const value of values) {
+    const top = checksum >> 25;
+    checksum = (checksum & 33554431) << 5 ^ value;
+    for (let bit = 0; bit < 5; bit++) {
+      if (top >> bit & 1) checksum ^= BECH32_GENERATOR[bit];
+    }
+  }
+  return checksum;
+}
+
 // src/qr.ts
 import { encode } from "uqr";
 var SAFE_COLOR = /^#(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$|^rgba?\([\d.,%/\s]+\)$|^[a-z]+$/i;
@@ -1836,6 +1537,8 @@ function bankRail(config) {
       trigger: config.trigger,
       sealed: await config.sealed?.(order),
       variableSymbol: config.variableSymbol?.(order),
+      webhookUrl: config.webhookUrl,
+      webhookSecret: config.webhookSecret,
       allowPublicGateway: config.allowPublicGateway
     });
     return {
@@ -1867,35 +1570,6 @@ function lightningRail(config) {
     };
   };
 }
-function blindLightningRail(config) {
-  return async (order) => {
-    const resolved = await invoiceFrom(config.lnAddresses, await config.amountMsat(order));
-    const watched = await config.gateway.watchPayment({
-      paymentHash: resolved.paymentHash,
-      verifyUrl: resolved.verifyUrl,
-      expiresAt: resolved.expiresAt,
-      trigger: config.trigger,
-      sealed: await config.sealed?.(order)
-    });
-    return {
-      id: watched.id,
-      rail: config.name ?? LIGHTNING,
-      scan: resolved.bolt11,
-      qr: encodeForQr(resolved.bolt11),
-      expiresAt: resolved.expiresAt
-    };
-  };
-}
-async function invoiceFrom(lnAddresses, amountMsat) {
-  try {
-    return await resolve(lnAddresses, amountMsat);
-  } catch (refused) {
-    if (refused instanceof NoWalletAvailable) {
-      throw new NoWalletAvailableError({ title: refused.message }, refused.wallets);
-    }
-    throw refused;
-  }
-}
 
 // src/price.ts
 var MSAT_PER_BTC2 = 1e11;
@@ -2027,13 +1701,13 @@ var DEFAULT_TOLERANCE_SECS = 300;
 async function verifyWebhookSignature(body, signature, secret, timestamp, options = {}) {
   if (!recent(timestamp, options.toleranceSecs ?? DEFAULT_TOLERANCE_SECS)) return false;
   const received = signature.startsWith(SIGNATURE_PREFIX) ? signature.slice(SIGNATURE_PREFIX.length) : signature;
-  return equalInConstantTime(await sign2(secret, timestamp, body), received.toLowerCase());
+  return equalInConstantTime(await sign(secret, timestamp, body), received.toLowerCase());
 }
 async function parseWebhook(body, signature, secret, timestamp, options = {}) {
   if (!await verifyWebhookSignature(body, signature, secret, timestamp, options)) return null;
-  const text3 = typeof body === "string" ? body : new TextDecoder().decode(body);
+  const text2 = typeof body === "string" ? body : new TextDecoder().decode(body);
   try {
-    return paymentFromWire(JSON.parse(text3));
+    return paymentFromWire(JSON.parse(text2));
   } catch {
     return null;
   }
@@ -2044,12 +1718,27 @@ async function parseWebhookRequest(request, secret, options = {}) {
   if (signature === null || timestamp === null) return null;
   return parseWebhook(await request.text(), signature, secret, timestamp, options);
 }
+async function parseWatchedWebhook(body, signature, secret, timestamp, options = {}) {
+  if (!await verifyWebhookSignature(body, signature, secret, 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, secret, 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, secret, timestamp, options);
+}
 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 sign2(secret, timestamp, body) {
+async function sign(secret, timestamp, body) {
   return hmacHex(secret, signed(timestamp, body));
 }
 function signed(timestamp, body) {
@@ -2076,7 +1765,6 @@ export {
   bankTransfer,
   bankVerifyEndpoint,
   bitstamp,
-  blindLightningRail,
   coinbase,
   coinmate,
   decodeInvoice,
@@ -2087,13 +1775,14 @@ export {
   isProvablyPaid,
   kraken,
   lightningRail,
-  lnurlPayEndpoint,
   lnurlToDataUrl,
   lnurlToSvg,
   medianOf,
   minorScaleOf,
   minorUnitsOf,
   msatFor,
+  parseWatchedWebhook,
+  parseWatchedWebhookRequest,
   parseWebhook,
   parseWebhookRequest,
   preimageMatchesHash,