← Back to Patent Claims
Patent Claim 038 All Patents →

Sealed-Proof Zero-Exposure Compliance Proof

Per-check salted commitments aggregated to a signed Merkle root - proving every check in a canon passed without disclosing what any one check evaluated.

Patent Claim JIL Sovereign July 2026 Claim 38 of 157

Executive Summary

JIL Sovereign's sealed-proof mechanism computes, for every discrete compliance check executed against a body of records, a cryptographic commitment: a hash of the check's identifier, its pass/fail result, and a randomly generated salt. Every per-check commitment in a canon run is aggregated into a Merkle tree, and the resulting root is signed with a quorum or hybrid cryptographic signature as a single "all-pass" (or partial-pass) assertion.

The signed root can be disclosed to any counterparty - a regulator, an insurer, an acquirer in diligence - as proof that the underlying canon of checks was executed and produced the asserted outcome, without disclosing the checks themselves, their individual results, or the records they evaluated. If a specific check's outcome later needs to be proven to a specific party, that one check's identifier, result, and salt can be selectively disclosed together with its Merkle-inclusion proof, without revealing any other check's outcome.

Core Innovation: A salted per-check commitment scheme aggregated into a signed Merkle root, enabling any party to cryptographically verify a compliance outcome - in full or one check at a time - without ever seeing the underlying data.

Problem Statement

Proving compliance to an outside party traditionally forces a choice between two unsatisfying options. Full disclosure - handing over the underlying records so a regulator, insurer, or counterparty can inspect them directly - exposes sensitive data well beyond what the specific question required. Narrative attestation - a letter or report stating "we passed these checks" - avoids exposing the data, but gives the reader nothing more than the attesting party's word; there is no independent, mathematical way to verify the assertion without re-running the underlying evaluation from scratch.

Neither option scales well to a canon of hundreds of individual checks, where a counterparty may only need proof of a handful of specific outcomes, not the whole record, and where the attesting party needs a way to prove "nothing here was cherry-picked" without publishing everything.

332
Checks aggregable into one signed root
1
Signed Merkle root per canon run
0
Underlying values exposed by the root itself

Why Existing Approaches Are Insufficient

  • Full data disclosure: Exposes far more than the specific compliance question required, creating unnecessary risk and often triggering its own regulatory handling obligations.
  • Narrative attestation letters (SOC 2, HITRUST-style reports): Trust-based; the reader has no independent way to verify the claim without re-auditing.
  • Aggregate scores without per-item structure: A single summary number ("98% pass rate") cannot later be decomposed to prove or disprove any specific check without re-disclosing the whole underlying evaluation.

Technical Architecture

Per-Check Commitment

For each check executed, the system computes commitment = H(check_code || result || salt), where salt is a freshly generated random value unique to that check instance. The salt provides hiding - without it, the commitment reveals nothing about the check code or result - and the hash function provides binding, so the committing party cannot later claim a different result for the same commitment.

ComponentRoleProperty Provided
check_codeIdentifies which check produced this commitmentConcealed unless disclosed
resultPass / fail outcome of the checkConcealed unless disclosed
saltRandom per-check nonceHiding - prevents guessing/brute-forcing small result spaces
H(...)Cryptographic hash functionBinding - commitment cannot be reinterpreted after the fact

Merkle Aggregation and Quorum Signature

All per-check commitments for a given canon run are assembled as leaves of a Merkle tree; the resulting Merkle root is signed with a threshold quorum or hybrid cryptographic signature, producing a single all-pass (or specified partial-pass) assertion covering the entire canon run in one compact, independently verifiable artifact.

Selective Disclosure Verification Flow

Proof of a single check's outcome does not require re-disclosing the rest of the canon run.

StepAction
1Requesting party asks for proof of a specific check's outcome.
2System discloses that check's check_code, result, salt, and its Merkle-inclusion path.
3Verifier recomputes H(check_code || result || salt) and confirms it matches the corresponding leaf.
4Verifier walks the Merkle-inclusion path and confirms it resolves to the signed root.
5Verifier checks the quorum/hybrid signature over the root.

A successful verification confirms the specific check's outcome against the signed root without the verifier learning the outcome of any check it was not shown.

Prior Art Differentiation

ApproachIndependently Verifiable?Per-Check Granularity?Underlying Data Exposed?
SOC 2 / HITRUST attestation lettersNo (trust-based)No (narrative summary)Not directly, but no cryptographic proof either
Vendor "trust center" self-reported dashboardsNoPartial, self-reportedSelectively self-disclosed, unverifiable
General statement-level ZK compliance proofsYes, at statement levelNo (proves the statement, not individual checks)No
JIL Sovereign Sealed-Proof CommitmentYes, cryptographicallyYes, per individual checkNo, hidden by salted commitment

Patent Claim

Independent Claim 38: A computer-implemented method for proving compliance without exposing underlying data, comprising: executing a set of discrete compliance checks against a body of records, each check producing a check identifier and a pass or fail result; generating, for each check, a cryptographic commitment as a hash of the check identifier, the result, and a randomly-generated salt value, such that the commitment reveals neither the identifier nor the result without the salt; assembling the per-check commitments into a Merkle tree and computing a Merkle root; generating a signed all-pass assertion over the Merkle root using a quorum or hybrid cryptographic signature; and selectively disclosing, upon request, an individual check's identifier, result, and salt together with its Merkle-inclusion proof, enabling a verifier to confirm that specific check's outcome against the signed root without learning the outcome of any other check in the set.