@agenticstechnologies/verify 0.0.0-stage → 1.0.1

package/src/merkle.mjs

@@ -0,0 +1,150 @@
+// Sorted-pair Merkle, same fold as netlify/edge-functions/lib/ledger.js
+// (imported by lib/gateway/proof.ts for buildBatch / foldLeafAtIndex):
+//   hashPair(a, b) = sha256Hex(a <= b ? a + b : b + a)
+//   odd node duplicated; empty leaf list → null (tree rule v1; v2 is at the end of this file)
+// A proof is only the sibling list. Pair order does not depend on index.
+
+import { sha256Hex } from "./evidence.mjs";
+
+async function hashPair(a, b) {
+  return sha256Hex(a <= b ? a + b : b + a);
+}
+
+export async function merkleRoot(leaves) {
+  if (!leaves || !leaves.length) return null;
+  let level = leaves.slice();
+  while (level.length > 1) {
+    const next = [];
+    for (let i = 0; i < level.length; i += 2) {
+      next.push(await hashPair(level[i], level[i + 1] ?? level[i]));
+    }
+    level = next;
+  }
+  return level[0];
+}
+
+export async function merkleProof(leaves, index) {
+  if (index < 0 || index >= leaves.length) return null;
+  const proof = [];
+  let level = leaves.slice();
+  let idx = index;
+  while (level.length > 1) {
+    const next = [];
+    for (let i = 0; i < level.length; i += 2) {
+      const left = level[i];
+      const right = level[i + 1] ?? level[i];
+      if (i === idx) proof.push(right);
+      else if (i + 1 === idx) proof.push(left);
+      next.push(await hashPair(left, right));
+    }
+    level = next;
+    idx = Math.floor(idx / 2);
+  }
+  return proof;
+}
+
+export async function verifyProof(leafHash, proof, root) {
+  let h = leafHash;
+  for (const sibling of proof || []) h = await hashPair(h, sibling);
+  return h === root;
+}
+
+// ── Tree rule v2 (L3-16): RFC 9162 section 2.1 (RFC 6962), over the 32 bytes of each hex leaf. ──
+//   leaf = SHA-256(0x00 || leaf bytes), node = SHA-256(0x01 || left || right), in position order.
+//   An odd last node is promoted unchanged (never paired with itself); empty → null; one leaf → its leaf hash.
+// A v2 proof is the RFC audit path; folding it needs the leaf index and the tree size. Batches anchored under v1
+// stay v1 for ever (anchor_batches.tree_rule): a verifier picks the fold by rule and never re-folds an old batch.
+export const TREE_RULE_V1 = "v1";
+export const TREE_RULE_V2 = "v2";
+
+function hexBytes(hex) {
+  if (typeof hex !== "string" || !/^[0-9a-f]{64}$/.test(hex)) throw new Error("merkle v2: a node must be 64 lowercase hex characters");
+  const out = new Uint8Array(32);
+  for (let i = 0; i < 32; i++) out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  return out;
+}
+
+async function prefixedHash(prefix, ...parts) {
+  const buf = new Uint8Array(1 + parts.length * 32);
+  buf[0] = prefix;
+  parts.forEach((p, i) => buf.set(p, 1 + i * 32));
+  return new Uint8Array(await crypto.subtle.digest("SHA-256", buf));
+}
+
+const bytesHex = (b) => [...b].map((x) => x.toString(16).padStart(2, "0")).join("");
+
+/** v2 leaf hash of a 64-hex leaf: SHA-256(0x00 || bytes), as hex. */
+export async function leafHashV2(leaf) {
+  return bytesHex(await prefixedHash(0x00, hexBytes(leaf)));
+}
+
+async function levelsV2(leaves) {
+  let level = [];
+  for (const l of leaves) level.push(await prefixedHash(0x00, hexBytes(l)));
+  const levels = [level];
+  while (level.length > 1) {
+    const next = [];
+    for (let i = 0; i + 1 < level.length; i += 2) next.push(await prefixedHash(0x01, level[i], level[i + 1]));
+    if (level.length % 2 === 1) next.push(level[level.length - 1]);
+    level = next;
+    levels.push(level);
+  }
+  return levels;
+}
+
+export async function merkleRootV2(leaves) {
+  if (!leaves || !leaves.length) return null;
+  const levels = await levelsV2(leaves);
+  return bytesHex(levels[levels.length - 1][0]);
+}
+
+/** The RFC audit path for the leaf at `index`, leaf to root, as hex. */
+export async function merkleProofV2(leaves, index) {
+  if (!leaves || !Number.isInteger(index) || index < 0 || index >= leaves.length) return null;
+  const levels = await levelsV2(leaves);
+  const path = [];
+  let idx = index;
+  for (const level of levels.slice(0, -1)) {
+    const sib = idx ^ 1;
+    if (sib < level.length) path.push(bytesHex(level[sib]));
+    idx >>= 1;
+  }
+  return path;
+}
+
+/** RFC 9162 2.1.3.2: fold `proof` from leaf `index` of a tree of `size` leaves and compare with `root`. */
+export async function verifyProofV2(leaf, index, size, proof, root) {
+  try {
+    if (!Number.isInteger(index) || !Number.isInteger(size) || index < 0 || index >= size) return false;
+    let fn = index;
+    let sn = size - 1;
+    let r = await prefixedHash(0x00, hexBytes(leaf));
+    for (const hex of proof || []) {
+      const p = hexBytes(hex);
+      if (sn === 0) return false;
+      if ((fn & 1) === 1 || fn === sn) {
+        r = await prefixedHash(0x01, p, r);
+        if ((fn & 1) === 0) {
+          while ((fn & 1) === 0 && fn !== 0) {
+            fn >>= 1;
+            sn >>= 1;
+          }
+        }
+      } else {
+        r = await prefixedHash(0x01, r, p);
+      }
+      fn >>= 1;
+      sn >>= 1;
+    }
+    return sn === 0 && bytesHex(r) === root;
+  } catch {
+    return false;
+  }
+}
+
+/** The fold a batch's rule names. Unknown rules are refused, never folded as v1. */
+export function treeRuleOf(value) {
+  if (value === undefined || value === null || value === "" || value === TREE_RULE_V1) return TREE_RULE_V1;
+  if (value === TREE_RULE_V2) return TREE_RULE_V2;
+  return null;
+}

