@agenticstechnologies/verify 0.0.0-stage → 1.0.1

package/src/bundle.mjs

@@ -0,0 +1,364 @@
+// Full offline check of an evidence export or a proof bundle.
+// Leaf and prev_hash: verifyEvidenceExport (GET /api/proof/export).
+// A single-receipt proof bundle (GET /api/proof/bundle) has `receipt` instead
+// of `receipts`; its chain array is hash links only.
+// Merkle and Solana run only when the bundle carries those fields.
+
+import { clearedLeafMatches, leafHash, verifyEvidenceExport } from "./evidence.mjs";
+import { merkleRoot, merkleRootV2, treeRuleOf, TREE_RULE_V2, verifyProof, verifyProofV2 } from "./merkle.mjs";
+import { checkSolanaMemo, classifyCluster } from "./solana.mjs";
+
+const HEX64 = /^[0-9a-f]{64}$/;
+
+function failure(reason, hashOk = false, chainOk = false) {
+  return {
+    receipt_hash: "",
+    prev_hash: "",
+    hash_ok: hashOk,
+    chain_ok: chainOk,
+    reason,
+  };
+}
+
+function hex64(v) {
+  if (typeof v !== "string") return null;
+  const s = v.trim().toLowerCase();
+  return HEX64.test(s) ? s : null;
+}
+
+function text(v) {
+  if (v == null) return null;
+  const s = String(v).trim();
+  return s.length ? s : null;
+}
+
+function linksOldestFirst(chain) {
+  for (let i = 0; i < chain.length; i++) {
+    const prev = String((chain[i] ?? {}).prev_hash ?? "");
+    if (i === 0) {
+      if (!HEX64.test(prev)) return false;
+    } else if (prev !== String((chain[i - 1] ?? {}).receipt_hash ?? "")) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function linksNewestFirst(chain) {
+  for (let i = 0; i < chain.length; i++) {
+    const prev = String((chain[i] ?? {}).prev_hash ?? "");
+    if (!HEX64.test(prev)) return false;
+    if (i < chain.length - 1 && prev !== String((chain[i + 1] ?? {}).receipt_hash ?? "")) {
+      return false;
+    }
+  }
+  return true;
+}
+
+async function verifySingleReceipt(bundle) {
+  const canonical = bundle.receipt ?? {};
+  const claimed = String(bundle.receipt_hash ?? "");
+  const prev = String(canonical.prev_hash ?? "");
+  let recomputed = "";
+  let hashOk = false;
+  try {
+    recomputed = await leafHash(canonical);
+    hashOk = recomputed === claimed || await clearedLeafMatches(canonical, claimed, leafHash, {
+      text_cleared_at: bundle.text_cleared_at,
+      hash_version: bundle.hash_version ?? canonical.hash_version,
+      uncleared_digest: bundle.uncleared_digest,
+      status: bundle.status,
+    });
+  } catch {
+    hashOk = false;
+  }
+  let chainOk = true;
+  let reason = null;
+  if (!hashOk) reason = `leaf recomputed ${recomputed} != ${claimed}`;
+  if (Array.isArray(bundle.chain) && bundle.chain.length > 0) {
+    const forward = linksOldestFirst(bundle.chain);
+    const backward = linksNewestFirst(bundle.chain);
+    if (!forward && !backward) {
+      chainOk = false;
+      reason = reason ?? "prev_hash does not match the previous receipt_hash";
+    } else {
+      const mine = bundle.chain.find((row) => String((row ?? {}).receipt_hash ?? "") === claimed);
+      if (!mine) {
+        chainOk = false;
+        reason = reason ?? "receipt_hash is not in the chain";
+      } else if (String(mine.prev_hash ?? "") !== prev) {
+        chainOk = false;
+        reason = reason ?? "prev_hash does not match the previous receipt_hash";
+      }
+    }
+  } else if (!HEX64.test(prev)) {
+    chainOk = false;
+    reason = reason ?? "prev_hash is not 64 hex characters";
+  }
+  const failures = [];
+  if (!hashOk || !chainOk) {
+    failures.push({
+      receipt_hash: claimed,
+      prev_hash: prev,
+      hash_ok: hashOk,
+      chain_ok: chainOk,
+      reason: reason ?? "failed",
+    });
+  }
+  return { checked: 1, failures };
+}
+
+function hexList(v) {
+  if (!Array.isArray(v)) return null;
+  return v.map((item) => (typeof item === "string" ? item.trim().toLowerCase() : ""));
+}
+
+function claimFrom(merkle, leaf) {
+  if (!merkle || typeof merkle !== "object") return null;
+  const root = hex64(merkle.root) || hex64(merkle.merkle_root);
+  const siblings = Array.isArray(merkle.siblings)
+    ? hexList(merkle.siblings)
+    : (Array.isArray(merkle.proof) ? hexList(merkle.proof) : null);
+  const leaves = Array.isArray(merkle.leaves) ? hexList(merkle.leaves) : null;
+  const index = Number.isInteger(merkle.index)
+    ? merkle.index
+    : (Number.isInteger(merkle.leaf_index) ? merkle.leaf_index : null);
+  if (!root && !siblings && !leaves) return null;
+  const size = Number.isInteger(merkle.leaf_count) ? merkle.leaf_count : (Number.isInteger(merkle.tree_size) ? merkle.tree_size : null);
+  return {
+    root,
+    siblings,
+    leaves,
+    index,
+    size,
+    // anchor_batches.tree_rule (L3-16). Absent is v1, the rule every batch before v2 was anchored under.
+    rule: merkle.tree_rule ?? null,
+    leaf: hex64(merkle.leaf) || leaf || null,
+  };
+}
+
+function merkleClaims(bundle) {
+  const claims = [];
+  const topLeaf = hex64(bundle.receipt_hash);
+  const top = claimFrom(bundle.merkle, topLeaf);
+  if (top) claims.push(top);
+  if (Array.isArray(bundle.receipts)) {
+    for (const row of bundle.receipts) {
+      if (!row || typeof row !== "object" || row.merkle == null) continue;
+      const rowClaim = claimFrom(row.merkle, hex64(row.receipt_hash));
+      if (rowClaim) claims.push(rowClaim);
+    }
+  }
+  // ledger_batches / anchor batch rows, if an export included them.
+  // Same field names as proof.ts: merkle_root, plus siblings or leaves.
+  if (Array.isArray(bundle.batches)) {
+    for (const batch of bundle.batches) {
+      if (!batch || typeof batch !== "object") continue;
+      const rowClaim = claimFrom({
+        root: batch.root,
+        merkle_root: batch.merkle_root,
+        siblings: batch.siblings,
+        proof: batch.proof,
+        leaves: batch.leaves,
+        index: batch.index,
+        leaf_index: batch.leaf_index,
+        leaf_count: batch.leaf_count,
+        tree_rule: batch.tree_rule,
+      }, topLeaf);
+      if (rowClaim) claims.push(rowClaim);
+    }
+  }
+  return claims;
+}
+
+async function checkClaim(claim) {
+  const reasons = [];
+  let confirmed = null;
+  const rule = treeRuleOf(claim.rule);
+  if (rule === null) {
+    reasons.push(`unknown merkle tree rule ${String(claim.rule).slice(0, 40)}`);
+    return { reasons, root: null };
+  }
+  const v2 = rule === TREE_RULE_V2;
+  if (!claim.root) {
+    reasons.push("merkle root is missing");
+    return { reasons, root: null };
+  }
+  if (!claim.leaves && !claim.siblings) {
+    reasons.push("merkle root is present but the export has no leaves or siblings to recompute");
+    return { reasons, root: null };
+  }
+  if (claim.leaves) {
+    if (claim.leaves.some((h) => !HEX64.test(h))) {
+      reasons.push("merkle leaf is not 64 hex characters");
+    } else {
+      const recomputed = v2 ? await merkleRootV2(claim.leaves) : await merkleRoot(claim.leaves);
+      if (recomputed !== claim.root) {
+        reasons.push(`merkle root recomputed ${recomputed} != ${claim.root}`);
+      } else {
+        confirmed = recomputed;
+      }
+      if (claim.index != null) {
+        if (claim.index < 0 || claim.index >= claim.leaves.length) {
+          reasons.push("merkle index is outside the leaf list");
+        } else if (claim.leaf && claim.leaves[claim.index] !== claim.leaf) {
+          reasons.push("merkle index does not point at the receipt hash");
+        }
+      }
+    }
+  }
+  if (claim.siblings) {
+    if (!claim.leaf) {
+      reasons.push("merkle proof is present but no leaf hash");
+    } else if (claim.siblings.some((h) => !HEX64.test(h))) {
+      reasons.push("merkle sibling is not 64 hex characters");
+    } else {
+      const size = claim.size ?? claim.leaves?.length ?? null;
+      if (v2 && (claim.index == null || size == null)) {
+        reasons.push("a v2 merkle proof needs the leaf index and leaf_count");
+      } else {
+        const folded = v2
+          ? await verifyProofV2(claim.leaf, claim.index, size, claim.siblings, claim.root)
+          : await verifyProof(claim.leaf, claim.siblings, claim.root);
+        if (!folded) reasons.push(`merkle proof does not fold to ${claim.root}`);
+        else if (!confirmed) confirmed = claim.root;
+      }
+    }
+  }
+  return { reasons, root: reasons.length === 0 ? confirmed : null };
+}
+
+async function verifyMerkle(bundle) {
+  const claims = merkleClaims(bundle);
+  if (claims.length === 0) {
+    return {
+      status: "not-present",
+      reason: "batch/merkle fields are not in this export",
+      roots: [],
+    };
+  }
+  const reasons = [];
+  const roots = [];
+  for (const claim of claims) {
+    const checked = await checkClaim(claim);
+    reasons.push(...checked.reasons);
+    if (checked.root) roots.push(checked.root);
+  }
+  if (reasons.length) {
+    return { status: "fail", reason: reasons[0], roots: [] };
+  }
+  return { status: "pass", reason: null, roots };
+}
+
+function anchorFrom(bundle) {
+  const a = bundle.anchor && typeof bundle.anchor === "object" ? bundle.anchor : null;
+  const src = a ?? {};
+  const tx = text(src.txid) || text(src.tx) || text(src.tx_hash) || text(bundle.tx) || text(bundle.txid) || text(bundle.anchor_txid);
+  const clusterHint = text(src.cluster) || text(src.chain) || text(bundle.cluster) || text(bundle.anchor_chain);
+  const explorer = text(src.explorer_url);
+  const memo = text(src.memo) || text(bundle.memo);
+  if (!a && !tx && !clusterHint) return null;
+  return { tx, clusterHint, explorer, memo };
+}
+
+async function verifySolana(bundle, merkle, opts) {
+  const anchor = anchorFrom(bundle);
+  // Local consistency: memo must equal a recomputed root even when there is
+  // no transaction to fetch, and even when the memo is not 64 hex characters.
+  // This does not call the network.
+  const memoText = anchor && anchor.memo ? String(anchor.memo).trim().toLowerCase() : "";
+  const memoHex = anchor ? hex64(anchor.memo) : null;
+  const roots = merkle.roots || [];
+  if (memoText && roots.length && !roots.includes(memoText)) {
+    return { status: "fail", reason: "anchor memo does not equal the recomputed merkle root" };
+  }
+  if (!anchor || (!anchor.tx && !anchor.clusterHint && !anchor.explorer)) {
+    return { status: "not-present", reason: "tx/cluster are not in this export" };
+  }
+  if (!anchor.tx || !(anchor.clusterHint || anchor.explorer)) {
+    return { status: "not-present", reason: "tx and cluster are both required" };
+  }
+  const cluster = classifyCluster(anchor.clusterHint, anchor.explorer);
+  if (cluster === "mainnet") {
+    return {
+      status: "warn",
+      reason: "solana memo not checked: cluster is mainnet; public devnet and testnet only",
+    };
+  }
+  if (cluster !== "devnet" && cluster !== "testnet") {
+    return {
+      status: "warn",
+      reason: "solana memo not checked: cluster is not devnet or testnet",
+    };
+  }
+  const expected = (memoHex && roots.includes(memoHex) ? memoHex : roots[0]) || memoHex;
+  if (!expected) {
+    return {
+      status: "not-present",
+      reason: "no merkle root or memo to compare",
+    };
+  }
+  const checked = await checkSolanaMemo({
+    txid: anchor.tx,
+    cluster,
+    expected,
+    timeoutMs: opts.timeoutMs,
+    fetchImpl: opts.fetchImpl,
+  });
+  if (checked.ok) return { status: "pass", reason: null };
+  if (checked.warn) return { status: "warn", reason: checked.reason };
+  return { status: "fail", reason: checked.reason };
+}
+
+/**
+ * @param {unknown} bundle
+ * @param {{ timeoutMs?: number, fetchImpl?: typeof fetch }} [opts]
+ */
+export async function verifyBundle(bundle, opts = {}) {
+  if (!bundle || typeof bundle !== "object" || Array.isArray(bundle)) {
+    return {
+      ok: false,
+      checked: 0,
+      failures: [failure("bundle is not an object")],
+      merkle: { status: "not-present", reason: "batch/merkle fields are not in this export" },
+      solana: { status: "not-present", reason: "tx/cluster are not in this export" },
+    };
+  }
+
+  let checked = 0;
+  /** @type {ReturnType<typeof failure>[]} */
+  let failures = [];
+  if (Array.isArray(bundle.receipts)) {
+    const leaf = await verifyEvidenceExport(bundle);
+    checked = leaf.checked;
+    failures = leaf.failures.slice();
+  } else if (bundle.receipt && typeof bundle.receipt === "object") {
+    const one = await verifySingleReceipt(bundle);
+    checked = one.checked;
+    failures = one.failures.slice();
+  } else {
+    failures = [failure("bundle.receipts is missing")];
+  }
+
+  // A receipts export already records this inside verifyEvidenceExport.
+  // A single-receipt proof bundle (GET /api/proof/bundle, the sample receipt)
+  // did not, so a truncated file could still pass leaf and Merkle.
+  if (bundle.verification && bundle.verification.truncated === true) {
+    const already = failures.some((row) => String(row.reason).includes("truncated"));
+    if (!already) failures.push(failure("export was truncated; refuse to call it complete"));
+  }
+
+  const merkle = await verifyMerkle(bundle);
+  if (merkle.status === "fail") failures.push(failure(merkle.reason));
+
+  const solana = await verifySolana(bundle, merkle, opts);
+  if (solana.status === "fail") failures.push(failure(solana.reason));
+
+  return {
+    ok: failures.length === 0,
+    checked,
+    failures,
+    merkle: { status: merkle.status, reason: merkle.reason },
+    solana: { status: solana.status, reason: solana.reason },
+  };
+}

package/src/cleared.d.ts

@@ -0,0 +1,11 @@
+export function clearedLeafMatches(
+  canonical: Record<string, unknown>,
+  storedHash: string,
+  leafHash: (canonical: Record<string, unknown>) => Promise<string>,
+  meta?: {
+    text_cleared_at?: unknown;
+    hash_version?: unknown;
+    uncleared_digest?: unknown;
+    status?: unknown;
+  },
+): Promise<boolean>;

package/src/cleared.mjs

@@ -0,0 +1,120 @@
+// Cleared-text leaf check. Shared by the evidence export, the proof bundle,
+// and the server (lib/gateway/proof.ts passes its own leafHash).
+//
+// Retention and deletion null free text and set text_cleared_at. They do not
+// rewrite receipt_hash. The older leaf (hash_version null, 2, or 3) covers
+// `outcome`, so a straight recompute misses after that column is null.
+//
+// When text_cleared_at is set:
+//   * Cleared fields are not put back. The stored hash is their commitment.
+//   * Older leaves: try the historical outcome labels in memory. A match means
+//     every field that was not cleared still agrees with the stored hash.
+//     The label that matched is not returned.
+//   * Version 4: reason, target, outcome, and error_message were inside the
+//     leaf. uncleared_digest, sealed when the text was cleared, is the hash of
+//     the leaf with those keys removed. Without that digest the leaf fails.
+//     An older outcome that is not in the historical list uses the same kind
+//     of digest, with outcome removed. Chain linkage is the caller's check.
+//
+// A receipt with no text_cleared_at still has to recompute exactly.
+
+export const LEGACY_OUTCOMES = Object.freeze([
+  "success",
+  "failed",
+  "partial",
+  "blocked",
+  "escalated",
+  "timeout",
+  "settled",
+  "attempted",
+  "circuit_open",
+  "fallback",
+  "retried",
+  "deployed",
+  "not_deployed",
+  "ok",
+  "clean",
+  "reversed",
+  "pending",
+  "human_override",
+  "escalation_needed",
+]);
+
+const HEX64 = /^[0-9a-f]{64}$/;
+const V4_CLEARED = ["reason", "target", "outcome", "error_message"];
+
+function hex64(value) {
+  const text = String(value ?? "").trim().toLowerCase();
+  return HEX64.test(text) ? text : "";
+}
+
+/**
+ * @param {Record<string, unknown>} canonical
+ * @param {string} storedHash
+ * @param {(canonical: Record<string, unknown>) => Promise<string>} leafHash
+ * @param {readonly string[]} [extraOutcomes]
+ */
+export async function legacyClearedMatches(canonical, storedHash, leafHash, extraOutcomes) {
+  const claimed = hex64(storedHash);
+  if (!claimed) return false;
+  const base = { ...(canonical || {}) };
+  delete base.text_cleared_at;
+  delete base.uncleared_digest;
+  const seen = new Set();
+  const list = extraOutcomes ? [...LEGACY_OUTCOMES, ...extraOutcomes] : LEGACY_OUTCOMES;
+  for (const outcome of list) {
+    if (typeof outcome !== "string") continue;
+    const label = outcome.trim();
+    if (!label || seen.has(label)) continue;
+    seen.add(label);
+    if (await leafHash({ ...base, outcome: label }) === claimed) return true;
+  }
+  return false;
+}
+
+/**
+ * Direct recompute, then the cleared-text rule.
+ * `meta.text_cleared_at` is the sibling flag. It is not part of the leaf.
+ *
+ * @param {Record<string, unknown>} canonical
+ * @param {string} storedHash
+ * @param {(canonical: Record<string, unknown>) => Promise<string>} leafHash
+ * @param {{ text_cleared_at?: unknown, hash_version?: unknown, uncleared_digest?: unknown, status?: unknown }} [meta]
+ */
+export async function clearedLeafMatches(canonical, storedHash, leafHash, meta) {
+  const raw = String(storedHash ?? "");
+  const claimed = hex64(raw);
+  let recomputed = "";
+  try {
+    recomputed = await leafHash(canonical || {});
+  } catch {
+    recomputed = "";
+  }
+  if (recomputed && (recomputed === raw || recomputed === claimed)) return true;
+  const cleared = meta?.text_cleared_at || canonical?.text_cleared_at;
+  if (!cleared) return false;
+  const version = Number(meta?.hash_version ?? canonical?.hash_version);
+  if (version === 4) {
+    if (!claimed) return false;
+    const digest = hex64(meta?.uncleared_digest || canonical?.uncleared_digest);
+    if (!digest) return false;
+    const body = { ...(canonical || {}) };
+    delete body.receipt_id;
+    delete body.batch_id;
+    delete body.text_cleared_at;
+    delete body.uncleared_digest;
+    for (const key of V4_CLEARED) delete body[key];
+    const partial = await leafHash(body);
+    return partial === digest;
+  }
+  const extra = [];
+  if (typeof meta?.status === "string" && meta.status.trim()) extra.push(meta.status.trim());
+  if (await legacyClearedMatches(canonical, claimed, leafHash, extra)) return true;
+  const digest = hex64(meta?.uncleared_digest || canonical?.uncleared_digest);
+  if (!digest) return false;
+  const body = { ...(canonical || {}) };
+  delete body.text_cleared_at;
+  delete body.uncleared_digest;
+  delete body.outcome;
+  return (await leafHash(body)) === digest;
+}

package/src/evidence.mjs

@@ -0,0 +1,112 @@
+// Leaf and prev_hash checks for GET /api/proof/export JSON.
+// Moved from scripts/verify-evidence.mjs so the package and that script share
+// one implementation. Behavior is unchanged:
+//   sha256Hex(JSON.stringify(canonicalize(canonical minus {receipt_id, batch_id})))
+// canonicalize sorts object keys recursively and drops null and undefined.
+// After the first row, prev_hash must equal the previous receipt_hash.
+// The first prev_hash must be 64 hex characters (genesis, or a receipt older
+// than the export window). A truncated export is not a pass.
+// When text_cleared_at is set, the stored hash covers the cleared fields
+// and every field that was not cleared is still checked.
+
+import { clearedLeafMatches } from "./cleared.mjs";
+
+export function canonicalize(v) {
+  if (v === null || v === undefined) return undefined;
+  if (Array.isArray(v)) return v.map(canonicalize);
+  if (typeof v === "object") {
+    const out = {};
+    for (const k of Object.keys(v).sort()) {
+      const cv = canonicalize(v[k]);
+      if (cv !== undefined) out[k] = cv;
+    }
+    return out;
+  }
+  return v;
+}
+
+export async function sha256Hex(input) {
+  const data = typeof input === "string" ? new TextEncoder().encode(input) : input;
+  const buf = await crypto.subtle.digest("SHA-256", data);
+  return [...new Uint8Array(buf)].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+
+export async function leafHash(canonical) {
+  const rest = { ...canonical };
+  delete rest.receipt_id;
+  delete rest.batch_id;
+  return sha256Hex(JSON.stringify(canonicalize(rest)));
+}
+
+export { clearedLeafMatches };
+
+/**
+ * @param {unknown} bundle
+ * @returns {Promise<{ ok: boolean, checked: number, failures: Array<{ receipt_hash: string, prev_hash: string, hash_ok: boolean, chain_ok: boolean, reason: string }> }>}
+ */
+export async function verifyEvidenceExport(bundle) {
+  const receipts = bundle && Array.isArray(bundle.receipts) ? bundle.receipts : null;
+  if (!receipts) {
+    return {
+      ok: false,
+      checked: 0,
+      failures: [{
+        receipt_hash: "",
+        prev_hash: "",
+        hash_ok: false,
+        chain_ok: false,
+        reason: "bundle.receipts is missing",
+      }],
+    };
+  }
+  const failures = [];
+  for (let i = 0; i < receipts.length; i++) {
+    const row = receipts[i] ?? {};
+    const canonical = row.canonical ?? {};
+    const claimed = String(row.receipt_hash ?? "");
+    const prev = String(canonical.prev_hash ?? "");
+    let recomputed = "";
+    try {
+      recomputed = await leafHash(canonical);
+    } catch {
+      recomputed = "";
+    }
+    const hashOk = recomputed === claimed || await clearedLeafMatches(canonical, claimed, leafHash, {
+      text_cleared_at: row.text_cleared_at,
+      hash_version: row.hash_version,
+      uncleared_digest: row.uncleared_digest,
+      status: row.status,
+    });
+    let chainOk = true;
+    let reason = null;
+    if (!hashOk) reason = `leaf recomputed ${recomputed} != ${claimed}`;
+    if (i === 0) {
+      if (!/^[0-9a-f]{64}$/.test(prev)) {
+        chainOk = false;
+        reason = reason ?? "prev_hash is not 64 hex characters";
+      }
+    } else if (prev !== String(receipts[i - 1].receipt_hash ?? "")) {
+      chainOk = false;
+      reason = reason ?? "prev_hash does not match the previous receipt_hash";
+    }
+    if (!hashOk || !chainOk) {
+      failures.push({
+        receipt_hash: claimed,
+        prev_hash: prev,
+        hash_ok: hashOk,
+        chain_ok: chainOk,
+        reason: reason ?? "failed",
+      });
+    }
+  }
+  if (bundle.verification && bundle.verification.truncated === true) {
+    failures.push({
+      receipt_hash: "",
+      prev_hash: "",
+      hash_ok: false,
+      chain_ok: false,
+      reason: "export was truncated; refuse to call it complete",
+    });
+  }
+  return { ok: failures.length === 0, checked: receipts.length, failures };
+}

package/src/index.d.ts

@@ -0,0 +1,32 @@
+export function canonicalize(value: unknown): unknown;
+export function sha256Hex(input: string): Promise<string>;
+export function leafHash(canonical: unknown): Promise<string>;
+export function verifyEvidenceExport(bundle: unknown): Promise<unknown>;
+
+export function merkleRoot(leaves: string[]): Promise<string | null>;
+export function merkleProof(leaves: string[], index: number): Promise<string[] | null>;
+export function verifyProof(leaf: string, proof: string[] | null | undefined, root: string): Promise<boolean>;
+
+/** Tree rule v2 (RFC 9162 2.1). Batches name their rule in tree_rule; absent is v1. */
+export const TREE_RULE_V1: "v1";
+export const TREE_RULE_V2: "v2";
+export function treeRuleOf(value: unknown): "v1" | "v2" | null;
+export function leafHashV2(leaf: string): Promise<string>;
+export function merkleRootV2(leaves: string[]): Promise<string | null>;
+export function merkleProofV2(leaves: string[], index: number): Promise<string[] | null>;
+export function verifyProofV2(leaf: string, index: number, size: number, proof: string[] | null | undefined, root: string): Promise<boolean>;
+
+export function verifyBundle(bundle: unknown, opts?: Record<string, unknown>): Promise<unknown>;
+
+export function agentRecord(events: unknown, asOf?: string): unknown;
+export function recordBundle(input: { handle: string; as_of?: string; outcomes: unknown }): unknown;
+export function signRecord(privateJwk: Record<string, unknown>, bundle: unknown): Promise<unknown>;
+export function verifyRecord(bundle: unknown, jwks: unknown): Promise<unknown>;
+export function isRecordBundle(bundle: unknown): boolean;
+
+export function classifyCluster(
+  hint: string | null | undefined,
+  explorer?: string | null | undefined,
+): "devnet" | "testnet" | "mainnet" | null;
+export function checkSolanaMemo(opts: Record<string, unknown>): Promise<unknown>;
+export const PUBLIC_RPC: { readonly devnet: string; readonly testnet: string };

package/src/index.mjs

@@ -0,0 +1,8 @@
+export { canonicalize, sha256Hex, leafHash, verifyEvidenceExport } from "./evidence.mjs";
+export {
+  merkleRoot, merkleProof, verifyProof,
+  TREE_RULE_V1, TREE_RULE_V2, treeRuleOf, leafHashV2, merkleRootV2, merkleProofV2, verifyProofV2,
+} from "./merkle.mjs";
+export { verifyBundle } from "./bundle.mjs";
+export { agentRecord, recordBundle, signRecord, verifyRecord, isRecordBundle } from "./record.mjs";
+export { classifyCluster, checkSolanaMemo, PUBLIC_RPC } from "./solana.mjs";