@vicacha-devs/strapi-plugin-certificates 0.0.0-stage → 1.0.0

package/dist/shared/index.js

@@ -0,0 +1,613 @@
+import { formatDateInCalendarSystem, extractCalendarParts } from "@vicacha-devs/strapi-plugin-calendar/shared";
+import { SUPPORTED_INTL_CALENDARS, applyDayOffset, extractCalendarParts as extractCalendarParts2, formatDateInCalendarSystem as formatDateInCalendarSystem2, getRegisteredCalendarFormatters, registerCalendarSystemFormatter, resolveOccurrenceAlternateDates, unregisterCalendarSystemFormatter } from "@vicacha-devs/strapi-plugin-calendar/shared";
+import { createHash, createHmac, generateKeyPairSync, randomBytes, sign, verify, timingSafeEqual } from "node:crypto";
+const PLUGIN_ID = "certificates";
+function formatSecondaryCalendars(date, systems, locale = "en") {
+  const result = {};
+  const dateStr = date.toISOString().slice(0, 10);
+  for (const sys of systems) {
+    if (!sys || !sys.enabled || !sys.id) continue;
+    const formatted = formatDateInCalendarSystem(dateStr, sys, locale, {
+      compact: false
+    });
+    const compact = formatDateInCalendarSystem(dateStr, sys, locale, {
+      compact: true
+    });
+    const parts = extractCalendarParts(
+      date,
+      sys.intlCalendar,
+      sys.dayOffset ?? 0
+    );
+    if (formatted) {
+      result[sys.id] = {
+        calendarId: sys.id,
+        label: sys.label || sys.id,
+        formatted,
+        compact: compact || formatted,
+        intlCalendar: sys.intlCalendar,
+        year: parts?.year,
+        month: parts?.month,
+        day: parts?.day,
+        isOverridden: false
+      };
+    }
+  }
+  return result;
+}
+function computePublicKeyFingerprint(publicKeyPem) {
+  const normalized = String(publicKeyPem || "").trim();
+  if (!normalized) return "";
+  const digest = createHash("sha256").update(normalized, "utf8").digest("hex");
+  return `SHA256:${digest.slice(0, 32).toUpperCase()}`;
+}
+function generateEd25519KeyPair() {
+  const { publicKey, privateKey } = generateKeyPairSync("ed25519", {
+    publicKeyEncoding: { type: "spki", format: "pem" },
+    privateKeyEncoding: { type: "pkcs8", format: "pem" }
+  });
+  return {
+    publicKeyPem: publicKey,
+    privateKeyPem: privateKey,
+    fingerprint: computePublicKeyFingerprint(publicKey)
+  };
+}
+function sanitizeSerialPrefix(prefix) {
+  const cleaned = String(prefix || "CERT").toUpperCase().replace(/[^A-Z0-9]/g, "").slice(0, 6);
+  return cleaned || "CERT";
+}
+function generateSerialNumber(prefix = "CERT", year) {
+  const safePrefix = sanitizeSerialPrefix(prefix);
+  const targetYear = typeof year === "number" && Number.isFinite(year) ? year : (/* @__PURE__ */ new Date()).getUTCFullYear();
+  const entropy = randomBytes(4).toString("hex").toUpperCase();
+  return `${safePrefix}-${targetYear}-${entropy}`;
+}
+function generateVerificationToken() {
+  return randomBytes(24).toString("hex");
+}
+function normalizeNationalId(rawId) {
+  return String(rawId || "").toUpperCase().replace(/[^A-Z0-9]/g, "");
+}
+function maskNationalId(rawId) {
+  const normalized = normalizeNationalId(rawId);
+  if (!normalized) return "";
+  if (normalized.length <= 4) {
+    return `***-${normalized}`;
+  }
+  const tail = normalized.slice(-4);
+  return `***-***-${tail}`;
+}
+function hashNationalId(rawId, serialNumber) {
+  const normalized = normalizeNationalId(rawId);
+  if (!normalized) return "";
+  const cleanSerial = String(serialNumber || "").trim().toUpperCase();
+  return createHash("sha256").update(`${cleanSerial}:${normalized}`, "utf8").digest("hex");
+}
+function verifyNationalIdHash(rawId, serialNumber, expectedHash) {
+  if (!expectedHash || !rawId) return false;
+  const computed = hashNationalId(rawId, serialNumber);
+  if (!computed) return false;
+  return verifyTokenConstantTime(computed, expectedHash);
+}
+function maskRecipientName(fullName) {
+  const parts = String(fullName || "").trim().split(/\s+/).filter(Boolean);
+  if (parts.length === 0) return "***";
+  if (parts.length === 1) {
+    const word = parts[0];
+    return word.length <= 2 ? `${word[0]}*` : `${word.slice(0, 2)}***`;
+  }
+  const first = parts[0];
+  const initials = parts.slice(1).map((part) => `${part.charAt(0).toUpperCase()}.`).join(" ");
+  return `${first} ${initials}`;
+}
+function cleanStr(val) {
+  return String(val ?? "").trim();
+}
+function serializeCanonicalPayload(payload) {
+  const signatories = payload.signatories ?? [];
+  const witnesses = payload.witnesses ?? [];
+  const ordered = {
+    version: "1.0",
+    serialNumber: cleanStr(payload.serialNumber),
+    templateSlug: cleanStr(payload.templateSlug),
+    organizationName: cleanStr(payload.organizationName),
+    recipientFullName: cleanStr(payload.recipientFullName),
+    recipientChosenName: cleanStr(payload.recipientChosenName),
+    nationalIdHash: cleanStr(payload.nationalIdHash),
+    issuedAt: cleanStr(payload.issuedAt),
+    expiresAt: cleanStr(payload.expiresAt),
+    signatories: signatories.map((s) => ({
+      name: cleanStr(s.name),
+      title: cleanStr(s.title)
+    })),
+    witnesses: witnesses.map((w) => ({
+      fullName: cleanStr(w.fullName),
+      role: cleanStr(w.role)
+    }))
+  };
+  return JSON.stringify(ordered);
+}
+function computeCanonicalPayloadHash(payload) {
+  const canonicalJson = serializeCanonicalPayload(payload);
+  return createHash("sha256").update(canonicalJson, "utf8").digest("hex");
+}
+function signCanonicalPayload(payload, privateKeyPem) {
+  const canonicalJson = serializeCanonicalPayload(payload);
+  const payloadHash = createHash("sha256").update(canonicalJson, "utf8").digest("hex");
+  const dataBuffer = Buffer.from(canonicalJson, "utf8");
+  const signature = sign(null, dataBuffer, privateKeyPem).toString("base64url");
+  return {
+    canonicalJson,
+    payloadHash,
+    signature
+  };
+}
+function verifyCanonicalPayloadSignature(payload, signatureBase64Url, publicKeyPem) {
+  try {
+    if (!signatureBase64Url || !publicKeyPem) return false;
+    const canonicalJson = serializeCanonicalPayload(payload);
+    const dataBuffer = Buffer.from(canonicalJson, "utf8");
+    const sigBuffer = Buffer.from(signatureBase64Url, "base64url");
+    return verify(null, dataBuffer, publicKeyPem, sigBuffer);
+  } catch {
+    return false;
+  }
+}
+function verifyTokenConstantTime(providedToken, expectedToken) {
+  if (!providedToken || !expectedToken) return false;
+  const a = Buffer.from(String(providedToken), "utf8");
+  const b = Buffer.from(String(expectedToken), "utf8");
+  if (a.length !== b.length || a.length === 0) {
+    return false;
+  }
+  return timingSafeEqual(a, b);
+}
+function computeDocuSignWebhookHmac(rawPayload, webhookSecret) {
+  return createHmac("sha256", webhookSecret).update(rawPayload, "utf8").digest("base64");
+}
+function verifyDocuSignWebhookHmac(rawPayload, signatureHeaderBase64, webhookSecret) {
+  if (!rawPayload || !signatureHeaderBase64 || !webhookSecret) {
+    return false;
+  }
+  const computedBase64 = computeDocuSignWebhookHmac(rawPayload, webhookSecret);
+  return verifyTokenConstantTime(
+    String(signatureHeaderBase64).trim(),
+    computedBase64
+  );
+}
+function computeDeterministicHex(input) {
+  const out = [];
+  for (let pass = 0; pass < 8; pass++) {
+    let h = (2166136261 ^ pass) >>> 0;
+    for (let i = 0; i < input.length; i++) {
+      h ^= input.charCodeAt(i);
+      h = Math.imul(h, 16777619) >>> 0;
+    }
+    out.push(h.toString(16).padStart(8, "0"));
+  }
+  return out.join("");
+}
+function escapeHtml(input) {
+  return String(input ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function sanitizeHexColor(input, fallback = "#14532d") {
+  const cleaned = String(input || "").trim();
+  if (/^#[0-9a-fA-F]{6}$/.test(cleaned)) {
+    return cleaned;
+  }
+  return fallback;
+}
+function interpolateBodyTemplate(templateText, variables) {
+  const safeTemplate = escapeHtml(templateText);
+  return safeTemplate.replace(
+    /\{\{\s*([a-zA-Z0-9_]+)\s*\}\}/g,
+    (_match, key) => {
+      const rawVal = variables[key] ?? "";
+      return `<strong>${escapeHtml(rawVal)}</strong>`;
+    }
+  );
+}
+function renderVerificationMatrixSvg(seedText, accentColor = "#14532d") {
+  const safeColor = sanitizeHexColor(accentColor);
+  const hashHex = computeDeterministicHex(seedText);
+  const size = 9;
+  const cells = [];
+  for (let row = 0; row < size; row++) {
+    for (let col = 0; col < size; col++) {
+      const isCornerFinder = row < 3 && col < 3 || row < 3 && col >= size - 3 || row >= size - 3 && col < 3;
+      const hexIdx = (row * size + col) % hashHex.length;
+      const nibble = parseInt(hashHex[hexIdx], 16);
+      const filled = isCornerFinder || nibble % 2 === 0;
+      if (filled) {
+        const x = 6 + col * 8;
+        const y = 6 + row * 8;
+        cells.push(
+          `<rect x="${x}" y="${y}" width="6.5" height="6.5" rx="1" fill="${safeColor}" />`
+        );
+      }
+    }
+  }
+  return [
+    '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 84 84" width="84" height="84" role="img" aria-label="Cryptographic Verification Matrix">',
+    `<rect x="1" y="1" width="82" height="82" rx="6" fill="#ffffff" stroke="${safeColor}" stroke-width="2" />`,
+    ...cells,
+    "</svg>"
+  ].join("");
+}
+function buildTemplateVariables(certificate, template, issuedDateFormatted, secondaryFormattedList) {
+  return {
+    recipientFullName: certificate.recipientFullName,
+    recipientChosenName: certificate.recipientChosenName || certificate.recipientFullName,
+    chosenName: certificate.recipientChosenName || "",
+    nationalIdMasked: certificate.nationalIdMasked || "N/A",
+    recipientNationality: certificate.recipientNationality || "",
+    issuedDateFormatted,
+    secondaryDateFormatted: secondaryFormattedList || issuedDateFormatted,
+    serialNumber: certificate.serialNumber,
+    organizationName: template.organizationName,
+    ...certificate.customData
+  };
+}
+function renderSignatoriesHtml(signatories) {
+  return (signatories || []).map(
+    (sig, idx) => `
+      <div class="sig-block">
+        <div class="sig-line"><span class="esign-anchor">/sig_${idx + 1}/</span></div>
+        <div class="sig-name">${escapeHtml(sig.name)}</div>
+        <div class="sig-title">${escapeHtml(sig.title)}</div>
+        ${sig.role ? `<div class="sig-role">${escapeHtml(sig.role)}</div>` : ""}
+      </div>`
+  ).join("");
+}
+function renderWitnessesHtml(witnesses) {
+  const list = witnesses || [];
+  if (list.length === 0) return "";
+  const cards = list.map(
+    (w, idx) => `
+            <div class="witness-card">
+              <div class="sig-line"><span class="esign-anchor">/wit_${idx + 1}/</span></div>
+              <div class="witness-name">${escapeHtml(w.fullName)}</div>
+              <div class="witness-meta">
+                ${w.role ? `<span>${escapeHtml(w.role)}</span>` : ""}
+                ${w.documentIdMasked ? `<span>ID: ${escapeHtml(w.documentIdMasked)}</span>` : ""}
+              </div>
+            </div>`
+  ).join("");
+  return `
+      <div class="witness-section">
+        <div class="witness-heading">Official Witnesses</div>
+        <div class="witness-grid">${cards}
+        </div>
+      </div>`;
+}
+function renderOptionalHtmlFragments(certificate, template, secondaryFormattedList) {
+  return {
+    statusBanner: certificate.status !== "issued" ? `<div class="watermark-alert">STATUS: ${escapeHtml(certificate.status.toUpperCase())}</div>` : "",
+    headerHtml: template.headerText ? `<div class="header-Invocation">${escapeHtml(template.headerText)}</div>` : "",
+    subheaderHtml: template.organizationSubheader ? `<div class="org-subheader">${escapeHtml(template.organizationSubheader)}</div>` : "",
+    chosenNameHtml: certificate.recipientChosenName ? `<div class="recipient-chosen">Chosen Name / Title: ${escapeHtml(certificate.recipientChosenName)}</div>` : "",
+    secondaryDateHtml: secondaryFormattedList ? `<span><strong>Secondary Calendar:</strong> ${escapeHtml(secondaryFormattedList)}</span>` : "",
+    nationalIdHtml: certificate.nationalIdMasked ? `<span><strong>Document ID:</strong> ${escapeHtml(certificate.nationalIdMasked)}</span>` : "",
+    esignLineHtml: certificate.esignEnvelopeId ? `<div>E-Sign Envelope (${escapeHtml(certificate.esignProvider || "docusign")}): ${escapeHtml(certificate.esignEnvelopeId)} [${escapeHtml(certificate.esignEnvelopeStatus || "sent")}]</div>` : ""
+  };
+}
+function renderPrintableCertificateHtml(params) {
+  const { certificate, template, verificationUrl } = params;
+  const accent = sanitizeHexColor(template.accentColor, "#14532d");
+  const issuedDateFormatted = certificate.issuedAt.slice(0, 10);
+  const secondaryFormattedList = Object.values(certificate.secondaryDates || {}).map((d) => `${d.label}: ${d.formatted}`).join(" • ");
+  const variables = buildTemplateVariables(
+    certificate,
+    template,
+    issuedDateFormatted,
+    secondaryFormattedList
+  );
+  const renderedBody = interpolateBodyTemplate(
+    template.bodyTemplate,
+    variables
+  );
+  const matrixSvg = renderVerificationMatrixSvg(
+    `${certificate.serialNumber}:${certificate.cryptographicSignature}`,
+    accent
+  );
+  const signatoriesHtml = renderSignatoriesHtml(certificate.signatories);
+  const witnessesHtml = renderWitnessesHtml(certificate.witnesses);
+  const fragments = renderOptionalHtmlFragments(
+    certificate,
+    template,
+    secondaryFormattedList
+  );
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>${escapeHtml(template.titleText)} — ${escapeHtml(certificate.serialNumber)}</title>
+  <style>
+    @page { size: A4 landscape; margin: 12mm; }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      padding: 24px;
+      font-family: Georgia, "Times New Roman", serif;
+      background: #f8fafc;
+      color: #0f172a;
+    }
+    .certificate-frame {
+      max-width: 1020px;
+      margin: 0 auto;
+      background: #ffffff;
+      border: 3px solid ${accent};
+      padding: 10px;
+      box-shadow: 0 10px 25px rgba(15, 23, 42, 0.08);
+      position: relative;
+    }
+    .certificate-inner {
+      border: 1px solid ${accent};
+      padding: 36px 48px;
+      position: relative;
+    }
+    .watermark-alert {
+      background: #fef2f2;
+      color: #991b1b;
+      border: 2px solid #dc2626;
+      padding: 8px 16px;
+      text-align: center;
+      font-weight: bold;
+      letter-spacing: 0.1em;
+      margin-bottom: 16px;
+    }
+    .header-Invocation {
+      text-align: center;
+      font-size: 20px;
+      color: ${accent};
+      margin-bottom: 8px;
+      font-weight: 600;
+    }
+    .org-name {
+      text-align: center;
+      font-size: 24px;
+      font-weight: 700;
+      letter-spacing: 0.06em;
+      text-transform: uppercase;
+      color: #0f172a;
+    }
+    .org-subheader {
+      text-align: center;
+      font-size: 13px;
+      color: #475569;
+      margin-top: 4px;
+      margin-bottom: 24px;
+    }
+    .cert-title {
+      text-align: center;
+      font-size: 30px;
+      color: ${accent};
+      margin: 18px 0 24px;
+      font-weight: 700;
+      border-bottom: 2px solid ${accent};
+      display: inline-block;
+      padding-bottom: 6px;
+    }
+    .title-wrap { text-align: center; }
+    .recipient-banner {
+      text-align: center;
+      margin: 16px 0 20px;
+    }
+    .recipient-name {
+      font-size: 28px;
+      font-weight: 700;
+      color: #0f172a;
+    }
+    .recipient-chosen {
+      font-size: 18px;
+      color: ${accent};
+      margin-top: 4px;
+      font-style: italic;
+    }
+    .cert-body {
+      font-size: 16px;
+      line-height: 1.75;
+      text-align: center;
+      max-width: 820px;
+      margin: 0 auto 28px;
+      color: #1e293b;
+    }
+    .dates-bar {
+      display: flex;
+      justify-content: center;
+      gap: 28px;
+      font-size: 13px;
+      color: #334155;
+      margin-bottom: 28px;
+      flex-wrap: wrap;
+    }
+    .sig-row {
+      display: flex;
+      justify-content: space-around;
+      gap: 24px;
+      margin-top: 32px;
+      margin-bottom: 24px;
+      flex-wrap: wrap;
+    }
+    .sig-block {
+      min-width: 200px;
+      text-align: center;
+    }
+    .sig-line {
+      border-bottom: 1px solid #334155;
+      height: 36px;
+      margin-bottom: 8px;
+    }
+    .esign-anchor {
+      color: #ffffff;
+      font-size: 1px;
+      line-height: 1px;
+      opacity: 0.01;
+      user-select: none;
+    }
+    .sig-name { font-weight: 700; font-size: 15px; }
+    .sig-title { font-size: 13px; color: #475569; }
+    .sig-role { font-size: 12px; color: ${accent}; }
+    .witness-section {
+      border-top: 1px dashed #cbd5e1;
+      padding-top: 14px;
+      margin-top: 16px;
+      margin-bottom: 20px;
+    }
+    .witness-heading {
+      text-align: center;
+      font-size: 12px;
+      text-transform: uppercase;
+      letter-spacing: 0.08em;
+      color: #64748b;
+      margin-bottom: 10px;
+    }
+    .witness-grid {
+      display: flex;
+      justify-content: center;
+      gap: 24px;
+      flex-wrap: wrap;
+    }
+    .witness-card {
+      font-size: 13px;
+      text-align: center;
+      padding: 6px 14px;
+      background: #f8fafc;
+      border-radius: 6px;
+      border: 1px solid #e2e8f0;
+    }
+    .witness-name { font-weight: 600; }
+    .witness-meta { font-size: 11px; color: #64748b; display: flex; gap: 8px; justify-content: center; }
+    .crypto-footer {
+      display: flex;
+      align-items: center;
+      justify-content: space-between;
+      border-top: 2px solid #e2e8f0;
+      padding-top: 16px;
+      margin-top: 16px;
+      gap: 16px;
+      font-family: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, monospace;
+      font-size: 11px;
+      color: #475569;
+    }
+    .crypto-details { line-height: 1.5; }
+    @media print {
+      body { background: #ffffff; padding: 0; }
+      .certificate-frame { box-shadow: none; }
+    }
+  </style>
+</head>
+<body>
+  <div class="certificate-frame">
+    <div class="certificate-inner">
+      ${fragments.statusBanner}
+      ${fragments.headerHtml}
+      <div class="org-name">${escapeHtml(template.organizationName)}</div>
+      ${fragments.subheaderHtml}
+      <div class="title-wrap">
+        <div class="cert-title">${escapeHtml(template.titleText)}</div>
+      </div>
+      <div class="recipient-banner">
+        <div class="recipient-name">${escapeHtml(certificate.recipientFullName)}</div>
+        ${fragments.chosenNameHtml}
+      </div>
+      <div class="cert-body">${renderedBody}</div>
+      <div class="dates-bar">
+        <span><strong>Serial No:</strong> ${escapeHtml(certificate.serialNumber)}</span>
+        <span><strong>Issued Date:</strong> ${escapeHtml(issuedDateFormatted)}</span>
+        ${fragments.secondaryDateHtml}
+        ${fragments.nationalIdHtml}
+      </div>
+      <div class="sig-row">${signatoriesHtml}</div>
+      ${witnessesHtml}
+      <div class="crypto-footer">
+        <div class="crypto-details">
+          <div><strong>CRYPTOGRAPHICALLY SIGNED RECORD (Ed25519)</strong></div>
+          <div>Serial: ${escapeHtml(certificate.serialNumber)} | Key Fingerprint: ${escapeHtml(certificate.publicKeyFingerprint)}</div>
+          <div>Payload SHA-256: ${escapeHtml(certificate.canonicalPayloadHash.slice(0, 32))}...</div>
+          <div>Signature (Ed25519): ${escapeHtml(certificate.cryptographicSignature.slice(0, 40))}...</div>
+          ${fragments.esignLineHtml}
+          <div>Verify Online: ${escapeHtml(verificationUrl)}</div>
+        </div>
+        <div>${matrixSvg}</div>
+      </div>
+    </div>
+  </div>
+</body>
+</html>`;
+}
+function escapeCsvCell(value) {
+  let str = String(value ?? "").replace(/\r?\n/g, " ").trim();
+  if (/^[=+\-@\t\r]/.test(str)) {
+    str = `'${str}`;
+  }
+  if (str.includes(",") || str.includes('"') || str.includes("'")) {
+    return `"${str.replace(/"/g, '""')}"`;
+  }
+  return str;
+}
+function exportCertificatesToCsv(records) {
+  const headers = [
+    "Serial Number",
+    "Template",
+    "Status",
+    "Recipient Full Name",
+    "Chosen Name / Title",
+    "Masked ID",
+    "Issued At",
+    "Expires At",
+    "Signatories",
+    "Witnesses Count",
+    "Key Fingerprint"
+  ];
+  const rows = records.map((r) => [
+    escapeCsvCell(r.serialNumber),
+    escapeCsvCell(r.templateName || r.templateSlug),
+    escapeCsvCell(r.status),
+    escapeCsvCell(r.recipientFullName),
+    escapeCsvCell(r.recipientChosenName || ""),
+    escapeCsvCell(r.nationalIdMasked || ""),
+    escapeCsvCell(r.issuedAt),
+    escapeCsvCell(r.expiresAt || ""),
+    escapeCsvCell((r.signatories || []).map((s) => s.name).join("; ")),
+    escapeCsvCell((r.witnesses || []).length),
+    escapeCsvCell(r.publicKeyFingerprint)
+  ]);
+  return [headers.join(","), ...rows.map((row) => row.join(","))].join("\n");
+}
+export {
+  PLUGIN_ID,
+  SUPPORTED_INTL_CALENDARS,
+  applyDayOffset,
+  computeCanonicalPayloadHash,
+  computeDocuSignWebhookHmac,
+  computePublicKeyFingerprint,
+  escapeCsvCell,
+  escapeHtml,
+  exportCertificatesToCsv,
+  extractCalendarParts2 as extractCalendarParts,
+  formatDateInCalendarSystem2 as formatDateInCalendarSystem,
+  formatSecondaryCalendars,
+  generateEd25519KeyPair,
+  generateSerialNumber,
+  generateVerificationToken,
+  getRegisteredCalendarFormatters,
+  hashNationalId,
+  interpolateBodyTemplate,
+  maskNationalId,
+  maskRecipientName,
+  normalizeNationalId,
+  registerCalendarSystemFormatter,
+  renderPrintableCertificateHtml,
+  renderVerificationMatrixSvg,
+  resolveOccurrenceAlternateDates,
+  sanitizeHexColor,
+  sanitizeSerialPrefix,
+  serializeCanonicalPayload,
+  signCanonicalPayload,
+  unregisterCalendarSystemFormatter,
+  verifyCanonicalPayloadSignature,
+  verifyDocuSignWebhookHmac,
+  verifyNationalIdHash,
+  verifyTokenConstantTime
+};