package/src/record.mjs

@@ -0,0 +1,440 @@
+// Offline check for a signed agent record (GET /api/record/:handle/export).
+//
+// The 0–100 formula adapts lib/bureau/scoring.ts and matches lib/record/score.ts.
+// Good = paid on time, an approval, or a recorded outcome.
+// Adverse = claim paid, or a denial. A filed claim that was not paid is in
+// the total only. Windows are 7-day buckets of the events themselves, newest
+// first, weighted 1, 1/2, 1/4, … Stability is 1/(1+variance) of the per-window
+// good rate, and it applies only when two or more windows exist.
+//
+//   base = reliability * (1 - incident rate)
+//   score = round(100 * base)                         when one window
+//   score = round(100 * base * (0.5 + 0.5 * stability)) when two or more
+//
+// score_version 2. A self-reported event weighs SELF_REPORTED_WEIGHT. An agent
+// with only self-reported scoring events cannot score above SELF_REPORTED_CAP.
+// Missing provenance weighs 1, so a version 1 set of settlements and claims
+// still produces the same number. Exports that omit score_version are read
+// with agentRecordV1. Written form: docs/record/score.md.
+//
+// No scoring event → score is null, label "New, no record yet".
+// The signature is EdDSA with the Bond key published at /.well-known/jwks.json.
+// This file does not fetch that URL and does not trust a key embedded in the file.
+
+import { canonicalize } from "./evidence.mjs";
+
+export const NEW_RECORD_LABEL = "New, no record yet";
+export const SCORE_VERSION = 2;
+export const SELF_REPORTED_WEIGHT = 0.25;
+export const SELF_REPORTED_CAP = 40;
+export const RECORD_TYP = "agentics.record.v1";
+export const RECORD_ISS = "https://agentics.you";
+export const RECORD_JWT_TYP = "agentics-record+jwt";
+const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
+const DAY_MS = 24 * 60 * 60 * 1000;
+const HEX64 = /^[0-9a-f]{64}$/;
+const HANDLE = /^[a-z0-9][a-z0-9-]{0,29}$/;
+const V1_KINDS = new Set(["paid_on_time", "claim_filed", "claim_paid"]);
+const KINDS = new Set([
+  "paid_on_time",
+  "claim_filed",
+  "claim_paid",
+  "denial",
+  "approval",
+  "outcome",
+  "outcome_adverse",
+]);
+const PROVENANCE = new Set(["verified_by_agentics", "self_reported", "imported"]);
+
+function clamp01(x) {
+  if (!Number.isFinite(x)) return 0;
+  if (x < 0) return 0;
+  if (x > 1) return 1;
+  return x;
+}
+
+function recencyWeight(windowIndex) {
+  return Math.pow(0.5, Math.max(0, windowIndex));
+}
+
+function iso(v) {
+  if (v instanceof Date) return Number.isFinite(v.getTime()) ? v.toISOString() : null;
+  if (typeof v === "string" && v.trim()) {
+    const t = Date.parse(v);
+    return Number.isFinite(t) ? new Date(t).toISOString() : null;
+  }
+  return null;
+}
+
+export function publicSeller(value) {
+  if (value == null) return null;
+  const s = String(value).trim().toLowerCase();
+  if (!s || s.includes("@") || /\s/.test(s) || s.length > 253) return null;
+  return s;
+}
+
+export function normalizeEvents(events) {
+  const seen = new Set();
+  const out = [];
+  for (const raw of events ?? []) {
+    if (!raw || typeof raw !== "object") continue;
+    const kind = String(raw.kind ?? "");
+    if (!KINDS.has(kind)) continue;
+    const at = iso(raw.at);
+    if (!at) continue;
+    const hash = raw.receipt_hash == null ? "" : String(raw.receipt_hash).trim().toLowerCase();
+    if (hash && !HEX64.test(hash)) continue;
+    if (hash) {
+      const key = `${kind}:${hash}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+    }
+    const seller = publicSeller(raw.seller);
+    const event = { kind, at };
+    if (seller) event.seller = seller;
+    if (hash) event.receipt_hash = hash;
+    const provenance = provenanceOf(raw.provenance);
+    if (provenance) event.provenance = provenance;
+    out.push(event);
+  }
+  return out;
+}
+
+function provenanceOf(value) {
+  return typeof value === "string" && PROVENANCE.has(value) ? value : undefined;
+}
+
+function eventWeight(event) {
+  return event.provenance === "self_reported" ? SELF_REPORTED_WEIGHT : 1;
+}
+
+export function recordWindows(events) {
+  const buckets = new Map();
+  for (const event of events) {
+    const t = Date.parse(event.at);
+    if (!Number.isFinite(t)) continue;
+    const key = Math.floor(t / WEEK_MS);
+    const bucket = buckets.get(key) ?? { total: 0, good: 0, adverse: 0 };
+    const weight = eventWeight(event);
+    bucket.total += weight;
+    if (event.kind === "paid_on_time" || event.kind === "approval" || event.kind === "outcome") bucket.good += weight;
+    if (event.kind === "claim_paid" || event.kind === "denial" || event.kind === "outcome_adverse") bucket.adverse += weight;
+    buckets.set(key, bucket);
+  }
+  return [...buckets.keys()]
+    .sort((a, b) => b - a)
+    .map((key, index) => {
+      const bucket = buckets.get(key);
+      return { window_index: index, total: bucket.total, good: bucket.good, adverse: bucket.adverse };
+    });
+}
+
+function recordReliability(windows) {
+  let num = 0;
+  let den = 0;
+  for (const w of windows) {
+    const weight = recencyWeight(w.window_index);
+    const total = Math.max(0, Number(w.total) || 0);
+    num += weight * Math.max(0, Number(w.good) || 0);
+    den += weight * total;
+  }
+  if (den <= 0) return null;
+  return clamp01(num / den);
+}
+
+function recordIncidentRate(windows) {
+  let num = 0;
+  let den = 0;
+  for (const w of windows) {
+    const weight = recencyWeight(w.window_index);
+    const total = Math.max(0, Number(w.total) || 0);
+    num += weight * Math.max(0, Number(w.adverse) || 0);
+    den += weight * total;
+  }
+  if (den <= 0) return null;
+  return clamp01(num / den);
+}
+
+function recordStability(windows) {
+  const rates = [];
+  for (const w of windows) {
+    const total = Math.max(0, Number(w.total) || 0);
+    if (total <= 0) continue;
+    rates.push(clamp01(Math.max(0, Number(w.good) || 0) / total));
+  }
+  if (rates.length < 2) return null;
+  const mean = rates.reduce((a, b) => a + b, 0) / rates.length;
+  const ss = rates.reduce((a, b) => a + (b - mean) * (b - mean), 0);
+  return clamp01(1 / (1 + ss / rates.length));
+}
+
+function scoreFromWindows(windows) {
+  const reliability = recordReliability(windows);
+  const incident = recordIncidentRate(windows);
+  if (reliability == null || incident == null) return null;
+  const stability = recordStability(windows);
+  const base = reliability * (1 - incident);
+  const scaled = stability == null ? base : base * (0.5 + 0.5 * stability);
+  if (!Number.isFinite(scaled)) return null;
+  return Math.round(clamp01(scaled) * 100);
+}
+
+function selfReportedOnly(events) {
+  return events.length > 0 && events.every((event) => event.provenance === "self_reported");
+}
+
+export function recordScore(events) {
+  const kept = normalizeEvents(events);
+  const score = scoreFromWindows(recordWindows(kept));
+  if (score == null) return null;
+  if (selfReportedOnly(kept)) return Math.min(score, SELF_REPORTED_CAP);
+  return score;
+}
+
+export function agentRecord(events, asOf) {
+  const kept = normalizeEvents(events);
+  const score = kept.length ? recordScore(kept) : null;
+  const sellers = new Set();
+  let first = Infinity;
+  for (const event of kept) {
+    if (event.seller) sellers.add(event.seller);
+    const t = Date.parse(event.at);
+    if (t < first) first = t;
+  }
+  const asOfMs = asOf instanceof Date ? asOf.getTime() : Date.parse(String(asOf));
+  const age = kept.length && Number.isFinite(first) && Number.isFinite(asOfMs)
+    ? Math.max(0, Math.floor((asOfMs - first) / DAY_MS))
+    : null;
+  return {
+    paid_on_time: kept.filter((event) => event.kind === "paid_on_time").length,
+    claims_filed: kept.filter((event) => event.kind === "claim_filed").length,
+    claims_paid: kept.filter((event) => event.kind === "claim_paid").length,
+    denials: kept.filter((event) => event.kind === "denial").length,
+    approvals: kept.filter((event) => event.kind === "approval").length,
+    outcomes: kept.filter((event) => event.kind === "outcome" || event.kind === "outcome_adverse").length,
+    distinct_sellers: sellers.size,
+    age_days: age,
+    verified_actions: kept.filter((event) => event.provenance !== "self_reported").length,
+    score,
+    score_version: SCORE_VERSION,
+    label: kept.length === 0 || score == null ? NEW_RECORD_LABEL : String(score),
+  };
+}
+
+/** Version 1 shape. Denials, approvals, outcomes, and provenance do not count. */
+export function agentRecordV1(events, asOf) {
+  const classic = normalizeEvents(events)
+    .filter((event) => V1_KINDS.has(event.kind))
+    .map((event) => {
+      const next = { kind: event.kind, at: event.at };
+      if (event.seller) next.seller = event.seller;
+      if (event.receipt_hash) next.receipt_hash = event.receipt_hash;
+      return next;
+    });
+  const score = classic.length ? scoreFromWindows(recordWindows(classic)) : null;
+  const sellers = new Set();
+  let first = Infinity;
+  for (const event of classic) {
+    if (event.seller) sellers.add(event.seller);
+    const t = Date.parse(event.at);
+    if (t < first) first = t;
+  }
+  const asOfMs = asOf instanceof Date ? asOf.getTime() : Date.parse(String(asOf));
+  const age = classic.length && Number.isFinite(first) && Number.isFinite(asOfMs)
+    ? Math.max(0, Math.floor((asOfMs - first) / DAY_MS))
+    : null;
+  return {
+    paid_on_time: classic.filter((event) => event.kind === "paid_on_time").length,
+    claims_filed: classic.filter((event) => event.kind === "claim_filed").length,
+    claims_paid: classic.filter((event) => event.kind === "claim_paid").length,
+    distinct_sellers: sellers.size,
+    age_days: age,
+    score,
+    label: classic.length === 0 || score == null ? NEW_RECORD_LABEL : String(score),
+  };
+}
+
+export function recordOutcomes(events) {
+  return normalizeEvents(events).sort((a, b) => {
+    if (a.at < b.at) return -1;
+    if (a.at > b.at) return 1;
+    const ah = a.receipt_hash ?? "";
+    const bh = b.receipt_hash ?? "";
+    if (ah < bh) return -1;
+    if (ah > bh) return 1;
+    if (a.kind < b.kind) return -1;
+    if (a.kind > b.kind) return 1;
+    return 0;
+  });
+}
+
+export function canonicalJson(value) {
+  return JSON.stringify(canonicalize(value));
+}
+
+function b64urlEncode(bytes) {
+  const u8 = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);
+  let str = "";
+  for (let i = 0; i < u8.length; i++) str += String.fromCharCode(u8[i]);
+  return btoa(str).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+
+function b64urlDecode(s) {
+  const pad = s.length % 4 === 0 ? "" : "=".repeat(4 - (s.length % 4));
+  const b64 = String(s).replace(/-/g, "+").replace(/_/g, "/") + pad;
+  const bin = atob(b64);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+}
+
+async function sha256Hex(text) {
+  const buf = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text));
+  return [...new Uint8Array(buf)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+async function publicParts(privateJwk) {
+  if (!privateJwk || privateJwk.kty !== "OKP" || privateJwk.crv !== "Ed25519" || !privateJwk.x || !privateJwk.d) {
+    throw new Error("bond_signing_jwk_invalid");
+  }
+  const kid = privateJwk.kid || (await sha256Hex(privateJwk.x)).slice(0, 16);
+  return { kid, x: privateJwk.x };
+}
+
+export function recordBundle({ handle, as_of, outcomes }) {
+  const list = recordOutcomes(outcomes);
+  const asOf = typeof as_of === "string" ? new Date(as_of).toISOString() : new Date(as_of).toISOString();
+  return {
+    v: 1,
+    typ: RECORD_TYP,
+    iss: RECORD_ISS,
+    handle: String(handle || "").trim().toLowerCase(),
+    as_of: asOf,
+    record: agentRecord(list, asOf),
+    outcomes: list,
+  };
+}
+
+function bundleError(bundle) {
+  if (!bundle || typeof bundle !== "object") return "malformed";
+  if (bundle.v !== 1 || bundle.typ !== RECORD_TYP) return "malformed";
+  if (bundle.iss !== RECORD_ISS) return "bad_iss";
+  if (typeof bundle.handle !== "string" || !HANDLE.test(bundle.handle)) return "bad_handle";
+  if (typeof bundle.as_of !== "string" || !Number.isFinite(Date.parse(bundle.as_of))) return "bad_time";
+  if (!bundle.record || typeof bundle.record !== "object" || !Array.isArray(bundle.outcomes)) return "malformed";
+  return null;
+}
+
+function recordVersion(record) {
+  return Number(record?.score_version) === SCORE_VERSION ? SCORE_VERSION : 1;
+}
+
+/** Version 2 records use the current formula. Anything else is read as version 1. */
+function expectedRecord(bundle) {
+  return recordVersion(bundle?.record) === SCORE_VERSION
+    ? agentRecord(bundle.outcomes, bundle.as_of)
+    : agentRecordV1(bundle.outcomes, bundle.as_of);
+}
+
+/** Sign the canonical bundle. Refuses a record that the outcomes do not produce. */
+export async function signRecord(privateJwk, bundle) {
+  const reason = bundleError(bundle);
+  if (reason) throw new Error(reason);
+  const expected = expectedRecord(bundle);
+  if (canonicalJson(expected) !== canonicalJson(bundle.record)) throw new Error("record_mismatch");
+  return signRecordPayload(privateJwk, bundle);
+}
+
+/** Sign whatever object is passed. Used to prove a lying payload still fails. */
+export async function signRecordPayload(privateJwk, bundle) {
+  const pub = await publicParts(privateJwk);
+  const header = { alg: "EdDSA", typ: RECORD_JWT_TYP, kid: pub.kid };
+  const payload = canonicalJson(bundle);
+  const signingInput = `${b64urlEncode(new TextEncoder().encode(canonicalJson(header)))}.${b64urlEncode(new TextEncoder().encode(payload))}`;
+  const key = await crypto.subtle.importKey(
+    "jwk",
+    { ...privateJwk, kid: pub.kid, alg: "EdDSA" },
+    { name: "Ed25519" },
+    false,
+    ["sign"],
+  );
+  const sig = await crypto.subtle.sign({ name: "Ed25519" }, key, new TextEncoder().encode(signingInput));
+  return `${signingInput}.${b64urlEncode(sig)}`;
+}
+
+// Stable `reason` codes stay as they are. `message` is the sentence a person
+// can read. Clock time does not expire a record: a key verifies old exports
+// for as long as it is still published.
+const RECORD_MESSAGES = {
+  malformed: "That doesn't look like a signed record.",
+  bad_header: "The signature header is not an EdDSA record.",
+  no_key: "No published key is available to check this record.",
+  unknown_kid: "This record was signed by a key that is not in the published set.",
+  bad_iss: "This record was not issued by Agentics.",
+  bad_handle: "The agent handle on this record is not valid.",
+  bad_time: "The record time is not a real timestamp.",
+  bad_sig: "The signature does not match this record.",
+  body_mismatch: "A field in this record was changed after it was signed.",
+  record_mismatch: "The score does not match the outcomes in this record.",
+};
+
+function fail(reason) {
+  return { ok: false, reason, message: RECORD_MESSAGES[reason] || "This record did not check out." };
+}
+
+/**
+ * Verify a record export offline.
+ * `jwks` is the caller's copy of /.well-known/jwks.json. A key inside the file is ignored.
+ */
+export async function verifyRecord(bundle, jwks) {
+  if (!bundle || typeof bundle !== "object") return fail("malformed");
+  const jws = bundle.jws;
+  if (typeof jws !== "string" || !jws) return fail("malformed");
+  const parts = jws.split(".");
+  if (parts.length !== 3 || parts.some((part) => !part)) return fail("malformed");
+  let header;
+  let payload;
+  try {
+    header = JSON.parse(new TextDecoder().decode(b64urlDecode(parts[0])));
+    payload = JSON.parse(new TextDecoder().decode(b64urlDecode(parts[1])));
+  } catch {
+    return fail("malformed");
+  }
+  if (!header || header.alg !== "EdDSA" || header.typ !== RECORD_JWT_TYP || !header.kid) return fail("bad_header");
+  const keys = Array.isArray(jwks?.keys) ? jwks.keys : [];
+  if (!keys.length) return fail("no_key");
+  const match = keys.find((key) => key && key.kid === header.kid && key.kty === "OKP" && key.crv === "Ed25519" && key.x);
+  if (!match) return fail("unknown_kid");
+  const reason = bundleError(payload);
+  if (reason) return fail(reason);
+  try {
+    const key = await crypto.subtle.importKey(
+      "jwk",
+      { kty: "OKP", crv: "Ed25519", x: match.x, alg: "EdDSA" },
+      { name: "Ed25519" },
+      false,
+      ["verify"],
+    );
+    const ok = await crypto.subtle.verify(
+      { name: "Ed25519" },
+      key,
+      b64urlDecode(parts[2]),
+      new TextEncoder().encode(`${parts[0]}.${parts[1]}`),
+    );
+    if (!ok) return fail("bad_sig");
+  } catch {
+    return fail("bad_sig");
+  }
+  const body = { ...bundle };
+  delete body.jws;
+  if (canonicalJson(body) !== canonicalJson(payload)) return fail("body_mismatch");
+  const expected = expectedRecord(payload);
+  if (canonicalJson(expected) !== canonicalJson(payload.record)) return fail("record_mismatch");
+  return { ok: true, handle: payload.handle, record: payload.record };
+}
+
+export function isRecordBundle(bundle) {
+  return !!bundle && typeof bundle === "object" && (
+    bundle.typ === RECORD_TYP || (typeof bundle.jws === "string" && Array.isArray(bundle.outcomes))
+  );
+}