Encryption protects the confidentiality of a video call. Digital signatures protect the integrity of recordings and transcripts. But neither answers a more fundamental question: how do you prove, to a third party, that a specific video session actually occurred, used genuine post-quantum encryption, and was not altered after the fact?
This is the attestation problem. A signed recording proves the recording has not been tampered with. But it does not independently prove that the session used PQ encryption, that the participants were who they claimed to be, or that the metadata (timestamps, duration, participant list) is accurate. For compliance, legal discovery, and audit purposes, organizations need a single, compact, independently verifiable proof that ties everything together.
H33-74 is that proof. It is a 74-byte substrate attestation that compresses three post-quantum algorithm families, session metadata, and participant authentication into a single cryptographic object — 32 bytes stored on-chain for immutable anchoring, and 42 bytes stored in Cachee (H33's distributed PQ-attested cache) for verification metadata. The system is patent pending (H33 substrate Claims 124–125).
The 74-Byte Breakdown
The number 74 is not arbitrary. It is the result of an engineering optimization that compresses approximately 21,100 bytes of raw PQ cryptographic material into the minimum viable attestation — a 285x compression ratio that makes on-chain anchoring economically feasible while preserving full cryptographic verifiability.
74 bytes, two storage tiers
16 bytes: Session UUID (globally unique identifier)
2 bytes: Algorithm bitfield (which PQ families were used)
8 bytes: Participant authentication hash (truncated)
4 bytes: Merkle tree depth + leaf count
4 bytes: Version + flags
The 32-byte on-chain component is the cryptographic anchor. It is immutable once written. The 42-byte Cachee component provides the metadata needed to initiate verification without retrieving the full attestation tree. Together, these 74 bytes are sufficient to: confirm that a specific session occurred at a specific time, verify which PQ algorithm families were used, validate participant authentication, and retrieve the full Merkle tree for deep verification if needed.
The Compression Problem: 21,100 Bytes to 74
Post-quantum algorithms are notoriously large. A single ML-DSA-65 signature is 3,293 bytes. A FALCON-512 signature is approximately 666 bytes. An SLH-DSA signature can exceed 17,000 bytes. The public keys are similarly large. If V100 needed to store the full PQ signature bundle for every video session on-chain, the cost would be prohibitive and the throughput would be unacceptable.
Raw PQ material per session attestation
| Component | Size |
|---|---|
| ML-DSA-65 signature | 3,293 bytes |
| ML-DSA-65 public key | 1,952 bytes |
| FALCON-512 signature | ~666 bytes |
| FALCON-512 public key | 897 bytes |
| SLH-DSA signature | ~17,088 bytes |
| Session metadata | ~200 bytes |
| Total raw material | ~21,100 bytes |
| H33-74 attestation | 74 bytes |
The compression is achieved through Merkle tree construction. Each PQ signature, public key, and metadata element becomes a leaf in a SHA3-256 Merkle tree. The tree is computed, and only the 32-byte root is stored on-chain. The full tree (all leaves, intermediate hashes, and the raw PQ signatures) is stored in Cachee and can be retrieved for full verification at any time. But the 32-byte root alone is sufficient to prove that a specific set of PQ signatures and metadata existed at the time the attestation was anchored.
How Attestation Works: Step by Step
When a V100 video session ends, the attestation pipeline executes automatically. The entire process completes in approximately 26 milliseconds, dominated by the SLH-DSA signature computation.
Attestation pipeline
Real-World Example: V100 API Response Headers
Every V100 API response for session-related endpoints includes the H33-74 attestation in the response headers. This makes attestation data available to every integration without additional API calls.
HTTP/2 200
content-type: application/json
x-v100-session-id: 8f14e45f-ceea-467f-a83c-2a5b7f8d9e12
x-h33-attestation-root: a7ffc6f8bf1ed766...51ef7ac (32 bytes, hex)
x-h33-attestation-meta: 0192c8e7f4b2...9d3f (42 bytes, hex)
x-h33-attestation-version: 1
x-h33-pq-families: mlwe,ntru,hash
x-h33-attestation-verify: https://v100.ai/api/v1/substrate/verifyThe x-h33-attestation-root header contains the 32-byte Merkle root. The x-h33-attestation-meta header contains the 42-byte Cachee metadata. Together, they are the complete H33-74 attestation. The x-h33-pq-families header enumerates which PQ algorithm families were used (all three for standard sessions). The x-h33-attestation-verify header provides the verification endpoint.
Verification: Trust Math, Not Infrastructure
H33-74 attestations are independently verifiable. A verifier does not need to trust V100, H33, or any infrastructure. They need only the 74 bytes and access to the verification endpoint (or the raw Merkle tree data, which can be requested directly).
Verifier V100 / Cachee
======== =============
1. Has: 74 bytes
(32-byte root + 42-byte meta)
|
|--- POST /api/v1/substrate/verify --->
| { root: "a7ffc6...", meta: "0192c8..." }
|
| 2. Retrieve full Merkle tree
| from Cachee using UUID
| in meta bytes 8..24
|
| 3. Recompute Merkle root
| from stored leaves
|
| 4. Compare recomputed root
| against on-chain anchor
|
| 5. Verify each PQ signature
| (ML-DSA, FALCON, SLH-DSA)
|
|<--- Verification result ---
| { valid: true,
| families: ["mlwe", "ntru", "hash"],
| session_time: "2026-04-14T10:30:00Z",
| participants: 4,
| root_matches_chain: true }
Shallow verification checks that the 42-byte metadata is consistent with the 32-byte root and that the root exists on-chain. This confirms the attestation was anchored and has not been tampered with. It completes in under 1 millisecond.
Deep verification retrieves the full Merkle tree from Cachee, recomputes the root from the raw leaves, and individually verifies each PQ signature (ML-DSA-65, FALCON-512, SLH-DSA). This confirms not only that the attestation is authentic but that each individual PQ signature is valid. Deep verification takes approximately 50 milliseconds, dominated by SLH-DSA signature verification.
For offline or air-gapped verification, the full Merkle tree can be exported as a standalone verification bundle. This bundle contains all leaves, intermediate hashes, PQ signatures, and public keys. A verifier with this bundle and the 32-byte on-chain root can perform complete verification without any network access.
Batched Attestation: Claims 124–125
For high-throughput deployments, H33-74 supports batched Merkle response attestation (patent pending — H33 substrate Claims 124–125). Instead of anchoring one Merkle root per session, multiple sessions are aggregated into a batch Merkle tree. The batch root is anchored once, and individual session attestations are provable as leaves within the batch tree.
This batching reduces on-chain cost proportionally to the batch size. A batch of 1,000 sessions requires only one 32-byte anchor instead of 1,000, reducing on-chain storage by 999x while maintaining identical per-session verifiability. Each individual session's attestation can be verified by providing the Merkle proof path from the session's leaf to the batch root.
V100 currently batches attestations every 60 seconds across all active tenants. Each batch covers all sessions that ended in that interval. The batching is transparent to API consumers — the 74-byte attestation in the response headers works identically whether the session was anchored individually or as part of a batch.
Why Attestation Matters for Video
Video content is uniquely susceptible to manipulation. Deepfake technology can alter facial expressions, synthesize speech, and fabricate entire video segments that are indistinguishable from genuine footage to human observers. For legal depositions, compliance recordings, and healthcare consultations, the ability to prove that a video was not altered is not optional — it is a legal and regulatory requirement.
H33-74 attestation provides this proof at the session level. The attestation is generated when the session ends, covering the entire session duration. Any modification to the recording, transcript, or metadata after attestation will fail verification because the modified data will produce a different Merkle root than what was anchored on-chain.
The three-family PQ signature design ensures this proof survives the quantum transition. Even when quantum computers can forge classical digital signatures, the H33-74 attestation remains valid because it is signed with three independent PQ families. Forging the attestation requires simultaneously breaking MLWE lattices, NTRU lattices, and hash functions — three independent mathematical bets that would each need to fail simultaneously.
Use cases for H33-74 attestation
Under the Hood: Technical Specifications
For engineers integrating with the H33-74 attestation system, here are the key technical parameters:
H33-74 technical parameters
74 bytes. Three PQ families. One tamper-proof guarantee.
Every V100 session generates an H33-74 attestation automatically. No configuration required. The attestation is in your API response headers on the first call. Start your free trial and see it live.