Architecture
Introduction: Bitcoin Backed Internet
LayerEdge transforms Bitcoin from a passive store of value into a verifiable infrastructure layer for off-chain computation. At the center of this transformation is the Proof Aggregation Layer — a modular system that enables recursive zk-proof verification across protocols, applications, and data pipelines, with finality rooted in Bitcoin's Proof-of-Work (PoW).
This system allows:
Thousands or millions of zk-proofs to be recursively compressed into a single succinct proof
The result to be anchored on Bitcoin in a tamper-proof, cost-efficient way
Developers to scale verifiable computation without overwhelming Bitcoin L1
It is designed to serve as the universal verifier layer for blockchains, rollups, zkML, decentralized AI, and off-chain infrastructure.
What It Does
The Proof Aggregation Layer is responsible for:
Accepting zk-proofs from heterogeneous systems
Normalizing and batching these proofs
Recursively aggregating them into one succinct proof
Anchoring that final proof to Bitcoin
Ensuring the entire flow is cryptographically verifiable and publicly auditable
This process allows:
A rollup to verify 1,000 blocks with 1 proof
An AI model to validate 10,000 inference steps off-chain
An L2 chain to settle its entire epoch using one zk anchor
And all of that to be verifiably tied to Bitcoin
Supported Proof Systems
LayerEdge is designed to be proof-system agnostic, supporting a wide spectrum of zk-proving technologies:
SNARKs
Groth16
PLONK
Halo2
Nova
Plonky2
STARKs
AirSTARK
Fractal
RISC Zero
SP1
zkVMs & Hybrid Runtimes
Nexus
Modular zkVM chains that output verifiable computation
These proofs are passed to the Verification Layer, where they are normalized and formatted into a unified intermediate representation.
Recursive Proof Aggregation
Concept
Rather than verifying every zk-proof one by one, LayerEdge uses recursive composition to combine all proofs π1,π2,…,πnπ1,π2,…,πn into a single final proof πaggπagg, which attests to the correctness of all constituent proofs.
πagg=⨁(π1,π2,…,πn)πagg=⨁(π1,π2,…,πn)
This drastically reduces:
Computation load
On-chain gas cost
Storage overhead
Verification time
How It Works (Step-by-Step)
Proof Generation Protocols generate zk-proofs for off-chain computations (e.g. L2 state transitions, ML inference, data attestations).
Proof Submission These proofs are submitted to the Verification Layer, along with metadata.
Normalization All incoming proofs are transformed into a standard internal representation, regardless of their zk framework.
Recursive Aggregation A cryptographic engine (e.g., Halo2, Nova, Spartan) aggregates the proofs recursively using a tree structure:
First merges pairs of proofs
Then merges those merged proofs
Continues until a single πagg remains
Finalization & Anchoring The final succinct proof is committed via DA layer + Bitcoin anchoring
Technical Benefits
Logarithmic Verification
Verifier checks only 1 proof regardless of batch size
Low On-chain Cost
Aggregated proofs reduce Bitcoin footprint by >95%
Multi-Proof Compatibility
Supports Groth16, Halo2, RISC Zero, Nexus, etc.
Auditability
All original proofs retrievable via DA Merkle paths
PoW Anchored
Final proof verifiability inherits Bitcoin's consensus security
Performance Comparison
Number of Proofs
10,000
1
Verifier Time
O(n)
O(log n)
Proof Size
Large (n × proof)
Small (single proof)
Bitcoin Settlement
High (per proof tx)
Minimal (1 tx)
Cost per Protocol
$900+
<$20 in 50-protocol network
Storage Overhead
High
Compressed + Merkle root
Architecture: The Four Core Modules
The Proof Aggregation Layer ties together four core architectural systems in LayerEdge:
1. Verification Layer
Accepts proofs from all zk frameworks
Normalizes inputs for the aggregation engine
Performs initial validation and metadata capture
2. General Prover / Verifier System
Aggregates normalized proofs recursively
Uses proof-friendly circuits (Halo2, Nova, Plonky3)
Produces a final aggregated zk-proof πaggπagg
3. Data Availability Layer (DA)
Commits each zk-proof's hash in a Merkle tree
Stores root on LayerEdge BSN for auditability
Allows light clients to verify Merkle Tree efficiently
4. Bitcoin Anchoring
Anchors πaggπagg on Bitcoin using:
OP_RETURN (hash-only)
Taproot scripts (commitments only)
OP_CAT (Onchain Verification)
Inherits finality from Bitcoin's PoW consensus
Why This Design Works
LayerEdge doesn't force Bitcoin to compute — it lets Bitcoin verify.
The aggregation layer enables the system to:
Keep computation off-chain
Keep verification trustless
Keep finality secure and immutable
In doing so, it solves the scalability bottleneck for any zk-based system that wants to root its trust model in Bitcoin.
Real-World Applications
Rollups & L2s
Compress block transitions into a single proof
zkML / AI
Aggregate multiple inference steps
IoT / DePIN
Verify distributed sensor data
zkOracles
Compress multiple feeds / queries
Decentralized Identity
Aggregate credential validations
Multichain Settlements
Batch proofs from L1s/L2s into a single zk-settlement
Anchored Finality
The final proof πagg is:
Committed to LayerEdge's Data Availability chain
Anchored on Bitcoin for finality
Auditable by any light client using inclusion proofs
This creates a system where:
Light clients can verify that their data was included
Protocols can build trustless zk-rollups with Bitcoin settlement
Auditors can confirm zk-proof correctness without re-execution
Related Subpages
LayerEdge is composed of five core architectural modules, each addressing a distinct aspect of secure, scalable, and verifiable computation. This section delves into the intricate technical details of how these components interact and ensures seamless end-to-end functionality.
📄 Verification Layer
Learn more about LayerEdge's Verification Layer
📄 General Prover / Verifier System
Learn more about General Prover / Verifier System
📄 Data Availability Layer
Learn more about how underlying proofs remain publicly verifiable
📄 Bitcoin Anchoring
Read more about how the final aggregated proof is anchored on Bitcoin
📄 Built on Babylon
Learn more about how Babylon is integrated with LayerEdge
Conclusion
The Proof Aggregation Layer is the backbone of the LayerEdge. It enables:
Massive zk scalability
Verifiable off-chain execution
Modular zk infrastructure
And finality secured by Bitcoin
By compressing thousands of zk-proofs into a single anchorable proof, LayerEdge turns Bitcoin into a global proof-of-verification engine — ready to secure the next generation of decentralized computation.
Last updated