Modular Privacy Stack

Components

• Data layer stores and retrieves encrypted payloads. Options include off-chain encrypted storage, data-availability layers, L1 blob data, and content-addressed networks with encryption.
• Execution layer runs private computation. Options include zero-knowledge execution environments, Fully Homomorphic Encryption, and trusted execution environments.
• Settlement layer provides finality and atomicity. Options include L1, validity-proof rollups, optimistic rollups, and cross-chain atomic swap protocols.
• Disclosure layer exposes scoped access for audit and compliance. Options include viewing keys, zero-knowledge proofs of properties, threshold key management, and on-chain attestations.
• Interface contracts define what each layer consumes and emits: encrypted reads and writes for Data, state transitions for Execution, proofs and signed transactions for Settlement, and disclosure artifacts for Disclosure.
• Orchestration service routes references and coordinates cross-layer flows; it aggregates audit logs across layers.

If a component is itself a pattern in this map (see sub_patterns and related_patterns), link it rather than describe it in depth.

Protocol

1. architect Map each transaction phase to a layer: what data stays in Data, what runs in Execution, where finality happens, and who needs scoped access.
2. architect Pin the interface between each pair of layers: content-addressed references at Data, state-transition objects at Execution, proof or signed-transaction envelopes at Settlement.
3. user Encrypt sensitive inputs and submit them to the Data layer; receive a content-addressed reference.
4. executor Retrieve the reference, run the private computation, and emit a state transition or proof.
5. contract Verify the proof or signed transaction on the Settlement layer; commit state atomically across legs when needed.
6. user Emit disclosure artifacts (viewing keys, proofs of properties, attestations) for the Disclosure layer and grant scoped access to authorized parties.
7. auditor Reconstruct the cross-layer audit trail from data hashes, execution proofs, settlement transaction identifiers, and disclosure events.

Guarantees & threat model

Guarantees:

• Layer isolation: a compromise or failure in one layer does not expose plaintext held by another, provided interfaces are honored.
• Upgradability: a layer can be replaced without redesigning the others, as long as the interface contract holds.
• Cross-layer audit: the combined trail is reconstructible from per-layer evidence.
• Failure containment: when Execution fails, Settlement reverts without affecting stored Data.

Threat model:

• Interface assumption: the guarantees hold only when each layer honors its interface contract. A misbehaving adapter between layers can bridge data from one to another.
• Orchestrator trust: a malicious orchestrator can correlate references and disclose timing and access patterns even when payloads stay encrypted.
• Metadata leakage: cross-layer routing discloses timing and size patterns; these are out of scope for the individual layers and must be addressed at the orchestration layer or with network-anonymity primitives.
• Key management: if disclosure keys are held by a single operator, the Disclosure layer inherits that operator's trust profile.
• Weakest-layer bound: the privacy guarantee is the minimum of what each layer provides for its part of the flow.

Trade-offs

• Coordination complexity: the orchestration logic adds operational surface and more moving parts than a monolithic stack.
• Latency accumulation: four layers in sequence compound delays relative to an integrated solution.
• Interface rigidity: stable interfaces can constrain layer-specific optimizations and may need adapter layers over time.
• Tooling fragmentation: multiple SDKs, monitoring stacks, and support relationships follow from mixing vendors per layer.
• Metadata leakage at routing boundaries is the residual risk even when all per-layer payloads are encrypted.

Example

A tokenized-bond issuance uses a modular stack:

• Bond terms and investor details are encrypted and stored off-chain with a content hash published to a data-availability layer.
• A zero-knowledge execution environment verifies investor eligibility and computes the allocation, emitting a settlement instruction with a validity proof.
• Atomic delivery-versus-payment settles on L1: bond tokens move to the buyer and payment tokens to the seller, or both legs revert.
• The issuer grants scoped viewing keys to the regulator through an on-chain attestation. The regulator decrypts bond terms and verifies eligibility proofs without observing the full transaction graph.

The issuer can later swap the execution environment for a different ZK system, add a regulator by issuing additional viewing keys, or move settlement to a rollup for cost reduction, without rebuilding the stack.

See also

• Aztec
• Zama
• Miden
• Railgun
• ERC-7573
• ERC-3643
• Ethereum Attestation Service