Skip to main content

Architecture

Introduction: Bitcoin's Security for zk-Proofs​

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.

Block Production in LayerEdge NetworkBlock Production in LayerEdge Network

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\pi_1, \pi_2, \ldots, \pi_n into a single final proof πagg\pi_{\text{agg}}, which attests to the correctness of all constituent proofs.

πagg=⨁(π1,π2,…,πn)\pi_{\text{agg}} = \bigoplus(\pi_1, \pi_2, \ldots, \pi_n)

This drastically reduces:

  • Computation load
  • On-chain gas cost
  • Storage overhead
  • Verification time

How It Works (Step-by-Step)​

  1. Proof Generation
    Protocols generate zk-proofs for off-chain computations (e.g. L2 state transitions, ML inference, data attestations).

  2. Proof Submission
    These proofs are submitted to the Verification Layer, along with metadata.

  3. Normalization
    All incoming proofs are transformed into a standard internal representation, regardless of their zk framework.

  4. 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

  5. Finalization & Anchoring
    The final succinct proof is either:

    • Posted on-chain directly (Bitcoin OP_RETURN, Taproot)
    • Or committed via DA layer + Bitcoin anchoring

Technical Benefits​

FeatureBenefit
Logarithmic VerificationVerifier checks only 1 proof regardless of batch size
Low On-chain CostAggregated proofs reduce Bitcoin footprint by >95%
Multi-Proof CompatibilitySupports Groth16, Halo2, RISC Zero, Nexus, etc.
AuditabilityAll original proofs retrievable via DA Merkle paths
InteroperabilityProofs come from any protocol using zk-backed execution
PoW AnchoredFinal proof verifiability inherits Bitcoin's consensus security

Performance Comparison​

PropertyIndividual ProofsLayerEdge Aggregation
Number of Proofs10,0001
Verifier TimeO(n)O(log n)
Proof SizeLarge (n × proof)Small (single proof)
Bitcoin SettlementHigh (per proof tx)Minimal (1 tx)
Cost per Protocol$900+<$20 in 50-protocol network
Storage OverheadHighCompressed + Merkle root
SecurityLocal onlyGlobal + Bitcoin PoW

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\pi_{\text{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 inclusion efficiently

4. Bitcoin Anchoring​

  • Anchors πagg on Bitcoin using:
    • OP_RETURN (hash-only)
    • Taproot scripts (conditional logic)
    • OP_CAT (future on-chain parsing)
  • 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​

Use CaseBenefit of Aggregation
Rollups & L2sCompress block transitions into a single proof
zkML / AIAggregate multiple inference steps
IoT / DePINVerify distributed sensor data
zkOraclesCompress multiple feeds / queries
Decentralized IdentityAggregate credential validations
Multichain SettlementsBatch 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.